{"version":3,"file":"js/chunk-vendors-eb2fbf4c.fc4dcf70.js","mappings":"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","sources":["webpack://dicom-frontend/./node_modules/shallowequal/index.js","webpack://dicom-frontend/./node_modules/side-channel/index.js","webpack://dicom-frontend/./node_modules/string-convert/camel2hyphen.js","webpack://dicom-frontend/./node_modules/tippy.js/dist/tippy.esm.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/error.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/logger.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/uuid.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/upload.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/noopUrlStorage.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/browser/urlStorage.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/browser/httpStack.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/browser/isReactNative.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/browser/uriToBlob.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/browser/sources/isCordova.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/browser/sources/readAsByteArray.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/browser/sources/FileSource.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/browser/sources/StreamSource.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/browser/fileReader.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/browser/fileSignature.js","webpack://dicom-frontend/./node_modules/tus-js-client/lib.esm/browser/index.js","webpack://dicom-frontend/./node_modules/url-parse/index.js","webpack://dicom-frontend/./node_modules/tinycolor2/cjs/tinycolor.js","webpack://dicom-frontend/./node_modules/underscore/modules/_setup.js","webpack://dicom-frontend/./node_modules/underscore/modules/restArguments.js","webpack://dicom-frontend/./node_modules/underscore/modules/isObject.js","webpack://dicom-frontend/./node_modules/underscore/modules/isNull.js","webpack://dicom-frontend/./node_modules/underscore/modules/isUndefined.js","webpack://dicom-frontend/./node_modules/underscore/modules/isBoolean.js","webpack://dicom-frontend/./node_modules/underscore/modules/isElement.js","webpack://dicom-frontend/./node_modules/underscore/modules/_tagTester.js","webpack://dicom-frontend/./node_modules/underscore/modules/isString.js","webpack://dicom-frontend/./node_modules/underscore/modules/isNumber.js","webpack://dicom-frontend/./node_modules/underscore/modules/isDate.js","webpack://dicom-frontend/./node_modules/underscore/modules/isRegExp.js","webpack://dicom-frontend/./node_modules/underscore/modules/isError.js","webpack://dicom-frontend/./node_modules/underscore/modules/isSymbol.js","webpack://dicom-frontend/./node_modules/underscore/modules/isArrayBuffer.js","webpack://dicom-frontend/./node_modules/underscore/modules/isFunction.js","webpack://dicom-frontend/./node_modules/underscore/modules/_hasObjectTag.js","webpack://dicom-frontend/./node_modules/underscore/modules/_stringTagBug.js","webpack://dicom-frontend/./node_modules/underscore/modules/isDataView.js","webpack://dicom-frontend/./node_modules/underscore/modules/isArray.js","webpack://dicom-frontend/./node_modules/underscore/modules/_has.js","webpack://dicom-frontend/./node_modules/underscore/modules/isArguments.js","webpack://dicom-frontend/./node_modules/underscore/modules/isFinite.js","webpack://dicom-frontend/./node_modules/underscore/modules/isNaN.js","webpack://dicom-frontend/./node_modules/underscore/modules/constant.js","webpack://dicom-frontend/./node_modules/underscore/modules/_createSizePropertyCheck.js","webpack://dicom-frontend/./node_modules/underscore/modules/_shallowProperty.js","webpack://dicom-frontend/./node_modules/underscore/modules/_getByteLength.js","webpack://dicom-frontend/./node_modules/underscore/modules/_isBufferLike.js","webpack://dicom-frontend/./node_modules/underscore/modules/isTypedArray.js","webpack://dicom-frontend/./node_modules/underscore/modules/_getLength.js","webpack://dicom-frontend/./node_modules/underscore/modules/_collectNonEnumProps.js","webpack://dicom-frontend/./node_modules/underscore/modules/keys.js","webpack://dicom-frontend/./node_modules/underscore/modules/isEmpty.js","webpack://dicom-frontend/./node_modules/underscore/modules/isMatch.js","webpack://dicom-frontend/./node_modules/underscore/modules/underscore.js","webpack://dicom-frontend/./node_modules/underscore/modules/_toBufferView.js","webpack://dicom-frontend/./node_modules/underscore/modules/isEqual.js","webpack://dicom-frontend/./node_modules/underscore/modules/allKeys.js","webpack://dicom-frontend/./node_modules/underscore/modules/_methodFingerprint.js","webpack://dicom-frontend/./node_modules/underscore/modules/isMap.js","webpack://dicom-frontend/./node_modules/underscore/modules/isWeakMap.js","webpack://dicom-frontend/./node_modules/underscore/modules/isSet.js","webpack://dicom-frontend/./node_modules/underscore/modules/isWeakSet.js","webpack://dicom-frontend/./node_modules/underscore/modules/values.js","webpack://dicom-frontend/./node_modules/underscore/modules/pairs.js","webpack://dicom-frontend/./node_modules/underscore/modules/invert.js","webpack://dicom-frontend/./node_modules/underscore/modules/functions.js","webpack://dicom-frontend/./node_modules/underscore/modules/_createAssigner.js","webpack://dicom-frontend/./node_modules/underscore/modules/extend.js","webpack://dicom-frontend/./node_modules/underscore/modules/extendOwn.js","webpack://dicom-frontend/./node_modules/underscore/modules/defaults.js","webpack://dicom-frontend/./node_modules/underscore/modules/_baseCreate.js","webpack://dicom-frontend/./node_modules/underscore/modules/create.js","webpack://dicom-frontend/./node_modules/underscore/modules/clone.js","webpack://dicom-frontend/./node_modules/underscore/modules/tap.js","webpack://dicom-frontend/./node_modules/underscore/modules/toPath.js","webpack://dicom-frontend/./node_modules/underscore/modules/_toPath.js","webpack://dicom-frontend/./node_modules/underscore/modules/_deepGet.js","webpack://dicom-frontend/./node_modules/underscore/modules/get.js","webpack://dicom-frontend/./node_modules/underscore/modules/has.js","webpack://dicom-frontend/./node_modules/underscore/modules/identity.js","webpack://dicom-frontend/./node_modules/underscore/modules/matcher.js","webpack://dicom-frontend/./node_modules/underscore/modules/property.js","webpack://dicom-frontend/./node_modules/underscore/modules/_optimizeCb.js","webpack://dicom-frontend/./node_modules/underscore/modules/_baseIteratee.js","webpack://dicom-frontend/./node_modules/underscore/modules/iteratee.js","webpack://dicom-frontend/./node_modules/underscore/modules/_cb.js","webpack://dicom-frontend/./node_modules/underscore/modules/mapObject.js","webpack://dicom-frontend/./node_modules/underscore/modules/noop.js","webpack://dicom-frontend/./node_modules/underscore/modules/propertyOf.js","webpack://dicom-frontend/./node_modules/underscore/modules/times.js","webpack://dicom-frontend/./node_modules/underscore/modules/random.js","webpack://dicom-frontend/./node_modules/underscore/modules/now.js","webpack://dicom-frontend/./node_modules/underscore/modules/_createEscaper.js","webpack://dicom-frontend/./node_modules/underscore/modules/_escapeMap.js","webpack://dicom-frontend/./node_modules/underscore/modules/escape.js","webpack://dicom-frontend/./node_modules/underscore/modules/_unescapeMap.js","webpack://dicom-frontend/./node_modules/underscore/modules/unescape.js","webpack://dicom-frontend/./node_modules/underscore/modules/templateSettings.js","webpack://dicom-frontend/./node_modules/underscore/modules/template.js","webpack://dicom-frontend/./node_modules/underscore/modules/result.js","webpack://dicom-frontend/./node_modules/underscore/modules/uniqueId.js","webpack://dicom-frontend/./node_modules/underscore/modules/chain.js","webpack://dicom-frontend/./node_modules/underscore/modules/_executeBound.js","webpack://dicom-frontend/./node_modules/underscore/modules/partial.js","webpack://dicom-frontend/./node_modules/underscore/modules/bind.js","webpack://dicom-frontend/./node_modules/underscore/modules/_isArrayLike.js","webpack://dicom-frontend/./node_modules/underscore/modules/_flatten.js","webpack://dicom-frontend/./node_modules/underscore/modules/bindAll.js","webpack://dicom-frontend/./node_modules/underscore/modules/memoize.js","webpack://dicom-frontend/./node_modules/underscore/modules/delay.js","webpack://dicom-frontend/./node_modules/underscore/modules/defer.js","webpack://dicom-frontend/./node_modules/underscore/modules/throttle.js","webpack://dicom-frontend/./node_modules/underscore/modules/debounce.js","webpack://dicom-frontend/./node_modules/underscore/modules/wrap.js","webpack://dicom-frontend/./node_modules/underscore/modules/negate.js","webpack://dicom-frontend/./node_modules/underscore/modules/compose.js","webpack://dicom-frontend/./node_modules/underscore/modules/after.js","webpack://dicom-frontend/./node_modules/underscore/modules/before.js","webpack://dicom-frontend/./node_modules/underscore/modules/once.js","webpack://dicom-frontend/./node_modules/underscore/modules/findKey.js","webpack://dicom-frontend/./node_modules/underscore/modules/_createPredicateIndexFinder.js","webpack://dicom-frontend/./node_modules/underscore/modules/findIndex.js","webpack://dicom-frontend/./node_modules/underscore/modules/findLastIndex.js","webpack://dicom-frontend/./node_modules/underscore/modules/sortedIndex.js","webpack://dicom-frontend/./node_modules/underscore/modules/_createIndexFinder.js","webpack://dicom-frontend/./node_modules/underscore/modules/indexOf.js","webpack://dicom-frontend/./node_modules/underscore/modules/lastIndexOf.js","webpack://dicom-frontend/./node_modules/underscore/modules/find.js","webpack://dicom-frontend/./node_modules/underscore/modules/findWhere.js","webpack://dicom-frontend/./node_modules/underscore/modules/each.js","webpack://dicom-frontend/./node_modules/underscore/modules/map.js","webpack://dicom-frontend/./node_modules/underscore/modules/_createReduce.js","webpack://dicom-frontend/./node_modules/underscore/modules/reduce.js","webpack://dicom-frontend/./node_modules/underscore/modules/reduceRight.js","webpack://dicom-frontend/./node_modules/underscore/modules/filter.js","webpack://dicom-frontend/./node_modules/underscore/modules/reject.js","webpack://dicom-frontend/./node_modules/underscore/modules/every.js","webpack://dicom-frontend/./node_modules/underscore/modules/some.js","webpack://dicom-frontend/./node_modules/underscore/modules/contains.js","webpack://dicom-frontend/./node_modules/underscore/modules/invoke.js","webpack://dicom-frontend/./node_modules/underscore/modules/pluck.js","webpack://dicom-frontend/./node_modules/underscore/modules/where.js","webpack://dicom-frontend/./node_modules/underscore/modules/max.js","webpack://dicom-frontend/./node_modules/underscore/modules/min.js","webpack://dicom-frontend/./node_modules/underscore/modules/toArray.js","webpack://dicom-frontend/./node_modules/underscore/modules/sample.js","webpack://dicom-frontend/./node_modules/underscore/modules/shuffle.js","webpack://dicom-frontend/./node_modules/underscore/modules/sortBy.js","webpack://dicom-frontend/./node_modules/underscore/modules/_group.js","webpack://dicom-frontend/./node_modules/underscore/modules/groupBy.js","webpack://dicom-frontend/./node_modules/underscore/modules/indexBy.js","webpack://dicom-frontend/./node_modules/underscore/modules/countBy.js","webpack://dicom-frontend/./node_modules/underscore/modules/partition.js","webpack://dicom-frontend/./node_modules/underscore/modules/size.js","webpack://dicom-frontend/./node_modules/underscore/modules/_keyInObj.js","webpack://dicom-frontend/./node_modules/underscore/modules/pick.js","webpack://dicom-frontend/./node_modules/underscore/modules/omit.js","webpack://dicom-frontend/./node_modules/underscore/modules/initial.js","webpack://dicom-frontend/./node_modules/underscore/modules/first.js","webpack://dicom-frontend/./node_modules/underscore/modules/rest.js","webpack://dicom-frontend/./node_modules/underscore/modules/last.js","webpack://dicom-frontend/./node_modules/underscore/modules/compact.js","webpack://dicom-frontend/./node_modules/underscore/modules/flatten.js","webpack://dicom-frontend/./node_modules/underscore/modules/difference.js","webpack://dicom-frontend/./node_modules/underscore/modules/without.js","webpack://dicom-frontend/./node_modules/underscore/modules/uniq.js","webpack://dicom-frontend/./node_modules/underscore/modules/union.js","webpack://dicom-frontend/./node_modules/underscore/modules/intersection.js","webpack://dicom-frontend/./node_modules/underscore/modules/unzip.js","webpack://dicom-frontend/./node_modules/underscore/modules/zip.js","webpack://dicom-frontend/./node_modules/underscore/modules/object.js","webpack://dicom-frontend/./node_modules/underscore/modules/range.js","webpack://dicom-frontend/./node_modules/underscore/modules/chunk.js","webpack://dicom-frontend/./node_modules/underscore/modules/_chainResult.js","webpack://dicom-frontend/./node_modules/underscore/modules/mixin.js","webpack://dicom-frontend/./node_modules/underscore/modules/underscore-array-methods.js","webpack://dicom-frontend/./node_modules/underscore/modules/index-default.js"],"sourcesContent":["//\n\nmodule.exports = function shallowEqual(objA, objB, compare, compareContext) {\n  var ret = compare ? compare.call(compareContext, objA, objB) : void 0;\n\n  if (ret !== void 0) {\n    return !!ret;\n  }\n\n  if (objA === objB) {\n    return true;\n  }\n\n  if (typeof objA !== \"object\" || !objA || typeof objB !== \"object\" || !objB) {\n    return false;\n  }\n\n  var keysA = Object.keys(objA);\n  var keysB = Object.keys(objB);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n\n  var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);\n\n  // Test for A's keys different from B.\n  for (var idx = 0; idx < keysA.length; idx++) {\n    var key = keysA[idx];\n\n    if (!bHasOwnProperty(key)) {\n      return false;\n    }\n\n    var valueA = objA[key];\n    var valueB = objB[key];\n\n    ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;\n\n    if (ret === false || (ret === void 0 && valueA !== valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\nvar callBound = require('call-bind/callBound');\nvar inspect = require('object-inspect');\n\nvar $TypeError = require('es-errors/type');\nvar $WeakMap = GetIntrinsic('%WeakMap%', true);\nvar $Map = GetIntrinsic('%Map%', true);\n\nvar $weakMapGet = callBound('WeakMap.prototype.get', true);\nvar $weakMapSet = callBound('WeakMap.prototype.set', true);\nvar $weakMapHas = callBound('WeakMap.prototype.has', true);\nvar $mapGet = callBound('Map.prototype.get', true);\nvar $mapSet = callBound('Map.prototype.set', true);\nvar $mapHas = callBound('Map.prototype.has', true);\n\n/*\n* This function traverses the list returning the node corresponding to the given key.\n*\n* That node is also moved to the head of the list, so that if it's accessed again we don't need to traverse the whole list. By doing so, all the recently used nodes can be accessed relatively quickly.\n*/\n/** @type {import('.').listGetNode} */\nvar listGetNode = function (list, key) { // eslint-disable-line consistent-return\n\t/** @type {typeof list | NonNullable<(typeof list)['next']>} */\n\tvar prev = list;\n\t/** @type {(typeof list)['next']} */\n\tvar curr;\n\tfor (; (curr = prev.next) !== null; prev = curr) {\n\t\tif (curr.key === key) {\n\t\t\tprev.next = curr.next;\n\t\t\t// eslint-disable-next-line no-extra-parens\n\t\t\tcurr.next = /** @type {NonNullable<typeof list.next>} */ (list.next);\n\t\t\tlist.next = curr; // eslint-disable-line no-param-reassign\n\t\t\treturn curr;\n\t\t}\n\t}\n};\n\n/** @type {import('.').listGet} */\nvar listGet = function (objects, key) {\n\tvar node = listGetNode(objects, key);\n\treturn node && node.value;\n};\n/** @type {import('.').listSet} */\nvar listSet = function (objects, key, value) {\n\tvar node = listGetNode(objects, key);\n\tif (node) {\n\t\tnode.value = value;\n\t} else {\n\t\t// Prepend the new node to the beginning of the list\n\t\tobjects.next = /** @type {import('.').ListNode<typeof value>} */ ({ // eslint-disable-line no-param-reassign, no-extra-parens\n\t\t\tkey: key,\n\t\t\tnext: objects.next,\n\t\t\tvalue: value\n\t\t});\n\t}\n};\n/** @type {import('.').listHas} */\nvar listHas = function (objects, key) {\n\treturn !!listGetNode(objects, key);\n};\n\n/** @type {import('.')} */\nmodule.exports = function getSideChannel() {\n\t/** @type {WeakMap<object, unknown>} */ var $wm;\n\t/** @type {Map<object, unknown>} */ var $m;\n\t/** @type {import('.').RootNode<unknown>} */ var $o;\n\n\t/** @type {import('.').Channel} */\n\tvar channel = {\n\t\tassert: function (key) {\n\t\t\tif (!channel.has(key)) {\n\t\t\t\tthrow new $TypeError('Side channel does not contain ' + inspect(key));\n\t\t\t}\n\t\t},\n\t\tget: function (key) { // eslint-disable-line consistent-return\n\t\t\tif ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {\n\t\t\t\tif ($wm) {\n\t\t\t\t\treturn $weakMapGet($wm, key);\n\t\t\t\t}\n\t\t\t} else if ($Map) {\n\t\t\t\tif ($m) {\n\t\t\t\t\treturn $mapGet($m, key);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif ($o) { // eslint-disable-line no-lonely-if\n\t\t\t\t\treturn listGet($o, key);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\thas: function (key) {\n\t\t\tif ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {\n\t\t\t\tif ($wm) {\n\t\t\t\t\treturn $weakMapHas($wm, key);\n\t\t\t\t}\n\t\t\t} else if ($Map) {\n\t\t\t\tif ($m) {\n\t\t\t\t\treturn $mapHas($m, key);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif ($o) { // eslint-disable-line no-lonely-if\n\t\t\t\t\treturn listHas($o, key);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t},\n\t\tset: function (key, value) {\n\t\t\tif ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {\n\t\t\t\tif (!$wm) {\n\t\t\t\t\t$wm = new $WeakMap();\n\t\t\t\t}\n\t\t\t\t$weakMapSet($wm, key, value);\n\t\t\t} else if ($Map) {\n\t\t\t\tif (!$m) {\n\t\t\t\t\t$m = new $Map();\n\t\t\t\t}\n\t\t\t\t$mapSet($m, key, value);\n\t\t\t} else {\n\t\t\t\tif (!$o) {\n\t\t\t\t\t// Initialize the linked list as an empty node, so that we don't have to special-case handling of the first node: we can always refer to it as (previous node).next, instead of something like (list).head\n\t\t\t\t\t$o = { key: {}, next: null };\n\t\t\t\t}\n\t\t\t\tlistSet($o, key, value);\n\t\t\t}\n\t\t}\n\t};\n\treturn channel;\n};\n","var camel2hyphen = function (str) {\n  return str\n          .replace(/[A-Z]/g, function (match) {\n            return '-' + match.toLowerCase();\n          })\n          .toLowerCase();\n};\n\nmodule.exports = camel2hyphen;","/**!\n* tippy.js v6.3.7\n* (c) 2017-2021 atomiks\n* MIT License\n*/\nimport { createPopper, applyStyles } from '@popperjs/core';\n\nvar ROUND_ARROW = '<svg width=\"16\" height=\"6\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M0 6s1.796-.013 4.67-3.615C5.851.9 6.93.006 8 0c1.07-.006 2.148.887 3.343 2.385C14.233 6.005 16 6 16 6H0z\"></svg>';\nvar BOX_CLASS = \"tippy-box\";\nvar CONTENT_CLASS = \"tippy-content\";\nvar BACKDROP_CLASS = \"tippy-backdrop\";\nvar ARROW_CLASS = \"tippy-arrow\";\nvar SVG_ARROW_CLASS = \"tippy-svg-arrow\";\nvar TOUCH_OPTIONS = {\n  passive: true,\n  capture: true\n};\nvar TIPPY_DEFAULT_APPEND_TO = function TIPPY_DEFAULT_APPEND_TO() {\n  return document.body;\n};\n\nfunction hasOwnProperty(obj, key) {\n  return {}.hasOwnProperty.call(obj, key);\n}\nfunction getValueAtIndexOrReturn(value, index, defaultValue) {\n  if (Array.isArray(value)) {\n    var v = value[index];\n    return v == null ? Array.isArray(defaultValue) ? defaultValue[index] : defaultValue : v;\n  }\n\n  return value;\n}\nfunction isType(value, type) {\n  var str = {}.toString.call(value);\n  return str.indexOf('[object') === 0 && str.indexOf(type + \"]\") > -1;\n}\nfunction invokeWithArgsOrReturn(value, args) {\n  return typeof value === 'function' ? value.apply(void 0, args) : value;\n}\nfunction debounce(fn, ms) {\n  // Avoid wrapping in `setTimeout` if ms is 0 anyway\n  if (ms === 0) {\n    return fn;\n  }\n\n  var timeout;\n  return function (arg) {\n    clearTimeout(timeout);\n    timeout = setTimeout(function () {\n      fn(arg);\n    }, ms);\n  };\n}\nfunction removeProperties(obj, keys) {\n  var clone = Object.assign({}, obj);\n  keys.forEach(function (key) {\n    delete clone[key];\n  });\n  return clone;\n}\nfunction splitBySpaces(value) {\n  return value.split(/\\s+/).filter(Boolean);\n}\nfunction normalizeToArray(value) {\n  return [].concat(value);\n}\nfunction pushIfUnique(arr, value) {\n  if (arr.indexOf(value) === -1) {\n    arr.push(value);\n  }\n}\nfunction unique(arr) {\n  return arr.filter(function (item, index) {\n    return arr.indexOf(item) === index;\n  });\n}\nfunction getBasePlacement(placement) {\n  return placement.split('-')[0];\n}\nfunction arrayFrom(value) {\n  return [].slice.call(value);\n}\nfunction removeUndefinedProps(obj) {\n  return Object.keys(obj).reduce(function (acc, key) {\n    if (obj[key] !== undefined) {\n      acc[key] = obj[key];\n    }\n\n    return acc;\n  }, {});\n}\n\nfunction div() {\n  return document.createElement('div');\n}\nfunction isElement(value) {\n  return ['Element', 'Fragment'].some(function (type) {\n    return isType(value, type);\n  });\n}\nfunction isNodeList(value) {\n  return isType(value, 'NodeList');\n}\nfunction isMouseEvent(value) {\n  return isType(value, 'MouseEvent');\n}\nfunction isReferenceElement(value) {\n  return !!(value && value._tippy && value._tippy.reference === value);\n}\nfunction getArrayOfElements(value) {\n  if (isElement(value)) {\n    return [value];\n  }\n\n  if (isNodeList(value)) {\n    return arrayFrom(value);\n  }\n\n  if (Array.isArray(value)) {\n    return value;\n  }\n\n  return arrayFrom(document.querySelectorAll(value));\n}\nfunction setTransitionDuration(els, value) {\n  els.forEach(function (el) {\n    if (el) {\n      el.style.transitionDuration = value + \"ms\";\n    }\n  });\n}\nfunction setVisibilityState(els, state) {\n  els.forEach(function (el) {\n    if (el) {\n      el.setAttribute('data-state', state);\n    }\n  });\n}\nfunction getOwnerDocument(elementOrElements) {\n  var _element$ownerDocumen;\n\n  var _normalizeToArray = normalizeToArray(elementOrElements),\n      element = _normalizeToArray[0]; // Elements created via a <template> have an ownerDocument with no reference to the body\n\n\n  return element != null && (_element$ownerDocumen = element.ownerDocument) != null && _element$ownerDocumen.body ? element.ownerDocument : document;\n}\nfunction isCursorOutsideInteractiveBorder(popperTreeData, event) {\n  var clientX = event.clientX,\n      clientY = event.clientY;\n  return popperTreeData.every(function (_ref) {\n    var popperRect = _ref.popperRect,\n        popperState = _ref.popperState,\n        props = _ref.props;\n    var interactiveBorder = props.interactiveBorder;\n    var basePlacement = getBasePlacement(popperState.placement);\n    var offsetData = popperState.modifiersData.offset;\n\n    if (!offsetData) {\n      return true;\n    }\n\n    var topDistance = basePlacement === 'bottom' ? offsetData.top.y : 0;\n    var bottomDistance = basePlacement === 'top' ? offsetData.bottom.y : 0;\n    var leftDistance = basePlacement === 'right' ? offsetData.left.x : 0;\n    var rightDistance = basePlacement === 'left' ? offsetData.right.x : 0;\n    var exceedsTop = popperRect.top - clientY + topDistance > interactiveBorder;\n    var exceedsBottom = clientY - popperRect.bottom - bottomDistance > interactiveBorder;\n    var exceedsLeft = popperRect.left - clientX + leftDistance > interactiveBorder;\n    var exceedsRight = clientX - popperRect.right - rightDistance > interactiveBorder;\n    return exceedsTop || exceedsBottom || exceedsLeft || exceedsRight;\n  });\n}\nfunction updateTransitionEndListener(box, action, listener) {\n  var method = action + \"EventListener\"; // some browsers apparently support `transition` (unprefixed) but only fire\n  // `webkitTransitionEnd`...\n\n  ['transitionend', 'webkitTransitionEnd'].forEach(function (event) {\n    box[method](event, listener);\n  });\n}\n/**\n * Compared to xxx.contains, this function works for dom structures with shadow\n * dom\n */\n\nfunction actualContains(parent, child) {\n  var target = child;\n\n  while (target) {\n    var _target$getRootNode;\n\n    if (parent.contains(target)) {\n      return true;\n    }\n\n    target = target.getRootNode == null ? void 0 : (_target$getRootNode = target.getRootNode()) == null ? void 0 : _target$getRootNode.host;\n  }\n\n  return false;\n}\n\nvar currentInput = {\n  isTouch: false\n};\nvar lastMouseMoveTime = 0;\n/**\n * When a `touchstart` event is fired, it's assumed the user is using touch\n * input. We'll bind a `mousemove` event listener to listen for mouse input in\n * the future. This way, the `isTouch` property is fully dynamic and will handle\n * hybrid devices that use a mix of touch + mouse input.\n */\n\nfunction onDocumentTouchStart() {\n  if (currentInput.isTouch) {\n    return;\n  }\n\n  currentInput.isTouch = true;\n\n  if (window.performance) {\n    document.addEventListener('mousemove', onDocumentMouseMove);\n  }\n}\n/**\n * When two `mousemove` event are fired consecutively within 20ms, it's assumed\n * the user is using mouse input again. `mousemove` can fire on touch devices as\n * well, but very rarely that quickly.\n */\n\nfunction onDocumentMouseMove() {\n  var now = performance.now();\n\n  if (now - lastMouseMoveTime < 20) {\n    currentInput.isTouch = false;\n    document.removeEventListener('mousemove', onDocumentMouseMove);\n  }\n\n  lastMouseMoveTime = now;\n}\n/**\n * When an element is in focus and has a tippy, leaving the tab/window and\n * returning causes it to show again. For mouse users this is unexpected, but\n * for keyboard use it makes sense.\n * TODO: find a better technique to solve this problem\n */\n\nfunction onWindowBlur() {\n  var activeElement = document.activeElement;\n\n  if (isReferenceElement(activeElement)) {\n    var instance = activeElement._tippy;\n\n    if (activeElement.blur && !instance.state.isVisible) {\n      activeElement.blur();\n    }\n  }\n}\nfunction bindGlobalEventListeners() {\n  document.addEventListener('touchstart', onDocumentTouchStart, TOUCH_OPTIONS);\n  window.addEventListener('blur', onWindowBlur);\n}\n\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';\nvar isIE11 = isBrowser ? // @ts-ignore\n!!window.msCrypto : false;\n\nfunction createMemoryLeakWarning(method) {\n  var txt = method === 'destroy' ? 'n already-' : ' ';\n  return [method + \"() was called on a\" + txt + \"destroyed instance. This is a no-op but\", 'indicates a potential memory leak.'].join(' ');\n}\nfunction clean(value) {\n  var spacesAndTabs = /[ \\t]{2,}/g;\n  var lineStartWithSpaces = /^[ \\t]*/gm;\n  return value.replace(spacesAndTabs, ' ').replace(lineStartWithSpaces, '').trim();\n}\n\nfunction getDevMessage(message) {\n  return clean(\"\\n  %ctippy.js\\n\\n  %c\" + clean(message) + \"\\n\\n  %c\\uD83D\\uDC77\\u200D This is a development-only message. It will be removed in production.\\n  \");\n}\n\nfunction getFormattedMessage(message) {\n  return [getDevMessage(message), // title\n  'color: #00C584; font-size: 1.3em; font-weight: bold;', // message\n  'line-height: 1.5', // footer\n  'color: #a6a095;'];\n} // Assume warnings and errors never have the same message\n\nvar visitedMessages;\n\nif (process.env.NODE_ENV !== \"production\") {\n  resetVisitedMessages();\n}\n\nfunction resetVisitedMessages() {\n  visitedMessages = new Set();\n}\nfunction warnWhen(condition, message) {\n  if (condition && !visitedMessages.has(message)) {\n    var _console;\n\n    visitedMessages.add(message);\n\n    (_console = console).warn.apply(_console, getFormattedMessage(message));\n  }\n}\nfunction errorWhen(condition, message) {\n  if (condition && !visitedMessages.has(message)) {\n    var _console2;\n\n    visitedMessages.add(message);\n\n    (_console2 = console).error.apply(_console2, getFormattedMessage(message));\n  }\n}\nfunction validateTargets(targets) {\n  var didPassFalsyValue = !targets;\n  var didPassPlainObject = Object.prototype.toString.call(targets) === '[object Object]' && !targets.addEventListener;\n  errorWhen(didPassFalsyValue, ['tippy() was passed', '`' + String(targets) + '`', 'as its targets (first) argument. Valid types are: String, Element,', 'Element[], or NodeList.'].join(' '));\n  errorWhen(didPassPlainObject, ['tippy() was passed a plain object which is not supported as an argument', 'for virtual positioning. Use props.getReferenceClientRect instead.'].join(' '));\n}\n\nvar pluginProps = {\n  animateFill: false,\n  followCursor: false,\n  inlinePositioning: false,\n  sticky: false\n};\nvar renderProps = {\n  allowHTML: false,\n  animation: 'fade',\n  arrow: true,\n  content: '',\n  inertia: false,\n  maxWidth: 350,\n  role: 'tooltip',\n  theme: '',\n  zIndex: 9999\n};\nvar defaultProps = Object.assign({\n  appendTo: TIPPY_DEFAULT_APPEND_TO,\n  aria: {\n    content: 'auto',\n    expanded: 'auto'\n  },\n  delay: 0,\n  duration: [300, 250],\n  getReferenceClientRect: null,\n  hideOnClick: true,\n  ignoreAttributes: false,\n  interactive: false,\n  interactiveBorder: 2,\n  interactiveDebounce: 0,\n  moveTransition: '',\n  offset: [0, 10],\n  onAfterUpdate: function onAfterUpdate() {},\n  onBeforeUpdate: function onBeforeUpdate() {},\n  onCreate: function onCreate() {},\n  onDestroy: function onDestroy() {},\n  onHidden: function onHidden() {},\n  onHide: function onHide() {},\n  onMount: function onMount() {},\n  onShow: function onShow() {},\n  onShown: function onShown() {},\n  onTrigger: function onTrigger() {},\n  onUntrigger: function onUntrigger() {},\n  onClickOutside: function onClickOutside() {},\n  placement: 'top',\n  plugins: [],\n  popperOptions: {},\n  render: null,\n  showOnCreate: false,\n  touch: true,\n  trigger: 'mouseenter focus',\n  triggerTarget: null\n}, pluginProps, renderProps);\nvar defaultKeys = Object.keys(defaultProps);\nvar setDefaultProps = function setDefaultProps(partialProps) {\n  /* istanbul ignore else */\n  if (process.env.NODE_ENV !== \"production\") {\n    validateProps(partialProps, []);\n  }\n\n  var keys = Object.keys(partialProps);\n  keys.forEach(function (key) {\n    defaultProps[key] = partialProps[key];\n  });\n};\nfunction getExtendedPassedProps(passedProps) {\n  var plugins = passedProps.plugins || [];\n  var pluginProps = plugins.reduce(function (acc, plugin) {\n    var name = plugin.name,\n        defaultValue = plugin.defaultValue;\n\n    if (name) {\n      var _name;\n\n      acc[name] = passedProps[name] !== undefined ? passedProps[name] : (_name = defaultProps[name]) != null ? _name : defaultValue;\n    }\n\n    return acc;\n  }, {});\n  return Object.assign({}, passedProps, pluginProps);\n}\nfunction getDataAttributeProps(reference, plugins) {\n  var propKeys = plugins ? Object.keys(getExtendedPassedProps(Object.assign({}, defaultProps, {\n    plugins: plugins\n  }))) : defaultKeys;\n  var props = propKeys.reduce(function (acc, key) {\n    var valueAsString = (reference.getAttribute(\"data-tippy-\" + key) || '').trim();\n\n    if (!valueAsString) {\n      return acc;\n    }\n\n    if (key === 'content') {\n      acc[key] = valueAsString;\n    } else {\n      try {\n        acc[key] = JSON.parse(valueAsString);\n      } catch (e) {\n        acc[key] = valueAsString;\n      }\n    }\n\n    return acc;\n  }, {});\n  return props;\n}\nfunction evaluateProps(reference, props) {\n  var out = Object.assign({}, props, {\n    content: invokeWithArgsOrReturn(props.content, [reference])\n  }, props.ignoreAttributes ? {} : getDataAttributeProps(reference, props.plugins));\n  out.aria = Object.assign({}, defaultProps.aria, out.aria);\n  out.aria = {\n    expanded: out.aria.expanded === 'auto' ? props.interactive : out.aria.expanded,\n    content: out.aria.content === 'auto' ? props.interactive ? null : 'describedby' : out.aria.content\n  };\n  return out;\n}\nfunction validateProps(partialProps, plugins) {\n  if (partialProps === void 0) {\n    partialProps = {};\n  }\n\n  if (plugins === void 0) {\n    plugins = [];\n  }\n\n  var keys = Object.keys(partialProps);\n  keys.forEach(function (prop) {\n    var nonPluginProps = removeProperties(defaultProps, Object.keys(pluginProps));\n    var didPassUnknownProp = !hasOwnProperty(nonPluginProps, prop); // Check if the prop exists in `plugins`\n\n    if (didPassUnknownProp) {\n      didPassUnknownProp = plugins.filter(function (plugin) {\n        return plugin.name === prop;\n      }).length === 0;\n    }\n\n    warnWhen(didPassUnknownProp, [\"`\" + prop + \"`\", \"is not a valid prop. You may have spelled it incorrectly, or if it's\", 'a plugin, forgot to pass it in an array as props.plugins.', '\\n\\n', 'All props: https://atomiks.github.io/tippyjs/v6/all-props/\\n', 'Plugins: https://atomiks.github.io/tippyjs/v6/plugins/'].join(' '));\n  });\n}\n\nvar innerHTML = function innerHTML() {\n  return 'innerHTML';\n};\n\nfunction dangerouslySetInnerHTML(element, html) {\n  element[innerHTML()] = html;\n}\n\nfunction createArrowElement(value) {\n  var arrow = div();\n\n  if (value === true) {\n    arrow.className = ARROW_CLASS;\n  } else {\n    arrow.className = SVG_ARROW_CLASS;\n\n    if (isElement(value)) {\n      arrow.appendChild(value);\n    } else {\n      dangerouslySetInnerHTML(arrow, value);\n    }\n  }\n\n  return arrow;\n}\n\nfunction setContent(content, props) {\n  if (isElement(props.content)) {\n    dangerouslySetInnerHTML(content, '');\n    content.appendChild(props.content);\n  } else if (typeof props.content !== 'function') {\n    if (props.allowHTML) {\n      dangerouslySetInnerHTML(content, props.content);\n    } else {\n      content.textContent = props.content;\n    }\n  }\n}\nfunction getChildren(popper) {\n  var box = popper.firstElementChild;\n  var boxChildren = arrayFrom(box.children);\n  return {\n    box: box,\n    content: boxChildren.find(function (node) {\n      return node.classList.contains(CONTENT_CLASS);\n    }),\n    arrow: boxChildren.find(function (node) {\n      return node.classList.contains(ARROW_CLASS) || node.classList.contains(SVG_ARROW_CLASS);\n    }),\n    backdrop: boxChildren.find(function (node) {\n      return node.classList.contains(BACKDROP_CLASS);\n    })\n  };\n}\nfunction render(instance) {\n  var popper = div();\n  var box = div();\n  box.className = BOX_CLASS;\n  box.setAttribute('data-state', 'hidden');\n  box.setAttribute('tabindex', '-1');\n  var content = div();\n  content.className = CONTENT_CLASS;\n  content.setAttribute('data-state', 'hidden');\n  setContent(content, instance.props);\n  popper.appendChild(box);\n  box.appendChild(content);\n  onUpdate(instance.props, instance.props);\n\n  function onUpdate(prevProps, nextProps) {\n    var _getChildren = getChildren(popper),\n        box = _getChildren.box,\n        content = _getChildren.content,\n        arrow = _getChildren.arrow;\n\n    if (nextProps.theme) {\n      box.setAttribute('data-theme', nextProps.theme);\n    } else {\n      box.removeAttribute('data-theme');\n    }\n\n    if (typeof nextProps.animation === 'string') {\n      box.setAttribute('data-animation', nextProps.animation);\n    } else {\n      box.removeAttribute('data-animation');\n    }\n\n    if (nextProps.inertia) {\n      box.setAttribute('data-inertia', '');\n    } else {\n      box.removeAttribute('data-inertia');\n    }\n\n    box.style.maxWidth = typeof nextProps.maxWidth === 'number' ? nextProps.maxWidth + \"px\" : nextProps.maxWidth;\n\n    if (nextProps.role) {\n      box.setAttribute('role', nextProps.role);\n    } else {\n      box.removeAttribute('role');\n    }\n\n    if (prevProps.content !== nextProps.content || prevProps.allowHTML !== nextProps.allowHTML) {\n      setContent(content, instance.props);\n    }\n\n    if (nextProps.arrow) {\n      if (!arrow) {\n        box.appendChild(createArrowElement(nextProps.arrow));\n      } else if (prevProps.arrow !== nextProps.arrow) {\n        box.removeChild(arrow);\n        box.appendChild(createArrowElement(nextProps.arrow));\n      }\n    } else if (arrow) {\n      box.removeChild(arrow);\n    }\n  }\n\n  return {\n    popper: popper,\n    onUpdate: onUpdate\n  };\n} // Runtime check to identify if the render function is the default one; this\n// way we can apply default CSS transitions logic and it can be tree-shaken away\n\nrender.$$tippy = true;\n\nvar idCounter = 1;\nvar mouseMoveListeners = []; // Used by `hideAll()`\n\nvar mountedInstances = [];\nfunction createTippy(reference, passedProps) {\n  var props = evaluateProps(reference, Object.assign({}, defaultProps, getExtendedPassedProps(removeUndefinedProps(passedProps)))); // ===========================================================================\n  // 🔒 Private members\n  // ===========================================================================\n\n  var showTimeout;\n  var hideTimeout;\n  var scheduleHideAnimationFrame;\n  var isVisibleFromClick = false;\n  var didHideDueToDocumentMouseDown = false;\n  var didTouchMove = false;\n  var ignoreOnFirstUpdate = false;\n  var lastTriggerEvent;\n  var currentTransitionEndListener;\n  var onFirstUpdate;\n  var listeners = [];\n  var debouncedOnMouseMove = debounce(onMouseMove, props.interactiveDebounce);\n  var currentTarget; // ===========================================================================\n  // 🔑 Public members\n  // ===========================================================================\n\n  var id = idCounter++;\n  var popperInstance = null;\n  var plugins = unique(props.plugins);\n  var state = {\n    // Is the instance currently enabled?\n    isEnabled: true,\n    // Is the tippy currently showing and not transitioning out?\n    isVisible: false,\n    // Has the instance been destroyed?\n    isDestroyed: false,\n    // Is the tippy currently mounted to the DOM?\n    isMounted: false,\n    // Has the tippy finished transitioning in?\n    isShown: false\n  };\n  var instance = {\n    // properties\n    id: id,\n    reference: reference,\n    popper: div(),\n    popperInstance: popperInstance,\n    props: props,\n    state: state,\n    plugins: plugins,\n    // methods\n    clearDelayTimeouts: clearDelayTimeouts,\n    setProps: setProps,\n    setContent: setContent,\n    show: show,\n    hide: hide,\n    hideWithInteractivity: hideWithInteractivity,\n    enable: enable,\n    disable: disable,\n    unmount: unmount,\n    destroy: destroy\n  }; // TODO: Investigate why this early return causes a TDZ error in the tests —\n  // it doesn't seem to happen in the browser\n\n  /* istanbul ignore if */\n\n  if (!props.render) {\n    if (process.env.NODE_ENV !== \"production\") {\n      errorWhen(true, 'render() function has not been supplied.');\n    }\n\n    return instance;\n  } // ===========================================================================\n  // Initial mutations\n  // ===========================================================================\n\n\n  var _props$render = props.render(instance),\n      popper = _props$render.popper,\n      onUpdate = _props$render.onUpdate;\n\n  popper.setAttribute('data-tippy-root', '');\n  popper.id = \"tippy-\" + instance.id;\n  instance.popper = popper;\n  reference._tippy = instance;\n  popper._tippy = instance;\n  var pluginsHooks = plugins.map(function (plugin) {\n    return plugin.fn(instance);\n  });\n  var hasAriaExpanded = reference.hasAttribute('aria-expanded');\n  addListeners();\n  handleAriaExpandedAttribute();\n  handleStyles();\n  invokeHook('onCreate', [instance]);\n\n  if (props.showOnCreate) {\n    scheduleShow();\n  } // Prevent a tippy with a delay from hiding if the cursor left then returned\n  // before it started hiding\n\n\n  popper.addEventListener('mouseenter', function () {\n    if (instance.props.interactive && instance.state.isVisible) {\n      instance.clearDelayTimeouts();\n    }\n  });\n  popper.addEventListener('mouseleave', function () {\n    if (instance.props.interactive && instance.props.trigger.indexOf('mouseenter') >= 0) {\n      getDocument().addEventListener('mousemove', debouncedOnMouseMove);\n    }\n  });\n  return instance; // ===========================================================================\n  // 🔒 Private methods\n  // ===========================================================================\n\n  function getNormalizedTouchSettings() {\n    var touch = instance.props.touch;\n    return Array.isArray(touch) ? touch : [touch, 0];\n  }\n\n  function getIsCustomTouchBehavior() {\n    return getNormalizedTouchSettings()[0] === 'hold';\n  }\n\n  function getIsDefaultRenderFn() {\n    var _instance$props$rende;\n\n    // @ts-ignore\n    return !!((_instance$props$rende = instance.props.render) != null && _instance$props$rende.$$tippy);\n  }\n\n  function getCurrentTarget() {\n    return currentTarget || reference;\n  }\n\n  function getDocument() {\n    var parent = getCurrentTarget().parentNode;\n    return parent ? getOwnerDocument(parent) : document;\n  }\n\n  function getDefaultTemplateChildren() {\n    return getChildren(popper);\n  }\n\n  function getDelay(isShow) {\n    // For touch or keyboard input, force `0` delay for UX reasons\n    // Also if the instance is mounted but not visible (transitioning out),\n    // ignore delay\n    if (instance.state.isMounted && !instance.state.isVisible || currentInput.isTouch || lastTriggerEvent && lastTriggerEvent.type === 'focus') {\n      return 0;\n    }\n\n    return getValueAtIndexOrReturn(instance.props.delay, isShow ? 0 : 1, defaultProps.delay);\n  }\n\n  function handleStyles(fromHide) {\n    if (fromHide === void 0) {\n      fromHide = false;\n    }\n\n    popper.style.pointerEvents = instance.props.interactive && !fromHide ? '' : 'none';\n    popper.style.zIndex = \"\" + instance.props.zIndex;\n  }\n\n  function invokeHook(hook, args, shouldInvokePropsHook) {\n    if (shouldInvokePropsHook === void 0) {\n      shouldInvokePropsHook = true;\n    }\n\n    pluginsHooks.forEach(function (pluginHooks) {\n      if (pluginHooks[hook]) {\n        pluginHooks[hook].apply(pluginHooks, args);\n      }\n    });\n\n    if (shouldInvokePropsHook) {\n      var _instance$props;\n\n      (_instance$props = instance.props)[hook].apply(_instance$props, args);\n    }\n  }\n\n  function handleAriaContentAttribute() {\n    var aria = instance.props.aria;\n\n    if (!aria.content) {\n      return;\n    }\n\n    var attr = \"aria-\" + aria.content;\n    var id = popper.id;\n    var nodes = normalizeToArray(instance.props.triggerTarget || reference);\n    nodes.forEach(function (node) {\n      var currentValue = node.getAttribute(attr);\n\n      if (instance.state.isVisible) {\n        node.setAttribute(attr, currentValue ? currentValue + \" \" + id : id);\n      } else {\n        var nextValue = currentValue && currentValue.replace(id, '').trim();\n\n        if (nextValue) {\n          node.setAttribute(attr, nextValue);\n        } else {\n          node.removeAttribute(attr);\n        }\n      }\n    });\n  }\n\n  function handleAriaExpandedAttribute() {\n    if (hasAriaExpanded || !instance.props.aria.expanded) {\n      return;\n    }\n\n    var nodes = normalizeToArray(instance.props.triggerTarget || reference);\n    nodes.forEach(function (node) {\n      if (instance.props.interactive) {\n        node.setAttribute('aria-expanded', instance.state.isVisible && node === getCurrentTarget() ? 'true' : 'false');\n      } else {\n        node.removeAttribute('aria-expanded');\n      }\n    });\n  }\n\n  function cleanupInteractiveMouseListeners() {\n    getDocument().removeEventListener('mousemove', debouncedOnMouseMove);\n    mouseMoveListeners = mouseMoveListeners.filter(function (listener) {\n      return listener !== debouncedOnMouseMove;\n    });\n  }\n\n  function onDocumentPress(event) {\n    // Moved finger to scroll instead of an intentional tap outside\n    if (currentInput.isTouch) {\n      if (didTouchMove || event.type === 'mousedown') {\n        return;\n      }\n    }\n\n    var actualTarget = event.composedPath && event.composedPath()[0] || event.target; // Clicked on interactive popper\n\n    if (instance.props.interactive && actualContains(popper, actualTarget)) {\n      return;\n    } // Clicked on the event listeners target\n\n\n    if (normalizeToArray(instance.props.triggerTarget || reference).some(function (el) {\n      return actualContains(el, actualTarget);\n    })) {\n      if (currentInput.isTouch) {\n        return;\n      }\n\n      if (instance.state.isVisible && instance.props.trigger.indexOf('click') >= 0) {\n        return;\n      }\n    } else {\n      invokeHook('onClickOutside', [instance, event]);\n    }\n\n    if (instance.props.hideOnClick === true) {\n      instance.clearDelayTimeouts();\n      instance.hide(); // `mousedown` event is fired right before `focus` if pressing the\n      // currentTarget. This lets a tippy with `focus` trigger know that it\n      // should not show\n\n      didHideDueToDocumentMouseDown = true;\n      setTimeout(function () {\n        didHideDueToDocumentMouseDown = false;\n      }); // The listener gets added in `scheduleShow()`, but this may be hiding it\n      // before it shows, and hide()'s early bail-out behavior can prevent it\n      // from being cleaned up\n\n      if (!instance.state.isMounted) {\n        removeDocumentPress();\n      }\n    }\n  }\n\n  function onTouchMove() {\n    didTouchMove = true;\n  }\n\n  function onTouchStart() {\n    didTouchMove = false;\n  }\n\n  function addDocumentPress() {\n    var doc = getDocument();\n    doc.addEventListener('mousedown', onDocumentPress, true);\n    doc.addEventListener('touchend', onDocumentPress, TOUCH_OPTIONS);\n    doc.addEventListener('touchstart', onTouchStart, TOUCH_OPTIONS);\n    doc.addEventListener('touchmove', onTouchMove, TOUCH_OPTIONS);\n  }\n\n  function removeDocumentPress() {\n    var doc = getDocument();\n    doc.removeEventListener('mousedown', onDocumentPress, true);\n    doc.removeEventListener('touchend', onDocumentPress, TOUCH_OPTIONS);\n    doc.removeEventListener('touchstart', onTouchStart, TOUCH_OPTIONS);\n    doc.removeEventListener('touchmove', onTouchMove, TOUCH_OPTIONS);\n  }\n\n  function onTransitionedOut(duration, callback) {\n    onTransitionEnd(duration, function () {\n      if (!instance.state.isVisible && popper.parentNode && popper.parentNode.contains(popper)) {\n        callback();\n      }\n    });\n  }\n\n  function onTransitionedIn(duration, callback) {\n    onTransitionEnd(duration, callback);\n  }\n\n  function onTransitionEnd(duration, callback) {\n    var box = getDefaultTemplateChildren().box;\n\n    function listener(event) {\n      if (event.target === box) {\n        updateTransitionEndListener(box, 'remove', listener);\n        callback();\n      }\n    } // Make callback synchronous if duration is 0\n    // `transitionend` won't fire otherwise\n\n\n    if (duration === 0) {\n      return callback();\n    }\n\n    updateTransitionEndListener(box, 'remove', currentTransitionEndListener);\n    updateTransitionEndListener(box, 'add', listener);\n    currentTransitionEndListener = listener;\n  }\n\n  function on(eventType, handler, options) {\n    if (options === void 0) {\n      options = false;\n    }\n\n    var nodes = normalizeToArray(instance.props.triggerTarget || reference);\n    nodes.forEach(function (node) {\n      node.addEventListener(eventType, handler, options);\n      listeners.push({\n        node: node,\n        eventType: eventType,\n        handler: handler,\n        options: options\n      });\n    });\n  }\n\n  function addListeners() {\n    if (getIsCustomTouchBehavior()) {\n      on('touchstart', onTrigger, {\n        passive: true\n      });\n      on('touchend', onMouseLeave, {\n        passive: true\n      });\n    }\n\n    splitBySpaces(instance.props.trigger).forEach(function (eventType) {\n      if (eventType === 'manual') {\n        return;\n      }\n\n      on(eventType, onTrigger);\n\n      switch (eventType) {\n        case 'mouseenter':\n          on('mouseleave', onMouseLeave);\n          break;\n\n        case 'focus':\n          on(isIE11 ? 'focusout' : 'blur', onBlurOrFocusOut);\n          break;\n\n        case 'focusin':\n          on('focusout', onBlurOrFocusOut);\n          break;\n      }\n    });\n  }\n\n  function removeListeners() {\n    listeners.forEach(function (_ref) {\n      var node = _ref.node,\n          eventType = _ref.eventType,\n          handler = _ref.handler,\n          options = _ref.options;\n      node.removeEventListener(eventType, handler, options);\n    });\n    listeners = [];\n  }\n\n  function onTrigger(event) {\n    var _lastTriggerEvent;\n\n    var shouldScheduleClickHide = false;\n\n    if (!instance.state.isEnabled || isEventListenerStopped(event) || didHideDueToDocumentMouseDown) {\n      return;\n    }\n\n    var wasFocused = ((_lastTriggerEvent = lastTriggerEvent) == null ? void 0 : _lastTriggerEvent.type) === 'focus';\n    lastTriggerEvent = event;\n    currentTarget = event.currentTarget;\n    handleAriaExpandedAttribute();\n\n    if (!instance.state.isVisible && isMouseEvent(event)) {\n      // If scrolling, `mouseenter` events can be fired if the cursor lands\n      // over a new target, but `mousemove` events don't get fired. This\n      // causes interactive tooltips to get stuck open until the cursor is\n      // moved\n      mouseMoveListeners.forEach(function (listener) {\n        return listener(event);\n      });\n    } // Toggle show/hide when clicking click-triggered tooltips\n\n\n    if (event.type === 'click' && (instance.props.trigger.indexOf('mouseenter') < 0 || isVisibleFromClick) && instance.props.hideOnClick !== false && instance.state.isVisible) {\n      shouldScheduleClickHide = true;\n    } else {\n      scheduleShow(event);\n    }\n\n    if (event.type === 'click') {\n      isVisibleFromClick = !shouldScheduleClickHide;\n    }\n\n    if (shouldScheduleClickHide && !wasFocused) {\n      scheduleHide(event);\n    }\n  }\n\n  function onMouseMove(event) {\n    var target = event.target;\n    var isCursorOverReferenceOrPopper = getCurrentTarget().contains(target) || popper.contains(target);\n\n    if (event.type === 'mousemove' && isCursorOverReferenceOrPopper) {\n      return;\n    }\n\n    var popperTreeData = getNestedPopperTree().concat(popper).map(function (popper) {\n      var _instance$popperInsta;\n\n      var instance = popper._tippy;\n      var state = (_instance$popperInsta = instance.popperInstance) == null ? void 0 : _instance$popperInsta.state;\n\n      if (state) {\n        return {\n          popperRect: popper.getBoundingClientRect(),\n          popperState: state,\n          props: props\n        };\n      }\n\n      return null;\n    }).filter(Boolean);\n\n    if (isCursorOutsideInteractiveBorder(popperTreeData, event)) {\n      cleanupInteractiveMouseListeners();\n      scheduleHide(event);\n    }\n  }\n\n  function onMouseLeave(event) {\n    var shouldBail = isEventListenerStopped(event) || instance.props.trigger.indexOf('click') >= 0 && isVisibleFromClick;\n\n    if (shouldBail) {\n      return;\n    }\n\n    if (instance.props.interactive) {\n      instance.hideWithInteractivity(event);\n      return;\n    }\n\n    scheduleHide(event);\n  }\n\n  function onBlurOrFocusOut(event) {\n    if (instance.props.trigger.indexOf('focusin') < 0 && event.target !== getCurrentTarget()) {\n      return;\n    } // If focus was moved to within the popper\n\n\n    if (instance.props.interactive && event.relatedTarget && popper.contains(event.relatedTarget)) {\n      return;\n    }\n\n    scheduleHide(event);\n  }\n\n  function isEventListenerStopped(event) {\n    return currentInput.isTouch ? getIsCustomTouchBehavior() !== event.type.indexOf('touch') >= 0 : false;\n  }\n\n  function createPopperInstance() {\n    destroyPopperInstance();\n    var _instance$props2 = instance.props,\n        popperOptions = _instance$props2.popperOptions,\n        placement = _instance$props2.placement,\n        offset = _instance$props2.offset,\n        getReferenceClientRect = _instance$props2.getReferenceClientRect,\n        moveTransition = _instance$props2.moveTransition;\n    var arrow = getIsDefaultRenderFn() ? getChildren(popper).arrow : null;\n    var computedReference = getReferenceClientRect ? {\n      getBoundingClientRect: getReferenceClientRect,\n      contextElement: getReferenceClientRect.contextElement || getCurrentTarget()\n    } : reference;\n    var tippyModifier = {\n      name: '$$tippy',\n      enabled: true,\n      phase: 'beforeWrite',\n      requires: ['computeStyles'],\n      fn: function fn(_ref2) {\n        var state = _ref2.state;\n\n        if (getIsDefaultRenderFn()) {\n          var _getDefaultTemplateCh = getDefaultTemplateChildren(),\n              box = _getDefaultTemplateCh.box;\n\n          ['placement', 'reference-hidden', 'escaped'].forEach(function (attr) {\n            if (attr === 'placement') {\n              box.setAttribute('data-placement', state.placement);\n            } else {\n              if (state.attributes.popper[\"data-popper-\" + attr]) {\n                box.setAttribute(\"data-\" + attr, '');\n              } else {\n                box.removeAttribute(\"data-\" + attr);\n              }\n            }\n          });\n          state.attributes.popper = {};\n        }\n      }\n    };\n    var modifiers = [{\n      name: 'offset',\n      options: {\n        offset: offset\n      }\n    }, {\n      name: 'preventOverflow',\n      options: {\n        padding: {\n          top: 2,\n          bottom: 2,\n          left: 5,\n          right: 5\n        }\n      }\n    }, {\n      name: 'flip',\n      options: {\n        padding: 5\n      }\n    }, {\n      name: 'computeStyles',\n      options: {\n        adaptive: !moveTransition\n      }\n    }, tippyModifier];\n\n    if (getIsDefaultRenderFn() && arrow) {\n      modifiers.push({\n        name: 'arrow',\n        options: {\n          element: arrow,\n          padding: 3\n        }\n      });\n    }\n\n    modifiers.push.apply(modifiers, (popperOptions == null ? void 0 : popperOptions.modifiers) || []);\n    instance.popperInstance = createPopper(computedReference, popper, Object.assign({}, popperOptions, {\n      placement: placement,\n      onFirstUpdate: onFirstUpdate,\n      modifiers: modifiers\n    }));\n  }\n\n  function destroyPopperInstance() {\n    if (instance.popperInstance) {\n      instance.popperInstance.destroy();\n      instance.popperInstance = null;\n    }\n  }\n\n  function mount() {\n    var appendTo = instance.props.appendTo;\n    var parentNode; // By default, we'll append the popper to the triggerTargets's parentNode so\n    // it's directly after the reference element so the elements inside the\n    // tippy can be tabbed to\n    // If there are clipping issues, the user can specify a different appendTo\n    // and ensure focus management is handled correctly manually\n\n    var node = getCurrentTarget();\n\n    if (instance.props.interactive && appendTo === TIPPY_DEFAULT_APPEND_TO || appendTo === 'parent') {\n      parentNode = node.parentNode;\n    } else {\n      parentNode = invokeWithArgsOrReturn(appendTo, [node]);\n    } // The popper element needs to exist on the DOM before its position can be\n    // updated as Popper needs to read its dimensions\n\n\n    if (!parentNode.contains(popper)) {\n      parentNode.appendChild(popper);\n    }\n\n    instance.state.isMounted = true;\n    createPopperInstance();\n    /* istanbul ignore else */\n\n    if (process.env.NODE_ENV !== \"production\") {\n      // Accessibility check\n      warnWhen(instance.props.interactive && appendTo === defaultProps.appendTo && node.nextElementSibling !== popper, ['Interactive tippy element may not be accessible via keyboard', 'navigation because it is not directly after the reference element', 'in the DOM source order.', '\\n\\n', 'Using a wrapper <div> or <span> tag around the reference element', 'solves this by creating a new parentNode context.', '\\n\\n', 'Specifying `appendTo: document.body` silences this warning, but it', 'assumes you are using a focus management solution to handle', 'keyboard navigation.', '\\n\\n', 'See: https://atomiks.github.io/tippyjs/v6/accessibility/#interactivity'].join(' '));\n    }\n  }\n\n  function getNestedPopperTree() {\n    return arrayFrom(popper.querySelectorAll('[data-tippy-root]'));\n  }\n\n  function scheduleShow(event) {\n    instance.clearDelayTimeouts();\n\n    if (event) {\n      invokeHook('onTrigger', [instance, event]);\n    }\n\n    addDocumentPress();\n    var delay = getDelay(true);\n\n    var _getNormalizedTouchSe = getNormalizedTouchSettings(),\n        touchValue = _getNormalizedTouchSe[0],\n        touchDelay = _getNormalizedTouchSe[1];\n\n    if (currentInput.isTouch && touchValue === 'hold' && touchDelay) {\n      delay = touchDelay;\n    }\n\n    if (delay) {\n      showTimeout = setTimeout(function () {\n        instance.show();\n      }, delay);\n    } else {\n      instance.show();\n    }\n  }\n\n  function scheduleHide(event) {\n    instance.clearDelayTimeouts();\n    invokeHook('onUntrigger', [instance, event]);\n\n    if (!instance.state.isVisible) {\n      removeDocumentPress();\n      return;\n    } // For interactive tippies, scheduleHide is added to a document.body handler\n    // from onMouseLeave so must intercept scheduled hides from mousemove/leave\n    // events when trigger contains mouseenter and click, and the tip is\n    // currently shown as a result of a click.\n\n\n    if (instance.props.trigger.indexOf('mouseenter') >= 0 && instance.props.trigger.indexOf('click') >= 0 && ['mouseleave', 'mousemove'].indexOf(event.type) >= 0 && isVisibleFromClick) {\n      return;\n    }\n\n    var delay = getDelay(false);\n\n    if (delay) {\n      hideTimeout = setTimeout(function () {\n        if (instance.state.isVisible) {\n          instance.hide();\n        }\n      }, delay);\n    } else {\n      // Fixes a `transitionend` problem when it fires 1 frame too\n      // late sometimes, we don't want hide() to be called.\n      scheduleHideAnimationFrame = requestAnimationFrame(function () {\n        instance.hide();\n      });\n    }\n  } // ===========================================================================\n  // 🔑 Public methods\n  // ===========================================================================\n\n\n  function enable() {\n    instance.state.isEnabled = true;\n  }\n\n  function disable() {\n    // Disabling the instance should also hide it\n    // https://github.com/atomiks/tippy.js-react/issues/106\n    instance.hide();\n    instance.state.isEnabled = false;\n  }\n\n  function clearDelayTimeouts() {\n    clearTimeout(showTimeout);\n    clearTimeout(hideTimeout);\n    cancelAnimationFrame(scheduleHideAnimationFrame);\n  }\n\n  function setProps(partialProps) {\n    /* istanbul ignore else */\n    if (process.env.NODE_ENV !== \"production\") {\n      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('setProps'));\n    }\n\n    if (instance.state.isDestroyed) {\n      return;\n    }\n\n    invokeHook('onBeforeUpdate', [instance, partialProps]);\n    removeListeners();\n    var prevProps = instance.props;\n    var nextProps = evaluateProps(reference, Object.assign({}, prevProps, removeUndefinedProps(partialProps), {\n      ignoreAttributes: true\n    }));\n    instance.props = nextProps;\n    addListeners();\n\n    if (prevProps.interactiveDebounce !== nextProps.interactiveDebounce) {\n      cleanupInteractiveMouseListeners();\n      debouncedOnMouseMove = debounce(onMouseMove, nextProps.interactiveDebounce);\n    } // Ensure stale aria-expanded attributes are removed\n\n\n    if (prevProps.triggerTarget && !nextProps.triggerTarget) {\n      normalizeToArray(prevProps.triggerTarget).forEach(function (node) {\n        node.removeAttribute('aria-expanded');\n      });\n    } else if (nextProps.triggerTarget) {\n      reference.removeAttribute('aria-expanded');\n    }\n\n    handleAriaExpandedAttribute();\n    handleStyles();\n\n    if (onUpdate) {\n      onUpdate(prevProps, nextProps);\n    }\n\n    if (instance.popperInstance) {\n      createPopperInstance(); // Fixes an issue with nested tippies if they are all getting re-rendered,\n      // and the nested ones get re-rendered first.\n      // https://github.com/atomiks/tippyjs-react/issues/177\n      // TODO: find a cleaner / more efficient solution(!)\n\n      getNestedPopperTree().forEach(function (nestedPopper) {\n        // React (and other UI libs likely) requires a rAF wrapper as it flushes\n        // its work in one\n        requestAnimationFrame(nestedPopper._tippy.popperInstance.forceUpdate);\n      });\n    }\n\n    invokeHook('onAfterUpdate', [instance, partialProps]);\n  }\n\n  function setContent(content) {\n    instance.setProps({\n      content: content\n    });\n  }\n\n  function show() {\n    /* istanbul ignore else */\n    if (process.env.NODE_ENV !== \"production\") {\n      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('show'));\n    } // Early bail-out\n\n\n    var isAlreadyVisible = instance.state.isVisible;\n    var isDestroyed = instance.state.isDestroyed;\n    var isDisabled = !instance.state.isEnabled;\n    var isTouchAndTouchDisabled = currentInput.isTouch && !instance.props.touch;\n    var duration = getValueAtIndexOrReturn(instance.props.duration, 0, defaultProps.duration);\n\n    if (isAlreadyVisible || isDestroyed || isDisabled || isTouchAndTouchDisabled) {\n      return;\n    } // Normalize `disabled` behavior across browsers.\n    // Firefox allows events on disabled elements, but Chrome doesn't.\n    // Using a wrapper element (i.e. <span>) is recommended.\n\n\n    if (getCurrentTarget().hasAttribute('disabled')) {\n      return;\n    }\n\n    invokeHook('onShow', [instance], false);\n\n    if (instance.props.onShow(instance) === false) {\n      return;\n    }\n\n    instance.state.isVisible = true;\n\n    if (getIsDefaultRenderFn()) {\n      popper.style.visibility = 'visible';\n    }\n\n    handleStyles();\n    addDocumentPress();\n\n    if (!instance.state.isMounted) {\n      popper.style.transition = 'none';\n    } // If flipping to the opposite side after hiding at least once, the\n    // animation will use the wrong placement without resetting the duration\n\n\n    if (getIsDefaultRenderFn()) {\n      var _getDefaultTemplateCh2 = getDefaultTemplateChildren(),\n          box = _getDefaultTemplateCh2.box,\n          content = _getDefaultTemplateCh2.content;\n\n      setTransitionDuration([box, content], 0);\n    }\n\n    onFirstUpdate = function onFirstUpdate() {\n      var _instance$popperInsta2;\n\n      if (!instance.state.isVisible || ignoreOnFirstUpdate) {\n        return;\n      }\n\n      ignoreOnFirstUpdate = true; // reflow\n\n      void popper.offsetHeight;\n      popper.style.transition = instance.props.moveTransition;\n\n      if (getIsDefaultRenderFn() && instance.props.animation) {\n        var _getDefaultTemplateCh3 = getDefaultTemplateChildren(),\n            _box = _getDefaultTemplateCh3.box,\n            _content = _getDefaultTemplateCh3.content;\n\n        setTransitionDuration([_box, _content], duration);\n        setVisibilityState([_box, _content], 'visible');\n      }\n\n      handleAriaContentAttribute();\n      handleAriaExpandedAttribute();\n      pushIfUnique(mountedInstances, instance); // certain modifiers (e.g. `maxSize`) require a second update after the\n      // popper has been positioned for the first time\n\n      (_instance$popperInsta2 = instance.popperInstance) == null ? void 0 : _instance$popperInsta2.forceUpdate();\n      invokeHook('onMount', [instance]);\n\n      if (instance.props.animation && getIsDefaultRenderFn()) {\n        onTransitionedIn(duration, function () {\n          instance.state.isShown = true;\n          invokeHook('onShown', [instance]);\n        });\n      }\n    };\n\n    mount();\n  }\n\n  function hide() {\n    /* istanbul ignore else */\n    if (process.env.NODE_ENV !== \"production\") {\n      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('hide'));\n    } // Early bail-out\n\n\n    var isAlreadyHidden = !instance.state.isVisible;\n    var isDestroyed = instance.state.isDestroyed;\n    var isDisabled = !instance.state.isEnabled;\n    var duration = getValueAtIndexOrReturn(instance.props.duration, 1, defaultProps.duration);\n\n    if (isAlreadyHidden || isDestroyed || isDisabled) {\n      return;\n    }\n\n    invokeHook('onHide', [instance], false);\n\n    if (instance.props.onHide(instance) === false) {\n      return;\n    }\n\n    instance.state.isVisible = false;\n    instance.state.isShown = false;\n    ignoreOnFirstUpdate = false;\n    isVisibleFromClick = false;\n\n    if (getIsDefaultRenderFn()) {\n      popper.style.visibility = 'hidden';\n    }\n\n    cleanupInteractiveMouseListeners();\n    removeDocumentPress();\n    handleStyles(true);\n\n    if (getIsDefaultRenderFn()) {\n      var _getDefaultTemplateCh4 = getDefaultTemplateChildren(),\n          box = _getDefaultTemplateCh4.box,\n          content = _getDefaultTemplateCh4.content;\n\n      if (instance.props.animation) {\n        setTransitionDuration([box, content], duration);\n        setVisibilityState([box, content], 'hidden');\n      }\n    }\n\n    handleAriaContentAttribute();\n    handleAriaExpandedAttribute();\n\n    if (instance.props.animation) {\n      if (getIsDefaultRenderFn()) {\n        onTransitionedOut(duration, instance.unmount);\n      }\n    } else {\n      instance.unmount();\n    }\n  }\n\n  function hideWithInteractivity(event) {\n    /* istanbul ignore else */\n    if (process.env.NODE_ENV !== \"production\") {\n      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('hideWithInteractivity'));\n    }\n\n    getDocument().addEventListener('mousemove', debouncedOnMouseMove);\n    pushIfUnique(mouseMoveListeners, debouncedOnMouseMove);\n    debouncedOnMouseMove(event);\n  }\n\n  function unmount() {\n    /* istanbul ignore else */\n    if (process.env.NODE_ENV !== \"production\") {\n      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('unmount'));\n    }\n\n    if (instance.state.isVisible) {\n      instance.hide();\n    }\n\n    if (!instance.state.isMounted) {\n      return;\n    }\n\n    destroyPopperInstance(); // If a popper is not interactive, it will be appended outside the popper\n    // tree by default. This seems mainly for interactive tippies, but we should\n    // find a workaround if possible\n\n    getNestedPopperTree().forEach(function (nestedPopper) {\n      nestedPopper._tippy.unmount();\n    });\n\n    if (popper.parentNode) {\n      popper.parentNode.removeChild(popper);\n    }\n\n    mountedInstances = mountedInstances.filter(function (i) {\n      return i !== instance;\n    });\n    instance.state.isMounted = false;\n    invokeHook('onHidden', [instance]);\n  }\n\n  function destroy() {\n    /* istanbul ignore else */\n    if (process.env.NODE_ENV !== \"production\") {\n      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('destroy'));\n    }\n\n    if (instance.state.isDestroyed) {\n      return;\n    }\n\n    instance.clearDelayTimeouts();\n    instance.unmount();\n    removeListeners();\n    delete reference._tippy;\n    instance.state.isDestroyed = true;\n    invokeHook('onDestroy', [instance]);\n  }\n}\n\nfunction tippy(targets, optionalProps) {\n  if (optionalProps === void 0) {\n    optionalProps = {};\n  }\n\n  var plugins = defaultProps.plugins.concat(optionalProps.plugins || []);\n  /* istanbul ignore else */\n\n  if (process.env.NODE_ENV !== \"production\") {\n    validateTargets(targets);\n    validateProps(optionalProps, plugins);\n  }\n\n  bindGlobalEventListeners();\n  var passedProps = Object.assign({}, optionalProps, {\n    plugins: plugins\n  });\n  var elements = getArrayOfElements(targets);\n  /* istanbul ignore else */\n\n  if (process.env.NODE_ENV !== \"production\") {\n    var isSingleContentElement = isElement(passedProps.content);\n    var isMoreThanOneReferenceElement = elements.length > 1;\n    warnWhen(isSingleContentElement && isMoreThanOneReferenceElement, ['tippy() was passed an Element as the `content` prop, but more than', 'one tippy instance was created by this invocation. This means the', 'content element will only be appended to the last tippy instance.', '\\n\\n', 'Instead, pass the .innerHTML of the element, or use a function that', 'returns a cloned version of the element instead.', '\\n\\n', '1) content: element.innerHTML\\n', '2) content: () => element.cloneNode(true)'].join(' '));\n  }\n\n  var instances = elements.reduce(function (acc, reference) {\n    var instance = reference && createTippy(reference, passedProps);\n\n    if (instance) {\n      acc.push(instance);\n    }\n\n    return acc;\n  }, []);\n  return isElement(targets) ? instances[0] : instances;\n}\n\ntippy.defaultProps = defaultProps;\ntippy.setDefaultProps = setDefaultProps;\ntippy.currentInput = currentInput;\nvar hideAll = function hideAll(_temp) {\n  var _ref = _temp === void 0 ? {} : _temp,\n      excludedReferenceOrInstance = _ref.exclude,\n      duration = _ref.duration;\n\n  mountedInstances.forEach(function (instance) {\n    var isExcluded = false;\n\n    if (excludedReferenceOrInstance) {\n      isExcluded = isReferenceElement(excludedReferenceOrInstance) ? instance.reference === excludedReferenceOrInstance : instance.popper === excludedReferenceOrInstance.popper;\n    }\n\n    if (!isExcluded) {\n      var originalDuration = instance.props.duration;\n      instance.setProps({\n        duration: duration\n      });\n      instance.hide();\n\n      if (!instance.state.isDestroyed) {\n        instance.setProps({\n          duration: originalDuration\n        });\n      }\n    }\n  });\n};\n\n// every time the popper is destroyed (i.e. a new target), removing the styles\n// and causing transitions to break for singletons when the console is open, but\n// most notably for non-transform styles being used, `gpuAcceleration: false`.\n\nvar applyStylesModifier = Object.assign({}, applyStyles, {\n  effect: function effect(_ref) {\n    var state = _ref.state;\n    var initialStyles = {\n      popper: {\n        position: state.options.strategy,\n        left: '0',\n        top: '0',\n        margin: '0'\n      },\n      arrow: {\n        position: 'absolute'\n      },\n      reference: {}\n    };\n    Object.assign(state.elements.popper.style, initialStyles.popper);\n    state.styles = initialStyles;\n\n    if (state.elements.arrow) {\n      Object.assign(state.elements.arrow.style, initialStyles.arrow);\n    } // intentionally return no cleanup function\n    // return () => { ... }\n\n  }\n});\n\nvar createSingleton = function createSingleton(tippyInstances, optionalProps) {\n  var _optionalProps$popper;\n\n  if (optionalProps === void 0) {\n    optionalProps = {};\n  }\n\n  /* istanbul ignore else */\n  if (process.env.NODE_ENV !== \"production\") {\n    errorWhen(!Array.isArray(tippyInstances), ['The first argument passed to createSingleton() must be an array of', 'tippy instances. The passed value was', String(tippyInstances)].join(' '));\n  }\n\n  var individualInstances = tippyInstances;\n  var references = [];\n  var triggerTargets = [];\n  var currentTarget;\n  var overrides = optionalProps.overrides;\n  var interceptSetPropsCleanups = [];\n  var shownOnCreate = false;\n\n  function setTriggerTargets() {\n    triggerTargets = individualInstances.map(function (instance) {\n      return normalizeToArray(instance.props.triggerTarget || instance.reference);\n    }).reduce(function (acc, item) {\n      return acc.concat(item);\n    }, []);\n  }\n\n  function setReferences() {\n    references = individualInstances.map(function (instance) {\n      return instance.reference;\n    });\n  }\n\n  function enableInstances(isEnabled) {\n    individualInstances.forEach(function (instance) {\n      if (isEnabled) {\n        instance.enable();\n      } else {\n        instance.disable();\n      }\n    });\n  }\n\n  function interceptSetProps(singleton) {\n    return individualInstances.map(function (instance) {\n      var originalSetProps = instance.setProps;\n\n      instance.setProps = function (props) {\n        originalSetProps(props);\n\n        if (instance.reference === currentTarget) {\n          singleton.setProps(props);\n        }\n      };\n\n      return function () {\n        instance.setProps = originalSetProps;\n      };\n    });\n  } // have to pass singleton, as it maybe undefined on first call\n\n\n  function prepareInstance(singleton, target) {\n    var index = triggerTargets.indexOf(target); // bail-out\n\n    if (target === currentTarget) {\n      return;\n    }\n\n    currentTarget = target;\n    var overrideProps = (overrides || []).concat('content').reduce(function (acc, prop) {\n      acc[prop] = individualInstances[index].props[prop];\n      return acc;\n    }, {});\n    singleton.setProps(Object.assign({}, overrideProps, {\n      getReferenceClientRect: typeof overrideProps.getReferenceClientRect === 'function' ? overrideProps.getReferenceClientRect : function () {\n        var _references$index;\n\n        return (_references$index = references[index]) == null ? void 0 : _references$index.getBoundingClientRect();\n      }\n    }));\n  }\n\n  enableInstances(false);\n  setReferences();\n  setTriggerTargets();\n  var plugin = {\n    fn: function fn() {\n      return {\n        onDestroy: function onDestroy() {\n          enableInstances(true);\n        },\n        onHidden: function onHidden() {\n          currentTarget = null;\n        },\n        onClickOutside: function onClickOutside(instance) {\n          if (instance.props.showOnCreate && !shownOnCreate) {\n            shownOnCreate = true;\n            currentTarget = null;\n          }\n        },\n        onShow: function onShow(instance) {\n          if (instance.props.showOnCreate && !shownOnCreate) {\n            shownOnCreate = true;\n            prepareInstance(instance, references[0]);\n          }\n        },\n        onTrigger: function onTrigger(instance, event) {\n          prepareInstance(instance, event.currentTarget);\n        }\n      };\n    }\n  };\n  var singleton = tippy(div(), Object.assign({}, removeProperties(optionalProps, ['overrides']), {\n    plugins: [plugin].concat(optionalProps.plugins || []),\n    triggerTarget: triggerTargets,\n    popperOptions: Object.assign({}, optionalProps.popperOptions, {\n      modifiers: [].concat(((_optionalProps$popper = optionalProps.popperOptions) == null ? void 0 : _optionalProps$popper.modifiers) || [], [applyStylesModifier])\n    })\n  }));\n  var originalShow = singleton.show;\n\n  singleton.show = function (target) {\n    originalShow(); // first time, showOnCreate or programmatic call with no params\n    // default to showing first instance\n\n    if (!currentTarget && target == null) {\n      return prepareInstance(singleton, references[0]);\n    } // triggered from event (do nothing as prepareInstance already called by onTrigger)\n    // programmatic call with no params when already visible (do nothing again)\n\n\n    if (currentTarget && target == null) {\n      return;\n    } // target is index of instance\n\n\n    if (typeof target === 'number') {\n      return references[target] && prepareInstance(singleton, references[target]);\n    } // target is a child tippy instance\n\n\n    if (individualInstances.indexOf(target) >= 0) {\n      var ref = target.reference;\n      return prepareInstance(singleton, ref);\n    } // target is a ReferenceElement\n\n\n    if (references.indexOf(target) >= 0) {\n      return prepareInstance(singleton, target);\n    }\n  };\n\n  singleton.showNext = function () {\n    var first = references[0];\n\n    if (!currentTarget) {\n      return singleton.show(0);\n    }\n\n    var index = references.indexOf(currentTarget);\n    singleton.show(references[index + 1] || first);\n  };\n\n  singleton.showPrevious = function () {\n    var last = references[references.length - 1];\n\n    if (!currentTarget) {\n      return singleton.show(last);\n    }\n\n    var index = references.indexOf(currentTarget);\n    var target = references[index - 1] || last;\n    singleton.show(target);\n  };\n\n  var originalSetProps = singleton.setProps;\n\n  singleton.setProps = function (props) {\n    overrides = props.overrides || overrides;\n    originalSetProps(props);\n  };\n\n  singleton.setInstances = function (nextInstances) {\n    enableInstances(true);\n    interceptSetPropsCleanups.forEach(function (fn) {\n      return fn();\n    });\n    individualInstances = nextInstances;\n    enableInstances(false);\n    setReferences();\n    setTriggerTargets();\n    interceptSetPropsCleanups = interceptSetProps(singleton);\n    singleton.setProps({\n      triggerTarget: triggerTargets\n    });\n  };\n\n  interceptSetPropsCleanups = interceptSetProps(singleton);\n  return singleton;\n};\n\nvar BUBBLING_EVENTS_MAP = {\n  mouseover: 'mouseenter',\n  focusin: 'focus',\n  click: 'click'\n};\n/**\n * Creates a delegate instance that controls the creation of tippy instances\n * for child elements (`target` CSS selector).\n */\n\nfunction delegate(targets, props) {\n  /* istanbul ignore else */\n  if (process.env.NODE_ENV !== \"production\") {\n    errorWhen(!(props && props.target), ['You must specity a `target` prop indicating a CSS selector string matching', 'the target elements that should receive a tippy.'].join(' '));\n  }\n\n  var listeners = [];\n  var childTippyInstances = [];\n  var disabled = false;\n  var target = props.target;\n  var nativeProps = removeProperties(props, ['target']);\n  var parentProps = Object.assign({}, nativeProps, {\n    trigger: 'manual',\n    touch: false\n  });\n  var childProps = Object.assign({\n    touch: defaultProps.touch\n  }, nativeProps, {\n    showOnCreate: true\n  });\n  var returnValue = tippy(targets, parentProps);\n  var normalizedReturnValue = normalizeToArray(returnValue);\n\n  function onTrigger(event) {\n    if (!event.target || disabled) {\n      return;\n    }\n\n    var targetNode = event.target.closest(target);\n\n    if (!targetNode) {\n      return;\n    } // Get relevant trigger with fallbacks:\n    // 1. Check `data-tippy-trigger` attribute on target node\n    // 2. Fallback to `trigger` passed to `delegate()`\n    // 3. Fallback to `defaultProps.trigger`\n\n\n    var trigger = targetNode.getAttribute('data-tippy-trigger') || props.trigger || defaultProps.trigger; // @ts-ignore\n\n    if (targetNode._tippy) {\n      return;\n    }\n\n    if (event.type === 'touchstart' && typeof childProps.touch === 'boolean') {\n      return;\n    }\n\n    if (event.type !== 'touchstart' && trigger.indexOf(BUBBLING_EVENTS_MAP[event.type]) < 0) {\n      return;\n    }\n\n    var instance = tippy(targetNode, childProps);\n\n    if (instance) {\n      childTippyInstances = childTippyInstances.concat(instance);\n    }\n  }\n\n  function on(node, eventType, handler, options) {\n    if (options === void 0) {\n      options = false;\n    }\n\n    node.addEventListener(eventType, handler, options);\n    listeners.push({\n      node: node,\n      eventType: eventType,\n      handler: handler,\n      options: options\n    });\n  }\n\n  function addEventListeners(instance) {\n    var reference = instance.reference;\n    on(reference, 'touchstart', onTrigger, TOUCH_OPTIONS);\n    on(reference, 'mouseover', onTrigger);\n    on(reference, 'focusin', onTrigger);\n    on(reference, 'click', onTrigger);\n  }\n\n  function removeEventListeners() {\n    listeners.forEach(function (_ref) {\n      var node = _ref.node,\n          eventType = _ref.eventType,\n          handler = _ref.handler,\n          options = _ref.options;\n      node.removeEventListener(eventType, handler, options);\n    });\n    listeners = [];\n  }\n\n  function applyMutations(instance) {\n    var originalDestroy = instance.destroy;\n    var originalEnable = instance.enable;\n    var originalDisable = instance.disable;\n\n    instance.destroy = function (shouldDestroyChildInstances) {\n      if (shouldDestroyChildInstances === void 0) {\n        shouldDestroyChildInstances = true;\n      }\n\n      if (shouldDestroyChildInstances) {\n        childTippyInstances.forEach(function (instance) {\n          instance.destroy();\n        });\n      }\n\n      childTippyInstances = [];\n      removeEventListeners();\n      originalDestroy();\n    };\n\n    instance.enable = function () {\n      originalEnable();\n      childTippyInstances.forEach(function (instance) {\n        return instance.enable();\n      });\n      disabled = false;\n    };\n\n    instance.disable = function () {\n      originalDisable();\n      childTippyInstances.forEach(function (instance) {\n        return instance.disable();\n      });\n      disabled = true;\n    };\n\n    addEventListeners(instance);\n  }\n\n  normalizedReturnValue.forEach(applyMutations);\n  return returnValue;\n}\n\nvar animateFill = {\n  name: 'animateFill',\n  defaultValue: false,\n  fn: function fn(instance) {\n    var _instance$props$rende;\n\n    // @ts-ignore\n    if (!((_instance$props$rende = instance.props.render) != null && _instance$props$rende.$$tippy)) {\n      if (process.env.NODE_ENV !== \"production\") {\n        errorWhen(instance.props.animateFill, 'The `animateFill` plugin requires the default render function.');\n      }\n\n      return {};\n    }\n\n    var _getChildren = getChildren(instance.popper),\n        box = _getChildren.box,\n        content = _getChildren.content;\n\n    var backdrop = instance.props.animateFill ? createBackdropElement() : null;\n    return {\n      onCreate: function onCreate() {\n        if (backdrop) {\n          box.insertBefore(backdrop, box.firstElementChild);\n          box.setAttribute('data-animatefill', '');\n          box.style.overflow = 'hidden';\n          instance.setProps({\n            arrow: false,\n            animation: 'shift-away'\n          });\n        }\n      },\n      onMount: function onMount() {\n        if (backdrop) {\n          var transitionDuration = box.style.transitionDuration;\n          var duration = Number(transitionDuration.replace('ms', '')); // The content should fade in after the backdrop has mostly filled the\n          // tooltip element. `clip-path` is the other alternative but is not\n          // well-supported and is buggy on some devices.\n\n          content.style.transitionDelay = Math.round(duration / 10) + \"ms\";\n          backdrop.style.transitionDuration = transitionDuration;\n          setVisibilityState([backdrop], 'visible');\n        }\n      },\n      onShow: function onShow() {\n        if (backdrop) {\n          backdrop.style.transitionDuration = '0ms';\n        }\n      },\n      onHide: function onHide() {\n        if (backdrop) {\n          setVisibilityState([backdrop], 'hidden');\n        }\n      }\n    };\n  }\n};\n\nfunction createBackdropElement() {\n  var backdrop = div();\n  backdrop.className = BACKDROP_CLASS;\n  setVisibilityState([backdrop], 'hidden');\n  return backdrop;\n}\n\nvar mouseCoords = {\n  clientX: 0,\n  clientY: 0\n};\nvar activeInstances = [];\n\nfunction storeMouseCoords(_ref) {\n  var clientX = _ref.clientX,\n      clientY = _ref.clientY;\n  mouseCoords = {\n    clientX: clientX,\n    clientY: clientY\n  };\n}\n\nfunction addMouseCoordsListener(doc) {\n  doc.addEventListener('mousemove', storeMouseCoords);\n}\n\nfunction removeMouseCoordsListener(doc) {\n  doc.removeEventListener('mousemove', storeMouseCoords);\n}\n\nvar followCursor = {\n  name: 'followCursor',\n  defaultValue: false,\n  fn: function fn(instance) {\n    var reference = instance.reference;\n    var doc = getOwnerDocument(instance.props.triggerTarget || reference);\n    var isInternalUpdate = false;\n    var wasFocusEvent = false;\n    var isUnmounted = true;\n    var prevProps = instance.props;\n\n    function getIsInitialBehavior() {\n      return instance.props.followCursor === 'initial' && instance.state.isVisible;\n    }\n\n    function addListener() {\n      doc.addEventListener('mousemove', onMouseMove);\n    }\n\n    function removeListener() {\n      doc.removeEventListener('mousemove', onMouseMove);\n    }\n\n    function unsetGetReferenceClientRect() {\n      isInternalUpdate = true;\n      instance.setProps({\n        getReferenceClientRect: null\n      });\n      isInternalUpdate = false;\n    }\n\n    function onMouseMove(event) {\n      // If the instance is interactive, avoid updating the position unless it's\n      // over the reference element\n      var isCursorOverReference = event.target ? reference.contains(event.target) : true;\n      var followCursor = instance.props.followCursor;\n      var clientX = event.clientX,\n          clientY = event.clientY;\n      var rect = reference.getBoundingClientRect();\n      var relativeX = clientX - rect.left;\n      var relativeY = clientY - rect.top;\n\n      if (isCursorOverReference || !instance.props.interactive) {\n        instance.setProps({\n          // @ts-ignore - unneeded DOMRect properties\n          getReferenceClientRect: function getReferenceClientRect() {\n            var rect = reference.getBoundingClientRect();\n            var x = clientX;\n            var y = clientY;\n\n            if (followCursor === 'initial') {\n              x = rect.left + relativeX;\n              y = rect.top + relativeY;\n            }\n\n            var top = followCursor === 'horizontal' ? rect.top : y;\n            var right = followCursor === 'vertical' ? rect.right : x;\n            var bottom = followCursor === 'horizontal' ? rect.bottom : y;\n            var left = followCursor === 'vertical' ? rect.left : x;\n            return {\n              width: right - left,\n              height: bottom - top,\n              top: top,\n              right: right,\n              bottom: bottom,\n              left: left\n            };\n          }\n        });\n      }\n    }\n\n    function create() {\n      if (instance.props.followCursor) {\n        activeInstances.push({\n          instance: instance,\n          doc: doc\n        });\n        addMouseCoordsListener(doc);\n      }\n    }\n\n    function destroy() {\n      activeInstances = activeInstances.filter(function (data) {\n        return data.instance !== instance;\n      });\n\n      if (activeInstances.filter(function (data) {\n        return data.doc === doc;\n      }).length === 0) {\n        removeMouseCoordsListener(doc);\n      }\n    }\n\n    return {\n      onCreate: create,\n      onDestroy: destroy,\n      onBeforeUpdate: function onBeforeUpdate() {\n        prevProps = instance.props;\n      },\n      onAfterUpdate: function onAfterUpdate(_, _ref2) {\n        var followCursor = _ref2.followCursor;\n\n        if (isInternalUpdate) {\n          return;\n        }\n\n        if (followCursor !== undefined && prevProps.followCursor !== followCursor) {\n          destroy();\n\n          if (followCursor) {\n            create();\n\n            if (instance.state.isMounted && !wasFocusEvent && !getIsInitialBehavior()) {\n              addListener();\n            }\n          } else {\n            removeListener();\n            unsetGetReferenceClientRect();\n          }\n        }\n      },\n      onMount: function onMount() {\n        if (instance.props.followCursor && !wasFocusEvent) {\n          if (isUnmounted) {\n            onMouseMove(mouseCoords);\n            isUnmounted = false;\n          }\n\n          if (!getIsInitialBehavior()) {\n            addListener();\n          }\n        }\n      },\n      onTrigger: function onTrigger(_, event) {\n        if (isMouseEvent(event)) {\n          mouseCoords = {\n            clientX: event.clientX,\n            clientY: event.clientY\n          };\n        }\n\n        wasFocusEvent = event.type === 'focus';\n      },\n      onHidden: function onHidden() {\n        if (instance.props.followCursor) {\n          unsetGetReferenceClientRect();\n          removeListener();\n          isUnmounted = true;\n        }\n      }\n    };\n  }\n};\n\nfunction getProps(props, modifier) {\n  var _props$popperOptions;\n\n  return {\n    popperOptions: Object.assign({}, props.popperOptions, {\n      modifiers: [].concat((((_props$popperOptions = props.popperOptions) == null ? void 0 : _props$popperOptions.modifiers) || []).filter(function (_ref) {\n        var name = _ref.name;\n        return name !== modifier.name;\n      }), [modifier])\n    })\n  };\n}\n\nvar inlinePositioning = {\n  name: 'inlinePositioning',\n  defaultValue: false,\n  fn: function fn(instance) {\n    var reference = instance.reference;\n\n    function isEnabled() {\n      return !!instance.props.inlinePositioning;\n    }\n\n    var placement;\n    var cursorRectIndex = -1;\n    var isInternalUpdate = false;\n    var triedPlacements = [];\n    var modifier = {\n      name: 'tippyInlinePositioning',\n      enabled: true,\n      phase: 'afterWrite',\n      fn: function fn(_ref2) {\n        var state = _ref2.state;\n\n        if (isEnabled()) {\n          if (triedPlacements.indexOf(state.placement) !== -1) {\n            triedPlacements = [];\n          }\n\n          if (placement !== state.placement && triedPlacements.indexOf(state.placement) === -1) {\n            triedPlacements.push(state.placement);\n            instance.setProps({\n              // @ts-ignore - unneeded DOMRect properties\n              getReferenceClientRect: function getReferenceClientRect() {\n                return _getReferenceClientRect(state.placement);\n              }\n            });\n          }\n\n          placement = state.placement;\n        }\n      }\n    };\n\n    function _getReferenceClientRect(placement) {\n      return getInlineBoundingClientRect(getBasePlacement(placement), reference.getBoundingClientRect(), arrayFrom(reference.getClientRects()), cursorRectIndex);\n    }\n\n    function setInternalProps(partialProps) {\n      isInternalUpdate = true;\n      instance.setProps(partialProps);\n      isInternalUpdate = false;\n    }\n\n    function addModifier() {\n      if (!isInternalUpdate) {\n        setInternalProps(getProps(instance.props, modifier));\n      }\n    }\n\n    return {\n      onCreate: addModifier,\n      onAfterUpdate: addModifier,\n      onTrigger: function onTrigger(_, event) {\n        if (isMouseEvent(event)) {\n          var rects = arrayFrom(instance.reference.getClientRects());\n          var cursorRect = rects.find(function (rect) {\n            return rect.left - 2 <= event.clientX && rect.right + 2 >= event.clientX && rect.top - 2 <= event.clientY && rect.bottom + 2 >= event.clientY;\n          });\n          var index = rects.indexOf(cursorRect);\n          cursorRectIndex = index > -1 ? index : cursorRectIndex;\n        }\n      },\n      onHidden: function onHidden() {\n        cursorRectIndex = -1;\n      }\n    };\n  }\n};\nfunction getInlineBoundingClientRect(currentBasePlacement, boundingRect, clientRects, cursorRectIndex) {\n  // Not an inline element, or placement is not yet known\n  if (clientRects.length < 2 || currentBasePlacement === null) {\n    return boundingRect;\n  } // There are two rects and they are disjoined\n\n\n  if (clientRects.length === 2 && cursorRectIndex >= 0 && clientRects[0].left > clientRects[1].right) {\n    return clientRects[cursorRectIndex] || boundingRect;\n  }\n\n  switch (currentBasePlacement) {\n    case 'top':\n    case 'bottom':\n      {\n        var firstRect = clientRects[0];\n        var lastRect = clientRects[clientRects.length - 1];\n        var isTop = currentBasePlacement === 'top';\n        var top = firstRect.top;\n        var bottom = lastRect.bottom;\n        var left = isTop ? firstRect.left : lastRect.left;\n        var right = isTop ? firstRect.right : lastRect.right;\n        var width = right - left;\n        var height = bottom - top;\n        return {\n          top: top,\n          bottom: bottom,\n          left: left,\n          right: right,\n          width: width,\n          height: height\n        };\n      }\n\n    case 'left':\n    case 'right':\n      {\n        var minLeft = Math.min.apply(Math, clientRects.map(function (rects) {\n          return rects.left;\n        }));\n        var maxRight = Math.max.apply(Math, clientRects.map(function (rects) {\n          return rects.right;\n        }));\n        var measureRects = clientRects.filter(function (rect) {\n          return currentBasePlacement === 'left' ? rect.left === minLeft : rect.right === maxRight;\n        });\n        var _top = measureRects[0].top;\n        var _bottom = measureRects[measureRects.length - 1].bottom;\n        var _left = minLeft;\n        var _right = maxRight;\n\n        var _width = _right - _left;\n\n        var _height = _bottom - _top;\n\n        return {\n          top: _top,\n          bottom: _bottom,\n          left: _left,\n          right: _right,\n          width: _width,\n          height: _height\n        };\n      }\n\n    default:\n      {\n        return boundingRect;\n      }\n  }\n}\n\nvar sticky = {\n  name: 'sticky',\n  defaultValue: false,\n  fn: function fn(instance) {\n    var reference = instance.reference,\n        popper = instance.popper;\n\n    function getReference() {\n      return instance.popperInstance ? instance.popperInstance.state.elements.reference : reference;\n    }\n\n    function shouldCheck(value) {\n      return instance.props.sticky === true || instance.props.sticky === value;\n    }\n\n    var prevRefRect = null;\n    var prevPopRect = null;\n\n    function updatePosition() {\n      var currentRefRect = shouldCheck('reference') ? getReference().getBoundingClientRect() : null;\n      var currentPopRect = shouldCheck('popper') ? popper.getBoundingClientRect() : null;\n\n      if (currentRefRect && areRectsDifferent(prevRefRect, currentRefRect) || currentPopRect && areRectsDifferent(prevPopRect, currentPopRect)) {\n        if (instance.popperInstance) {\n          instance.popperInstance.update();\n        }\n      }\n\n      prevRefRect = currentRefRect;\n      prevPopRect = currentPopRect;\n\n      if (instance.state.isMounted) {\n        requestAnimationFrame(updatePosition);\n      }\n    }\n\n    return {\n      onMount: function onMount() {\n        if (instance.props.sticky) {\n          updatePosition();\n        }\n      }\n    };\n  }\n};\n\nfunction areRectsDifferent(rectA, rectB) {\n  if (rectA && rectB) {\n    return rectA.top !== rectB.top || rectA.right !== rectB.right || rectA.bottom !== rectB.bottom || rectA.left !== rectB.left;\n  }\n\n  return true;\n}\n\ntippy.setDefaultProps({\n  render: render\n});\n\nexport default tippy;\nexport { animateFill, createSingleton, delegate, followCursor, hideAll, inlinePositioning, ROUND_ARROW as roundArrow, sticky };\n//# sourceMappingURL=tippy.esm.js.map\n","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \"function\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \"function\") { throw new TypeError(\"Super expression must either be null or a function\"); } if (typeof _cache !== \"undefined\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\nfunction _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\nfunction _isNativeFunction(fn) { try { return Function.toString.call(fn).indexOf(\"[native code]\") !== -1; } catch (e) { return typeof fn === \"function\"; } }\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\nvar DetailedError = /*#__PURE__*/function (_Error) {\n  _inherits(DetailedError, _Error);\n  var _super = _createSuper(DetailedError);\n  function DetailedError(message) {\n    var _this;\n    var causingErr = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n    var req = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n    var res = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n    _classCallCheck(this, DetailedError);\n    _this = _super.call(this, message);\n    _this.originalRequest = req;\n    _this.originalResponse = res;\n    _this.causingError = causingErr;\n    if (causingErr != null) {\n      message += \", caused by \".concat(causingErr.toString());\n    }\n    if (req != null) {\n      var requestId = req.getHeader('X-Request-ID') || 'n/a';\n      var method = req.getMethod();\n      var url = req.getURL();\n      var status = res ? res.getStatus() : 'n/a';\n      var body = res ? res.getBody() || '' : 'n/a';\n      message += \", originated from request (method: \".concat(method, \", url: \").concat(url, \", response code: \").concat(status, \", response text: \").concat(body, \", request id: \").concat(requestId, \")\");\n    }\n    _this.message = message;\n    return _this;\n  }\n  return _createClass(DetailedError);\n}( /*#__PURE__*/_wrapNativeSuper(Error));\nexport default DetailedError;","/* eslint no-console: \"off\" */\n\nvar isEnabled = false;\nexport function enableDebugLog() {\n  isEnabled = true;\n}\nexport function log(msg) {\n  if (!isEnabled) return;\n  console.log(msg);\n}","/**\n * Generate a UUID v4 based on random numbers. We intentioanlly use the less\n * secure Math.random function here since the more secure crypto.getRandomNumbers\n * is not available on all platforms.\n * This is not a problem for us since we use the UUID only for generating a\n * request ID, so we can correlate server logs to client errors.\n *\n * This function is taken from following site:\n * https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript\n *\n * @return {string} The generate UUID\n */\nexport default function uuid() {\n  /* eslint-disable no-bitwise */\n  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n    var r = Math.random() * 16 | 0;\n    var v = c === 'x' ? r : r & 0x3 | 0x8;\n    return v.toString(16);\n  });\n}","function _regeneratorRuntime() { \"use strict\"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return e; }; var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function (t, e, r) { t[e] = r.value; }, i = \"function\" == typeof Symbol ? Symbol : {}, a = i.iterator || \"@@iterator\", c = i.asyncIterator || \"@@asyncIterator\", u = i.toStringTag || \"@@toStringTag\"; function define(t, e, r) { return Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }), t[e]; } try { define({}, \"\"); } catch (t) { define = function define(t, e, r) { return t[e] = r; }; } function wrap(t, e, r, n) { var i = e && e.prototype instanceof Generator ? e : Generator, a = Object.create(i.prototype), c = new Context(n || []); return o(a, \"_invoke\", { value: makeInvokeMethod(t, r, c) }), a; } function tryCatch(t, e, r) { try { return { type: \"normal\", arg: t.call(e, r) }; } catch (t) { return { type: \"throw\", arg: t }; } } e.wrap = wrap; var h = \"suspendedStart\", l = \"suspendedYield\", f = \"executing\", s = \"completed\", y = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var p = {}; define(p, a, function () { return this; }); var d = Object.getPrototypeOf, v = d && d(d(values([]))); v && v !== r && n.call(v, a) && (p = v); var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p); function defineIteratorMethods(t) { [\"next\", \"throw\", \"return\"].forEach(function (e) { define(t, e, function (t) { return this._invoke(e, t); }); }); } function AsyncIterator(t, e) { function invoke(r, o, i, a) { var c = tryCatch(t[r], t, o); if (\"throw\" !== c.type) { var u = c.arg, h = u.value; return h && \"object\" == _typeof(h) && n.call(h, \"__await\") ? e.resolve(h.__await).then(function (t) { invoke(\"next\", t, i, a); }, function (t) { invoke(\"throw\", t, i, a); }) : e.resolve(h).then(function (t) { u.value = t, i(u); }, function (t) { return invoke(\"throw\", t, i, a); }); } a(c.arg); } var r; o(this, \"_invoke\", { value: function value(t, n) { function callInvokeWithMethodAndArg() { return new e(function (e, r) { invoke(t, n, e, r); }); } return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(e, r, n) { var o = h; return function (i, a) { if (o === f) throw new Error(\"Generator is already running\"); if (o === s) { if (\"throw\" === i) throw a; return { value: t, done: !0 }; } for (n.method = i, n.arg = a;;) { var c = n.delegate; if (c) { var u = maybeInvokeDelegate(c, n); if (u) { if (u === y) continue; return u; } } if (\"next\" === n.method) n.sent = n._sent = n.arg;else if (\"throw\" === n.method) { if (o === h) throw o = s, n.arg; n.dispatchException(n.arg); } else \"return\" === n.method && n.abrupt(\"return\", n.arg); o = f; var p = tryCatch(e, r, n); if (\"normal\" === p.type) { if (o = n.done ? s : l, p.arg === y) continue; return { value: p.arg, done: n.done }; } \"throw\" === p.type && (o = s, n.method = \"throw\", n.arg = p.arg); } }; } function maybeInvokeDelegate(e, r) { var n = r.method, o = e.iterator[n]; if (o === t) return r.delegate = null, \"throw\" === n && e.iterator[\"return\"] && (r.method = \"return\", r.arg = t, maybeInvokeDelegate(e, r), \"throw\" === r.method) || \"return\" !== n && (r.method = \"throw\", r.arg = new TypeError(\"The iterator does not provide a '\" + n + \"' method\")), y; var i = tryCatch(o, e.iterator, r.arg); if (\"throw\" === i.type) return r.method = \"throw\", r.arg = i.arg, r.delegate = null, y; var a = i.arg; return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, \"return\" !== r.method && (r.method = \"next\", r.arg = t), r.delegate = null, y) : a : (r.method = \"throw\", r.arg = new TypeError(\"iterator result is not an object\"), r.delegate = null, y); } function pushTryEntry(t) { var e = { tryLoc: t[0] }; 1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e); } function resetTryEntry(t) { var e = t.completion || {}; e.type = \"normal\", delete e.arg, t.completion = e; } function Context(t) { this.tryEntries = [{ tryLoc: \"root\" }], t.forEach(pushTryEntry, this), this.reset(!0); } function values(e) { if (e || \"\" === e) { var r = e[a]; if (r) return r.call(e); if (\"function\" == typeof e.next) return e; if (!isNaN(e.length)) { var o = -1, i = function next() { for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next; return next.value = t, next.done = !0, next; }; return i.next = i; } } throw new TypeError(_typeof(e) + \" is not iterable\"); } return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, \"constructor\", { value: GeneratorFunctionPrototype, configurable: !0 }), o(GeneratorFunctionPrototype, \"constructor\", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, \"GeneratorFunction\"), e.isGeneratorFunction = function (t) { var e = \"function\" == typeof t && t.constructor; return !!e && (e === GeneratorFunction || \"GeneratorFunction\" === (e.displayName || e.name)); }, e.mark = function (t) { return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, \"GeneratorFunction\")), t.prototype = Object.create(g), t; }, e.awrap = function (t) { return { __await: t }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () { return this; }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) { void 0 === i && (i = Promise); var a = new AsyncIterator(wrap(t, r, n, o), i); return e.isGeneratorFunction(r) ? a : a.next().then(function (t) { return t.done ? t.value : a.next(); }); }, defineIteratorMethods(g), define(g, u, \"Generator\"), define(g, a, function () { return this; }), define(g, \"toString\", function () { return \"[object Generator]\"; }), e.keys = function (t) { var e = Object(t), r = []; for (var n in e) r.push(n); return r.reverse(), function next() { for (; r.length;) { var t = r.pop(); if (t in e) return next.value = t, next.done = !1, next; } return next.done = !0, next; }; }, e.values = values, Context.prototype = { constructor: Context, reset: function reset(e) { if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = \"next\", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) \"t\" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t); }, stop: function stop() { this.done = !0; var t = this.tryEntries[0].completion; if (\"throw\" === t.type) throw t.arg; return this.rval; }, dispatchException: function dispatchException(e) { if (this.done) throw e; var r = this; function handle(n, o) { return a.type = \"throw\", a.arg = e, r.next = n, o && (r.method = \"next\", r.arg = t), !!o; } for (var o = this.tryEntries.length - 1; o >= 0; --o) { var i = this.tryEntries[o], a = i.completion; if (\"root\" === i.tryLoc) return handle(\"end\"); if (i.tryLoc <= this.prev) { var c = n.call(i, \"catchLoc\"), u = n.call(i, \"finallyLoc\"); if (c && u) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } else if (c) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); } else { if (!u) throw new Error(\"try statement without catch or finally\"); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } } } }, abrupt: function abrupt(t, e) { for (var r = this.tryEntries.length - 1; r >= 0; --r) { var o = this.tryEntries[r]; if (o.tryLoc <= this.prev && n.call(o, \"finallyLoc\") && this.prev < o.finallyLoc) { var i = o; break; } } i && (\"break\" === t || \"continue\" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null); var a = i ? i.completion : {}; return a.type = t, a.arg = e, i ? (this.method = \"next\", this.next = i.finallyLoc, y) : this.complete(a); }, complete: function complete(t, e) { if (\"throw\" === t.type) throw t.arg; return \"break\" === t.type || \"continue\" === t.type ? this.next = t.arg : \"return\" === t.type ? (this.rval = this.arg = t.arg, this.method = \"return\", this.next = \"end\") : \"normal\" === t.type && e && (this.next = e), y; }, finish: function finish(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y; } }, \"catch\": function _catch(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.tryLoc === t) { var n = r.completion; if (\"throw\" === n.type) { var o = n.arg; resetTryEntry(r); } return o; } } throw new Error(\"illegal catch attempt\"); }, delegateYield: function delegateYield(e, r, n) { return this.delegate = { iterator: values(e), resultName: r, nextLoc: n }, \"next\" === this.method && (this.arg = t), y; } }, e; }\nfunction asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }\nfunction _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err); } _next(undefined); }); }; }\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nfunction _iterableToArrayLimit(r, l) { var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t[\"return\"] && (u = t[\"return\"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nfunction _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport { Base64 } from 'js-base64';\nimport URL from 'url-parse';\nimport DetailedError from './error.js';\nimport { log } from './logger.js';\nimport uuid from './uuid.js';\nvar defaultOptions = {\n  endpoint: null,\n  uploadUrl: null,\n  metadata: {},\n  fingerprint: null,\n  uploadSize: null,\n  onProgress: null,\n  onChunkComplete: null,\n  onSuccess: null,\n  onError: null,\n  onUploadUrlAvailable: null,\n  overridePatchMethod: false,\n  headers: {},\n  addRequestId: false,\n  onBeforeRequest: null,\n  onAfterResponse: null,\n  onShouldRetry: defaultOnShouldRetry,\n  chunkSize: Infinity,\n  retryDelays: [0, 1000, 3000, 5000],\n  parallelUploads: 1,\n  parallelUploadBoundaries: null,\n  storeFingerprintForResuming: true,\n  removeFingerprintOnSuccess: false,\n  uploadLengthDeferred: false,\n  uploadDataDuringCreation: false,\n  urlStorage: null,\n  fileReader: null,\n  httpStack: null\n};\nvar BaseUpload = /*#__PURE__*/function () {\n  function BaseUpload(file, options) {\n    _classCallCheck(this, BaseUpload);\n    // Warn about removed options from previous versions\n    if ('resume' in options) {\n      // eslint-disable-next-line no-console\n      console.log('tus: The `resume` option has been removed in tus-js-client v2. Please use the URL storage API instead.');\n    }\n\n    // The default options will already be added from the wrapper classes.\n    this.options = options;\n\n    // Cast chunkSize to integer\n    this.options.chunkSize = Number(this.options.chunkSize);\n\n    // The storage module used to store URLs\n    this._urlStorage = this.options.urlStorage;\n\n    // The underlying File/Blob object\n    this.file = file;\n\n    // The URL against which the file will be uploaded\n    this.url = null;\n\n    // The underlying request object for the current PATCH request\n    this._req = null;\n\n    // The fingerpinrt for the current file (set after start())\n    this._fingerprint = null;\n\n    // The key that the URL storage returned when saving an URL with a fingerprint,\n    this._urlStorageKey = null;\n\n    // The offset used in the current PATCH request\n    this._offset = null;\n\n    // True if the current PATCH request has been aborted\n    this._aborted = false;\n\n    // The file's size in bytes\n    this._size = null;\n\n    // The Source object which will wrap around the given file and provides us\n    // with a unified interface for getting its size and slice chunks from its\n    // content allowing us to easily handle Files, Blobs, Buffers and Streams.\n    this._source = null;\n\n    // The current count of attempts which have been made. Zero indicates none.\n    this._retryAttempt = 0;\n\n    // The timeout's ID which is used to delay the next retry\n    this._retryTimeout = null;\n\n    // The offset of the remote upload before the latest attempt was started.\n    this._offsetBeforeRetry = 0;\n\n    // An array of BaseUpload instances which are used for uploading the different\n    // parts, if the parallelUploads option is used.\n    this._parallelUploads = null;\n\n    // An array of upload URLs which are used for uploading the different\n    // parts, if the parallelUploads option is used.\n    this._parallelUploadUrls = null;\n  }\n\n  /**\n   * Use the Termination extension to delete an upload from the server by sending a DELETE\n   * request to the specified upload URL. This is only possible if the server supports the\n   * Termination extension. If the `options.retryDelays` property is set, the method will\n   * also retry if an error ocurrs.\n   *\n   * @param {String} url The upload's URL which will be terminated.\n   * @param {object} options Optional options for influencing HTTP requests.\n   * @return {Promise} The Promise will be resolved/rejected when the requests finish.\n   */\n  _createClass(BaseUpload, [{\n    key: \"findPreviousUploads\",\n    value: function findPreviousUploads() {\n      var _this = this;\n      return this.options.fingerprint(this.file, this.options).then(function (fingerprint) {\n        return _this._urlStorage.findUploadsByFingerprint(fingerprint);\n      });\n    }\n  }, {\n    key: \"resumeFromPreviousUpload\",\n    value: function resumeFromPreviousUpload(previousUpload) {\n      this.url = previousUpload.uploadUrl || null;\n      this._parallelUploadUrls = previousUpload.parallelUploadUrls || null;\n      this._urlStorageKey = previousUpload.urlStorageKey;\n    }\n  }, {\n    key: \"start\",\n    value: function start() {\n      var _this2 = this;\n      var file = this.file;\n      if (!file) {\n        this._emitError(new Error('tus: no file or stream to upload provided'));\n        return;\n      }\n      if (!this.options.endpoint && !this.options.uploadUrl && !this.url) {\n        this._emitError(new Error('tus: neither an endpoint or an upload URL is provided'));\n        return;\n      }\n      var retryDelays = this.options.retryDelays;\n      if (retryDelays != null && Object.prototype.toString.call(retryDelays) !== '[object Array]') {\n        this._emitError(new Error('tus: the `retryDelays` option must either be an array or null'));\n        return;\n      }\n      if (this.options.parallelUploads > 1) {\n        // Test which options are incompatible with parallel uploads.\n        for (var _i = 0, _arr = ['uploadUrl', 'uploadSize', 'uploadLengthDeferred']; _i < _arr.length; _i++) {\n          var optionName = _arr[_i];\n          if (this.options[optionName]) {\n            this._emitError(new Error(\"tus: cannot use the \".concat(optionName, \" option when parallelUploads is enabled\")));\n            return;\n          }\n        }\n      }\n      if (this.options.parallelUploadBoundaries) {\n        if (this.options.parallelUploads <= 1) {\n          this._emitError(new Error('tus: cannot use the `parallelUploadBoundaries` option when `parallelUploads` is disabled'));\n          return;\n        }\n        if (this.options.parallelUploads !== this.options.parallelUploadBoundaries.length) {\n          this._emitError(new Error('tus: the `parallelUploadBoundaries` must have the same length as the value of `parallelUploads`'));\n          return;\n        }\n      }\n      this.options.fingerprint(file, this.options).then(function (fingerprint) {\n        if (fingerprint == null) {\n          log('No fingerprint was calculated meaning that the upload cannot be stored in the URL storage.');\n        } else {\n          log(\"Calculated fingerprint: \".concat(fingerprint));\n        }\n        _this2._fingerprint = fingerprint;\n        if (_this2._source) {\n          return _this2._source;\n        }\n        return _this2.options.fileReader.openFile(file, _this2.options.chunkSize);\n      }).then(function (source) {\n        _this2._source = source;\n\n        // First, we look at the uploadLengthDeferred option.\n        // Next, we check if the caller has supplied a manual upload size.\n        // Finally, we try to use the calculated size from the source object.\n        if (_this2.options.uploadLengthDeferred) {\n          _this2._size = null;\n        } else if (_this2.options.uploadSize != null) {\n          _this2._size = Number(_this2.options.uploadSize);\n          if (Number.isNaN(_this2._size)) {\n            _this2._emitError(new Error('tus: cannot convert `uploadSize` option into a number'));\n            return;\n          }\n        } else {\n          _this2._size = _this2._source.size;\n          if (_this2._size == null) {\n            _this2._emitError(new Error(\"tus: cannot automatically derive upload's size from input. Specify it manually using the `uploadSize` option or use the `uploadLengthDeferred` option\"));\n            return;\n          }\n        }\n\n        // If the upload was configured to use multiple requests or if we resume from\n        // an upload which used multiple requests, we start a parallel upload.\n        if (_this2.options.parallelUploads > 1 || _this2._parallelUploadUrls != null) {\n          _this2._startParallelUpload();\n        } else {\n          _this2._startSingleUpload();\n        }\n      })[\"catch\"](function (err) {\n        _this2._emitError(err);\n      });\n    }\n\n    /**\n     * Initiate the uploading procedure for a parallelized upload, where one file is split into\n     * multiple request which are run in parallel.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_startParallelUpload\",\n    value: function _startParallelUpload() {\n      var _this$options$paralle,\n        _this3 = this;\n      var totalSize = this._size;\n      var totalProgress = 0;\n      this._parallelUploads = [];\n      var partCount = this._parallelUploadUrls != null ? this._parallelUploadUrls.length : this.options.parallelUploads;\n\n      // The input file will be split into multiple slices which are uploaded in separate\n      // requests. Here we get the start and end position for the slices.\n      var parts = (_this$options$paralle = this.options.parallelUploadBoundaries) !== null && _this$options$paralle !== void 0 ? _this$options$paralle : splitSizeIntoParts(this._source.size, partCount);\n\n      // Attach URLs from previous uploads, if available.\n      if (this._parallelUploadUrls) {\n        parts.forEach(function (part, index) {\n          part.uploadUrl = _this3._parallelUploadUrls[index] || null;\n        });\n      }\n\n      // Create an empty list for storing the upload URLs\n      this._parallelUploadUrls = new Array(parts.length);\n\n      // Generate a promise for each slice that will be resolve if the respective\n      // upload is completed.\n      var uploads = parts.map(function (part, index) {\n        var lastPartProgress = 0;\n        return _this3._source.slice(part.start, part.end).then(function (_ref) {\n          var value = _ref.value;\n          return new Promise(function (resolve, reject) {\n            // Merge with the user supplied options but overwrite some values.\n            var options = _objectSpread(_objectSpread({}, _this3.options), {}, {\n              // If available, the partial upload should be resumed from a previous URL.\n              uploadUrl: part.uploadUrl || null,\n              // We take manually care of resuming for partial uploads, so they should\n              // not be stored in the URL storage.\n              storeFingerprintForResuming: false,\n              removeFingerprintOnSuccess: false,\n              // Reset the parallelUploads option to not cause recursion.\n              parallelUploads: 1,\n              // Reset this option as we are not doing a parallel upload.\n              parallelUploadBoundaries: null,\n              metadata: {},\n              // Add the header to indicate the this is a partial upload.\n              headers: _objectSpread(_objectSpread({}, _this3.options.headers), {}, {\n                'Upload-Concat': 'partial'\n              }),\n              // Reject or resolve the promise if the upload errors or completes.\n              onSuccess: resolve,\n              onError: reject,\n              // Based in the progress for this partial upload, calculate the progress\n              // for the entire final upload.\n              onProgress: function onProgress(newPartProgress) {\n                totalProgress = totalProgress - lastPartProgress + newPartProgress;\n                lastPartProgress = newPartProgress;\n                _this3._emitProgress(totalProgress, totalSize);\n              },\n              // Wait until every partial upload has an upload URL, so we can add\n              // them to the URL storage.\n              onUploadUrlAvailable: function onUploadUrlAvailable() {\n                _this3._parallelUploadUrls[index] = upload.url;\n                // Test if all uploads have received an URL\n                if (_this3._parallelUploadUrls.filter(function (u) {\n                  return Boolean(u);\n                }).length === parts.length) {\n                  _this3._saveUploadInUrlStorage();\n                }\n              }\n            });\n            var upload = new BaseUpload(value, options);\n            upload.start();\n\n            // Store the upload in an array, so we can later abort them if necessary.\n            _this3._parallelUploads.push(upload);\n          });\n        });\n      });\n      var req;\n      // Wait until all partial uploads are finished and we can send the POST request for\n      // creating the final upload.\n      Promise.all(uploads).then(function () {\n        req = _this3._openRequest('POST', _this3.options.endpoint);\n        req.setHeader('Upload-Concat', \"final;\".concat(_this3._parallelUploadUrls.join(' ')));\n\n        // Add metadata if values have been added\n        var metadata = encodeMetadata(_this3.options.metadata);\n        if (metadata !== '') {\n          req.setHeader('Upload-Metadata', metadata);\n        }\n        return _this3._sendRequest(req, null);\n      }).then(function (res) {\n        if (!inStatusCategory(res.getStatus(), 200)) {\n          _this3._emitHttpError(req, res, 'tus: unexpected response while creating upload');\n          return;\n        }\n        var location = res.getHeader('Location');\n        if (location == null) {\n          _this3._emitHttpError(req, res, 'tus: invalid or missing Location header');\n          return;\n        }\n        _this3.url = resolveUrl(_this3.options.endpoint, location);\n        log(\"Created upload at \".concat(_this3.url));\n        _this3._emitSuccess();\n      })[\"catch\"](function (err) {\n        _this3._emitError(err);\n      });\n    }\n\n    /**\n     * Initiate the uploading procedure for a non-parallel upload. Here the entire file is\n     * uploaded in a sequential matter.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_startSingleUpload\",\n    value: function _startSingleUpload() {\n      // Reset the aborted flag when the upload is started or else the\n      // _performUpload will stop before sending a request if the upload has been\n      // aborted previously.\n      this._aborted = false;\n\n      // The upload had been started previously and we should reuse this URL.\n      if (this.url != null) {\n        log(\"Resuming upload from previous URL: \".concat(this.url));\n        this._resumeUpload();\n        return;\n      }\n\n      // A URL has manually been specified, so we try to resume\n      if (this.options.uploadUrl != null) {\n        log(\"Resuming upload from provided URL: \".concat(this.options.uploadUrl));\n        this.url = this.options.uploadUrl;\n        this._resumeUpload();\n        return;\n      }\n\n      // An upload has not started for the file yet, so we start a new one\n      log('Creating a new upload');\n      this._createUpload();\n    }\n\n    /**\n     * Abort any running request and stop the current upload. After abort is called, no event\n     * handler will be invoked anymore. You can use the `start` method to resume the upload\n     * again.\n     * If `shouldTerminate` is true, the `terminate` function will be called to remove the\n     * current upload from the server.\n     *\n     * @param {boolean} shouldTerminate True if the upload should be deleted from the server.\n     * @return {Promise} The Promise will be resolved/rejected when the requests finish.\n     */\n  }, {\n    key: \"abort\",\n    value: function abort(shouldTerminate) {\n      var _this4 = this;\n      // Stop any parallel partial uploads, that have been started in _startParallelUploads.\n      if (this._parallelUploads != null) {\n        this._parallelUploads.forEach(function (upload) {\n          upload.abort(shouldTerminate);\n        });\n      }\n\n      // Stop any current running request.\n      if (this._req !== null) {\n        this._req.abort();\n        // Note: We do not close the file source here, so the user can resume in the future.\n      }\n      this._aborted = true;\n\n      // Stop any timeout used for initiating a retry.\n      if (this._retryTimeout != null) {\n        clearTimeout(this._retryTimeout);\n        this._retryTimeout = null;\n      }\n      if (!shouldTerminate || this.url == null) {\n        return Promise.resolve();\n      }\n      return BaseUpload.terminate(this.url, this.options)\n      // Remove entry from the URL storage since the upload URL is no longer valid.\n      .then(function () {\n        return _this4._removeFromUrlStorage();\n      });\n    }\n  }, {\n    key: \"_emitHttpError\",\n    value: function _emitHttpError(req, res, message, causingErr) {\n      this._emitError(new DetailedError(message, causingErr, req, res));\n    }\n  }, {\n    key: \"_emitError\",\n    value: function _emitError(err) {\n      var _this5 = this;\n      // Do not emit errors, e.g. from aborted HTTP requests, if the upload has been stopped.\n      if (this._aborted) return;\n\n      // Check if we should retry, when enabled, before sending the error to the user.\n      if (this.options.retryDelays != null) {\n        // We will reset the attempt counter if\n        // - we were already able to connect to the server (offset != null) and\n        // - we were able to upload a small chunk of data to the server\n        var shouldResetDelays = this._offset != null && this._offset > this._offsetBeforeRetry;\n        if (shouldResetDelays) {\n          this._retryAttempt = 0;\n        }\n        if (shouldRetry(err, this._retryAttempt, this.options)) {\n          var delay = this.options.retryDelays[this._retryAttempt++];\n          this._offsetBeforeRetry = this._offset;\n          this._retryTimeout = setTimeout(function () {\n            _this5.start();\n          }, delay);\n          return;\n        }\n      }\n      if (typeof this.options.onError === 'function') {\n        this.options.onError(err);\n      } else {\n        throw err;\n      }\n    }\n\n    /**\n     * Publishes notification if the upload has been successfully completed.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_emitSuccess\",\n    value: function _emitSuccess() {\n      if (this.options.removeFingerprintOnSuccess) {\n        // Remove stored fingerprint and corresponding endpoint. This causes\n        // new uploads of the same file to be treated as a different file.\n        this._removeFromUrlStorage();\n      }\n      if (typeof this.options.onSuccess === 'function') {\n        this.options.onSuccess();\n      }\n    }\n\n    /**\n     * Publishes notification when data has been sent to the server. This\n     * data may not have been accepted by the server yet.\n     *\n     * @param {number} bytesSent  Number of bytes sent to the server.\n     * @param {number} bytesTotal Total number of bytes to be sent to the server.\n     * @api private\n     */\n  }, {\n    key: \"_emitProgress\",\n    value: function _emitProgress(bytesSent, bytesTotal) {\n      if (typeof this.options.onProgress === 'function') {\n        this.options.onProgress(bytesSent, bytesTotal);\n      }\n    }\n\n    /**\n     * Publishes notification when a chunk of data has been sent to the server\n     * and accepted by the server.\n     * @param {number} chunkSize  Size of the chunk that was accepted by the server.\n     * @param {number} bytesAccepted Total number of bytes that have been\n     *                                accepted by the server.\n     * @param {number} bytesTotal Total number of bytes to be sent to the server.\n     * @api private\n     */\n  }, {\n    key: \"_emitChunkComplete\",\n    value: function _emitChunkComplete(chunkSize, bytesAccepted, bytesTotal) {\n      if (typeof this.options.onChunkComplete === 'function') {\n        this.options.onChunkComplete(chunkSize, bytesAccepted, bytesTotal);\n      }\n    }\n\n    /**\n     * Create a new upload using the creation extension by sending a POST\n     * request to the endpoint. After successful creation the file will be\n     * uploaded\n     *\n     * @api private\n     */\n  }, {\n    key: \"_createUpload\",\n    value: function _createUpload() {\n      var _this6 = this;\n      if (!this.options.endpoint) {\n        this._emitError(new Error('tus: unable to create upload because no endpoint is provided'));\n        return;\n      }\n      var req = this._openRequest('POST', this.options.endpoint);\n      if (this.options.uploadLengthDeferred) {\n        req.setHeader('Upload-Defer-Length', 1);\n      } else {\n        req.setHeader('Upload-Length', this._size);\n      }\n\n      // Add metadata if values have been added\n      var metadata = encodeMetadata(this.options.metadata);\n      if (metadata !== '') {\n        req.setHeader('Upload-Metadata', metadata);\n      }\n      var promise;\n      if (this.options.uploadDataDuringCreation && !this.options.uploadLengthDeferred) {\n        this._offset = 0;\n        promise = this._addChunkToRequest(req);\n      } else {\n        promise = this._sendRequest(req, null);\n      }\n      promise.then(function (res) {\n        if (!inStatusCategory(res.getStatus(), 200)) {\n          _this6._emitHttpError(req, res, 'tus: unexpected response while creating upload');\n          return;\n        }\n        var location = res.getHeader('Location');\n        if (location == null) {\n          _this6._emitHttpError(req, res, 'tus: invalid or missing Location header');\n          return;\n        }\n        _this6.url = resolveUrl(_this6.options.endpoint, location);\n        log(\"Created upload at \".concat(_this6.url));\n        if (typeof _this6.options.onUploadUrlAvailable === 'function') {\n          _this6.options.onUploadUrlAvailable();\n        }\n        if (_this6._size === 0) {\n          // Nothing to upload and file was successfully created\n          _this6._emitSuccess();\n          _this6._source.close();\n          return;\n        }\n        _this6._saveUploadInUrlStorage().then(function () {\n          if (_this6.options.uploadDataDuringCreation) {\n            _this6._handleUploadResponse(req, res);\n          } else {\n            _this6._offset = 0;\n            _this6._performUpload();\n          }\n        });\n      })[\"catch\"](function (err) {\n        _this6._emitHttpError(req, null, 'tus: failed to create upload', err);\n      });\n    }\n\n    /*\n     * Try to resume an existing upload. First a HEAD request will be sent\n     * to retrieve the offset. If the request fails a new upload will be\n     * created. In the case of a successful response the file will be uploaded.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_resumeUpload\",\n    value: function _resumeUpload() {\n      var _this7 = this;\n      var req = this._openRequest('HEAD', this.url);\n      var promise = this._sendRequest(req, null);\n      promise.then(function (res) {\n        var status = res.getStatus();\n        if (!inStatusCategory(status, 200)) {\n          // If the upload is locked (indicated by the 423 Locked status code), we\n          // emit an error instead of directly starting a new upload. This way the\n          // retry logic can catch the error and will retry the upload. An upload\n          // is usually locked for a short period of time and will be available\n          // afterwards.\n          if (status === 423) {\n            _this7._emitHttpError(req, res, 'tus: upload is currently locked; retry later');\n            return;\n          }\n          if (inStatusCategory(status, 400)) {\n            // Remove stored fingerprint and corresponding endpoint,\n            // on client errors since the file can not be found\n            _this7._removeFromUrlStorage();\n          }\n          if (!_this7.options.endpoint) {\n            // Don't attempt to create a new upload if no endpoint is provided.\n            _this7._emitHttpError(req, res, 'tus: unable to resume upload (new upload cannot be created without an endpoint)');\n            return;\n          }\n\n          // Try to create a new upload\n          _this7.url = null;\n          _this7._createUpload();\n          return;\n        }\n        var offset = parseInt(res.getHeader('Upload-Offset'), 10);\n        if (Number.isNaN(offset)) {\n          _this7._emitHttpError(req, res, 'tus: invalid or missing offset value');\n          return;\n        }\n        var length = parseInt(res.getHeader('Upload-Length'), 10);\n        if (Number.isNaN(length) && !_this7.options.uploadLengthDeferred) {\n          _this7._emitHttpError(req, res, 'tus: invalid or missing length value');\n          return;\n        }\n        if (typeof _this7.options.onUploadUrlAvailable === 'function') {\n          _this7.options.onUploadUrlAvailable();\n        }\n        _this7._saveUploadInUrlStorage().then(function () {\n          // Upload has already been completed and we do not need to send additional\n          // data to the server\n          if (offset === length) {\n            _this7._emitProgress(length, length);\n            _this7._emitSuccess();\n            return;\n          }\n          _this7._offset = offset;\n          _this7._performUpload();\n        });\n      })[\"catch\"](function (err) {\n        _this7._emitHttpError(req, null, 'tus: failed to resume upload', err);\n      });\n    }\n\n    /**\n     * Start uploading the file using PATCH requests. The file will be divided\n     * into chunks as specified in the chunkSize option. During the upload\n     * the onProgress event handler may be invoked multiple times.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_performUpload\",\n    value: function _performUpload() {\n      var _this8 = this;\n      // If the upload has been aborted, we will not send the next PATCH request.\n      // This is important if the abort method was called during a callback, such\n      // as onChunkComplete or onProgress.\n      if (this._aborted) {\n        return;\n      }\n      var req;\n\n      // Some browser and servers may not support the PATCH method. For those\n      // cases, you can tell tus-js-client to use a POST request with the\n      // X-HTTP-Method-Override header for simulating a PATCH request.\n      if (this.options.overridePatchMethod) {\n        req = this._openRequest('POST', this.url);\n        req.setHeader('X-HTTP-Method-Override', 'PATCH');\n      } else {\n        req = this._openRequest('PATCH', this.url);\n      }\n      req.setHeader('Upload-Offset', this._offset);\n      var promise = this._addChunkToRequest(req);\n      promise.then(function (res) {\n        if (!inStatusCategory(res.getStatus(), 200)) {\n          _this8._emitHttpError(req, res, 'tus: unexpected response while uploading chunk');\n          return;\n        }\n        _this8._handleUploadResponse(req, res);\n      })[\"catch\"](function (err) {\n        // Don't emit an error if the upload was aborted manually\n        if (_this8._aborted) {\n          return;\n        }\n        _this8._emitHttpError(req, null, \"tus: failed to upload chunk at offset \".concat(_this8._offset), err);\n      });\n    }\n\n    /**\n     * _addChunktoRequest reads a chunk from the source and sends it using the\n     * supplied request object. It will not handle the response.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_addChunkToRequest\",\n    value: function _addChunkToRequest(req) {\n      var _this9 = this;\n      var start = this._offset;\n      var end = this._offset + this.options.chunkSize;\n      req.setProgressHandler(function (bytesSent) {\n        _this9._emitProgress(start + bytesSent, _this9._size);\n      });\n      req.setHeader('Content-Type', 'application/offset+octet-stream');\n\n      // The specified chunkSize may be Infinity or the calcluated end position\n      // may exceed the file's size. In both cases, we limit the end position to\n      // the input's total size for simpler calculations and correctness.\n      if ((end === Infinity || end > this._size) && !this.options.uploadLengthDeferred) {\n        end = this._size;\n      }\n      return this._source.slice(start, end).then(function (_ref2) {\n        var value = _ref2.value,\n          done = _ref2.done;\n        var valueSize = value && value.size ? value.size : 0;\n\n        // If the upload length is deferred, the upload size was not specified during\n        // upload creation. So, if the file reader is done reading, we know the total\n        // upload size and can tell the tus server.\n        if (_this9.options.uploadLengthDeferred && done) {\n          _this9._size = _this9._offset + valueSize;\n          req.setHeader('Upload-Length', _this9._size);\n        }\n\n        // The specified uploadSize might not match the actual amount of data that a source\n        // provides. In these cases, we cannot successfully complete the upload, so we\n        // rather error out and let the user know. If not, tus-js-client will be stuck\n        // in a loop of repeating empty PATCH requests.\n        // See https://community.transloadit.com/t/how-to-abort-hanging-companion-uploads/16488/13\n        var newSize = _this9._offset + valueSize;\n        if (!_this9.options.uploadLengthDeferred && done && newSize !== _this9._size) {\n          return Promise.reject(new Error(\"upload was configured with a size of \".concat(_this9._size, \" bytes, but the source is done after \").concat(newSize, \" bytes\")));\n        }\n        if (value === null) {\n          return _this9._sendRequest(req);\n        }\n        _this9._emitProgress(_this9._offset, _this9._size);\n        return _this9._sendRequest(req, value);\n      });\n    }\n\n    /**\n     * _handleUploadResponse is used by requests that haven been sent using _addChunkToRequest\n     * and already have received a response.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_handleUploadResponse\",\n    value: function _handleUploadResponse(req, res) {\n      var offset = parseInt(res.getHeader('Upload-Offset'), 10);\n      if (Number.isNaN(offset)) {\n        this._emitHttpError(req, res, 'tus: invalid or missing offset value');\n        return;\n      }\n      this._emitProgress(offset, this._size);\n      this._emitChunkComplete(offset - this._offset, offset, this._size);\n      this._offset = offset;\n      if (offset === this._size) {\n        // Yay, finally done :)\n        this._emitSuccess();\n        this._source.close();\n        return;\n      }\n      this._performUpload();\n    }\n\n    /**\n     * Create a new HTTP request object with the given method and URL.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_openRequest\",\n    value: function _openRequest(method, url) {\n      var req = openRequest(method, url, this.options);\n      this._req = req;\n      return req;\n    }\n\n    /**\n     * Remove the entry in the URL storage, if it has been saved before.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_removeFromUrlStorage\",\n    value: function _removeFromUrlStorage() {\n      var _this10 = this;\n      if (!this._urlStorageKey) return;\n      this._urlStorage.removeUpload(this._urlStorageKey)[\"catch\"](function (err) {\n        _this10._emitError(err);\n      });\n      this._urlStorageKey = null;\n    }\n\n    /**\n     * Add the upload URL to the URL storage, if possible.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_saveUploadInUrlStorage\",\n    value: function _saveUploadInUrlStorage() {\n      var _this11 = this;\n      // We do not store the upload URL\n      // - if it was disabled in the option, or\n      // - if no fingerprint was calculated for the input (i.e. a stream), or\n      // - if the URL is already stored (i.e. key is set alread).\n      if (!this.options.storeFingerprintForResuming || !this._fingerprint || this._urlStorageKey !== null) {\n        return Promise.resolve();\n      }\n      var storedUpload = {\n        size: this._size,\n        metadata: this.options.metadata,\n        creationTime: new Date().toString()\n      };\n      if (this._parallelUploads) {\n        // Save multiple URLs if the parallelUploads option is used ...\n        storedUpload.parallelUploadUrls = this._parallelUploadUrls;\n      } else {\n        // ... otherwise we just save the one available URL.\n        storedUpload.uploadUrl = this.url;\n      }\n      return this._urlStorage.addUpload(this._fingerprint, storedUpload).then(function (urlStorageKey) {\n        _this11._urlStorageKey = urlStorageKey;\n      });\n    }\n\n    /**\n     * Send a request with the provided body.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_sendRequest\",\n    value: function _sendRequest(req) {\n      var body = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n      return sendRequest(req, body, this.options);\n    }\n  }], [{\n    key: \"terminate\",\n    value: function terminate(url) {\n      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      var req = openRequest('DELETE', url, options);\n      return sendRequest(req, null, options).then(function (res) {\n        // A 204 response indicates a successfull request\n        if (res.getStatus() === 204) {\n          return;\n        }\n        throw new DetailedError('tus: unexpected response while terminating upload', null, req, res);\n      })[\"catch\"](function (err) {\n        if (!(err instanceof DetailedError)) {\n          err = new DetailedError('tus: failed to terminate upload', err, req, null);\n        }\n        if (!shouldRetry(err, 0, options)) {\n          throw err;\n        }\n\n        // Instead of keeping track of the retry attempts, we remove the first element from the delays\n        // array. If the array is empty, all retry attempts are used up and we will bubble up the error.\n        // We recursively call the terminate function will removing elements from the retryDelays array.\n        var delay = options.retryDelays[0];\n        var remainingDelays = options.retryDelays.slice(1);\n        var newOptions = _objectSpread(_objectSpread({}, options), {}, {\n          retryDelays: remainingDelays\n        });\n        return new Promise(function (resolve) {\n          return setTimeout(resolve, delay);\n        }).then(function () {\n          return BaseUpload.terminate(url, newOptions);\n        });\n      });\n    }\n  }]);\n  return BaseUpload;\n}();\nfunction encodeMetadata(metadata) {\n  return Object.entries(metadata).map(function (_ref3) {\n    var _ref4 = _slicedToArray(_ref3, 2),\n      key = _ref4[0],\n      value = _ref4[1];\n    return \"\".concat(key, \" \").concat(Base64.encode(String(value)));\n  }).join(',');\n}\n\n/**\n * Checks whether a given status is in the range of the expected category.\n * For example, only a status between 200 and 299 will satisfy the category 200.\n *\n * @api private\n */\nfunction inStatusCategory(status, category) {\n  return status >= category && status < category + 100;\n}\n\n/**\n * Create a new HTTP request with the specified method and URL.\n * The necessary headers that are included in every request\n * will be added, including the request ID.\n *\n * @api private\n */\nfunction openRequest(method, url, options) {\n  var req = options.httpStack.createRequest(method, url);\n  req.setHeader('Tus-Resumable', '1.0.0');\n  var headers = options.headers || {};\n  Object.entries(headers).forEach(function (_ref5) {\n    var _ref6 = _slicedToArray(_ref5, 2),\n      name = _ref6[0],\n      value = _ref6[1];\n    req.setHeader(name, value);\n  });\n  if (options.addRequestId) {\n    var requestId = uuid();\n    req.setHeader('X-Request-ID', requestId);\n  }\n  return req;\n}\n\n/**\n * Send a request with the provided body while invoking the onBeforeRequest\n * and onAfterResponse callbacks.\n *\n * @api private\n */\nfunction sendRequest(_x, _x2, _x3) {\n  return _sendRequest2.apply(this, arguments);\n}\n/**\n * Checks whether the browser running this code has internet access.\n * This function will always return true in the node.js environment\n *\n * @api private\n */\nfunction _sendRequest2() {\n  _sendRequest2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(req, body, options) {\n    var res;\n    return _regeneratorRuntime().wrap(function _callee$(_context) {\n      while (1) switch (_context.prev = _context.next) {\n        case 0:\n          if (!(typeof options.onBeforeRequest === 'function')) {\n            _context.next = 3;\n            break;\n          }\n          _context.next = 3;\n          return options.onBeforeRequest(req);\n        case 3:\n          _context.next = 5;\n          return req.send(body);\n        case 5:\n          res = _context.sent;\n          if (!(typeof options.onAfterResponse === 'function')) {\n            _context.next = 9;\n            break;\n          }\n          _context.next = 9;\n          return options.onAfterResponse(req, res);\n        case 9:\n          return _context.abrupt(\"return\", res);\n        case 10:\n        case \"end\":\n          return _context.stop();\n      }\n    }, _callee);\n  }));\n  return _sendRequest2.apply(this, arguments);\n}\nfunction isOnline() {\n  var online = true;\n  if (typeof window !== 'undefined' &&\n  // eslint-disable-next-line no-undef\n  'navigator' in window &&\n  // eslint-disable-next-line no-undef\n  window.navigator.onLine === false) {\n    // eslint-disable-line no-undef\n    online = false;\n  }\n  return online;\n}\n\n/**\n * Checks whether or not it is ok to retry a request.\n * @param {Error|DetailedError} err the error returned from the last request\n * @param {number} retryAttempt the number of times the request has already been retried\n * @param {object} options tus Upload options\n *\n * @api private\n */\nfunction shouldRetry(err, retryAttempt, options) {\n  // We only attempt a retry if\n  // - retryDelays option is set\n  // - we didn't exceed the maxium number of retries, yet, and\n  // - this error was caused by a request or it's response and\n  // - the error is server error (i.e. not a status 4xx except a 409 or 423) or\n  // a onShouldRetry is specified and returns true\n  // - the browser does not indicate that we are offline\n  if (options.retryDelays == null || retryAttempt >= options.retryDelays.length || err.originalRequest == null) {\n    return false;\n  }\n  if (options && typeof options.onShouldRetry === 'function') {\n    return options.onShouldRetry(err, retryAttempt, options);\n  }\n  return defaultOnShouldRetry(err);\n}\n\n/**\n * determines if the request should be retried. Will only retry if not a status 4xx except a 409 or 423\n * @param {DetailedError} err\n * @returns {boolean}\n */\nfunction defaultOnShouldRetry(err) {\n  var status = err.originalResponse ? err.originalResponse.getStatus() : 0;\n  return (!inStatusCategory(status, 400) || status === 409 || status === 423) && isOnline();\n}\n\n/**\n * Resolve a relative link given the origin as source. For example,\n * if a HTTP request to http://example.com/files/ returns a Location\n * header with the value /upload/abc, the resolved URL will be:\n * http://example.com/upload/abc\n */\nfunction resolveUrl(origin, link) {\n  return new URL(link, origin).toString();\n}\n\n/**\n * Calculate the start and end positions for the parts if an upload\n * is split into multiple parallel requests.\n *\n * @param {number} totalSize The byte size of the upload, which will be split.\n * @param {number} partCount The number in how many parts the upload will be split.\n * @return {object[]}\n * @api private\n */\nfunction splitSizeIntoParts(totalSize, partCount) {\n  var partSize = Math.floor(totalSize / partCount);\n  var parts = [];\n  for (var i = 0; i < partCount; i++) {\n    parts.push({\n      start: partSize * i,\n      end: partSize * (i + 1)\n    });\n  }\n  parts[partCount - 1].end = totalSize;\n  return parts;\n}\nBaseUpload.defaultOptions = defaultOptions;\nexport default BaseUpload;","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\n/* eslint no-unused-vars: \"off\" */\nvar NoopUrlStorage = /*#__PURE__*/function () {\n  function NoopUrlStorage() {\n    _classCallCheck(this, NoopUrlStorage);\n  }\n  _createClass(NoopUrlStorage, [{\n    key: \"listAllUploads\",\n    value: function listAllUploads() {\n      return Promise.resolve([]);\n    }\n  }, {\n    key: \"findUploadsByFingerprint\",\n    value: function findUploadsByFingerprint(fingerprint) {\n      return Promise.resolve([]);\n    }\n  }, {\n    key: \"removeUpload\",\n    value: function removeUpload(urlStorageKey) {\n      return Promise.resolve();\n    }\n  }, {\n    key: \"addUpload\",\n    value: function addUpload(fingerprint, upload) {\n      return Promise.resolve(null);\n    }\n  }]);\n  return NoopUrlStorage;\n}();\nexport { NoopUrlStorage as default };","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nvar hasStorage = false;\ntry {\n  hasStorage = 'localStorage' in window;\n\n  // Attempt to store and read entries from the local storage to detect Private\n  // Mode on Safari on iOS (see #49)\n  // If the key was not used before, we remove it from local storage again to\n  // not cause confusion where the entry came from.\n  var key = 'tusSupport';\n  var originalValue = localStorage.getItem(key);\n  localStorage.setItem(key, originalValue);\n  if (originalValue === null) localStorage.removeItem(key);\n} catch (e) {\n  // If we try to access localStorage inside a sandboxed iframe, a SecurityError\n  // is thrown. When in private mode on iOS Safari, a QuotaExceededError is\n  // thrown (see #49)\n  if (e.code === e.SECURITY_ERR || e.code === e.QUOTA_EXCEEDED_ERR) {\n    hasStorage = false;\n  } else {\n    throw e;\n  }\n}\nexport var canStoreURLs = hasStorage;\nexport var WebStorageUrlStorage = /*#__PURE__*/function () {\n  function WebStorageUrlStorage() {\n    _classCallCheck(this, WebStorageUrlStorage);\n  }\n  _createClass(WebStorageUrlStorage, [{\n    key: \"findAllUploads\",\n    value: function findAllUploads() {\n      var results = this._findEntries('tus::');\n      return Promise.resolve(results);\n    }\n  }, {\n    key: \"findUploadsByFingerprint\",\n    value: function findUploadsByFingerprint(fingerprint) {\n      var results = this._findEntries(\"tus::\".concat(fingerprint, \"::\"));\n      return Promise.resolve(results);\n    }\n  }, {\n    key: \"removeUpload\",\n    value: function removeUpload(urlStorageKey) {\n      localStorage.removeItem(urlStorageKey);\n      return Promise.resolve();\n    }\n  }, {\n    key: \"addUpload\",\n    value: function addUpload(fingerprint, upload) {\n      var id = Math.round(Math.random() * 1e12);\n      var key = \"tus::\".concat(fingerprint, \"::\").concat(id);\n      localStorage.setItem(key, JSON.stringify(upload));\n      return Promise.resolve(key);\n    }\n  }, {\n    key: \"_findEntries\",\n    value: function _findEntries(prefix) {\n      var results = [];\n      for (var i = 0; i < localStorage.length; i++) {\n        var _key = localStorage.key(i);\n        if (_key.indexOf(prefix) !== 0) continue;\n        try {\n          var upload = JSON.parse(localStorage.getItem(_key));\n          upload.urlStorageKey = _key;\n          results.push(upload);\n        } catch (e) {\n          // The JSON parse error is intentionally ignored here, so a malformed\n          // entry in the storage cannot prevent an upload.\n        }\n      }\n      return results;\n    }\n  }]);\n  return WebStorageUrlStorage;\n}();","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\n/* eslint-disable max-classes-per-file */\nvar XHRHttpStack = /*#__PURE__*/function () {\n  function XHRHttpStack() {\n    _classCallCheck(this, XHRHttpStack);\n  }\n  _createClass(XHRHttpStack, [{\n    key: \"createRequest\",\n    value: function createRequest(method, url) {\n      return new Request(method, url);\n    }\n  }, {\n    key: \"getName\",\n    value: function getName() {\n      return 'XHRHttpStack';\n    }\n  }]);\n  return XHRHttpStack;\n}();\nexport { XHRHttpStack as default };\nvar Request = /*#__PURE__*/function () {\n  function Request(method, url) {\n    _classCallCheck(this, Request);\n    this._xhr = new XMLHttpRequest();\n    this._xhr.open(method, url, true);\n    this._method = method;\n    this._url = url;\n    this._headers = {};\n  }\n  _createClass(Request, [{\n    key: \"getMethod\",\n    value: function getMethod() {\n      return this._method;\n    }\n  }, {\n    key: \"getURL\",\n    value: function getURL() {\n      return this._url;\n    }\n  }, {\n    key: \"setHeader\",\n    value: function setHeader(header, value) {\n      this._xhr.setRequestHeader(header, value);\n      this._headers[header] = value;\n    }\n  }, {\n    key: \"getHeader\",\n    value: function getHeader(header) {\n      return this._headers[header];\n    }\n  }, {\n    key: \"setProgressHandler\",\n    value: function setProgressHandler(progressHandler) {\n      // Test support for progress events before attaching an event listener\n      if (!('upload' in this._xhr)) {\n        return;\n      }\n      this._xhr.upload.onprogress = function (e) {\n        if (!e.lengthComputable) {\n          return;\n        }\n        progressHandler(e.loaded);\n      };\n    }\n  }, {\n    key: \"send\",\n    value: function send() {\n      var _this = this;\n      var body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n      return new Promise(function (resolve, reject) {\n        _this._xhr.onload = function () {\n          resolve(new Response(_this._xhr));\n        };\n        _this._xhr.onerror = function (err) {\n          reject(err);\n        };\n        _this._xhr.send(body);\n      });\n    }\n  }, {\n    key: \"abort\",\n    value: function abort() {\n      this._xhr.abort();\n      return Promise.resolve();\n    }\n  }, {\n    key: \"getUnderlyingObject\",\n    value: function getUnderlyingObject() {\n      return this._xhr;\n    }\n  }]);\n  return Request;\n}();\nvar Response = /*#__PURE__*/function () {\n  function Response(xhr) {\n    _classCallCheck(this, Response);\n    this._xhr = xhr;\n  }\n  _createClass(Response, [{\n    key: \"getStatus\",\n    value: function getStatus() {\n      return this._xhr.status;\n    }\n  }, {\n    key: \"getHeader\",\n    value: function getHeader(header) {\n      return this._xhr.getResponseHeader(header);\n    }\n  }, {\n    key: \"getBody\",\n    value: function getBody() {\n      return this._xhr.responseText;\n    }\n  }, {\n    key: \"getUnderlyingObject\",\n    value: function getUnderlyingObject() {\n      return this._xhr;\n    }\n  }]);\n  return Response;\n}();","var isReactNative = function isReactNative() {\n  return typeof navigator !== 'undefined' && typeof navigator.product === 'string' && navigator.product.toLowerCase() === 'reactnative';\n};\nexport default isReactNative;","/**\n * uriToBlob resolves a URI to a Blob object. This is used for\n * React Native to retrieve a file (identified by a file://\n * URI) as a blob.\n */\nexport default function uriToBlob(uri) {\n  return new Promise(function (resolve, reject) {\n    var xhr = new XMLHttpRequest();\n    xhr.responseType = 'blob';\n    xhr.onload = function () {\n      var blob = xhr.response;\n      resolve(blob);\n    };\n    xhr.onerror = function (err) {\n      reject(err);\n    };\n    xhr.open('GET', uri);\n    xhr.send();\n  });\n}","var isCordova = function isCordova() {\n  return typeof window !== 'undefined' && (typeof window.PhoneGap !== 'undefined' || typeof window.Cordova !== 'undefined' || typeof window.cordova !== 'undefined');\n};\nexport default isCordova;","/**\n * readAsByteArray converts a File object to a Uint8Array.\n * This function is only used on the Apache Cordova platform.\n * See https://cordova.apache.org/docs/en/latest/reference/cordova-plugin-file/index.html#read-a-file\n */\nexport default function readAsByteArray(chunk) {\n  return new Promise(function (resolve, reject) {\n    var reader = new FileReader();\n    reader.onload = function () {\n      var value = new Uint8Array(reader.result);\n      resolve({\n        value: value\n      });\n    };\n    reader.onerror = function (err) {\n      reject(err);\n    };\n    reader.readAsArrayBuffer(chunk);\n  });\n}","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport isCordova from './isCordova.js';\nimport readAsByteArray from './readAsByteArray.js';\nvar FileSource = /*#__PURE__*/function () {\n  // Make this.size a method\n  function FileSource(file) {\n    _classCallCheck(this, FileSource);\n    this._file = file;\n    this.size = file.size;\n  }\n  _createClass(FileSource, [{\n    key: \"slice\",\n    value: function slice(start, end) {\n      // In Apache Cordova applications, a File must be resolved using\n      // FileReader instances, see\n      // https://cordova.apache.org/docs/en/8.x/reference/cordova-plugin-file/index.html#read-a-file\n      if (isCordova()) {\n        return readAsByteArray(this._file.slice(start, end));\n      }\n      var value = this._file.slice(start, end);\n      var done = end >= this.size;\n      return Promise.resolve({\n        value: value,\n        done: done\n      });\n    }\n  }, {\n    key: \"close\",\n    value: function close() {\n      // Nothing to do here since we don't need to release any resources.\n    }\n  }]);\n  return FileSource;\n}();\nexport { FileSource as default };","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nfunction len(blobOrArray) {\n  if (blobOrArray === undefined) return 0;\n  if (blobOrArray.size !== undefined) return blobOrArray.size;\n  return blobOrArray.length;\n}\n\n/*\n  Typed arrays and blobs don't have a concat method.\n  This function helps StreamSource accumulate data to reach chunkSize.\n*/\nfunction concat(a, b) {\n  if (a.concat) {\n    // Is `a` an Array?\n    return a.concat(b);\n  }\n  if (a instanceof Blob) {\n    return new Blob([a, b], {\n      type: a.type\n    });\n  }\n  if (a.set) {\n    // Is `a` a typed array?\n    var c = new a.constructor(a.length + b.length);\n    c.set(a);\n    c.set(b, a.length);\n    return c;\n  }\n  throw new Error('Unknown data type');\n}\nvar StreamSource = /*#__PURE__*/function () {\n  function StreamSource(reader) {\n    _classCallCheck(this, StreamSource);\n    this._buffer = undefined;\n    this._bufferOffset = 0;\n    this._reader = reader;\n    this._done = false;\n  }\n  _createClass(StreamSource, [{\n    key: \"slice\",\n    value: function slice(start, end) {\n      if (start < this._bufferOffset) {\n        return Promise.reject(new Error(\"Requested data is before the reader's current offset\"));\n      }\n      return this._readUntilEnoughDataOrDone(start, end);\n    }\n  }, {\n    key: \"_readUntilEnoughDataOrDone\",\n    value: function _readUntilEnoughDataOrDone(start, end) {\n      var _this = this;\n      var hasEnoughData = end <= this._bufferOffset + len(this._buffer);\n      if (this._done || hasEnoughData) {\n        var value = this._getDataFromBuffer(start, end);\n        var done = value == null ? this._done : false;\n        return Promise.resolve({\n          value: value,\n          done: done\n        });\n      }\n      return this._reader.read().then(function (_ref) {\n        var value = _ref.value,\n          done = _ref.done;\n        if (done) {\n          _this._done = true;\n        } else if (_this._buffer === undefined) {\n          _this._buffer = value;\n        } else {\n          _this._buffer = concat(_this._buffer, value);\n        }\n        return _this._readUntilEnoughDataOrDone(start, end);\n      });\n    }\n  }, {\n    key: \"_getDataFromBuffer\",\n    value: function _getDataFromBuffer(start, end) {\n      // Remove data from buffer before `start`.\n      // Data might be reread from the buffer if an upload fails, so we can only\n      // safely delete data when it comes *before* what is currently being read.\n      if (start > this._bufferOffset) {\n        this._buffer = this._buffer.slice(start - this._bufferOffset);\n        this._bufferOffset = start;\n      }\n      // If the buffer is empty after removing old data, all data has been read.\n      var hasAllDataBeenRead = len(this._buffer) === 0;\n      if (this._done && hasAllDataBeenRead) {\n        return null;\n      }\n      // We already removed data before `start`, so we just return the first\n      // chunk from the buffer.\n      return this._buffer.slice(0, end - start);\n    }\n  }, {\n    key: \"close\",\n    value: function close() {\n      if (this._reader.cancel) {\n        this._reader.cancel();\n      }\n    }\n  }]);\n  return StreamSource;\n}();\nexport { StreamSource as default };","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nfunction _regeneratorRuntime() { \"use strict\"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return e; }; var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function (t, e, r) { t[e] = r.value; }, i = \"function\" == typeof Symbol ? Symbol : {}, a = i.iterator || \"@@iterator\", c = i.asyncIterator || \"@@asyncIterator\", u = i.toStringTag || \"@@toStringTag\"; function define(t, e, r) { return Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }), t[e]; } try { define({}, \"\"); } catch (t) { define = function define(t, e, r) { return t[e] = r; }; } function wrap(t, e, r, n) { var i = e && e.prototype instanceof Generator ? e : Generator, a = Object.create(i.prototype), c = new Context(n || []); return o(a, \"_invoke\", { value: makeInvokeMethod(t, r, c) }), a; } function tryCatch(t, e, r) { try { return { type: \"normal\", arg: t.call(e, r) }; } catch (t) { return { type: \"throw\", arg: t }; } } e.wrap = wrap; var h = \"suspendedStart\", l = \"suspendedYield\", f = \"executing\", s = \"completed\", y = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var p = {}; define(p, a, function () { return this; }); var d = Object.getPrototypeOf, v = d && d(d(values([]))); v && v !== r && n.call(v, a) && (p = v); var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p); function defineIteratorMethods(t) { [\"next\", \"throw\", \"return\"].forEach(function (e) { define(t, e, function (t) { return this._invoke(e, t); }); }); } function AsyncIterator(t, e) { function invoke(r, o, i, a) { var c = tryCatch(t[r], t, o); if (\"throw\" !== c.type) { var u = c.arg, h = u.value; return h && \"object\" == _typeof(h) && n.call(h, \"__await\") ? e.resolve(h.__await).then(function (t) { invoke(\"next\", t, i, a); }, function (t) { invoke(\"throw\", t, i, a); }) : e.resolve(h).then(function (t) { u.value = t, i(u); }, function (t) { return invoke(\"throw\", t, i, a); }); } a(c.arg); } var r; o(this, \"_invoke\", { value: function value(t, n) { function callInvokeWithMethodAndArg() { return new e(function (e, r) { invoke(t, n, e, r); }); } return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(e, r, n) { var o = h; return function (i, a) { if (o === f) throw new Error(\"Generator is already running\"); if (o === s) { if (\"throw\" === i) throw a; return { value: t, done: !0 }; } for (n.method = i, n.arg = a;;) { var c = n.delegate; if (c) { var u = maybeInvokeDelegate(c, n); if (u) { if (u === y) continue; return u; } } if (\"next\" === n.method) n.sent = n._sent = n.arg;else if (\"throw\" === n.method) { if (o === h) throw o = s, n.arg; n.dispatchException(n.arg); } else \"return\" === n.method && n.abrupt(\"return\", n.arg); o = f; var p = tryCatch(e, r, n); if (\"normal\" === p.type) { if (o = n.done ? s : l, p.arg === y) continue; return { value: p.arg, done: n.done }; } \"throw\" === p.type && (o = s, n.method = \"throw\", n.arg = p.arg); } }; } function maybeInvokeDelegate(e, r) { var n = r.method, o = e.iterator[n]; if (o === t) return r.delegate = null, \"throw\" === n && e.iterator[\"return\"] && (r.method = \"return\", r.arg = t, maybeInvokeDelegate(e, r), \"throw\" === r.method) || \"return\" !== n && (r.method = \"throw\", r.arg = new TypeError(\"The iterator does not provide a '\" + n + \"' method\")), y; var i = tryCatch(o, e.iterator, r.arg); if (\"throw\" === i.type) return r.method = \"throw\", r.arg = i.arg, r.delegate = null, y; var a = i.arg; return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, \"return\" !== r.method && (r.method = \"next\", r.arg = t), r.delegate = null, y) : a : (r.method = \"throw\", r.arg = new TypeError(\"iterator result is not an object\"), r.delegate = null, y); } function pushTryEntry(t) { var e = { tryLoc: t[0] }; 1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e); } function resetTryEntry(t) { var e = t.completion || {}; e.type = \"normal\", delete e.arg, t.completion = e; } function Context(t) { this.tryEntries = [{ tryLoc: \"root\" }], t.forEach(pushTryEntry, this), this.reset(!0); } function values(e) { if (e || \"\" === e) { var r = e[a]; if (r) return r.call(e); if (\"function\" == typeof e.next) return e; if (!isNaN(e.length)) { var o = -1, i = function next() { for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next; return next.value = t, next.done = !0, next; }; return i.next = i; } } throw new TypeError(_typeof(e) + \" is not iterable\"); } return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, \"constructor\", { value: GeneratorFunctionPrototype, configurable: !0 }), o(GeneratorFunctionPrototype, \"constructor\", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, \"GeneratorFunction\"), e.isGeneratorFunction = function (t) { var e = \"function\" == typeof t && t.constructor; return !!e && (e === GeneratorFunction || \"GeneratorFunction\" === (e.displayName || e.name)); }, e.mark = function (t) { return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, \"GeneratorFunction\")), t.prototype = Object.create(g), t; }, e.awrap = function (t) { return { __await: t }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () { return this; }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) { void 0 === i && (i = Promise); var a = new AsyncIterator(wrap(t, r, n, o), i); return e.isGeneratorFunction(r) ? a : a.next().then(function (t) { return t.done ? t.value : a.next(); }); }, defineIteratorMethods(g), define(g, u, \"Generator\"), define(g, a, function () { return this; }), define(g, \"toString\", function () { return \"[object Generator]\"; }), e.keys = function (t) { var e = Object(t), r = []; for (var n in e) r.push(n); return r.reverse(), function next() { for (; r.length;) { var t = r.pop(); if (t in e) return next.value = t, next.done = !1, next; } return next.done = !0, next; }; }, e.values = values, Context.prototype = { constructor: Context, reset: function reset(e) { if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = \"next\", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) \"t\" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t); }, stop: function stop() { this.done = !0; var t = this.tryEntries[0].completion; if (\"throw\" === t.type) throw t.arg; return this.rval; }, dispatchException: function dispatchException(e) { if (this.done) throw e; var r = this; function handle(n, o) { return a.type = \"throw\", a.arg = e, r.next = n, o && (r.method = \"next\", r.arg = t), !!o; } for (var o = this.tryEntries.length - 1; o >= 0; --o) { var i = this.tryEntries[o], a = i.completion; if (\"root\" === i.tryLoc) return handle(\"end\"); if (i.tryLoc <= this.prev) { var c = n.call(i, \"catchLoc\"), u = n.call(i, \"finallyLoc\"); if (c && u) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } else if (c) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); } else { if (!u) throw new Error(\"try statement without catch or finally\"); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } } } }, abrupt: function abrupt(t, e) { for (var r = this.tryEntries.length - 1; r >= 0; --r) { var o = this.tryEntries[r]; if (o.tryLoc <= this.prev && n.call(o, \"finallyLoc\") && this.prev < o.finallyLoc) { var i = o; break; } } i && (\"break\" === t || \"continue\" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null); var a = i ? i.completion : {}; return a.type = t, a.arg = e, i ? (this.method = \"next\", this.next = i.finallyLoc, y) : this.complete(a); }, complete: function complete(t, e) { if (\"throw\" === t.type) throw t.arg; return \"break\" === t.type || \"continue\" === t.type ? this.next = t.arg : \"return\" === t.type ? (this.rval = this.arg = t.arg, this.method = \"return\", this.next = \"end\") : \"normal\" === t.type && e && (this.next = e), y; }, finish: function finish(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y; } }, \"catch\": function _catch(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.tryLoc === t) { var n = r.completion; if (\"throw\" === n.type) { var o = n.arg; resetTryEntry(r); } return o; } } throw new Error(\"illegal catch attempt\"); }, delegateYield: function delegateYield(e, r, n) { return this.delegate = { iterator: values(e), resultName: r, nextLoc: n }, \"next\" === this.method && (this.arg = t), y; } }, e; }\nfunction asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }\nfunction _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err); } _next(undefined); }); }; }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport isReactNative from './isReactNative.js';\nimport uriToBlob from './uriToBlob.js';\nimport FileSource from './sources/FileSource.js';\nimport StreamSource from './sources/StreamSource.js';\nvar FileReader = /*#__PURE__*/function () {\n  function FileReader() {\n    _classCallCheck(this, FileReader);\n  }\n  _createClass(FileReader, [{\n    key: \"openFile\",\n    value: function () {\n      var _openFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(input, chunkSize) {\n        var blob;\n        return _regeneratorRuntime().wrap(function _callee$(_context) {\n          while (1) switch (_context.prev = _context.next) {\n            case 0:\n              if (!(isReactNative() && input && typeof input.uri !== 'undefined')) {\n                _context.next = 11;\n                break;\n              }\n              _context.prev = 1;\n              _context.next = 4;\n              return uriToBlob(input.uri);\n            case 4:\n              blob = _context.sent;\n              return _context.abrupt(\"return\", new FileSource(blob));\n            case 8:\n              _context.prev = 8;\n              _context.t0 = _context[\"catch\"](1);\n              throw new Error(\"tus: cannot fetch `file.uri` as Blob, make sure the uri is correct and accessible. \".concat(_context.t0));\n            case 11:\n              if (!(typeof input.slice === 'function' && typeof input.size !== 'undefined')) {\n                _context.next = 13;\n                break;\n              }\n              return _context.abrupt(\"return\", Promise.resolve(new FileSource(input)));\n            case 13:\n              if (!(typeof input.read === 'function')) {\n                _context.next = 18;\n                break;\n              }\n              chunkSize = Number(chunkSize);\n              if (Number.isFinite(chunkSize)) {\n                _context.next = 17;\n                break;\n              }\n              return _context.abrupt(\"return\", Promise.reject(new Error('cannot create source for stream without a finite value for the `chunkSize` option')));\n            case 17:\n              return _context.abrupt(\"return\", Promise.resolve(new StreamSource(input, chunkSize)));\n            case 18:\n              return _context.abrupt(\"return\", Promise.reject(new Error('source object may only be an instance of File, Blob, or Reader in this environment')));\n            case 19:\n            case \"end\":\n              return _context.stop();\n          }\n        }, _callee, null, [[1, 8]]);\n      }));\n      function openFile(_x, _x2) {\n        return _openFile.apply(this, arguments);\n      }\n      return openFile;\n    }()\n  }]);\n  return FileReader;\n}();\nexport { FileReader as default };","import isReactNative from './isReactNative.js';\n\n// TODO: Differenciate between input types\n\n/**\n * Generate a fingerprint for a file which will be used the store the endpoint\n *\n * @param {File} file\n * @param {Object} options\n * @param {Function} callback\n */\nexport default function fingerprint(file, options) {\n  if (isReactNative()) {\n    return Promise.resolve(reactNativeFingerprint(file, options));\n  }\n  return Promise.resolve(['tus-br', file.name, file.type, file.size, file.lastModified, options.endpoint].join('-'));\n}\nfunction reactNativeFingerprint(file, options) {\n  var exifHash = file.exif ? hashCode(JSON.stringify(file.exif)) : 'noexif';\n  return ['tus-rn', file.name || 'noname', file.size || 'nosize', exifHash, options.endpoint].join('/');\n}\nfunction hashCode(str) {\n  /* eslint-disable no-bitwise */\n  // from https://stackoverflow.com/a/8831937/151666\n  var hash = 0;\n  if (str.length === 0) {\n    return hash;\n  }\n  for (var i = 0; i < str.length; i++) {\n    var _char = str.charCodeAt(i);\n    hash = (hash << 5) - hash + _char;\n    hash &= hash; // Convert to 32bit integer\n  }\n  return hash;\n}","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport BaseUpload from '../upload.js';\nimport NoopUrlStorage from '../noopUrlStorage.js';\nimport { enableDebugLog } from '../logger.js';\nimport DetailedError from '../error.js';\nimport { canStoreURLs, WebStorageUrlStorage } from './urlStorage.js';\nimport DefaultHttpStack from './httpStack.js';\nimport FileReader from './fileReader.js';\nimport fingerprint from './fileSignature.js';\nvar defaultOptions = _objectSpread(_objectSpread({}, BaseUpload.defaultOptions), {}, {\n  httpStack: new DefaultHttpStack(),\n  fileReader: new FileReader(),\n  urlStorage: canStoreURLs ? new WebStorageUrlStorage() : new NoopUrlStorage(),\n  fingerprint: fingerprint\n});\nvar Upload = /*#__PURE__*/function (_BaseUpload) {\n  _inherits(Upload, _BaseUpload);\n  var _super = _createSuper(Upload);\n  function Upload() {\n    var file = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    _classCallCheck(this, Upload);\n    options = _objectSpread(_objectSpread({}, defaultOptions), options);\n    return _super.call(this, file, options);\n  }\n  _createClass(Upload, null, [{\n    key: \"terminate\",\n    value: function terminate(url) {\n      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      options = _objectSpread(_objectSpread({}, defaultOptions), options);\n      return BaseUpload.terminate(url, options);\n    }\n  }]);\n  return Upload;\n}(BaseUpload);\nvar _window = window,\n  XMLHttpRequest = _window.XMLHttpRequest,\n  Blob = _window.Blob;\nvar isSupported = XMLHttpRequest && Blob && typeof Blob.prototype.slice === 'function';\nexport { Upload, canStoreURLs, defaultOptions, isSupported, enableDebugLog, DefaultHttpStack, DetailedError };","'use strict';\n\nvar required = require('requires-port')\n  , qs = require('querystringify')\n  , controlOrWhitespace = /^[\\x00-\\x20\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff]+/\n  , CRHTLF = /[\\n\\r\\t]/g\n  , slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\\/\\//\n  , port = /:\\d+$/\n  , protocolre = /^([a-z][a-z0-9.+-]*:)?(\\/\\/)?([\\\\/]+)?([\\S\\s]*)/i\n  , windowsDriveLetter = /^[a-zA-Z]:/;\n\n/**\n * Remove control characters and whitespace from the beginning of a string.\n *\n * @param {Object|String} str String to trim.\n * @returns {String} A new string representing `str` stripped of control\n *     characters and whitespace from its beginning.\n * @public\n */\nfunction trimLeft(str) {\n  return (str ? str : '').toString().replace(controlOrWhitespace, '');\n}\n\n/**\n * These are the parse rules for the URL parser, it informs the parser\n * about:\n *\n * 0. The char it Needs to parse, if it's a string it should be done using\n *    indexOf, RegExp using exec and NaN means set as current value.\n * 1. The property we should set when parsing this value.\n * 2. Indication if it's backwards or forward parsing, when set as number it's\n *    the value of extra chars that should be split off.\n * 3. Inherit from location if non existing in the parser.\n * 4. `toLowerCase` the resulting value.\n */\nvar rules = [\n  ['#', 'hash'],                        // Extract from the back.\n  ['?', 'query'],                       // Extract from the back.\n  function sanitize(address, url) {     // Sanitize what is left of the address\n    return isSpecial(url.protocol) ? address.replace(/\\\\/g, '/') : address;\n  },\n  ['/', 'pathname'],                    // Extract from the back.\n  ['@', 'auth', 1],                     // Extract from the front.\n  [NaN, 'host', undefined, 1, 1],       // Set left over value.\n  [/:(\\d*)$/, 'port', undefined, 1],    // RegExp the back.\n  [NaN, 'hostname', undefined, 1, 1]    // Set left over.\n];\n\n/**\n * These properties should not be copied or inherited from. This is only needed\n * for all non blob URL's as a blob URL does not include a hash, only the\n * origin.\n *\n * @type {Object}\n * @private\n */\nvar ignore = { hash: 1, query: 1 };\n\n/**\n * The location object differs when your code is loaded through a normal page,\n * Worker or through a worker using a blob. And with the blobble begins the\n * trouble as the location object will contain the URL of the blob, not the\n * location of the page where our code is loaded in. The actual origin is\n * encoded in the `pathname` so we can thankfully generate a good \"default\"\n * location from it so we can generate proper relative URL's again.\n *\n * @param {Object|String} loc Optional default location object.\n * @returns {Object} lolcation object.\n * @public\n */\nfunction lolcation(loc) {\n  var globalVar;\n\n  if (typeof window !== 'undefined') globalVar = window;\n  else if (typeof global !== 'undefined') globalVar = global;\n  else if (typeof self !== 'undefined') globalVar = self;\n  else globalVar = {};\n\n  var location = globalVar.location || {};\n  loc = loc || location;\n\n  var finaldestination = {}\n    , type = typeof loc\n    , key;\n\n  if ('blob:' === loc.protocol) {\n    finaldestination = new Url(unescape(loc.pathname), {});\n  } else if ('string' === type) {\n    finaldestination = new Url(loc, {});\n    for (key in ignore) delete finaldestination[key];\n  } else if ('object' === type) {\n    for (key in loc) {\n      if (key in ignore) continue;\n      finaldestination[key] = loc[key];\n    }\n\n    if (finaldestination.slashes === undefined) {\n      finaldestination.slashes = slashes.test(loc.href);\n    }\n  }\n\n  return finaldestination;\n}\n\n/**\n * Check whether a protocol scheme is special.\n *\n * @param {String} The protocol scheme of the URL\n * @return {Boolean} `true` if the protocol scheme is special, else `false`\n * @private\n */\nfunction isSpecial(scheme) {\n  return (\n    scheme === 'file:' ||\n    scheme === 'ftp:' ||\n    scheme === 'http:' ||\n    scheme === 'https:' ||\n    scheme === 'ws:' ||\n    scheme === 'wss:'\n  );\n}\n\n/**\n * @typedef ProtocolExtract\n * @type Object\n * @property {String} protocol Protocol matched in the URL, in lowercase.\n * @property {Boolean} slashes `true` if protocol is followed by \"//\", else `false`.\n * @property {String} rest Rest of the URL that is not part of the protocol.\n */\n\n/**\n * Extract protocol information from a URL with/without double slash (\"//\").\n *\n * @param {String} address URL we want to extract from.\n * @param {Object} location\n * @return {ProtocolExtract} Extracted information.\n * @private\n */\nfunction extractProtocol(address, location) {\n  address = trimLeft(address);\n  address = address.replace(CRHTLF, '');\n  location = location || {};\n\n  var match = protocolre.exec(address);\n  var protocol = match[1] ? match[1].toLowerCase() : '';\n  var forwardSlashes = !!match[2];\n  var otherSlashes = !!match[3];\n  var slashesCount = 0;\n  var rest;\n\n  if (forwardSlashes) {\n    if (otherSlashes) {\n      rest = match[2] + match[3] + match[4];\n      slashesCount = match[2].length + match[3].length;\n    } else {\n      rest = match[2] + match[4];\n      slashesCount = match[2].length;\n    }\n  } else {\n    if (otherSlashes) {\n      rest = match[3] + match[4];\n      slashesCount = match[3].length;\n    } else {\n      rest = match[4]\n    }\n  }\n\n  if (protocol === 'file:') {\n    if (slashesCount >= 2) {\n      rest = rest.slice(2);\n    }\n  } else if (isSpecial(protocol)) {\n    rest = match[4];\n  } else if (protocol) {\n    if (forwardSlashes) {\n      rest = rest.slice(2);\n    }\n  } else if (slashesCount >= 2 && isSpecial(location.protocol)) {\n    rest = match[4];\n  }\n\n  return {\n    protocol: protocol,\n    slashes: forwardSlashes || isSpecial(protocol),\n    slashesCount: slashesCount,\n    rest: rest\n  };\n}\n\n/**\n * Resolve a relative URL pathname against a base URL pathname.\n *\n * @param {String} relative Pathname of the relative URL.\n * @param {String} base Pathname of the base URL.\n * @return {String} Resolved pathname.\n * @private\n */\nfunction resolve(relative, base) {\n  if (relative === '') return base;\n\n  var path = (base || '/').split('/').slice(0, -1).concat(relative.split('/'))\n    , i = path.length\n    , last = path[i - 1]\n    , unshift = false\n    , up = 0;\n\n  while (i--) {\n    if (path[i] === '.') {\n      path.splice(i, 1);\n    } else if (path[i] === '..') {\n      path.splice(i, 1);\n      up++;\n    } else if (up) {\n      if (i === 0) unshift = true;\n      path.splice(i, 1);\n      up--;\n    }\n  }\n\n  if (unshift) path.unshift('');\n  if (last === '.' || last === '..') path.push('');\n\n  return path.join('/');\n}\n\n/**\n * The actual URL instance. Instead of returning an object we've opted-in to\n * create an actual constructor as it's much more memory efficient and\n * faster and it pleases my OCD.\n *\n * It is worth noting that we should not use `URL` as class name to prevent\n * clashes with the global URL instance that got introduced in browsers.\n *\n * @constructor\n * @param {String} address URL we want to parse.\n * @param {Object|String} [location] Location defaults for relative paths.\n * @param {Boolean|Function} [parser] Parser for the query string.\n * @private\n */\nfunction Url(address, location, parser) {\n  address = trimLeft(address);\n  address = address.replace(CRHTLF, '');\n\n  if (!(this instanceof Url)) {\n    return new Url(address, location, parser);\n  }\n\n  var relative, extracted, parse, instruction, index, key\n    , instructions = rules.slice()\n    , type = typeof location\n    , url = this\n    , i = 0;\n\n  //\n  // The following if statements allows this module two have compatibility with\n  // 2 different API:\n  //\n  // 1. Node.js's `url.parse` api which accepts a URL, boolean as arguments\n  //    where the boolean indicates that the query string should also be parsed.\n  //\n  // 2. The `URL` interface of the browser which accepts a URL, object as\n  //    arguments. The supplied object will be used as default values / fall-back\n  //    for relative paths.\n  //\n  if ('object' !== type && 'string' !== type) {\n    parser = location;\n    location = null;\n  }\n\n  if (parser && 'function' !== typeof parser) parser = qs.parse;\n\n  location = lolcation(location);\n\n  //\n  // Extract protocol information before running the instructions.\n  //\n  extracted = extractProtocol(address || '', location);\n  relative = !extracted.protocol && !extracted.slashes;\n  url.slashes = extracted.slashes || relative && location.slashes;\n  url.protocol = extracted.protocol || location.protocol || '';\n  address = extracted.rest;\n\n  //\n  // When the authority component is absent the URL starts with a path\n  // component.\n  //\n  if (\n    extracted.protocol === 'file:' && (\n      extracted.slashesCount !== 2 || windowsDriveLetter.test(address)) ||\n    (!extracted.slashes &&\n      (extracted.protocol ||\n        extracted.slashesCount < 2 ||\n        !isSpecial(url.protocol)))\n  ) {\n    instructions[3] = [/(.*)/, 'pathname'];\n  }\n\n  for (; i < instructions.length; i++) {\n    instruction = instructions[i];\n\n    if (typeof instruction === 'function') {\n      address = instruction(address, url);\n      continue;\n    }\n\n    parse = instruction[0];\n    key = instruction[1];\n\n    if (parse !== parse) {\n      url[key] = address;\n    } else if ('string' === typeof parse) {\n      index = parse === '@'\n        ? address.lastIndexOf(parse)\n        : address.indexOf(parse);\n\n      if (~index) {\n        if ('number' === typeof instruction[2]) {\n          url[key] = address.slice(0, index);\n          address = address.slice(index + instruction[2]);\n        } else {\n          url[key] = address.slice(index);\n          address = address.slice(0, index);\n        }\n      }\n    } else if ((index = parse.exec(address))) {\n      url[key] = index[1];\n      address = address.slice(0, index.index);\n    }\n\n    url[key] = url[key] || (\n      relative && instruction[3] ? location[key] || '' : ''\n    );\n\n    //\n    // Hostname, host and protocol should be lowercased so they can be used to\n    // create a proper `origin`.\n    //\n    if (instruction[4]) url[key] = url[key].toLowerCase();\n  }\n\n  //\n  // Also parse the supplied query string in to an object. If we're supplied\n  // with a custom parser as function use that instead of the default build-in\n  // parser.\n  //\n  if (parser) url.query = parser(url.query);\n\n  //\n  // If the URL is relative, resolve the pathname against the base URL.\n  //\n  if (\n      relative\n    && location.slashes\n    && url.pathname.charAt(0) !== '/'\n    && (url.pathname !== '' || location.pathname !== '')\n  ) {\n    url.pathname = resolve(url.pathname, location.pathname);\n  }\n\n  //\n  // Default to a / for pathname if none exists. This normalizes the URL\n  // to always have a /\n  //\n  if (url.pathname.charAt(0) !== '/' && isSpecial(url.protocol)) {\n    url.pathname = '/' + url.pathname;\n  }\n\n  //\n  // We should not add port numbers if they are already the default port number\n  // for a given protocol. As the host also contains the port number we're going\n  // override it with the hostname which contains no port number.\n  //\n  if (!required(url.port, url.protocol)) {\n    url.host = url.hostname;\n    url.port = '';\n  }\n\n  //\n  // Parse down the `auth` for the username and password.\n  //\n  url.username = url.password = '';\n\n  if (url.auth) {\n    index = url.auth.indexOf(':');\n\n    if (~index) {\n      url.username = url.auth.slice(0, index);\n      url.username = encodeURIComponent(decodeURIComponent(url.username));\n\n      url.password = url.auth.slice(index + 1);\n      url.password = encodeURIComponent(decodeURIComponent(url.password))\n    } else {\n      url.username = encodeURIComponent(decodeURIComponent(url.auth));\n    }\n\n    url.auth = url.password ? url.username +':'+ url.password : url.username;\n  }\n\n  url.origin = url.protocol !== 'file:' && isSpecial(url.protocol) && url.host\n    ? url.protocol +'//'+ url.host\n    : 'null';\n\n  //\n  // The href is just the compiled result.\n  //\n  url.href = url.toString();\n}\n\n/**\n * This is convenience method for changing properties in the URL instance to\n * insure that they all propagate correctly.\n *\n * @param {String} part          Property we need to adjust.\n * @param {Mixed} value          The newly assigned value.\n * @param {Boolean|Function} fn  When setting the query, it will be the function\n *                               used to parse the query.\n *                               When setting the protocol, double slash will be\n *                               removed from the final url if it is true.\n * @returns {URL} URL instance for chaining.\n * @public\n */\nfunction set(part, value, fn) {\n  var url = this;\n\n  switch (part) {\n    case 'query':\n      if ('string' === typeof value && value.length) {\n        value = (fn || qs.parse)(value);\n      }\n\n      url[part] = value;\n      break;\n\n    case 'port':\n      url[part] = value;\n\n      if (!required(value, url.protocol)) {\n        url.host = url.hostname;\n        url[part] = '';\n      } else if (value) {\n        url.host = url.hostname +':'+ value;\n      }\n\n      break;\n\n    case 'hostname':\n      url[part] = value;\n\n      if (url.port) value += ':'+ url.port;\n      url.host = value;\n      break;\n\n    case 'host':\n      url[part] = value;\n\n      if (port.test(value)) {\n        value = value.split(':');\n        url.port = value.pop();\n        url.hostname = value.join(':');\n      } else {\n        url.hostname = value;\n        url.port = '';\n      }\n\n      break;\n\n    case 'protocol':\n      url.protocol = value.toLowerCase();\n      url.slashes = !fn;\n      break;\n\n    case 'pathname':\n    case 'hash':\n      if (value) {\n        var char = part === 'pathname' ? '/' : '#';\n        url[part] = value.charAt(0) !== char ? char + value : value;\n      } else {\n        url[part] = value;\n      }\n      break;\n\n    case 'username':\n    case 'password':\n      url[part] = encodeURIComponent(value);\n      break;\n\n    case 'auth':\n      var index = value.indexOf(':');\n\n      if (~index) {\n        url.username = value.slice(0, index);\n        url.username = encodeURIComponent(decodeURIComponent(url.username));\n\n        url.password = value.slice(index + 1);\n        url.password = encodeURIComponent(decodeURIComponent(url.password));\n      } else {\n        url.username = encodeURIComponent(decodeURIComponent(value));\n      }\n  }\n\n  for (var i = 0; i < rules.length; i++) {\n    var ins = rules[i];\n\n    if (ins[4]) url[ins[1]] = url[ins[1]].toLowerCase();\n  }\n\n  url.auth = url.password ? url.username +':'+ url.password : url.username;\n\n  url.origin = url.protocol !== 'file:' && isSpecial(url.protocol) && url.host\n    ? url.protocol +'//'+ url.host\n    : 'null';\n\n  url.href = url.toString();\n\n  return url;\n}\n\n/**\n * Transform the properties back in to a valid and full URL string.\n *\n * @param {Function} stringify Optional query stringify function.\n * @returns {String} Compiled version of the URL.\n * @public\n */\nfunction toString(stringify) {\n  if (!stringify || 'function' !== typeof stringify) stringify = qs.stringify;\n\n  var query\n    , url = this\n    , host = url.host\n    , protocol = url.protocol;\n\n  if (protocol && protocol.charAt(protocol.length - 1) !== ':') protocol += ':';\n\n  var result =\n    protocol +\n    ((url.protocol && url.slashes) || isSpecial(url.protocol) ? '//' : '');\n\n  if (url.username) {\n    result += url.username;\n    if (url.password) result += ':'+ url.password;\n    result += '@';\n  } else if (url.password) {\n    result += ':'+ url.password;\n    result += '@';\n  } else if (\n    url.protocol !== 'file:' &&\n    isSpecial(url.protocol) &&\n    !host &&\n    url.pathname !== '/'\n  ) {\n    //\n    // Add back the empty userinfo, otherwise the original invalid URL\n    // might be transformed into a valid one with `url.pathname` as host.\n    //\n    result += '@';\n  }\n\n  //\n  // Trailing colon is removed from `url.host` when it is parsed. If it still\n  // ends with a colon, then add back the trailing colon that was removed. This\n  // prevents an invalid URL from being transformed into a valid one.\n  //\n  if (host[host.length - 1] === ':' || (port.test(url.hostname) && !url.port)) {\n    host += ':';\n  }\n\n  result += host + url.pathname;\n\n  query = 'object' === typeof url.query ? stringify(url.query) : url.query;\n  if (query) result += '?' !== query.charAt(0) ? '?'+ query : query;\n\n  if (url.hash) result += url.hash;\n\n  return result;\n}\n\nUrl.prototype = { set: set, toString: toString };\n\n//\n// Expose the URL parser and some additional properties that might be useful for\n// others or testing.\n//\nUrl.extractProtocol = extractProtocol;\nUrl.location = lolcation;\nUrl.trimLeft = trimLeft;\nUrl.qs = qs;\n\nmodule.exports = Url;\n","// This file is autogenerated. It's used to publish CJS to npm.\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.tinycolor = factory());\n})(this, (function () { 'use strict';\n\n  function _typeof(obj) {\n    \"@babel/helpers - typeof\";\n\n    return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n      return typeof obj;\n    } : function (obj) {\n      return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    }, _typeof(obj);\n  }\n\n  // https://github.com/bgrins/TinyColor\n  // Brian Grinstead, MIT License\n\n  var trimLeft = /^\\s+/;\n  var trimRight = /\\s+$/;\n  function tinycolor(color, opts) {\n    color = color ? color : \"\";\n    opts = opts || {};\n\n    // If input is already a tinycolor, return itself\n    if (color instanceof tinycolor) {\n      return color;\n    }\n    // If we are called as a function, call using new instead\n    if (!(this instanceof tinycolor)) {\n      return new tinycolor(color, opts);\n    }\n    var rgb = inputToRGB(color);\n    this._originalInput = color, this._r = rgb.r, this._g = rgb.g, this._b = rgb.b, this._a = rgb.a, this._roundA = Math.round(100 * this._a) / 100, this._format = opts.format || rgb.format;\n    this._gradientType = opts.gradientType;\n\n    // Don't let the range of [0,255] come back in [0,1].\n    // Potentially lose a little bit of precision here, but will fix issues where\n    // .5 gets interpreted as half of the total, instead of half of 1\n    // If it was supposed to be 128, this was already taken care of by `inputToRgb`\n    if (this._r < 1) this._r = Math.round(this._r);\n    if (this._g < 1) this._g = Math.round(this._g);\n    if (this._b < 1) this._b = Math.round(this._b);\n    this._ok = rgb.ok;\n  }\n  tinycolor.prototype = {\n    isDark: function isDark() {\n      return this.getBrightness() < 128;\n    },\n    isLight: function isLight() {\n      return !this.isDark();\n    },\n    isValid: function isValid() {\n      return this._ok;\n    },\n    getOriginalInput: function getOriginalInput() {\n      return this._originalInput;\n    },\n    getFormat: function getFormat() {\n      return this._format;\n    },\n    getAlpha: function getAlpha() {\n      return this._a;\n    },\n    getBrightness: function getBrightness() {\n      //http://www.w3.org/TR/AERT#color-contrast\n      var rgb = this.toRgb();\n      return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;\n    },\n    getLuminance: function getLuminance() {\n      //http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef\n      var rgb = this.toRgb();\n      var RsRGB, GsRGB, BsRGB, R, G, B;\n      RsRGB = rgb.r / 255;\n      GsRGB = rgb.g / 255;\n      BsRGB = rgb.b / 255;\n      if (RsRGB <= 0.03928) R = RsRGB / 12.92;else R = Math.pow((RsRGB + 0.055) / 1.055, 2.4);\n      if (GsRGB <= 0.03928) G = GsRGB / 12.92;else G = Math.pow((GsRGB + 0.055) / 1.055, 2.4);\n      if (BsRGB <= 0.03928) B = BsRGB / 12.92;else B = Math.pow((BsRGB + 0.055) / 1.055, 2.4);\n      return 0.2126 * R + 0.7152 * G + 0.0722 * B;\n    },\n    setAlpha: function setAlpha(value) {\n      this._a = boundAlpha(value);\n      this._roundA = Math.round(100 * this._a) / 100;\n      return this;\n    },\n    toHsv: function toHsv() {\n      var hsv = rgbToHsv(this._r, this._g, this._b);\n      return {\n        h: hsv.h * 360,\n        s: hsv.s,\n        v: hsv.v,\n        a: this._a\n      };\n    },\n    toHsvString: function toHsvString() {\n      var hsv = rgbToHsv(this._r, this._g, this._b);\n      var h = Math.round(hsv.h * 360),\n        s = Math.round(hsv.s * 100),\n        v = Math.round(hsv.v * 100);\n      return this._a == 1 ? \"hsv(\" + h + \", \" + s + \"%, \" + v + \"%)\" : \"hsva(\" + h + \", \" + s + \"%, \" + v + \"%, \" + this._roundA + \")\";\n    },\n    toHsl: function toHsl() {\n      var hsl = rgbToHsl(this._r, this._g, this._b);\n      return {\n        h: hsl.h * 360,\n        s: hsl.s,\n        l: hsl.l,\n        a: this._a\n      };\n    },\n    toHslString: function toHslString() {\n      var hsl = rgbToHsl(this._r, this._g, this._b);\n      var h = Math.round(hsl.h * 360),\n        s = Math.round(hsl.s * 100),\n        l = Math.round(hsl.l * 100);\n      return this._a == 1 ? \"hsl(\" + h + \", \" + s + \"%, \" + l + \"%)\" : \"hsla(\" + h + \", \" + s + \"%, \" + l + \"%, \" + this._roundA + \")\";\n    },\n    toHex: function toHex(allow3Char) {\n      return rgbToHex(this._r, this._g, this._b, allow3Char);\n    },\n    toHexString: function toHexString(allow3Char) {\n      return \"#\" + this.toHex(allow3Char);\n    },\n    toHex8: function toHex8(allow4Char) {\n      return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char);\n    },\n    toHex8String: function toHex8String(allow4Char) {\n      return \"#\" + this.toHex8(allow4Char);\n    },\n    toRgb: function toRgb() {\n      return {\n        r: Math.round(this._r),\n        g: Math.round(this._g),\n        b: Math.round(this._b),\n        a: this._a\n      };\n    },\n    toRgbString: function toRgbString() {\n      return this._a == 1 ? \"rgb(\" + Math.round(this._r) + \", \" + Math.round(this._g) + \", \" + Math.round(this._b) + \")\" : \"rgba(\" + Math.round(this._r) + \", \" + Math.round(this._g) + \", \" + Math.round(this._b) + \", \" + this._roundA + \")\";\n    },\n    toPercentageRgb: function toPercentageRgb() {\n      return {\n        r: Math.round(bound01(this._r, 255) * 100) + \"%\",\n        g: Math.round(bound01(this._g, 255) * 100) + \"%\",\n        b: Math.round(bound01(this._b, 255) * 100) + \"%\",\n        a: this._a\n      };\n    },\n    toPercentageRgbString: function toPercentageRgbString() {\n      return this._a == 1 ? \"rgb(\" + Math.round(bound01(this._r, 255) * 100) + \"%, \" + Math.round(bound01(this._g, 255) * 100) + \"%, \" + Math.round(bound01(this._b, 255) * 100) + \"%)\" : \"rgba(\" + Math.round(bound01(this._r, 255) * 100) + \"%, \" + Math.round(bound01(this._g, 255) * 100) + \"%, \" + Math.round(bound01(this._b, 255) * 100) + \"%, \" + this._roundA + \")\";\n    },\n    toName: function toName() {\n      if (this._a === 0) {\n        return \"transparent\";\n      }\n      if (this._a < 1) {\n        return false;\n      }\n      return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;\n    },\n    toFilter: function toFilter(secondColor) {\n      var hex8String = \"#\" + rgbaToArgbHex(this._r, this._g, this._b, this._a);\n      var secondHex8String = hex8String;\n      var gradientType = this._gradientType ? \"GradientType = 1, \" : \"\";\n      if (secondColor) {\n        var s = tinycolor(secondColor);\n        secondHex8String = \"#\" + rgbaToArgbHex(s._r, s._g, s._b, s._a);\n      }\n      return \"progid:DXImageTransform.Microsoft.gradient(\" + gradientType + \"startColorstr=\" + hex8String + \",endColorstr=\" + secondHex8String + \")\";\n    },\n    toString: function toString(format) {\n      var formatSet = !!format;\n      format = format || this._format;\n      var formattedString = false;\n      var hasAlpha = this._a < 1 && this._a >= 0;\n      var needsAlphaFormat = !formatSet && hasAlpha && (format === \"hex\" || format === \"hex6\" || format === \"hex3\" || format === \"hex4\" || format === \"hex8\" || format === \"name\");\n      if (needsAlphaFormat) {\n        // Special case for \"transparent\", all other non-alpha formats\n        // will return rgba when there is transparency.\n        if (format === \"name\" && this._a === 0) {\n          return this.toName();\n        }\n        return this.toRgbString();\n      }\n      if (format === \"rgb\") {\n        formattedString = this.toRgbString();\n      }\n      if (format === \"prgb\") {\n        formattedString = this.toPercentageRgbString();\n      }\n      if (format === \"hex\" || format === \"hex6\") {\n        formattedString = this.toHexString();\n      }\n      if (format === \"hex3\") {\n        formattedString = this.toHexString(true);\n      }\n      if (format === \"hex4\") {\n        formattedString = this.toHex8String(true);\n      }\n      if (format === \"hex8\") {\n        formattedString = this.toHex8String();\n      }\n      if (format === \"name\") {\n        formattedString = this.toName();\n      }\n      if (format === \"hsl\") {\n        formattedString = this.toHslString();\n      }\n      if (format === \"hsv\") {\n        formattedString = this.toHsvString();\n      }\n      return formattedString || this.toHexString();\n    },\n    clone: function clone() {\n      return tinycolor(this.toString());\n    },\n    _applyModification: function _applyModification(fn, args) {\n      var color = fn.apply(null, [this].concat([].slice.call(args)));\n      this._r = color._r;\n      this._g = color._g;\n      this._b = color._b;\n      this.setAlpha(color._a);\n      return this;\n    },\n    lighten: function lighten() {\n      return this._applyModification(_lighten, arguments);\n    },\n    brighten: function brighten() {\n      return this._applyModification(_brighten, arguments);\n    },\n    darken: function darken() {\n      return this._applyModification(_darken, arguments);\n    },\n    desaturate: function desaturate() {\n      return this._applyModification(_desaturate, arguments);\n    },\n    saturate: function saturate() {\n      return this._applyModification(_saturate, arguments);\n    },\n    greyscale: function greyscale() {\n      return this._applyModification(_greyscale, arguments);\n    },\n    spin: function spin() {\n      return this._applyModification(_spin, arguments);\n    },\n    _applyCombination: function _applyCombination(fn, args) {\n      return fn.apply(null, [this].concat([].slice.call(args)));\n    },\n    analogous: function analogous() {\n      return this._applyCombination(_analogous, arguments);\n    },\n    complement: function complement() {\n      return this._applyCombination(_complement, arguments);\n    },\n    monochromatic: function monochromatic() {\n      return this._applyCombination(_monochromatic, arguments);\n    },\n    splitcomplement: function splitcomplement() {\n      return this._applyCombination(_splitcomplement, arguments);\n    },\n    // Disabled until https://github.com/bgrins/TinyColor/issues/254\n    // polyad: function (number) {\n    //   return this._applyCombination(polyad, [number]);\n    // },\n    triad: function triad() {\n      return this._applyCombination(polyad, [3]);\n    },\n    tetrad: function tetrad() {\n      return this._applyCombination(polyad, [4]);\n    }\n  };\n\n  // If input is an object, force 1 into \"1.0\" to handle ratios properly\n  // String input requires \"1.0\" as input, so 1 will be treated as 1\n  tinycolor.fromRatio = function (color, opts) {\n    if (_typeof(color) == \"object\") {\n      var newColor = {};\n      for (var i in color) {\n        if (color.hasOwnProperty(i)) {\n          if (i === \"a\") {\n            newColor[i] = color[i];\n          } else {\n            newColor[i] = convertToPercentage(color[i]);\n          }\n        }\n      }\n      color = newColor;\n    }\n    return tinycolor(color, opts);\n  };\n\n  // Given a string or object, convert that input to RGB\n  // Possible string inputs:\n  //\n  //     \"red\"\n  //     \"#f00\" or \"f00\"\n  //     \"#ff0000\" or \"ff0000\"\n  //     \"#ff000000\" or \"ff000000\"\n  //     \"rgb 255 0 0\" or \"rgb (255, 0, 0)\"\n  //     \"rgb 1.0 0 0\" or \"rgb (1, 0, 0)\"\n  //     \"rgba (255, 0, 0, 1)\" or \"rgba 255, 0, 0, 1\"\n  //     \"rgba (1.0, 0, 0, 1)\" or \"rgba 1.0, 0, 0, 1\"\n  //     \"hsl(0, 100%, 50%)\" or \"hsl 0 100% 50%\"\n  //     \"hsla(0, 100%, 50%, 1)\" or \"hsla 0 100% 50%, 1\"\n  //     \"hsv(0, 100%, 100%)\" or \"hsv 0 100% 100%\"\n  //\n  function inputToRGB(color) {\n    var rgb = {\n      r: 0,\n      g: 0,\n      b: 0\n    };\n    var a = 1;\n    var s = null;\n    var v = null;\n    var l = null;\n    var ok = false;\n    var format = false;\n    if (typeof color == \"string\") {\n      color = stringInputToObject(color);\n    }\n    if (_typeof(color) == \"object\") {\n      if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {\n        rgb = rgbToRgb(color.r, color.g, color.b);\n        ok = true;\n        format = String(color.r).substr(-1) === \"%\" ? \"prgb\" : \"rgb\";\n      } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {\n        s = convertToPercentage(color.s);\n        v = convertToPercentage(color.v);\n        rgb = hsvToRgb(color.h, s, v);\n        ok = true;\n        format = \"hsv\";\n      } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {\n        s = convertToPercentage(color.s);\n        l = convertToPercentage(color.l);\n        rgb = hslToRgb(color.h, s, l);\n        ok = true;\n        format = \"hsl\";\n      }\n      if (color.hasOwnProperty(\"a\")) {\n        a = color.a;\n      }\n    }\n    a = boundAlpha(a);\n    return {\n      ok: ok,\n      format: color.format || format,\n      r: Math.min(255, Math.max(rgb.r, 0)),\n      g: Math.min(255, Math.max(rgb.g, 0)),\n      b: Math.min(255, Math.max(rgb.b, 0)),\n      a: a\n    };\n  }\n\n  // Conversion Functions\n  // --------------------\n\n  // `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:\n  // <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>\n\n  // `rgbToRgb`\n  // Handle bounds / percentage checking to conform to CSS color spec\n  // <http://www.w3.org/TR/css3-color/>\n  // *Assumes:* r, g, b in [0, 255] or [0, 1]\n  // *Returns:* { r, g, b } in [0, 255]\n  function rgbToRgb(r, g, b) {\n    return {\n      r: bound01(r, 255) * 255,\n      g: bound01(g, 255) * 255,\n      b: bound01(b, 255) * 255\n    };\n  }\n\n  // `rgbToHsl`\n  // Converts an RGB color value to HSL.\n  // *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]\n  // *Returns:* { h, s, l } in [0,1]\n  function rgbToHsl(r, g, b) {\n    r = bound01(r, 255);\n    g = bound01(g, 255);\n    b = bound01(b, 255);\n    var max = Math.max(r, g, b),\n      min = Math.min(r, g, b);\n    var h,\n      s,\n      l = (max + min) / 2;\n    if (max == min) {\n      h = s = 0; // achromatic\n    } else {\n      var d = max - min;\n      s = l > 0.5 ? d / (2 - max - min) : d / (max + min);\n      switch (max) {\n        case r:\n          h = (g - b) / d + (g < b ? 6 : 0);\n          break;\n        case g:\n          h = (b - r) / d + 2;\n          break;\n        case b:\n          h = (r - g) / d + 4;\n          break;\n      }\n      h /= 6;\n    }\n    return {\n      h: h,\n      s: s,\n      l: l\n    };\n  }\n\n  // `hslToRgb`\n  // Converts an HSL color value to RGB.\n  // *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]\n  // *Returns:* { r, g, b } in the set [0, 255]\n  function hslToRgb(h, s, l) {\n    var r, g, b;\n    h = bound01(h, 360);\n    s = bound01(s, 100);\n    l = bound01(l, 100);\n    function hue2rgb(p, q, t) {\n      if (t < 0) t += 1;\n      if (t > 1) t -= 1;\n      if (t < 1 / 6) return p + (q - p) * 6 * t;\n      if (t < 1 / 2) return q;\n      if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;\n      return p;\n    }\n    if (s === 0) {\n      r = g = b = l; // achromatic\n    } else {\n      var q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n      var p = 2 * l - q;\n      r = hue2rgb(p, q, h + 1 / 3);\n      g = hue2rgb(p, q, h);\n      b = hue2rgb(p, q, h - 1 / 3);\n    }\n    return {\n      r: r * 255,\n      g: g * 255,\n      b: b * 255\n    };\n  }\n\n  // `rgbToHsv`\n  // Converts an RGB color value to HSV\n  // *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]\n  // *Returns:* { h, s, v } in [0,1]\n  function rgbToHsv(r, g, b) {\n    r = bound01(r, 255);\n    g = bound01(g, 255);\n    b = bound01(b, 255);\n    var max = Math.max(r, g, b),\n      min = Math.min(r, g, b);\n    var h,\n      s,\n      v = max;\n    var d = max - min;\n    s = max === 0 ? 0 : d / max;\n    if (max == min) {\n      h = 0; // achromatic\n    } else {\n      switch (max) {\n        case r:\n          h = (g - b) / d + (g < b ? 6 : 0);\n          break;\n        case g:\n          h = (b - r) / d + 2;\n          break;\n        case b:\n          h = (r - g) / d + 4;\n          break;\n      }\n      h /= 6;\n    }\n    return {\n      h: h,\n      s: s,\n      v: v\n    };\n  }\n\n  // `hsvToRgb`\n  // Converts an HSV color value to RGB.\n  // *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]\n  // *Returns:* { r, g, b } in the set [0, 255]\n  function hsvToRgb(h, s, v) {\n    h = bound01(h, 360) * 6;\n    s = bound01(s, 100);\n    v = bound01(v, 100);\n    var i = Math.floor(h),\n      f = h - i,\n      p = v * (1 - s),\n      q = v * (1 - f * s),\n      t = v * (1 - (1 - f) * s),\n      mod = i % 6,\n      r = [v, q, p, p, t, v][mod],\n      g = [t, v, v, q, p, p][mod],\n      b = [p, p, t, v, v, q][mod];\n    return {\n      r: r * 255,\n      g: g * 255,\n      b: b * 255\n    };\n  }\n\n  // `rgbToHex`\n  // Converts an RGB color to hex\n  // Assumes r, g, and b are contained in the set [0, 255]\n  // Returns a 3 or 6 character hex\n  function rgbToHex(r, g, b, allow3Char) {\n    var hex = [pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16))];\n\n    // Return a 3 character hex if possible\n    if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) {\n      return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);\n    }\n    return hex.join(\"\");\n  }\n\n  // `rgbaToHex`\n  // Converts an RGBA color plus alpha transparency to hex\n  // Assumes r, g, b are contained in the set [0, 255] and\n  // a in [0, 1]. Returns a 4 or 8 character rgba hex\n  function rgbaToHex(r, g, b, a, allow4Char) {\n    var hex = [pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16)), pad2(convertDecimalToHex(a))];\n\n    // Return a 4 character hex if possible\n    if (allow4Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1) && hex[3].charAt(0) == hex[3].charAt(1)) {\n      return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);\n    }\n    return hex.join(\"\");\n  }\n\n  // `rgbaToArgbHex`\n  // Converts an RGBA color to an ARGB Hex8 string\n  // Rarely used, but required for \"toFilter()\"\n  function rgbaToArgbHex(r, g, b, a) {\n    var hex = [pad2(convertDecimalToHex(a)), pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16))];\n    return hex.join(\"\");\n  }\n\n  // `equals`\n  // Can be called with any tinycolor input\n  tinycolor.equals = function (color1, color2) {\n    if (!color1 || !color2) return false;\n    return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();\n  };\n  tinycolor.random = function () {\n    return tinycolor.fromRatio({\n      r: Math.random(),\n      g: Math.random(),\n      b: Math.random()\n    });\n  };\n\n  // Modification Functions\n  // ----------------------\n  // Thanks to less.js for some of the basics here\n  // <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js>\n\n  function _desaturate(color, amount) {\n    amount = amount === 0 ? 0 : amount || 10;\n    var hsl = tinycolor(color).toHsl();\n    hsl.s -= amount / 100;\n    hsl.s = clamp01(hsl.s);\n    return tinycolor(hsl);\n  }\n  function _saturate(color, amount) {\n    amount = amount === 0 ? 0 : amount || 10;\n    var hsl = tinycolor(color).toHsl();\n    hsl.s += amount / 100;\n    hsl.s = clamp01(hsl.s);\n    return tinycolor(hsl);\n  }\n  function _greyscale(color) {\n    return tinycolor(color).desaturate(100);\n  }\n  function _lighten(color, amount) {\n    amount = amount === 0 ? 0 : amount || 10;\n    var hsl = tinycolor(color).toHsl();\n    hsl.l += amount / 100;\n    hsl.l = clamp01(hsl.l);\n    return tinycolor(hsl);\n  }\n  function _brighten(color, amount) {\n    amount = amount === 0 ? 0 : amount || 10;\n    var rgb = tinycolor(color).toRgb();\n    rgb.r = Math.max(0, Math.min(255, rgb.r - Math.round(255 * -(amount / 100))));\n    rgb.g = Math.max(0, Math.min(255, rgb.g - Math.round(255 * -(amount / 100))));\n    rgb.b = Math.max(0, Math.min(255, rgb.b - Math.round(255 * -(amount / 100))));\n    return tinycolor(rgb);\n  }\n  function _darken(color, amount) {\n    amount = amount === 0 ? 0 : amount || 10;\n    var hsl = tinycolor(color).toHsl();\n    hsl.l -= amount / 100;\n    hsl.l = clamp01(hsl.l);\n    return tinycolor(hsl);\n  }\n\n  // Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.\n  // Values outside of this range will be wrapped into this range.\n  function _spin(color, amount) {\n    var hsl = tinycolor(color).toHsl();\n    var hue = (hsl.h + amount) % 360;\n    hsl.h = hue < 0 ? 360 + hue : hue;\n    return tinycolor(hsl);\n  }\n\n  // Combination Functions\n  // ---------------------\n  // Thanks to jQuery xColor for some of the ideas behind these\n  // <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js>\n\n  function _complement(color) {\n    var hsl = tinycolor(color).toHsl();\n    hsl.h = (hsl.h + 180) % 360;\n    return tinycolor(hsl);\n  }\n  function polyad(color, number) {\n    if (isNaN(number) || number <= 0) {\n      throw new Error(\"Argument to polyad must be a positive number\");\n    }\n    var hsl = tinycolor(color).toHsl();\n    var result = [tinycolor(color)];\n    var step = 360 / number;\n    for (var i = 1; i < number; i++) {\n      result.push(tinycolor({\n        h: (hsl.h + i * step) % 360,\n        s: hsl.s,\n        l: hsl.l\n      }));\n    }\n    return result;\n  }\n  function _splitcomplement(color) {\n    var hsl = tinycolor(color).toHsl();\n    var h = hsl.h;\n    return [tinycolor(color), tinycolor({\n      h: (h + 72) % 360,\n      s: hsl.s,\n      l: hsl.l\n    }), tinycolor({\n      h: (h + 216) % 360,\n      s: hsl.s,\n      l: hsl.l\n    })];\n  }\n  function _analogous(color, results, slices) {\n    results = results || 6;\n    slices = slices || 30;\n    var hsl = tinycolor(color).toHsl();\n    var part = 360 / slices;\n    var ret = [tinycolor(color)];\n    for (hsl.h = (hsl.h - (part * results >> 1) + 720) % 360; --results;) {\n      hsl.h = (hsl.h + part) % 360;\n      ret.push(tinycolor(hsl));\n    }\n    return ret;\n  }\n  function _monochromatic(color, results) {\n    results = results || 6;\n    var hsv = tinycolor(color).toHsv();\n    var h = hsv.h,\n      s = hsv.s,\n      v = hsv.v;\n    var ret = [];\n    var modification = 1 / results;\n    while (results--) {\n      ret.push(tinycolor({\n        h: h,\n        s: s,\n        v: v\n      }));\n      v = (v + modification) % 1;\n    }\n    return ret;\n  }\n\n  // Utility Functions\n  // ---------------------\n\n  tinycolor.mix = function (color1, color2, amount) {\n    amount = amount === 0 ? 0 : amount || 50;\n    var rgb1 = tinycolor(color1).toRgb();\n    var rgb2 = tinycolor(color2).toRgb();\n    var p = amount / 100;\n    var rgba = {\n      r: (rgb2.r - rgb1.r) * p + rgb1.r,\n      g: (rgb2.g - rgb1.g) * p + rgb1.g,\n      b: (rgb2.b - rgb1.b) * p + rgb1.b,\n      a: (rgb2.a - rgb1.a) * p + rgb1.a\n    };\n    return tinycolor(rgba);\n  };\n\n  // Readability Functions\n  // ---------------------\n  // <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)\n\n  // `contrast`\n  // Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)\n  tinycolor.readability = function (color1, color2) {\n    var c1 = tinycolor(color1);\n    var c2 = tinycolor(color2);\n    return (Math.max(c1.getLuminance(), c2.getLuminance()) + 0.05) / (Math.min(c1.getLuminance(), c2.getLuminance()) + 0.05);\n  };\n\n  // `isReadable`\n  // Ensure that foreground and background color combinations meet WCAG2 guidelines.\n  // The third argument is an optional Object.\n  //      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';\n  //      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.\n  // If the entire object is absent, isReadable defaults to {level:\"AA\",size:\"small\"}.\n\n  // *Example*\n  //    tinycolor.isReadable(\"#000\", \"#111\") => false\n  //    tinycolor.isReadable(\"#000\", \"#111\",{level:\"AA\",size:\"large\"}) => false\n  tinycolor.isReadable = function (color1, color2, wcag2) {\n    var readability = tinycolor.readability(color1, color2);\n    var wcag2Parms, out;\n    out = false;\n    wcag2Parms = validateWCAG2Parms(wcag2);\n    switch (wcag2Parms.level + wcag2Parms.size) {\n      case \"AAsmall\":\n      case \"AAAlarge\":\n        out = readability >= 4.5;\n        break;\n      case \"AAlarge\":\n        out = readability >= 3;\n        break;\n      case \"AAAsmall\":\n        out = readability >= 7;\n        break;\n    }\n    return out;\n  };\n\n  // `mostReadable`\n  // Given a base color and a list of possible foreground or background\n  // colors for that base, returns the most readable color.\n  // Optionally returns Black or White if the most readable color is unreadable.\n  // *Example*\n  //    tinycolor.mostReadable(tinycolor.mostReadable(\"#123\", [\"#124\", \"#125\"],{includeFallbackColors:false}).toHexString(); // \"#112255\"\n  //    tinycolor.mostReadable(tinycolor.mostReadable(\"#123\", [\"#124\", \"#125\"],{includeFallbackColors:true}).toHexString();  // \"#ffffff\"\n  //    tinycolor.mostReadable(\"#a8015a\", [\"#faf3f3\"],{includeFallbackColors:true,level:\"AAA\",size:\"large\"}).toHexString(); // \"#faf3f3\"\n  //    tinycolor.mostReadable(\"#a8015a\", [\"#faf3f3\"],{includeFallbackColors:true,level:\"AAA\",size:\"small\"}).toHexString(); // \"#ffffff\"\n  tinycolor.mostReadable = function (baseColor, colorList, args) {\n    var bestColor = null;\n    var bestScore = 0;\n    var readability;\n    var includeFallbackColors, level, size;\n    args = args || {};\n    includeFallbackColors = args.includeFallbackColors;\n    level = args.level;\n    size = args.size;\n    for (var i = 0; i < colorList.length; i++) {\n      readability = tinycolor.readability(baseColor, colorList[i]);\n      if (readability > bestScore) {\n        bestScore = readability;\n        bestColor = tinycolor(colorList[i]);\n      }\n    }\n    if (tinycolor.isReadable(baseColor, bestColor, {\n      level: level,\n      size: size\n    }) || !includeFallbackColors) {\n      return bestColor;\n    } else {\n      args.includeFallbackColors = false;\n      return tinycolor.mostReadable(baseColor, [\"#fff\", \"#000\"], args);\n    }\n  };\n\n  // Big List of Colors\n  // ------------------\n  // <https://www.w3.org/TR/css-color-4/#named-colors>\n  var names = tinycolor.names = {\n    aliceblue: \"f0f8ff\",\n    antiquewhite: \"faebd7\",\n    aqua: \"0ff\",\n    aquamarine: \"7fffd4\",\n    azure: \"f0ffff\",\n    beige: \"f5f5dc\",\n    bisque: \"ffe4c4\",\n    black: \"000\",\n    blanchedalmond: \"ffebcd\",\n    blue: \"00f\",\n    blueviolet: \"8a2be2\",\n    brown: \"a52a2a\",\n    burlywood: \"deb887\",\n    burntsienna: \"ea7e5d\",\n    cadetblue: \"5f9ea0\",\n    chartreuse: \"7fff00\",\n    chocolate: \"d2691e\",\n    coral: \"ff7f50\",\n    cornflowerblue: \"6495ed\",\n    cornsilk: \"fff8dc\",\n    crimson: \"dc143c\",\n    cyan: \"0ff\",\n    darkblue: \"00008b\",\n    darkcyan: \"008b8b\",\n    darkgoldenrod: \"b8860b\",\n    darkgray: \"a9a9a9\",\n    darkgreen: \"006400\",\n    darkgrey: \"a9a9a9\",\n    darkkhaki: \"bdb76b\",\n    darkmagenta: \"8b008b\",\n    darkolivegreen: \"556b2f\",\n    darkorange: \"ff8c00\",\n    darkorchid: \"9932cc\",\n    darkred: \"8b0000\",\n    darksalmon: \"e9967a\",\n    darkseagreen: \"8fbc8f\",\n    darkslateblue: \"483d8b\",\n    darkslategray: \"2f4f4f\",\n    darkslategrey: \"2f4f4f\",\n    darkturquoise: \"00ced1\",\n    darkviolet: \"9400d3\",\n    deeppink: \"ff1493\",\n    deepskyblue: \"00bfff\",\n    dimgray: \"696969\",\n    dimgrey: \"696969\",\n    dodgerblue: \"1e90ff\",\n    firebrick: \"b22222\",\n    floralwhite: \"fffaf0\",\n    forestgreen: \"228b22\",\n    fuchsia: \"f0f\",\n    gainsboro: \"dcdcdc\",\n    ghostwhite: \"f8f8ff\",\n    gold: \"ffd700\",\n    goldenrod: \"daa520\",\n    gray: \"808080\",\n    green: \"008000\",\n    greenyellow: \"adff2f\",\n    grey: \"808080\",\n    honeydew: \"f0fff0\",\n    hotpink: \"ff69b4\",\n    indianred: \"cd5c5c\",\n    indigo: \"4b0082\",\n    ivory: \"fffff0\",\n    khaki: \"f0e68c\",\n    lavender: \"e6e6fa\",\n    lavenderblush: \"fff0f5\",\n    lawngreen: \"7cfc00\",\n    lemonchiffon: \"fffacd\",\n    lightblue: \"add8e6\",\n    lightcoral: \"f08080\",\n    lightcyan: \"e0ffff\",\n    lightgoldenrodyellow: \"fafad2\",\n    lightgray: \"d3d3d3\",\n    lightgreen: \"90ee90\",\n    lightgrey: \"d3d3d3\",\n    lightpink: \"ffb6c1\",\n    lightsalmon: \"ffa07a\",\n    lightseagreen: \"20b2aa\",\n    lightskyblue: \"87cefa\",\n    lightslategray: \"789\",\n    lightslategrey: \"789\",\n    lightsteelblue: \"b0c4de\",\n    lightyellow: \"ffffe0\",\n    lime: \"0f0\",\n    limegreen: \"32cd32\",\n    linen: \"faf0e6\",\n    magenta: \"f0f\",\n    maroon: \"800000\",\n    mediumaquamarine: \"66cdaa\",\n    mediumblue: \"0000cd\",\n    mediumorchid: \"ba55d3\",\n    mediumpurple: \"9370db\",\n    mediumseagreen: \"3cb371\",\n    mediumslateblue: \"7b68ee\",\n    mediumspringgreen: \"00fa9a\",\n    mediumturquoise: \"48d1cc\",\n    mediumvioletred: \"c71585\",\n    midnightblue: \"191970\",\n    mintcream: \"f5fffa\",\n    mistyrose: \"ffe4e1\",\n    moccasin: \"ffe4b5\",\n    navajowhite: \"ffdead\",\n    navy: \"000080\",\n    oldlace: \"fdf5e6\",\n    olive: \"808000\",\n    olivedrab: \"6b8e23\",\n    orange: \"ffa500\",\n    orangered: \"ff4500\",\n    orchid: \"da70d6\",\n    palegoldenrod: \"eee8aa\",\n    palegreen: \"98fb98\",\n    paleturquoise: \"afeeee\",\n    palevioletred: \"db7093\",\n    papayawhip: \"ffefd5\",\n    peachpuff: \"ffdab9\",\n    peru: \"cd853f\",\n    pink: \"ffc0cb\",\n    plum: \"dda0dd\",\n    powderblue: \"b0e0e6\",\n    purple: \"800080\",\n    rebeccapurple: \"663399\",\n    red: \"f00\",\n    rosybrown: \"bc8f8f\",\n    royalblue: \"4169e1\",\n    saddlebrown: \"8b4513\",\n    salmon: \"fa8072\",\n    sandybrown: \"f4a460\",\n    seagreen: \"2e8b57\",\n    seashell: \"fff5ee\",\n    sienna: \"a0522d\",\n    silver: \"c0c0c0\",\n    skyblue: \"87ceeb\",\n    slateblue: \"6a5acd\",\n    slategray: \"708090\",\n    slategrey: \"708090\",\n    snow: \"fffafa\",\n    springgreen: \"00ff7f\",\n    steelblue: \"4682b4\",\n    tan: \"d2b48c\",\n    teal: \"008080\",\n    thistle: \"d8bfd8\",\n    tomato: \"ff6347\",\n    turquoise: \"40e0d0\",\n    violet: \"ee82ee\",\n    wheat: \"f5deb3\",\n    white: \"fff\",\n    whitesmoke: \"f5f5f5\",\n    yellow: \"ff0\",\n    yellowgreen: \"9acd32\"\n  };\n\n  // Make it easy to access colors via `hexNames[hex]`\n  var hexNames = tinycolor.hexNames = flip(names);\n\n  // Utilities\n  // ---------\n\n  // `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }`\n  function flip(o) {\n    var flipped = {};\n    for (var i in o) {\n      if (o.hasOwnProperty(i)) {\n        flipped[o[i]] = i;\n      }\n    }\n    return flipped;\n  }\n\n  // Return a valid alpha value [0,1] with all invalid values being set to 1\n  function boundAlpha(a) {\n    a = parseFloat(a);\n    if (isNaN(a) || a < 0 || a > 1) {\n      a = 1;\n    }\n    return a;\n  }\n\n  // Take input from [0, n] and return it as [0, 1]\n  function bound01(n, max) {\n    if (isOnePointZero(n)) n = \"100%\";\n    var processPercent = isPercentage(n);\n    n = Math.min(max, Math.max(0, parseFloat(n)));\n\n    // Automatically convert percentage into number\n    if (processPercent) {\n      n = parseInt(n * max, 10) / 100;\n    }\n\n    // Handle floating point rounding errors\n    if (Math.abs(n - max) < 0.000001) {\n      return 1;\n    }\n\n    // Convert into [0, 1] range if it isn't already\n    return n % max / parseFloat(max);\n  }\n\n  // Force a number between 0 and 1\n  function clamp01(val) {\n    return Math.min(1, Math.max(0, val));\n  }\n\n  // Parse a base-16 hex value into a base-10 integer\n  function parseIntFromHex(val) {\n    return parseInt(val, 16);\n  }\n\n  // Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1\n  // <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>\n  function isOnePointZero(n) {\n    return typeof n == \"string\" && n.indexOf(\".\") != -1 && parseFloat(n) === 1;\n  }\n\n  // Check to see if string passed in is a percentage\n  function isPercentage(n) {\n    return typeof n === \"string\" && n.indexOf(\"%\") != -1;\n  }\n\n  // Force a hex value to have 2 characters\n  function pad2(c) {\n    return c.length == 1 ? \"0\" + c : \"\" + c;\n  }\n\n  // Replace a decimal with it's percentage value\n  function convertToPercentage(n) {\n    if (n <= 1) {\n      n = n * 100 + \"%\";\n    }\n    return n;\n  }\n\n  // Converts a decimal to a hex value\n  function convertDecimalToHex(d) {\n    return Math.round(parseFloat(d) * 255).toString(16);\n  }\n  // Converts a hex value to a decimal\n  function convertHexToDecimal(h) {\n    return parseIntFromHex(h) / 255;\n  }\n  var matchers = function () {\n    // <http://www.w3.org/TR/css3-values/#integers>\n    var CSS_INTEGER = \"[-\\\\+]?\\\\d+%?\";\n\n    // <http://www.w3.org/TR/css3-values/#number-value>\n    var CSS_NUMBER = \"[-\\\\+]?\\\\d*\\\\.\\\\d+%?\";\n\n    // Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.\n    var CSS_UNIT = \"(?:\" + CSS_NUMBER + \")|(?:\" + CSS_INTEGER + \")\";\n\n    // Actual matching.\n    // Parentheses and commas are optional, but not required.\n    // Whitespace can take the place of commas or opening paren\n    var PERMISSIVE_MATCH3 = \"[\\\\s|\\\\(]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")\\\\s*\\\\)?\";\n    var PERMISSIVE_MATCH4 = \"[\\\\s|\\\\(]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")\\\\s*\\\\)?\";\n    return {\n      CSS_UNIT: new RegExp(CSS_UNIT),\n      rgb: new RegExp(\"rgb\" + PERMISSIVE_MATCH3),\n      rgba: new RegExp(\"rgba\" + PERMISSIVE_MATCH4),\n      hsl: new RegExp(\"hsl\" + PERMISSIVE_MATCH3),\n      hsla: new RegExp(\"hsla\" + PERMISSIVE_MATCH4),\n      hsv: new RegExp(\"hsv\" + PERMISSIVE_MATCH3),\n      hsva: new RegExp(\"hsva\" + PERMISSIVE_MATCH4),\n      hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,\n      hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,\n      hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,\n      hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/\n    };\n  }();\n\n  // `isValidCSSUnit`\n  // Take in a single string / number and check to see if it looks like a CSS unit\n  // (see `matchers` above for definition).\n  function isValidCSSUnit(color) {\n    return !!matchers.CSS_UNIT.exec(color);\n  }\n\n  // `stringInputToObject`\n  // Permissive string parsing.  Take in a number of formats, and output an object\n  // based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`\n  function stringInputToObject(color) {\n    color = color.replace(trimLeft, \"\").replace(trimRight, \"\").toLowerCase();\n    var named = false;\n    if (names[color]) {\n      color = names[color];\n      named = true;\n    } else if (color == \"transparent\") {\n      return {\n        r: 0,\n        g: 0,\n        b: 0,\n        a: 0,\n        format: \"name\"\n      };\n    }\n\n    // Try to match string input using regular expressions.\n    // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]\n    // Just return an object and let the conversion functions handle that.\n    // This way the result will be the same whether the tinycolor is initialized with string or object.\n    var match;\n    if (match = matchers.rgb.exec(color)) {\n      return {\n        r: match[1],\n        g: match[2],\n        b: match[3]\n      };\n    }\n    if (match = matchers.rgba.exec(color)) {\n      return {\n        r: match[1],\n        g: match[2],\n        b: match[3],\n        a: match[4]\n      };\n    }\n    if (match = matchers.hsl.exec(color)) {\n      return {\n        h: match[1],\n        s: match[2],\n        l: match[3]\n      };\n    }\n    if (match = matchers.hsla.exec(color)) {\n      return {\n        h: match[1],\n        s: match[2],\n        l: match[3],\n        a: match[4]\n      };\n    }\n    if (match = matchers.hsv.exec(color)) {\n      return {\n        h: match[1],\n        s: match[2],\n        v: match[3]\n      };\n    }\n    if (match = matchers.hsva.exec(color)) {\n      return {\n        h: match[1],\n        s: match[2],\n        v: match[3],\n        a: match[4]\n      };\n    }\n    if (match = matchers.hex8.exec(color)) {\n      return {\n        r: parseIntFromHex(match[1]),\n        g: parseIntFromHex(match[2]),\n        b: parseIntFromHex(match[3]),\n        a: convertHexToDecimal(match[4]),\n        format: named ? \"name\" : \"hex8\"\n      };\n    }\n    if (match = matchers.hex6.exec(color)) {\n      return {\n        r: parseIntFromHex(match[1]),\n        g: parseIntFromHex(match[2]),\n        b: parseIntFromHex(match[3]),\n        format: named ? \"name\" : \"hex\"\n      };\n    }\n    if (match = matchers.hex4.exec(color)) {\n      return {\n        r: parseIntFromHex(match[1] + \"\" + match[1]),\n        g: parseIntFromHex(match[2] + \"\" + match[2]),\n        b: parseIntFromHex(match[3] + \"\" + match[3]),\n        a: convertHexToDecimal(match[4] + \"\" + match[4]),\n        format: named ? \"name\" : \"hex8\"\n      };\n    }\n    if (match = matchers.hex3.exec(color)) {\n      return {\n        r: parseIntFromHex(match[1] + \"\" + match[1]),\n        g: parseIntFromHex(match[2] + \"\" + match[2]),\n        b: parseIntFromHex(match[3] + \"\" + match[3]),\n        format: named ? \"name\" : \"hex\"\n      };\n    }\n    return false;\n  }\n  function validateWCAG2Parms(parms) {\n    // return valid WCAG2 parms for isReadable.\n    // If input parms are invalid, return {\"level\":\"AA\", \"size\":\"small\"}\n    var level, size;\n    parms = parms || {\n      level: \"AA\",\n      size: \"small\"\n    };\n    level = (parms.level || \"AA\").toUpperCase();\n    size = (parms.size || \"small\").toLowerCase();\n    if (level !== \"AA\" && level !== \"AAA\") {\n      level = \"AA\";\n    }\n    if (size !== \"small\" && size !== \"large\") {\n      size = \"small\";\n    }\n    return {\n      level: level,\n      size: size\n    };\n  }\n\n  return tinycolor;\n\n}));\n","// Current version.\nexport var VERSION = '1.13.7';\n\n// Establish the root object, `window` (`self`) in the browser, `global`\n// on the server, or `this` in some virtual machines. We use `self`\n// instead of `window` for `WebWorker` support.\nexport var root = (typeof self == 'object' && self.self === self && self) ||\n          (typeof global == 'object' && global.global === global && global) ||\n          Function('return this')() ||\n          {};\n\n// Save bytes in the minified (but not gzipped) version:\nexport var ArrayProto = Array.prototype, ObjProto = Object.prototype;\nexport var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;\n\n// Create quick reference variables for speed access to core prototypes.\nexport var push = ArrayProto.push,\n    slice = ArrayProto.slice,\n    toString = ObjProto.toString,\n    hasOwnProperty = ObjProto.hasOwnProperty;\n\n// Modern feature detection.\nexport var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined',\n    supportsDataView = typeof DataView !== 'undefined';\n\n// All **ECMAScript 5+** native function implementations that we hope to use\n// are declared here.\nexport var nativeIsArray = Array.isArray,\n    nativeKeys = Object.keys,\n    nativeCreate = Object.create,\n    nativeIsView = supportsArrayBuffer && ArrayBuffer.isView;\n\n// Create references to these builtin functions because we override them.\nexport var _isNaN = isNaN,\n    _isFinite = isFinite;\n\n// Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\nexport var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\nexport var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n  'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n// The largest integer that can be represented exactly.\nexport var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n","// Some functions take a variable number of arguments, or a few expected\n// arguments at the beginning and then a variable number of values to operate\n// on. This helper accumulates all remaining arguments past the function’s\n// argument length (or an explicit `startIndex`), into an array that becomes\n// the last argument. Similar to ES6’s \"rest parameter\".\nexport default function restArguments(func, startIndex) {\n  startIndex = startIndex == null ? func.length - 1 : +startIndex;\n  return function() {\n    var length = Math.max(arguments.length - startIndex, 0),\n        rest = Array(length),\n        index = 0;\n    for (; index < length; index++) {\n      rest[index] = arguments[index + startIndex];\n    }\n    switch (startIndex) {\n      case 0: return func.call(this, rest);\n      case 1: return func.call(this, arguments[0], rest);\n      case 2: return func.call(this, arguments[0], arguments[1], rest);\n    }\n    var args = Array(startIndex + 1);\n    for (index = 0; index < startIndex; index++) {\n      args[index] = arguments[index];\n    }\n    args[startIndex] = rest;\n    return func.apply(this, args);\n  };\n}\n","// Is a given variable an object?\nexport default function isObject(obj) {\n  var type = typeof obj;\n  return type === 'function' || (type === 'object' && !!obj);\n}\n","// Is a given value equal to null?\nexport default function isNull(obj) {\n  return obj === null;\n}\n","// Is a given variable undefined?\nexport default function isUndefined(obj) {\n  return obj === void 0;\n}\n","import { toString } from './_setup.js';\n\n// Is a given value a boolean?\nexport default function isBoolean(obj) {\n  return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n}\n","// Is a given value a DOM element?\nexport default function isElement(obj) {\n  return !!(obj && obj.nodeType === 1);\n}\n","import { toString } from './_setup.js';\n\n// Internal function for creating a `toString`-based type tester.\nexport default function tagTester(name) {\n  var tag = '[object ' + name + ']';\n  return function(obj) {\n    return toString.call(obj) === tag;\n  };\n}\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('String');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Number');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Date');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('RegExp');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Error');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Symbol');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('ArrayBuffer');\n","import tagTester from './_tagTester.js';\nimport { root } from './_setup.js';\n\nvar isFunction = tagTester('Function');\n\n// Optimize `isFunction` if appropriate. Work around some `typeof` bugs in old\n// v8, IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236).\nvar nodelist = root.document && root.document.childNodes;\nif (typeof /./ != 'function' && typeof Int8Array != 'object' && typeof nodelist != 'function') {\n  isFunction = function(obj) {\n    return typeof obj == 'function' || false;\n  };\n}\n\nexport default isFunction;\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Object');\n","import { supportsDataView } from './_setup.js';\nimport hasObjectTag from './_hasObjectTag.js';\n\n// In IE 10 - Edge 13, `DataView` has string tag `'[object Object]'`.\n// In IE 11, the most common among them, this problem also applies to\n// `Map`, `WeakMap` and `Set`.\n// Also, there are cases where an application can override the native\n// `DataView` object, in cases like that we can't use the constructor\n// safely and should just rely on alternate `DataView` checks\nexport var hasDataViewBug = (\n      supportsDataView && (!/\\[native code\\]/.test(String(DataView)) || hasObjectTag(new DataView(new ArrayBuffer(8))))\n    ),\n    isIE11 = (typeof Map !== 'undefined' && hasObjectTag(new Map));\n","import tagTester from './_tagTester.js';\nimport isFunction from './isFunction.js';\nimport isArrayBuffer from './isArrayBuffer.js';\nimport { hasDataViewBug } from './_stringTagBug.js';\n\nvar isDataView = tagTester('DataView');\n\n// In IE 10 - Edge 13, we need a different heuristic\n// to determine whether an object is a `DataView`.\n// Also, in cases where the native `DataView` is\n// overridden we can't rely on the tag itself.\nfunction alternateIsDataView(obj) {\n  return obj != null && isFunction(obj.getInt8) && isArrayBuffer(obj.buffer);\n}\n\nexport default (hasDataViewBug ? alternateIsDataView : isDataView);\n","import { nativeIsArray } from './_setup.js';\nimport tagTester from './_tagTester.js';\n\n// Is a given value an array?\n// Delegates to ECMA5's native `Array.isArray`.\nexport default nativeIsArray || tagTester('Array');\n","import { hasOwnProperty } from './_setup.js';\n\n// Internal function to check whether `key` is an own property name of `obj`.\nexport default function has(obj, key) {\n  return obj != null && hasOwnProperty.call(obj, key);\n}\n","import tagTester from './_tagTester.js';\nimport has from './_has.js';\n\nvar isArguments = tagTester('Arguments');\n\n// Define a fallback version of the method in browsers (ahem, IE < 9), where\n// there isn't any inspectable \"Arguments\" type.\n(function() {\n  if (!isArguments(arguments)) {\n    isArguments = function(obj) {\n      return has(obj, 'callee');\n    };\n  }\n}());\n\nexport default isArguments;\n","import { _isFinite } from './_setup.js';\nimport isSymbol from './isSymbol.js';\n\n// Is a given object a finite number?\nexport default function isFinite(obj) {\n  return !isSymbol(obj) && _isFinite(obj) && !isNaN(parseFloat(obj));\n}\n","import { _isNaN } from './_setup.js';\nimport isNumber from './isNumber.js';\n\n// Is the given value `NaN`?\nexport default function isNaN(obj) {\n  return isNumber(obj) && _isNaN(obj);\n}\n","// Predicate-generating function. Often useful outside of Underscore.\nexport default function constant(value) {\n  return function() {\n    return value;\n  };\n}\n","import { MAX_ARRAY_INDEX } from './_setup.js';\n\n// Common internal logic for `isArrayLike` and `isBufferLike`.\nexport default function createSizePropertyCheck(getSizeProperty) {\n  return function(collection) {\n    var sizeProperty = getSizeProperty(collection);\n    return typeof sizeProperty == 'number' && sizeProperty >= 0 && sizeProperty <= MAX_ARRAY_INDEX;\n  }\n}\n","// Internal helper to generate a function to obtain property `key` from `obj`.\nexport default function shallowProperty(key) {\n  return function(obj) {\n    return obj == null ? void 0 : obj[key];\n  };\n}\n","import shallowProperty from './_shallowProperty.js';\n\n// Internal helper to obtain the `byteLength` property of an object.\nexport default shallowProperty('byteLength');\n","import createSizePropertyCheck from './_createSizePropertyCheck.js';\nimport getByteLength from './_getByteLength.js';\n\n// Internal helper to determine whether we should spend extensive checks against\n// `ArrayBuffer` et al.\nexport default createSizePropertyCheck(getByteLength);\n","import { supportsArrayBuffer, nativeIsView, toString } from './_setup.js';\nimport isDataView from './isDataView.js';\nimport constant from './constant.js';\nimport isBufferLike from './_isBufferLike.js';\n\n// Is a given value a typed array?\nvar typedArrayPattern = /\\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\\]/;\nfunction isTypedArray(obj) {\n  // `ArrayBuffer.isView` is the most future-proof, so use it when available.\n  // Otherwise, fall back on the above regular expression.\n  return nativeIsView ? (nativeIsView(obj) && !isDataView(obj)) :\n                isBufferLike(obj) && typedArrayPattern.test(toString.call(obj));\n}\n\nexport default supportsArrayBuffer ? isTypedArray : constant(false);\n","import shallowProperty from './_shallowProperty.js';\n\n// Internal helper to obtain the `length` property of an object.\nexport default shallowProperty('length');\n","import { nonEnumerableProps, ObjProto } from './_setup.js';\nimport isFunction from './isFunction.js';\nimport has from './_has.js';\n\n// Internal helper to create a simple lookup structure.\n// `collectNonEnumProps` used to depend on `_.contains`, but this led to\n// circular imports. `emulatedSet` is a one-off solution that only works for\n// arrays of strings.\nfunction emulatedSet(keys) {\n  var hash = {};\n  for (var l = keys.length, i = 0; i < l; ++i) hash[keys[i]] = true;\n  return {\n    contains: function(key) { return hash[key] === true; },\n    push: function(key) {\n      hash[key] = true;\n      return keys.push(key);\n    }\n  };\n}\n\n// Internal helper. Checks `keys` for the presence of keys in IE < 9 that won't\n// be iterated by `for key in ...` and thus missed. Extends `keys` in place if\n// needed.\nexport default function collectNonEnumProps(obj, keys) {\n  keys = emulatedSet(keys);\n  var nonEnumIdx = nonEnumerableProps.length;\n  var constructor = obj.constructor;\n  var proto = (isFunction(constructor) && constructor.prototype) || ObjProto;\n\n  // Constructor is a special case.\n  var prop = 'constructor';\n  if (has(obj, prop) && !keys.contains(prop)) keys.push(prop);\n\n  while (nonEnumIdx--) {\n    prop = nonEnumerableProps[nonEnumIdx];\n    if (prop in obj && obj[prop] !== proto[prop] && !keys.contains(prop)) {\n      keys.push(prop);\n    }\n  }\n}\n","import isObject from './isObject.js';\nimport { nativeKeys, hasEnumBug } from './_setup.js';\nimport has from './_has.js';\nimport collectNonEnumProps from './_collectNonEnumProps.js';\n\n// Retrieve the names of an object's own properties.\n// Delegates to **ECMAScript 5**'s native `Object.keys`.\nexport default function keys(obj) {\n  if (!isObject(obj)) return [];\n  if (nativeKeys) return nativeKeys(obj);\n  var keys = [];\n  for (var key in obj) if (has(obj, key)) keys.push(key);\n  // Ahem, IE < 9.\n  if (hasEnumBug) collectNonEnumProps(obj, keys);\n  return keys;\n}\n","import getLength from './_getLength.js';\nimport isArray from './isArray.js';\nimport isString from './isString.js';\nimport isArguments from './isArguments.js';\nimport keys from './keys.js';\n\n// Is a given array, string, or object empty?\n// An \"empty\" object has no enumerable own-properties.\nexport default function isEmpty(obj) {\n  if (obj == null) return true;\n  // Skip the more expensive `toString`-based type checks if `obj` has no\n  // `.length`.\n  var length = getLength(obj);\n  if (typeof length == 'number' && (\n    isArray(obj) || isString(obj) || isArguments(obj)\n  )) return length === 0;\n  return getLength(keys(obj)) === 0;\n}\n","import keys from './keys.js';\n\n// Returns whether an object has a given set of `key:value` pairs.\nexport default function isMatch(object, attrs) {\n  var _keys = keys(attrs), length = _keys.length;\n  if (object == null) return !length;\n  var obj = Object(object);\n  for (var i = 0; i < length; i++) {\n    var key = _keys[i];\n    if (attrs[key] !== obj[key] || !(key in obj)) return false;\n  }\n  return true;\n}\n","import { VERSION } from './_setup.js';\n\n// If Underscore is called as a function, it returns a wrapped object that can\n// be used OO-style. This wrapper holds altered versions of all functions added\n// through `_.mixin`. Wrapped objects may be chained.\nexport default function _(obj) {\n  if (obj instanceof _) return obj;\n  if (!(this instanceof _)) return new _(obj);\n  this._wrapped = obj;\n}\n\n_.VERSION = VERSION;\n\n// Extracts the result from a wrapped and chained object.\n_.prototype.value = function() {\n  return this._wrapped;\n};\n\n// Provide unwrapping proxies for some methods used in engine operations\n// such as arithmetic and JSON stringification.\n_.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\n\n_.prototype.toString = function() {\n  return String(this._wrapped);\n};\n","import getByteLength from './_getByteLength.js';\n\n// Internal function to wrap or shallow-copy an ArrayBuffer,\n// typed array or DataView to a new view, reusing the buffer.\nexport default function toBufferView(bufferSource) {\n  return new Uint8Array(\n    bufferSource.buffer || bufferSource,\n    bufferSource.byteOffset || 0,\n    getByteLength(bufferSource)\n  );\n}\n","import _ from './underscore.js';\nimport { toString, SymbolProto } from './_setup.js';\nimport getByteLength from './_getByteLength.js';\nimport isTypedArray from './isTypedArray.js';\nimport isFunction from './isFunction.js';\nimport { hasDataViewBug }  from './_stringTagBug.js';\nimport isDataView from './isDataView.js';\nimport keys from './keys.js';\nimport has from './_has.js';\nimport toBufferView from './_toBufferView.js';\n\n// We use this string twice, so give it a name for minification.\nvar tagDataView = '[object DataView]';\n\n// Internal recursive comparison function for `_.isEqual`.\nfunction eq(a, b, aStack, bStack) {\n  // Identical objects are equal. `0 === -0`, but they aren't identical.\n  // See the [Harmony `egal` proposal](https://wiki.ecmascript.org/doku.php?id=harmony:egal).\n  if (a === b) return a !== 0 || 1 / a === 1 / b;\n  // `null` or `undefined` only equal to itself (strict comparison).\n  if (a == null || b == null) return false;\n  // `NaN`s are equivalent, but non-reflexive.\n  if (a !== a) return b !== b;\n  // Exhaust primitive checks\n  var type = typeof a;\n  if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;\n  return deepEq(a, b, aStack, bStack);\n}\n\n// Internal recursive comparison function for `_.isEqual`.\nfunction deepEq(a, b, aStack, bStack) {\n  // Unwrap any wrapped objects.\n  if (a instanceof _) a = a._wrapped;\n  if (b instanceof _) b = b._wrapped;\n  // Compare `[[Class]]` names.\n  var className = toString.call(a);\n  if (className !== toString.call(b)) return false;\n  // Work around a bug in IE 10 - Edge 13.\n  if (hasDataViewBug && className == '[object Object]' && isDataView(a)) {\n    if (!isDataView(b)) return false;\n    className = tagDataView;\n  }\n  switch (className) {\n    // These types are compared by value.\n    case '[object RegExp]':\n      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n    case '[object String]':\n      // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n      // equivalent to `new String(\"5\")`.\n      return '' + a === '' + b;\n    case '[object Number]':\n      // `NaN`s are equivalent, but non-reflexive.\n      // Object(NaN) is equivalent to NaN.\n      if (+a !== +a) return +b !== +b;\n      // An `egal` comparison is performed for other numeric values.\n      return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n    case '[object Date]':\n    case '[object Boolean]':\n      // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n      // millisecond representations. Note that invalid dates with millisecond representations\n      // of `NaN` are not equivalent.\n      return +a === +b;\n    case '[object Symbol]':\n      return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b);\n    case '[object ArrayBuffer]':\n    case tagDataView:\n      // Coerce to typed array so we can fall through.\n      return deepEq(toBufferView(a), toBufferView(b), aStack, bStack);\n  }\n\n  var areArrays = className === '[object Array]';\n  if (!areArrays && isTypedArray(a)) {\n      var byteLength = getByteLength(a);\n      if (byteLength !== getByteLength(b)) return false;\n      if (a.buffer === b.buffer && a.byteOffset === b.byteOffset) return true;\n      areArrays = true;\n  }\n  if (!areArrays) {\n    if (typeof a != 'object' || typeof b != 'object') return false;\n\n    // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n    // from different frames are.\n    var aCtor = a.constructor, bCtor = b.constructor;\n    if (aCtor !== bCtor && !(isFunction(aCtor) && aCtor instanceof aCtor &&\n                             isFunction(bCtor) && bCtor instanceof bCtor)\n                        && ('constructor' in a && 'constructor' in b)) {\n      return false;\n    }\n  }\n  // Assume equality for cyclic structures. The algorithm for detecting cyclic\n  // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n  // Initializing stack of traversed objects.\n  // It's done here since we only need them for objects and arrays comparison.\n  aStack = aStack || [];\n  bStack = bStack || [];\n  var length = aStack.length;\n  while (length--) {\n    // Linear search. Performance is inversely proportional to the number of\n    // unique nested structures.\n    if (aStack[length] === a) return bStack[length] === b;\n  }\n\n  // Add the first object to the stack of traversed objects.\n  aStack.push(a);\n  bStack.push(b);\n\n  // Recursively compare objects and arrays.\n  if (areArrays) {\n    // Compare array lengths to determine if a deep comparison is necessary.\n    length = a.length;\n    if (length !== b.length) return false;\n    // Deep compare the contents, ignoring non-numeric properties.\n    while (length--) {\n      if (!eq(a[length], b[length], aStack, bStack)) return false;\n    }\n  } else {\n    // Deep compare objects.\n    var _keys = keys(a), key;\n    length = _keys.length;\n    // Ensure that both objects contain the same number of properties before comparing deep equality.\n    if (keys(b).length !== length) return false;\n    while (length--) {\n      // Deep compare each member\n      key = _keys[length];\n      if (!(has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n    }\n  }\n  // Remove the first object from the stack of traversed objects.\n  aStack.pop();\n  bStack.pop();\n  return true;\n}\n\n// Perform a deep comparison to check if two objects are equal.\nexport default function isEqual(a, b) {\n  return eq(a, b);\n}\n","import isObject from './isObject.js';\nimport { hasEnumBug } from './_setup.js';\nimport collectNonEnumProps from './_collectNonEnumProps.js';\n\n// Retrieve all the enumerable property names of an object.\nexport default function allKeys(obj) {\n  if (!isObject(obj)) return [];\n  var keys = [];\n  for (var key in obj) keys.push(key);\n  // Ahem, IE < 9.\n  if (hasEnumBug) collectNonEnumProps(obj, keys);\n  return keys;\n}\n","import getLength from './_getLength.js';\nimport isFunction from './isFunction.js';\nimport allKeys from './allKeys.js';\n\n// Since the regular `Object.prototype.toString` type tests don't work for\n// some types in IE 11, we use a fingerprinting heuristic instead, based\n// on the methods. It's not great, but it's the best we got.\n// The fingerprint method lists are defined below.\nexport function ie11fingerprint(methods) {\n  var length = getLength(methods);\n  return function(obj) {\n    if (obj == null) return false;\n    // `Map`, `WeakMap` and `Set` have no enumerable keys.\n    var keys = allKeys(obj);\n    if (getLength(keys)) return false;\n    for (var i = 0; i < length; i++) {\n      if (!isFunction(obj[methods[i]])) return false;\n    }\n    // If we are testing against `WeakMap`, we need to ensure that\n    // `obj` doesn't have a `forEach` method in order to distinguish\n    // it from a regular `Map`.\n    return methods !== weakMapMethods || !isFunction(obj[forEachName]);\n  };\n}\n\n// In the interest of compact minification, we write\n// each string in the fingerprints only once.\nvar forEachName = 'forEach',\n    hasName = 'has',\n    commonInit = ['clear', 'delete'],\n    mapTail = ['get', hasName, 'set'];\n\n// `Map`, `WeakMap` and `Set` each have slightly different\n// combinations of the above sublists.\nexport var mapMethods = commonInit.concat(forEachName, mapTail),\n    weakMapMethods = commonInit.concat(mapTail),\n    setMethods = ['add'].concat(commonInit, forEachName, hasName);\n","import tagTester from './_tagTester.js';\nimport { isIE11 } from './_stringTagBug.js';\nimport { ie11fingerprint, mapMethods }  from './_methodFingerprint.js';\n\nexport default isIE11 ? ie11fingerprint(mapMethods) : tagTester('Map');\n","import tagTester from './_tagTester.js';\nimport { isIE11 } from './_stringTagBug.js';\nimport { ie11fingerprint, weakMapMethods }  from './_methodFingerprint.js';\n\nexport default isIE11 ? ie11fingerprint(weakMapMethods) : tagTester('WeakMap');\n","import tagTester from './_tagTester.js';\nimport { isIE11 } from './_stringTagBug.js';\nimport { ie11fingerprint, setMethods }  from './_methodFingerprint.js';\n\nexport default isIE11 ? ie11fingerprint(setMethods) : tagTester('Set');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('WeakSet');\n","import keys from './keys.js';\n\n// Retrieve the values of an object's properties.\nexport default function values(obj) {\n  var _keys = keys(obj);\n  var length = _keys.length;\n  var values = Array(length);\n  for (var i = 0; i < length; i++) {\n    values[i] = obj[_keys[i]];\n  }\n  return values;\n}\n","import keys from './keys.js';\n\n// Convert an object into a list of `[key, value]` pairs.\n// The opposite of `_.object` with one argument.\nexport default function pairs(obj) {\n  var _keys = keys(obj);\n  var length = _keys.length;\n  var pairs = Array(length);\n  for (var i = 0; i < length; i++) {\n    pairs[i] = [_keys[i], obj[_keys[i]]];\n  }\n  return pairs;\n}\n","import keys from './keys.js';\n\n// Invert the keys and values of an object. The values must be serializable.\nexport default function invert(obj) {\n  var result = {};\n  var _keys = keys(obj);\n  for (var i = 0, length = _keys.length; i < length; i++) {\n    result[obj[_keys[i]]] = _keys[i];\n  }\n  return result;\n}\n","import isFunction from './isFunction.js';\n\n// Return a sorted list of the function names available on the object.\nexport default function functions(obj) {\n  var names = [];\n  for (var key in obj) {\n    if (isFunction(obj[key])) names.push(key);\n  }\n  return names.sort();\n}\n","// An internal function for creating assigner functions.\nexport default function createAssigner(keysFunc, defaults) {\n  return function(obj) {\n    var length = arguments.length;\n    if (defaults) obj = Object(obj);\n    if (length < 2 || obj == null) return obj;\n    for (var index = 1; index < length; index++) {\n      var source = arguments[index],\n          keys = keysFunc(source),\n          l = keys.length;\n      for (var i = 0; i < l; i++) {\n        var key = keys[i];\n        if (!defaults || obj[key] === void 0) obj[key] = source[key];\n      }\n    }\n    return obj;\n  };\n}\n","import createAssigner from './_createAssigner.js';\nimport allKeys from './allKeys.js';\n\n// Extend a given object with all the properties in passed-in object(s).\nexport default createAssigner(allKeys);\n","import createAssigner from './_createAssigner.js';\nimport keys from './keys.js';\n\n// Assigns a given object with all the own properties in the passed-in\n// object(s).\n// (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\nexport default createAssigner(keys);\n","import createAssigner from './_createAssigner.js';\nimport allKeys from './allKeys.js';\n\n// Fill in a given object with default properties.\nexport default createAssigner(allKeys, true);\n","import isObject from './isObject.js';\nimport { nativeCreate } from './_setup.js';\n\n// Create a naked function reference for surrogate-prototype-swapping.\nfunction ctor() {\n  return function(){};\n}\n\n// An internal function for creating a new object that inherits from another.\nexport default function baseCreate(prototype) {\n  if (!isObject(prototype)) return {};\n  if (nativeCreate) return nativeCreate(prototype);\n  var Ctor = ctor();\n  Ctor.prototype = prototype;\n  var result = new Ctor;\n  Ctor.prototype = null;\n  return result;\n}\n","import baseCreate from './_baseCreate.js';\nimport extendOwn from './extendOwn.js';\n\n// Creates an object that inherits from the given prototype object.\n// If additional properties are provided then they will be added to the\n// created object.\nexport default function create(prototype, props) {\n  var result = baseCreate(prototype);\n  if (props) extendOwn(result, props);\n  return result;\n}\n","import isObject from './isObject.js';\nimport isArray from './isArray.js';\nimport extend from './extend.js';\n\n// Create a (shallow-cloned) duplicate of an object.\nexport default function clone(obj) {\n  if (!isObject(obj)) return obj;\n  return isArray(obj) ? obj.slice() : extend({}, obj);\n}\n","// Invokes `interceptor` with the `obj` and then returns `obj`.\n// The primary purpose of this method is to \"tap into\" a method chain, in\n// order to perform operations on intermediate results within the chain.\nexport default function tap(obj, interceptor) {\n  interceptor(obj);\n  return obj;\n}\n","import _ from './underscore.js';\nimport isArray from './isArray.js';\n\n// Normalize a (deep) property `path` to array.\n// Like `_.iteratee`, this function can be customized.\nexport default function toPath(path) {\n  return isArray(path) ? path : [path];\n}\n_.toPath = toPath;\n","import _ from './underscore.js';\nimport './toPath.js';\n\n// Internal wrapper for `_.toPath` to enable minification.\n// Similar to `cb` for `_.iteratee`.\nexport default function toPath(path) {\n  return _.toPath(path);\n}\n","// Internal function to obtain a nested property in `obj` along `path`.\nexport default function deepGet(obj, path) {\n  var length = path.length;\n  for (var i = 0; i < length; i++) {\n    if (obj == null) return void 0;\n    obj = obj[path[i]];\n  }\n  return length ? obj : void 0;\n}\n","import toPath from './_toPath.js';\nimport deepGet from './_deepGet.js';\nimport isUndefined from './isUndefined.js';\n\n// Get the value of the (deep) property on `path` from `object`.\n// If any property in `path` does not exist or if the value is\n// `undefined`, return `defaultValue` instead.\n// The `path` is normalized through `_.toPath`.\nexport default function get(object, path, defaultValue) {\n  var value = deepGet(object, toPath(path));\n  return isUndefined(value) ? defaultValue : value;\n}\n","import _has from './_has.js';\nimport toPath from './_toPath.js';\n\n// Shortcut function for checking if an object has a given property directly on\n// itself (in other words, not on a prototype). Unlike the internal `has`\n// function, this public version can also traverse nested properties.\nexport default function has(obj, path) {\n  path = toPath(path);\n  var length = path.length;\n  for (var i = 0; i < length; i++) {\n    var key = path[i];\n    if (!_has(obj, key)) return false;\n    obj = obj[key];\n  }\n  return !!length;\n}\n","// Keep the identity function around for default iteratees.\nexport default function identity(value) {\n  return value;\n}\n","import extendOwn from './extendOwn.js';\nimport isMatch from './isMatch.js';\n\n// Returns a predicate for checking whether an object has a given set of\n// `key:value` pairs.\nexport default function matcher(attrs) {\n  attrs = extendOwn({}, attrs);\n  return function(obj) {\n    return isMatch(obj, attrs);\n  };\n}\n","import deepGet from './_deepGet.js';\nimport toPath from './_toPath.js';\n\n// Creates a function that, when passed an object, will traverse that object’s\n// properties down the given `path`, specified as an array of keys or indices.\nexport default function property(path) {\n  path = toPath(path);\n  return function(obj) {\n    return deepGet(obj, path);\n  };\n}\n","// Internal function that returns an efficient (for current engines) version\n// of the passed-in callback, to be repeatedly applied in other Underscore\n// functions.\nexport default function optimizeCb(func, context, argCount) {\n  if (context === void 0) return func;\n  switch (argCount == null ? 3 : argCount) {\n    case 1: return function(value) {\n      return func.call(context, value);\n    };\n    // The 2-argument case is omitted because we’re not using it.\n    case 3: return function(value, index, collection) {\n      return func.call(context, value, index, collection);\n    };\n    case 4: return function(accumulator, value, index, collection) {\n      return func.call(context, accumulator, value, index, collection);\n    };\n  }\n  return function() {\n    return func.apply(context, arguments);\n  };\n}\n","import identity from './identity.js';\nimport isFunction from './isFunction.js';\nimport isObject from './isObject.js';\nimport isArray from './isArray.js';\nimport matcher from './matcher.js';\nimport property from './property.js';\nimport optimizeCb from './_optimizeCb.js';\n\n// An internal function to generate callbacks that can be applied to each\n// element in a collection, returning the desired result — either `_.identity`,\n// an arbitrary callback, a property matcher, or a property accessor.\nexport default function baseIteratee(value, context, argCount) {\n  if (value == null) return identity;\n  if (isFunction(value)) return optimizeCb(value, context, argCount);\n  if (isObject(value) && !isArray(value)) return matcher(value);\n  return property(value);\n}\n","import _ from './underscore.js';\nimport baseIteratee from './_baseIteratee.js';\n\n// External wrapper for our callback generator. Users may customize\n// `_.iteratee` if they want additional predicate/iteratee shorthand styles.\n// This abstraction hides the internal-only `argCount` argument.\nexport default function iteratee(value, context) {\n  return baseIteratee(value, context, Infinity);\n}\n_.iteratee = iteratee;\n","import _ from './underscore.js';\nimport baseIteratee from './_baseIteratee.js';\nimport iteratee from './iteratee.js';\n\n// The function we call internally to generate a callback. It invokes\n// `_.iteratee` if overridden, otherwise `baseIteratee`.\nexport default function cb(value, context, argCount) {\n  if (_.iteratee !== iteratee) return _.iteratee(value, context);\n  return baseIteratee(value, context, argCount);\n}\n","import cb from './_cb.js';\nimport keys from './keys.js';\n\n// Returns the results of applying the `iteratee` to each element of `obj`.\n// In contrast to `_.map` it returns an object.\nexport default function mapObject(obj, iteratee, context) {\n  iteratee = cb(iteratee, context);\n  var _keys = keys(obj),\n      length = _keys.length,\n      results = {};\n  for (var index = 0; index < length; index++) {\n    var currentKey = _keys[index];\n    results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n  }\n  return results;\n}\n","// Predicate-generating function. Often useful outside of Underscore.\nexport default function noop(){}\n","import noop from './noop.js';\nimport get from './get.js';\n\n// Generates a function for a given object that returns a given property.\nexport default function propertyOf(obj) {\n  if (obj == null) return noop;\n  return function(path) {\n    return get(obj, path);\n  };\n}\n","import optimizeCb from './_optimizeCb.js';\n\n// Run a function **n** times.\nexport default function times(n, iteratee, context) {\n  var accum = Array(Math.max(0, n));\n  iteratee = optimizeCb(iteratee, context, 1);\n  for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n  return accum;\n}\n","// Return a random integer between `min` and `max` (inclusive).\nexport default function random(min, max) {\n  if (max == null) {\n    max = min;\n    min = 0;\n  }\n  return min + Math.floor(Math.random() * (max - min + 1));\n}\n","// A (possibly faster) way to get the current timestamp as an integer.\nexport default Date.now || function() {\n  return new Date().getTime();\n};\n","import keys from './keys.js';\n\n// Internal helper to generate functions for escaping and unescaping strings\n// to/from HTML interpolation.\nexport default function createEscaper(map) {\n  var escaper = function(match) {\n    return map[match];\n  };\n  // Regexes for identifying a key that needs to be escaped.\n  var source = '(?:' + keys(map).join('|') + ')';\n  var testRegexp = RegExp(source);\n  var replaceRegexp = RegExp(source, 'g');\n  return function(string) {\n    string = string == null ? '' : '' + string;\n    return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n  };\n}\n","// Internal list of HTML entities for escaping.\nexport default {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;',\n  \"'\": '&#x27;',\n  '`': '&#x60;'\n};\n","import createEscaper from './_createEscaper.js';\nimport escapeMap from './_escapeMap.js';\n\n// Function for escaping strings to HTML interpolation.\nexport default createEscaper(escapeMap);\n","import invert from './invert.js';\nimport escapeMap from './_escapeMap.js';\n\n// Internal list of HTML entities for unescaping.\nexport default invert(escapeMap);\n","import createEscaper from './_createEscaper.js';\nimport unescapeMap from './_unescapeMap.js';\n\n// Function for unescaping strings from HTML interpolation.\nexport default createEscaper(unescapeMap);\n","import _ from './underscore.js';\n\n// By default, Underscore uses ERB-style template delimiters. Change the\n// following template settings to use alternative delimiters.\nexport default _.templateSettings = {\n  evaluate: /<%([\\s\\S]+?)%>/g,\n  interpolate: /<%=([\\s\\S]+?)%>/g,\n  escape: /<%-([\\s\\S]+?)%>/g\n};\n","import defaults from './defaults.js';\nimport _ from './underscore.js';\nimport './templateSettings.js';\n\n// When customizing `_.templateSettings`, if you don't want to define an\n// interpolation, evaluation or escaping regex, we need one that is\n// guaranteed not to match.\nvar noMatch = /(.)^/;\n\n// Certain characters need to be escaped so that they can be put into a\n// string literal.\nvar escapes = {\n  \"'\": \"'\",\n  '\\\\': '\\\\',\n  '\\r': 'r',\n  '\\n': 'n',\n  '\\u2028': 'u2028',\n  '\\u2029': 'u2029'\n};\n\nvar escapeRegExp = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\nfunction escapeChar(match) {\n  return '\\\\' + escapes[match];\n}\n\n// In order to prevent third-party code injection through\n// `_.templateSettings.variable`, we test it against the following regular\n// expression. It is intentionally a bit more liberal than just matching valid\n// identifiers, but still prevents possible loopholes through defaults or\n// destructuring assignment.\nvar bareIdentifier = /^\\s*(\\w|\\$)+\\s*$/;\n\n// JavaScript micro-templating, similar to John Resig's implementation.\n// Underscore templating handles arbitrary delimiters, preserves whitespace,\n// and correctly escapes quotes within interpolated code.\n// NB: `oldSettings` only exists for backwards compatibility.\nexport default function template(text, settings, oldSettings) {\n  if (!settings && oldSettings) settings = oldSettings;\n  settings = defaults({}, settings, _.templateSettings);\n\n  // Combine delimiters into one regular expression via alternation.\n  var matcher = RegExp([\n    (settings.escape || noMatch).source,\n    (settings.interpolate || noMatch).source,\n    (settings.evaluate || noMatch).source\n  ].join('|') + '|$', 'g');\n\n  // Compile the template source, escaping string literals appropriately.\n  var index = 0;\n  var source = \"__p+='\";\n  text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n    source += text.slice(index, offset).replace(escapeRegExp, escapeChar);\n    index = offset + match.length;\n\n    if (escape) {\n      source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n    } else if (interpolate) {\n      source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n    } else if (evaluate) {\n      source += \"';\\n\" + evaluate + \"\\n__p+='\";\n    }\n\n    // Adobe VMs need the match returned to produce the correct offset.\n    return match;\n  });\n  source += \"';\\n\";\n\n  var argument = settings.variable;\n  if (argument) {\n    // Insure against third-party code injection. (CVE-2021-23358)\n    if (!bareIdentifier.test(argument)) throw new Error(\n      'variable is not a bare identifier: ' + argument\n    );\n  } else {\n    // If a variable is not specified, place data values in local scope.\n    source = 'with(obj||{}){\\n' + source + '}\\n';\n    argument = 'obj';\n  }\n\n  source = \"var __t,__p='',__j=Array.prototype.join,\" +\n    \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n    source + 'return __p;\\n';\n\n  var render;\n  try {\n    render = new Function(argument, '_', source);\n  } catch (e) {\n    e.source = source;\n    throw e;\n  }\n\n  var template = function(data) {\n    return render.call(this, data, _);\n  };\n\n  // Provide the compiled source as a convenience for precompilation.\n  template.source = 'function(' + argument + '){\\n' + source + '}';\n\n  return template;\n}\n","import isFunction from './isFunction.js';\nimport toPath from './_toPath.js';\n\n// Traverses the children of `obj` along `path`. If a child is a function, it\n// is invoked with its parent as context. Returns the value of the final\n// child, or `fallback` if any child is undefined.\nexport default function result(obj, path, fallback) {\n  path = toPath(path);\n  var length = path.length;\n  if (!length) {\n    return isFunction(fallback) ? fallback.call(obj) : fallback;\n  }\n  for (var i = 0; i < length; i++) {\n    var prop = obj == null ? void 0 : obj[path[i]];\n    if (prop === void 0) {\n      prop = fallback;\n      i = length; // Ensure we don't continue iterating.\n    }\n    obj = isFunction(prop) ? prop.call(obj) : prop;\n  }\n  return obj;\n}\n","// Generate a unique integer id (unique within the entire client session).\n// Useful for temporary DOM ids.\nvar idCounter = 0;\nexport default function uniqueId(prefix) {\n  var id = ++idCounter + '';\n  return prefix ? prefix + id : id;\n}\n","import _ from './underscore.js';\n\n// Start chaining a wrapped Underscore object.\nexport default function chain(obj) {\n  var instance = _(obj);\n  instance._chain = true;\n  return instance;\n}\n","import baseCreate from './_baseCreate.js';\nimport isObject from './isObject.js';\n\n// Internal function to execute `sourceFunc` bound to `context` with optional\n// `args`. Determines whether to execute a function as a constructor or as a\n// normal function.\nexport default function executeBound(sourceFunc, boundFunc, context, callingContext, args) {\n  if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n  var self = baseCreate(sourceFunc.prototype);\n  var result = sourceFunc.apply(self, args);\n  if (isObject(result)) return result;\n  return self;\n}\n","import restArguments from './restArguments.js';\nimport executeBound from './_executeBound.js';\nimport _ from './underscore.js';\n\n// Partially apply a function by creating a version that has had some of its\n// arguments pre-filled, without changing its dynamic `this` context. `_` acts\n// as a placeholder by default, allowing any combination of arguments to be\n// pre-filled. Set `_.partial.placeholder` for a custom placeholder argument.\nvar partial = restArguments(function(func, boundArgs) {\n  var placeholder = partial.placeholder;\n  var bound = function() {\n    var position = 0, length = boundArgs.length;\n    var args = Array(length);\n    for (var i = 0; i < length; i++) {\n      args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];\n    }\n    while (position < arguments.length) args.push(arguments[position++]);\n    return executeBound(func, bound, this, this, args);\n  };\n  return bound;\n});\n\npartial.placeholder = _;\nexport default partial;\n","import restArguments from './restArguments.js';\nimport isFunction from './isFunction.js';\nimport executeBound from './_executeBound.js';\n\n// Create a function bound to a given object (assigning `this`, and arguments,\n// optionally).\nexport default restArguments(function(func, context, args) {\n  if (!isFunction(func)) throw new TypeError('Bind must be called on a function');\n  var bound = restArguments(function(callArgs) {\n    return executeBound(func, bound, context, this, args.concat(callArgs));\n  });\n  return bound;\n});\n","import createSizePropertyCheck from './_createSizePropertyCheck.js';\nimport getLength from './_getLength.js';\n\n// Internal helper for collection methods to determine whether a collection\n// should be iterated as an array or as an object.\n// Related: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n// Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\nexport default createSizePropertyCheck(getLength);\n","import getLength from './_getLength.js';\nimport isArrayLike from './_isArrayLike.js';\nimport isArray from './isArray.js';\nimport isArguments from './isArguments.js';\n\n// Internal implementation of a recursive `flatten` function.\nexport default function flatten(input, depth, strict, output) {\n  output = output || [];\n  if (!depth && depth !== 0) {\n    depth = Infinity;\n  } else if (depth <= 0) {\n    return output.concat(input);\n  }\n  var idx = output.length;\n  for (var i = 0, length = getLength(input); i < length; i++) {\n    var value = input[i];\n    if (isArrayLike(value) && (isArray(value) || isArguments(value))) {\n      // Flatten current level of array or arguments object.\n      if (depth > 1) {\n        flatten(value, depth - 1, strict, output);\n        idx = output.length;\n      } else {\n        var j = 0, len = value.length;\n        while (j < len) output[idx++] = value[j++];\n      }\n    } else if (!strict) {\n      output[idx++] = value;\n    }\n  }\n  return output;\n}\n","import restArguments from './restArguments.js';\nimport flatten from './_flatten.js';\nimport bind from './bind.js';\n\n// Bind a number of an object's methods to that object. Remaining arguments\n// are the method names to be bound. Useful for ensuring that all callbacks\n// defined on an object belong to it.\nexport default restArguments(function(obj, keys) {\n  keys = flatten(keys, false, false);\n  var index = keys.length;\n  if (index < 1) throw new Error('bindAll must be passed function names');\n  while (index--) {\n    var key = keys[index];\n    obj[key] = bind(obj[key], obj);\n  }\n  return obj;\n});\n","import has from './_has.js';\n\n// Memoize an expensive function by storing its results.\nexport default function memoize(func, hasher) {\n  var memoize = function(key) {\n    var cache = memoize.cache;\n    var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n    if (!has(cache, address)) cache[address] = func.apply(this, arguments);\n    return cache[address];\n  };\n  memoize.cache = {};\n  return memoize;\n}\n","import restArguments from './restArguments.js';\n\n// Delays a function for the given number of milliseconds, and then calls\n// it with the arguments supplied.\nexport default restArguments(function(func, wait, args) {\n  return setTimeout(function() {\n    return func.apply(null, args);\n  }, wait);\n});\n","import partial from './partial.js';\nimport delay from './delay.js';\nimport _ from './underscore.js';\n\n// Defers a function, scheduling it to run after the current call stack has\n// cleared.\nexport default partial(delay, _, 1);\n","import now from './now.js';\n\n// Returns a function, that, when invoked, will only be triggered at most once\n// during a given window of time. Normally, the throttled function will run\n// as much as it can, without ever going more than once per `wait` duration;\n// but if you'd like to disable the execution on the leading edge, pass\n// `{leading: false}`. To disable execution on the trailing edge, ditto.\nexport default function throttle(func, wait, options) {\n  var timeout, context, args, result;\n  var previous = 0;\n  if (!options) options = {};\n\n  var later = function() {\n    previous = options.leading === false ? 0 : now();\n    timeout = null;\n    result = func.apply(context, args);\n    if (!timeout) context = args = null;\n  };\n\n  var throttled = function() {\n    var _now = now();\n    if (!previous && options.leading === false) previous = _now;\n    var remaining = wait - (_now - previous);\n    context = this;\n    args = arguments;\n    if (remaining <= 0 || remaining > wait) {\n      if (timeout) {\n        clearTimeout(timeout);\n        timeout = null;\n      }\n      previous = _now;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    } else if (!timeout && options.trailing !== false) {\n      timeout = setTimeout(later, remaining);\n    }\n    return result;\n  };\n\n  throttled.cancel = function() {\n    clearTimeout(timeout);\n    previous = 0;\n    timeout = context = args = null;\n  };\n\n  return throttled;\n}\n","import restArguments from './restArguments.js';\nimport now from './now.js';\n\n// When a sequence of calls of the returned function ends, the argument\n// function is triggered. The end of a sequence is defined by the `wait`\n// parameter. If `immediate` is passed, the argument function will be\n// triggered at the beginning of the sequence instead of at the end.\nexport default function debounce(func, wait, immediate) {\n  var timeout, previous, args, result, context;\n\n  var later = function() {\n    var passed = now() - previous;\n    if (wait > passed) {\n      timeout = setTimeout(later, wait - passed);\n    } else {\n      timeout = null;\n      if (!immediate) result = func.apply(context, args);\n      // This check is needed because `func` can recursively invoke `debounced`.\n      if (!timeout) args = context = null;\n    }\n  };\n\n  var debounced = restArguments(function(_args) {\n    context = this;\n    args = _args;\n    previous = now();\n    if (!timeout) {\n      timeout = setTimeout(later, wait);\n      if (immediate) result = func.apply(context, args);\n    }\n    return result;\n  });\n\n  debounced.cancel = function() {\n    clearTimeout(timeout);\n    timeout = args = context = null;\n  };\n\n  return debounced;\n}\n","import partial from './partial.js';\n\n// Returns the first function passed as an argument to the second,\n// allowing you to adjust arguments, run code before and after, and\n// conditionally execute the original function.\nexport default function wrap(func, wrapper) {\n  return partial(wrapper, func);\n}\n","// Returns a negated version of the passed-in predicate.\nexport default function negate(predicate) {\n  return function() {\n    return !predicate.apply(this, arguments);\n  };\n}\n","// Returns a function that is the composition of a list of functions, each\n// consuming the return value of the function that follows.\nexport default function compose() {\n  var args = arguments;\n  var start = args.length - 1;\n  return function() {\n    var i = start;\n    var result = args[start].apply(this, arguments);\n    while (i--) result = args[i].call(this, result);\n    return result;\n  };\n}\n","// Returns a function that will only be executed on and after the Nth call.\nexport default function after(times, func) {\n  return function() {\n    if (--times < 1) {\n      return func.apply(this, arguments);\n    }\n  };\n}\n","// Returns a function that will only be executed up to (but not including) the\n// Nth call.\nexport default function before(times, func) {\n  var memo;\n  return function() {\n    if (--times > 0) {\n      memo = func.apply(this, arguments);\n    }\n    if (times <= 1) func = null;\n    return memo;\n  };\n}\n","import partial from './partial.js';\nimport before from './before.js';\n\n// Returns a function that will be executed at most one time, no matter how\n// often you call it. Useful for lazy initialization.\nexport default partial(before, 2);\n","import cb from './_cb.js';\nimport keys from './keys.js';\n\n// Returns the first key on an object that passes a truth test.\nexport default function findKey(obj, predicate, context) {\n  predicate = cb(predicate, context);\n  var _keys = keys(obj), key;\n  for (var i = 0, length = _keys.length; i < length; i++) {\n    key = _keys[i];\n    if (predicate(obj[key], key, obj)) return key;\n  }\n}\n","import cb from './_cb.js';\nimport getLength from './_getLength.js';\n\n// Internal function to generate `_.findIndex` and `_.findLastIndex`.\nexport default function createPredicateIndexFinder(dir) {\n  return function(array, predicate, context) {\n    predicate = cb(predicate, context);\n    var length = getLength(array);\n    var index = dir > 0 ? 0 : length - 1;\n    for (; index >= 0 && index < length; index += dir) {\n      if (predicate(array[index], index, array)) return index;\n    }\n    return -1;\n  };\n}\n","import createPredicateIndexFinder from './_createPredicateIndexFinder.js';\n\n// Returns the first index on an array-like that passes a truth test.\nexport default createPredicateIndexFinder(1);\n","import createPredicateIndexFinder from './_createPredicateIndexFinder.js';\n\n// Returns the last index on an array-like that passes a truth test.\nexport default createPredicateIndexFinder(-1);\n","import cb from './_cb.js';\nimport getLength from './_getLength.js';\n\n// Use a comparator function to figure out the smallest index at which\n// an object should be inserted so as to maintain order. Uses binary search.\nexport default function sortedIndex(array, obj, iteratee, context) {\n  iteratee = cb(iteratee, context, 1);\n  var value = iteratee(obj);\n  var low = 0, high = getLength(array);\n  while (low < high) {\n    var mid = Math.floor((low + high) / 2);\n    if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n  }\n  return low;\n}\n","import getLength from './_getLength.js';\nimport { slice } from './_setup.js';\nimport isNaN from './isNaN.js';\n\n// Internal function to generate the `_.indexOf` and `_.lastIndexOf` functions.\nexport default function createIndexFinder(dir, predicateFind, sortedIndex) {\n  return function(array, item, idx) {\n    var i = 0, length = getLength(array);\n    if (typeof idx == 'number') {\n      if (dir > 0) {\n        i = idx >= 0 ? idx : Math.max(idx + length, i);\n      } else {\n        length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n      }\n    } else if (sortedIndex && idx && length) {\n      idx = sortedIndex(array, item);\n      return array[idx] === item ? idx : -1;\n    }\n    if (item !== item) {\n      idx = predicateFind(slice.call(array, i, length), isNaN);\n      return idx >= 0 ? idx + i : -1;\n    }\n    for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n      if (array[idx] === item) return idx;\n    }\n    return -1;\n  };\n}\n","import sortedIndex from './sortedIndex.js';\nimport findIndex from './findIndex.js';\nimport createIndexFinder from './_createIndexFinder.js';\n\n// Return the position of the first occurrence of an item in an array,\n// or -1 if the item is not included in the array.\n// If the array is large and already in sort order, pass `true`\n// for **isSorted** to use binary search.\nexport default createIndexFinder(1, findIndex, sortedIndex);\n","import findLastIndex from './findLastIndex.js';\nimport createIndexFinder from './_createIndexFinder.js';\n\n// Return the position of the last occurrence of an item in an array,\n// or -1 if the item is not included in the array.\nexport default createIndexFinder(-1, findLastIndex);\n","import isArrayLike from './_isArrayLike.js';\nimport findIndex from './findIndex.js';\nimport findKey from './findKey.js';\n\n// Return the first value which passes a truth test.\nexport default function find(obj, predicate, context) {\n  var keyFinder = isArrayLike(obj) ? findIndex : findKey;\n  var key = keyFinder(obj, predicate, context);\n  if (key !== void 0 && key !== -1) return obj[key];\n}\n","import find from './find.js';\nimport matcher from './matcher.js';\n\n// Convenience version of a common use case of `_.find`: getting the first\n// object containing specific `key:value` pairs.\nexport default function findWhere(obj, attrs) {\n  return find(obj, matcher(attrs));\n}\n","import optimizeCb from './_optimizeCb.js';\nimport isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// The cornerstone for collection functions, an `each`\n// implementation, aka `forEach`.\n// Handles raw objects in addition to array-likes. Treats all\n// sparse array-likes as if they were dense.\nexport default function each(obj, iteratee, context) {\n  iteratee = optimizeCb(iteratee, context);\n  var i, length;\n  if (isArrayLike(obj)) {\n    for (i = 0, length = obj.length; i < length; i++) {\n      iteratee(obj[i], i, obj);\n    }\n  } else {\n    var _keys = keys(obj);\n    for (i = 0, length = _keys.length; i < length; i++) {\n      iteratee(obj[_keys[i]], _keys[i], obj);\n    }\n  }\n  return obj;\n}\n","import cb from './_cb.js';\nimport isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// Return the results of applying the iteratee to each element.\nexport default function map(obj, iteratee, context) {\n  iteratee = cb(iteratee, context);\n  var _keys = !isArrayLike(obj) && keys(obj),\n      length = (_keys || obj).length,\n      results = Array(length);\n  for (var index = 0; index < length; index++) {\n    var currentKey = _keys ? _keys[index] : index;\n    results[index] = iteratee(obj[currentKey], currentKey, obj);\n  }\n  return results;\n}\n","import isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\nimport optimizeCb from './_optimizeCb.js';\n\n// Internal helper to create a reducing function, iterating left or right.\nexport default function createReduce(dir) {\n  // Wrap code that reassigns argument variables in a separate function than\n  // the one that accesses `arguments.length` to avoid a perf hit. (#1991)\n  var reducer = function(obj, iteratee, memo, initial) {\n    var _keys = !isArrayLike(obj) && keys(obj),\n        length = (_keys || obj).length,\n        index = dir > 0 ? 0 : length - 1;\n    if (!initial) {\n      memo = obj[_keys ? _keys[index] : index];\n      index += dir;\n    }\n    for (; index >= 0 && index < length; index += dir) {\n      var currentKey = _keys ? _keys[index] : index;\n      memo = iteratee(memo, obj[currentKey], currentKey, obj);\n    }\n    return memo;\n  };\n\n  return function(obj, iteratee, memo, context) {\n    var initial = arguments.length >= 3;\n    return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial);\n  };\n}\n","import createReduce from './_createReduce.js';\n\n// **Reduce** builds up a single result from a list of values, aka `inject`,\n// or `foldl`.\nexport default createReduce(1);\n","import createReduce from './_createReduce.js';\n\n// The right-associative version of reduce, also known as `foldr`.\nexport default createReduce(-1);\n","import cb from './_cb.js';\nimport each from './each.js';\n\n// Return all the elements that pass a truth test.\nexport default function filter(obj, predicate, context) {\n  var results = [];\n  predicate = cb(predicate, context);\n  each(obj, function(value, index, list) {\n    if (predicate(value, index, list)) results.push(value);\n  });\n  return results;\n}\n","import filter from './filter.js';\nimport negate from './negate.js';\nimport cb from './_cb.js';\n\n// Return all the elements for which a truth test fails.\nexport default function reject(obj, predicate, context) {\n  return filter(obj, negate(cb(predicate)), context);\n}\n","import cb from './_cb.js';\nimport isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// Determine whether all of the elements pass a truth test.\nexport default function every(obj, predicate, context) {\n  predicate = cb(predicate, context);\n  var _keys = !isArrayLike(obj) && keys(obj),\n      length = (_keys || obj).length;\n  for (var index = 0; index < length; index++) {\n    var currentKey = _keys ? _keys[index] : index;\n    if (!predicate(obj[currentKey], currentKey, obj)) return false;\n  }\n  return true;\n}\n","import cb from './_cb.js';\nimport isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// Determine if at least one element in the object passes a truth test.\nexport default function some(obj, predicate, context) {\n  predicate = cb(predicate, context);\n  var _keys = !isArrayLike(obj) && keys(obj),\n      length = (_keys || obj).length;\n  for (var index = 0; index < length; index++) {\n    var currentKey = _keys ? _keys[index] : index;\n    if (predicate(obj[currentKey], currentKey, obj)) return true;\n  }\n  return false;\n}\n","import isArrayLike from './_isArrayLike.js';\nimport values from './values.js';\nimport indexOf from './indexOf.js';\n\n// Determine if the array or object contains a given item (using `===`).\nexport default function contains(obj, item, fromIndex, guard) {\n  if (!isArrayLike(obj)) obj = values(obj);\n  if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n  return indexOf(obj, item, fromIndex) >= 0;\n}\n","import restArguments from './restArguments.js';\nimport isFunction from './isFunction.js';\nimport map from './map.js';\nimport deepGet from './_deepGet.js';\nimport toPath from './_toPath.js';\n\n// Invoke a method (with arguments) on every item in a collection.\nexport default restArguments(function(obj, path, args) {\n  var contextPath, func;\n  if (isFunction(path)) {\n    func = path;\n  } else {\n    path = toPath(path);\n    contextPath = path.slice(0, -1);\n    path = path[path.length - 1];\n  }\n  return map(obj, function(context) {\n    var method = func;\n    if (!method) {\n      if (contextPath && contextPath.length) {\n        context = deepGet(context, contextPath);\n      }\n      if (context == null) return void 0;\n      method = context[path];\n    }\n    return method == null ? method : method.apply(context, args);\n  });\n});\n","import map from './map.js';\nimport property from './property.js';\n\n// Convenience version of a common use case of `_.map`: fetching a property.\nexport default function pluck(obj, key) {\n  return map(obj, property(key));\n}\n","import filter from './filter.js';\nimport matcher from './matcher.js';\n\n// Convenience version of a common use case of `_.filter`: selecting only\n// objects containing specific `key:value` pairs.\nexport default function where(obj, attrs) {\n  return filter(obj, matcher(attrs));\n}\n","import isArrayLike from './_isArrayLike.js';\nimport values from './values.js';\nimport cb from './_cb.js';\nimport each from './each.js';\n\n// Return the maximum element (or element-based computation).\nexport default function max(obj, iteratee, context) {\n  var result = -Infinity, lastComputed = -Infinity,\n      value, computed;\n  if (iteratee == null || (typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null)) {\n    obj = isArrayLike(obj) ? obj : values(obj);\n    for (var i = 0, length = obj.length; i < length; i++) {\n      value = obj[i];\n      if (value != null && value > result) {\n        result = value;\n      }\n    }\n  } else {\n    iteratee = cb(iteratee, context);\n    each(obj, function(v, index, list) {\n      computed = iteratee(v, index, list);\n      if (computed > lastComputed || (computed === -Infinity && result === -Infinity)) {\n        result = v;\n        lastComputed = computed;\n      }\n    });\n  }\n  return result;\n}\n","import isArrayLike from './_isArrayLike.js';\nimport values from './values.js';\nimport cb from './_cb.js';\nimport each from './each.js';\n\n// Return the minimum element (or element-based computation).\nexport default function min(obj, iteratee, context) {\n  var result = Infinity, lastComputed = Infinity,\n      value, computed;\n  if (iteratee == null || (typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null)) {\n    obj = isArrayLike(obj) ? obj : values(obj);\n    for (var i = 0, length = obj.length; i < length; i++) {\n      value = obj[i];\n      if (value != null && value < result) {\n        result = value;\n      }\n    }\n  } else {\n    iteratee = cb(iteratee, context);\n    each(obj, function(v, index, list) {\n      computed = iteratee(v, index, list);\n      if (computed < lastComputed || (computed === Infinity && result === Infinity)) {\n        result = v;\n        lastComputed = computed;\n      }\n    });\n  }\n  return result;\n}\n","import isArray from './isArray.js';\nimport { slice } from './_setup.js';\nimport isString from './isString.js';\nimport isArrayLike from './_isArrayLike.js';\nimport map from './map.js';\nimport identity from './identity.js';\nimport values from './values.js';\n\n// Safely create a real, live array from anything iterable.\nvar reStrSymbol = /[^\\ud800-\\udfff]|[\\ud800-\\udbff][\\udc00-\\udfff]|[\\ud800-\\udfff]/g;\nexport default function toArray(obj) {\n  if (!obj) return [];\n  if (isArray(obj)) return slice.call(obj);\n  if (isString(obj)) {\n    // Keep surrogate pair characters together.\n    return obj.match(reStrSymbol);\n  }\n  if (isArrayLike(obj)) return map(obj, identity);\n  return values(obj);\n}\n","import isArrayLike from './_isArrayLike.js';\nimport values from './values.js';\nimport getLength from './_getLength.js';\nimport random from './random.js';\nimport toArray from './toArray.js';\n\n// Sample **n** random values from a collection using the modern version of the\n// [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n// If **n** is not specified, returns a single random element.\n// The internal `guard` argument allows it to work with `_.map`.\nexport default function sample(obj, n, guard) {\n  if (n == null || guard) {\n    if (!isArrayLike(obj)) obj = values(obj);\n    return obj[random(obj.length - 1)];\n  }\n  var sample = toArray(obj);\n  var length = getLength(sample);\n  n = Math.max(Math.min(n, length), 0);\n  var last = length - 1;\n  for (var index = 0; index < n; index++) {\n    var rand = random(index, last);\n    var temp = sample[index];\n    sample[index] = sample[rand];\n    sample[rand] = temp;\n  }\n  return sample.slice(0, n);\n}\n","import sample from './sample.js';\n\n// Shuffle a collection.\nexport default function shuffle(obj) {\n  return sample(obj, Infinity);\n}\n","import cb from './_cb.js';\nimport pluck from './pluck.js';\nimport map from './map.js';\n\n// Sort the object's values by a criterion produced by an iteratee.\nexport default function sortBy(obj, iteratee, context) {\n  var index = 0;\n  iteratee = cb(iteratee, context);\n  return pluck(map(obj, function(value, key, list) {\n    return {\n      value: value,\n      index: index++,\n      criteria: iteratee(value, key, list)\n    };\n  }).sort(function(left, right) {\n    var a = left.criteria;\n    var b = right.criteria;\n    if (a !== b) {\n      if (a > b || a === void 0) return 1;\n      if (a < b || b === void 0) return -1;\n    }\n    return left.index - right.index;\n  }), 'value');\n}\n","import cb from './_cb.js';\nimport each from './each.js';\n\n// An internal function used for aggregate \"group by\" operations.\nexport default function group(behavior, partition) {\n  return function(obj, iteratee, context) {\n    var result = partition ? [[], []] : {};\n    iteratee = cb(iteratee, context);\n    each(obj, function(value, index) {\n      var key = iteratee(value, index, obj);\n      behavior(result, value, key);\n    });\n    return result;\n  };\n}\n","import group from './_group.js';\nimport has from './_has.js';\n\n// Groups the object's values by a criterion. Pass either a string attribute\n// to group by, or a function that returns the criterion.\nexport default group(function(result, value, key) {\n  if (has(result, key)) result[key].push(value); else result[key] = [value];\n});\n","import group from './_group.js';\n\n// Indexes the object's values by a criterion, similar to `_.groupBy`, but for\n// when you know that your index values will be unique.\nexport default group(function(result, value, key) {\n  result[key] = value;\n});\n","import group from './_group.js';\nimport has from './_has.js';\n\n// Counts instances of an object that group by a certain criterion. Pass\n// either a string attribute to count by, or a function that returns the\n// criterion.\nexport default group(function(result, value, key) {\n  if (has(result, key)) result[key]++; else result[key] = 1;\n});\n","import group from './_group.js';\n\n// Split a collection into two arrays: one whose elements all pass the given\n// truth test, and one whose elements all do not pass the truth test.\nexport default group(function(result, value, pass) {\n  result[pass ? 0 : 1].push(value);\n}, true);\n","import isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// Return the number of elements in a collection.\nexport default function size(obj) {\n  if (obj == null) return 0;\n  return isArrayLike(obj) ? obj.length : keys(obj).length;\n}\n","// Internal `_.pick` helper function to determine whether `key` is an enumerable\n// property name of `obj`.\nexport default function keyInObj(value, key, obj) {\n  return key in obj;\n}\n","import restArguments from './restArguments.js';\nimport isFunction from './isFunction.js';\nimport optimizeCb from './_optimizeCb.js';\nimport allKeys from './allKeys.js';\nimport keyInObj from './_keyInObj.js';\nimport flatten from './_flatten.js';\n\n// Return a copy of the object only containing the allowed properties.\nexport default restArguments(function(obj, keys) {\n  var result = {}, iteratee = keys[0];\n  if (obj == null) return result;\n  if (isFunction(iteratee)) {\n    if (keys.length > 1) iteratee = optimizeCb(iteratee, keys[1]);\n    keys = allKeys(obj);\n  } else {\n    iteratee = keyInObj;\n    keys = flatten(keys, false, false);\n    obj = Object(obj);\n  }\n  for (var i = 0, length = keys.length; i < length; i++) {\n    var key = keys[i];\n    var value = obj[key];\n    if (iteratee(value, key, obj)) result[key] = value;\n  }\n  return result;\n});\n","import restArguments from './restArguments.js';\nimport isFunction from './isFunction.js';\nimport negate from './negate.js';\nimport map from './map.js';\nimport flatten from './_flatten.js';\nimport contains from './contains.js';\nimport pick from './pick.js';\n\n// Return a copy of the object without the disallowed properties.\nexport default restArguments(function(obj, keys) {\n  var iteratee = keys[0], context;\n  if (isFunction(iteratee)) {\n    iteratee = negate(iteratee);\n    if (keys.length > 1) context = keys[1];\n  } else {\n    keys = map(flatten(keys, false, false), String);\n    iteratee = function(value, key) {\n      return !contains(keys, key);\n    };\n  }\n  return pick(obj, iteratee, context);\n});\n","import { slice } from './_setup.js';\n\n// Returns everything but the last entry of the array. Especially useful on\n// the arguments object. Passing **n** will return all the values in\n// the array, excluding the last N.\nexport default function initial(array, n, guard) {\n  return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n}\n","import initial from './initial.js';\n\n// Get the first element of an array. Passing **n** will return the first N\n// values in the array. The **guard** check allows it to work with `_.map`.\nexport default function first(array, n, guard) {\n  if (array == null || array.length < 1) return n == null || guard ? void 0 : [];\n  if (n == null || guard) return array[0];\n  return initial(array, array.length - n);\n}\n","import { slice } from './_setup.js';\n\n// Returns everything but the first entry of the `array`. Especially useful on\n// the `arguments` object. Passing an **n** will return the rest N values in the\n// `array`.\nexport default function rest(array, n, guard) {\n  return slice.call(array, n == null || guard ? 1 : n);\n}\n","import rest from './rest.js';\n\n// Get the last element of an array. Passing **n** will return the last N\n// values in the array.\nexport default function last(array, n, guard) {\n  if (array == null || array.length < 1) return n == null || guard ? void 0 : [];\n  if (n == null || guard) return array[array.length - 1];\n  return rest(array, Math.max(0, array.length - n));\n}\n","import filter from './filter.js';\n\n// Trim out all falsy values from an array.\nexport default function compact(array) {\n  return filter(array, Boolean);\n}\n","import _flatten from './_flatten.js';\n\n// Flatten out an array, either recursively (by default), or up to `depth`.\n// Passing `true` or `false` as `depth` means `1` or `Infinity`, respectively.\nexport default function flatten(array, depth) {\n  return _flatten(array, depth, false);\n}\n","import restArguments from './restArguments.js';\nimport flatten from './_flatten.js';\nimport filter from './filter.js';\nimport contains from './contains.js';\n\n// Take the difference between one array and a number of other arrays.\n// Only the elements present in just the first array will remain.\nexport default restArguments(function(array, rest) {\n  rest = flatten(rest, true, true);\n  return filter(array, function(value){\n    return !contains(rest, value);\n  });\n});\n","import restArguments from './restArguments.js';\nimport difference from './difference.js';\n\n// Return a version of the array that does not contain the specified value(s).\nexport default restArguments(function(array, otherArrays) {\n  return difference(array, otherArrays);\n});\n","import isBoolean from './isBoolean.js';\nimport cb from './_cb.js';\nimport getLength from './_getLength.js';\nimport contains from './contains.js';\n\n// Produce a duplicate-free version of the array. If the array has already\n// been sorted, you have the option of using a faster algorithm.\n// The faster algorithm will not work with an iteratee if the iteratee\n// is not a one-to-one function, so providing an iteratee will disable\n// the faster algorithm.\nexport default function uniq(array, isSorted, iteratee, context) {\n  if (!isBoolean(isSorted)) {\n    context = iteratee;\n    iteratee = isSorted;\n    isSorted = false;\n  }\n  if (iteratee != null) iteratee = cb(iteratee, context);\n  var result = [];\n  var seen = [];\n  for (var i = 0, length = getLength(array); i < length; i++) {\n    var value = array[i],\n        computed = iteratee ? iteratee(value, i, array) : value;\n    if (isSorted && !iteratee) {\n      if (!i || seen !== computed) result.push(value);\n      seen = computed;\n    } else if (iteratee) {\n      if (!contains(seen, computed)) {\n        seen.push(computed);\n        result.push(value);\n      }\n    } else if (!contains(result, value)) {\n      result.push(value);\n    }\n  }\n  return result;\n}\n","import restArguments from './restArguments.js';\nimport uniq from './uniq.js';\nimport flatten from './_flatten.js';\n\n// Produce an array that contains the union: each distinct element from all of\n// the passed-in arrays.\nexport default restArguments(function(arrays) {\n  return uniq(flatten(arrays, true, true));\n});\n","import getLength from './_getLength.js';\nimport contains from './contains.js';\n\n// Produce an array that contains every item shared between all the\n// passed-in arrays.\nexport default function intersection(array) {\n  var result = [];\n  var argsLength = arguments.length;\n  for (var i = 0, length = getLength(array); i < length; i++) {\n    var item = array[i];\n    if (contains(result, item)) continue;\n    var j;\n    for (j = 1; j < argsLength; j++) {\n      if (!contains(arguments[j], item)) break;\n    }\n    if (j === argsLength) result.push(item);\n  }\n  return result;\n}\n","import max from './max.js';\nimport getLength from './_getLength.js';\nimport pluck from './pluck.js';\n\n// Complement of zip. Unzip accepts an array of arrays and groups\n// each array's elements on shared indices.\nexport default function unzip(array) {\n  var length = (array && max(array, getLength).length) || 0;\n  var result = Array(length);\n\n  for (var index = 0; index < length; index++) {\n    result[index] = pluck(array, index);\n  }\n  return result;\n}\n","import restArguments from './restArguments.js';\nimport unzip from './unzip.js';\n\n// Zip together multiple lists into a single array -- elements that share\n// an index go together.\nexport default restArguments(unzip);\n","import getLength  from './_getLength.js';\n\n// Converts lists into objects. Pass either a single array of `[key, value]`\n// pairs, or two parallel arrays of the same length -- one of keys, and one of\n// the corresponding values. Passing by pairs is the reverse of `_.pairs`.\nexport default function object(list, values) {\n  var result = {};\n  for (var i = 0, length = getLength(list); i < length; i++) {\n    if (values) {\n      result[list[i]] = values[i];\n    } else {\n      result[list[i][0]] = list[i][1];\n    }\n  }\n  return result;\n}\n","// Generate an integer Array containing an arithmetic progression. A port of\n// the native Python `range()` function. See\n// [the Python documentation](https://docs.python.org/library/functions.html#range).\nexport default function range(start, stop, step) {\n  if (stop == null) {\n    stop = start || 0;\n    start = 0;\n  }\n  if (!step) {\n    step = stop < start ? -1 : 1;\n  }\n\n  var length = Math.max(Math.ceil((stop - start) / step), 0);\n  var range = Array(length);\n\n  for (var idx = 0; idx < length; idx++, start += step) {\n    range[idx] = start;\n  }\n\n  return range;\n}\n","import { slice } from './_setup.js';\n\n// Chunk a single array into multiple arrays, each containing `count` or fewer\n// items.\nexport default function chunk(array, count) {\n  if (count == null || count < 1) return [];\n  var result = [];\n  var i = 0, length = array.length;\n  while (i < length) {\n    result.push(slice.call(array, i, i += count));\n  }\n  return result;\n}\n","import _ from './underscore.js';\n\n// Helper function to continue chaining intermediate results.\nexport default function chainResult(instance, obj) {\n  return instance._chain ? _(obj).chain() : obj;\n}\n","import _ from './underscore.js';\nimport each from './each.js';\nimport functions from './functions.js';\nimport { push } from './_setup.js';\nimport chainResult from './_chainResult.js';\n\n// Add your own custom functions to the Underscore object.\nexport default function mixin(obj) {\n  each(functions(obj), function(name) {\n    var func = _[name] = obj[name];\n    _.prototype[name] = function() {\n      var args = [this._wrapped];\n      push.apply(args, arguments);\n      return chainResult(this, func.apply(_, args));\n    };\n  });\n  return _;\n}\n","import _ from './underscore.js';\nimport each from './each.js';\nimport { ArrayProto } from './_setup.js';\nimport chainResult from './_chainResult.js';\n\n// Add all mutator `Array` functions to the wrapper.\neach(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n  var method = ArrayProto[name];\n  _.prototype[name] = function() {\n    var obj = this._wrapped;\n    if (obj != null) {\n      method.apply(obj, arguments);\n      if ((name === 'shift' || name === 'splice') && obj.length === 0) {\n        delete obj[0];\n      }\n    }\n    return chainResult(this, obj);\n  };\n});\n\n// Add all accessor `Array` functions to the wrapper.\neach(['concat', 'join', 'slice'], function(name) {\n  var method = ArrayProto[name];\n  _.prototype[name] = function() {\n    var obj = this._wrapped;\n    if (obj != null) obj = method.apply(obj, arguments);\n    return chainResult(this, obj);\n  };\n});\n\nexport default _;\n","// Default Export\n// ==============\n// In this module, we mix our bundled exports into the `_` object and export\n// the result. This is analogous to setting `module.exports = _` in CommonJS.\n// Hence, this module is also the entry point of our UMD bundle and the package\n// entry point for CommonJS and AMD users. In other words, this is (the source\n// of) the module you are interfacing with when you do any of the following:\n//\n// ```js\n// // CommonJS\n// var _ = require('underscore');\n//\n// // AMD\n// define(['underscore'], function(_) {...});\n//\n// // UMD in the browser\n// // _ is available as a global variable\n// ```\nimport * as allExports from './index.js';\nimport { mixin } from './index.js';\n\n// Add all of the Underscore functions to the wrapper object.\nvar _ = mixin(allExports);\n// Legacy Node.js API.\n_._ = _;\n// Export the Underscore API.\nexport default _;\n"],"names":["module","exports","objA","objB","compare","compareContext","ret","call","keysA","Object","keys","keysB","length","bHasOwnProperty","prototype","hasOwnProperty","bind","idx","key","valueA","valueB","GetIntrinsic","callBound","inspect","$TypeError","$WeakMap","$Map","$weakMapGet","$weakMapSet","$weakMapHas","$mapGet","$mapSet","$mapHas","listGetNode","list","curr","prev","next","listGet","objects","node","value","listSet","listHas","$wm","$m","$o","channel","assert","has","get","set","camel2hyphen","str","replace","match","toLowerCase","BOX_CLASS","CONTENT_CLASS","BACKDROP_CLASS","ARROW_CLASS","SVG_ARROW_CLASS","TOUCH_OPTIONS","passive","capture","TIPPY_DEFAULT_APPEND_TO","document","body","getValueAtIndexOrReturn","index","defaultValue","Array","isArray","v","isType","type","toString","indexOf","invokeWithArgsOrReturn","args","apply","debounce","fn","ms","arg","clearTimeout","timeout","setTimeout","splitBySpaces","split","filter","Boolean","normalizeToArray","concat","pushIfUnique","arr","push","unique","item","getBasePlacement","placement","arrayFrom","slice","removeUndefinedProps","obj","reduce","acc","undefined","div","createElement","isElement","some","isNodeList","isMouseEvent","isReferenceElement","_tippy","reference","getArrayOfElements","querySelectorAll","setTransitionDuration","els","forEach","el","style","transitionDuration","setVisibilityState","state","setAttribute","getOwnerDocument","elementOrElements","_element$ownerDocumen","_normalizeToArray","element","ownerDocument","isCursorOutsideInteractiveBorder","popperTreeData","event","clientX","clientY","every","_ref","popperRect","popperState","props","interactiveBorder","basePlacement","offsetData","modifiersData","offset","topDistance","top","y","bottomDistance","bottom","leftDistance","left","x","rightDistance","right","exceedsTop","exceedsBottom","exceedsLeft","exceedsRight","updateTransitionEndListener","box","action","listener","method","actualContains","parent","child","target","_target$getRootNode","contains","getRootNode","host","currentInput","isTouch","lastMouseMoveTime","onDocumentTouchStart","window","performance","addEventListener","onDocumentMouseMove","now","removeEventListener","onWindowBlur","activeElement","instance","blur","isVisible","bindGlobalEventListeners","isBrowser","isIE11","msCrypto","pluginProps","animateFill","followCursor","inlinePositioning","sticky","renderProps","allowHTML","animation","arrow","content","inertia","maxWidth","role","theme","zIndex","defaultProps","assign","appendTo","aria","expanded","delay","duration","getReferenceClientRect","hideOnClick","ignoreAttributes","interactive","interactiveDebounce","moveTransition","onAfterUpdate","onBeforeUpdate","onCreate","onDestroy","onHidden","onHide","onMount","onShow","onShown","onTrigger","onUntrigger","onClickOutside","plugins","popperOptions","render","showOnCreate","touch","trigger","triggerTarget","defaultKeys","setDefaultProps","partialProps","getExtendedPassedProps","passedProps","plugin","_name","name","getDataAttributeProps","propKeys","valueAsString","getAttribute","trim","JSON","parse","e","evaluateProps","out","innerHTML","dangerouslySetInnerHTML","html","createArrowElement","className","appendChild","setContent","textContent","getChildren","popper","firstElementChild","boxChildren","children","find","classList","backdrop","onUpdate","prevProps","nextProps","_getChildren","removeAttribute","removeChild","$$tippy","idCounter","mouseMoveListeners","mountedInstances","createTippy","showTimeout","hideTimeout","scheduleHideAnimationFrame","lastTriggerEvent","currentTransitionEndListener","onFirstUpdate","currentTarget","isVisibleFromClick","didHideDueToDocumentMouseDown","didTouchMove","ignoreOnFirstUpdate","listeners","debouncedOnMouseMove","onMouseMove","id","popperInstance","isEnabled","isDestroyed","isMounted","isShown","clearDelayTimeouts","setProps","show","hide","hideWithInteractivity","enable","disable","unmount","destroy","_props$render","pluginsHooks","map","hasAriaExpanded","hasAttribute","addListeners","handleAriaExpandedAttribute","handleStyles","invokeHook","scheduleShow","getDocument","getNormalizedTouchSettings","getIsCustomTouchBehavior","getIsDefaultRenderFn","_instance$props$rende","getCurrentTarget","parentNode","getDefaultTemplateChildren","getDelay","isShow","fromHide","pointerEvents","hook","shouldInvokePropsHook","_instance$props","pluginHooks","handleAriaContentAttribute","attr","nodes","currentValue","nextValue","cleanupInteractiveMouseListeners","onDocumentPress","actualTarget","composedPath","removeDocumentPress","onTouchMove","onTouchStart","addDocumentPress","doc","onTransitionedOut","callback","onTransitionEnd","onTransitionedIn","on","eventType","handler","options","onMouseLeave","onBlurOrFocusOut","removeListeners","_lastTriggerEvent","shouldScheduleClickHide","isEventListenerStopped","wasFocused","scheduleHide","isCursorOverReferenceOrPopper","getNestedPopperTree","_instance$popperInsta","getBoundingClientRect","shouldBail","relatedTarget","createPopperInstance","destroyPopperInstance","_instance$props2","computedReference","contextElement","tippyModifier","enabled","phase","requires","_ref2","_getDefaultTemplateCh","attributes","modifiers","padding","adaptive","mount","_getNormalizedTouchSe","touchValue","touchDelay","requestAnimationFrame","cancelAnimationFrame","nestedPopper","forceUpdate","isAlreadyVisible","isDisabled","isTouchAndTouchDisabled","visibility","transition","_getDefaultTemplateCh2","_instance$popperInsta2","offsetHeight","_getDefaultTemplateCh3","_box","_content","isAlreadyHidden","_getDefaultTemplateCh4","i","tippy","targets","optionalProps","elements","instances","effect","initialStyles","position","strategy","margin","styles","_typeof","o","Symbol","iterator","constructor","_defineProperties","descriptor","enumerable","configurable","writable","defineProperty","_toPropertyKey","_createClass","Constructor","protoProps","staticProps","_toPrimitive","String","input","hint","prim","toPrimitive","res","TypeError","Number","_classCallCheck","_inherits","subClass","superClass","create","_setPrototypeOf","_createSuper","Derived","hasNativeReflectConstruct","_isNativeReflectConstruct","result","Super","_getPrototypeOf","NewTarget","this","Reflect","construct","arguments","_possibleConstructorReturn","self","_assertThisInitialized","ReferenceError","_wrapNativeSuper","Class","_cache","Map","_isNativeFunction","Wrapper","_construct","Parent","a","Function","sham","Proxy","valueOf","p","setPrototypeOf","__proto__","getPrototypeOf","DetailedError","_Error","_super","message","_this","causingErr","req","originalRequest","originalResponse","causingError","requestId","getHeader","getMethod","url","getURL","status","getStatus","getBody","Error","log","msg","console","uuid","c","r","Math","random","_regeneratorRuntime","t","n","asyncIterator","u","toStringTag","define","wrap","Generator","Context","makeInvokeMethod","tryCatch","h","l","f","s","GeneratorFunction","GeneratorFunctionPrototype","d","values","g","defineIteratorMethods","_invoke","AsyncIterator","invoke","resolve","__await","then","callInvokeWithMethodAndArg","done","delegate","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","resultName","nextLoc","pushTryEntry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","isNaN","displayName","isGeneratorFunction","mark","awrap","async","Promise","reverse","pop","charAt","stop","rval","handle","complete","finish","delegateYield","asyncGeneratorStep","gen","reject","_next","_throw","info","error","_asyncToGenerator","err","_slicedToArray","_arrayWithHoles","_iterableToArrayLimit","_unsupportedIterableToArray","_nonIterableRest","minLen","_arrayLikeToArray","from","test","len","arr2","ownKeys","getOwnPropertySymbols","getOwnPropertyDescriptor","_objectSpread","_defineProperty","getOwnPropertyDescriptors","defineProperties","defaultOptions","endpoint","uploadUrl","metadata","fingerprint","uploadSize","onProgress","onChunkComplete","onSuccess","onError","onUploadUrlAvailable","overridePatchMethod","headers","addRequestId","onBeforeRequest","onAfterResponse","onShouldRetry","defaultOnShouldRetry","chunkSize","Infinity","retryDelays","parallelUploads","parallelUploadBoundaries","storeFingerprintForResuming","removeFingerprintOnSuccess","uploadLengthDeferred","uploadDataDuringCreation","urlStorage","fileReader","httpStack","BaseUpload","file","_urlStorage","_req","_fingerprint","_urlStorageKey","_offset","_aborted","_size","_source","_retryAttempt","_retryTimeout","_offsetBeforeRetry","_parallelUploads","_parallelUploadUrls","findUploadsByFingerprint","previousUpload","parallelUploadUrls","urlStorageKey","_this2","_i","_arr","optionName","_emitError","openFile","source","size","_startParallelUpload","_startSingleUpload","_this$options$paralle","_this3","totalSize","totalProgress","partCount","parts","splitSizeIntoParts","part","uploads","lastPartProgress","start","end","newPartProgress","_emitProgress","upload","_saveUploadInUrlStorage","all","_openRequest","setHeader","join","encodeMetadata","_sendRequest","inStatusCategory","location","resolveUrl","_emitSuccess","_emitHttpError","_resumeUpload","_createUpload","shouldTerminate","_this4","abort","terminate","_removeFromUrlStorage","_this5","shouldResetDelays","shouldRetry","bytesSent","bytesTotal","bytesAccepted","_this6","promise","_addChunkToRequest","close","_handleUploadResponse","_performUpload","_this7","parseInt","_this8","_this9","setProgressHandler","valueSize","newSize","_emitChunkComplete","openRequest","_this10","removeUpload","_this11","storedUpload","creationTime","Date","addUpload","sendRequest","remainingDelays","newOptions","entries","_ref3","_ref4","encode","category","createRequest","_ref5","_ref6","_x","_x2","_x3","_sendRequest2","_callee","_context","send","isOnline","online","navigator","onLine","retryAttempt","origin","link","partSize","floor","NoopUrlStorage","hasStorage","originalValue","localStorage","getItem","setItem","removeItem","code","SECURITY_ERR","QUOTA_EXCEEDED_ERR","canStoreURLs","WebStorageUrlStorage","results","_findEntries","round","stringify","prefix","_key","XHRHttpStack","Request","_xhr","XMLHttpRequest","open","_method","_url","_headers","header","setRequestHeader","progressHandler","onprogress","lengthComputable","loaded","onload","Response","onerror","xhr","getResponseHeader","responseText","isReactNative","product","uriToBlob","uri","responseType","blob","response","isCordova","PhoneGap","Cordova","cordova","readAsByteArray","chunk","reader","FileReader","Uint8Array","readAsArrayBuffer","FileSource","_file","blobOrArray","b","Blob","StreamSource","_buffer","_bufferOffset","_reader","_done","_readUntilEnoughDataOrDone","hasEnoughData","_getDataFromBuffer","read","hasAllDataBeenRead","cancel","_openFile","t0","isFinite","reactNativeFingerprint","lastModified","exifHash","exif","hashCode","hash","_char","charCodeAt","Upload","_BaseUpload","_window","required","qs","controlOrWhitespace","CRHTLF","slashes","port","protocolre","windowsDriveLetter","trimLeft","rules","address","isSpecial","protocol","NaN","ignore","query","lolcation","loc","globalVar","finaldestination","Url","unescape","pathname","href","scheme","extractProtocol","rest","exec","forwardSlashes","otherSlashes","slashesCount","relative","base","path","last","unshift","up","splice","parser","extracted","instruction","instructions","lastIndexOf","hostname","username","password","auth","encodeURIComponent","decodeURIComponent","char","ins","global","factory","trimRight","tinycolor","color","opts","rgb","inputToRGB","_originalInput","_r","_g","_b","_a","_roundA","_format","format","_gradientType","gradientType","_ok","ok","stringInputToObject","isValidCSSUnit","rgbToRgb","substr","convertToPercentage","hsvToRgb","hslToRgb","boundAlpha","min","max","bound01","rgbToHsl","hue2rgb","q","rgbToHsv","mod","rgbToHex","allow3Char","hex","pad2","rgbaToHex","allow4Char","convertDecimalToHex","rgbaToArgbHex","_desaturate","amount","hsl","toHsl","clamp01","_saturate","_greyscale","desaturate","_lighten","_brighten","toRgb","_darken","_spin","hue","_complement","polyad","number","step","_splitcomplement","_analogous","slices","_monochromatic","hsv","toHsv","modification","isDark","getBrightness","isLight","isValid","getOriginalInput","getFormat","getAlpha","getLuminance","RsRGB","GsRGB","BsRGB","R","G","B","pow","setAlpha","toHsvString","toHslString","toHex","toHexString","toHex8","toHex8String","toRgbString","toPercentageRgb","toPercentageRgbString","toName","hexNames","toFilter","secondColor","hex8String","secondHex8String","formatSet","formattedString","hasAlpha","needsAlphaFormat","clone","_applyModification","lighten","brighten","darken","saturate","greyscale","spin","_applyCombination","analogous","complement","monochromatic","splitcomplement","triad","tetrad","fromRatio","newColor","equals","color1","color2","mix","rgb1","rgb2","rgba","readability","c1","c2","isReadable","wcag2","wcag2Parms","validateWCAG2Parms","level","mostReadable","baseColor","colorList","includeFallbackColors","bestColor","bestScore","names","aliceblue","antiquewhite","aqua","aquamarine","azure","beige","bisque","black","blanchedalmond","blue","blueviolet","brown","burlywood","burntsienna","cadetblue","chartreuse","chocolate","coral","cornflowerblue","cornsilk","crimson","cyan","darkblue","darkcyan","darkgoldenrod","darkgray","darkgreen","darkgrey","darkkhaki","darkmagenta","darkolivegreen","darkorange","darkorchid","darkred","darksalmon","darkseagreen","darkslateblue","darkslategray","darkslategrey","darkturquoise","darkviolet","deeppink","deepskyblue","dimgray","dimgrey","dodgerblue","firebrick","floralwhite","forestgreen","fuchsia","gainsboro","ghostwhite","gold","goldenrod","gray","green","greenyellow","grey","honeydew","hotpink","indianred","indigo","ivory","khaki","lavender","lavenderblush","lawngreen","lemonchiffon","lightblue","lightcoral","lightcyan","lightgoldenrodyellow","lightgray","lightgreen","lightgrey","lightpink","lightsalmon","lightseagreen","lightskyblue","lightslategray","lightslategrey","lightsteelblue","lightyellow","lime","limegreen","linen","magenta","maroon","mediumaquamarine","mediumblue","mediumorchid","mediumpurple","mediumseagreen","mediumslateblue","mediumspringgreen","mediumturquoise","mediumvioletred","midnightblue","mintcream","mistyrose","moccasin","navajowhite","navy","oldlace","olive","olivedrab","orange","orangered","orchid","palegoldenrod","palegreen","paleturquoise","palevioletred","papayawhip","peachpuff","peru","pink","plum","powderblue","purple","rebeccapurple","red","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","slategrey","snow","springgreen","steelblue","tan","teal","thistle","tomato","turquoise","violet","wheat","white","whitesmoke","yellow","yellowgreen","flip","flipped","parseFloat","isOnePointZero","processPercent","isPercentage","abs","val","parseIntFromHex","convertHexToDecimal","matchers","CSS_INTEGER","CSS_NUMBER","CSS_UNIT","PERMISSIVE_MATCH3","PERMISSIVE_MATCH4","RegExp","hsla","hsva","hex3","hex6","hex4","hex8","named","parms","toUpperCase","VERSION","root","ArrayProto","ObjProto","SymbolProto","supportsArrayBuffer","ArrayBuffer","supportsDataView","DataView","nativeIsArray","nativeKeys","nativeCreate","nativeIsView","isView","_isNaN","_isFinite","hasEnumBug","propertyIsEnumerable","nonEnumerableProps","MAX_ARRAY_INDEX","restArguments","func","startIndex","isObject","isNull","isUndefined","isBoolean","nodeType","tagTester","tag","isFunction","nodelist","childNodes","Int8Array","hasDataViewBug","isDataView","alternateIsDataView","getInt8","isArrayBuffer","buffer","isArguments","isSymbol","isNumber","constant","createSizePropertyCheck","getSizeProperty","collection","sizeProperty","shallowProperty","typedArrayPattern","isTypedArray","emulatedSet","collectNonEnumProps","nonEnumIdx","proto","prop","isEmpty","isString","isMatch","object","attrs","_keys","_","_wrapped","toBufferView","bufferSource","byteOffset","toJSON","tagDataView","eq","aStack","bStack","deepEq","areArrays","byteLength","aCtor","bCtor","isEqual","allKeys","ie11fingerprint","methods","weakMapMethods","forEachName","hasName","commonInit","mapTail","mapMethods","setMethods","pairs","invert","functions","sort","createAssigner","keysFunc","defaults","ctor","baseCreate","Ctor","extendOwn","extend","tap","interceptor","toPath","deepGet","identity","matcher","property","optimizeCb","context","argCount","accumulator","baseIteratee","iteratee","cb","mapObject","currentKey","noop","propertyOf","times","accum","getTime","createEscaper","escaper","testRegexp","replaceRegexp","string","templateSettings","evaluate","interpolate","escape","noMatch","escapes","escapeRegExp","escapeChar","bareIdentifier","template","text","settings","oldSettings","argument","variable","data","fallback","uniqueId","chain","_chain","executeBound","sourceFunc","boundFunc","callingContext","partial","boundArgs","placeholder","bound","callArgs","flatten","depth","strict","output","j","memoize","hasher","cache","wait","throttle","previous","later","leading","throttled","_now","remaining","trailing","immediate","passed","debounced","_args","wrapper","negate","predicate","compose","after","before","memo","findKey","createPredicateIndexFinder","dir","array","sortedIndex","low","high","mid","createIndexFinder","predicateFind","findIndex","findLastIndex","keyFinder","findWhere","each","createReduce","reducer","initial","fromIndex","guard","contextPath","pluck","where","computed","lastComputed","reStrSymbol","toArray","sample","rand","temp","shuffle","sortBy","criteria","group","behavior","partition","pass","keyInObj","pick","first","compact","otherArrays","difference","uniq","isSorted","seen","arrays","intersection","argsLength","unzip","range","ceil","count","chainResult","mixin"],"sourceRoot":""}