{"version":3,"file":"ad-hoc/wac/search.js","mappings":"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","sources":["webpack:///./node_modules/@algolia/events/events.js","webpack:///./node_modules/@sentry/hub/esm/flags.js","webpack:///./node_modules/@sentry/hub/esm/session.js","webpack:///./node_modules/@sentry/hub/esm/hub.js","webpack:///./node_modules/@sentry/hub/esm/scope.js","webpack:///./node_modules/@sentry/hub/node_modules/tslib/tslib.es6.js","webpack:///./node_modules/@sentry/minimal/node_modules/tslib/tslib.es6.js","webpack:///./node_modules/@sentry/minimal/esm/index.js","webpack:///./node_modules/@sentry/types/esm/severity.js","webpack:///./node_modules/@sentry/utils/esm/browser.js","webpack:///./node_modules/@sentry/utils/esm/flags.js","webpack:///./node_modules/@sentry/utils/esm/global.js","webpack:///./node_modules/@sentry/utils/esm/is.js","webpack:///./node_modules/@sentry/utils/esm/logger.js","webpack:///./node_modules/@sentry/utils/esm/misc.js","webpack:///./node_modules/@sentry/utils/esm/node.js","webpack:///./node_modules/@sentry/utils/esm/env.js","webpack:///./node_modules/@sentry/utils/esm/object.js","webpack:///./node_modules/@sentry/utils/esm/string.js","webpack:///./node_modules/@sentry/utils/esm/syncpromise.js","webpack:///./node_modules/@sentry/utils/esm/time.js","webpack:///./node_modules/@sentry/utils/node_modules/tslib/tslib.es6.js","webpack:///./node_modules/algoliasearch-helper/index.js","webpack:///./node_modules/algoliasearch-helper/src/DerivedHelper/index.js","webpack:///./node_modules/algoliasearch-helper/src/SearchParameters/RefinementList.js","webpack:///./node_modules/algoliasearch-helper/src/SearchParameters/index.js","webpack:///./node_modules/algoliasearch-helper/src/SearchResults/generate-hierarchical-tree.js","webpack:///./node_modules/algoliasearch-helper/src/SearchResults/index.js","webpack:///./node_modules/algoliasearch-helper/src/algoliasearch.helper.js","webpack:///./node_modules/algoliasearch-helper/src/functions/compact.js","webpack:///./node_modules/algoliasearch-helper/src/functions/defaultsPure.js","webpack:///./node_modules/algoliasearch-helper/src/functions/escapeFacetValue.js","webpack:///./node_modules/algoliasearch-helper/src/functions/find.js","webpack:///./node_modules/algoliasearch-helper/src/functions/findIndex.js","webpack:///./node_modules/algoliasearch-helper/src/functions/formatSort.js","webpack:///./node_modules/algoliasearch-helper/src/functions/inherits.js","webpack:///./node_modules/algoliasearch-helper/src/functions/intersection.js","webpack:///./node_modules/algoliasearch-helper/src/functions/merge.js","webpack:///./node_modules/algoliasearch-helper/src/functions/objectHasKeys.js","webpack:///./node_modules/algoliasearch-helper/src/functions/omit.js","webpack:///./node_modules/algoliasearch-helper/src/functions/orderBy.js","webpack:///./node_modules/algoliasearch-helper/src/functions/valToNumber.js","webpack:///./node_modules/algoliasearch-helper/src/requestBuilder.js","webpack:///./node_modules/algoliasearch-helper/src/utils/isValidUserToken.js","webpack:///./node_modules/algoliasearch-helper/src/version.js","webpack:///./node_modules/algoliasearch/dist/algoliasearch.umd.js","webpack:///./node_modules/base64-js/index.js","webpack:///./node_modules/buffer/index.js","webpack:///./node_modules/ellipsize/src/index.js","webpack:///./node_modules/history/node_modules/@babel/runtime/helpers/esm/extends.js","webpack:///./node_modules/history/index.js","webpack:///./node_modules/ieee754/index.js","webpack:///./node_modules/querystringify/index.js","webpack:///./node_modules/requires-port/index.js","webpack:///./config.ts","webpack:///./node_modules/mustache/mustache.mjs","webpack:///./resources/js/ad-hoc/wac/search.ts","webpack:///./resources/js/common/analytics.ts","webpack:///./resources/js/common/environment.ts","webpack:///./resources/js/common/tracking/index.ts","webpack:///./resources/js/common/logger.ts","webpack:///./resources/js/common/tracking/constants.ts","webpack:///./resources/js/common/tracking/platforms/gasv2.ts","webpack:///./resources/js/common/tracking/platforms/gasv3.ts","webpack:///./resources/js/common/tracking/platforms/googleAnalytics.ts","webpack:///./resources/js/common/tracking/platforms/segment.ts","webpack:///./resources/js/common/tracking/platforms/index.ts","webpack:///./resources/js/imkt.ts","webpack:///./resources/js/utils/api.ts","webpack:///./resources/js/utils/browser.ts","webpack:///./resources/js/utils/general.ts","webpack:///./resources/js/utils/get-script.ts","webpack:///./resources/js/utils/history.ts","webpack:///./resources/js/utils/storage.ts","webpack:///./resources/js/utils/string.ts","webpack:///./resources/js/utils/tracking.ts","webpack:///./resources/js/utils/url.ts","webpack:///./node_modules/url-parse/index.js","webpack:///external var \"jQuery\"","webpack:///./node_modules/axios/lib/helpers/bind.js","webpack:///./node_modules/axios/lib/utils.js","webpack:///./node_modules/axios/lib/core/AxiosError.js","webpack:///./node_modules/axios/lib/helpers/toFormData.js","webpack:///./node_modules/axios/lib/helpers/AxiosURLSearchParams.js","webpack:///./node_modules/axios/lib/helpers/buildURL.js","webpack:///./node_modules/axios/lib/core/InterceptorManager.js","webpack:///./node_modules/axios/lib/defaults/transitional.js","webpack:///./node_modules/axios/lib/platform/browser/index.js","webpack:///./node_modules/axios/lib/platform/browser/classes/URLSearchParams.js","webpack:///./node_modules/axios/lib/platform/browser/classes/FormData.js","webpack:///./node_modules/axios/lib/platform/browser/classes/Blob.js","webpack:///./node_modules/axios/lib/platform/common/utils.js","webpack:///./node_modules/axios/lib/platform/index.js","webpack:///./node_modules/axios/lib/helpers/formDataToJSON.js","webpack:///./node_modules/axios/lib/defaults/index.js","webpack:///./node_modules/axios/lib/helpers/toURLEncodedForm.js","webpack:///./node_modules/axios/lib/helpers/parseHeaders.js","webpack:///./node_modules/axios/lib/core/AxiosHeaders.js","webpack:///./node_modules/axios/lib/core/transformData.js","webpack:///./node_modules/axios/lib/cancel/isCancel.js","webpack:///./node_modules/axios/lib/cancel/CanceledError.js","webpack:///./node_modules/axios/lib/core/settle.js","webpack:///./node_modules/axios/lib/helpers/speedometer.js","webpack:///./node_modules/axios/lib/helpers/progressEventReducer.js","webpack:///./node_modules/axios/lib/helpers/throttle.js","webpack:///./node_modules/axios/lib/helpers/isURLSameOrigin.js","webpack:///./node_modules/axios/lib/helpers/cookies.js","webpack:///./node_modules/axios/lib/core/buildFullPath.js","webpack:///./node_modules/axios/lib/helpers/isAbsoluteURL.js","webpack:///./node_modules/axios/lib/helpers/combineURLs.js","webpack:///./node_modules/axios/lib/core/mergeConfig.js","webpack:///./node_modules/axios/lib/helpers/resolveConfig.js","webpack:///./node_modules/axios/lib/adapters/xhr.js","webpack:///./node_modules/axios/lib/helpers/parseProtocol.js","webpack:///./node_modules/axios/lib/helpers/composeSignals.js","webpack:///./node_modules/axios/lib/helpers/trackStream.js","webpack:///./node_modules/axios/lib/adapters/fetch.js","webpack:///./node_modules/axios/lib/adapters/adapters.js","webpack:///./node_modules/axios/lib/helpers/null.js","webpack:///./node_modules/axios/lib/core/dispatchRequest.js","webpack:///./node_modules/axios/lib/env/data.js","webpack:///./node_modules/axios/lib/helpers/validator.js","webpack:///./node_modules/axios/lib/core/Axios.js","webpack:///./node_modules/axios/lib/cancel/CancelToken.js","webpack:///./node_modules/axios/lib/helpers/HttpStatusCode.js","webpack:///./node_modules/axios/lib/axios.js","webpack:///./node_modules/axios/lib/helpers/spread.js","webpack:///./node_modules/axios/lib/helpers/isAxiosError.js"],"sourcesContent":["// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n  this._events = this._events || {};\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\n// EventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function(n) {\n  if (!isNumber(n) || n < 0 || isNaN(n))\n    throw TypeError('n must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nEventEmitter.prototype.emit = function(type) {\n  var er, handler, len, args, i, listeners;\n\n  if (!this._events)\n    this._events = {};\n\n  // If there is no 'error' event listener then throw.\n  if (type === 'error') {\n    if (!this._events.error ||\n        (isObject(this._events.error) && !this._events.error.length)) {\n      er = arguments[1];\n      if (er instanceof Error) {\n        throw er; // Unhandled 'error' event\n      } else {\n        // At least give some kind of context to the user\n        var err = new Error('Uncaught, unspecified \"error\" event. (' + er + ')');\n        err.context = er;\n        throw err;\n      }\n    }\n  }\n\n  handler = this._events[type];\n\n  if (isUndefined(handler))\n    return false;\n\n  if (isFunction(handler)) {\n    switch (arguments.length) {\n      // fast cases\n      case 1:\n        handler.call(this);\n        break;\n      case 2:\n        handler.call(this, arguments[1]);\n        break;\n      case 3:\n        handler.call(this, arguments[1], arguments[2]);\n        break;\n      // slower\n      default:\n        args = Array.prototype.slice.call(arguments, 1);\n        handler.apply(this, args);\n    }\n  } else if (isObject(handler)) {\n    args = Array.prototype.slice.call(arguments, 1);\n    listeners = handler.slice();\n    len = listeners.length;\n    for (i = 0; i < len; i++)\n      listeners[i].apply(this, args);\n  }\n\n  return true;\n};\n\nEventEmitter.prototype.addListener = function(type, listener) {\n  var m;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events)\n    this._events = {};\n\n  // To avoid recursion in the case that type === \"newListener\"! Before\n  // adding it to the listeners, first emit \"newListener\".\n  if (this._events.newListener)\n    this.emit('newListener', type,\n              isFunction(listener.listener) ?\n              listener.listener : listener);\n\n  if (!this._events[type])\n    // Optimize the case of one listener. Don't need the extra array object.\n    this._events[type] = listener;\n  else if (isObject(this._events[type]))\n    // If we've already got an array, just append.\n    this._events[type].push(listener);\n  else\n    // Adding the second element, need to change to array.\n    this._events[type] = [this._events[type], listener];\n\n  // Check for listener leak\n  if (isObject(this._events[type]) && !this._events[type].warned) {\n    if (!isUndefined(this._maxListeners)) {\n      m = this._maxListeners;\n    } else {\n      m = EventEmitter.defaultMaxListeners;\n    }\n\n    if (m && m > 0 && this._events[type].length > m) {\n      this._events[type].warned = true;\n      console.error('(node) warning: possible EventEmitter memory ' +\n                    'leak detected. %d listeners added. ' +\n                    'Use emitter.setMaxListeners() to increase limit.',\n                    this._events[type].length);\n      if (typeof console.trace === 'function') {\n        // not supported in IE 10\n        console.trace();\n      }\n    }\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function(type, listener) {\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  var fired = false;\n\n  function g() {\n    this.removeListener(type, g);\n\n    if (!fired) {\n      fired = true;\n      listener.apply(this, arguments);\n    }\n  }\n\n  g.listener = listener;\n  this.on(type, g);\n\n  return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function(type, listener) {\n  var list, position, length, i;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events || !this._events[type])\n    return this;\n\n  list = this._events[type];\n  length = list.length;\n  position = -1;\n\n  if (list === listener ||\n      (isFunction(list.listener) && list.listener === listener)) {\n    delete this._events[type];\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n\n  } else if (isObject(list)) {\n    for (i = length; i-- > 0;) {\n      if (list[i] === listener ||\n          (list[i].listener && list[i].listener === listener)) {\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0)\n      return this;\n\n    if (list.length === 1) {\n      list.length = 0;\n      delete this._events[type];\n    } else {\n      list.splice(position, 1);\n    }\n\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function(type) {\n  var key, listeners;\n\n  if (!this._events)\n    return this;\n\n  // not listening for removeListener, no need to emit\n  if (!this._events.removeListener) {\n    if (arguments.length === 0)\n      this._events = {};\n    else if (this._events[type])\n      delete this._events[type];\n    return this;\n  }\n\n  // emit removeListener for all listeners on all events\n  if (arguments.length === 0) {\n    for (key in this._events) {\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n    this.removeAllListeners('removeListener');\n    this._events = {};\n    return this;\n  }\n\n  listeners = this._events[type];\n\n  if (isFunction(listeners)) {\n    this.removeListener(type, listeners);\n  } else if (listeners) {\n    // LIFO order\n    while (listeners.length)\n      this.removeListener(type, listeners[listeners.length - 1]);\n  }\n  delete this._events[type];\n\n  return this;\n};\n\nEventEmitter.prototype.listeners = function(type) {\n  var ret;\n  if (!this._events || !this._events[type])\n    ret = [];\n  else if (isFunction(this._events[type]))\n    ret = [this._events[type]];\n  else\n    ret = this._events[type].slice();\n  return ret;\n};\n\nEventEmitter.prototype.listenerCount = function(type) {\n  if (this._events) {\n    var evlistener = this._events[type];\n\n    if (isFunction(evlistener))\n      return 1;\n    else if (evlistener)\n      return evlistener.length;\n  }\n  return 0;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  return emitter.listenerCount(type);\n};\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n","/*\n * This file defines flags and constants that can be modified during compile time in order to facilitate tree shaking\n * for users.\n *\n * Debug flags need to be declared in each package individually and must not be imported across package boundaries,\n * because some build tools have trouble tree-shaking imported guards.\n *\n * As a convention, we define debug flags in a `flags.ts` file in the root of a package's `src` folder.\n *\n * Debug flag files will contain \"magic strings\" like `__SENTRY_DEBUG__` that may get replaced with actual values during\n * our, or the user's build process. Take care when introducing new flags - they must not throw if they are not\n * replaced.\n */\n/** Flag that is true for debug builds, false otherwise. */\nexport var IS_DEBUG_BUILD = typeof __SENTRY_DEBUG__ === 'undefined' ? true : __SENTRY_DEBUG__;\n//# sourceMappingURL=flags.js.map","import { dropUndefinedKeys, timestampInSeconds, uuid4 } from '@sentry/utils';\n/**\n * @inheritdoc\n */\nvar Session = /** @class */ (function () {\n    function Session(context) {\n        this.errors = 0;\n        this.sid = uuid4();\n        this.duration = 0;\n        this.status = 'ok';\n        this.init = true;\n        this.ignoreDuration = false;\n        // Both timestamp and started are in seconds since the UNIX epoch.\n        var startingTime = timestampInSeconds();\n        this.timestamp = startingTime;\n        this.started = startingTime;\n        if (context) {\n            this.update(context);\n        }\n    }\n    /** JSDoc */\n    // eslint-disable-next-line complexity\n    Session.prototype.update = function (context) {\n        if (context === void 0) { context = {}; }\n        if (context.user) {\n            if (!this.ipAddress && context.user.ip_address) {\n                this.ipAddress = context.user.ip_address;\n            }\n            if (!this.did && !context.did) {\n                this.did = context.user.id || context.user.email || context.user.username;\n            }\n        }\n        this.timestamp = context.timestamp || timestampInSeconds();\n        if (context.ignoreDuration) {\n            this.ignoreDuration = context.ignoreDuration;\n        }\n        if (context.sid) {\n            // Good enough uuid validation. — Kamil\n            this.sid = context.sid.length === 32 ? context.sid : uuid4();\n        }\n        if (context.init !== undefined) {\n            this.init = context.init;\n        }\n        if (!this.did && context.did) {\n            this.did = \"\" + context.did;\n        }\n        if (typeof context.started === 'number') {\n            this.started = context.started;\n        }\n        if (this.ignoreDuration) {\n            this.duration = undefined;\n        }\n        else if (typeof context.duration === 'number') {\n            this.duration = context.duration;\n        }\n        else {\n            var duration = this.timestamp - this.started;\n            this.duration = duration >= 0 ? duration : 0;\n        }\n        if (context.release) {\n            this.release = context.release;\n        }\n        if (context.environment) {\n            this.environment = context.environment;\n        }\n        if (!this.ipAddress && context.ipAddress) {\n            this.ipAddress = context.ipAddress;\n        }\n        if (!this.userAgent && context.userAgent) {\n            this.userAgent = context.userAgent;\n        }\n        if (typeof context.errors === 'number') {\n            this.errors = context.errors;\n        }\n        if (context.status) {\n            this.status = context.status;\n        }\n    };\n    /** JSDoc */\n    Session.prototype.close = function (status) {\n        if (status) {\n            this.update({ status: status });\n        }\n        else if (this.status === 'ok') {\n            this.update({ status: 'exited' });\n        }\n        else {\n            this.update();\n        }\n    };\n    /** JSDoc */\n    Session.prototype.toJSON = function () {\n        return dropUndefinedKeys({\n            sid: \"\" + this.sid,\n            init: this.init,\n            // Make sure that sec is converted to ms for date constructor\n            started: new Date(this.started * 1000).toISOString(),\n            timestamp: new Date(this.timestamp * 1000).toISOString(),\n            status: this.status,\n            errors: this.errors,\n            did: typeof this.did === 'number' || typeof this.did === 'string' ? \"\" + this.did : undefined,\n            duration: this.duration,\n            attrs: {\n                release: this.release,\n                environment: this.environment,\n                ip_address: this.ipAddress,\n                user_agent: this.userAgent,\n            },\n        });\n    };\n    return Session;\n}());\nexport { Session };\n//# sourceMappingURL=session.js.map","import { __assign, __read, __spread } from \"tslib\";\nimport { consoleSandbox, dateTimestampInSeconds, getGlobalObject, getGlobalSingleton, isNodeEnv, logger, uuid4, } from '@sentry/utils';\nimport { IS_DEBUG_BUILD } from './flags';\nimport { Scope } from './scope';\nimport { Session } from './session';\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nexport var API_VERSION = 4;\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nvar DEFAULT_BREADCRUMBS = 100;\n/**\n * @inheritDoc\n */\nvar Hub = /** @class */ (function () {\n    /**\n     * Creates a new instance of the hub, will push one {@link Layer} into the\n     * internal stack on creation.\n     *\n     * @param client bound to the hub.\n     * @param scope bound to the hub.\n     * @param version number, higher number means higher priority.\n     */\n    function Hub(client, scope, _version) {\n        if (scope === void 0) { scope = new Scope(); }\n        if (_version === void 0) { _version = API_VERSION; }\n        this._version = _version;\n        /** Is a {@link Layer}[] containing the client and scope */\n        this._stack = [{}];\n        this.getStackTop().scope = scope;\n        if (client) {\n            this.bindClient(client);\n        }\n    }\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.isOlderThan = function (version) {\n        return this._version < version;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.bindClient = function (client) {\n        var top = this.getStackTop();\n        top.client = client;\n        if (client && client.setupIntegrations) {\n            client.setupIntegrations();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.pushScope = function () {\n        // We want to clone the content of prev scope\n        var scope = Scope.clone(this.getScope());\n        this.getStack().push({\n            client: this.getClient(),\n            scope: scope,\n        });\n        return scope;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.popScope = function () {\n        if (this.getStack().length <= 1)\n            return false;\n        return !!this.getStack().pop();\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.withScope = function (callback) {\n        var scope = this.pushScope();\n        try {\n            callback(scope);\n        }\n        finally {\n            this.popScope();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getClient = function () {\n        return this.getStackTop().client;\n    };\n    /** Returns the scope of the top stack. */\n    Hub.prototype.getScope = function () {\n        return this.getStackTop().scope;\n    };\n    /** Returns the scope stack for domains or the process. */\n    Hub.prototype.getStack = function () {\n        return this._stack;\n    };\n    /** Returns the topmost scope layer in the order domain > local > process. */\n    Hub.prototype.getStackTop = function () {\n        return this._stack[this._stack.length - 1];\n    };\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    Hub.prototype.captureException = function (exception, hint) {\n        var eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimic the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error('Sentry syntheticException');\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: exception,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureException', exception, __assign(__assign({}, finalHint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureMessage = function (message, level, hint) {\n        var eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimic the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error(message);\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: message,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureMessage', message, level, __assign(__assign({}, finalHint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureEvent = function (event, hint) {\n        var eventId = hint && hint.event_id ? hint.event_id : uuid4();\n        if (event.type !== 'transaction') {\n            this._lastEventId = eventId;\n        }\n        this._invokeClient('captureEvent', event, __assign(__assign({}, hint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.lastEventId = function () {\n        return this._lastEventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.addBreadcrumb = function (breadcrumb, hint) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (!scope || !client)\n            return;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var _b = (client.getOptions && client.getOptions()) || {}, _c = _b.beforeBreadcrumb, beforeBreadcrumb = _c === void 0 ? null : _c, _d = _b.maxBreadcrumbs, maxBreadcrumbs = _d === void 0 ? DEFAULT_BREADCRUMBS : _d;\n        if (maxBreadcrumbs <= 0)\n            return;\n        var timestamp = dateTimestampInSeconds();\n        var mergedBreadcrumb = __assign({ timestamp: timestamp }, breadcrumb);\n        var finalBreadcrumb = beforeBreadcrumb\n            ? consoleSandbox(function () { return beforeBreadcrumb(mergedBreadcrumb, hint); })\n            : mergedBreadcrumb;\n        if (finalBreadcrumb === null)\n            return;\n        scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setUser = function (user) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setUser(user);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTags = function (tags) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setTags(tags);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtras = function (extras) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setExtras(extras);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTag = function (key, value) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setTag(key, value);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtra = function (key, extra) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setExtra(key, extra);\n    };\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype.setContext = function (name, context) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setContext(name, context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.configureScope = function (callback) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (scope && client) {\n            callback(scope);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.run = function (callback) {\n        var oldHub = makeMain(this);\n        try {\n            callback(this);\n        }\n        finally {\n            makeMain(oldHub);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getIntegration = function (integration) {\n        var client = this.getClient();\n        if (!client)\n            return null;\n        try {\n            return client.getIntegration(integration);\n        }\n        catch (_oO) {\n            IS_DEBUG_BUILD && logger.warn(\"Cannot retrieve integration \" + integration.id + \" from the current Hub\");\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSpan = function (context) {\n        return this._callExtensionMethod('startSpan', context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startTransaction = function (context, customSamplingContext) {\n        return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.traceHeaders = function () {\n        return this._callExtensionMethod('traceHeaders');\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureSession = function (endSession) {\n        if (endSession === void 0) { endSession = false; }\n        // both send the update and pull the session from the scope\n        if (endSession) {\n            return this.endSession();\n        }\n        // only send the update\n        this._sendSessionUpdate();\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.endSession = function () {\n        var layer = this.getStackTop();\n        var scope = layer && layer.scope;\n        var session = scope && scope.getSession();\n        if (session) {\n            session.close();\n        }\n        this._sendSessionUpdate();\n        // the session is over; take it off of the scope\n        if (scope) {\n            scope.setSession();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSession = function (context) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        var _b = (client && client.getOptions()) || {}, release = _b.release, environment = _b.environment;\n        // Will fetch userAgent if called from browser sdk\n        var global = getGlobalObject();\n        var userAgent = (global.navigator || {}).userAgent;\n        var session = new Session(__assign(__assign(__assign({ release: release,\n            environment: environment }, (scope && { user: scope.getUser() })), (userAgent && { userAgent: userAgent })), context));\n        if (scope) {\n            // End existing session if there's one\n            var currentSession = scope.getSession && scope.getSession();\n            if (currentSession && currentSession.status === 'ok') {\n                currentSession.update({ status: 'exited' });\n            }\n            this.endSession();\n            // Afterwards we set the new session on the scope\n            scope.setSession(session);\n        }\n        return session;\n    };\n    /**\n     * Sends the current Session on the scope\n     */\n    Hub.prototype._sendSessionUpdate = function () {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (!scope)\n            return;\n        var session = scope.getSession && scope.getSession();\n        if (session) {\n            if (client && client.captureSession) {\n                client.captureSession(session);\n            }\n        }\n    };\n    /**\n     * Internal helper function to call a method on the top client if it exists.\n     *\n     * @param method The method to call on the client.\n     * @param args Arguments to pass to the client function.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype._invokeClient = function (method) {\n        var _a;\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var _b = this.getStackTop(), scope = _b.scope, client = _b.client;\n        if (client && client[method]) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any\n            (_a = client)[method].apply(_a, __spread(args, [scope]));\n        }\n    };\n    /**\n     * Calls global extension method and binding current instance to the function call\n     */\n    // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype._callExtensionMethod = function (method) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var carrier = getMainCarrier();\n        var sentry = carrier.__SENTRY__;\n        if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n            return sentry.extensions[method].apply(this, args);\n        }\n        IS_DEBUG_BUILD && logger.warn(\"Extension method \" + method + \" couldn't be found, doing nothing.\");\n    };\n    return Hub;\n}());\nexport { Hub };\n/**\n * Returns the global shim registry.\n *\n * FIXME: This function is problematic, because despite always returning a valid Carrier,\n * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check\n * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.\n **/\nexport function getMainCarrier() {\n    var carrier = getGlobalObject();\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {\n        extensions: {},\n        hub: undefined,\n    };\n    return carrier;\n}\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nexport function makeMain(hub) {\n    var registry = getMainCarrier();\n    var oldHub = getHubFromCarrier(registry);\n    setHubOnCarrier(registry, hub);\n    return oldHub;\n}\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nexport function getCurrentHub() {\n    // Get main carrier (global for every environment)\n    var registry = getMainCarrier();\n    // If there's no hub, or its an old API, assign a new one\n    if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n        setHubOnCarrier(registry, new Hub());\n    }\n    // Prefer domains over global if they are there (applicable only to Node environment)\n    if (isNodeEnv()) {\n        return getHubFromActiveDomain(registry);\n    }\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n}\n/**\n * Returns the active domain, if one exists\n * @deprecated No longer used; remove in v7\n * @returns The domain, or undefined if there is no active domain\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function getActiveDomain() {\n    IS_DEBUG_BUILD && logger.warn('Function `getActiveDomain` is deprecated and will be removed in a future version.');\n    var sentry = getMainCarrier().__SENTRY__;\n    return sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n}\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n    try {\n        var sentry = getMainCarrier().__SENTRY__;\n        var activeDomain = sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n        // If there's no active domain, just return global hub\n        if (!activeDomain) {\n            return getHubFromCarrier(registry);\n        }\n        // If there's no hub on current domain, or it's an old API, assign a new one\n        if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n            var registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n            setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n        }\n        // Return hub that lives on a domain\n        return getHubFromCarrier(activeDomain);\n    }\n    catch (_Oo) {\n        // Return hub that lives on a global object\n        return getHubFromCarrier(registry);\n    }\n}\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier) {\n    return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nexport function getHubFromCarrier(carrier) {\n    return getGlobalSingleton('hub', function () { return new Hub(); }, carrier);\n}\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n * @returns A boolean indicating success or failure\n */\nexport function setHubOnCarrier(carrier, hub) {\n    if (!carrier)\n        return false;\n    var __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});\n    __SENTRY__.hub = hub;\n    return true;\n}\n//# sourceMappingURL=hub.js.map","import { __assign, __read, __spread } from \"tslib\";\nimport { dateTimestampInSeconds, getGlobalSingleton, isPlainObject, isThenable, SyncPromise } from '@sentry/utils';\n/**\n * Absolute maximum number of breadcrumbs added to an event.\n * The `maxBreadcrumbs` option cannot be higher than this value.\n */\nvar MAX_BREADCRUMBS = 100;\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nvar Scope = /** @class */ (function () {\n    function Scope() {\n        /** Flag if notifying is happening. */\n        this._notifyingListeners = false;\n        /** Callback for client to receive scope changes. */\n        this._scopeListeners = [];\n        /** Callback list that will be called after {@link applyToEvent}. */\n        this._eventProcessors = [];\n        /** Array of breadcrumbs. */\n        this._breadcrumbs = [];\n        /** User */\n        this._user = {};\n        /** Tags */\n        this._tags = {};\n        /** Extra */\n        this._extra = {};\n        /** Contexts */\n        this._contexts = {};\n        /**\n         * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get\n         * sent to Sentry\n         */\n        this._sdkProcessingMetadata = {};\n    }\n    /**\n     * Inherit values from the parent scope.\n     * @param scope to clone.\n     */\n    Scope.clone = function (scope) {\n        var newScope = new Scope();\n        if (scope) {\n            newScope._breadcrumbs = __spread(scope._breadcrumbs);\n            newScope._tags = __assign({}, scope._tags);\n            newScope._extra = __assign({}, scope._extra);\n            newScope._contexts = __assign({}, scope._contexts);\n            newScope._user = scope._user;\n            newScope._level = scope._level;\n            newScope._span = scope._span;\n            newScope._session = scope._session;\n            newScope._transactionName = scope._transactionName;\n            newScope._fingerprint = scope._fingerprint;\n            newScope._eventProcessors = __spread(scope._eventProcessors);\n            newScope._requestSession = scope._requestSession;\n        }\n        return newScope;\n    };\n    /**\n     * Add internal on change listener. Used for sub SDKs that need to store the scope.\n     * @hidden\n     */\n    Scope.prototype.addScopeListener = function (callback) {\n        this._scopeListeners.push(callback);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addEventProcessor = function (callback) {\n        this._eventProcessors.push(callback);\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setUser = function (user) {\n        this._user = user || {};\n        if (this._session) {\n            this._session.update({ user: user });\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getUser = function () {\n        return this._user;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getRequestSession = function () {\n        return this._requestSession;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setRequestSession = function (requestSession) {\n        this._requestSession = requestSession;\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTags = function (tags) {\n        this._tags = __assign(__assign({}, this._tags), tags);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTag = function (key, value) {\n        var _a;\n        this._tags = __assign(__assign({}, this._tags), (_a = {}, _a[key] = value, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtras = function (extras) {\n        this._extra = __assign(__assign({}, this._extra), extras);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtra = function (key, extra) {\n        var _a;\n        this._extra = __assign(__assign({}, this._extra), (_a = {}, _a[key] = extra, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setFingerprint = function (fingerprint) {\n        this._fingerprint = fingerprint;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setLevel = function (level) {\n        this._level = level;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTransactionName = function (name) {\n        this._transactionName = name;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Can be removed in major version.\n     * @deprecated in favor of {@link this.setTransactionName}\n     */\n    Scope.prototype.setTransaction = function (name) {\n        return this.setTransactionName(name);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setContext = function (key, context) {\n        var _a;\n        if (context === null) {\n            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n            delete this._contexts[key];\n        }\n        else {\n            this._contexts = __assign(__assign({}, this._contexts), (_a = {}, _a[key] = context, _a));\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSpan = function (span) {\n        this._span = span;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getSpan = function () {\n        return this._span;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getTransaction = function () {\n        // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will\n        // have a pointer to the currently-active transaction.\n        var span = this.getSpan();\n        return span && span.transaction;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSession = function (session) {\n        if (!session) {\n            delete this._session;\n        }\n        else {\n            this._session = session;\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getSession = function () {\n        return this._session;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.update = function (captureContext) {\n        if (!captureContext) {\n            return this;\n        }\n        if (typeof captureContext === 'function') {\n            var updatedScope = captureContext(this);\n            return updatedScope instanceof Scope ? updatedScope : this;\n        }\n        if (captureContext instanceof Scope) {\n            this._tags = __assign(__assign({}, this._tags), captureContext._tags);\n            this._extra = __assign(__assign({}, this._extra), captureContext._extra);\n            this._contexts = __assign(__assign({}, this._contexts), captureContext._contexts);\n            if (captureContext._user && Object.keys(captureContext._user).length) {\n                this._user = captureContext._user;\n            }\n            if (captureContext._level) {\n                this._level = captureContext._level;\n            }\n            if (captureContext._fingerprint) {\n                this._fingerprint = captureContext._fingerprint;\n            }\n            if (captureContext._requestSession) {\n                this._requestSession = captureContext._requestSession;\n            }\n        }\n        else if (isPlainObject(captureContext)) {\n            // eslint-disable-next-line no-param-reassign\n            captureContext = captureContext;\n            this._tags = __assign(__assign({}, this._tags), captureContext.tags);\n            this._extra = __assign(__assign({}, this._extra), captureContext.extra);\n            this._contexts = __assign(__assign({}, this._contexts), captureContext.contexts);\n            if (captureContext.user) {\n                this._user = captureContext.user;\n            }\n            if (captureContext.level) {\n                this._level = captureContext.level;\n            }\n            if (captureContext.fingerprint) {\n                this._fingerprint = captureContext.fingerprint;\n            }\n            if (captureContext.requestSession) {\n                this._requestSession = captureContext.requestSession;\n            }\n        }\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clear = function () {\n        this._breadcrumbs = [];\n        this._tags = {};\n        this._extra = {};\n        this._user = {};\n        this._contexts = {};\n        this._level = undefined;\n        this._transactionName = undefined;\n        this._fingerprint = undefined;\n        this._requestSession = undefined;\n        this._span = undefined;\n        this._session = undefined;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {\n        var maxCrumbs = typeof maxBreadcrumbs === 'number' ? Math.min(maxBreadcrumbs, MAX_BREADCRUMBS) : MAX_BREADCRUMBS;\n        // No data has been changed, so don't notify scope listeners\n        if (maxCrumbs <= 0) {\n            return this;\n        }\n        var mergedBreadcrumb = __assign({ timestamp: dateTimestampInSeconds() }, breadcrumb);\n        this._breadcrumbs = __spread(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxCrumbs);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clearBreadcrumbs = function () {\n        this._breadcrumbs = [];\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Applies the current context and fingerprint to the event.\n     * Note that breadcrumbs will be added by the client.\n     * Also if the event has already breadcrumbs on it, we do not merge them.\n     * @param event Event\n     * @param hint May contain additional information about the original exception.\n     * @hidden\n     */\n    Scope.prototype.applyToEvent = function (event, hint) {\n        if (this._extra && Object.keys(this._extra).length) {\n            event.extra = __assign(__assign({}, this._extra), event.extra);\n        }\n        if (this._tags && Object.keys(this._tags).length) {\n            event.tags = __assign(__assign({}, this._tags), event.tags);\n        }\n        if (this._user && Object.keys(this._user).length) {\n            event.user = __assign(__assign({}, this._user), event.user);\n        }\n        if (this._contexts && Object.keys(this._contexts).length) {\n            event.contexts = __assign(__assign({}, this._contexts), event.contexts);\n        }\n        if (this._level) {\n            event.level = this._level;\n        }\n        if (this._transactionName) {\n            event.transaction = this._transactionName;\n        }\n        // We want to set the trace context for normal events only if there isn't already\n        // a trace context on the event. There is a product feature in place where we link\n        // errors with transaction and it relies on that.\n        if (this._span) {\n            event.contexts = __assign({ trace: this._span.getTraceContext() }, event.contexts);\n            var transactionName = this._span.transaction && this._span.transaction.name;\n            if (transactionName) {\n                event.tags = __assign({ transaction: transactionName }, event.tags);\n            }\n        }\n        this._applyFingerprint(event);\n        event.breadcrumbs = __spread((event.breadcrumbs || []), this._breadcrumbs);\n        event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n        event.sdkProcessingMetadata = this._sdkProcessingMetadata;\n        return this._notifyEventProcessors(__spread(getGlobalEventProcessors(), this._eventProcessors), event, hint);\n    };\n    /**\n     * Add data which will be accessible during event processing but won't get sent to Sentry\n     */\n    Scope.prototype.setSDKProcessingMetadata = function (newData) {\n        this._sdkProcessingMetadata = __assign(__assign({}, this._sdkProcessingMetadata), newData);\n        return this;\n    };\n    /**\n     * This will be called after {@link applyToEvent} is finished.\n     */\n    Scope.prototype._notifyEventProcessors = function (processors, event, hint, index) {\n        var _this = this;\n        if (index === void 0) { index = 0; }\n        return new SyncPromise(function (resolve, reject) {\n            var processor = processors[index];\n            if (event === null || typeof processor !== 'function') {\n                resolve(event);\n            }\n            else {\n                var result = processor(__assign({}, event), hint);\n                if (isThenable(result)) {\n                    void result\n                        .then(function (final) { return _this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve); })\n                        .then(null, reject);\n                }\n                else {\n                    void _this._notifyEventProcessors(processors, result, hint, index + 1)\n                        .then(resolve)\n                        .then(null, reject);\n                }\n            }\n        });\n    };\n    /**\n     * This will be called on every set call.\n     */\n    Scope.prototype._notifyScopeListeners = function () {\n        var _this = this;\n        // We need this check for this._notifyingListeners to be able to work on scope during updates\n        // If this check is not here we'll produce endless recursion when something is done with the scope\n        // during the callback.\n        if (!this._notifyingListeners) {\n            this._notifyingListeners = true;\n            this._scopeListeners.forEach(function (callback) {\n                callback(_this);\n            });\n            this._notifyingListeners = false;\n        }\n    };\n    /**\n     * Applies fingerprint from the scope to the event if there's one,\n     * uses message if there's one instead or get rid of empty fingerprint\n     */\n    Scope.prototype._applyFingerprint = function (event) {\n        // Make sure it's an array first and we actually have something in place\n        event.fingerprint = event.fingerprint\n            ? Array.isArray(event.fingerprint)\n                ? event.fingerprint\n                : [event.fingerprint]\n            : [];\n        // If we have something on the scope, then merge it with event\n        if (this._fingerprint) {\n            event.fingerprint = event.fingerprint.concat(this._fingerprint);\n        }\n        // If we have no data at all, remove empty array default\n        if (event.fingerprint && !event.fingerprint.length) {\n            delete event.fingerprint;\n        }\n    };\n    return Scope;\n}());\nexport { Scope };\n/**\n * Returns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n    return getGlobalSingleton('globalEventProcessors', function () { return []; });\n}\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nexport function addGlobalEventProcessor(callback) {\n    getGlobalEventProcessors().push(callback);\n}\n//# sourceMappingURL=scope.js.map","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import { __assign, __read, __spread } from \"tslib\";\nimport { getCurrentHub } from '@sentry/hub';\n/**\n * This calls a function on the current hub.\n * @param method function to call on hub.\n * @param args to pass to function.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction callOnHub(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    var hub = getCurrentHub();\n    if (hub && hub[method]) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return hub[method].apply(hub, __spread(args));\n    }\n    throw new Error(\"No hub defined or \" + method + \" was not found on the hub, please open a bug report.\");\n}\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @returns The generated eventId.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nexport function captureException(exception, captureContext) {\n    var syntheticException = new Error('Sentry syntheticException');\n    return callOnHub('captureException', exception, {\n        captureContext: captureContext,\n        originalException: exception,\n        syntheticException: syntheticException,\n    });\n}\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param Severity Define the level of the message.\n * @returns The generated eventId.\n */\nexport function captureMessage(message, captureContext) {\n    var syntheticException = new Error(message);\n    // This is necessary to provide explicit scopes upgrade, without changing the original\n    // arity of the `captureMessage(message, level)` method.\n    var level = typeof captureContext === 'string' ? captureContext : undefined;\n    var context = typeof captureContext !== 'string' ? { captureContext: captureContext } : undefined;\n    return callOnHub('captureMessage', message, level, __assign({ originalException: message, syntheticException: syntheticException }, context));\n}\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nexport function captureEvent(event) {\n    return callOnHub('captureEvent', event);\n}\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nexport function configureScope(callback) {\n    callOnHub('configureScope', callback);\n}\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nexport function addBreadcrumb(breadcrumb) {\n    callOnHub('addBreadcrumb', breadcrumb);\n}\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function setContext(name, context) {\n    callOnHub('setContext', name, context);\n}\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nexport function setExtras(extras) {\n    callOnHub('setExtras', extras);\n}\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nexport function setTags(tags) {\n    callOnHub('setTags', tags);\n}\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nexport function setExtra(key, extra) {\n    callOnHub('setExtra', key, extra);\n}\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nexport function setTag(key, value) {\n    callOnHub('setTag', key, value);\n}\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nexport function setUser(user) {\n    callOnHub('setUser', user);\n}\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nexport function withScope(callback) {\n    callOnHub('withScope', callback);\n}\n/**\n * Calls a function on the latest client. Use this with caution, it's meant as\n * in \"internal\" helper so we don't need to expose every possible function in\n * the shim. It is not guaranteed that the client actually implements the\n * function.\n *\n * @param method The method to call on the client/client.\n * @param args Arguments to pass to the client/fontend.\n * @hidden\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function _callOnClient(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    callOnHub.apply(void 0, __spread(['_invokeClient', method], args));\n}\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n */\nexport function startTransaction(context, customSamplingContext) {\n    return callOnHub('startTransaction', __assign({}, context), customSamplingContext);\n}\n//# sourceMappingURL=index.js.map","/**\n * TODO(v7): Remove this enum and replace with SeverityLevel\n */\nexport var Severity;\n(function (Severity) {\n    /** JSDoc */\n    Severity[\"Fatal\"] = \"fatal\";\n    /** JSDoc */\n    Severity[\"Error\"] = \"error\";\n    /** JSDoc */\n    Severity[\"Warning\"] = \"warning\";\n    /** JSDoc */\n    Severity[\"Log\"] = \"log\";\n    /** JSDoc */\n    Severity[\"Info\"] = \"info\";\n    /** JSDoc */\n    Severity[\"Debug\"] = \"debug\";\n    /** JSDoc */\n    Severity[\"Critical\"] = \"critical\";\n})(Severity || (Severity = {}));\n// TODO: in v7, these can disappear, because they now also exist in `@sentry/utils`. (Having them there rather than here\n// is nice because then it enforces the idea that only types are exported from `@sentry/types`.)\nexport var SeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug', 'critical'];\n//# sourceMappingURL=severity.js.map","import { getGlobalObject } from './global';\nimport { isString } from './is';\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nexport function htmlTreeAsString(elem, keyAttrs) {\n    // try/catch both:\n    // - accessing event.target (see getsentry/raven-js#838, #768)\n    // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n    // - can throw an exception in some circumstances.\n    try {\n        var currentElem = elem;\n        var MAX_TRAVERSE_HEIGHT = 5;\n        var MAX_OUTPUT_LEN = 80;\n        var out = [];\n        var height = 0;\n        var len = 0;\n        var separator = ' > ';\n        var sepLength = separator.length;\n        var nextStr = void 0;\n        // eslint-disable-next-line no-plusplus\n        while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n            nextStr = _htmlElementAsString(currentElem, keyAttrs);\n            // bail out if\n            // - nextStr is the 'html' element\n            // - the length of the string that would be created exceeds MAX_OUTPUT_LEN\n            //   (ignore this limit if we are on the first iteration)\n            if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {\n                break;\n            }\n            out.push(nextStr);\n            len += nextStr.length;\n            currentElem = currentElem.parentNode;\n        }\n        return out.reverse().join(separator);\n    }\n    catch (_oO) {\n        return '<unknown>';\n    }\n}\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el, keyAttrs) {\n    var elem = el;\n    var out = [];\n    var className;\n    var classes;\n    var key;\n    var attr;\n    var i;\n    if (!elem || !elem.tagName) {\n        return '';\n    }\n    out.push(elem.tagName.toLowerCase());\n    // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n    var keyAttrPairs = keyAttrs && keyAttrs.length\n        ? keyAttrs.filter(function (keyAttr) { return elem.getAttribute(keyAttr); }).map(function (keyAttr) { return [keyAttr, elem.getAttribute(keyAttr)]; })\n        : null;\n    if (keyAttrPairs && keyAttrPairs.length) {\n        keyAttrPairs.forEach(function (keyAttrPair) {\n            out.push(\"[\" + keyAttrPair[0] + \"=\\\"\" + keyAttrPair[1] + \"\\\"]\");\n        });\n    }\n    else {\n        if (elem.id) {\n            out.push(\"#\" + elem.id);\n        }\n        // eslint-disable-next-line prefer-const\n        className = elem.className;\n        if (className && isString(className)) {\n            classes = className.split(/\\s+/);\n            for (i = 0; i < classes.length; i++) {\n                out.push(\".\" + classes[i]);\n            }\n        }\n    }\n    var allowedAttrs = ['type', 'name', 'title', 'alt'];\n    for (i = 0; i < allowedAttrs.length; i++) {\n        key = allowedAttrs[i];\n        attr = elem.getAttribute(key);\n        if (attr) {\n            out.push(\"[\" + key + \"=\\\"\" + attr + \"\\\"]\");\n        }\n    }\n    return out.join('');\n}\n/**\n * A safe form of location.href\n */\nexport function getLocationHref() {\n    var global = getGlobalObject();\n    try {\n        return global.document.location.href;\n    }\n    catch (oO) {\n        return '';\n    }\n}\n//# sourceMappingURL=browser.js.map","/*\n * This file defines flags and constants that can be modified during compile time in order to facilitate tree shaking\n * for users.\n *\n * Debug flags need to be declared in each package individually and must not be imported across package boundaries,\n * because some build tools have trouble tree-shaking imported guards.\n *\n * As a convention, we define debug flags in a `flags.ts` file in the root of a package's `src` folder.\n *\n * Debug flag files will contain \"magic strings\" like `__SENTRY_DEBUG__` that may get replaced with actual values during\n * our, or the user's build process. Take care when introducing new flags - they must not throw if they are not\n * replaced.\n */\n/** Flag that is true for debug builds, false otherwise. */\nexport var IS_DEBUG_BUILD = typeof __SENTRY_DEBUG__ === 'undefined' ? true : __SENTRY_DEBUG__;\n//# sourceMappingURL=flags.js.map","/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n */\nimport { isNodeEnv } from './node';\nvar fallbackGlobalObject = {};\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nexport function getGlobalObject() {\n    return (isNodeEnv()\n        ? global\n        : typeof window !== 'undefined' // eslint-disable-line no-restricted-globals\n            ? window // eslint-disable-line no-restricted-globals\n            : typeof self !== 'undefined'\n                ? self\n                : fallbackGlobalObject);\n}\n/**\n * Returns a global singleton contained in the global `__SENTRY__` object.\n *\n * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory\n * function and added to the `__SENTRY__` object.\n *\n * @param name name of the global singleton on __SENTRY__\n * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`\n * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `getGlobalObject`'s return value\n * @returns the singleton\n */\nexport function getGlobalSingleton(name, creator, obj) {\n    var global = (obj || getGlobalObject());\n    var __SENTRY__ = (global.__SENTRY__ = global.__SENTRY__ || {});\n    var singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n    return singleton;\n}\n//# sourceMappingURL=global.js.map","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n// eslint-disable-next-line @typescript-eslint/unbound-method\nvar objectToString = Object.prototype.toString;\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isError(wat) {\n    switch (objectToString.call(wat)) {\n        case '[object Error]':\n        case '[object Exception]':\n        case '[object DOMException]':\n            return true;\n        default:\n            return isInstanceOf(wat, Error);\n    }\n}\nfunction isBuiltin(wat, ty) {\n    return objectToString.call(wat) === \"[object \" + ty + \"]\";\n}\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isErrorEvent(wat) {\n    return isBuiltin(wat, 'ErrorEvent');\n}\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMError(wat) {\n    return isBuiltin(wat, 'DOMError');\n}\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMException(wat) {\n    return isBuiltin(wat, 'DOMException');\n}\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isString(wat) {\n    return isBuiltin(wat, 'String');\n}\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPrimitive(wat) {\n    return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPlainObject(wat) {\n    return isBuiltin(wat, 'Object');\n}\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isEvent(wat) {\n    return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isElement(wat) {\n    return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isRegExp(wat) {\n    return isBuiltin(wat, 'RegExp');\n}\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nexport function isThenable(wat) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isSyntheticEvent(wat) {\n    return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n/**\n * Checks whether given value is NaN\n * {@link isNaN}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isNaN(wat) {\n    return typeof wat === 'number' && wat !== wat;\n}\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nexport function isInstanceOf(wat, base) {\n    try {\n        return wat instanceof base;\n    }\n    catch (_e) {\n        return false;\n    }\n}\n//# sourceMappingURL=is.js.map","import { __read, __spread } from \"tslib\";\nimport { IS_DEBUG_BUILD } from './flags';\nimport { getGlobalObject, getGlobalSingleton } from './global';\n// TODO: Implement different loggers for different environments\nvar global = getGlobalObject();\n/** Prefix for logging strings */\nvar PREFIX = 'Sentry Logger ';\nexport var CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert'];\n/**\n * Temporarily disable sentry console instrumentations.\n *\n * @param callback The function to run against the original `console` messages\n * @returns The results of the callback\n */\nexport function consoleSandbox(callback) {\n    var global = getGlobalObject();\n    if (!('console' in global)) {\n        return callback();\n    }\n    var originalConsole = global.console;\n    var wrappedLevels = {};\n    // Restore all wrapped console methods\n    CONSOLE_LEVELS.forEach(function (level) {\n        // TODO(v7): Remove this check as it's only needed for Node 6\n        var originalWrappedFunc = originalConsole[level] && originalConsole[level].__sentry_original__;\n        if (level in global.console && originalWrappedFunc) {\n            wrappedLevels[level] = originalConsole[level];\n            originalConsole[level] = originalWrappedFunc;\n        }\n    });\n    try {\n        return callback();\n    }\n    finally {\n        // Revert restoration to wrapped state\n        Object.keys(wrappedLevels).forEach(function (level) {\n            originalConsole[level] = wrappedLevels[level];\n        });\n    }\n}\nfunction makeLogger() {\n    var enabled = false;\n    var logger = {\n        enable: function () {\n            enabled = true;\n        },\n        disable: function () {\n            enabled = false;\n        },\n    };\n    if (IS_DEBUG_BUILD) {\n        CONSOLE_LEVELS.forEach(function (name) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            logger[name] = function () {\n                var args = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    args[_i] = arguments[_i];\n                }\n                if (enabled) {\n                    consoleSandbox(function () {\n                        var _a;\n                        (_a = global.console)[name].apply(_a, __spread([PREFIX + \"[\" + name + \"]:\"], args));\n                    });\n                }\n            };\n        });\n    }\n    else {\n        CONSOLE_LEVELS.forEach(function (name) {\n            logger[name] = function () { return undefined; };\n        });\n    }\n    return logger;\n}\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nvar logger;\nif (IS_DEBUG_BUILD) {\n    logger = getGlobalSingleton('logger', makeLogger);\n}\nelse {\n    logger = makeLogger();\n}\nexport { logger };\n//# sourceMappingURL=logger.js.map","import { __assign } from \"tslib\";\nimport { getGlobalObject } from './global';\nimport { addNonEnumerableProperty } from './object';\nimport { snipLine } from './string';\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nexport function uuid4() {\n    var global = getGlobalObject();\n    var crypto = global.crypto || global.msCrypto;\n    if (!(crypto === void 0) && crypto.getRandomValues) {\n        // Use window.crypto API if available\n        var arr = new Uint16Array(8);\n        crypto.getRandomValues(arr);\n        // set 4 in byte 7\n        // eslint-disable-next-line no-bitwise\n        arr[3] = (arr[3] & 0xfff) | 0x4000;\n        // set 2 most significant bits of byte 9 to '10'\n        // eslint-disable-next-line no-bitwise\n        arr[4] = (arr[4] & 0x3fff) | 0x8000;\n        var pad = function (num) {\n            var v = num.toString(16);\n            while (v.length < 4) {\n                v = \"0\" + v;\n            }\n            return v;\n        };\n        return (pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) + pad(arr[5]) + pad(arr[6]) + pad(arr[7]));\n    }\n    // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n    return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n        // eslint-disable-next-line no-bitwise\n        var r = (Math.random() * 16) | 0;\n        // eslint-disable-next-line no-bitwise\n        var v = c === 'x' ? r : (r & 0x3) | 0x8;\n        return v.toString(16);\n    });\n}\n/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nexport function parseUrl(url) {\n    if (!url) {\n        return {};\n    }\n    var match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n    if (!match) {\n        return {};\n    }\n    // coerce to undefined values to empty string so we don't get 'undefined'\n    var query = match[6] || '';\n    var fragment = match[8] || '';\n    return {\n        host: match[4],\n        path: match[5],\n        protocol: match[2],\n        relative: match[5] + query + fragment,\n    };\n}\nfunction getFirstException(event) {\n    return event.exception && event.exception.values ? event.exception.values[0] : undefined;\n}\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nexport function getEventDescription(event) {\n    var message = event.message, eventId = event.event_id;\n    if (message) {\n        return message;\n    }\n    var firstException = getFirstException(event);\n    if (firstException) {\n        if (firstException.type && firstException.value) {\n            return firstException.type + \": \" + firstException.value;\n        }\n        return firstException.type || firstException.value || eventId || '<unknown>';\n    }\n    return eventId || '<unknown>';\n}\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nexport function addExceptionTypeValue(event, value, type) {\n    var exception = (event.exception = event.exception || {});\n    var values = (exception.values = exception.values || []);\n    var firstException = (values[0] = values[0] || {});\n    if (!firstException.value) {\n        firstException.value = value || '';\n    }\n    if (!firstException.type) {\n        firstException.type = type || 'Error';\n    }\n}\n/**\n * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.\n *\n * @param event The event to modify.\n * @param newMechanism Mechanism data to add to the event.\n * @hidden\n */\nexport function addExceptionMechanism(event, newMechanism) {\n    var firstException = getFirstException(event);\n    if (!firstException) {\n        return;\n    }\n    var defaultMechanism = { type: 'generic', handled: true };\n    var currentMechanism = firstException.mechanism;\n    firstException.mechanism = __assign(__assign(__assign({}, defaultMechanism), currentMechanism), newMechanism);\n    if (newMechanism && 'data' in newMechanism) {\n        var mergedData = __assign(__assign({}, (currentMechanism && currentMechanism.data)), newMechanism.data);\n        firstException.mechanism.data = mergedData;\n    }\n}\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nvar SEMVER_REGEXP = /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nexport function parseSemver(input) {\n    var match = input.match(SEMVER_REGEXP) || [];\n    var major = parseInt(match[1], 10);\n    var minor = parseInt(match[2], 10);\n    var patch = parseInt(match[3], 10);\n    return {\n        buildmetadata: match[5],\n        major: isNaN(major) ? undefined : major,\n        minor: isNaN(minor) ? undefined : minor,\n        patch: isNaN(patch) ? undefined : patch,\n        prerelease: match[4],\n    };\n}\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nexport function addContextToFrame(lines, frame, linesOfContext) {\n    if (linesOfContext === void 0) { linesOfContext = 5; }\n    var lineno = frame.lineno || 0;\n    var maxLines = lines.length;\n    var sourceLine = Math.max(Math.min(maxLines, lineno - 1), 0);\n    frame.pre_context = lines\n        .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n        .map(function (line) { return snipLine(line, 0); });\n    frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n    frame.post_context = lines\n        .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n        .map(function (line) { return snipLine(line, 0); });\n}\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nexport function stripUrlQueryAndFragment(urlPath) {\n    // eslint-disable-next-line no-useless-escape\n    return urlPath.split(/[\\?#]/, 1)[0];\n}\n/**\n * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object\n * in question), and marks it captured if not.\n *\n * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and\n * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so\n * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because\n * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not\n * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This\n * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we\n * see it.\n *\n * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on\n * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent\n * object wrapper forms so that this check will always work. However, because we need to flag the exact object which\n * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification\n * must be done before the exception captured.\n *\n * @param A thrown exception to check or flag as having been seen\n * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)\n */\nexport function checkOrSetAlreadyCaught(exception) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    if (exception && exception.__sentry_captured__) {\n        return true;\n    }\n    try {\n        // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the\n        // `ExtraErrorData` integration\n        addNonEnumerableProperty(exception, '__sentry_captured__', true);\n    }\n    catch (err) {\n        // `exception` is a primitive, so we can't mark it seen\n    }\n    return false;\n}\n//# sourceMappingURL=misc.js.map","/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n */\nimport { isBrowserBundle } from './env';\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nexport function isNodeEnv() {\n    // explicitly check for browser bundles as those can be optimized statically\n    // by terser/rollup.\n    return (!isBrowserBundle() &&\n        Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]');\n}\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any\nexport function dynamicRequire(mod, request) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return mod.require(request);\n}\n/**\n * Helper for dynamically loading module that should work with linked dependencies.\n * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`\n * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during\n * build time. `require.resolve` is also not available in any other way, so we cannot create,\n * a fake helper like we do with `dynamicRequire`.\n *\n * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.\n * That is to mimic the behavior of `require.resolve` exactly.\n *\n * @param moduleName module name to require\n * @returns possibly required module\n */\nexport function loadModule(moduleName) {\n    var mod;\n    try {\n        mod = dynamicRequire(module, moduleName);\n    }\n    catch (e) {\n        // no-empty\n    }\n    try {\n        var cwd = dynamicRequire(module, 'process').cwd;\n        mod = dynamicRequire(module, cwd() + \"/node_modules/\" + moduleName);\n    }\n    catch (e) {\n        // no-empty\n    }\n    return mod;\n}\n//# sourceMappingURL=node.js.map","/*\n * This module exists for optimizations in the build process through rollup and terser.  We define some global\n * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these\n * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will\n * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to\n * `logger` and preventing node-related code from appearing in browser bundles.\n *\n * Attention:\n * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by\n * users. These fags should live in their respective packages, as we identified user tooling (specifically webpack)\n * having issues tree-shaking these constants across package boundaries.\n * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want\n * users to be able to shake away expressions that it guards.\n */\n/**\n * Figures out if we're building a browser bundle.\n *\n * @returns true if this is a browser bundle build.\n */\nexport function isBrowserBundle() {\n    return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;\n}\n//# sourceMappingURL=env.js.map","import { __assign, __values } from \"tslib\";\nimport { htmlTreeAsString } from './browser';\nimport { isElement, isError, isEvent, isInstanceOf, isPlainObject, isPrimitive } from './is';\nimport { truncate } from './string';\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * @param source An object that contains a method to be wrapped.\n * @param name The name of the method to be wrapped.\n * @param replacementFactory A higher-order function that takes the original version of the given method and returns a\n * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to\n * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other\n * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\nexport function fill(source, name, replacementFactory) {\n    if (!(name in source)) {\n        return;\n    }\n    var original = source[name];\n    var wrapped = replacementFactory(original);\n    // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n    // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n    if (typeof wrapped === 'function') {\n        try {\n            markFunctionWrapped(wrapped, original);\n        }\n        catch (_Oo) {\n            // This can throw if multiple fill happens on a global object like XMLHttpRequest\n            // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n        }\n    }\n    source[name] = wrapped;\n}\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nexport function addNonEnumerableProperty(obj, name, value) {\n    Object.defineProperty(obj, name, {\n        // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n        value: value,\n        writable: true,\n        configurable: true,\n    });\n}\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nexport function markFunctionWrapped(wrapped, original) {\n    var proto = original.prototype || {};\n    wrapped.prototype = original.prototype = proto;\n    addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n}\n/**\n * This extracts the original function if available.  See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\nexport function getOriginalFunction(func) {\n    return func.__sentry_original__;\n}\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nexport function urlEncode(object) {\n    return Object.keys(object)\n        .map(function (key) { return encodeURIComponent(key) + \"=\" + encodeURIComponent(object[key]); })\n        .join('&');\n}\n/**\n * Transforms any object into an object literal with all its attributes\n * attached to it.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n */\nexport function convertToPlainObject(value) {\n    var newObj = value;\n    if (isError(value)) {\n        newObj = __assign({ message: value.message, name: value.name, stack: value.stack }, getOwnProperties(value));\n    }\n    else if (isEvent(value)) {\n        var event_1 = value;\n        newObj = __assign({ type: event_1.type, target: serializeEventTarget(event_1.target), currentTarget: serializeEventTarget(event_1.currentTarget) }, getOwnProperties(event_1));\n        if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n            newObj.detail = event_1.detail;\n        }\n    }\n    return newObj;\n}\n/** Creates a string representation of the target of an `Event` object */\nfunction serializeEventTarget(target) {\n    try {\n        return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);\n    }\n    catch (_oO) {\n        return '<unknown>';\n    }\n}\n/** Filters out all but an object's own properties */\nfunction getOwnProperties(obj) {\n    var extractedProps = {};\n    for (var property in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, property)) {\n            extractedProps[property] = obj[property];\n        }\n    }\n    return extractedProps;\n}\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function extractExceptionKeysForMessage(exception, maxLength) {\n    if (maxLength === void 0) { maxLength = 40; }\n    var keys = Object.keys(convertToPlainObject(exception));\n    keys.sort();\n    if (!keys.length) {\n        return '[object has no keys]';\n    }\n    if (keys[0].length >= maxLength) {\n        return truncate(keys[0], maxLength);\n    }\n    for (var includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n        var serialized = keys.slice(0, includedKeys).join(', ');\n        if (serialized.length > maxLength) {\n            continue;\n        }\n        if (includedKeys === keys.length) {\n            return serialized;\n        }\n        return truncate(serialized, maxLength);\n    }\n    return '';\n}\n/**\n * Given any object, return the new object with removed keys that value was `undefined`.\n * Works recursively on objects and arrays.\n */\nexport function dropUndefinedKeys(val) {\n    var e_1, _a;\n    if (isPlainObject(val)) {\n        var rv = {};\n        try {\n            for (var _b = __values(Object.keys(val)), _c = _b.next(); !_c.done; _c = _b.next()) {\n                var key = _c.value;\n                if (typeof val[key] !== 'undefined') {\n                    rv[key] = dropUndefinedKeys(val[key]);\n                }\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        return rv;\n    }\n    if (Array.isArray(val)) {\n        return val.map(dropUndefinedKeys);\n    }\n    return val;\n}\n/**\n * Ensure that something is an object.\n *\n * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper\n * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.\n *\n * @param wat The subject of the objectification\n * @returns A version of `wat` which can safely be used with `Object` class methods\n */\nexport function objectify(wat) {\n    var objectified;\n    switch (true) {\n        case wat === undefined || wat === null:\n            objectified = new String(wat);\n            break;\n        // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason\n        // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as\n        // an object in order to wrap it.\n        case typeof wat === 'symbol' || typeof wat === 'bigint':\n            objectified = Object(wat);\n            break;\n        // this will catch the remaining primitives: `String`, `Number`, and `Boolean`\n        case isPrimitive(wat):\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            objectified = new wat.constructor(wat);\n            break;\n        // by process of elimination, at this point we know that `wat` must already be an object\n        default:\n            objectified = wat;\n            break;\n    }\n    return objectified;\n}\n//# sourceMappingURL=object.js.map","import { isRegExp, isString } from './is';\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nexport function truncate(str, max) {\n    if (max === void 0) { max = 0; }\n    if (typeof str !== 'string' || max === 0) {\n        return str;\n    }\n    return str.length <= max ? str : str.substr(0, max) + \"...\";\n}\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nexport function snipLine(line, colno) {\n    var newLine = line;\n    var lineLength = newLine.length;\n    if (lineLength <= 150) {\n        return newLine;\n    }\n    if (colno > lineLength) {\n        // eslint-disable-next-line no-param-reassign\n        colno = lineLength;\n    }\n    var start = Math.max(colno - 60, 0);\n    if (start < 5) {\n        start = 0;\n    }\n    var end = Math.min(start + 140, lineLength);\n    if (end > lineLength - 5) {\n        end = lineLength;\n    }\n    if (end === lineLength) {\n        start = Math.max(end - 140, 0);\n    }\n    newLine = newLine.slice(start, end);\n    if (start > 0) {\n        newLine = \"'{snip} \" + newLine;\n    }\n    if (end < lineLength) {\n        newLine += ' {snip}';\n    }\n    return newLine;\n}\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function safeJoin(input, delimiter) {\n    if (!Array.isArray(input)) {\n        return '';\n    }\n    var output = [];\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (var i = 0; i < input.length; i++) {\n        var value = input[i];\n        try {\n            output.push(String(value));\n        }\n        catch (e) {\n            output.push('[value cannot be serialized]');\n        }\n    }\n    return output.join(delimiter);\n}\n/**\n * Checks if the value matches a regex or includes the string\n * @param value The string value to be checked against\n * @param pattern Either a regex or a string that must be contained in value\n */\nexport function isMatchingPattern(value, pattern) {\n    if (!isString(value)) {\n        return false;\n    }\n    if (isRegExp(pattern)) {\n        return pattern.test(value);\n    }\n    if (typeof pattern === 'string') {\n        return value.indexOf(pattern) !== -1;\n    }\n    return false;\n}\n/**\n * Given a string, escape characters which have meaning in the regex grammar, such that the result is safe to feed to\n * `new RegExp()`.\n *\n * Based on https://github.com/sindresorhus/escape-string-regexp. Vendored to a) reduce the size by skipping the runtime\n * type-checking, and b) ensure it gets down-compiled for old versions of Node (the published package only supports Node\n * 12+).\n *\n * @param regexString The string to escape\n * @returns An version of the string with all special regex characters escaped\n */\nexport function escapeStringForRegex(regexString) {\n    // escape the hyphen separately so we can also replace it with a unicode literal hyphen, to avoid the problems\n    // discussed in https://github.com/sindresorhus/escape-string-regexp/issues/20.\n    return regexString.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d');\n}\n//# sourceMappingURL=string.js.map","/* eslint-disable @typescript-eslint/explicit-function-return-type */\n/* eslint-disable @typescript-eslint/typedef */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { isThenable } from './is';\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nexport function resolvedSyncPromise(value) {\n    return new SyncPromise(function (resolve) {\n        resolve(value);\n    });\n}\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nexport function rejectedSyncPromise(reason) {\n    return new SyncPromise(function (_, reject) {\n        reject(reason);\n    });\n}\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nvar SyncPromise = /** @class */ (function () {\n    function SyncPromise(executor) {\n        var _this = this;\n        this._state = 0 /* PENDING */;\n        this._handlers = [];\n        /** JSDoc */\n        this._resolve = function (value) {\n            _this._setResult(1 /* RESOLVED */, value);\n        };\n        /** JSDoc */\n        this._reject = function (reason) {\n            _this._setResult(2 /* REJECTED */, reason);\n        };\n        /** JSDoc */\n        this._setResult = function (state, value) {\n            if (_this._state !== 0 /* PENDING */) {\n                return;\n            }\n            if (isThenable(value)) {\n                void value.then(_this._resolve, _this._reject);\n                return;\n            }\n            _this._state = state;\n            _this._value = value;\n            _this._executeHandlers();\n        };\n        /** JSDoc */\n        this._executeHandlers = function () {\n            if (_this._state === 0 /* PENDING */) {\n                return;\n            }\n            var cachedHandlers = _this._handlers.slice();\n            _this._handlers = [];\n            cachedHandlers.forEach(function (handler) {\n                if (handler[0]) {\n                    return;\n                }\n                if (_this._state === 1 /* RESOLVED */) {\n                    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n                    handler[1](_this._value);\n                }\n                if (_this._state === 2 /* REJECTED */) {\n                    handler[2](_this._value);\n                }\n                handler[0] = true;\n            });\n        };\n        try {\n            executor(this._resolve, this._reject);\n        }\n        catch (e) {\n            this._reject(e);\n        }\n    }\n    /** JSDoc */\n    SyncPromise.prototype.then = function (onfulfilled, onrejected) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            _this._handlers.push([\n                false,\n                function (result) {\n                    if (!onfulfilled) {\n                        // TODO: ¯\\_(ツ)_/¯\n                        // TODO: FIXME\n                        resolve(result);\n                    }\n                    else {\n                        try {\n                            resolve(onfulfilled(result));\n                        }\n                        catch (e) {\n                            reject(e);\n                        }\n                    }\n                },\n                function (reason) {\n                    if (!onrejected) {\n                        reject(reason);\n                    }\n                    else {\n                        try {\n                            resolve(onrejected(reason));\n                        }\n                        catch (e) {\n                            reject(e);\n                        }\n                    }\n                },\n            ]);\n            _this._executeHandlers();\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.catch = function (onrejected) {\n        return this.then(function (val) { return val; }, onrejected);\n    };\n    /** JSDoc */\n    SyncPromise.prototype.finally = function (onfinally) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            var val;\n            var isRejected;\n            return _this.then(function (value) {\n                isRejected = false;\n                val = value;\n                if (onfinally) {\n                    onfinally();\n                }\n            }, function (reason) {\n                isRejected = true;\n                val = reason;\n                if (onfinally) {\n                    onfinally();\n                }\n            }).then(function () {\n                if (isRejected) {\n                    reject(val);\n                    return;\n                }\n                resolve(val);\n            });\n        });\n    };\n    return SyncPromise;\n}());\nexport { SyncPromise };\n//# sourceMappingURL=syncpromise.js.map","import { getGlobalObject } from './global';\nimport { dynamicRequire, isNodeEnv } from './node';\n/**\n * A TimestampSource implementation for environments that do not support the Performance Web API natively.\n *\n * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier\n * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It\n * is more obvious to explain \"why does my span have negative duration\" than \"why my spans have zero duration\".\n */\nvar dateTimestampSource = {\n    nowSeconds: function () { return Date.now() / 1000; },\n};\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction getBrowserPerformance() {\n    var performance = getGlobalObject().performance;\n    if (!performance || !performance.now) {\n        return undefined;\n    }\n    // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n    //\n    // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n    // performance.now() gives a date arbitrarily in the past.\n    //\n    // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n    // undefined.\n    //\n    // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n    // interact with data coming out of performance entries.\n    //\n    // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n    // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n    // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n    // observed skews that can be as long as days, weeks or months.\n    //\n    // See https://github.com/getsentry/sentry-javascript/issues/2590.\n    //\n    // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n    // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n    // transactions of long-lived web pages.\n    var timeOrigin = Date.now() - performance.now();\n    return {\n        now: function () { return performance.now(); },\n        timeOrigin: timeOrigin,\n    };\n}\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\nfunction getNodePerformance() {\n    try {\n        var perfHooks = dynamicRequire(module, 'perf_hooks');\n        return perfHooks.performance;\n    }\n    catch (_) {\n        return undefined;\n    }\n}\n/**\n * The Performance API implementation for the current platform, if available.\n */\nvar platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\nvar timestampSource = platformPerformance === undefined\n    ? dateTimestampSource\n    : {\n        nowSeconds: function () { return (platformPerformance.timeOrigin + platformPerformance.now()) / 1000; },\n    };\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nexport var dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * See `usingPerformanceAPI` to test whether the Performance API is used.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nexport var timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);\n// Re-exported with an old name for backwards-compatibility.\nexport var timestampWithMs = timestampInSeconds;\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nexport var usingPerformanceAPI = platformPerformance !== undefined;\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n */\nexport var _browserPerformanceTimeOriginMode;\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nexport var browserPerformanceTimeOrigin = (function () {\n    // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or\n    // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin\n    // data as reliable if they are within a reasonable threshold of the current time.\n    var performance = getGlobalObject().performance;\n    if (!performance || !performance.now) {\n        _browserPerformanceTimeOriginMode = 'none';\n        return undefined;\n    }\n    var threshold = 3600 * 1000;\n    var performanceNow = performance.now();\n    var dateNow = Date.now();\n    // if timeOrigin isn't available set delta to threshold so it isn't used\n    var timeOriginDelta = performance.timeOrigin\n        ? Math.abs(performance.timeOrigin + performanceNow - dateNow)\n        : threshold;\n    var timeOriginIsReliable = timeOriginDelta < threshold;\n    // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n    // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n    // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n    // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n    // Date API.\n    // eslint-disable-next-line deprecation/deprecation\n    var navigationStart = performance.timing && performance.timing.navigationStart;\n    var hasNavigationStart = typeof navigationStart === 'number';\n    // if navigationStart isn't available set delta to threshold so it isn't used\n    var navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n    var navigationStartIsReliable = navigationStartDelta < threshold;\n    if (timeOriginIsReliable || navigationStartIsReliable) {\n        // Use the more reliable time origin\n        if (timeOriginDelta <= navigationStartDelta) {\n            _browserPerformanceTimeOriginMode = 'timeOrigin';\n            return performance.timeOrigin;\n        }\n        else {\n            _browserPerformanceTimeOriginMode = 'navigationStart';\n            return navigationStart;\n        }\n    }\n    // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n    _browserPerformanceTimeOriginMode = 'dateNow';\n    return dateNow;\n})();\n//# sourceMappingURL=time.js.map","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","'use strict';\n\nvar AlgoliaSearchHelper = require('./src/algoliasearch.helper');\n\nvar SearchParameters = require('./src/SearchParameters');\nvar SearchResults = require('./src/SearchResults');\n\n/**\n * The algoliasearchHelper module is the function that will let its\n * contains everything needed to use the Algoliasearch\n * Helper. It is a also a function that instanciate the helper.\n * To use the helper, you also need the Algolia JS client v3.\n * @example\n * //using the UMD build\n * var client = algoliasearch('latency', '6be0576ff61c053d5f9a3225e2a90f76');\n * var helper = algoliasearchHelper(client, 'bestbuy', {\n *   facets: ['shipping'],\n *   disjunctiveFacets: ['category']\n * });\n * helper.on('result', function(event) {\n *   console.log(event.results);\n * });\n * helper\n *   .toggleFacetRefinement('category', 'Movies & TV Shows')\n *   .toggleFacetRefinement('shipping', 'Free shipping')\n *   .search();\n * @example\n * // The helper is an event emitter using the node API\n * helper.on('result', updateTheResults);\n * helper.once('result', updateTheResults);\n * helper.removeListener('result', updateTheResults);\n * helper.removeAllListeners('result');\n * @module algoliasearchHelper\n * @param  {AlgoliaSearch} client an AlgoliaSearch client\n * @param  {string} index the name of the index to query\n * @param  {SearchParameters|object} opts an object defining the initial config of the search. It doesn't have to be a {SearchParameters}, just an object containing the properties you need from it.\n * @return {AlgoliaSearchHelper}\n */\nfunction algoliasearchHelper(client, index, opts) {\n  return new AlgoliaSearchHelper(client, index, opts);\n}\n\n/**\n * The version currently used\n * @member module:algoliasearchHelper.version\n * @type {number}\n */\nalgoliasearchHelper.version = require('./src/version.js');\n\n/**\n * Constructor for the Helper.\n * @member module:algoliasearchHelper.AlgoliaSearchHelper\n * @type {AlgoliaSearchHelper}\n */\nalgoliasearchHelper.AlgoliaSearchHelper = AlgoliaSearchHelper;\n\n/**\n * Constructor for the object containing all the parameters of the search.\n * @member module:algoliasearchHelper.SearchParameters\n * @type {SearchParameters}\n */\nalgoliasearchHelper.SearchParameters = SearchParameters;\n\n/**\n * Constructor for the object containing the results of the search.\n * @member module:algoliasearchHelper.SearchResults\n * @type {SearchResults}\n */\nalgoliasearchHelper.SearchResults = SearchResults;\n\nmodule.exports = algoliasearchHelper;\n","'use strict';\n\nvar EventEmitter = require('@algolia/events');\nvar inherits = require('../functions/inherits');\n\n/**\n * A DerivedHelper is a way to create sub requests to\n * Algolia from a main helper.\n * @class\n * @classdesc The DerivedHelper provides an event based interface for search callbacks:\n *  - search: when a search is triggered using the `search()` method.\n *  - result: when the response is retrieved from Algolia and is processed.\n *    This event contains a {@link SearchResults} object and the\n *    {@link SearchParameters} corresponding to this answer.\n */\nfunction DerivedHelper(mainHelper, fn) {\n  this.main = mainHelper;\n  this.fn = fn;\n  this.lastResults = null;\n}\n\ninherits(DerivedHelper, EventEmitter);\n\n/**\n * Detach this helper from the main helper\n * @return {undefined}\n * @throws Error if the derived helper is already detached\n */\nDerivedHelper.prototype.detach = function() {\n  this.removeAllListeners();\n  this.main.detachDerivedHelper(this);\n};\n\nDerivedHelper.prototype.getModifiedState = function(parameters) {\n  return this.fn(parameters);\n};\n\nmodule.exports = DerivedHelper;\n","'use strict';\n\n/**\n * Functions to manipulate refinement lists\n *\n * The RefinementList is not formally defined through a prototype but is based\n * on a specific structure.\n *\n * @module SearchParameters.refinementList\n *\n * @typedef {string[]} SearchParameters.refinementList.Refinements\n * @typedef {Object.<string, SearchParameters.refinementList.Refinements>} SearchParameters.refinementList.RefinementList\n */\n\nvar defaultsPure = require('../functions/defaultsPure');\nvar omit = require('../functions/omit');\nvar objectHasKeys = require('../functions/objectHasKeys');\n\nvar lib = {\n  /**\n   * Adds a refinement to a RefinementList\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} attribute the attribute to refine\n   * @param {string} value the value of the refinement, if the value is not a string it will be converted\n   * @return {RefinementList} a new and updated refinement list\n   */\n  addRefinement: function addRefinement(refinementList, attribute, value) {\n    if (lib.isRefined(refinementList, attribute, value)) {\n      return refinementList;\n    }\n\n    var valueAsString = '' + value;\n\n    var facetRefinement = !refinementList[attribute] ?\n      [valueAsString] :\n      refinementList[attribute].concat(valueAsString);\n\n    var mod = {};\n\n    mod[attribute] = facetRefinement;\n\n    return defaultsPure({}, mod, refinementList);\n  },\n  /**\n   * Removes refinement(s) for an attribute:\n   *  - if the value is specified removes the refinement for the value on the attribute\n   *  - if no value is specified removes all the refinements for this attribute\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} attribute the attribute to refine\n   * @param {string} [value] the value of the refinement\n   * @return {RefinementList} a new and updated refinement lst\n   */\n  removeRefinement: function removeRefinement(refinementList, attribute, value) {\n    if (value === undefined) {\n      // we use the \"filter\" form of clearRefinement, since it leaves empty values as-is\n      // the form with a string will remove the attribute completely\n      return lib.clearRefinement(refinementList, function(v, f) {\n        return attribute === f;\n      });\n    }\n\n    var valueAsString = '' + value;\n\n    return lib.clearRefinement(refinementList, function(v, f) {\n      return attribute === f && valueAsString === v;\n    });\n  },\n  /**\n   * Toggles the refinement value for an attribute.\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} attribute the attribute to refine\n   * @param {string} value the value of the refinement\n   * @return {RefinementList} a new and updated list\n   */\n  toggleRefinement: function toggleRefinement(refinementList, attribute, value) {\n    if (value === undefined) throw new Error('toggleRefinement should be used with a value');\n\n    if (lib.isRefined(refinementList, attribute, value)) {\n      return lib.removeRefinement(refinementList, attribute, value);\n    }\n\n    return lib.addRefinement(refinementList, attribute, value);\n  },\n  /**\n   * Clear all or parts of a RefinementList. Depending on the arguments, three\n   * kinds of behavior can happen:\n   *  - if no attribute is provided: clears the whole list\n   *  - if an attribute is provided as a string: clears the list for the specific attribute\n   *  - if an attribute is provided as a function: discards the elements for which the function returns true\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} [attribute] the attribute or function to discard\n   * @param {string} [refinementType] optional parameter to give more context to the attribute function\n   * @return {RefinementList} a new and updated refinement list\n   */\n  clearRefinement: function clearRefinement(refinementList, attribute, refinementType) {\n    if (attribute === undefined) {\n      if (!objectHasKeys(refinementList)) {\n        return refinementList;\n      }\n      return {};\n    } else if (typeof attribute === 'string') {\n      return omit(refinementList, [attribute]);\n    } else if (typeof attribute === 'function') {\n      var hasChanged = false;\n\n      var newRefinementList = Object.keys(refinementList).reduce(function(memo, key) {\n        var values = refinementList[key] || [];\n        var facetList = values.filter(function(value) {\n          return !attribute(value, key, refinementType);\n        });\n\n        if (facetList.length !== values.length) {\n          hasChanged = true;\n        }\n        memo[key] = facetList;\n\n        return memo;\n      }, {});\n\n      if (hasChanged) return newRefinementList;\n      return refinementList;\n    }\n  },\n  /**\n   * Test if the refinement value is used for the attribute. If no refinement value\n   * is provided, test if the refinementList contains any refinement for the\n   * given attribute.\n   * @param {RefinementList} refinementList the list of refinement\n   * @param {string} attribute name of the attribute\n   * @param {string} [refinementValue] value of the filter/refinement\n   * @return {boolean}\n   */\n  isRefined: function isRefined(refinementList, attribute, refinementValue) {\n    var containsRefinements = !!refinementList[attribute] &&\n      refinementList[attribute].length > 0;\n\n    if (refinementValue === undefined || !containsRefinements) {\n      return containsRefinements;\n    }\n\n    var refinementValueAsString = '' + refinementValue;\n\n    return refinementList[attribute].indexOf(refinementValueAsString) !== -1;\n  }\n};\n\nmodule.exports = lib;\n","'use strict';\n\nvar merge = require('../functions/merge');\nvar defaultsPure = require('../functions/defaultsPure');\nvar intersection = require('../functions/intersection');\nvar find = require('../functions/find');\nvar valToNumber = require('../functions/valToNumber');\nvar omit = require('../functions/omit');\nvar objectHasKeys = require('../functions/objectHasKeys');\nvar isValidUserToken = require('../utils/isValidUserToken');\n\nvar RefinementList = require('./RefinementList');\n\n/**\n * isEqual, but only for numeric refinement values, possible values:\n * - 5\n * - [5]\n * - [[5]]\n * - [[5,5],[4]]\n */\nfunction isEqualNumericRefinement(a, b) {\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return (\n      a.length === b.length &&\n      a.every(function(el, i) {\n        return isEqualNumericRefinement(b[i], el);\n      })\n    );\n  }\n  return a === b;\n}\n\n/**\n * like _.find but using deep equality to be able to use it\n * to find arrays.\n * @private\n * @param {any[]} array array to search into (elements are base or array of base)\n * @param {any} searchedValue the value we're looking for (base or array of base)\n * @return {any} the searched value or undefined\n */\nfunction findArray(array, searchedValue) {\n  return find(array, function(currentValue) {\n    return isEqualNumericRefinement(currentValue, searchedValue);\n  });\n}\n\n/**\n * The facet list is the structure used to store the list of values used to\n * filter a single attribute.\n * @typedef {string[]} SearchParameters.FacetList\n */\n\n/**\n * Structure to store numeric filters with the operator as the key. The supported operators\n * are `=`, `>`, `<`, `>=`, `<=` and `!=`.\n * @typedef {Object.<string, Array.<number|number[]>>} SearchParameters.OperatorList\n */\n\n/**\n * SearchParameters is the data structure that contains all the information\n * usable for making a search to Algolia API. It doesn't do the search itself,\n * nor does it contains logic about the parameters.\n * It is an immutable object, therefore it has been created in a way that each\n * changes does not change the object itself but returns a copy with the\n * modification.\n * This object should probably not be instantiated outside of the helper. It will\n * be provided when needed. This object is documented for reference as you'll\n * get it from events generated by the {@link AlgoliaSearchHelper}.\n * If need be, instantiate the Helper from the factory function {@link SearchParameters.make}\n * @constructor\n * @classdesc contains all the parameters of a search\n * @param {object|SearchParameters} newParameters existing parameters or partial object\n * for the properties of a new SearchParameters\n * @see SearchParameters.make\n * @example <caption>SearchParameters of the first query in\n *   <a href=\"http://demos.algolia.com/instant-search-demo/\">the instant search demo</a></caption>\n{\n   \"query\": \"\",\n   \"disjunctiveFacets\": [\n      \"customerReviewCount\",\n      \"category\",\n      \"salePrice_range\",\n      \"manufacturer\"\n  ],\n   \"maxValuesPerFacet\": 30,\n   \"page\": 0,\n   \"hitsPerPage\": 10,\n   \"facets\": [\n      \"type\",\n      \"shipping\"\n  ]\n}\n */\nfunction SearchParameters(newParameters) {\n  var params = newParameters ? SearchParameters._parseNumbers(newParameters) : {};\n\n  if (params.userToken !== undefined && !isValidUserToken(params.userToken)) {\n    console.warn('[algoliasearch-helper] The `userToken` parameter is invalid. This can lead to wrong analytics.\\n  - Format: [a-zA-Z0-9_-]{1,64}');\n  }\n  /**\n   * This attribute contains the list of all the conjunctive facets\n   * used. This list will be added to requested facets in the\n   * [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.\n   * @member {string[]}\n   */\n  this.facets = params.facets || [];\n  /**\n   * This attribute contains the list of all the disjunctive facets\n   * used. This list will be added to requested facets in the\n   * [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.\n   * @member {string[]}\n   */\n  this.disjunctiveFacets = params.disjunctiveFacets || [];\n  /**\n   * This attribute contains the list of all the hierarchical facets\n   * used. This list will be added to requested facets in the\n   * [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.\n   * Hierarchical facets are a sub type of disjunctive facets that\n   * let you filter faceted attributes hierarchically.\n   * @member {string[]|object[]}\n   */\n  this.hierarchicalFacets = params.hierarchicalFacets || [];\n\n  // Refinements\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the conjunctive facets. Each facet must be properly\n   * defined in the `facets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters selected for the associated facet name.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n  this.facetsRefinements = params.facetsRefinements || {};\n  /**\n   * This attribute contains all the filters that need to be\n   * excluded from the conjunctive facets. Each facet must be properly\n   * defined in the `facets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters excluded for the associated facet name.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n  this.facetsExcludes = params.facetsExcludes || {};\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the disjunctive facets. Each facet must be properly\n   * defined in the `disjunctiveFacets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters selected for the associated facet name.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n  this.disjunctiveFacetsRefinements = params.disjunctiveFacetsRefinements || {};\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the numeric attributes.\n   *\n   * The key is the name of the attribute, and the value is the\n   * filters to apply to this attribute.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `numericFilters` attribute.\n   * @member {Object.<string, SearchParameters.OperatorList>}\n   */\n  this.numericRefinements = params.numericRefinements || {};\n  /**\n   * This attribute contains all the tags used to refine the query.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `tagFilters` attribute.\n   * @member {string[]}\n   */\n  this.tagRefinements = params.tagRefinements || [];\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the hierarchical facets. Each facet must be properly\n   * defined in the `hierarchicalFacets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters selected for the associated facet name. The FacetList values\n   * are structured as a string that contain the values for each level\n   * separated by the configured separator.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n  this.hierarchicalFacetsRefinements = params.hierarchicalFacetsRefinements || {};\n\n  var self = this;\n  Object.keys(params).forEach(function(paramName) {\n    var isKeyKnown = SearchParameters.PARAMETERS.indexOf(paramName) !== -1;\n    var isValueDefined = params[paramName] !== undefined;\n\n    if (!isKeyKnown && isValueDefined) {\n      self[paramName] = params[paramName];\n    }\n  });\n}\n\n/**\n * List all the properties in SearchParameters and therefore all the known Algolia properties\n * This doesn't contain any beta/hidden features.\n * @private\n */\nSearchParameters.PARAMETERS = Object.keys(new SearchParameters());\n\n/**\n * @private\n * @param {object} partialState full or part of a state\n * @return {object} a new object with the number keys as number\n */\nSearchParameters._parseNumbers = function(partialState) {\n  // Do not reparse numbers in SearchParameters, they ought to be parsed already\n  if (partialState instanceof SearchParameters) return partialState;\n\n  var numbers = {};\n\n  var numberKeys = [\n    'aroundPrecision',\n    'aroundRadius',\n    'getRankingInfo',\n    'minWordSizefor2Typos',\n    'minWordSizefor1Typo',\n    'page',\n    'maxValuesPerFacet',\n    'distinct',\n    'minimumAroundRadius',\n    'hitsPerPage',\n    'minProximity'\n  ];\n\n  numberKeys.forEach(function(k) {\n    var value = partialState[k];\n    if (typeof value === 'string') {\n      var parsedValue = parseFloat(value);\n      // global isNaN is ok to use here, value is only number or NaN\n      numbers[k] = isNaN(parsedValue) ? value : parsedValue;\n    }\n  });\n\n  // there's two formats of insideBoundingBox, we need to parse\n  // the one which is an array of float geo rectangles\n  if (Array.isArray(partialState.insideBoundingBox)) {\n    numbers.insideBoundingBox = partialState.insideBoundingBox.map(function(geoRect) {\n      if (Array.isArray(geoRect)) {\n        return geoRect.map(function(value) {\n          return parseFloat(value);\n        });\n      }\n      return geoRect;\n    });\n  }\n\n  if (partialState.numericRefinements) {\n    var numericRefinements = {};\n    Object.keys(partialState.numericRefinements).forEach(function(attribute) {\n      var operators = partialState.numericRefinements[attribute] || {};\n      numericRefinements[attribute] = {};\n      Object.keys(operators).forEach(function(operator) {\n        var values = operators[operator];\n        var parsedValues = values.map(function(v) {\n          if (Array.isArray(v)) {\n            return v.map(function(vPrime) {\n              if (typeof vPrime === 'string') {\n                return parseFloat(vPrime);\n              }\n              return vPrime;\n            });\n          } else if (typeof v === 'string') {\n            return parseFloat(v);\n          }\n          return v;\n        });\n        numericRefinements[attribute][operator] = parsedValues;\n      });\n    });\n    numbers.numericRefinements = numericRefinements;\n  }\n\n  return merge({}, partialState, numbers);\n};\n\n/**\n * Factory for SearchParameters\n * @param {object|SearchParameters} newParameters existing parameters or partial\n * object for the properties of a new SearchParameters\n * @return {SearchParameters} frozen instance of SearchParameters\n */\nSearchParameters.make = function makeSearchParameters(newParameters) {\n  var instance = new SearchParameters(newParameters);\n\n  var hierarchicalFacets = newParameters.hierarchicalFacets || [];\n  hierarchicalFacets.forEach(function(facet) {\n    if (facet.rootPath) {\n      var currentRefinement = instance.getHierarchicalRefinement(facet.name);\n\n      if (currentRefinement.length > 0 && currentRefinement[0].indexOf(facet.rootPath) !== 0) {\n        instance = instance.clearRefinements(facet.name);\n      }\n\n      // get it again in case it has been cleared\n      currentRefinement = instance.getHierarchicalRefinement(facet.name);\n      if (currentRefinement.length === 0) {\n        instance = instance.toggleHierarchicalFacetRefinement(facet.name, facet.rootPath);\n      }\n    }\n  });\n\n  return instance;\n};\n\n/**\n * Validates the new parameters based on the previous state\n * @param {SearchParameters} currentState the current state\n * @param {object|SearchParameters} parameters the new parameters to set\n * @return {Error|null} Error if the modification is invalid, null otherwise\n */\nSearchParameters.validate = function(currentState, parameters) {\n  var params = parameters || {};\n\n  if (currentState.tagFilters && params.tagRefinements && params.tagRefinements.length > 0) {\n    return new Error(\n      '[Tags] Cannot switch from the managed tag API to the advanced API. It is probably ' +\n      'an error, if it is really what you want, you should first clear the tags with clearTags method.');\n  }\n\n  if (currentState.tagRefinements.length > 0 && params.tagFilters) {\n    return new Error(\n      '[Tags] Cannot switch from the advanced tag API to the managed API. It is probably ' +\n      'an error, if it is not, you should first clear the tags with clearTags method.');\n  }\n\n  if (\n    currentState.numericFilters &&\n    params.numericRefinements &&\n    objectHasKeys(params.numericRefinements)\n  ) {\n    return new Error(\n      \"[Numeric filters] Can't switch from the advanced to the managed API. It\" +\n        ' is probably an error, if this is really what you want, you have to first' +\n        ' clear the numeric filters.'\n    );\n  }\n\n  if (objectHasKeys(currentState.numericRefinements) && params.numericFilters) {\n    return new Error(\n      \"[Numeric filters] Can't switch from the managed API to the advanced. It\" +\n      ' is probably an error, if this is really what you want, you have to first' +\n      ' clear the numeric filters.');\n  }\n\n  return null;\n};\n\nSearchParameters.prototype = {\n  constructor: SearchParameters,\n\n  /**\n   * Remove all refinements (disjunctive + conjunctive + excludes + numeric filters)\n   * @method\n   * @param {undefined|string|SearchParameters.clearCallback} [attribute] optional string or function\n   * - If not given, means to clear all the filters.\n   * - If `string`, means to clear all refinements for the `attribute` named filter.\n   * - If `function`, means to clear all the refinements that return truthy values.\n   * @return {SearchParameters}\n   */\n  clearRefinements: function clearRefinements(attribute) {\n    var patch = {\n      numericRefinements: this._clearNumericRefinements(attribute),\n      facetsRefinements: RefinementList.clearRefinement(\n        this.facetsRefinements,\n        attribute,\n        'conjunctiveFacet'\n      ),\n      facetsExcludes: RefinementList.clearRefinement(\n        this.facetsExcludes,\n        attribute,\n        'exclude'\n      ),\n      disjunctiveFacetsRefinements: RefinementList.clearRefinement(\n        this.disjunctiveFacetsRefinements,\n        attribute,\n        'disjunctiveFacet'\n      ),\n      hierarchicalFacetsRefinements: RefinementList.clearRefinement(\n        this.hierarchicalFacetsRefinements,\n        attribute,\n        'hierarchicalFacet'\n      )\n    };\n    if (\n      patch.numericRefinements === this.numericRefinements &&\n      patch.facetsRefinements === this.facetsRefinements &&\n      patch.facetsExcludes === this.facetsExcludes &&\n      patch.disjunctiveFacetsRefinements === this.disjunctiveFacetsRefinements &&\n      patch.hierarchicalFacetsRefinements === this.hierarchicalFacetsRefinements\n    ) {\n      return this;\n    }\n    return this.setQueryParameters(patch);\n  },\n  /**\n   * Remove all the refined tags from the SearchParameters\n   * @method\n   * @return {SearchParameters}\n   */\n  clearTags: function clearTags() {\n    if (this.tagFilters === undefined && this.tagRefinements.length === 0) return this;\n\n    return this.setQueryParameters({\n      tagFilters: undefined,\n      tagRefinements: []\n    });\n  },\n  /**\n   * Set the index.\n   * @method\n   * @param {string} index the index name\n   * @return {SearchParameters}\n   */\n  setIndex: function setIndex(index) {\n    if (index === this.index) return this;\n\n    return this.setQueryParameters({\n      index: index\n    });\n  },\n  /**\n   * Query setter\n   * @method\n   * @param {string} newQuery value for the new query\n   * @return {SearchParameters}\n   */\n  setQuery: function setQuery(newQuery) {\n    if (newQuery === this.query) return this;\n\n    return this.setQueryParameters({\n      query: newQuery\n    });\n  },\n  /**\n   * Page setter\n   * @method\n   * @param {number} newPage new page number\n   * @return {SearchParameters}\n   */\n  setPage: function setPage(newPage) {\n    if (newPage === this.page) return this;\n\n    return this.setQueryParameters({\n      page: newPage\n    });\n  },\n  /**\n   * Facets setter\n   * The facets are the simple facets, used for conjunctive (and) faceting.\n   * @method\n   * @param {string[]} facets all the attributes of the algolia records used for conjunctive faceting\n   * @return {SearchParameters}\n   */\n  setFacets: function setFacets(facets) {\n    return this.setQueryParameters({\n      facets: facets\n    });\n  },\n  /**\n   * Disjunctive facets setter\n   * Change the list of disjunctive (or) facets the helper chan handle.\n   * @method\n   * @param {string[]} facets all the attributes of the algolia records used for disjunctive faceting\n   * @return {SearchParameters}\n   */\n  setDisjunctiveFacets: function setDisjunctiveFacets(facets) {\n    return this.setQueryParameters({\n      disjunctiveFacets: facets\n    });\n  },\n  /**\n   * HitsPerPage setter\n   * Hits per page represents the number of hits retrieved for this query\n   * @method\n   * @param {number} n number of hits retrieved per page of results\n   * @return {SearchParameters}\n   */\n  setHitsPerPage: function setHitsPerPage(n) {\n    if (this.hitsPerPage === n) return this;\n\n    return this.setQueryParameters({\n      hitsPerPage: n\n    });\n  },\n  /**\n   * typoTolerance setter\n   * Set the value of typoTolerance\n   * @method\n   * @param {string} typoTolerance new value of typoTolerance (\"true\", \"false\", \"min\" or \"strict\")\n   * @return {SearchParameters}\n   */\n  setTypoTolerance: function setTypoTolerance(typoTolerance) {\n    if (this.typoTolerance === typoTolerance) return this;\n\n    return this.setQueryParameters({\n      typoTolerance: typoTolerance\n    });\n  },\n  /**\n   * Add a numeric filter for a given attribute\n   * When value is an array, they are combined with OR\n   * When value is a single value, it will combined with AND\n   * @method\n   * @param {string} attribute attribute to set the filter on\n   * @param {string} operator operator of the filter (possible values: =, >, >=, <, <=, !=)\n   * @param {number | number[]} value value of the filter\n   * @return {SearchParameters}\n   * @example\n   * // for price = 50 or 40\n   * searchparameter.addNumericRefinement('price', '=', [50, 40]);\n   * @example\n   * // for size = 38 and 40\n   * searchparameter.addNumericRefinement('size', '=', 38);\n   * searchparameter.addNumericRefinement('size', '=', 40);\n   */\n  addNumericRefinement: function(attribute, operator, v) {\n    var value = valToNumber(v);\n\n    if (this.isNumericRefined(attribute, operator, value)) return this;\n\n    var mod = merge({}, this.numericRefinements);\n\n    mod[attribute] = merge({}, mod[attribute]);\n\n    if (mod[attribute][operator]) {\n      // Array copy\n      mod[attribute][operator] = mod[attribute][operator].slice();\n      // Add the element. Concat can't be used here because value can be an array.\n      mod[attribute][operator].push(value);\n    } else {\n      mod[attribute][operator] = [value];\n    }\n\n    return this.setQueryParameters({\n      numericRefinements: mod\n    });\n  },\n  /**\n   * Get the list of conjunctive refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getConjunctiveRefinements: function(facetName) {\n    if (!this.isConjunctiveFacet(facetName)) {\n      return [];\n    }\n    return this.facetsRefinements[facetName] || [];\n  },\n  /**\n   * Get the list of disjunctive refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getDisjunctiveRefinements: function(facetName) {\n    if (!this.isDisjunctiveFacet(facetName)) {\n      return [];\n    }\n    return this.disjunctiveFacetsRefinements[facetName] || [];\n  },\n  /**\n   * Get the list of hierarchical refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getHierarchicalRefinement: function(facetName) {\n    // we send an array but we currently do not support multiple\n    // hierarchicalRefinements for a hierarchicalFacet\n    return this.hierarchicalFacetsRefinements[facetName] || [];\n  },\n  /**\n   * Get the list of exclude refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getExcludeRefinements: function(facetName) {\n    if (!this.isConjunctiveFacet(facetName)) {\n      return [];\n    }\n    return this.facetsExcludes[facetName] || [];\n  },\n\n  /**\n   * Remove all the numeric filter for a given (attribute, operator)\n   * @method\n   * @param {string} attribute attribute to set the filter on\n   * @param {string} [operator] operator of the filter (possible values: =, >, >=, <, <=, !=)\n   * @param {number} [number] the value to be removed\n   * @return {SearchParameters}\n   */\n  removeNumericRefinement: function(attribute, operator, paramValue) {\n    if (paramValue !== undefined) {\n      if (!this.isNumericRefined(attribute, operator, paramValue)) {\n        return this;\n      }\n      return this.setQueryParameters({\n        numericRefinements: this._clearNumericRefinements(function(value, key) {\n          return (\n            key === attribute &&\n            value.op === operator &&\n            isEqualNumericRefinement(value.val, valToNumber(paramValue))\n          );\n        })\n      });\n    } else if (operator !== undefined) {\n      if (!this.isNumericRefined(attribute, operator)) return this;\n      return this.setQueryParameters({\n        numericRefinements: this._clearNumericRefinements(function(value, key) {\n          return key === attribute && value.op === operator;\n        })\n      });\n    }\n\n    if (!this.isNumericRefined(attribute)) return this;\n    return this.setQueryParameters({\n      numericRefinements: this._clearNumericRefinements(function(value, key) {\n        return key === attribute;\n      })\n    });\n  },\n  /**\n   * Get the list of numeric refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {SearchParameters.OperatorList} list of refinements\n   */\n  getNumericRefinements: function(facetName) {\n    return this.numericRefinements[facetName] || {};\n  },\n  /**\n   * Return the current refinement for the (attribute, operator)\n   * @param {string} attribute attribute in the record\n   * @param {string} operator operator applied on the refined values\n   * @return {Array.<number|number[]>} refined values\n   */\n  getNumericRefinement: function(attribute, operator) {\n    return this.numericRefinements[attribute] && this.numericRefinements[attribute][operator];\n  },\n  /**\n   * Clear numeric filters.\n   * @method\n   * @private\n   * @param {string|SearchParameters.clearCallback} [attribute] optional string or function\n   * - If not given, means to clear all the filters.\n   * - If `string`, means to clear all refinements for the `attribute` named filter.\n   * - If `function`, means to clear all the refinements that return truthy values.\n   * @return {Object.<string, OperatorList>}\n   */\n  _clearNumericRefinements: function _clearNumericRefinements(attribute) {\n    if (attribute === undefined) {\n      if (!objectHasKeys(this.numericRefinements)) {\n        return this.numericRefinements;\n      }\n      return {};\n    } else if (typeof attribute === 'string') {\n      return omit(this.numericRefinements, [attribute]);\n    } else if (typeof attribute === 'function') {\n      var hasChanged = false;\n      var numericRefinements = this.numericRefinements;\n      var newNumericRefinements = Object.keys(numericRefinements).reduce(function(memo, key) {\n        var operators = numericRefinements[key];\n        var operatorList = {};\n\n        operators = operators || {};\n        Object.keys(operators).forEach(function(operator) {\n          var values = operators[operator] || [];\n          var outValues = [];\n          values.forEach(function(value) {\n            var predicateResult = attribute({val: value, op: operator}, key, 'numeric');\n            if (!predicateResult) outValues.push(value);\n          });\n          if (outValues.length !== values.length) {\n            hasChanged = true;\n          }\n          operatorList[operator] = outValues;\n        });\n\n        memo[key] = operatorList;\n\n        return memo;\n      }, {});\n\n      if (hasChanged) return newNumericRefinements;\n      return this.numericRefinements;\n    }\n  },\n  /**\n   * Add a facet to the facets attribute of the helper configuration, if it\n   * isn't already present.\n   * @method\n   * @param {string} facet facet name to add\n   * @return {SearchParameters}\n   */\n  addFacet: function addFacet(facet) {\n    if (this.isConjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.setQueryParameters({\n      facets: this.facets.concat([facet])\n    });\n  },\n  /**\n   * Add a disjunctive facet to the disjunctiveFacets attribute of the helper\n   * configuration, if it isn't already present.\n   * @method\n   * @param {string} facet disjunctive facet name to add\n   * @return {SearchParameters}\n   */\n  addDisjunctiveFacet: function addDisjunctiveFacet(facet) {\n    if (this.isDisjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.setQueryParameters({\n      disjunctiveFacets: this.disjunctiveFacets.concat([facet])\n    });\n  },\n  /**\n   * Add a hierarchical facet to the hierarchicalFacets attribute of the helper\n   * configuration.\n   * @method\n   * @param {object} hierarchicalFacet hierarchical facet to add\n   * @return {SearchParameters}\n   * @throws will throw an error if a hierarchical facet with the same name was already declared\n   */\n  addHierarchicalFacet: function addHierarchicalFacet(hierarchicalFacet) {\n    if (this.isHierarchicalFacet(hierarchicalFacet.name)) {\n      throw new Error(\n        'Cannot declare two hierarchical facets with the same name: `' + hierarchicalFacet.name + '`');\n    }\n\n    return this.setQueryParameters({\n      hierarchicalFacets: this.hierarchicalFacets.concat([hierarchicalFacet])\n    });\n  },\n  /**\n   * Add a refinement on a \"normal\" facet\n   * @method\n   * @param {string} facet attribute to apply the faceting on\n   * @param {string} value value of the attribute (will be converted to string)\n   * @return {SearchParameters}\n   */\n  addFacetRefinement: function addFacetRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n    if (RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;\n\n    return this.setQueryParameters({\n      facetsRefinements: RefinementList.addRefinement(this.facetsRefinements, facet, value)\n    });\n  },\n  /**\n   * Exclude a value from a \"normal\" facet\n   * @method\n   * @param {string} facet attribute to apply the exclusion on\n   * @param {string} value value of the attribute (will be converted to string)\n   * @return {SearchParameters}\n   */\n  addExcludeRefinement: function addExcludeRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n    if (RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;\n\n    return this.setQueryParameters({\n      facetsExcludes: RefinementList.addRefinement(this.facetsExcludes, facet, value)\n    });\n  },\n  /**\n   * Adds a refinement on a disjunctive facet.\n   * @method\n   * @param {string} facet attribute to apply the faceting on\n   * @param {string} value value of the attribute (will be converted to string)\n   * @return {SearchParameters}\n   */\n  addDisjunctiveFacetRefinement: function addDisjunctiveFacetRefinement(facet, value) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      throw new Error(\n        facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');\n    }\n\n    if (RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;\n\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.addRefinement(\n        this.disjunctiveFacetsRefinements, facet, value)\n    });\n  },\n  /**\n   * addTagRefinement adds a tag to the list used to filter the results\n   * @param {string} tag tag to be added\n   * @return {SearchParameters}\n   */\n  addTagRefinement: function addTagRefinement(tag) {\n    if (this.isTagRefined(tag)) return this;\n\n    var modification = {\n      tagRefinements: this.tagRefinements.concat(tag)\n    };\n\n    return this.setQueryParameters(modification);\n  },\n  /**\n   * Remove a facet from the facets attribute of the helper configuration, if it\n   * is present.\n   * @method\n   * @param {string} facet facet name to remove\n   * @return {SearchParameters}\n   */\n  removeFacet: function removeFacet(facet) {\n    if (!this.isConjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.clearRefinements(facet).setQueryParameters({\n      facets: this.facets.filter(function(f) {\n        return f !== facet;\n      })\n    });\n  },\n  /**\n   * Remove a disjunctive facet from the disjunctiveFacets attribute of the\n   * helper configuration, if it is present.\n   * @method\n   * @param {string} facet disjunctive facet name to remove\n   * @return {SearchParameters}\n   */\n  removeDisjunctiveFacet: function removeDisjunctiveFacet(facet) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.clearRefinements(facet).setQueryParameters({\n      disjunctiveFacets: this.disjunctiveFacets.filter(function(f) {\n        return f !== facet;\n      })\n    });\n  },\n  /**\n   * Remove a hierarchical facet from the hierarchicalFacets attribute of the\n   * helper configuration, if it is present.\n   * @method\n   * @param {string} facet hierarchical facet name to remove\n   * @return {SearchParameters}\n   */\n  removeHierarchicalFacet: function removeHierarchicalFacet(facet) {\n    if (!this.isHierarchicalFacet(facet)) {\n      return this;\n    }\n\n    return this.clearRefinements(facet).setQueryParameters({\n      hierarchicalFacets: this.hierarchicalFacets.filter(function(f) {\n        return f.name !== facet;\n      })\n    });\n  },\n  /**\n   * Remove a refinement set on facet. If a value is provided, it will clear the\n   * refinement for the given value, otherwise it will clear all the refinement\n   * values for the faceted attribute.\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {string} [value] value used to filter\n   * @return {SearchParameters}\n   */\n  removeFacetRefinement: function removeFacetRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n    if (!RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;\n\n    return this.setQueryParameters({\n      facetsRefinements: RefinementList.removeRefinement(this.facetsRefinements, facet, value)\n    });\n  },\n  /**\n   * Remove a negative refinement on a facet\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {string} value value used to filter\n   * @return {SearchParameters}\n   */\n  removeExcludeRefinement: function removeExcludeRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n    if (!RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;\n\n    return this.setQueryParameters({\n      facetsExcludes: RefinementList.removeRefinement(this.facetsExcludes, facet, value)\n    });\n  },\n  /**\n   * Remove a refinement on a disjunctive facet\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {string} value value used to filter\n   * @return {SearchParameters}\n   */\n  removeDisjunctiveFacetRefinement: function removeDisjunctiveFacetRefinement(facet, value) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      throw new Error(\n        facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');\n    }\n    if (!RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;\n\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.removeRefinement(\n        this.disjunctiveFacetsRefinements, facet, value)\n    });\n  },\n  /**\n   * Remove a tag from the list of tag refinements\n   * @method\n   * @param {string} tag the tag to remove\n   * @return {SearchParameters}\n   */\n  removeTagRefinement: function removeTagRefinement(tag) {\n    if (!this.isTagRefined(tag)) return this;\n\n    var modification = {\n      tagRefinements: this.tagRefinements.filter(function(t) {\n        return t !== tag;\n      })\n    };\n\n    return this.setQueryParameters(modification);\n  },\n  /**\n   * Generic toggle refinement method to use with facet, disjunctive facets\n   * and hierarchical facets\n   * @param  {string} facet the facet to refine\n   * @param  {string} value the associated value\n   * @return {SearchParameters}\n   * @throws will throw an error if the facet is not declared in the settings of the helper\n   * @deprecated since version 2.19.0, see {@link SearchParameters#toggleFacetRefinement}\n   */\n  toggleRefinement: function toggleRefinement(facet, value) {\n    return this.toggleFacetRefinement(facet, value);\n  },\n  /**\n   * Generic toggle refinement method to use with facet, disjunctive facets\n   * and hierarchical facets\n   * @param  {string} facet the facet to refine\n   * @param  {string} value the associated value\n   * @return {SearchParameters}\n   * @throws will throw an error if the facet is not declared in the settings of the helper\n   */\n  toggleFacetRefinement: function toggleFacetRefinement(facet, value) {\n    if (this.isHierarchicalFacet(facet)) {\n      return this.toggleHierarchicalFacetRefinement(facet, value);\n    } else if (this.isConjunctiveFacet(facet)) {\n      return this.toggleConjunctiveFacetRefinement(facet, value);\n    } else if (this.isDisjunctiveFacet(facet)) {\n      return this.toggleDisjunctiveFacetRefinement(facet, value);\n    }\n\n    throw new Error('Cannot refine the undeclared facet ' + facet +\n      '; it should be added to the helper options facets, disjunctiveFacets or hierarchicalFacets');\n  },\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters}\n   */\n  toggleConjunctiveFacetRefinement: function toggleConjunctiveFacetRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n\n    return this.setQueryParameters({\n      facetsRefinements: RefinementList.toggleRefinement(this.facetsRefinements, facet, value)\n    });\n  },\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters}\n   */\n  toggleExcludeFacetRefinement: function toggleExcludeFacetRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n\n    return this.setQueryParameters({\n      facetsExcludes: RefinementList.toggleRefinement(this.facetsExcludes, facet, value)\n    });\n  },\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters}\n   */\n  toggleDisjunctiveFacetRefinement: function toggleDisjunctiveFacetRefinement(facet, value) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      throw new Error(\n        facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');\n    }\n\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.toggleRefinement(\n        this.disjunctiveFacetsRefinements, facet, value)\n    });\n  },\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters}\n   */\n  toggleHierarchicalFacetRefinement: function toggleHierarchicalFacetRefinement(facet, value) {\n    if (!this.isHierarchicalFacet(facet)) {\n      throw new Error(\n        facet + ' is not defined in the hierarchicalFacets attribute of the helper configuration');\n    }\n\n    var separator = this._getHierarchicalFacetSeparator(this.getHierarchicalFacetByName(facet));\n\n    var mod = {};\n\n    var upOneOrMultipleLevel = this.hierarchicalFacetsRefinements[facet] !== undefined &&\n      this.hierarchicalFacetsRefinements[facet].length > 0 && (\n      // remove current refinement:\n      // refinement was 'beer > IPA', call is toggleRefine('beer > IPA'), refinement should be `beer`\n      this.hierarchicalFacetsRefinements[facet][0] === value ||\n      // remove a parent refinement of the current refinement:\n      //  - refinement was 'beer > IPA > Flying dog'\n      //  - call is toggleRefine('beer > IPA')\n      //  - refinement should be `beer`\n      this.hierarchicalFacetsRefinements[facet][0].indexOf(value + separator) === 0\n    );\n\n    if (upOneOrMultipleLevel) {\n      if (value.indexOf(separator) === -1) {\n        // go back to root level\n        mod[facet] = [];\n      } else {\n        mod[facet] = [value.slice(0, value.lastIndexOf(separator))];\n      }\n    } else {\n      mod[facet] = [value];\n    }\n\n    return this.setQueryParameters({\n      hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)\n    });\n  },\n\n  /**\n   * Adds a refinement on a hierarchical facet.\n   * @param {string} facet the facet name\n   * @param {string} path the hierarchical facet path\n   * @return {SearchParameter} the new state\n   * @throws Error if the facet is not defined or if the facet is refined\n   */\n  addHierarchicalFacetRefinement: function(facet, path) {\n    if (this.isHierarchicalFacetRefined(facet)) {\n      throw new Error(facet + ' is already refined.');\n    }\n    if (!this.isHierarchicalFacet(facet)) {\n      throw new Error(facet + ' is not defined in the hierarchicalFacets attribute of the helper configuration.');\n    }\n    var mod = {};\n    mod[facet] = [path];\n    return this.setQueryParameters({\n      hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)\n    });\n  },\n\n  /**\n   * Removes the refinement set on a hierarchical facet.\n   * @param {string} facet the facet name\n   * @return {SearchParameter} the new state\n   * @throws Error if the facet is not defined or if the facet is not refined\n   */\n  removeHierarchicalFacetRefinement: function(facet) {\n    if (!this.isHierarchicalFacetRefined(facet)) {\n      return this;\n    }\n    var mod = {};\n    mod[facet] = [];\n    return this.setQueryParameters({\n      hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)\n    });\n  },\n  /**\n   * Switch the tag refinement\n   * @method\n   * @param {string} tag the tag to remove or add\n   * @return {SearchParameters}\n   */\n  toggleTagRefinement: function toggleTagRefinement(tag) {\n    if (this.isTagRefined(tag)) {\n      return this.removeTagRefinement(tag);\n    }\n\n    return this.addTagRefinement(tag);\n  },\n  /**\n   * Test if the facet name is from one of the disjunctive facets\n   * @method\n   * @param {string} facet facet name to test\n   * @return {boolean}\n   */\n  isDisjunctiveFacet: function(facet) {\n    return this.disjunctiveFacets.indexOf(facet) > -1;\n  },\n  /**\n   * Test if the facet name is from one of the hierarchical facets\n   * @method\n   * @param {string} facetName facet name to test\n   * @return {boolean}\n   */\n  isHierarchicalFacet: function(facetName) {\n    return this.getHierarchicalFacetByName(facetName) !== undefined;\n  },\n  /**\n   * Test if the facet name is from one of the conjunctive/normal facets\n   * @method\n   * @param {string} facet facet name to test\n   * @return {boolean}\n   */\n  isConjunctiveFacet: function(facet) {\n    return this.facets.indexOf(facet) > -1;\n  },\n  /**\n   * Returns true if the facet is refined, either for a specific value or in\n   * general.\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} value, optional value. If passed will test that this value\n   * is filtering the given facet.\n   * @return {boolean} returns true if refined\n   */\n  isFacetRefined: function isFacetRefined(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      return false;\n    }\n    return RefinementList.isRefined(this.facetsRefinements, facet, value);\n  },\n  /**\n   * Returns true if the facet contains exclusions or if a specific value is\n   * excluded.\n   *\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} [value] optional value. If passed will test that this value\n   * is filtering the given facet.\n   * @return {boolean} returns true if refined\n   */\n  isExcludeRefined: function isExcludeRefined(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      return false;\n    }\n    return RefinementList.isRefined(this.facetsExcludes, facet, value);\n  },\n  /**\n   * Returns true if the facet contains a refinement, or if a value passed is a\n   * refinement for the facet.\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} value optional, will test if the value is used for refinement\n   * if there is one, otherwise will test if the facet contains any refinement\n   * @return {boolean}\n   */\n  isDisjunctiveFacetRefined: function isDisjunctiveFacetRefined(facet, value) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      return false;\n    }\n    return RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value);\n  },\n  /**\n   * Returns true if the facet contains a refinement, or if a value passed is a\n   * refinement for the facet.\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} value optional, will test if the value is used for refinement\n   * if there is one, otherwise will test if the facet contains any refinement\n   * @return {boolean}\n   */\n  isHierarchicalFacetRefined: function isHierarchicalFacetRefined(facet, value) {\n    if (!this.isHierarchicalFacet(facet)) {\n      return false;\n    }\n\n    var refinements = this.getHierarchicalRefinement(facet);\n\n    if (!value) {\n      return refinements.length > 0;\n    }\n\n    return refinements.indexOf(value) !== -1;\n  },\n  /**\n   * Test if the triple (attribute, operator, value) is already refined.\n   * If only the attribute and the operator are provided, it tests if the\n   * contains any refinement value.\n   * @method\n   * @param {string} attribute attribute for which the refinement is applied\n   * @param {string} [operator] operator of the refinement\n   * @param {string} [value] value of the refinement\n   * @return {boolean} true if it is refined\n   */\n  isNumericRefined: function isNumericRefined(attribute, operator, value) {\n    if (value === undefined && operator === undefined) {\n      return !!this.numericRefinements[attribute];\n    }\n\n    var isOperatorDefined =\n      this.numericRefinements[attribute] &&\n      this.numericRefinements[attribute][operator] !== undefined;\n\n    if (value === undefined || !isOperatorDefined) {\n      return isOperatorDefined;\n    }\n\n    var parsedValue = valToNumber(value);\n    var isAttributeValueDefined =\n      findArray(this.numericRefinements[attribute][operator], parsedValue) !==\n      undefined;\n\n    return isOperatorDefined && isAttributeValueDefined;\n  },\n  /**\n   * Returns true if the tag refined, false otherwise\n   * @method\n   * @param {string} tag the tag to check\n   * @return {boolean}\n   */\n  isTagRefined: function isTagRefined(tag) {\n    return this.tagRefinements.indexOf(tag) !== -1;\n  },\n  /**\n   * Returns the list of all disjunctive facets refined\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {string[]}\n   */\n  getRefinedDisjunctiveFacets: function getRefinedDisjunctiveFacets() {\n    var self = this;\n\n    // attributes used for numeric filter can also be disjunctive\n    var disjunctiveNumericRefinedFacets = intersection(\n      Object.keys(this.numericRefinements).filter(function(facet) {\n        return Object.keys(self.numericRefinements[facet]).length > 0;\n      }),\n      this.disjunctiveFacets\n    );\n\n    return Object.keys(this.disjunctiveFacetsRefinements).filter(function(facet) {\n      return self.disjunctiveFacetsRefinements[facet].length > 0;\n    })\n      .concat(disjunctiveNumericRefinedFacets)\n      .concat(this.getRefinedHierarchicalFacets());\n  },\n  /**\n   * Returns the list of all disjunctive facets refined\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {string[]}\n   */\n  getRefinedHierarchicalFacets: function getRefinedHierarchicalFacets() {\n    var self = this;\n    return intersection(\n      // enforce the order between the two arrays,\n      // so that refinement name index === hierarchical facet index\n      this.hierarchicalFacets.map(function(facet) { return facet.name; }),\n      Object.keys(this.hierarchicalFacetsRefinements).filter(function(facet) {\n        return self.hierarchicalFacetsRefinements[facet].length > 0;\n      })\n    );\n  },\n  /**\n   * Returned the list of all disjunctive facets not refined\n   * @method\n   * @return {string[]}\n   */\n  getUnrefinedDisjunctiveFacets: function() {\n    var refinedFacets = this.getRefinedDisjunctiveFacets();\n\n    return this.disjunctiveFacets.filter(function(f) {\n      return refinedFacets.indexOf(f) === -1;\n    });\n  },\n\n  managedParameters: [\n    'index',\n\n    'facets',\n    'disjunctiveFacets',\n    'facetsRefinements',\n    'hierarchicalFacets',\n    'facetsExcludes',\n\n    'disjunctiveFacetsRefinements',\n    'numericRefinements',\n    'tagRefinements',\n    'hierarchicalFacetsRefinements'\n  ],\n  getQueryParams: function getQueryParams() {\n    var managedParameters = this.managedParameters;\n\n    var queryParams = {};\n\n    var self = this;\n    Object.keys(this).forEach(function(paramName) {\n      var paramValue = self[paramName];\n      if (managedParameters.indexOf(paramName) === -1 && paramValue !== undefined) {\n        queryParams[paramName] = paramValue;\n      }\n    });\n\n    return queryParams;\n  },\n  /**\n   * Let the user set a specific value for a given parameter. Will return the\n   * same instance if the parameter is invalid or if the value is the same as the\n   * previous one.\n   * @method\n   * @param {string} parameter the parameter name\n   * @param {any} value the value to be set, must be compliant with the definition\n   * of the attribute on the object\n   * @return {SearchParameters} the updated state\n   */\n  setQueryParameter: function setParameter(parameter, value) {\n    if (this[parameter] === value) return this;\n\n    var modification = {};\n\n    modification[parameter] = value;\n\n    return this.setQueryParameters(modification);\n  },\n  /**\n   * Let the user set any of the parameters with a plain object.\n   * @method\n   * @param {object} params all the keys and the values to be updated\n   * @return {SearchParameters} a new updated instance\n   */\n  setQueryParameters: function setQueryParameters(params) {\n    if (!params) return this;\n\n    var error = SearchParameters.validate(this, params);\n\n    if (error) {\n      throw error;\n    }\n\n    var self = this;\n    var nextWithNumbers = SearchParameters._parseNumbers(params);\n    var previousPlainObject = Object.keys(this).reduce(function(acc, key) {\n      acc[key] = self[key];\n      return acc;\n    }, {});\n\n    var nextPlainObject = Object.keys(nextWithNumbers).reduce(\n      function(previous, key) {\n        var isPreviousValueDefined = previous[key] !== undefined;\n        var isNextValueDefined = nextWithNumbers[key] !== undefined;\n\n        if (isPreviousValueDefined && !isNextValueDefined) {\n          return omit(previous, [key]);\n        }\n\n        if (isNextValueDefined) {\n          previous[key] = nextWithNumbers[key];\n        }\n\n        return previous;\n      },\n      previousPlainObject\n    );\n\n    return new this.constructor(nextPlainObject);\n  },\n\n  /**\n   * Returns a new instance with the page reset. Two scenarios possible:\n   * the page is omitted -> return the given instance\n   * the page is set -> return a new instance with a page of 0\n   * @return {SearchParameters} a new updated instance\n   */\n  resetPage: function() {\n    if (this.page === undefined) {\n      return this;\n    }\n\n    return this.setPage(0);\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet separator or the default one (`>`)\n   * @param  {object} hierarchicalFacet\n   * @return {string} returns the hierarchicalFacet.separator or `>` as default\n   */\n  _getHierarchicalFacetSortBy: function(hierarchicalFacet) {\n    return hierarchicalFacet.sortBy || ['isRefined:desc', 'name:asc'];\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet separator or the default one (`>`)\n   * @private\n   * @param  {object} hierarchicalFacet\n   * @return {string} returns the hierarchicalFacet.separator or `>` as default\n   */\n  _getHierarchicalFacetSeparator: function(hierarchicalFacet) {\n    return hierarchicalFacet.separator || ' > ';\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet prefix path or null\n   * @private\n   * @param  {object} hierarchicalFacet\n   * @return {string} returns the hierarchicalFacet.rootPath or null as default\n   */\n  _getHierarchicalRootPath: function(hierarchicalFacet) {\n    return hierarchicalFacet.rootPath || null;\n  },\n\n  /**\n   * Helper function to check if we show the parent level of the hierarchicalFacet\n   * @private\n   * @param  {object} hierarchicalFacet\n   * @return {string} returns the hierarchicalFacet.showParentLevel or true as default\n   */\n  _getHierarchicalShowParentLevel: function(hierarchicalFacet) {\n    if (typeof hierarchicalFacet.showParentLevel === 'boolean') {\n      return hierarchicalFacet.showParentLevel;\n    }\n    return true;\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet by it's name\n   * @param  {string} hierarchicalFacetName\n   * @return {object} a hierarchicalFacet\n   */\n  getHierarchicalFacetByName: function(hierarchicalFacetName) {\n    return find(\n      this.hierarchicalFacets,\n      function(f) {\n        return f.name === hierarchicalFacetName;\n      }\n    );\n  },\n\n  /**\n   * Get the current breadcrumb for a hierarchical facet, as an array\n   * @param  {string} facetName Hierarchical facet name\n   * @return {array.<string>} the path as an array of string\n   */\n  getHierarchicalFacetBreadcrumb: function(facetName) {\n    if (!this.isHierarchicalFacet(facetName)) {\n      return [];\n    }\n\n    var refinement = this.getHierarchicalRefinement(facetName)[0];\n    if (!refinement) return [];\n\n    var separator = this._getHierarchicalFacetSeparator(\n      this.getHierarchicalFacetByName(facetName)\n    );\n    var path = refinement.split(separator);\n    return path.map(function(part) {\n      return part.trim();\n    });\n  },\n\n  toString: function() {\n    return JSON.stringify(this, null, 2);\n  }\n};\n\n/**\n * Callback used for clearRefinement method\n * @callback SearchParameters.clearCallback\n * @param {OperatorList|FacetList} value the value of the filter\n * @param {string} key the current attribute name\n * @param {string} type `numeric`, `disjunctiveFacet`, `conjunctiveFacet`, `hierarchicalFacet` or `exclude`\n * depending on the type of facet\n * @return {boolean} `true` if the element should be removed. `false` otherwise.\n */\nmodule.exports = SearchParameters;\n","'use strict';\n\nmodule.exports = generateTrees;\n\nvar orderBy = require('../functions/orderBy');\nvar find = require('../functions/find');\nvar prepareHierarchicalFacetSortBy = require('../functions/formatSort');\nvar fv = require('../functions/escapeFacetValue');\nvar escapeFacetValue = fv.escapeFacetValue;\nvar unescapeFacetValue = fv.unescapeFacetValue;\n\nfunction generateTrees(state) {\n  return function generate(hierarchicalFacetResult, hierarchicalFacetIndex) {\n    var hierarchicalFacet = state.hierarchicalFacets[hierarchicalFacetIndex];\n    var hierarchicalFacetRefinement =\n      (state.hierarchicalFacetsRefinements[hierarchicalFacet.name] &&\n        state.hierarchicalFacetsRefinements[hierarchicalFacet.name][0]) ||\n      '';\n    var hierarchicalSeparator = state._getHierarchicalFacetSeparator(\n      hierarchicalFacet\n    );\n    var hierarchicalRootPath = state._getHierarchicalRootPath(\n      hierarchicalFacet\n    );\n    var hierarchicalShowParentLevel = state._getHierarchicalShowParentLevel(\n      hierarchicalFacet\n    );\n    var sortBy = prepareHierarchicalFacetSortBy(\n      state._getHierarchicalFacetSortBy(hierarchicalFacet)\n    );\n\n    var rootExhaustive = hierarchicalFacetResult.every(function(facetResult) {\n      return facetResult.exhaustive;\n    });\n\n    var generateTreeFn = generateHierarchicalTree(\n      sortBy,\n      hierarchicalSeparator,\n      hierarchicalRootPath,\n      hierarchicalShowParentLevel,\n      hierarchicalFacetRefinement\n    );\n\n    var results = hierarchicalFacetResult;\n\n    if (hierarchicalRootPath) {\n      results = hierarchicalFacetResult.slice(\n        hierarchicalRootPath.split(hierarchicalSeparator).length\n      );\n    }\n\n    return results.reduce(generateTreeFn, {\n      name: state.hierarchicalFacets[hierarchicalFacetIndex].name,\n      count: null, // root level, no count\n      isRefined: true, // root level, always refined\n      path: null, // root level, no path\n      escapedValue: null,\n      exhaustive: rootExhaustive,\n      data: null\n    });\n  };\n}\n\nfunction generateHierarchicalTree(\n  sortBy,\n  hierarchicalSeparator,\n  hierarchicalRootPath,\n  hierarchicalShowParentLevel,\n  currentRefinement\n) {\n  return function generateTree(\n    hierarchicalTree,\n    hierarchicalFacetResult,\n    currentHierarchicalLevel\n  ) {\n    var parent = hierarchicalTree;\n\n    if (currentHierarchicalLevel > 0) {\n      var level = 0;\n\n      parent = hierarchicalTree;\n\n      while (level < currentHierarchicalLevel) {\n        /**\n         * @type {object[]]} hierarchical data\n         */\n        var data = parent && Array.isArray(parent.data) ? parent.data : [];\n        parent = find(data, function(subtree) {\n          return subtree.isRefined;\n        });\n        level++;\n      }\n    }\n\n    // we found a refined parent, let's add current level data under it\n    if (parent) {\n      // filter values in case an object has multiple categories:\n      //   {\n      //     categories: {\n      //       level0: ['beers', 'bières'],\n      //       level1: ['beers > IPA', 'bières > Belges']\n      //     }\n      //   }\n      //\n      // If parent refinement is `beers`, then we do not want to have `bières > Belges`\n      // showing up\n\n      var picked = Object.keys(hierarchicalFacetResult.data)\n        .map(function(facetValue) {\n          return [facetValue, hierarchicalFacetResult.data[facetValue]];\n        })\n        .filter(function(tuple) {\n          var facetValue = tuple[0];\n          return onlyMatchingTree(\n            facetValue,\n            parent.path || hierarchicalRootPath,\n            currentRefinement,\n            hierarchicalSeparator,\n            hierarchicalRootPath,\n            hierarchicalShowParentLevel\n          );\n        });\n\n      parent.data = orderBy(\n        picked.map(function(tuple) {\n          var facetValue = tuple[0];\n          var facetCount = tuple[1];\n\n          return format(\n            facetCount,\n            facetValue,\n            hierarchicalSeparator,\n            unescapeFacetValue(currentRefinement),\n            hierarchicalFacetResult.exhaustive\n          );\n        }),\n        sortBy[0],\n        sortBy[1]\n      );\n    }\n\n    return hierarchicalTree;\n  };\n}\n\nfunction onlyMatchingTree(\n  facetValue,\n  parentPath,\n  currentRefinement,\n  hierarchicalSeparator,\n  hierarchicalRootPath,\n  hierarchicalShowParentLevel\n) {\n  // we want the facetValue is a child of hierarchicalRootPath\n  if (\n    hierarchicalRootPath &&\n    (facetValue.indexOf(hierarchicalRootPath) !== 0 ||\n      hierarchicalRootPath === facetValue)\n  ) {\n    return false;\n  }\n\n  // we always want root levels (only when there is no prefix path)\n  return (\n    (!hierarchicalRootPath &&\n      facetValue.indexOf(hierarchicalSeparator) === -1) ||\n    // if there is a rootPath, being root level mean 1 level under rootPath\n    (hierarchicalRootPath &&\n      facetValue.split(hierarchicalSeparator).length -\n        hierarchicalRootPath.split(hierarchicalSeparator).length ===\n        1) ||\n    // if current refinement is a root level and current facetValue is a root level,\n    // keep the facetValue\n    (facetValue.indexOf(hierarchicalSeparator) === -1 &&\n      currentRefinement.indexOf(hierarchicalSeparator) === -1) ||\n    // currentRefinement is a child of the facet value\n    currentRefinement.indexOf(facetValue) === 0 ||\n    // facetValue is a child of the current parent, add it\n    (facetValue.indexOf(parentPath + hierarchicalSeparator) === 0 &&\n      (hierarchicalShowParentLevel ||\n        facetValue.indexOf(currentRefinement) === 0))\n  );\n}\n\nfunction format(\n  facetCount,\n  facetValue,\n  hierarchicalSeparator,\n  currentRefinement,\n  exhaustive\n) {\n  var parts = facetValue.split(hierarchicalSeparator);\n  return {\n    name: parts[parts.length - 1].trim(),\n    path: facetValue,\n    escapedValue: escapeFacetValue(facetValue),\n    count: facetCount,\n    isRefined:\n      currentRefinement === facetValue ||\n      currentRefinement.indexOf(facetValue + hierarchicalSeparator) === 0,\n    exhaustive: exhaustive,\n    data: null\n  };\n}\n","'use strict';\n\nvar merge = require('../functions/merge');\nvar defaultsPure = require('../functions/defaultsPure');\nvar orderBy = require('../functions/orderBy');\nvar compact = require('../functions/compact');\nvar find = require('../functions/find');\nvar findIndex = require('../functions/findIndex');\nvar formatSort = require('../functions/formatSort');\nvar fv = require('../functions/escapeFacetValue');\nvar escapeFacetValue = fv.escapeFacetValue;\nvar unescapeFacetValue = fv.unescapeFacetValue;\n\nvar generateHierarchicalTree = require('./generate-hierarchical-tree');\n\n/**\n * @typedef SearchResults.Facet\n * @type {object}\n * @property {string} name name of the attribute in the record\n * @property {object} data the faceting data: value, number of entries\n * @property {object} stats undefined unless facet_stats is retrieved from algolia\n */\n\n/**\n * @typedef SearchResults.HierarchicalFacet\n * @type {object}\n * @property {string} name name of the current value given the hierarchical level, trimmed.\n * If root node, you get the facet name\n * @property {number} count number of objects matching this hierarchical value\n * @property {string} path the current hierarchical value full path\n * @property {boolean} isRefined `true` if the current value was refined, `false` otherwise\n * @property {HierarchicalFacet[]} data sub values for the current level\n */\n\n/**\n * @typedef SearchResults.FacetValue\n * @type {object}\n * @property {string} name the facet value itself\n * @property {number} count times this facet appears in the results\n * @property {boolean} isRefined is the facet currently selected\n * @property {boolean} isExcluded is the facet currently excluded (only for conjunctive facets)\n */\n\n/**\n * @typedef Refinement\n * @type {object}\n * @property {string} type the type of filter used:\n * `numeric`, `facet`, `exclude`, `disjunctive`, `hierarchical`\n * @property {string} attributeName name of the attribute used for filtering\n * @property {string} name the value of the filter\n * @property {number} numericValue the value as a number. Only for numeric filters.\n * @property {string} operator the operator used. Only for numeric filters.\n * @property {number} count the number of computed hits for this filter. Only on facets.\n * @property {boolean} exhaustive if the count is exhaustive\n */\n\n/**\n * @param {string[]} attributes\n */\nfunction getIndices(attributes) {\n  var indices = {};\n\n  attributes.forEach(function(val, idx) {\n    indices[val] = idx;\n  });\n\n  return indices;\n}\n\nfunction assignFacetStats(dest, facetStats, key) {\n  if (facetStats && facetStats[key]) {\n    dest.stats = facetStats[key];\n  }\n}\n\n/**\n * @typedef {Object} HierarchicalFacet\n * @property {string} name\n * @property {string[]} attributes\n */\n\n/**\n * @param {HierarchicalFacet[]} hierarchicalFacets\n * @param {string} hierarchicalAttributeName\n */\nfunction findMatchingHierarchicalFacetFromAttributeName(\n  hierarchicalFacets,\n  hierarchicalAttributeName\n) {\n  return find(hierarchicalFacets, function facetKeyMatchesAttribute(\n    hierarchicalFacet\n  ) {\n    var facetNames = hierarchicalFacet.attributes || [];\n    return facetNames.indexOf(hierarchicalAttributeName) > -1;\n  });\n}\n\n/*eslint-disable */\n/**\n * Constructor for SearchResults\n * @class\n * @classdesc SearchResults contains the results of a query to Algolia using the\n * {@link AlgoliaSearchHelper}.\n * @param {SearchParameters} state state that led to the response\n * @param {array.<object>} results the results from algolia client\n * @example <caption>SearchResults of the first query in\n * <a href=\"http://demos.algolia.com/instant-search-demo\">the instant search demo</a></caption>\n{\n   \"hitsPerPage\": 10,\n   \"processingTimeMS\": 2,\n   \"facets\": [\n      {\n         \"name\": \"type\",\n         \"data\": {\n            \"HardGood\": 6627,\n            \"BlackTie\": 550,\n            \"Music\": 665,\n            \"Software\": 131,\n            \"Game\": 456,\n            \"Movie\": 1571\n         },\n         \"exhaustive\": false\n      },\n      {\n         \"exhaustive\": false,\n         \"data\": {\n            \"Free shipping\": 5507\n         },\n         \"name\": \"shipping\"\n      }\n  ],\n   \"hits\": [\n      {\n         \"thumbnailImage\": \"http://img.bbystatic.com/BestBuy_US/images/products/1688/1688832_54x108_s.gif\",\n         \"_highlightResult\": {\n            \"shortDescription\": {\n               \"matchLevel\": \"none\",\n               \"value\": \"Safeguard your PC, Mac, Android and iOS devices with comprehensive Internet protection\",\n               \"matchedWords\": []\n            },\n            \"category\": {\n               \"matchLevel\": \"none\",\n               \"value\": \"Computer Security Software\",\n               \"matchedWords\": []\n            },\n            \"manufacturer\": {\n               \"matchedWords\": [],\n               \"value\": \"Webroot\",\n               \"matchLevel\": \"none\"\n            },\n            \"name\": {\n               \"value\": \"Webroot SecureAnywhere Internet Security (3-Device) (1-Year Subscription) - Mac/Windows\",\n               \"matchedWords\": [],\n               \"matchLevel\": \"none\"\n            }\n         },\n         \"image\": \"http://img.bbystatic.com/BestBuy_US/images/products/1688/1688832_105x210_sc.jpg\",\n         \"shipping\": \"Free shipping\",\n         \"bestSellingRank\": 4,\n         \"shortDescription\": \"Safeguard your PC, Mac, Android and iOS devices with comprehensive Internet protection\",\n         \"url\": \"http://www.bestbuy.com/site/webroot-secureanywhere-internet-security-3-devi…d=1219060687969&skuId=1688832&cmp=RMX&ky=2d3GfEmNIzjA0vkzveHdZEBgpPCyMnLTJ\",\n         \"name\": \"Webroot SecureAnywhere Internet Security (3-Device) (1-Year Subscription) - Mac/Windows\",\n         \"category\": \"Computer Security Software\",\n         \"salePrice_range\": \"1 - 50\",\n         \"objectID\": \"1688832\",\n         \"type\": \"Software\",\n         \"customerReviewCount\": 5980,\n         \"salePrice\": 49.99,\n         \"manufacturer\": \"Webroot\"\n      },\n      ....\n  ],\n   \"nbHits\": 10000,\n   \"disjunctiveFacets\": [\n      {\n         \"exhaustive\": false,\n         \"data\": {\n            \"5\": 183,\n            \"12\": 112,\n            \"7\": 149,\n            ...\n         },\n         \"name\": \"customerReviewCount\",\n         \"stats\": {\n            \"max\": 7461,\n            \"avg\": 157.939,\n            \"min\": 1\n         }\n      },\n      {\n         \"data\": {\n            \"Printer Ink\": 142,\n            \"Wireless Speakers\": 60,\n            \"Point & Shoot Cameras\": 48,\n            ...\n         },\n         \"name\": \"category\",\n         \"exhaustive\": false\n      },\n      {\n         \"exhaustive\": false,\n         \"data\": {\n            \"> 5000\": 2,\n            \"1 - 50\": 6524,\n            \"501 - 2000\": 566,\n            \"201 - 500\": 1501,\n            \"101 - 200\": 1360,\n            \"2001 - 5000\": 47\n         },\n         \"name\": \"salePrice_range\"\n      },\n      {\n         \"data\": {\n            \"Dynex™\": 202,\n            \"Insignia™\": 230,\n            \"PNY\": 72,\n            ...\n         },\n         \"name\": \"manufacturer\",\n         \"exhaustive\": false\n      }\n  ],\n   \"query\": \"\",\n   \"nbPages\": 100,\n   \"page\": 0,\n   \"index\": \"bestbuy\"\n}\n **/\n/*eslint-enable */\nfunction SearchResults(state, results, options) {\n  var mainSubResponse = results[0];\n\n  this._rawResults = results;\n\n  var self = this;\n\n  // https://www.algolia.com/doc/api-reference/api-methods/search/#response\n  Object.keys(mainSubResponse).forEach(function(key) {\n    self[key] = mainSubResponse[key];\n  });\n\n  // Make every key of the result options reachable from the instance\n  Object.keys(options || {}).forEach(function(key) {\n    self[key] = options[key];\n  });\n\n  /**\n   * query used to generate the results\n   * @name query\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * The query as parsed by the engine given all the rules.\n   * @name parsedQuery\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * all the records that match the search parameters. Each record is\n   * augmented with a new attribute `_highlightResult`\n   * which is an object keyed by attribute and with the following properties:\n   *  - `value` : the value of the facet highlighted (html)\n   *  - `matchLevel`: full, partial or none depending on how the query terms match\n   * @name hits\n   * @member {object[]}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * index where the results come from\n   * @name index\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * number of hits per page requested\n   * @name hitsPerPage\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * total number of hits of this query on the index\n   * @name nbHits\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * total number of pages with respect to the number of hits per page and the total number of hits\n   * @name nbPages\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * current page\n   * @name page\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * The position if the position was guessed by IP.\n   * @name aroundLatLng\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   * @example \"48.8637,2.3615\",\n   */\n  /**\n   * The radius computed by Algolia.\n   * @name automaticRadius\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   * @example \"126792922\",\n   */\n  /**\n   * String identifying the server used to serve this request.\n   *\n   * getRankingInfo needs to be set to `true` for this to be returned\n   *\n   * @name serverUsed\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   * @example \"c7-use-2.algolia.net\",\n   */\n  /**\n   * Boolean that indicates if the computation of the counts did time out.\n   * @deprecated\n   * @name timeoutCounts\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * Boolean that indicates if the computation of the hits did time out.\n   * @deprecated\n   * @name timeoutHits\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * True if the counts of the facets is exhaustive\n   * @name exhaustiveFacetsCount\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * True if the number of hits is exhaustive\n   * @name exhaustiveNbHits\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * Contains the userData if they are set by a [query rule](https://www.algolia.com/doc/guides/query-rules/query-rules-overview/).\n   * @name userData\n   * @member {object[]}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * queryID is the unique identifier of the query used to generate the current search results.\n   * This value is only available if the `clickAnalytics` search parameter is set to `true`.\n   * @name queryID\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * sum of the processing time of all the queries\n   * @member {number}\n   */\n  this.processingTimeMS = results.reduce(function(sum, result) {\n    return result.processingTimeMS === undefined\n      ? sum\n      : sum + result.processingTimeMS;\n  }, 0);\n\n  /**\n   * disjunctive facets results\n   * @member {SearchResults.Facet[]}\n   */\n  this.disjunctiveFacets = [];\n  /**\n   * disjunctive facets results\n   * @member {SearchResults.HierarchicalFacet[]}\n   */\n  this.hierarchicalFacets = state.hierarchicalFacets.map(function initFutureTree() {\n    return [];\n  });\n  /**\n   * other facets results\n   * @member {SearchResults.Facet[]}\n   */\n  this.facets = [];\n\n  var disjunctiveFacets = state.getRefinedDisjunctiveFacets();\n\n  var facetsIndices = getIndices(state.facets);\n  var disjunctiveFacetsIndices = getIndices(state.disjunctiveFacets);\n  var nextDisjunctiveResult = 1;\n\n  // Since we send request only for disjunctive facets that have been refined,\n  // we get the facets information from the first, general, response.\n\n  var mainFacets = mainSubResponse.facets || {};\n\n  Object.keys(mainFacets).forEach(function(facetKey) {\n    var facetValueObject = mainFacets[facetKey];\n\n    var hierarchicalFacet = findMatchingHierarchicalFacetFromAttributeName(\n      state.hierarchicalFacets,\n      facetKey\n    );\n\n    if (hierarchicalFacet) {\n      // Place the hierarchicalFacet data at the correct index depending on\n      // the attributes order that was defined at the helper initialization\n      var facetIndex = hierarchicalFacet.attributes.indexOf(facetKey);\n      var idxAttributeName = findIndex(state.hierarchicalFacets, function(f) {\n        return f.name === hierarchicalFacet.name;\n      });\n      self.hierarchicalFacets[idxAttributeName][facetIndex] = {\n        attribute: facetKey,\n        data: facetValueObject,\n        exhaustive: mainSubResponse.exhaustiveFacetsCount\n      };\n    } else {\n      var isFacetDisjunctive = state.disjunctiveFacets.indexOf(facetKey) !== -1;\n      var isFacetConjunctive = state.facets.indexOf(facetKey) !== -1;\n      var position;\n\n      if (isFacetDisjunctive) {\n        position = disjunctiveFacetsIndices[facetKey];\n        self.disjunctiveFacets[position] = {\n          name: facetKey,\n          data: facetValueObject,\n          exhaustive: mainSubResponse.exhaustiveFacetsCount\n        };\n        assignFacetStats(self.disjunctiveFacets[position], mainSubResponse.facets_stats, facetKey);\n      }\n      if (isFacetConjunctive) {\n        position = facetsIndices[facetKey];\n        self.facets[position] = {\n          name: facetKey,\n          data: facetValueObject,\n          exhaustive: mainSubResponse.exhaustiveFacetsCount\n        };\n        assignFacetStats(self.facets[position], mainSubResponse.facets_stats, facetKey);\n      }\n    }\n  });\n\n  // Make sure we do not keep holes within the hierarchical facets\n  this.hierarchicalFacets = compact(this.hierarchicalFacets);\n\n  // aggregate the refined disjunctive facets\n  disjunctiveFacets.forEach(function(disjunctiveFacet) {\n    var result = results[nextDisjunctiveResult];\n    var facets = result && result.facets ? result.facets : {};\n    var hierarchicalFacet = state.getHierarchicalFacetByName(disjunctiveFacet);\n\n    // There should be only item in facets.\n    Object.keys(facets).forEach(function(dfacet) {\n      var facetResults = facets[dfacet];\n\n      var position;\n\n      if (hierarchicalFacet) {\n        position = findIndex(state.hierarchicalFacets, function(f) {\n          return f.name === hierarchicalFacet.name;\n        });\n        var attributeIndex = findIndex(self.hierarchicalFacets[position], function(f) {\n          return f.attribute === dfacet;\n        });\n\n        // previous refinements and no results so not able to find it\n        if (attributeIndex === -1) {\n          return;\n        }\n\n        self.hierarchicalFacets[position][attributeIndex].data = merge(\n          {},\n          self.hierarchicalFacets[position][attributeIndex].data,\n          facetResults\n        );\n      } else {\n        position = disjunctiveFacetsIndices[dfacet];\n\n        var dataFromMainRequest = mainSubResponse.facets && mainSubResponse.facets[dfacet] || {};\n\n        self.disjunctiveFacets[position] = {\n          name: dfacet,\n          data: defaultsPure({}, facetResults, dataFromMainRequest),\n          exhaustive: result.exhaustiveFacetsCount\n        };\n        assignFacetStats(self.disjunctiveFacets[position], result.facets_stats, dfacet);\n\n        if (state.disjunctiveFacetsRefinements[dfacet]) {\n          state.disjunctiveFacetsRefinements[dfacet].forEach(function(refinementValue) {\n            // add the disjunctive refinements if it is no more retrieved\n            if (!self.disjunctiveFacets[position].data[refinementValue] &&\n              state.disjunctiveFacetsRefinements[dfacet].indexOf(unescapeFacetValue(refinementValue)) > -1) {\n              self.disjunctiveFacets[position].data[refinementValue] = 0;\n            }\n          });\n        }\n      }\n    });\n    nextDisjunctiveResult++;\n  });\n\n  // if we have some parent level values for hierarchical facets, merge them\n  state.getRefinedHierarchicalFacets().forEach(function(refinedFacet) {\n    var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);\n    var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n    var currentRefinement = state.getHierarchicalRefinement(refinedFacet);\n    // if we are already at a root refinement (or no refinement at all), there is no\n    // root level values request\n    if (currentRefinement.length === 0 || currentRefinement[0].split(separator).length < 2) {\n      return;\n    }\n\n    results.slice(nextDisjunctiveResult).forEach(function(result) {\n      var facets = result && result.facets\n        ? result.facets\n        : {};\n\n      Object.keys(facets).forEach(function(dfacet) {\n        var facetResults = facets[dfacet];\n        var position = findIndex(state.hierarchicalFacets, function(f) {\n          return f.name === hierarchicalFacet.name;\n        });\n        var attributeIndex = findIndex(self.hierarchicalFacets[position], function(f) {\n          return f.attribute === dfacet;\n        });\n\n        // previous refinements and no results so not able to find it\n        if (attributeIndex === -1) {\n          return;\n        }\n\n        // when we always get root levels, if the hits refinement is `beers > IPA` (count: 5),\n        // then the disjunctive values will be `beers` (count: 100),\n        // but we do not want to display\n        //   | beers (100)\n        //     > IPA (5)\n        // We want\n        //   | beers (5)\n        //     > IPA (5)\n        var defaultData = {};\n\n        if (currentRefinement.length > 0) {\n          var root = currentRefinement[0].split(separator)[0];\n          defaultData[root] = self.hierarchicalFacets[position][attributeIndex].data[root];\n        }\n\n        self.hierarchicalFacets[position][attributeIndex].data = defaultsPure(\n          defaultData,\n          facetResults,\n          self.hierarchicalFacets[position][attributeIndex].data\n        );\n      });\n\n      nextDisjunctiveResult++;\n    });\n  });\n\n  // add the excludes\n  Object.keys(state.facetsExcludes).forEach(function(facetName) {\n    var excludes = state.facetsExcludes[facetName];\n    var position = facetsIndices[facetName];\n\n    self.facets[position] = {\n      name: facetName,\n      data: mainSubResponse.facets[facetName],\n      exhaustive: mainSubResponse.exhaustiveFacetsCount\n    };\n    excludes.forEach(function(facetValue) {\n      self.facets[position] = self.facets[position] || {name: facetName};\n      self.facets[position].data = self.facets[position].data || {};\n      self.facets[position].data[facetValue] = 0;\n    });\n  });\n\n  /**\n   * @type {Array}\n   */\n  this.hierarchicalFacets = this.hierarchicalFacets.map(generateHierarchicalTree(state));\n\n  /**\n   * @type {Array}\n   */\n  this.facets = compact(this.facets);\n  /**\n   * @type {Array}\n   */\n  this.disjunctiveFacets = compact(this.disjunctiveFacets);\n\n  this._state = state;\n}\n\n/**\n * Get a facet object with its name\n * @deprecated\n * @param {string} name name of the faceted attribute\n * @return {SearchResults.Facet} the facet object\n */\nSearchResults.prototype.getFacetByName = function(name) {\n  function predicate(facet) {\n    return facet.name === name;\n  }\n\n  return find(this.facets, predicate) ||\n    find(this.disjunctiveFacets, predicate) ||\n    find(this.hierarchicalFacets, predicate);\n};\n\n/**\n * Get the facet values of a specified attribute from a SearchResults object.\n * @private\n * @param {SearchResults} results the search results to search in\n * @param {string} attribute name of the faceted attribute to search for\n * @return {array|object} facet values. For the hierarchical facets it is an object.\n */\nfunction extractNormalizedFacetValues(results, attribute) {\n  function predicate(facet) {\n    return facet.name === attribute;\n  }\n\n  if (results._state.isConjunctiveFacet(attribute)) {\n    var facet = find(results.facets, predicate);\n    if (!facet) return [];\n\n    return Object.keys(facet.data).map(function(name) {\n      var value = escapeFacetValue(name);\n      return {\n        name: name,\n        escapedValue: value,\n        count: facet.data[name],\n        isRefined: results._state.isFacetRefined(attribute, value),\n        isExcluded: results._state.isExcludeRefined(attribute, name)\n      };\n    });\n  } else if (results._state.isDisjunctiveFacet(attribute)) {\n    var disjunctiveFacet = find(results.disjunctiveFacets, predicate);\n    if (!disjunctiveFacet) return [];\n\n    return Object.keys(disjunctiveFacet.data).map(function(name) {\n      var value = escapeFacetValue(name);\n      return {\n        name: name,\n        escapedValue: value,\n        count: disjunctiveFacet.data[name],\n        isRefined: results._state.isDisjunctiveFacetRefined(attribute, value)\n      };\n    });\n  } else if (results._state.isHierarchicalFacet(attribute)) {\n    return find(results.hierarchicalFacets, predicate);\n  }\n}\n\n/**\n * Sort nodes of a hierarchical or disjunctive facet results\n * @private\n * @param {function} sortFn\n * @param {HierarchicalFacet|Array} node node upon which we want to apply the sort\n * @param {string[]} names attribute names\n * @param {number} [level=0] current index in the names array\n */\nfunction recSort(sortFn, node, names, level) {\n  level = level || 0;\n\n  if (Array.isArray(node)) {\n    return sortFn(node, names[level]);\n  }\n\n  if (!node.data || node.data.length === 0) {\n    return node;\n  }\n\n  var children = node.data.map(function(childNode) {\n    return recSort(sortFn, childNode, names, level + 1);\n  });\n  var sortedChildren = sortFn(children, names[level]);\n  var newNode = defaultsPure({data: sortedChildren}, node);\n  return newNode;\n}\n\nSearchResults.DEFAULT_SORT = ['isRefined:desc', 'count:desc', 'name:asc'];\n\nfunction vanillaSortFn(order, data) {\n  return data.sort(order);\n}\n\n/**\n * @typedef FacetOrdering\n * @type {Object}\n * @property {string[]} [order]\n * @property {'count' | 'alpha' | 'hidden'} [sortRemainingBy]\n */\n\n/**\n * Sorts facet arrays via their facet ordering\n * @param {Array} facetValues the values\n * @param {FacetOrdering} facetOrdering the ordering\n * @returns {Array}\n */\nfunction sortViaFacetOrdering(facetValues, facetOrdering) {\n  var orderedFacets = [];\n  var remainingFacets = [];\n\n  var order = facetOrdering.order || [];\n  /**\n   * an object with the keys being the values in order, the values their index:\n   * ['one', 'two'] -> { one: 0, two: 1 }\n   */\n  var reverseOrder = order.reduce(function(acc, name, i) {\n    acc[name] = i;\n    return acc;\n  }, {});\n\n  facetValues.forEach(function(item) {\n    // hierarchical facets get sorted using their raw name\n    var name = item.path || item.name;\n    if (reverseOrder[name] !== undefined) {\n      orderedFacets[reverseOrder[name]] = item;\n    } else {\n      remainingFacets.push(item);\n    }\n  });\n\n  orderedFacets = orderedFacets.filter(function(facet) {\n    return facet;\n  });\n\n  var sortRemainingBy = facetOrdering.sortRemainingBy;\n  var ordering;\n  if (sortRemainingBy === 'hidden') {\n    return orderedFacets;\n  } else if (sortRemainingBy === 'alpha') {\n    ordering = [['path', 'name'], ['asc', 'asc']];\n  } else {\n    ordering = [['count'], ['desc']];\n  }\n\n  return orderedFacets.concat(\n    orderBy(remainingFacets, ordering[0], ordering[1])\n  );\n}\n\n/**\n * @param {SearchResults} results the search results class\n * @param {string} attribute the attribute to retrieve ordering of\n * @returns {FacetOrdering=}\n */\nfunction getFacetOrdering(results, attribute) {\n  return (\n    results.renderingContent &&\n    results.renderingContent.facetOrdering &&\n    results.renderingContent.facetOrdering.values &&\n    results.renderingContent.facetOrdering.values[attribute]\n  );\n}\n\n/**\n * Get a the list of values for a given facet attribute. Those values are sorted\n * refinement first, descending count (bigger value on top), and name ascending\n * (alphabetical order). The sort formula can overridden using either string based\n * predicates or a function.\n *\n * This method will return all the values returned by the Algolia engine plus all\n * the values already refined. This means that it can happen that the\n * `maxValuesPerFacet` [configuration](https://www.algolia.com/doc/rest-api/search#param-maxValuesPerFacet)\n * might not be respected if you have facet values that are already refined.\n * @param {string} attribute attribute name\n * @param {object} opts configuration options.\n * @param {boolean} [opts.facetOrdering]\n * Force the use of facetOrdering from the result if a sortBy is present. If\n * sortBy isn't present, facetOrdering will be used automatically.\n * @param {Array.<string> | function} opts.sortBy\n * When using strings, it consists of\n * the name of the [FacetValue](#SearchResults.FacetValue) or the\n * [HierarchicalFacet](#SearchResults.HierarchicalFacet) attributes with the\n * order (`asc` or `desc`). For example to order the value by count, the\n * argument would be `['count:asc']`.\n *\n * If only the attribute name is specified, the ordering defaults to the one\n * specified in the default value for this attribute.\n *\n * When not specified, the order is\n * ascending.  This parameter can also be a function which takes two facet\n * values and should return a number, 0 if equal, 1 if the first argument is\n * bigger or -1 otherwise.\n *\n * The default value for this attribute `['isRefined:desc', 'count:desc', 'name:asc']`\n * @return {FacetValue[]|HierarchicalFacet|undefined} depending on the type of facet of\n * the attribute requested (hierarchical, disjunctive or conjunctive)\n * @example\n * helper.on('result', function(event){\n *   //get values ordered only by name ascending using the string predicate\n *   event.results.getFacetValues('city', {sortBy: ['name:asc']});\n *   //get values  ordered only by count ascending using a function\n *   event.results.getFacetValues('city', {\n *     // this is equivalent to ['count:asc']\n *     sortBy: function(a, b) {\n *       if (a.count === b.count) return 0;\n *       if (a.count > b.count)   return 1;\n *       if (b.count > a.count)   return -1;\n *     }\n *   });\n * });\n */\nSearchResults.prototype.getFacetValues = function(attribute, opts) {\n  var facetValues = extractNormalizedFacetValues(this, attribute);\n  if (!facetValues) {\n    return undefined;\n  }\n\n  var options = defaultsPure({}, opts, {\n    sortBy: SearchResults.DEFAULT_SORT,\n    // if no sortBy is given, attempt to sort based on facetOrdering\n    // if it is given, we still allow to sort via facet ordering first\n    facetOrdering: !(opts && opts.sortBy)\n  });\n\n  var results = this;\n  var attributes;\n  if (Array.isArray(facetValues)) {\n    attributes = [attribute];\n  } else {\n    var config = results._state.getHierarchicalFacetByName(facetValues.name);\n    attributes = config.attributes;\n  }\n\n  return recSort(function(data, facetName) {\n    if (options.facetOrdering) {\n      var facetOrdering = getFacetOrdering(results, facetName);\n      if (Boolean(facetOrdering)) {\n        return sortViaFacetOrdering(data, facetOrdering);\n      }\n    }\n\n    if (Array.isArray(options.sortBy)) {\n      var order = formatSort(options.sortBy, SearchResults.DEFAULT_SORT);\n      return orderBy(data, order[0], order[1]);\n    } else if (typeof options.sortBy === 'function') {\n      return vanillaSortFn(options.sortBy, data);\n    }\n    throw new Error(\n      'options.sortBy is optional but if defined it must be ' +\n        'either an array of string (predicates) or a sorting function'\n    );\n  }, facetValues, attributes);\n};\n\n/**\n * Returns the facet stats if attribute is defined and the facet contains some.\n * Otherwise returns undefined.\n * @param {string} attribute name of the faceted attribute\n * @return {object} The stats of the facet\n */\nSearchResults.prototype.getFacetStats = function(attribute) {\n  if (this._state.isConjunctiveFacet(attribute)) {\n    return getFacetStatsIfAvailable(this.facets, attribute);\n  } else if (this._state.isDisjunctiveFacet(attribute)) {\n    return getFacetStatsIfAvailable(this.disjunctiveFacets, attribute);\n  }\n\n  return undefined;\n};\n\n/**\n * @typedef {Object} FacetListItem\n * @property {string} name\n */\n\n/**\n * @param {FacetListItem[]} facetList (has more items, but enough for here)\n * @param {string} facetName\n */\nfunction getFacetStatsIfAvailable(facetList, facetName) {\n  var data = find(facetList, function(facet) {\n    return facet.name === facetName;\n  });\n  return data && data.stats;\n}\n\n/**\n * Returns all refinements for all filters + tags. It also provides\n * additional information: count and exhaustiveness for each filter.\n *\n * See the [refinement type](#Refinement) for an exhaustive view of the available\n * data.\n *\n * Note that for a numeric refinement, results are grouped per operator, this\n * means that it will return responses for operators which are empty.\n *\n * @return {Array.<Refinement>} all the refinements\n */\nSearchResults.prototype.getRefinements = function() {\n  var state = this._state;\n  var results = this;\n  var res = [];\n\n  Object.keys(state.facetsRefinements).forEach(function(attributeName) {\n    state.facetsRefinements[attributeName].forEach(function(name) {\n      res.push(getRefinement(state, 'facet', attributeName, name, results.facets));\n    });\n  });\n\n  Object.keys(state.facetsExcludes).forEach(function(attributeName) {\n    state.facetsExcludes[attributeName].forEach(function(name) {\n      res.push(getRefinement(state, 'exclude', attributeName, name, results.facets));\n    });\n  });\n\n  Object.keys(state.disjunctiveFacetsRefinements).forEach(function(attributeName) {\n    state.disjunctiveFacetsRefinements[attributeName].forEach(function(name) {\n      res.push(getRefinement(state, 'disjunctive', attributeName, name, results.disjunctiveFacets));\n    });\n  });\n\n  Object.keys(state.hierarchicalFacetsRefinements).forEach(function(attributeName) {\n    state.hierarchicalFacetsRefinements[attributeName].forEach(function(name) {\n      res.push(getHierarchicalRefinement(state, attributeName, name, results.hierarchicalFacets));\n    });\n  });\n\n\n  Object.keys(state.numericRefinements).forEach(function(attributeName) {\n    var operators = state.numericRefinements[attributeName];\n    Object.keys(operators).forEach(function(operator) {\n      operators[operator].forEach(function(value) {\n        res.push({\n          type: 'numeric',\n          attributeName: attributeName,\n          name: value,\n          numericValue: value,\n          operator: operator\n        });\n      });\n    });\n  });\n\n  state.tagRefinements.forEach(function(name) {\n    res.push({type: 'tag', attributeName: '_tags', name: name});\n  });\n\n  return res;\n};\n\n/**\n * @typedef {Object} Facet\n * @property {string} name\n * @property {Object} data\n * @property {boolean} exhaustive\n */\n\n/**\n * @param {*} state\n * @param {*} type\n * @param {string} attributeName\n * @param {*} name\n * @param {Facet[]} resultsFacets\n */\nfunction getRefinement(state, type, attributeName, name, resultsFacets) {\n  var facet = find(resultsFacets, function(f) {\n    return f.name === attributeName;\n  });\n  var count = facet && facet.data && facet.data[name] ? facet.data[name] : 0;\n  var exhaustive = (facet && facet.exhaustive) || false;\n\n  return {\n    type: type,\n    attributeName: attributeName,\n    name: name,\n    count: count,\n    exhaustive: exhaustive\n  };\n}\n\n/**\n * @param {*} state\n * @param {string} attributeName\n * @param {*} name\n * @param {Facet[]} resultsFacets\n */\nfunction getHierarchicalRefinement(state, attributeName, name, resultsFacets) {\n  var facetDeclaration = state.getHierarchicalFacetByName(attributeName);\n  var separator = state._getHierarchicalFacetSeparator(facetDeclaration);\n  var split = name.split(separator);\n  var rootFacet = find(resultsFacets, function(facet) {\n    return facet.name === attributeName;\n  });\n\n  var facet = split.reduce(function(intermediateFacet, part) {\n    var newFacet =\n      intermediateFacet && find(intermediateFacet.data, function(f) {\n        return f.name === part;\n      });\n    return newFacet !== undefined ? newFacet : intermediateFacet;\n  }, rootFacet);\n\n  var count = (facet && facet.count) || 0;\n  var exhaustive = (facet && facet.exhaustive) || false;\n  var path = (facet && facet.path) || '';\n\n  return {\n    type: 'hierarchical',\n    attributeName: attributeName,\n    name: path,\n    count: count,\n    exhaustive: exhaustive\n  };\n}\n\nmodule.exports = SearchResults;\n","'use strict';\n\nvar SearchParameters = require('./SearchParameters');\nvar SearchResults = require('./SearchResults');\nvar DerivedHelper = require('./DerivedHelper');\nvar requestBuilder = require('./requestBuilder');\n\nvar EventEmitter = require('@algolia/events');\nvar inherits = require('./functions/inherits');\nvar objectHasKeys = require('./functions/objectHasKeys');\nvar omit = require('./functions/omit');\nvar merge = require('./functions/merge');\n\nvar version = require('./version');\nvar escapeFacetValue = require('./functions/escapeFacetValue').escapeFacetValue;\n\n/**\n * Event triggered when a parameter is set or updated\n * @event AlgoliaSearchHelper#event:change\n * @property {object} event\n * @property {SearchParameters} event.state the current parameters with the latest changes applied\n * @property {SearchResults} event.results the previous results received from Algolia. `null` before the first request\n * @example\n * helper.on('change', function(event) {\n *   console.log('The parameters have changed');\n * });\n */\n\n/**\n * Event triggered when a main search is sent to Algolia\n * @event AlgoliaSearchHelper#event:search\n * @property {object} event\n * @property {SearchParameters} event.state the parameters used for this search\n * @property {SearchResults} event.results the results from the previous search. `null` if it is the first search.\n * @example\n * helper.on('search', function(event) {\n *   console.log('Search sent');\n * });\n */\n\n/**\n * Event triggered when a search using `searchForFacetValues` is sent to Algolia\n * @event AlgoliaSearchHelper#event:searchForFacetValues\n * @property {object} event\n * @property {SearchParameters} event.state the parameters used for this search it is the first search.\n * @property {string} event.facet the facet searched into\n * @property {string} event.query the query used to search in the facets\n * @example\n * helper.on('searchForFacetValues', function(event) {\n *   console.log('searchForFacetValues sent');\n * });\n */\n\n/**\n * Event triggered when a search using `searchOnce` is sent to Algolia\n * @event AlgoliaSearchHelper#event:searchOnce\n * @property {object} event\n * @property {SearchParameters} event.state the parameters used for this search it is the first search.\n * @example\n * helper.on('searchOnce', function(event) {\n *   console.log('searchOnce sent');\n * });\n */\n\n/**\n * Event triggered when the results are retrieved from Algolia\n * @event AlgoliaSearchHelper#event:result\n * @property {object} event\n * @property {SearchResults} event.results the results received from Algolia\n * @property {SearchParameters} event.state the parameters used to query Algolia. Those might be different from the one in the helper instance (for example if the network is unreliable).\n * @example\n * helper.on('result', function(event) {\n *   console.log('Search results received');\n * });\n */\n\n/**\n * Event triggered when Algolia sends back an error. For example, if an unknown parameter is\n * used, the error can be caught using this event.\n * @event AlgoliaSearchHelper#event:error\n * @property {object} event\n * @property {Error} event.error the error returned by the Algolia.\n * @example\n * helper.on('error', function(event) {\n *   console.log('Houston we got a problem.');\n * });\n */\n\n/**\n * Event triggered when the queue of queries have been depleted (with any result or outdated queries)\n * @event AlgoliaSearchHelper#event:searchQueueEmpty\n * @example\n * helper.on('searchQueueEmpty', function() {\n *   console.log('No more search pending');\n *   // This is received before the result event if we're not expecting new results\n * });\n *\n * helper.search();\n */\n\n/**\n * Initialize a new AlgoliaSearchHelper\n * @class\n * @classdesc The AlgoliaSearchHelper is a class that ease the management of the\n * search. It provides an event based interface for search callbacks:\n *  - change: when the internal search state is changed.\n *    This event contains a {@link SearchParameters} object and the\n *    {@link SearchResults} of the last result if any.\n *  - search: when a search is triggered using the `search()` method.\n *  - result: when the response is retrieved from Algolia and is processed.\n *    This event contains a {@link SearchResults} object and the\n *    {@link SearchParameters} corresponding to this answer.\n *  - error: when the response is an error. This event contains the error returned by the server.\n * @param  {AlgoliaSearch} client an AlgoliaSearch client\n * @param  {string} index the index name to query\n * @param  {SearchParameters | object} options an object defining the initial\n * config of the search. It doesn't have to be a {SearchParameters},\n * just an object containing the properties you need from it.\n */\nfunction AlgoliaSearchHelper(client, index, options) {\n  if (typeof client.addAlgoliaAgent === 'function') {\n    client.addAlgoliaAgent('JS Helper (' + version + ')');\n  }\n\n  this.setClient(client);\n  var opts = options || {};\n  opts.index = index;\n  this.state = SearchParameters.make(opts);\n  this.lastResults = null;\n  this._queryId = 0;\n  this._lastQueryIdReceived = -1;\n  this.derivedHelpers = [];\n  this._currentNbQueries = 0;\n}\n\ninherits(AlgoliaSearchHelper, EventEmitter);\n\n/**\n * Start the search with the parameters set in the state. When the\n * method is called, it triggers a `search` event. The results will\n * be available through the `result` event. If an error occurs, an\n * `error` will be fired instead.\n * @return {AlgoliaSearchHelper}\n * @fires search\n * @fires result\n * @fires error\n * @chainable\n */\nAlgoliaSearchHelper.prototype.search = function() {\n  this._search({onlyWithDerivedHelpers: false});\n  return this;\n};\n\nAlgoliaSearchHelper.prototype.searchOnlyWithDerivedHelpers = function() {\n  this._search({onlyWithDerivedHelpers: true});\n  return this;\n};\n\n/**\n * Gets the search query parameters that would be sent to the Algolia Client\n * for the hits\n * @return {object} Query Parameters\n */\nAlgoliaSearchHelper.prototype.getQuery = function() {\n  var state = this.state;\n  return requestBuilder._getHitsSearchParams(state);\n};\n\n/**\n * Start a search using a modified version of the current state. This method does\n * not trigger the helper lifecycle and does not modify the state kept internally\n * by the helper. This second aspect means that the next search call will be the\n * same as a search call before calling searchOnce.\n * @param {object} options can contain all the parameters that can be set to SearchParameters\n * plus the index\n * @param {function} [callback] optional callback executed when the response from the\n * server is back.\n * @return {promise|undefined} if a callback is passed the method returns undefined\n * otherwise it returns a promise containing an object with two keys :\n *  - content with a SearchResults\n *  - state with the state used for the query as a SearchParameters\n * @example\n * // Changing the number of records returned per page to 1\n * // This example uses the callback API\n * var state = helper.searchOnce({hitsPerPage: 1},\n *   function(error, content, state) {\n *     // if an error occurred it will be passed in error, otherwise its value is null\n *     // content contains the results formatted as a SearchResults\n *     // state is the instance of SearchParameters used for this search\n *   });\n * @example\n * // Changing the number of records returned per page to 1\n * // This example uses the promise API\n * var state1 = helper.searchOnce({hitsPerPage: 1})\n *                 .then(promiseHandler);\n *\n * function promiseHandler(res) {\n *   // res contains\n *   // {\n *   //   content : SearchResults\n *   //   state   : SearchParameters (the one used for this specific search)\n *   // }\n * }\n */\nAlgoliaSearchHelper.prototype.searchOnce = function(options, cb) {\n  var tempState = !options ? this.state : this.state.setQueryParameters(options);\n  var queries = requestBuilder._getQueries(tempState.index, tempState);\n  var self = this;\n\n  this._currentNbQueries++;\n\n  this.emit('searchOnce', {\n    state: tempState\n  });\n\n  if (cb) {\n    this.client\n      .search(queries)\n      .then(function(content) {\n        self._currentNbQueries--;\n        if (self._currentNbQueries === 0) {\n          self.emit('searchQueueEmpty');\n        }\n\n        cb(null, new SearchResults(tempState, content.results), tempState);\n      })\n      .catch(function(err) {\n        self._currentNbQueries--;\n        if (self._currentNbQueries === 0) {\n          self.emit('searchQueueEmpty');\n        }\n\n        cb(err, null, tempState);\n      });\n\n    return undefined;\n  }\n\n  return this.client.search(queries).then(function(content) {\n    self._currentNbQueries--;\n    if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n    return {\n      content: new SearchResults(tempState, content.results),\n      state: tempState,\n      _originalResponse: content\n    };\n  }, function(e) {\n    self._currentNbQueries--;\n    if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n    throw e;\n  });\n};\n\n /**\n * Start the search for answers with the parameters set in the state.\n * This method returns a promise.\n * @param {Object} options - the options for answers API call\n * @param {string[]} options.attributesForPrediction - Attributes to use for predictions. If empty, `searchableAttributes` is used instead.\n * @param {string[]} options.queryLanguages - The languages in the query. Currently only supports ['en'].\n * @param {number} options.nbHits - Maximum number of answers to retrieve from the Answers Engine. Cannot be greater than 1000.\n *\n * @return {promise} the answer results\n */\nAlgoliaSearchHelper.prototype.findAnswers = function(options) {\n  var state = this.state;\n  var derivedHelper = this.derivedHelpers[0];\n  if (!derivedHelper) {\n    return Promise.resolve([]);\n  }\n  var derivedState = derivedHelper.getModifiedState(state);\n  var data = merge(\n    {\n      attributesForPrediction: options.attributesForPrediction,\n      nbHits: options.nbHits\n    },\n    {\n      params: omit(requestBuilder._getHitsSearchParams(derivedState), [\n        'attributesToSnippet',\n        'hitsPerPage',\n        'restrictSearchableAttributes',\n        'snippetEllipsisText' // FIXME remove this line once the engine is fixed.\n      ])\n    }\n  );\n\n  var errorMessage = 'search for answers was called, but this client does not have a function client.initIndex(index).findAnswers';\n  if (typeof this.client.initIndex !== 'function') {\n    throw new Error(errorMessage);\n  }\n  var index = this.client.initIndex(derivedState.index);\n  if (typeof index.findAnswers !== 'function') {\n    throw new Error(errorMessage);\n  }\n  return index.findAnswers(derivedState.query, options.queryLanguages, data);\n};\n\n/**\n * Structure of each result when using\n * [`searchForFacetValues()`](reference.html#AlgoliaSearchHelper#searchForFacetValues)\n * @typedef FacetSearchHit\n * @type {object}\n * @property {string} value the facet value\n * @property {string} highlighted the facet value highlighted with the query string\n * @property {number} count number of occurrence of this facet value\n * @property {boolean} isRefined true if the value is already refined\n */\n\n/**\n * Structure of the data resolved by the\n * [`searchForFacetValues()`](reference.html#AlgoliaSearchHelper#searchForFacetValues)\n * promise.\n * @typedef FacetSearchResult\n * @type {object}\n * @property {FacetSearchHit} facetHits the results for this search for facet values\n * @property {number} processingTimeMS time taken by the query inside the engine\n */\n\n/**\n * Search for facet values based on an query and the name of a faceted attribute. This\n * triggers a search and will return a promise. On top of using the query, it also sends\n * the parameters from the state so that the search is narrowed down to only the possible values.\n *\n * See the description of [FacetSearchResult](reference.html#FacetSearchResult)\n * @param {string} facet the name of the faceted attribute\n * @param {string} query the string query for the search\n * @param {number} [maxFacetHits] the maximum number values returned. Should be > 0 and <= 100\n * @param {object} [userState] the set of custom parameters to use on top of the current state. Setting a property to `undefined` removes\n * it in the generated query.\n * @return {promise.<FacetSearchResult>} the results of the search\n */\nAlgoliaSearchHelper.prototype.searchForFacetValues = function(facet, query, maxFacetHits, userState) {\n  var clientHasSFFV = typeof this.client.searchForFacetValues === 'function';\n  var clientHasInitIndex = typeof this.client.initIndex === 'function';\n  if (\n    !clientHasSFFV &&\n    !clientHasInitIndex &&\n    typeof this.client.search !== 'function'\n  ) {\n    throw new Error(\n      'search for facet values (searchable) was called, but this client does not have a function client.searchForFacetValues or client.initIndex(index).searchForFacetValues'\n    );\n  }\n\n  var state = this.state.setQueryParameters(userState || {});\n  var isDisjunctive = state.isDisjunctiveFacet(facet);\n  var algoliaQuery = requestBuilder.getSearchForFacetQuery(facet, query, maxFacetHits, state);\n\n  this._currentNbQueries++;\n  var self = this;\n  var searchForFacetValuesPromise;\n  // newer algoliasearch ^3.27.1 - ~4.0.0\n  if (clientHasSFFV) {\n    searchForFacetValuesPromise = this.client.searchForFacetValues([\n      {indexName: state.index, params: algoliaQuery}\n    ]);\n    // algoliasearch < 3.27.1\n  } else if (clientHasInitIndex) {\n    searchForFacetValuesPromise = this.client\n      .initIndex(state.index)\n      .searchForFacetValues(algoliaQuery);\n    // algoliasearch ~5.0.0\n  } else {\n    // @MAJOR only use client.search\n    delete algoliaQuery.facetName;\n    searchForFacetValuesPromise = this.client\n      .search([\n        {\n          type: 'facet',\n          facet: facet,\n          indexName: state.index,\n          params: algoliaQuery\n        }\n      ])\n      .then(function processResponse(response) {\n        return response.results[0];\n      });\n  }\n\n  this.emit('searchForFacetValues', {\n    state: state,\n    facet: facet,\n    query: query\n  });\n\n  return searchForFacetValuesPromise.then(function addIsRefined(content) {\n    self._currentNbQueries--;\n    if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n\n    content = Array.isArray(content) ? content[0] : content;\n\n    content.facetHits.forEach(function(f) {\n      f.escapedValue = escapeFacetValue(f.value);\n      f.isRefined = isDisjunctive\n        ? state.isDisjunctiveFacetRefined(facet, f.escapedValue)\n        : state.isFacetRefined(facet, f.escapedValue);\n    });\n\n    return content;\n  }, function(e) {\n    self._currentNbQueries--;\n    if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n    throw e;\n  });\n};\n\n/**\n * Sets the text query used for the search.\n *\n * This method resets the current page to 0.\n * @param  {string} q the user query\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.setQuery = function(q) {\n  this._change({\n    state: this.state.resetPage().setQuery(q),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * Remove all the types of refinements except tags. A string can be provided to remove\n * only the refinements of a specific attribute. For more advanced use case, you can\n * provide a function instead. This function should follow the\n * [clearCallback definition](#SearchParameters.clearCallback).\n *\n * This method resets the current page to 0.\n * @param {string} [name] optional name of the facet / attribute on which we want to remove all refinements\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n * @example\n * // Removing all the refinements\n * helper.clearRefinements().search();\n * @example\n * // Removing all the filters on a the category attribute.\n * helper.clearRefinements('category').search();\n * @example\n * // Removing only the exclude filters on the category facet.\n * helper.clearRefinements(function(value, attribute, type) {\n *   return type === 'exclude' && attribute === 'category';\n * }).search();\n */\nAlgoliaSearchHelper.prototype.clearRefinements = function(name) {\n  this._change({\n    state: this.state.resetPage().clearRefinements(name),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * Remove all the tag filters.\n *\n * This method resets the current page to 0.\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.clearTags = function() {\n  this._change({\n    state: this.state.resetPage().clearTags(),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * Adds a disjunctive filter to a faceted attribute with the `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value (will be converted to string)\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.addDisjunctiveFacetRefinement = function(facet, value) {\n  this._change({\n    state: this.state.resetPage().addDisjunctiveFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addDisjunctiveFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.addDisjunctiveRefine = function() {\n  return this.addDisjunctiveFacetRefinement.apply(this, arguments);\n};\n\n/**\n * Adds a refinement on a hierarchical facet. It will throw\n * an exception if the facet is not defined or if the facet\n * is already refined.\n *\n * This method resets the current page to 0.\n * @param {string} facet the facet name\n * @param {string} path the hierarchical facet path\n * @return {AlgoliaSearchHelper}\n * @throws Error if the facet is not defined or if the facet is refined\n * @chainable\n * @fires change\n */\nAlgoliaSearchHelper.prototype.addHierarchicalFacetRefinement = function(facet, value) {\n  this._change({\n    state: this.state.resetPage().addHierarchicalFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * Adds a an numeric filter to an attribute with the `operator` and `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} attribute the attribute on which the numeric filter applies\n * @param  {string} operator the operator of the filter\n * @param  {number} value the value of the filter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.addNumericRefinement = function(attribute, operator, value) {\n  this._change({\n    state: this.state.resetPage().addNumericRefinement(attribute, operator, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * Adds a filter to a faceted attribute with the `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value (will be converted to string)\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.addFacetRefinement = function(facet, value) {\n  this._change({\n    state: this.state.resetPage().addFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.addRefine = function() {\n  return this.addFacetRefinement.apply(this, arguments);\n};\n\n\n/**\n * Adds a an exclusion filter to a faceted attribute with the `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value (will be converted to string)\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.addFacetExclusion = function(facet, value) {\n  this._change({\n    state: this.state.resetPage().addExcludeRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetExclusion}\n */\nAlgoliaSearchHelper.prototype.addExclude = function() {\n  return this.addFacetExclusion.apply(this, arguments);\n};\n\n/**\n * Adds a tag filter with the `tag` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param {string} tag the tag to add to the filter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.addTag = function(tag) {\n  this._change({\n    state: this.state.resetPage().addTagRefinement(tag),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * Removes an numeric filter to an attribute with the `operator` and `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * Some parameters are optional, triggering different behavior:\n *  - if the value is not provided, then all the numeric value will be removed for the\n *  specified attribute/operator couple.\n *  - if the operator is not provided either, then all the numeric filter on this attribute\n *  will be removed.\n *\n * This method resets the current page to 0.\n * @param  {string} attribute the attribute on which the numeric filter applies\n * @param  {string} [operator] the operator of the filter\n * @param  {number} [value] the value of the filter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.removeNumericRefinement = function(attribute, operator, value) {\n  this._change({\n    state: this.state.resetPage().removeNumericRefinement(attribute, operator, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * Removes a disjunctive filter to a faceted attribute with the `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * If the value is omitted, then this method will remove all the filters for the\n * attribute.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} [value] the associated value\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.removeDisjunctiveFacetRefinement = function(facet, value) {\n  this._change({\n    state: this.state.resetPage().removeDisjunctiveFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeDisjunctiveFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.removeDisjunctiveRefine = function() {\n  return this.removeDisjunctiveFacetRefinement.apply(this, arguments);\n};\n\n/**\n * Removes the refinement set on a hierarchical facet.\n * @param {string} facet the facet name\n * @return {AlgoliaSearchHelper}\n * @throws Error if the facet is not defined or if the facet is not refined\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.removeHierarchicalFacetRefinement = function(facet) {\n  this._change({\n    state: this.state.resetPage().removeHierarchicalFacetRefinement(facet),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * Removes a filter to a faceted attribute with the `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * If the value is omitted, then this method will remove all the filters for the\n * attribute.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} [value] the associated value\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.removeFacetRefinement = function(facet, value) {\n  this._change({\n    state: this.state.resetPage().removeFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.removeRefine = function() {\n  return this.removeFacetRefinement.apply(this, arguments);\n};\n\n/**\n * Removes an exclusion filter to a faceted attribute with the `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * If the value is omitted, then this method will remove all the filters for the\n * attribute.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} [value] the associated value\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.removeFacetExclusion = function(facet, value) {\n  this._change({\n    state: this.state.resetPage().removeExcludeRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetExclusion}\n */\nAlgoliaSearchHelper.prototype.removeExclude = function() {\n  return this.removeFacetExclusion.apply(this, arguments);\n};\n\n/**\n * Removes a tag filter with the `tag` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param {string} tag tag to remove from the filter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.removeTag = function(tag) {\n  this._change({\n    state: this.state.resetPage().removeTagRefinement(tag),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * Adds or removes an exclusion filter to a faceted attribute with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.toggleFacetExclusion = function(facet, value) {\n  this._change({\n    state: this.state.resetPage().toggleExcludeFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetExclusion}\n */\nAlgoliaSearchHelper.prototype.toggleExclude = function() {\n  return this.toggleFacetExclusion.apply(this, arguments);\n};\n\n/**\n * Adds or removes a filter to a faceted attribute with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method can be used for conjunctive, disjunctive and hierarchical filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value\n * @return {AlgoliaSearchHelper}\n * @throws Error will throw an error if the facet is not declared in the settings of the helper\n * @fires change\n * @chainable\n * @deprecated since version 2.19.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.toggleRefinement = function(facet, value) {\n  return this.toggleFacetRefinement(facet, value);\n};\n\n/**\n * Adds or removes a filter to a faceted attribute with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method can be used for conjunctive, disjunctive and hierarchical filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value\n * @return {AlgoliaSearchHelper}\n * @throws Error will throw an error if the facet is not declared in the settings of the helper\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.toggleFacetRefinement = function(facet, value) {\n  this._change({\n    state: this.state.resetPage().toggleFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.toggleRefine = function() {\n  return this.toggleFacetRefinement.apply(this, arguments);\n};\n\n/**\n * Adds or removes a tag filter with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method resets the current page to 0.\n * @param {string} tag tag to remove or add\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.toggleTag = function(tag) {\n  this._change({\n    state: this.state.resetPage().toggleTagRefinement(tag),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * Increments the page number by one.\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n * @example\n * helper.setPage(0).nextPage().getPage();\n * // returns 1\n */\nAlgoliaSearchHelper.prototype.nextPage = function() {\n  var page = this.state.page || 0;\n  return this.setPage(page + 1);\n};\n\n/**\n * Decrements the page number by one.\n * @fires change\n * @return {AlgoliaSearchHelper}\n * @chainable\n * @example\n * helper.setPage(1).previousPage().getPage();\n * // returns 0\n */\nAlgoliaSearchHelper.prototype.previousPage = function() {\n  var page = this.state.page || 0;\n  return this.setPage(page - 1);\n};\n\n/**\n * @private\n */\nfunction setCurrentPage(page) {\n  if (page < 0) throw new Error('Page requested below 0.');\n\n  this._change({\n    state: this.state.setPage(page),\n    isPageReset: false\n  });\n\n  return this;\n}\n\n/**\n * Change the current page\n * @deprecated\n * @param  {number} page The page number\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.setCurrentPage = setCurrentPage;\n\n/**\n * Updates the current page.\n * @function\n * @param  {number} page The page number\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.setPage = setCurrentPage;\n\n/**\n * Updates the name of the index that will be targeted by the query.\n *\n * This method resets the current page to 0.\n * @param {string} name the index name\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.setIndex = function(name) {\n  this._change({\n    state: this.state.resetPage().setIndex(name),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * Update a parameter of the search. This method reset the page\n *\n * The complete list of parameters is available on the\n * [Algolia website](https://www.algolia.com/doc/rest#query-an-index).\n * The most commonly used parameters have their own [shortcuts](#query-parameters-shortcuts)\n * or benefit from higher-level APIs (all the kind of filters and facets have their own API)\n *\n * This method resets the current page to 0.\n * @param {string} parameter name of the parameter to update\n * @param {any} value new value of the parameter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n * @example\n * helper.setQueryParameter('hitsPerPage', 20).search();\n */\nAlgoliaSearchHelper.prototype.setQueryParameter = function(parameter, value) {\n  this._change({\n    state: this.state.resetPage().setQueryParameter(parameter, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n\n/**\n * Set the whole state (warning: will erase previous state)\n * @param {SearchParameters} newState the whole new state\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.setState = function(newState) {\n  this._change({\n    state: SearchParameters.make(newState),\n    isPageReset: false\n  });\n\n  return this;\n};\n\n/**\n * Override the current state without triggering a change event.\n * Do not use this method unless you know what you are doing. (see the example\n * for a legit use case)\n * @param {SearchParameters} newState the whole new state\n * @return {AlgoliaSearchHelper}\n * @example\n *  helper.on('change', function(state){\n *    // In this function you might want to find a way to store the state in the url/history\n *    updateYourURL(state)\n *  })\n *  window.onpopstate = function(event){\n *    // This is naive though as you should check if the state is really defined etc.\n *    helper.overrideStateWithoutTriggeringChangeEvent(event.state).search()\n *  }\n * @chainable\n */\nAlgoliaSearchHelper.prototype.overrideStateWithoutTriggeringChangeEvent = function(newState) {\n  this.state = new SearchParameters(newState);\n  return this;\n};\n\n/**\n * Check if an attribute has any numeric, conjunctive, disjunctive or hierarchical filters.\n * @param {string} attribute the name of the attribute\n * @return {boolean} true if the attribute is filtered by at least one value\n * @example\n * // hasRefinements works with numeric, conjunctive, disjunctive and hierarchical filters\n * helper.hasRefinements('price'); // false\n * helper.addNumericRefinement('price', '>', 100);\n * helper.hasRefinements('price'); // true\n *\n * helper.hasRefinements('color'); // false\n * helper.addFacetRefinement('color', 'blue');\n * helper.hasRefinements('color'); // true\n *\n * helper.hasRefinements('material'); // false\n * helper.addDisjunctiveFacetRefinement('material', 'plastic');\n * helper.hasRefinements('material'); // true\n *\n * helper.hasRefinements('categories'); // false\n * helper.toggleFacetRefinement('categories', 'kitchen > knife');\n * helper.hasRefinements('categories'); // true\n *\n */\nAlgoliaSearchHelper.prototype.hasRefinements = function(attribute) {\n  if (objectHasKeys(this.state.getNumericRefinements(attribute))) {\n    return true;\n  } else if (this.state.isConjunctiveFacet(attribute)) {\n    return this.state.isFacetRefined(attribute);\n  } else if (this.state.isDisjunctiveFacet(attribute)) {\n    return this.state.isDisjunctiveFacetRefined(attribute);\n  } else if (this.state.isHierarchicalFacet(attribute)) {\n    return this.state.isHierarchicalFacetRefined(attribute);\n  }\n\n  // there's currently no way to know that the user did call `addNumericRefinement` at some point\n  // thus we cannot distinguish if there once was a numeric refinement that was cleared\n  // so we will return false in every other situations to be consistent\n  // while what we should do here is throw because we did not find the attribute in any type\n  // of refinement\n  return false;\n};\n\n/**\n * Check if a value is excluded for a specific faceted attribute. If the value\n * is omitted then the function checks if there is any excluding refinements.\n *\n * @param  {string}  facet name of the attribute for used for faceting\n * @param  {string}  [value] optional value. If passed will test that this value\n   * is filtering the given facet.\n * @return {boolean} true if refined\n * @example\n * helper.isExcludeRefined('color'); // false\n * helper.isExcludeRefined('color', 'blue') // false\n * helper.isExcludeRefined('color', 'red') // false\n *\n * helper.addFacetExclusion('color', 'red');\n *\n * helper.isExcludeRefined('color'); // true\n * helper.isExcludeRefined('color', 'blue') // false\n * helper.isExcludeRefined('color', 'red') // true\n */\nAlgoliaSearchHelper.prototype.isExcluded = function(facet, value) {\n  return this.state.isExcludeRefined(facet, value);\n};\n\n/**\n * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasRefinements}\n */\nAlgoliaSearchHelper.prototype.isDisjunctiveRefined = function(facet, value) {\n  return this.state.isDisjunctiveFacetRefined(facet, value);\n};\n\n/**\n * Check if the string is a currently filtering tag.\n * @param {string} tag tag to check\n * @return {boolean}\n */\nAlgoliaSearchHelper.prototype.hasTag = function(tag) {\n  return this.state.isTagRefined(tag);\n};\n\n/**\n * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasTag}\n */\nAlgoliaSearchHelper.prototype.isTagRefined = function() {\n  return this.hasTagRefinements.apply(this, arguments);\n};\n\n\n/**\n * Get the name of the currently used index.\n * @return {string}\n * @example\n * helper.setIndex('highestPrice_products').getIndex();\n * // returns 'highestPrice_products'\n */\nAlgoliaSearchHelper.prototype.getIndex = function() {\n  return this.state.index;\n};\n\nfunction getCurrentPage() {\n  return this.state.page;\n}\n\n/**\n * Get the currently selected page\n * @deprecated\n * @return {number} the current page\n */\nAlgoliaSearchHelper.prototype.getCurrentPage = getCurrentPage;\n/**\n * Get the currently selected page\n * @function\n * @return {number} the current page\n */\nAlgoliaSearchHelper.prototype.getPage = getCurrentPage;\n\n/**\n * Get all the tags currently set to filters the results.\n *\n * @return {string[]} The list of tags currently set.\n */\nAlgoliaSearchHelper.prototype.getTags = function() {\n  return this.state.tagRefinements;\n};\n\n/**\n * Get the list of refinements for a given attribute. This method works with\n * conjunctive, disjunctive, excluding and numerical filters.\n *\n * See also SearchResults#getRefinements\n *\n * @param {string} facetName attribute name used for faceting\n * @return {Array.<FacetRefinement|NumericRefinement>} All Refinement are objects that contain a value, and\n * a type. Numeric also contains an operator.\n * @example\n * helper.addNumericRefinement('price', '>', 100);\n * helper.getRefinements('price');\n * // [\n * //   {\n * //     \"value\": [\n * //       100\n * //     ],\n * //     \"operator\": \">\",\n * //     \"type\": \"numeric\"\n * //   }\n * // ]\n * @example\n * helper.addFacetRefinement('color', 'blue');\n * helper.addFacetExclusion('color', 'red');\n * helper.getRefinements('color');\n * // [\n * //   {\n * //     \"value\": \"blue\",\n * //     \"type\": \"conjunctive\"\n * //   },\n * //   {\n * //     \"value\": \"red\",\n * //     \"type\": \"exclude\"\n * //   }\n * // ]\n * @example\n * helper.addDisjunctiveFacetRefinement('material', 'plastic');\n * // [\n * //   {\n * //     \"value\": \"plastic\",\n * //     \"type\": \"disjunctive\"\n * //   }\n * // ]\n */\nAlgoliaSearchHelper.prototype.getRefinements = function(facetName) {\n  var refinements = [];\n\n  if (this.state.isConjunctiveFacet(facetName)) {\n    var conjRefinements = this.state.getConjunctiveRefinements(facetName);\n\n    conjRefinements.forEach(function(r) {\n      refinements.push({\n        value: r,\n        type: 'conjunctive'\n      });\n    });\n\n    var excludeRefinements = this.state.getExcludeRefinements(facetName);\n\n    excludeRefinements.forEach(function(r) {\n      refinements.push({\n        value: r,\n        type: 'exclude'\n      });\n    });\n  } else if (this.state.isDisjunctiveFacet(facetName)) {\n    var disjRefinements = this.state.getDisjunctiveRefinements(facetName);\n\n    disjRefinements.forEach(function(r) {\n      refinements.push({\n        value: r,\n        type: 'disjunctive'\n      });\n    });\n  }\n\n  var numericRefinements = this.state.getNumericRefinements(facetName);\n\n  Object.keys(numericRefinements).forEach(function(operator) {\n    var value = numericRefinements[operator];\n\n    refinements.push({\n      value: value,\n      operator: operator,\n      type: 'numeric'\n    });\n  });\n\n  return refinements;\n};\n\n/**\n * Return the current refinement for the (attribute, operator)\n * @param {string} attribute attribute in the record\n * @param {string} operator operator applied on the refined values\n * @return {Array.<number|number[]>} refined values\n */\nAlgoliaSearchHelper.prototype.getNumericRefinement = function(attribute, operator) {\n  return this.state.getNumericRefinement(attribute, operator);\n};\n\n/**\n * Get the current breadcrumb for a hierarchical facet, as an array\n * @param  {string} facetName Hierarchical facet name\n * @return {array.<string>} the path as an array of string\n */\nAlgoliaSearchHelper.prototype.getHierarchicalFacetBreadcrumb = function(facetName) {\n  return this.state.getHierarchicalFacetBreadcrumb(facetName);\n};\n\n// /////////// PRIVATE\n\n/**\n * Perform the underlying queries\n * @private\n * @return {undefined}\n * @fires search\n * @fires result\n * @fires error\n */\nAlgoliaSearchHelper.prototype._search = function(options) {\n  var state = this.state;\n  var states = [];\n  var mainQueries = [];\n\n  if (!options.onlyWithDerivedHelpers) {\n    mainQueries = requestBuilder._getQueries(state.index, state);\n\n    states.push({\n      state: state,\n      queriesCount: mainQueries.length,\n      helper: this\n    });\n\n    this.emit('search', {\n      state: state,\n      results: this.lastResults\n    });\n  }\n\n  var derivedQueries = this.derivedHelpers.map(function(derivedHelper) {\n    var derivedState = derivedHelper.getModifiedState(state);\n    var derivedStateQueries = requestBuilder._getQueries(derivedState.index, derivedState);\n\n    states.push({\n      state: derivedState,\n      queriesCount: derivedStateQueries.length,\n      helper: derivedHelper\n    });\n\n    derivedHelper.emit('search', {\n      state: derivedState,\n      results: derivedHelper.lastResults\n    });\n\n    return derivedStateQueries;\n  });\n\n  var queries = Array.prototype.concat.apply(mainQueries, derivedQueries);\n  var queryId = this._queryId++;\n\n  this._currentNbQueries++;\n\n  try {\n    this.client.search(queries)\n      .then(this._dispatchAlgoliaResponse.bind(this, states, queryId))\n      .catch(this._dispatchAlgoliaError.bind(this, queryId));\n  } catch (error) {\n    // If we reach this part, we're in an internal error state\n    this.emit('error', {\n      error: error\n    });\n  }\n};\n\n/**\n * Transform the responses as sent by the server and transform them into a user\n * usable object that merge the results of all the batch requests. It will dispatch\n * over the different helper + derived helpers (when there are some).\n * @private\n * @param {array.<{SearchParameters, AlgoliaQueries, AlgoliaSearchHelper}>}\n *  state state used for to generate the request\n * @param {number} queryId id of the current request\n * @param {object} content content of the response\n * @return {undefined}\n */\nAlgoliaSearchHelper.prototype._dispatchAlgoliaResponse = function(states, queryId, content) {\n  // FIXME remove the number of outdated queries discarded instead of just one\n\n  if (queryId < this._lastQueryIdReceived) {\n    // Outdated answer\n    return;\n  }\n\n  this._currentNbQueries -= (queryId - this._lastQueryIdReceived);\n  this._lastQueryIdReceived = queryId;\n\n  if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');\n\n  var results = content.results.slice();\n\n  states.forEach(function(s) {\n    var state = s.state;\n    var queriesCount = s.queriesCount;\n    var helper = s.helper;\n    var specificResults = results.splice(0, queriesCount);\n\n    var formattedResponse = helper.lastResults = new SearchResults(state, specificResults);\n\n    helper.emit('result', {\n      results: formattedResponse,\n      state: state\n    });\n  });\n};\n\nAlgoliaSearchHelper.prototype._dispatchAlgoliaError = function(queryId, error) {\n  if (queryId < this._lastQueryIdReceived) {\n    // Outdated answer\n    return;\n  }\n\n  this._currentNbQueries -= queryId - this._lastQueryIdReceived;\n  this._lastQueryIdReceived = queryId;\n\n  this.emit('error', {\n    error: error\n  });\n\n  if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');\n};\n\nAlgoliaSearchHelper.prototype.containsRefinement = function(query, facetFilters, numericFilters, tagFilters) {\n  return query ||\n    facetFilters.length !== 0 ||\n    numericFilters.length !== 0 ||\n    tagFilters.length !== 0;\n};\n\n/**\n * Test if there are some disjunctive refinements on the facet\n * @private\n * @param {string} facet the attribute to test\n * @return {boolean}\n */\nAlgoliaSearchHelper.prototype._hasDisjunctiveRefinements = function(facet) {\n  return this.state.disjunctiveRefinements[facet] &&\n    this.state.disjunctiveRefinements[facet].length > 0;\n};\n\nAlgoliaSearchHelper.prototype._change = function(event) {\n  var state = event.state;\n  var isPageReset = event.isPageReset;\n\n  if (state !== this.state) {\n    this.state = state;\n\n    this.emit('change', {\n      state: this.state,\n      results: this.lastResults,\n      isPageReset: isPageReset\n    });\n  }\n};\n\n/**\n * Clears the cache of the underlying Algolia client.\n * @return {AlgoliaSearchHelper}\n */\nAlgoliaSearchHelper.prototype.clearCache = function() {\n  this.client.clearCache && this.client.clearCache();\n  return this;\n};\n\n/**\n * Updates the internal client instance. If the reference of the clients\n * are equal then no update is actually done.\n * @param  {AlgoliaSearch} newClient an AlgoliaSearch client\n * @return {AlgoliaSearchHelper}\n */\nAlgoliaSearchHelper.prototype.setClient = function(newClient) {\n  if (this.client === newClient) return this;\n\n  if (typeof newClient.addAlgoliaAgent === 'function') {\n    newClient.addAlgoliaAgent('JS Helper (' + version + ')');\n  }\n  this.client = newClient;\n\n  return this;\n};\n\n/**\n * Gets the instance of the currently used client.\n * @return {AlgoliaSearch}\n */\nAlgoliaSearchHelper.prototype.getClient = function() {\n  return this.client;\n};\n\n/**\n * Creates an derived instance of the Helper. A derived helper\n * is a way to request other indices synchronised with the lifecycle\n * of the main Helper. This mechanism uses the multiqueries feature\n * of Algolia to aggregate all the requests in a single network call.\n *\n * This method takes a function that is used to create a new SearchParameter\n * that will be used to create requests to Algolia. Those new requests\n * are created just before the `search` event. The signature of the function\n * is `SearchParameters -> SearchParameters`.\n *\n * This method returns a new DerivedHelper which is an EventEmitter\n * that fires the same `search`, `result` and `error` events. Those\n * events, however, will receive data specific to this DerivedHelper\n * and the SearchParameters that is returned by the call of the\n * parameter function.\n * @param {function} fn SearchParameters -> SearchParameters\n * @return {DerivedHelper}\n */\nAlgoliaSearchHelper.prototype.derive = function(fn) {\n  var derivedHelper = new DerivedHelper(this, fn);\n  this.derivedHelpers.push(derivedHelper);\n  return derivedHelper;\n};\n\n/**\n * This method detaches a derived Helper from the main one. Prefer using the one from the\n * derived helper itself, to remove the event listeners too.\n * @private\n * @return {undefined}\n * @throws Error\n */\nAlgoliaSearchHelper.prototype.detachDerivedHelper = function(derivedHelper) {\n  var pos = this.derivedHelpers.indexOf(derivedHelper);\n  if (pos === -1) throw new Error('Derived helper already detached');\n  this.derivedHelpers.splice(pos, 1);\n};\n\n/**\n * This method returns true if there is currently at least one on-going search.\n * @return {boolean} true if there is a search pending\n */\nAlgoliaSearchHelper.prototype.hasPendingRequests = function() {\n  return this._currentNbQueries > 0;\n};\n\n/**\n * @typedef AlgoliaSearchHelper.NumericRefinement\n * @type {object}\n * @property {number[]} value the numbers that are used for filtering this attribute with\n * the operator specified.\n * @property {string} operator the faceting data: value, number of entries\n * @property {string} type will be 'numeric'\n */\n\n/**\n * @typedef AlgoliaSearchHelper.FacetRefinement\n * @type {object}\n * @property {string} value the string use to filter the attribute\n * @property {string} type the type of filter: 'conjunctive', 'disjunctive', 'exclude'\n */\n\nmodule.exports = AlgoliaSearchHelper;\n","'use strict';\n\nmodule.exports = function compact(array) {\n  if (!Array.isArray(array)) {\n    return [];\n  }\n\n  return array.filter(Boolean);\n};\n","'use strict';\n\n// NOTE: this behaves like lodash/defaults, but doesn't mutate the target\n// it also preserve keys order\nmodule.exports = function defaultsPure() {\n  var sources = Array.prototype.slice.call(arguments);\n\n  return sources.reduceRight(function(acc, source) {\n    Object.keys(Object(source)).forEach(function(key) {\n      if (source[key] === undefined) {\n        return;\n      }\n      if (acc[key] !== undefined) {\n        // remove if already added, so that we can add it in correct order\n        delete acc[key];\n      }\n      acc[key] = source[key];\n    });\n    return acc;\n  }, {});\n};\n","'use strict';\n\n/**\n * Replaces a leading - with \\-\n * @private\n * @param {any} value the facet value to replace\n * @returns any\n */\nfunction escapeFacetValue(value) {\n  if (typeof value !== 'string') return value;\n\n  return String(value).replace(/^-/, '\\\\-');\n}\n\n/**\n * Replaces a leading \\- with -\n * @private\n * @param {any} value the escaped facet value\n * @returns any\n */\nfunction unescapeFacetValue(value) {\n  if (typeof value !== 'string') return value;\n\n  return value.replace(/^\\\\-/, '-');\n}\n\nmodule.exports = {\n  escapeFacetValue: escapeFacetValue,\n  unescapeFacetValue: unescapeFacetValue\n};\n","'use strict';\n\n// @MAJOR can be replaced by native Array#find when we change support\nmodule.exports = function find(array, comparator) {\n  if (!Array.isArray(array)) {\n    return undefined;\n  }\n\n  for (var i = 0; i < array.length; i++) {\n    if (comparator(array[i])) {\n      return array[i];\n    }\n  }\n};\n","'use strict';\n\n// @MAJOR can be replaced by native Array#findIndex when we change support\nmodule.exports = function find(array, comparator) {\n  if (!Array.isArray(array)) {\n    return -1;\n  }\n\n  for (var i = 0; i < array.length; i++) {\n    if (comparator(array[i])) {\n      return i;\n    }\n  }\n  return -1;\n};\n","'use strict';\n\nvar find = require('./find');\n\n/**\n * Transform sort format from user friendly notation to lodash format\n * @param {string[]} sortBy array of predicate of the form \"attribute:order\"\n * @param {string[]} [defaults] array of predicate of the form \"attribute:order\"\n * @return {array.<string[]>} array containing 2 elements : attributes, orders\n */\nmodule.exports = function formatSort(sortBy, defaults) {\n  var defaultInstructions = (defaults || []).map(function(sort) {\n    return sort.split(':');\n  });\n\n  return sortBy.reduce(\n    function preparePredicate(out, sort) {\n      var sortInstruction = sort.split(':');\n\n      var matchingDefault = find(defaultInstructions, function(\n        defaultInstruction\n      ) {\n        return defaultInstruction[0] === sortInstruction[0];\n      });\n\n      if (sortInstruction.length > 1 || !matchingDefault) {\n        out[0].push(sortInstruction[0]);\n        out[1].push(sortInstruction[1]);\n        return out;\n      }\n\n      out[0].push(matchingDefault[0]);\n      out[1].push(matchingDefault[1]);\n      return out;\n    },\n    [[], []]\n  );\n};\n","'use strict';\n\nfunction inherits(ctor, superCtor) {\n  ctor.prototype = Object.create(superCtor.prototype, {\n    constructor: {\n      value: ctor,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n}\n\nmodule.exports = inherits;\n","'use strict';\n\nfunction intersection(arr1, arr2) {\n  return arr1.filter(function(value, index) {\n    return (\n      arr2.indexOf(value) > -1 &&\n      arr1.indexOf(value) === index /* skips duplicates */\n    );\n  });\n}\n\nmodule.exports = intersection;\n","'use strict';\n\nfunction clone(value) {\n  if (typeof value === 'object' && value !== null) {\n    return _merge(Array.isArray(value) ? [] : {}, value);\n  }\n  return value;\n}\n\nfunction isObjectOrArrayOrFunction(value) {\n  return (\n    typeof value === 'function' ||\n    Array.isArray(value) ||\n    Object.prototype.toString.call(value) === '[object Object]'\n  );\n}\n\nfunction _merge(target, source) {\n  if (target === source) {\n    return target;\n  }\n\n  for (var key in source) {\n    if (\n      !Object.prototype.hasOwnProperty.call(source, key) ||\n      key === '__proto__'\n    ) {\n      continue;\n    }\n\n    var sourceVal = source[key];\n    var targetVal = target[key];\n\n    if (typeof targetVal !== 'undefined' && typeof sourceVal === 'undefined') {\n      continue;\n    }\n\n    if (\n      isObjectOrArrayOrFunction(targetVal) &&\n      isObjectOrArrayOrFunction(sourceVal)\n    ) {\n      target[key] = _merge(targetVal, sourceVal);\n    } else {\n      target[key] = clone(sourceVal);\n    }\n  }\n  return target;\n}\n\n/**\n * This method is like Object.assign, but recursively merges own and inherited\n * enumerable keyed properties of source objects into the destination object.\n *\n * NOTE: this behaves like lodash/merge, but:\n * - does mutate functions if they are a source\n * - treats non-plain objects as plain\n * - does not work for circular objects\n * - treats sparse arrays as sparse\n * - does not convert Array-like objects (Arguments, NodeLists, etc.) to arrays\n *\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n */\n\nfunction merge(target) {\n  if (!isObjectOrArrayOrFunction(target)) {\n    target = {};\n  }\n\n  for (var i = 1, l = arguments.length; i < l; i++) {\n    var source = arguments[i];\n\n    if (isObjectOrArrayOrFunction(source)) {\n      _merge(target, source);\n    }\n  }\n  return target;\n}\n\nmodule.exports = merge;\n","'use strict';\n\nfunction objectHasKeys(obj) {\n  return obj && Object.keys(obj).length > 0;\n}\n\nmodule.exports = objectHasKeys;\n","'use strict';\n\n// https://github.com/babel/babel/blob/3aaafae053fa75febb3aa45d45b6f00646e30ba4/packages/babel-helpers/src/helpers.js#L604-L620\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source === null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key;\n  var i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}\n\nmodule.exports = _objectWithoutPropertiesLoose;\n","'use strict';\n\nfunction compareAscending(value, other) {\n  if (value !== other) {\n    var valIsDefined = value !== undefined;\n    var valIsNull = value === null;\n\n    var othIsDefined = other !== undefined;\n    var othIsNull = other === null;\n\n    if (\n      (!othIsNull && value > other) ||\n      (valIsNull && othIsDefined) ||\n      !valIsDefined\n    ) {\n      return 1;\n    }\n    if (\n      (!valIsNull && value < other) ||\n      (othIsNull && valIsDefined) ||\n      !othIsDefined\n    ) {\n      return -1;\n    }\n  }\n  return 0;\n}\n\n/**\n * @param {Array<object>} collection object with keys in attributes\n * @param {Array<string>} iteratees attributes\n * @param {Array<string>} orders asc | desc\n */\nfunction orderBy(collection, iteratees, orders) {\n  if (!Array.isArray(collection)) {\n    return [];\n  }\n\n  if (!Array.isArray(orders)) {\n    orders = [];\n  }\n\n  var result = collection.map(function(value, index) {\n    return {\n      criteria: iteratees.map(function(iteratee) {\n        return value[iteratee];\n      }),\n      index: index,\n      value: value\n    };\n  });\n\n  result.sort(function comparer(object, other) {\n    var index = -1;\n\n    while (++index < object.criteria.length) {\n      var res = compareAscending(object.criteria[index], other.criteria[index]);\n      if (res) {\n        if (index >= orders.length) {\n          return res;\n        }\n        if (orders[index] === 'desc') {\n          return -res;\n        }\n        return res;\n      }\n    }\n\n    // This ensures a stable sort in V8 and other engines.\n    // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.\n    return object.index - other.index;\n  });\n\n  return result.map(function(res) {\n    return res.value;\n  });\n}\n\nmodule.exports = orderBy;\n","'use strict';\n\nfunction valToNumber(v) {\n  if (typeof v === 'number') {\n    return v;\n  } else if (typeof v === 'string') {\n    return parseFloat(v);\n  } else if (Array.isArray(v)) {\n    return v.map(valToNumber);\n  }\n\n  throw new Error('The value should be a number, a parsable string or an array of those.');\n}\n\nmodule.exports = valToNumber;\n","'use strict';\n\nvar merge = require('./functions/merge');\n\nfunction sortObject(obj) {\n  return Object.keys(obj)\n    .sort(function(a, b) {\n      return a.localeCompare(b);\n    })\n    .reduce(function(acc, curr) {\n      acc[curr] = obj[curr];\n      return acc;\n    }, {});\n}\n\nvar requestBuilder = {\n  /**\n   * Get all the queries to send to the client, those queries can used directly\n   * with the Algolia client.\n   * @private\n   * @return {object[]} The queries\n   */\n  _getQueries: function getQueries(index, state) {\n    var queries = [];\n\n    // One query for the hits\n    queries.push({\n      indexName: index,\n      params: requestBuilder._getHitsSearchParams(state)\n    });\n\n    // One for each disjunctive facets\n    state.getRefinedDisjunctiveFacets().forEach(function(refinedFacet) {\n      queries.push({\n        indexName: index,\n        params: requestBuilder._getDisjunctiveFacetSearchParams(state, refinedFacet)\n      });\n    });\n\n    // More to get the parent levels of the hierarchical facets when refined\n    state.getRefinedHierarchicalFacets().forEach(function(refinedFacet) {\n      var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);\n      var currentRefinement = state.getHierarchicalRefinement(refinedFacet);\n      var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n      // If we are deeper than level 0 (starting from `beer > IPA`)\n      // we want to get all parent values\n      if (currentRefinement.length > 0 && currentRefinement[0].split(separator).length > 1) {\n        // We generate a map of the filters we will use for our facet values queries\n        var filtersMap = currentRefinement[0].split(separator).slice(0, -1).reduce(\n          function createFiltersMap(map, segment, level) {\n            return map.concat({\n              attribute: hierarchicalFacet.attributes[level],\n              value: level === 0\n                ? segment\n                : [map[map.length - 1].value, segment].join(separator)\n            });\n          }\n        , []);\n\n        filtersMap.forEach(function(filter, level) {\n          var params = requestBuilder._getDisjunctiveFacetSearchParams(\n            state,\n            filter.attribute,\n            level === 0\n          );\n\n          var parent = filtersMap[level - 1];\n          params.facetFilters = level > 0 ? [parent.attribute + ':' + parent.value] : undefined;\n\n          queries.push({indexName: index, params: params});\n        });\n      }\n    });\n\n    return queries;\n  },\n\n  /**\n   * Build search parameters used to fetch hits\n   * @private\n   * @return {object.<string, any>}\n   */\n  _getHitsSearchParams: function(state) {\n    var facets = state.facets\n      .concat(state.disjunctiveFacets)\n      .concat(requestBuilder._getHitsHierarchicalFacetsAttributes(state));\n\n\n    var facetFilters = requestBuilder._getFacetFilters(state);\n    var numericFilters = requestBuilder._getNumericFilters(state);\n    var tagFilters = requestBuilder._getTagFilters(state);\n    var additionalParams = {\n      facets: facets.indexOf('*') > -1 ? ['*'] : facets,\n      tagFilters: tagFilters\n    };\n\n    if (facetFilters.length > 0) {\n      additionalParams.facetFilters = facetFilters;\n    }\n\n    if (numericFilters.length > 0) {\n      additionalParams.numericFilters = numericFilters;\n    }\n\n    return sortObject(merge({}, state.getQueryParams(), additionalParams));\n  },\n\n  /**\n   * Build search parameters used to fetch a disjunctive facet\n   * @private\n   * @param  {string} facet the associated facet name\n   * @param  {boolean} hierarchicalRootLevel ?? FIXME\n   * @return {object}\n   */\n  _getDisjunctiveFacetSearchParams: function(state, facet, hierarchicalRootLevel) {\n    var facetFilters = requestBuilder._getFacetFilters(state, facet, hierarchicalRootLevel);\n    var numericFilters = requestBuilder._getNumericFilters(state, facet);\n    var tagFilters = requestBuilder._getTagFilters(state);\n    var additionalParams = {\n      hitsPerPage: 0,\n      page: 0,\n      analytics: false,\n      clickAnalytics: false\n    };\n\n    if (tagFilters.length > 0) {\n      additionalParams.tagFilters = tagFilters;\n    }\n\n    var hierarchicalFacet = state.getHierarchicalFacetByName(facet);\n\n    if (hierarchicalFacet) {\n      additionalParams.facets = requestBuilder._getDisjunctiveHierarchicalFacetAttribute(\n        state,\n        hierarchicalFacet,\n        hierarchicalRootLevel\n      );\n    } else {\n      additionalParams.facets = facet;\n    }\n\n    if (numericFilters.length > 0) {\n      additionalParams.numericFilters = numericFilters;\n    }\n\n    if (facetFilters.length > 0) {\n      additionalParams.facetFilters = facetFilters;\n    }\n\n    return sortObject(merge({}, state.getQueryParams(), additionalParams));\n  },\n\n  /**\n   * Return the numeric filters in an algolia request fashion\n   * @private\n   * @param {string} [facetName] the name of the attribute for which the filters should be excluded\n   * @return {string[]} the numeric filters in the algolia format\n   */\n  _getNumericFilters: function(state, facetName) {\n    if (state.numericFilters) {\n      return state.numericFilters;\n    }\n\n    var numericFilters = [];\n\n    Object.keys(state.numericRefinements).forEach(function(attribute) {\n      var operators = state.numericRefinements[attribute] || {};\n      Object.keys(operators).forEach(function(operator) {\n        var values = operators[operator] || [];\n        if (facetName !== attribute) {\n          values.forEach(function(value) {\n            if (Array.isArray(value)) {\n              var vs = value.map(function(v) {\n                return attribute + operator + v;\n              });\n              numericFilters.push(vs);\n            } else {\n              numericFilters.push(attribute + operator + value);\n            }\n          });\n        }\n      });\n    });\n\n    return numericFilters;\n  },\n\n  /**\n   * Return the tags filters depending\n   * @private\n   * @return {string}\n   */\n  _getTagFilters: function(state) {\n    if (state.tagFilters) {\n      return state.tagFilters;\n    }\n\n    return state.tagRefinements.join(',');\n  },\n\n\n  /**\n   * Build facetFilters parameter based on current refinements. The array returned\n   * contains strings representing the facet filters in the algolia format.\n   * @private\n   * @param  {string} [facet] if set, the current disjunctive facet\n   * @return {array.<string>}\n   */\n  _getFacetFilters: function(state, facet, hierarchicalRootLevel) {\n    var facetFilters = [];\n\n    var facetsRefinements = state.facetsRefinements || {};\n    Object.keys(facetsRefinements).forEach(function(facetName) {\n      var facetValues = facetsRefinements[facetName] || [];\n      facetValues.forEach(function(facetValue) {\n        facetFilters.push(facetName + ':' + facetValue);\n      });\n    });\n\n    var facetsExcludes = state.facetsExcludes || {};\n    Object.keys(facetsExcludes).forEach(function(facetName) {\n      var facetValues = facetsExcludes[facetName] || [];\n      facetValues.forEach(function(facetValue) {\n        facetFilters.push(facetName + ':-' + facetValue);\n      });\n    });\n\n    var disjunctiveFacetsRefinements = state.disjunctiveFacetsRefinements || {};\n    Object.keys(disjunctiveFacetsRefinements).forEach(function(facetName) {\n      var facetValues = disjunctiveFacetsRefinements[facetName] || [];\n      if (facetName === facet || !facetValues || facetValues.length === 0) {\n        return;\n      }\n      var orFilters = [];\n\n      facetValues.forEach(function(facetValue) {\n        orFilters.push(facetName + ':' + facetValue);\n      });\n\n      facetFilters.push(orFilters);\n    });\n\n    var hierarchicalFacetsRefinements = state.hierarchicalFacetsRefinements || {};\n    Object.keys(hierarchicalFacetsRefinements).forEach(function(facetName) {\n      var facetValues = hierarchicalFacetsRefinements[facetName] || [];\n      var facetValue = facetValues[0];\n\n      if (facetValue === undefined) {\n        return;\n      }\n\n      var hierarchicalFacet = state.getHierarchicalFacetByName(facetName);\n      var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n      var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);\n      var attributeToRefine;\n      var attributesIndex;\n\n      // we ask for parent facet values only when the `facet` is the current hierarchical facet\n      if (facet === facetName) {\n        // if we are at the root level already, no need to ask for facet values, we get them from\n        // the hits query\n        if (facetValue.indexOf(separator) === -1 || (!rootPath && hierarchicalRootLevel === true) ||\n          (rootPath && rootPath.split(separator).length === facetValue.split(separator).length)) {\n          return;\n        }\n\n        if (!rootPath) {\n          attributesIndex = facetValue.split(separator).length - 2;\n          facetValue = facetValue.slice(0, facetValue.lastIndexOf(separator));\n        } else {\n          attributesIndex = rootPath.split(separator).length - 1;\n          facetValue = rootPath;\n        }\n\n        attributeToRefine = hierarchicalFacet.attributes[attributesIndex];\n      } else {\n        attributesIndex = facetValue.split(separator).length - 1;\n\n        attributeToRefine = hierarchicalFacet.attributes[attributesIndex];\n      }\n\n      if (attributeToRefine) {\n        facetFilters.push([attributeToRefine + ':' + facetValue]);\n      }\n    });\n\n    return facetFilters;\n  },\n\n  _getHitsHierarchicalFacetsAttributes: function(state) {\n    var out = [];\n\n    return state.hierarchicalFacets.reduce(\n      // ask for as much levels as there's hierarchical refinements\n      function getHitsAttributesForHierarchicalFacet(allAttributes, hierarchicalFacet) {\n        var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0];\n\n        // if no refinement, ask for root level\n        if (!hierarchicalRefinement) {\n          allAttributes.push(hierarchicalFacet.attributes[0]);\n          return allAttributes;\n        }\n\n        var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n        var level = hierarchicalRefinement.split(separator).length;\n        var newAttributes = hierarchicalFacet.attributes.slice(0, level + 1);\n\n        return allAttributes.concat(newAttributes);\n      }, out);\n  },\n\n  _getDisjunctiveHierarchicalFacetAttribute: function(state, hierarchicalFacet, rootLevel) {\n    var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n    if (rootLevel === true) {\n      var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);\n      var attributeIndex = 0;\n\n      if (rootPath) {\n        attributeIndex = rootPath.split(separator).length;\n      }\n      return [hierarchicalFacet.attributes[attributeIndex]];\n    }\n\n    var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0] || '';\n    // if refinement is 'beers > IPA > Flying dog',\n    // then we want `facets: ['beers > IPA']` as disjunctive facet (parent level values)\n\n    var parentLevel = hierarchicalRefinement.split(separator).length - 1;\n    return hierarchicalFacet.attributes.slice(0, parentLevel + 1);\n  },\n\n  getSearchForFacetQuery: function(facetName, query, maxFacetHits, state) {\n    var stateForSearchForFacetValues = state.isDisjunctiveFacet(facetName) ?\n      state.clearRefinements(facetName) :\n      state;\n    var searchForFacetSearchParameters = {\n      facetQuery: query,\n      facetName: facetName\n    };\n    if (typeof maxFacetHits === 'number') {\n      searchForFacetSearchParameters.maxFacetHits = maxFacetHits;\n    }\n    return sortObject(merge(\n      {},\n      requestBuilder._getHitsSearchParams(stateForSearchForFacetValues),\n      searchForFacetSearchParameters\n    ));\n  }\n};\n\nmodule.exports = requestBuilder;\n","'use strict';\n\nmodule.exports = function isValidUserToken(userToken) {\n  if (userToken === null) {\n    return false;\n  }\n  return /^[a-zA-Z0-9_-]{1,64}$/.test(userToken);\n};\n","'use strict';\n\nmodule.exports = '3.10.0';\n","/*! algoliasearch.umd.js | 4.13.1 | © Algolia, inc. | https://github.com/algolia/algoliasearch-client-javascript */\n!function(t,e){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=e():\"function\"==typeof define&&define.amd?define(e):(t=t||self).algoliasearch=e()}(this,(function(){\"use strict\";function t(t,e,r){return e in t?Object.defineProperty(t,e,{value:r,enumerable:!0,configurable:!0,writable:!0}):t[e]=r,t}function e(t,e){var r=Object.keys(t);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(t);e&&(n=n.filter((function(e){return Object.getOwnPropertyDescriptor(t,e).enumerable}))),r.push.apply(r,n)}return r}function r(r){for(var n=1;n<arguments.length;n++){var a=null!=arguments[n]?arguments[n]:{};n%2?e(Object(a),!0).forEach((function(e){t(r,e,a[e])})):Object.getOwnPropertyDescriptors?Object.defineProperties(r,Object.getOwnPropertyDescriptors(a)):e(Object(a)).forEach((function(t){Object.defineProperty(r,t,Object.getOwnPropertyDescriptor(a,t))}))}return r}function n(t,e){if(null==t)return{};var r,n,a=function(t,e){if(null==t)return{};var r,n,a={},o=Object.keys(t);for(n=0;n<o.length;n++)r=o[n],e.indexOf(r)>=0||(a[r]=t[r]);return a}(t,e);if(Object.getOwnPropertySymbols){var o=Object.getOwnPropertySymbols(t);for(n=0;n<o.length;n++)r=o[n],e.indexOf(r)>=0||Object.prototype.propertyIsEnumerable.call(t,r)&&(a[r]=t[r])}return a}function a(t,e){return function(t){if(Array.isArray(t))return t}(t)||function(t,e){if(!(Symbol.iterator in Object(t)||\"[object Arguments]\"===Object.prototype.toString.call(t)))return;var r=[],n=!0,a=!1,o=void 0;try{for(var i,u=t[Symbol.iterator]();!(n=(i=u.next()).done)&&(r.push(i.value),!e||r.length!==e);n=!0);}catch(t){a=!0,o=t}finally{try{n||null==u.return||u.return()}finally{if(a)throw o}}return r}(t,e)||function(){throw new TypeError(\"Invalid attempt to destructure non-iterable instance\")}()}function o(t){return function(t){if(Array.isArray(t)){for(var e=0,r=new Array(t.length);e<t.length;e++)r[e]=t[e];return r}}(t)||function(t){if(Symbol.iterator in Object(t)||\"[object Arguments]\"===Object.prototype.toString.call(t))return Array.from(t)}(t)||function(){throw new TypeError(\"Invalid attempt to spread non-iterable instance\")}()}function i(t){var e,r=\"algoliasearch-client-js-\".concat(t.key),n=function(){return void 0===e&&(e=t.localStorage||window.localStorage),e},o=function(){return JSON.parse(n().getItem(r)||\"{}\")};return{get:function(t,e){var r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{miss:function(){return Promise.resolve()}};return Promise.resolve().then((function(){var r=JSON.stringify(t),n=o()[r];return Promise.all([n||e(),void 0!==n])})).then((function(t){var e=a(t,2),n=e[0],o=e[1];return Promise.all([n,o||r.miss(n)])})).then((function(t){return a(t,1)[0]}))},set:function(t,e){return Promise.resolve().then((function(){var a=o();return a[JSON.stringify(t)]=e,n().setItem(r,JSON.stringify(a)),e}))},delete:function(t){return Promise.resolve().then((function(){var e=o();delete e[JSON.stringify(t)],n().setItem(r,JSON.stringify(e))}))},clear:function(){return Promise.resolve().then((function(){n().removeItem(r)}))}}}function u(t){var e=o(t.caches),r=e.shift();return void 0===r?{get:function(t,e){var r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{miss:function(){return Promise.resolve()}},n=e();return n.then((function(t){return Promise.all([t,r.miss(t)])})).then((function(t){return a(t,1)[0]}))},set:function(t,e){return Promise.resolve(e)},delete:function(t){return Promise.resolve()},clear:function(){return Promise.resolve()}}:{get:function(t,n){var a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{miss:function(){return Promise.resolve()}};return r.get(t,n,a).catch((function(){return u({caches:e}).get(t,n,a)}))},set:function(t,n){return r.set(t,n).catch((function(){return u({caches:e}).set(t,n)}))},delete:function(t){return r.delete(t).catch((function(){return u({caches:e}).delete(t)}))},clear:function(){return r.clear().catch((function(){return u({caches:e}).clear()}))}}}function s(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{serializable:!0},e={};return{get:function(r,n){var a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{miss:function(){return Promise.resolve()}},o=JSON.stringify(r);if(o in e)return Promise.resolve(t.serializable?JSON.parse(e[o]):e[o]);var i=n(),u=a&&a.miss||function(){return Promise.resolve()};return i.then((function(t){return u(t)})).then((function(){return i}))},set:function(r,n){return e[JSON.stringify(r)]=t.serializable?JSON.stringify(n):n,Promise.resolve(n)},delete:function(t){return delete e[JSON.stringify(t)],Promise.resolve()},clear:function(){return e={},Promise.resolve()}}}function c(t,e,r){var n={\"x-algolia-api-key\":r,\"x-algolia-application-id\":e};return{headers:function(){return t===m.WithinHeaders?n:{}},queryParameters:function(){return t===m.WithinQueryParameters?n:{}}}}function f(t){var e=0;return t((function r(){return e++,new Promise((function(n){setTimeout((function(){n(t(r))}),Math.min(100*e,1e3))}))}))}function d(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:function(t,e){return Promise.resolve()};return Object.assign(t,{wait:function(r){return d(t.then((function(t){return Promise.all([e(t,r),t])})).then((function(t){return t[1]})))}})}function l(t){for(var e=t.length-1;e>0;e--){var r=Math.floor(Math.random()*(e+1)),n=t[e];t[e]=t[r],t[r]=n}return t}function p(t,e){return e?(Object.keys(e).forEach((function(r){t[r]=e[r](t)})),t):t}function h(t){for(var e=arguments.length,r=new Array(e>1?e-1:0),n=1;n<e;n++)r[n-1]=arguments[n];var a=0;return t.replace(/%s/g,(function(){return encodeURIComponent(r[a++])}))}var m={WithinQueryParameters:0,WithinHeaders:1};function y(t,e){var r=t||{},n=r.data||{};return Object.keys(r).forEach((function(t){-1===[\"timeout\",\"headers\",\"queryParameters\",\"data\",\"cacheable\"].indexOf(t)&&(n[t]=r[t])})),{data:Object.entries(n).length>0?n:void 0,timeout:r.timeout||e,headers:r.headers||{},queryParameters:r.queryParameters||{},cacheable:r.cacheable}}var g={Read:1,Write:2,Any:3},v=1,b=2,P=3;function w(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:v;return r(r({},t),{},{status:e,lastUpdate:Date.now()})}function O(t){return\"string\"==typeof t?{protocol:\"https\",url:t,accept:g.Any}:{protocol:t.protocol||\"https\",url:t.url,accept:t.accept||g.Any}}var I=\"DELETE\",x=\"GET\",j=\"POST\",D=\"PUT\";function q(t,e){return Promise.all(e.map((function(e){return t.get(e,(function(){return Promise.resolve(w(e))}))}))).then((function(t){var r=t.filter((function(t){return function(t){return t.status===v||Date.now()-t.lastUpdate>12e4}(t)})),n=t.filter((function(t){return function(t){return t.status===P&&Date.now()-t.lastUpdate<=12e4}(t)})),a=[].concat(o(r),o(n));return{getTimeout:function(t,e){return(0===n.length&&0===t?1:n.length+3+t)*e},statelessHosts:a.length>0?a.map((function(t){return O(t)})):e}}))}function S(t,e,n,a){var i=[],u=function(t,e){if(t.method===x||void 0===t.data&&void 0===e.data)return;var n=Array.isArray(t.data)?t.data:r(r({},t.data),e.data);return JSON.stringify(n)}(n,a),s=function(t,e){var n=r(r({},t.headers),e.headers),a={};return Object.keys(n).forEach((function(t){var e=n[t];a[t.toLowerCase()]=e})),a}(t,a),c=n.method,f=n.method!==x?{}:r(r({},n.data),a.data),d=r(r(r({\"x-algolia-agent\":t.userAgent.value},t.queryParameters),f),a.queryParameters),l=0,p=function e(r,o){var f=r.pop();if(void 0===f)throw{name:\"RetryError\",message:\"Unreachable hosts - your application id may be incorrect. If the error persists, contact support@algolia.com.\",transporterStackTrace:R(i)};var p={data:u,headers:s,method:c,url:N(f,n.path,d),connectTimeout:o(l,t.timeouts.connect),responseTimeout:o(l,a.timeout)},h=function(t){var e={request:p,response:t,host:f,triesLeft:r.length};return i.push(e),e},m={onSuccess:function(t){return function(t){try{return JSON.parse(t.content)}catch(e){throw function(t,e){return{name:\"DeserializationError\",message:t,response:e}}(e.message,t)}}(t)},onRetry:function(n){var a=h(n);return n.isTimedOut&&l++,Promise.all([t.logger.info(\"Retryable failure\",A(a)),t.hostsCache.set(f,w(f,n.isTimedOut?P:b))]).then((function(){return e(r,o)}))},onFail:function(t){throw h(t),function(t,e){var r=t.content,n=t.status,a=r;try{a=JSON.parse(r).message}catch(t){}return function(t,e,r){return{name:\"ApiError\",message:t,status:e,transporterStackTrace:r}}(a,n,e)}(t,R(i))}};return t.requester.send(p).then((function(t){return function(t,e){return function(t){var e=t.status;return t.isTimedOut||function(t){var e=t.isTimedOut,r=t.status;return!e&&0==~~r}(t)||2!=~~(e/100)&&4!=~~(e/100)}(t)?e.onRetry(t):2==~~(t.status/100)?e.onSuccess(t):e.onFail(t)}(t,m)}))};return q(t.hostsCache,e).then((function(t){return p(o(t.statelessHosts).reverse(),t.getTimeout)}))}function k(t){var e=t.hostsCache,r=t.logger,n=t.requester,o=t.requestsCache,i=t.responsesCache,u=t.timeouts,s=t.userAgent,c=t.hosts,f=t.queryParameters,d={hostsCache:e,logger:r,requester:n,requestsCache:o,responsesCache:i,timeouts:u,userAgent:s,headers:t.headers,queryParameters:f,hosts:c.map((function(t){return O(t)})),read:function(t,e){var r=y(e,d.timeouts.read),n=function(){return S(d,d.hosts.filter((function(t){return 0!=(t.accept&g.Read)})),t,r)};if(!0!==(void 0!==r.cacheable?r.cacheable:t.cacheable))return n();var o={request:t,mappedRequestOptions:r,transporter:{queryParameters:d.queryParameters,headers:d.headers}};return d.responsesCache.get(o,(function(){return d.requestsCache.get(o,(function(){return d.requestsCache.set(o,n()).then((function(t){return Promise.all([d.requestsCache.delete(o),t])}),(function(t){return Promise.all([d.requestsCache.delete(o),Promise.reject(t)])})).then((function(t){var e=a(t,2);e[0];return e[1]}))}))}),{miss:function(t){return d.responsesCache.set(o,t)}})},write:function(t,e){return S(d,d.hosts.filter((function(t){return 0!=(t.accept&g.Write)})),t,y(e,d.timeouts.write))}};return d}function T(t){var e={value:\"Algolia for JavaScript (\".concat(t,\")\"),add:function(t){var r=\"; \".concat(t.segment).concat(void 0!==t.version?\" (\".concat(t.version,\")\"):\"\");return-1===e.value.indexOf(r)&&(e.value=\"\".concat(e.value).concat(r)),e}};return e}function N(t,e,r){var n=E(r),a=\"\".concat(t.protocol,\"://\").concat(t.url,\"/\").concat(\"/\"===e.charAt(0)?e.substr(1):e);return n.length&&(a+=\"?\".concat(n)),a}function E(t){return Object.keys(t).map((function(e){return h(\"%s=%s\",e,(r=t[e],\"[object Object]\"===Object.prototype.toString.call(r)||\"[object Array]\"===Object.prototype.toString.call(r)?JSON.stringify(t[e]):t[e]));var r})).join(\"&\")}function R(t){return t.map((function(t){return A(t)}))}function A(t){var e=t.request.headers[\"x-algolia-api-key\"]?{\"x-algolia-api-key\":\"*****\"}:{};return r(r({},t),{},{request:r(r({},t.request),{},{headers:r(r({},t.request.headers),e)})})}var C=function(t){return function(e,r){return t.transporter.write({method:j,path:\"2/abtests\",data:e},r)}},U=function(t){return function(e,r){return t.transporter.write({method:I,path:h(\"2/abtests/%s\",e)},r)}},z=function(t){return function(e,r){return t.transporter.read({method:x,path:h(\"2/abtests/%s\",e)},r)}},J=function(t){return function(e){return t.transporter.read({method:x,path:\"2/abtests\"},e)}},F=function(t){return function(e,r){return t.transporter.write({method:j,path:h(\"2/abtests/%s/stop\",e)},r)}},H=function(t){return function(e){return t.transporter.read({method:x,path:\"1/strategies/personalization\"},e)}},M=function(t){return function(e,r){return t.transporter.write({method:j,path:\"1/strategies/personalization\",data:e},r)}};function K(t){return function e(r){return t.request(r).then((function(n){if(void 0!==t.batch&&t.batch(n.hits),!t.shouldStop(n))return n.cursor?e({cursor:n.cursor}):e({page:(r.page||0)+1})}))}({})}var W=function(t){return function(e,a){var o=a||{},i=o.queryParameters,u=n(o,[\"queryParameters\"]),s=r({acl:e},void 0!==i?{queryParameters:i}:{});return d(t.transporter.write({method:j,path:\"1/keys\",data:s},u),(function(e,r){return f((function(n){return tt(t)(e.key,r).catch((function(t){if(404!==t.status)throw t;return n()}))}))}))}},B=function(t){return function(e,r,n){var a=y(n);return a.queryParameters[\"X-Algolia-User-ID\"]=e,t.transporter.write({method:j,path:\"1/clusters/mapping\",data:{cluster:r}},a)}},Q=function(t){return function(e,r,n){return t.transporter.write({method:j,path:\"1/clusters/mapping/batch\",data:{users:e,cluster:r}},n)}},G=function(t){return function(e,r){return d(t.transporter.write({method:j,path:h(\"/1/dictionaries/%s/batch\",e),data:{clearExistingDictionaryEntries:!0,requests:{action:\"addEntry\",body:[]}}},r),(function(e,r){return jt(t)(e.taskID,r)}))}},L=function(t){return function(e,r,n){return d(t.transporter.write({method:j,path:h(\"1/indexes/%s/operation\",e),data:{operation:\"copy\",destination:r}},n),(function(r,n){return ut(t)(e,{methods:{waitTask:de}}).waitTask(r.taskID,n)}))}},V=function(t){return function(e,n,a){return L(t)(e,n,r(r({},a),{},{scope:[pe.Rules]}))}},_=function(t){return function(e,n,a){return L(t)(e,n,r(r({},a),{},{scope:[pe.Settings]}))}},X=function(t){return function(e,n,a){return L(t)(e,n,r(r({},a),{},{scope:[pe.Synonyms]}))}},Y=function(t){return function(e,r){return e.method===x?t.transporter.read(e,r):t.transporter.write(e,r)}},Z=function(t){return function(e,r){return d(t.transporter.write({method:I,path:h(\"1/keys/%s\",e)},r),(function(r,n){return f((function(r){return tt(t)(e,n).then(r).catch((function(t){if(404!==t.status)throw t}))}))}))}},$=function(t){return function(e,r,n){var a=r.map((function(t){return{action:\"deleteEntry\",body:{objectID:t}}}));return d(t.transporter.write({method:j,path:h(\"/1/dictionaries/%s/batch\",e),data:{clearExistingDictionaryEntries:!1,requests:a}},n),(function(e,r){return jt(t)(e.taskID,r)}))}},tt=function(t){return function(e,r){return t.transporter.read({method:x,path:h(\"1/keys/%s\",e)},r)}},et=function(t){return function(e,r){return t.transporter.read({method:x,path:h(\"1/task/%s\",e.toString())},r)}},rt=function(t){return function(e){return t.transporter.read({method:x,path:\"/1/dictionaries/*/settings\"},e)}},nt=function(t){return function(e){return t.transporter.read({method:x,path:\"1/logs\"},e)}},at=function(t){return function(e){return t.transporter.read({method:x,path:\"1/clusters/mapping/top\"},e)}},ot=function(t){return function(e,r){return t.transporter.read({method:x,path:h(\"1/clusters/mapping/%s\",e)},r)}},it=function(t){return function(e){var r=e||{},a=r.retrieveMappings,o=n(r,[\"retrieveMappings\"]);return!0===a&&(o.getClusters=!0),t.transporter.read({method:x,path:\"1/clusters/mapping/pending\"},o)}},ut=function(t){return function(e){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},n={transporter:t.transporter,appId:t.appId,indexName:e};return p(n,r.methods)}},st=function(t){return function(e){return t.transporter.read({method:x,path:\"1/keys\"},e)}},ct=function(t){return function(e){return t.transporter.read({method:x,path:\"1/clusters\"},e)}},ft=function(t){return function(e){return t.transporter.read({method:x,path:\"1/indexes\"},e)}},dt=function(t){return function(e){return t.transporter.read({method:x,path:\"1/clusters/mapping\"},e)}},lt=function(t){return function(e,r,n){return d(t.transporter.write({method:j,path:h(\"1/indexes/%s/operation\",e),data:{operation:\"move\",destination:r}},n),(function(r,n){return ut(t)(e,{methods:{waitTask:de}}).waitTask(r.taskID,n)}))}},pt=function(t){return function(e,r){return d(t.transporter.write({method:j,path:\"1/indexes/*/batch\",data:{requests:e}},r),(function(e,r){return Promise.all(Object.keys(e.taskID).map((function(n){return ut(t)(n,{methods:{waitTask:de}}).waitTask(e.taskID[n],r)})))}))}},ht=function(t){return function(e,r){return t.transporter.read({method:j,path:\"1/indexes/*/objects\",data:{requests:e}},r)}},mt=function(t){return function(e,n){var a=e.map((function(t){return r(r({},t),{},{params:E(t.params||{})})}));return t.transporter.read({method:j,path:\"1/indexes/*/queries\",data:{requests:a},cacheable:!0},n)}},yt=function(t){return function(e,a){return Promise.all(e.map((function(e){var o=e.params,i=o.facetName,u=o.facetQuery,s=n(o,[\"facetName\",\"facetQuery\"]);return ut(t)(e.indexName,{methods:{searchForFacetValues:ue}}).searchForFacetValues(i,u,r(r({},a),s))})))}},gt=function(t){return function(e,r){var n=y(r);return n.queryParameters[\"X-Algolia-User-ID\"]=e,t.transporter.write({method:I,path:\"1/clusters/mapping\"},n)}},vt=function(t){return function(e,r,n){var a=r.map((function(t){return{action:\"addEntry\",body:t}}));return d(t.transporter.write({method:j,path:h(\"/1/dictionaries/%s/batch\",e),data:{clearExistingDictionaryEntries:!0,requests:a}},n),(function(e,r){return jt(t)(e.taskID,r)}))}},bt=function(t){return function(e,r){return d(t.transporter.write({method:j,path:h(\"1/keys/%s/restore\",e)},r),(function(r,n){return f((function(r){return tt(t)(e,n).catch((function(t){if(404!==t.status)throw t;return r()}))}))}))}},Pt=function(t){return function(e,r,n){var a=r.map((function(t){return{action:\"addEntry\",body:t}}));return d(t.transporter.write({method:j,path:h(\"/1/dictionaries/%s/batch\",e),data:{clearExistingDictionaryEntries:!1,requests:a}},n),(function(e,r){return jt(t)(e.taskID,r)}))}},wt=function(t){return function(e,r,n){return t.transporter.read({method:j,path:h(\"/1/dictionaries/%s/search\",e),data:{query:r},cacheable:!0},n)}},Ot=function(t){return function(e,r){return t.transporter.read({method:j,path:\"1/clusters/mapping/search\",data:{query:e}},r)}},It=function(t){return function(e,r){return d(t.transporter.write({method:D,path:\"/1/dictionaries/*/settings\",data:e},r),(function(e,r){return jt(t)(e.taskID,r)}))}},xt=function(t){return function(e,r){var a=Object.assign({},r),o=r||{},i=o.queryParameters,u=n(o,[\"queryParameters\"]),s=i?{queryParameters:i}:{},c=[\"acl\",\"indexes\",\"referers\",\"restrictSources\",\"queryParameters\",\"description\",\"maxQueriesPerIPPerHour\",\"maxHitsPerQuery\"];return d(t.transporter.write({method:D,path:h(\"1/keys/%s\",e),data:s},u),(function(r,n){return f((function(r){return tt(t)(e,n).then((function(t){return function(t){return Object.keys(a).filter((function(t){return-1!==c.indexOf(t)})).every((function(e){return t[e]===a[e]}))}(t)?Promise.resolve():r()}))}))}))}},jt=function(t){return function(e,r){return f((function(n){return et(t)(e,r).then((function(t){return\"published\"!==t.status?n():void 0}))}))}},Dt=function(t){return function(e,r){return d(t.transporter.write({method:j,path:h(\"1/indexes/%s/batch\",t.indexName),data:{requests:e}},r),(function(e,r){return de(t)(e.taskID,r)}))}},qt=function(t){return function(e){return K(r(r({shouldStop:function(t){return void 0===t.cursor}},e),{},{request:function(r){return t.transporter.read({method:j,path:h(\"1/indexes/%s/browse\",t.indexName),data:r},e)}}))}},St=function(t){return function(e){var n=r({hitsPerPage:1e3},e);return K(r(r({shouldStop:function(t){return t.hits.length<n.hitsPerPage}},n),{},{request:function(e){return se(t)(\"\",r(r({},n),e)).then((function(t){return r(r({},t),{},{hits:t.hits.map((function(t){return delete t._highlightResult,t}))})}))}}))}},kt=function(t){return function(e){var n=r({hitsPerPage:1e3},e);return K(r(r({shouldStop:function(t){return t.hits.length<n.hitsPerPage}},n),{},{request:function(e){return ce(t)(\"\",r(r({},n),e)).then((function(t){return r(r({},t),{},{hits:t.hits.map((function(t){return delete t._highlightResult,t}))})}))}}))}},Tt=function(t){return function(e,r,a){var o=a||{},i=o.batchSize,u=n(o,[\"batchSize\"]),s={taskIDs:[],objectIDs:[]};return d(function n(){var a,o=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,c=[];for(a=o;a<e.length&&(c.push(e[a]),c.length!==(i||1e3));a++);return 0===c.length?Promise.resolve(s):Dt(t)(c.map((function(t){return{action:r,body:t}})),u).then((function(t){return s.objectIDs=s.objectIDs.concat(t.objectIDs),s.taskIDs.push(t.taskID),a++,n(a)}))}(),(function(e,r){return Promise.all(e.taskIDs.map((function(e){return de(t)(e,r)})))}))}},Nt=function(t){return function(e){return d(t.transporter.write({method:j,path:h(\"1/indexes/%s/clear\",t.indexName)},e),(function(e,r){return de(t)(e.taskID,r)}))}},Et=function(t){return function(e){var r=e||{},a=r.forwardToReplicas,o=y(n(r,[\"forwardToReplicas\"]));return a&&(o.queryParameters.forwardToReplicas=1),d(t.transporter.write({method:j,path:h(\"1/indexes/%s/rules/clear\",t.indexName)},o),(function(e,r){return de(t)(e.taskID,r)}))}},Rt=function(t){return function(e){var r=e||{},a=r.forwardToReplicas,o=y(n(r,[\"forwardToReplicas\"]));return a&&(o.queryParameters.forwardToReplicas=1),d(t.transporter.write({method:j,path:h(\"1/indexes/%s/synonyms/clear\",t.indexName)},o),(function(e,r){return de(t)(e.taskID,r)}))}},At=function(t){return function(e,r){return d(t.transporter.write({method:j,path:h(\"1/indexes/%s/deleteByQuery\",t.indexName),data:e},r),(function(e,r){return de(t)(e.taskID,r)}))}},Ct=function(t){return function(e){return d(t.transporter.write({method:I,path:h(\"1/indexes/%s\",t.indexName)},e),(function(e,r){return de(t)(e.taskID,r)}))}},Ut=function(t){return function(e,r){return d(zt(t)([e],r).then((function(t){return{taskID:t.taskIDs[0]}})),(function(e,r){return de(t)(e.taskID,r)}))}},zt=function(t){return function(e,r){var n=e.map((function(t){return{objectID:t}}));return Tt(t)(n,le.DeleteObject,r)}},Jt=function(t){return function(e,r){var a=r||{},o=a.forwardToReplicas,i=y(n(a,[\"forwardToReplicas\"]));return o&&(i.queryParameters.forwardToReplicas=1),d(t.transporter.write({method:I,path:h(\"1/indexes/%s/rules/%s\",t.indexName,e)},i),(function(e,r){return de(t)(e.taskID,r)}))}},Ft=function(t){return function(e,r){var a=r||{},o=a.forwardToReplicas,i=y(n(a,[\"forwardToReplicas\"]));return o&&(i.queryParameters.forwardToReplicas=1),d(t.transporter.write({method:I,path:h(\"1/indexes/%s/synonyms/%s\",t.indexName,e)},i),(function(e,r){return de(t)(e.taskID,r)}))}},Ht=function(t){return function(e){return Lt(t)(e).then((function(){return!0})).catch((function(t){if(404!==t.status)throw t;return!1}))}},Mt=function(t){return function(e,r,n){return t.transporter.read({method:j,path:h(\"1/answers/%s/prediction\",t.indexName),data:{query:e,queryLanguages:r},cacheable:!0},n)}},Kt=function(t){return function(e,o){var i=o||{},u=i.query,s=i.paginate,c=n(i,[\"query\",\"paginate\"]),f=0;return function n(){return ie(t)(u||\"\",r(r({},c),{},{page:f})).then((function(t){for(var r=0,o=Object.entries(t.hits);r<o.length;r++){var i=a(o[r],2),u=i[0],c=i[1];if(e(c))return{object:c,position:parseInt(u,10),page:f}}if(f++,!1===s||f>=t.nbPages)throw{name:\"ObjectNotFoundError\",message:\"Object not found.\"};return n()}))}()}},Wt=function(t){return function(e,r){return t.transporter.read({method:x,path:h(\"1/indexes/%s/%s\",t.indexName,e)},r)}},Bt=function(){return function(t,e){for(var r=0,n=Object.entries(t.hits);r<n.length;r++){var o=a(n[r],2),i=o[0];if(o[1].objectID===e)return parseInt(i,10)}return-1}},Qt=function(t){return function(e,a){var o=a||{},i=o.attributesToRetrieve,u=n(o,[\"attributesToRetrieve\"]),s=e.map((function(e){return r({indexName:t.indexName,objectID:e},i?{attributesToRetrieve:i}:{})}));return t.transporter.read({method:j,path:\"1/indexes/*/objects\",data:{requests:s}},u)}},Gt=function(t){return function(e,r){return t.transporter.read({method:x,path:h(\"1/indexes/%s/rules/%s\",t.indexName,e)},r)}},Lt=function(t){return function(e){return t.transporter.read({method:x,path:h(\"1/indexes/%s/settings\",t.indexName),data:{getVersion:2}},e)}},Vt=function(t){return function(e,r){return t.transporter.read({method:x,path:h(\"1/indexes/%s/synonyms/%s\",t.indexName,e)},r)}},_t=function(t){return function(e,r){return d(Xt(t)([e],r).then((function(t){return{objectID:t.objectIDs[0],taskID:t.taskIDs[0]}})),(function(e,r){return de(t)(e.taskID,r)}))}},Xt=function(t){return function(e,r){var a=r||{},o=a.createIfNotExists,i=n(a,[\"createIfNotExists\"]),u=o?le.PartialUpdateObject:le.PartialUpdateObjectNoCreate;return Tt(t)(e,u,i)}},Yt=function(t){return function(e,i){var u=i||{},s=u.safe,c=u.autoGenerateObjectIDIfNotExist,f=u.batchSize,l=n(u,[\"safe\",\"autoGenerateObjectIDIfNotExist\",\"batchSize\"]),p=function(e,r,n,a){return d(t.transporter.write({method:j,path:h(\"1/indexes/%s/operation\",e),data:{operation:n,destination:r}},a),(function(e,r){return de(t)(e.taskID,r)}))},m=Math.random().toString(36).substring(7),y=\"\".concat(t.indexName,\"_tmp_\").concat(m),g=ee({appId:t.appId,transporter:t.transporter,indexName:y}),v=[],b=p(t.indexName,y,\"copy\",r(r({},l),{},{scope:[\"settings\",\"synonyms\",\"rules\"]}));return v.push(b),d((s?b.wait(l):b).then((function(){var t=g(e,r(r({},l),{},{autoGenerateObjectIDIfNotExist:c,batchSize:f}));return v.push(t),s?t.wait(l):t})).then((function(){var e=p(y,t.indexName,\"move\",l);return v.push(e),s?e.wait(l):e})).then((function(){return Promise.all(v)})).then((function(t){var e=a(t,3),r=e[0],n=e[1],i=e[2];return{objectIDs:n.objectIDs,taskIDs:[r.taskID].concat(o(n.taskIDs),[i.taskID])}})),(function(t,e){return Promise.all(v.map((function(t){return t.wait(e)})))}))}},Zt=function(t){return function(e,n){return ne(t)(e,r(r({},n),{},{clearExistingRules:!0}))}},$t=function(t){return function(e,n){return oe(t)(e,r(r({},n),{},{clearExistingSynonyms:!0}))}},te=function(t){return function(e,r){return d(ee(t)([e],r).then((function(t){return{objectID:t.objectIDs[0],taskID:t.taskIDs[0]}})),(function(e,r){return de(t)(e.taskID,r)}))}},ee=function(t){return function(e,r){var a=r||{},o=a.autoGenerateObjectIDIfNotExist,i=n(a,[\"autoGenerateObjectIDIfNotExist\"]),u=o?le.AddObject:le.UpdateObject;if(u===le.UpdateObject){var s=!0,c=!1,f=void 0;try{for(var l,p=e[Symbol.iterator]();!(s=(l=p.next()).done);s=!0){if(void 0===l.value.objectID)return d(Promise.reject({name:\"MissingObjectIDError\",message:\"All objects must have an unique objectID (like a primary key) to be valid. Algolia is also able to generate objectIDs automatically but *it's not recommended*. To do it, use the `{'autoGenerateObjectIDIfNotExist': true}` option.\"}))}}catch(t){c=!0,f=t}finally{try{s||null==p.return||p.return()}finally{if(c)throw f}}}return Tt(t)(e,u,i)}},re=function(t){return function(e,r){return ne(t)([e],r)}},ne=function(t){return function(e,r){var a=r||{},o=a.forwardToReplicas,i=a.clearExistingRules,u=y(n(a,[\"forwardToReplicas\",\"clearExistingRules\"]));return o&&(u.queryParameters.forwardToReplicas=1),i&&(u.queryParameters.clearExistingRules=1),d(t.transporter.write({method:j,path:h(\"1/indexes/%s/rules/batch\",t.indexName),data:e},u),(function(e,r){return de(t)(e.taskID,r)}))}},ae=function(t){return function(e,r){return oe(t)([e],r)}},oe=function(t){return function(e,r){var a=r||{},o=a.forwardToReplicas,i=a.clearExistingSynonyms,u=a.replaceExistingSynonyms,s=y(n(a,[\"forwardToReplicas\",\"clearExistingSynonyms\",\"replaceExistingSynonyms\"]));return o&&(s.queryParameters.forwardToReplicas=1),(u||i)&&(s.queryParameters.replaceExistingSynonyms=1),d(t.transporter.write({method:j,path:h(\"1/indexes/%s/synonyms/batch\",t.indexName),data:e},s),(function(e,r){return de(t)(e.taskID,r)}))}},ie=function(t){return function(e,r){return t.transporter.read({method:j,path:h(\"1/indexes/%s/query\",t.indexName),data:{query:e},cacheable:!0},r)}},ue=function(t){return function(e,r,n){return t.transporter.read({method:j,path:h(\"1/indexes/%s/facets/%s/query\",t.indexName,e),data:{facetQuery:r},cacheable:!0},n)}},se=function(t){return function(e,r){return t.transporter.read({method:j,path:h(\"1/indexes/%s/rules/search\",t.indexName),data:{query:e}},r)}},ce=function(t){return function(e,r){return t.transporter.read({method:j,path:h(\"1/indexes/%s/synonyms/search\",t.indexName),data:{query:e}},r)}},fe=function(t){return function(e,r){var a=r||{},o=a.forwardToReplicas,i=y(n(a,[\"forwardToReplicas\"]));return o&&(i.queryParameters.forwardToReplicas=1),d(t.transporter.write({method:D,path:h(\"1/indexes/%s/settings\",t.indexName),data:e},i),(function(e,r){return de(t)(e.taskID,r)}))}},de=function(t){return function(e,r){return f((function(n){return function(t){return function(e,r){return t.transporter.read({method:x,path:h(\"1/indexes/%s/task/%s\",t.indexName,e.toString())},r)}}(t)(e,r).then((function(t){return\"published\"!==t.status?n():void 0}))}))}},le={AddObject:\"addObject\",UpdateObject:\"updateObject\",PartialUpdateObject:\"partialUpdateObject\",PartialUpdateObjectNoCreate:\"partialUpdateObjectNoCreate\",DeleteObject:\"deleteObject\",DeleteIndex:\"delete\",ClearIndex:\"clear\"},pe={Settings:\"settings\",Synonyms:\"synonyms\",Rules:\"rules\"},he=1,me=2,ye=3;function ge(t,e,n){var a,o={appId:t,apiKey:e,timeouts:{connect:1,read:2,write:30},requester:{send:function(t){return new Promise((function(e){var r=new XMLHttpRequest;r.open(t.method,t.url,!0),Object.keys(t.headers).forEach((function(e){return r.setRequestHeader(e,t.headers[e])}));var n,a=function(t,n){return setTimeout((function(){r.abort(),e({status:0,content:n,isTimedOut:!0})}),1e3*t)},o=a(t.connectTimeout,\"Connection timeout\");r.onreadystatechange=function(){r.readyState>r.OPENED&&void 0===n&&(clearTimeout(o),n=a(t.responseTimeout,\"Socket timeout\"))},r.onerror=function(){0===r.status&&(clearTimeout(o),clearTimeout(n),e({content:r.responseText||\"Network request failed\",status:r.status,isTimedOut:!1}))},r.onload=function(){clearTimeout(o),clearTimeout(n),e({content:r.responseText,status:r.status,isTimedOut:!1})},r.send(t.data)}))}},logger:(a=ye,{debug:function(t,e){return he>=a&&console.debug(t,e),Promise.resolve()},info:function(t,e){return me>=a&&console.info(t,e),Promise.resolve()},error:function(t,e){return console.error(t,e),Promise.resolve()}}),responsesCache:s(),requestsCache:s({serializable:!1}),hostsCache:u({caches:[i({key:\"\".concat(\"4.13.1\",\"-\").concat(t)}),s()]}),userAgent:T(\"4.13.1\").add({segment:\"Browser\"})},f=r(r({},o),n),d=function(){return function(t){return function(t){var e=t.region||\"us\",n=c(m.WithinHeaders,t.appId,t.apiKey),a=k(r(r({hosts:[{url:\"personalization.\".concat(e,\".algolia.com\")}]},t),{},{headers:r(r(r({},n.headers()),{\"content-type\":\"application/json\"}),t.headers),queryParameters:r(r({},n.queryParameters()),t.queryParameters)}));return p({appId:t.appId,transporter:a},t.methods)}(r(r(r({},o),t),{},{methods:{getPersonalizationStrategy:H,setPersonalizationStrategy:M}}))}};return function(t){var e=t.appId,n=c(void 0!==t.authMode?t.authMode:m.WithinHeaders,e,t.apiKey),a=k(r(r({hosts:[{url:\"\".concat(e,\"-dsn.algolia.net\"),accept:g.Read},{url:\"\".concat(e,\".algolia.net\"),accept:g.Write}].concat(l([{url:\"\".concat(e,\"-1.algolianet.com\")},{url:\"\".concat(e,\"-2.algolianet.com\")},{url:\"\".concat(e,\"-3.algolianet.com\")}]))},t),{},{headers:r(r(r({},n.headers()),{\"content-type\":\"application/x-www-form-urlencoded\"}),t.headers),queryParameters:r(r({},n.queryParameters()),t.queryParameters)}));return p({transporter:a,appId:e,addAlgoliaAgent:function(t,e){a.userAgent.add({segment:t,version:e})},clearCache:function(){return Promise.all([a.requestsCache.clear(),a.responsesCache.clear()]).then((function(){}))}},t.methods)}(r(r({},f),{},{methods:{search:mt,searchForFacetValues:yt,multipleBatch:pt,multipleGetObjects:ht,multipleQueries:mt,copyIndex:L,copySettings:_,copySynonyms:X,copyRules:V,moveIndex:lt,listIndices:ft,getLogs:nt,listClusters:ct,multipleSearchForFacetValues:yt,getApiKey:tt,addApiKey:W,listApiKeys:st,updateApiKey:xt,deleteApiKey:Z,restoreApiKey:bt,assignUserID:B,assignUserIDs:Q,getUserID:ot,searchUserIDs:Ot,listUserIDs:dt,getTopUserIDs:at,removeUserID:gt,hasPendingMappings:it,clearDictionaryEntries:G,deleteDictionaryEntries:$,getDictionarySettings:rt,getAppTask:et,replaceDictionaryEntries:vt,saveDictionaryEntries:Pt,searchDictionaryEntries:wt,setDictionarySettings:It,waitAppTask:jt,customRequest:Y,initIndex:function(t){return function(e){return ut(t)(e,{methods:{batch:Dt,delete:Ct,findAnswers:Mt,getObject:Wt,getObjects:Qt,saveObject:te,saveObjects:ee,search:ie,searchForFacetValues:ue,waitTask:de,setSettings:fe,getSettings:Lt,partialUpdateObject:_t,partialUpdateObjects:Xt,deleteObject:Ut,deleteObjects:zt,deleteBy:At,clearObjects:Nt,browseObjects:qt,getObjectPosition:Bt,findObject:Kt,exists:Ht,saveSynonym:ae,saveSynonyms:oe,getSynonym:Vt,searchSynonyms:ce,browseSynonyms:kt,deleteSynonym:Ft,clearSynonyms:Rt,replaceAllObjects:Yt,replaceAllSynonyms:$t,searchRules:se,getRule:Gt,deleteRule:Jt,saveRule:re,saveRules:ne,replaceAllRules:Zt,browseRules:St,clearRules:Et}})}},initAnalytics:function(){return function(t){return function(t){var e=t.region||\"us\",n=c(m.WithinHeaders,t.appId,t.apiKey),a=k(r(r({hosts:[{url:\"analytics.\".concat(e,\".algolia.com\")}]},t),{},{headers:r(r(r({},n.headers()),{\"content-type\":\"application/json\"}),t.headers),queryParameters:r(r({},n.queryParameters()),t.queryParameters)}));return p({appId:t.appId,transporter:a},t.methods)}(r(r(r({},o),t),{},{methods:{addABTest:C,getABTest:z,getABTests:J,stopABTest:F,deleteABTest:U}}))}},initPersonalization:d,initRecommendation:function(){return function(t){return f.logger.info(\"The `initRecommendation` method is deprecated. Use `initPersonalization` instead.\"),d()(t)}}}}))}return ge.version=\"4.13.1\",ge}));\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar customInspectSymbol =\n  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\n    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\n    : null\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nvar K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Print warning and recommend using `buffer` v4.x which has an Object\n *               implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n    typeof console.error === 'function') {\n  console.error(\n    'This browser lacks typed array (Uint8Array) support which is required by ' +\n    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n  )\n}\n\nfunction typedArraySupport () {\n  // Can typed array instances can be augmented?\n  try {\n    var arr = new Uint8Array(1)\n    var proto = { foo: function () { return 42 } }\n    Object.setPrototypeOf(proto, Uint8Array.prototype)\n    Object.setPrototypeOf(arr, proto)\n    return arr.foo() === 42\n  } catch (e) {\n    return false\n  }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.buffer\n  }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.byteOffset\n  }\n})\n\nfunction createBuffer (length) {\n  if (length > K_MAX_LENGTH) {\n    throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n  }\n  // Return an augmented `Uint8Array` instance\n  var buf = new Uint8Array(length)\n  Object.setPrototypeOf(buf, Buffer.prototype)\n  return buf\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new TypeError(\n        'The \"string\" argument must be of type string. Received type number'\n      )\n    }\n    return allocUnsafe(arg)\n  }\n  return from(arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n  if (typeof value === 'string') {\n    return fromString(value, encodingOrOffset)\n  }\n\n  if (ArrayBuffer.isView(value)) {\n    return fromArrayView(value)\n  }\n\n  if (value == null) {\n    throw new TypeError(\n      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n      'or Array-like Object. Received type ' + (typeof value)\n    )\n  }\n\n  if (isInstance(value, ArrayBuffer) ||\n      (value && isInstance(value.buffer, ArrayBuffer))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof SharedArrayBuffer !== 'undefined' &&\n      (isInstance(value, SharedArrayBuffer) ||\n      (value && isInstance(value.buffer, SharedArrayBuffer)))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'number') {\n    throw new TypeError(\n      'The \"value\" argument must not be of type number. Received type number'\n    )\n  }\n\n  var valueOf = value.valueOf && value.valueOf()\n  if (valueOf != null && valueOf !== value) {\n    return Buffer.from(valueOf, encodingOrOffset, length)\n  }\n\n  var b = fromObject(value)\n  if (b) return b\n\n  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n      typeof value[Symbol.toPrimitive] === 'function') {\n    return Buffer.from(\n      value[Symbol.toPrimitive]('string'), encodingOrOffset, length\n    )\n  }\n\n  throw new TypeError(\n    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n    'or Array-like Object. Received type ' + (typeof value)\n  )\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\nObject.setPrototypeOf(Buffer, Uint8Array)\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be of type number')\n  } else if (size < 0) {\n    throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n  }\n}\n\nfunction alloc (size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpreted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(size).fill(fill, encoding)\n      : createBuffer(size).fill(fill)\n  }\n  return createBuffer(size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n  assertSize(size)\n  return createBuffer(size < 0 ? 0 : checked(size) | 0)\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(size)\n}\n\nfunction fromString (string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('Unknown encoding: ' + encoding)\n  }\n\n  var length = byteLength(string, encoding) | 0\n  var buf = createBuffer(length)\n\n  var actual = buf.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    buf = buf.slice(0, actual)\n  }\n\n  return buf\n}\n\nfunction fromArrayLike (array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  var buf = createBuffer(length)\n  for (var i = 0; i < length; i += 1) {\n    buf[i] = array[i] & 255\n  }\n  return buf\n}\n\nfunction fromArrayView (arrayView) {\n  if (isInstance(arrayView, Uint8Array)) {\n    var copy = new Uint8Array(arrayView)\n    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\n  }\n  return fromArrayLike(arrayView)\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\"offset\" is outside of buffer bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\"length\" is outside of buffer bounds')\n  }\n\n  var buf\n  if (byteOffset === undefined && length === undefined) {\n    buf = new Uint8Array(array)\n  } else if (length === undefined) {\n    buf = new Uint8Array(array, byteOffset)\n  } else {\n    buf = new Uint8Array(array, byteOffset, length)\n  }\n\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(buf, Buffer.prototype)\n\n  return buf\n}\n\nfunction fromObject (obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    var buf = createBuffer(len)\n\n    if (buf.length === 0) {\n      return buf\n    }\n\n    obj.copy(buf, 0, 0, len)\n    return buf\n  }\n\n  if (obj.length !== undefined) {\n    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n      return createBuffer(0)\n    }\n    return fromArrayLike(obj)\n  }\n\n  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n    return fromArrayLike(obj.data)\n  }\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= K_MAX_LENGTH) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return b != null && b._isBuffer === true &&\n    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError(\n      'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n    )\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!Array.isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (isInstance(buf, Uint8Array)) {\n      if (pos + buf.length > buffer.length) {\n        Buffer.from(buf).copy(buffer, pos)\n      } else {\n        Uint8Array.prototype.set.call(\n          buffer,\n          buf,\n          pos\n        )\n      }\n    } else if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    } else {\n      buf.copy(buffer, pos)\n    }\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    throw new TypeError(\n      'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n      'Received type ' + typeof string\n    )\n  }\n\n  var len = string.length\n  var mustMatch = (arguments.length > 2 && arguments[2] === true)\n  if (!mustMatch && len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) {\n          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n        }\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coercion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.toLocaleString = Buffer.prototype.toString\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n  if (this.length > max) str += ' ... '\n  return '<Buffer ' + str + '>'\n}\nif (customInspectSymbol) {\n  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (isInstance(target, Uint8Array)) {\n    target = Buffer.from(target, target.offset, target.byteLength)\n  }\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError(\n      'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n      'Received type ' + (typeof target)\n    )\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset // Coerce to Number.\n  if (numberIsNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  var strLen = string.length\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (numberIsNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset >>> 0\n    if (isFinite(length)) {\n      length = length >>> 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return asciiWrite(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF)\n      ? 4\n      : (firstByte > 0xDF)\n          ? 3\n          : (firstByte > 0xBF)\n              ? 2\n              : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += hexSliceLookupTable[buf[i]]\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\n  for (var i = 0; i < bytes.length - 1; i += 2) {\n    res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf = this.subarray(start, end)\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(newBuf, Buffer.prototype)\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUintLE =\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUintBE =\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUint8 =\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUint16LE =\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUint16BE =\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUint32LE =\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUint32BE =\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUintLE =\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUintBE =\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUint8 =\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeUint16LE =\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint16BE =\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint32LE =\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset + 3] = (value >>> 24)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 1] = (value >>> 8)\n  this[offset] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeUint32BE =\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    var limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    var limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 3] = (value >>> 24)\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('Index out of range')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n\n  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n    // Use built-in when available, missing from IE11\n    this.copyWithin(targetStart, start, end)\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, end),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if ((encoding === 'utf8' && code < 128) ||\n          encoding === 'latin1') {\n        // Fast path: If `val` fits into a single byte, use that numeric value.\n        val = code\n      }\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  } else if (typeof val === 'boolean') {\n    val = Number(val)\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : Buffer.from(val, encoding)\n    var len = bytes.length\n    if (len === 0) {\n      throw new TypeError('The value \"' + val +\n        '\" is invalid for argument \"value\"')\n    }\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node takes equal signs as end of the Base64 encoding\n  str = str.split('=')[0]\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = str.trim().replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n  return obj instanceof type ||\n    (obj != null && obj.constructor != null && obj.constructor.name != null &&\n      obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n  // For IE11 support\n  return obj !== obj // eslint-disable-line no-self-compare\n}\n\n// Create lookup table for `toString('hex')`\n// See: https://github.com/feross/buffer/issues/219\nvar hexSliceLookupTable = (function () {\n  var alphabet = '0123456789abcdef'\n  var table = new Array(256)\n  for (var i = 0; i < 16; ++i) {\n    var i16 = i * 16\n    for (var j = 0; j < 16; ++j) {\n      table[i16 + j] = alphabet[i] + alphabet[j]\n    }\n  }\n  return table\n})()\n","\"use strict\";\n\nvar defaults = {\n    ellipse: \"…\",\n    chars: [\" \", \"-\"],\n    max: 140,\n    truncate: true,\n};\n\n/**\n * \"mac-style\" or \"harmonica\" ellipsize.\n * Ellipsizes a string in the middle instead of the end.\n *\n * Examples:\n *\n *      These are a few of my favourite things\n *      These are … my faourite things\n *      These are … faourite things\n *      hese … things\n *\n * @param {string} str\n * @param {Number} max\n * @param {string} ellipse\n * @param {string[]} chars\n * @returns {string} ellipsized\n */\n\nfunction ellipsizeMiddle(str, max, ellipse, chars) {\n    if (str <= max) return str;\n    if (max < 2) return str.slice(0, max - ellipse.length) + ellipse;\n\n    var maxLen = max - ellipse.length;\n    var middle = Math.floor(maxLen / 2);\n\n    var left = middle;\n    var right = str.length - middle;\n\n    for (var i = 0; i < middle; i++) {\n        var charLeft = str.charAt(i);\n        var posRight = str.length - i;\n\n        var charRight = str.charAt(posRight);\n\n        if (chars.indexOf(charLeft) !== -1) left = i;\n        if (chars.indexOf(charRight) !== -1) right = posRight;\n    }\n\n    return str.slice(0, left) + ellipse + str.slice(right);\n}\n\n/**\n *\n * @param {string} str\n * @param {number} max\n * @param {string} ellipse\n * @param {string[]} chars\n * @param {boolean} truncate\n * @returns\n */\nfunction ellipsize(str, max, ellipse, chars, truncate) {\n    if (str.length <= max) return str;\n\n    var maxLen = max - ellipse.length;\n    var end = maxLen;\n\n    for (var i = 0; i <= maxLen; i++) {\n        var char = str.charAt(i);\n        if (chars.indexOf(char) !== -1) end = i;\n    }\n\n    // no breakpoint found, but truncate\n    // was not allowed.\n    if (!truncate && end == maxLen) return \"\";\n\n    return str.slice(0, end) + ellipse;\n}\n\n/**\n * Ellipsize a string. Produces a string that is max lenght,\n * including the ellipse character.\n *\n * @param {string} str - String to ellipsize\n * @param {number} max - Max length including ellipsis\n * @param {Record<string, any>} [opts] - See additional options\n * @returns {string} ellipsized string\n */\nmodule.exports = function (str, max, opts) {\n    if (typeof str !== \"string\" || str.length === 0) return \"\";\n    if (max === 0) return \"\";\n\n    opts = opts || {};\n\n    for (var key in defaults) {\n        if (opts[key] === null || typeof opts[key] === \"undefined\") {\n            opts[key] = defaults[key];\n        }\n    }\n\n    opts.max = max || opts.max;\n\n    if (opts.truncate == \"middle\")\n        return ellipsizeMiddle(str, opts.max, opts.ellipse, opts.chars);\n\n    return ellipsize(str, opts.max, opts.ellipse, opts.chars, opts.truncate);\n};\n\nmodule.exports.ellipsizeMiddle = ellipsizeMiddle;\nmodule.exports.ellipsize = ellipsize;\n","export default function _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}","import _extends from '@babel/runtime/helpers/esm/extends';\n\n/**\r\n * Actions represent the type of change to a location value.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#action\r\n */\nvar Action;\n\n(function (Action) {\n  /**\r\n   * A POP indicates a change to an arbitrary index in the history stack, such\r\n   * as a back or forward navigation. It does not describe the direction of the\r\n   * navigation, only that the current index changed.\r\n   *\r\n   * Note: This is the default action for newly created history objects.\r\n   */\n  Action[\"Pop\"] = \"POP\";\n  /**\r\n   * A PUSH indicates a new entry being added to the history stack, such as when\r\n   * a link is clicked and a new page loads. When this happens, all subsequent\r\n   * entries in the stack are lost.\r\n   */\n\n  Action[\"Push\"] = \"PUSH\";\n  /**\r\n   * A REPLACE indicates the entry at the current index in the history stack\r\n   * being replaced by a new one.\r\n   */\n\n  Action[\"Replace\"] = \"REPLACE\";\n})(Action || (Action = {}));\n\nvar readOnly = process.env.NODE_ENV !== \"production\" ? function (obj) {\n  return Object.freeze(obj);\n} : function (obj) {\n  return obj;\n};\n\nfunction warning(cond, message) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== 'undefined') console.warn(message);\n\n    try {\n      // Welcome to debugging history!\n      //\n      // This error is thrown as a convenience so you can more easily\n      // find the source for a warning that appears in the console by\n      // enabling \"pause on exceptions\" in your JavaScript debugger.\n      throw new Error(message); // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\n\nvar BeforeUnloadEventType = 'beforeunload';\nvar HashChangeEventType = 'hashchange';\nvar PopStateEventType = 'popstate';\n/**\r\n * Browser history stores the location in regular URLs. This is the standard for\r\n * most web apps, but it requires some configuration on the server to ensure you\r\n * serve the same app at multiple URLs.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\r\n */\n\nfunction createBrowserHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var _options = options,\n      _options$window = _options.window,\n      window = _options$window === void 0 ? document.defaultView : _options$window;\n  var globalHistory = window.history;\n\n  function getIndexAndLocation() {\n    var _window$location = window.location,\n        pathname = _window$location.pathname,\n        search = _window$location.search,\n        hash = _window$location.hash;\n    var state = globalHistory.state || {};\n    return [state.idx, readOnly({\n      pathname: pathname,\n      search: search,\n      hash: hash,\n      state: state.usr || null,\n      key: state.key || 'default'\n    })];\n  }\n\n  var blockedPopTx = null;\n\n  function handlePop() {\n    if (blockedPopTx) {\n      blockers.call(blockedPopTx);\n      blockedPopTx = null;\n    } else {\n      var nextAction = Action.Pop;\n\n      var _getIndexAndLocation = getIndexAndLocation(),\n          nextIndex = _getIndexAndLocation[0],\n          nextLocation = _getIndexAndLocation[1];\n\n      if (blockers.length) {\n        if (nextIndex != null) {\n          var delta = index - nextIndex;\n\n          if (delta) {\n            // Revert the POP\n            blockedPopTx = {\n              action: nextAction,\n              location: nextLocation,\n              retry: function retry() {\n                go(delta * -1);\n              }\n            };\n            go(delta);\n          }\n        } else {\n          // Trying to POP to a location with no index. We did not create\n          // this location, so we can't effectively block the navigation.\n          process.env.NODE_ENV !== \"production\" ? warning(false, // TODO: Write up a doc that explains our blocking strategy in\n          // detail and link to it here so people can understand better what\n          // is going on and how to avoid it.\n          \"You are trying to block a POP navigation to a location that was not \" + \"created by the history library. The block will fail silently in \" + \"production, but in general you should do all navigation with the \" + \"history library (instead of using window.history.pushState directly) \" + \"to avoid this situation.\") : void 0;\n        }\n      } else {\n        applyTx(nextAction);\n      }\n    }\n  }\n\n  window.addEventListener(PopStateEventType, handlePop);\n  var action = Action.Pop;\n\n  var _getIndexAndLocation2 = getIndexAndLocation(),\n      index = _getIndexAndLocation2[0],\n      location = _getIndexAndLocation2[1];\n\n  var listeners = createEvents();\n  var blockers = createEvents();\n\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState(_extends({}, globalHistory.state, {\n      idx: index\n    }), '');\n  }\n\n  function createHref(to) {\n    return typeof to === 'string' ? to : createPath(to);\n  } // state defaults to `null` because `window.history.state` does\n\n\n  function getNextLocation(to, state) {\n    if (state === void 0) {\n      state = null;\n    }\n\n    return readOnly(_extends({\n      pathname: location.pathname,\n      hash: '',\n      search: ''\n    }, typeof to === 'string' ? parsePath(to) : to, {\n      state: state,\n      key: createKey()\n    }));\n  }\n\n  function getHistoryStateAndUrl(nextLocation, index) {\n    return [{\n      usr: nextLocation.state,\n      key: nextLocation.key,\n      idx: index\n    }, createHref(nextLocation)];\n  }\n\n  function allowTx(action, location, retry) {\n    return !blockers.length || (blockers.call({\n      action: action,\n      location: location,\n      retry: retry\n    }), false);\n  }\n\n  function applyTx(nextAction) {\n    action = nextAction;\n\n    var _getIndexAndLocation3 = getIndexAndLocation();\n\n    index = _getIndexAndLocation3[0];\n    location = _getIndexAndLocation3[1];\n    listeners.call({\n      action: action,\n      location: location\n    });\n  }\n\n  function push(to, state) {\n    var nextAction = Action.Push;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      push(to, state);\n    }\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      var _getHistoryStateAndUr = getHistoryStateAndUrl(nextLocation, index + 1),\n          historyState = _getHistoryStateAndUr[0],\n          url = _getHistoryStateAndUr[1]; // TODO: Support forced reloading\n      // try...catch because iOS limits us to 100 pushState calls :/\n\n\n      try {\n        globalHistory.pushState(historyState, '', url);\n      } catch (error) {\n        // They are going to lose state here, but there is no real\n        // way to warn them about it since the page will refresh...\n        window.location.assign(url);\n      }\n\n      applyTx(nextAction);\n    }\n  }\n\n  function replace(to, state) {\n    var nextAction = Action.Replace;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      replace(to, state);\n    }\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      var _getHistoryStateAndUr2 = getHistoryStateAndUrl(nextLocation, index),\n          historyState = _getHistoryStateAndUr2[0],\n          url = _getHistoryStateAndUr2[1]; // TODO: Support forced reloading\n\n\n      globalHistory.replaceState(historyState, '', url);\n      applyTx(nextAction);\n    }\n  }\n\n  function go(delta) {\n    globalHistory.go(delta);\n  }\n\n  var history = {\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return location;\n    },\n\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    back: function back() {\n      go(-1);\n    },\n    forward: function forward() {\n      go(1);\n    },\n    listen: function listen(listener) {\n      return listeners.push(listener);\n    },\n    block: function block(blocker) {\n      var unblock = blockers.push(blocker);\n\n      if (blockers.length === 1) {\n        window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);\n      }\n\n      return function () {\n        unblock(); // Remove the beforeunload listener so the document may\n        // still be salvageable in the pagehide event.\n        // See https://html.spec.whatwg.org/#unloading-documents\n\n        if (!blockers.length) {\n          window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);\n        }\n      };\n    }\n  };\n  return history;\n}\n/**\r\n * Hash history stores the location in window.location.hash. This makes it ideal\r\n * for situations where you don't want to send the location to the server for\r\n * some reason, either because you do cannot configure it or the URL space is\r\n * reserved for something else.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\r\n */\n\nfunction createHashHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var _options2 = options,\n      _options2$window = _options2.window,\n      window = _options2$window === void 0 ? document.defaultView : _options2$window;\n  var globalHistory = window.history;\n\n  function getIndexAndLocation() {\n    var _parsePath = parsePath(window.location.hash.substr(1)),\n        _parsePath$pathname = _parsePath.pathname,\n        pathname = _parsePath$pathname === void 0 ? '/' : _parsePath$pathname,\n        _parsePath$search = _parsePath.search,\n        search = _parsePath$search === void 0 ? '' : _parsePath$search,\n        _parsePath$hash = _parsePath.hash,\n        hash = _parsePath$hash === void 0 ? '' : _parsePath$hash;\n\n    var state = globalHistory.state || {};\n    return [state.idx, readOnly({\n      pathname: pathname,\n      search: search,\n      hash: hash,\n      state: state.usr || null,\n      key: state.key || 'default'\n    })];\n  }\n\n  var blockedPopTx = null;\n\n  function handlePop() {\n    if (blockedPopTx) {\n      blockers.call(blockedPopTx);\n      blockedPopTx = null;\n    } else {\n      var nextAction = Action.Pop;\n\n      var _getIndexAndLocation4 = getIndexAndLocation(),\n          nextIndex = _getIndexAndLocation4[0],\n          nextLocation = _getIndexAndLocation4[1];\n\n      if (blockers.length) {\n        if (nextIndex != null) {\n          var delta = index - nextIndex;\n\n          if (delta) {\n            // Revert the POP\n            blockedPopTx = {\n              action: nextAction,\n              location: nextLocation,\n              retry: function retry() {\n                go(delta * -1);\n              }\n            };\n            go(delta);\n          }\n        } else {\n          // Trying to POP to a location with no index. We did not create\n          // this location, so we can't effectively block the navigation.\n          process.env.NODE_ENV !== \"production\" ? warning(false, // TODO: Write up a doc that explains our blocking strategy in\n          // detail and link to it here so people can understand better\n          // what is going on and how to avoid it.\n          \"You are trying to block a POP navigation to a location that was not \" + \"created by the history library. The block will fail silently in \" + \"production, but in general you should do all navigation with the \" + \"history library (instead of using window.history.pushState directly) \" + \"to avoid this situation.\") : void 0;\n        }\n      } else {\n        applyTx(nextAction);\n      }\n    }\n  }\n\n  window.addEventListener(PopStateEventType, handlePop); // popstate does not fire on hashchange in IE 11 and old (trident) Edge\n  // https://developer.mozilla.org/de/docs/Web/API/Window/popstate_event\n\n  window.addEventListener(HashChangeEventType, function () {\n    var _getIndexAndLocation5 = getIndexAndLocation(),\n        nextLocation = _getIndexAndLocation5[1]; // Ignore extraneous hashchange events.\n\n\n    if (createPath(nextLocation) !== createPath(location)) {\n      handlePop();\n    }\n  });\n  var action = Action.Pop;\n\n  var _getIndexAndLocation6 = getIndexAndLocation(),\n      index = _getIndexAndLocation6[0],\n      location = _getIndexAndLocation6[1];\n\n  var listeners = createEvents();\n  var blockers = createEvents();\n\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState(_extends({}, globalHistory.state, {\n      idx: index\n    }), '');\n  }\n\n  function getBaseHref() {\n    var base = document.querySelector('base');\n    var href = '';\n\n    if (base && base.getAttribute('href')) {\n      var url = window.location.href;\n      var hashIndex = url.indexOf('#');\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n\n    return href;\n  }\n\n  function createHref(to) {\n    return getBaseHref() + '#' + (typeof to === 'string' ? to : createPath(to));\n  }\n\n  function getNextLocation(to, state) {\n    if (state === void 0) {\n      state = null;\n    }\n\n    return readOnly(_extends({\n      pathname: location.pathname,\n      hash: '',\n      search: ''\n    }, typeof to === 'string' ? parsePath(to) : to, {\n      state: state,\n      key: createKey()\n    }));\n  }\n\n  function getHistoryStateAndUrl(nextLocation, index) {\n    return [{\n      usr: nextLocation.state,\n      key: nextLocation.key,\n      idx: index\n    }, createHref(nextLocation)];\n  }\n\n  function allowTx(action, location, retry) {\n    return !blockers.length || (blockers.call({\n      action: action,\n      location: location,\n      retry: retry\n    }), false);\n  }\n\n  function applyTx(nextAction) {\n    action = nextAction;\n\n    var _getIndexAndLocation7 = getIndexAndLocation();\n\n    index = _getIndexAndLocation7[0];\n    location = _getIndexAndLocation7[1];\n    listeners.call({\n      action: action,\n      location: location\n    });\n  }\n\n  function push(to, state) {\n    var nextAction = Action.Push;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      push(to, state);\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(nextLocation.pathname.charAt(0) === '/', \"Relative pathnames are not supported in hash history.push(\" + JSON.stringify(to) + \")\") : void 0;\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      var _getHistoryStateAndUr3 = getHistoryStateAndUrl(nextLocation, index + 1),\n          historyState = _getHistoryStateAndUr3[0],\n          url = _getHistoryStateAndUr3[1]; // TODO: Support forced reloading\n      // try...catch because iOS limits us to 100 pushState calls :/\n\n\n      try {\n        globalHistory.pushState(historyState, '', url);\n      } catch (error) {\n        // They are going to lose state here, but there is no real\n        // way to warn them about it since the page will refresh...\n        window.location.assign(url);\n      }\n\n      applyTx(nextAction);\n    }\n  }\n\n  function replace(to, state) {\n    var nextAction = Action.Replace;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      replace(to, state);\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(nextLocation.pathname.charAt(0) === '/', \"Relative pathnames are not supported in hash history.replace(\" + JSON.stringify(to) + \")\") : void 0;\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      var _getHistoryStateAndUr4 = getHistoryStateAndUrl(nextLocation, index),\n          historyState = _getHistoryStateAndUr4[0],\n          url = _getHistoryStateAndUr4[1]; // TODO: Support forced reloading\n\n\n      globalHistory.replaceState(historyState, '', url);\n      applyTx(nextAction);\n    }\n  }\n\n  function go(delta) {\n    globalHistory.go(delta);\n  }\n\n  var history = {\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return location;\n    },\n\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    back: function back() {\n      go(-1);\n    },\n    forward: function forward() {\n      go(1);\n    },\n    listen: function listen(listener) {\n      return listeners.push(listener);\n    },\n    block: function block(blocker) {\n      var unblock = blockers.push(blocker);\n\n      if (blockers.length === 1) {\n        window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);\n      }\n\n      return function () {\n        unblock(); // Remove the beforeunload listener so the document may\n        // still be salvageable in the pagehide event.\n        // See https://html.spec.whatwg.org/#unloading-documents\n\n        if (!blockers.length) {\n          window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);\n        }\n      };\n    }\n  };\n  return history;\n}\n/**\r\n * Memory history stores the current location in memory. It is designed for use\r\n * in stateful non-browser environments like tests and React Native.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#creatememoryhistory\r\n */\n\nfunction createMemoryHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var _options3 = options,\n      _options3$initialEntr = _options3.initialEntries,\n      initialEntries = _options3$initialEntr === void 0 ? ['/'] : _options3$initialEntr,\n      initialIndex = _options3.initialIndex;\n  var entries = initialEntries.map(function (entry) {\n    var location = readOnly(_extends({\n      pathname: '/',\n      search: '',\n      hash: '',\n      state: null,\n      key: createKey()\n    }, typeof entry === 'string' ? parsePath(entry) : entry));\n    process.env.NODE_ENV !== \"production\" ? warning(location.pathname.charAt(0) === '/', \"Relative pathnames are not supported in createMemoryHistory({ initialEntries }) (invalid entry: \" + JSON.stringify(entry) + \")\") : void 0;\n    return location;\n  });\n  var index = clamp(initialIndex == null ? entries.length - 1 : initialIndex, 0, entries.length - 1);\n  var action = Action.Pop;\n  var location = entries[index];\n  var listeners = createEvents();\n  var blockers = createEvents();\n\n  function createHref(to) {\n    return typeof to === 'string' ? to : createPath(to);\n  }\n\n  function getNextLocation(to, state) {\n    if (state === void 0) {\n      state = null;\n    }\n\n    return readOnly(_extends({\n      pathname: location.pathname,\n      search: '',\n      hash: ''\n    }, typeof to === 'string' ? parsePath(to) : to, {\n      state: state,\n      key: createKey()\n    }));\n  }\n\n  function allowTx(action, location, retry) {\n    return !blockers.length || (blockers.call({\n      action: action,\n      location: location,\n      retry: retry\n    }), false);\n  }\n\n  function applyTx(nextAction, nextLocation) {\n    action = nextAction;\n    location = nextLocation;\n    listeners.call({\n      action: action,\n      location: location\n    });\n  }\n\n  function push(to, state) {\n    var nextAction = Action.Push;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      push(to, state);\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(location.pathname.charAt(0) === '/', \"Relative pathnames are not supported in memory history.push(\" + JSON.stringify(to) + \")\") : void 0;\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      applyTx(nextAction, nextLocation);\n    }\n  }\n\n  function replace(to, state) {\n    var nextAction = Action.Replace;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      replace(to, state);\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(location.pathname.charAt(0) === '/', \"Relative pathnames are not supported in memory history.replace(\" + JSON.stringify(to) + \")\") : void 0;\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      entries[index] = nextLocation;\n      applyTx(nextAction, nextLocation);\n    }\n  }\n\n  function go(delta) {\n    var nextIndex = clamp(index + delta, 0, entries.length - 1);\n    var nextAction = Action.Pop;\n    var nextLocation = entries[nextIndex];\n\n    function retry() {\n      go(delta);\n    }\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      index = nextIndex;\n      applyTx(nextAction, nextLocation);\n    }\n  }\n\n  var history = {\n    get index() {\n      return index;\n    },\n\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return location;\n    },\n\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    back: function back() {\n      go(-1);\n    },\n    forward: function forward() {\n      go(1);\n    },\n    listen: function listen(listener) {\n      return listeners.push(listener);\n    },\n    block: function block(blocker) {\n      return blockers.push(blocker);\n    }\n  };\n  return history;\n} ////////////////////////////////////////////////////////////////////////////////\n// UTILS\n////////////////////////////////////////////////////////////////////////////////\n\nfunction clamp(n, lowerBound, upperBound) {\n  return Math.min(Math.max(n, lowerBound), upperBound);\n}\n\nfunction promptBeforeUnload(event) {\n  // Cancel the event.\n  event.preventDefault(); // Chrome (and legacy IE) requires returnValue to be set.\n\n  event.returnValue = '';\n}\n\nfunction createEvents() {\n  var handlers = [];\n  return {\n    get length() {\n      return handlers.length;\n    },\n\n    push: function push(fn) {\n      handlers.push(fn);\n      return function () {\n        handlers = handlers.filter(function (handler) {\n          return handler !== fn;\n        });\n      };\n    },\n    call: function call(arg) {\n      handlers.forEach(function (fn) {\n        return fn && fn(arg);\n      });\n    }\n  };\n}\n\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n/**\r\n * Creates a string URL path from the given pathname, search, and hash components.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createpath\r\n */\n\n\nfunction createPath(_ref) {\n  var _ref$pathname = _ref.pathname,\n      pathname = _ref$pathname === void 0 ? '/' : _ref$pathname,\n      _ref$search = _ref.search,\n      search = _ref$search === void 0 ? '' : _ref$search,\n      _ref$hash = _ref.hash,\n      hash = _ref$hash === void 0 ? '' : _ref$hash;\n  if (search && search !== '?') pathname += search.charAt(0) === '?' ? search : '?' + search;\n  if (hash && hash !== '#') pathname += hash.charAt(0) === '#' ? hash : '#' + hash;\n  return pathname;\n}\n/**\r\n * Parses a string URL path into its separate pathname, search, and hash components.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#parsepath\r\n */\n\nfunction parsePath(path) {\n  var parsedPath = {};\n\n  if (path) {\n    var hashIndex = path.indexOf('#');\n\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n\n    var searchIndex = path.indexOf('?');\n\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n\n  return parsedPath;\n}\n\nexport { Action, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, parsePath };\n//# sourceMappingURL=index.js.map\n","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n  , undef;\n\n/**\n * Decode a URI encoded string.\n *\n * @param {String} input The URI encoded string.\n * @returns {String|Null} The decoded string.\n * @api private\n */\nfunction decode(input) {\n  try {\n    return decodeURIComponent(input.replace(/\\+/g, ' '));\n  } catch (e) {\n    return null;\n  }\n}\n\n/**\n * Attempts to encode a given input.\n *\n * @param {String} input The string that needs to be encoded.\n * @returns {String|Null} The encoded string.\n * @api private\n */\nfunction encode(input) {\n  try {\n    return encodeURIComponent(input);\n  } catch (e) {\n    return null;\n  }\n}\n\n/**\n * Simple query string parser.\n *\n * @param {String} query The query string that needs to be parsed.\n * @returns {Object}\n * @api public\n */\nfunction querystring(query) {\n  var parser = /([^=?#&]+)=?([^&]*)/g\n    , result = {}\n    , part;\n\n  while (part = parser.exec(query)) {\n    var key = decode(part[1])\n      , value = decode(part[2]);\n\n    //\n    // Prevent overriding of existing properties. This ensures that build-in\n    // methods like `toString` or __proto__ are not overriden by malicious\n    // querystrings.\n    //\n    // In the case if failed decoding, we want to omit the key/value pairs\n    // from the result.\n    //\n    if (key === null || value === null || key in result) continue;\n    result[key] = value;\n  }\n\n  return result;\n}\n\n/**\n * Transform a query string to an object.\n *\n * @param {Object} obj Object that should be transformed.\n * @param {String} prefix Optional prefix.\n * @returns {String}\n * @api public\n */\nfunction querystringify(obj, prefix) {\n  prefix = prefix || '';\n\n  var pairs = []\n    , value\n    , key;\n\n  //\n  // Optionally prefix with a '?' if needed\n  //\n  if ('string' !== typeof prefix) prefix = '?';\n\n  for (key in obj) {\n    if (has.call(obj, key)) {\n      value = obj[key];\n\n      //\n      // Edge cases where we actually want to encode the value to an empty\n      // string instead of the stringified value.\n      //\n      if (!value && (value === null || value === undef || isNaN(value))) {\n        value = '';\n      }\n\n      key = encode(key);\n      value = encode(value);\n\n      //\n      // If we failed to encode the strings, we should bail out as we don't\n      // want to add invalid strings to the query.\n      //\n      if (key === null || value === null) continue;\n      pairs.push(key +'='+ value);\n    }\n  }\n\n  return pairs.length ? prefix + pairs.join('&') : '';\n}\n\n//\n// Expose the module.\n//\nexports.stringify = querystringify;\nexports.parse = querystring;\n","'use strict';\n\n/**\n * Check if we're required to add a port number.\n *\n * @see https://url.spec.whatwg.org/#default-port\n * @param {Number|String} port Port number we need to check\n * @param {String} protocol Protocol we need to check against.\n * @returns {Boolean} Is it a default port for the given protocol\n * @api private\n */\nmodule.exports = function required(port, protocol) {\n  protocol = protocol.split(':')[0];\n  port = +port;\n\n  if (!port) return false;\n\n  switch (protocol) {\n    case 'http':\n    case 'ws':\n    return port !== 80;\n\n    case 'https':\n    case 'wss':\n    return port !== 443;\n\n    case 'ftp':\n    return port !== 21;\n\n    case 'gopher':\n    return port !== 70;\n\n    case 'file':\n    return false;\n  }\n\n  return port !== 0;\n};\n","/**\n * url Config for de cluttering endpoints so that we can change it in one place and it will reflect\n * across the whole code base, eventually we can make one for prod but just dev for right now\n * stgWacInternalUrl(formerly): \"qa-wac.internal.atlassian.com\"\n */\n\n\nexport const stgConfig = {\n  stgWacInternalUrl: \"https://wac.stg.internal.atlassian.com\"\n};\n\nexport default stgConfig;\n","/*!\n * mustache.js - Logic-less {{mustache}} templates with JavaScript\n * http://github.com/janl/mustache.js\n */\n\nvar objectToString = Object.prototype.toString;\nvar isArray = Array.isArray || function isArrayPolyfill (object) {\n  return objectToString.call(object) === '[object Array]';\n};\n\nfunction isFunction (object) {\n  return typeof object === 'function';\n}\n\n/**\n * More correct typeof string handling array\n * which normally returns typeof 'object'\n */\nfunction typeStr (obj) {\n  return isArray(obj) ? 'array' : typeof obj;\n}\n\nfunction escapeRegExp (string) {\n  return string.replace(/[\\-\\[\\]{}()*+?.,\\\\\\^$|#\\s]/g, '\\\\$&');\n}\n\n/**\n * Null safe way of checking whether or not an object,\n * including its prototype, has a given property\n */\nfunction hasProperty (obj, propName) {\n  return obj != null && typeof obj === 'object' && (propName in obj);\n}\n\n/**\n * Safe way of detecting whether or not the given thing is a primitive and\n * whether it has the given property\n */\nfunction primitiveHasOwnProperty (primitive, propName) {\n  return (\n    primitive != null\n    && typeof primitive !== 'object'\n    && primitive.hasOwnProperty\n    && primitive.hasOwnProperty(propName)\n  );\n}\n\n// Workaround for https://issues.apache.org/jira/browse/COUCHDB-577\n// See https://github.com/janl/mustache.js/issues/189\nvar regExpTest = RegExp.prototype.test;\nfunction testRegExp (re, string) {\n  return regExpTest.call(re, string);\n}\n\nvar nonSpaceRe = /\\S/;\nfunction isWhitespace (string) {\n  return !testRegExp(nonSpaceRe, string);\n}\n\nvar entityMap = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;',\n  \"'\": '&#39;',\n  '/': '&#x2F;',\n  '`': '&#x60;',\n  '=': '&#x3D;'\n};\n\nfunction escapeHtml (string) {\n  return String(string).replace(/[&<>\"'`=\\/]/g, function fromEntityMap (s) {\n    return entityMap[s];\n  });\n}\n\nvar whiteRe = /\\s*/;\nvar spaceRe = /\\s+/;\nvar equalsRe = /\\s*=/;\nvar curlyRe = /\\s*\\}/;\nvar tagRe = /#|\\^|\\/|>|\\{|&|=|!/;\n\n/**\n * Breaks up the given `template` string into a tree of tokens. If the `tags`\n * argument is given here it must be an array with two string values: the\n * opening and closing tags used in the template (e.g. [ \"<%\", \"%>\" ]). Of\n * course, the default is to use mustaches (i.e. mustache.tags).\n *\n * A token is an array with at least 4 elements. The first element is the\n * mustache symbol that was used inside the tag, e.g. \"#\" or \"&\". If the tag\n * did not contain a symbol (i.e. {{myValue}}) this element is \"name\". For\n * all text that appears outside a symbol this element is \"text\".\n *\n * The second element of a token is its \"value\". For mustache tags this is\n * whatever else was inside the tag besides the opening symbol. For text tokens\n * this is the text itself.\n *\n * The third and fourth elements of the token are the start and end indices,\n * respectively, of the token in the original template.\n *\n * Tokens that are the root node of a subtree contain two more elements: 1) an\n * array of tokens in the subtree and 2) the index in the original template at\n * which the closing tag for that section begins.\n *\n * Tokens for partials also contain two more elements: 1) a string value of\n * indendation prior to that tag and 2) the index of that tag on that line -\n * eg a value of 2 indicates the partial is the third tag on this line.\n */\nfunction parseTemplate (template, tags) {\n  if (!template)\n    return [];\n  var lineHasNonSpace = false;\n  var sections = [];     // Stack to hold section tokens\n  var tokens = [];       // Buffer to hold the tokens\n  var spaces = [];       // Indices of whitespace tokens on the current line\n  var hasTag = false;    // Is there a {{tag}} on the current line?\n  var nonSpace = false;  // Is there a non-space char on the current line?\n  var indentation = '';  // Tracks indentation for tags that use it\n  var tagIndex = 0;      // Stores a count of number of tags encountered on a line\n\n  // Strips all whitespace tokens array for the current line\n  // if there was a {{#tag}} on it and otherwise only space.\n  function stripSpace () {\n    if (hasTag && !nonSpace) {\n      while (spaces.length)\n        delete tokens[spaces.pop()];\n    } else {\n      spaces = [];\n    }\n\n    hasTag = false;\n    nonSpace = false;\n  }\n\n  var openingTagRe, closingTagRe, closingCurlyRe;\n  function compileTags (tagsToCompile) {\n    if (typeof tagsToCompile === 'string')\n      tagsToCompile = tagsToCompile.split(spaceRe, 2);\n\n    if (!isArray(tagsToCompile) || tagsToCompile.length !== 2)\n      throw new Error('Invalid tags: ' + tagsToCompile);\n\n    openingTagRe = new RegExp(escapeRegExp(tagsToCompile[0]) + '\\\\s*');\n    closingTagRe = new RegExp('\\\\s*' + escapeRegExp(tagsToCompile[1]));\n    closingCurlyRe = new RegExp('\\\\s*' + escapeRegExp('}' + tagsToCompile[1]));\n  }\n\n  compileTags(tags || mustache.tags);\n\n  var scanner = new Scanner(template);\n\n  var start, type, value, chr, token, openSection;\n  while (!scanner.eos()) {\n    start = scanner.pos;\n\n    // Match any text between tags.\n    value = scanner.scanUntil(openingTagRe);\n\n    if (value) {\n      for (var i = 0, valueLength = value.length; i < valueLength; ++i) {\n        chr = value.charAt(i);\n\n        if (isWhitespace(chr)) {\n          spaces.push(tokens.length);\n          indentation += chr;\n        } else {\n          nonSpace = true;\n          lineHasNonSpace = true;\n          indentation += ' ';\n        }\n\n        tokens.push([ 'text', chr, start, start + 1 ]);\n        start += 1;\n\n        // Check for whitespace on the current line.\n        if (chr === '\\n') {\n          stripSpace();\n          indentation = '';\n          tagIndex = 0;\n          lineHasNonSpace = false;\n        }\n      }\n    }\n\n    // Match the opening tag.\n    if (!scanner.scan(openingTagRe))\n      break;\n\n    hasTag = true;\n\n    // Get the tag type.\n    type = scanner.scan(tagRe) || 'name';\n    scanner.scan(whiteRe);\n\n    // Get the tag value.\n    if (type === '=') {\n      value = scanner.scanUntil(equalsRe);\n      scanner.scan(equalsRe);\n      scanner.scanUntil(closingTagRe);\n    } else if (type === '{') {\n      value = scanner.scanUntil(closingCurlyRe);\n      scanner.scan(curlyRe);\n      scanner.scanUntil(closingTagRe);\n      type = '&';\n    } else {\n      value = scanner.scanUntil(closingTagRe);\n    }\n\n    // Match the closing tag.\n    if (!scanner.scan(closingTagRe))\n      throw new Error('Unclosed tag at ' + scanner.pos);\n\n    if (type == '>') {\n      token = [ type, value, start, scanner.pos, indentation, tagIndex, lineHasNonSpace ];\n    } else {\n      token = [ type, value, start, scanner.pos ];\n    }\n    tagIndex++;\n    tokens.push(token);\n\n    if (type === '#' || type === '^') {\n      sections.push(token);\n    } else if (type === '/') {\n      // Check section nesting.\n      openSection = sections.pop();\n\n      if (!openSection)\n        throw new Error('Unopened section \"' + value + '\" at ' + start);\n\n      if (openSection[1] !== value)\n        throw new Error('Unclosed section \"' + openSection[1] + '\" at ' + start);\n    } else if (type === 'name' || type === '{' || type === '&') {\n      nonSpace = true;\n    } else if (type === '=') {\n      // Set the tags for the next time around.\n      compileTags(value);\n    }\n  }\n\n  stripSpace();\n\n  // Make sure there are no open sections when we're done.\n  openSection = sections.pop();\n\n  if (openSection)\n    throw new Error('Unclosed section \"' + openSection[1] + '\" at ' + scanner.pos);\n\n  return nestTokens(squashTokens(tokens));\n}\n\n/**\n * Combines the values of consecutive text tokens in the given `tokens` array\n * to a single token.\n */\nfunction squashTokens (tokens) {\n  var squashedTokens = [];\n\n  var token, lastToken;\n  for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {\n    token = tokens[i];\n\n    if (token) {\n      if (token[0] === 'text' && lastToken && lastToken[0] === 'text') {\n        lastToken[1] += token[1];\n        lastToken[3] = token[3];\n      } else {\n        squashedTokens.push(token);\n        lastToken = token;\n      }\n    }\n  }\n\n  return squashedTokens;\n}\n\n/**\n * Forms the given array of `tokens` into a nested tree structure where\n * tokens that represent a section have two additional items: 1) an array of\n * all tokens that appear in that section and 2) the index in the original\n * template that represents the end of that section.\n */\nfunction nestTokens (tokens) {\n  var nestedTokens = [];\n  var collector = nestedTokens;\n  var sections = [];\n\n  var token, section;\n  for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {\n    token = tokens[i];\n\n    switch (token[0]) {\n      case '#':\n      case '^':\n        collector.push(token);\n        sections.push(token);\n        collector = token[4] = [];\n        break;\n      case '/':\n        section = sections.pop();\n        section[5] = token[2];\n        collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;\n        break;\n      default:\n        collector.push(token);\n    }\n  }\n\n  return nestedTokens;\n}\n\n/**\n * A simple string scanner that is used by the template parser to find\n * tokens in template strings.\n */\nfunction Scanner (string) {\n  this.string = string;\n  this.tail = string;\n  this.pos = 0;\n}\n\n/**\n * Returns `true` if the tail is empty (end of string).\n */\nScanner.prototype.eos = function eos () {\n  return this.tail === '';\n};\n\n/**\n * Tries to match the given regular expression at the current position.\n * Returns the matched text if it can match, the empty string otherwise.\n */\nScanner.prototype.scan = function scan (re) {\n  var match = this.tail.match(re);\n\n  if (!match || match.index !== 0)\n    return '';\n\n  var string = match[0];\n\n  this.tail = this.tail.substring(string.length);\n  this.pos += string.length;\n\n  return string;\n};\n\n/**\n * Skips all text until the given regular expression can be matched. Returns\n * the skipped string, which is the entire tail if no match can be made.\n */\nScanner.prototype.scanUntil = function scanUntil (re) {\n  var index = this.tail.search(re), match;\n\n  switch (index) {\n    case -1:\n      match = this.tail;\n      this.tail = '';\n      break;\n    case 0:\n      match = '';\n      break;\n    default:\n      match = this.tail.substring(0, index);\n      this.tail = this.tail.substring(index);\n  }\n\n  this.pos += match.length;\n\n  return match;\n};\n\n/**\n * Represents a rendering context by wrapping a view object and\n * maintaining a reference to the parent context.\n */\nfunction Context (view, parentContext) {\n  this.view = view;\n  this.cache = { '.': this.view };\n  this.parent = parentContext;\n}\n\n/**\n * Creates a new context using the given view with this context\n * as the parent.\n */\nContext.prototype.push = function push (view) {\n  return new Context(view, this);\n};\n\n/**\n * Returns the value of the given name in this context, traversing\n * up the context hierarchy if the value is absent in this context's view.\n */\nContext.prototype.lookup = function lookup (name) {\n  var cache = this.cache;\n\n  var value;\n  if (cache.hasOwnProperty(name)) {\n    value = cache[name];\n  } else {\n    var context = this, intermediateValue, names, index, lookupHit = false;\n\n    while (context) {\n      if (name.indexOf('.') > 0) {\n        intermediateValue = context.view;\n        names = name.split('.');\n        index = 0;\n\n        /**\n         * Using the dot notion path in `name`, we descend through the\n         * nested objects.\n         *\n         * To be certain that the lookup has been successful, we have to\n         * check if the last object in the path actually has the property\n         * we are looking for. We store the result in `lookupHit`.\n         *\n         * This is specially necessary for when the value has been set to\n         * `undefined` and we want to avoid looking up parent contexts.\n         *\n         * In the case where dot notation is used, we consider the lookup\n         * to be successful even if the last \"object\" in the path is\n         * not actually an object but a primitive (e.g., a string, or an\n         * integer), because it is sometimes useful to access a property\n         * of an autoboxed primitive, such as the length of a string.\n         **/\n        while (intermediateValue != null && index < names.length) {\n          if (index === names.length - 1)\n            lookupHit = (\n              hasProperty(intermediateValue, names[index])\n              || primitiveHasOwnProperty(intermediateValue, names[index])\n            );\n\n          intermediateValue = intermediateValue[names[index++]];\n        }\n      } else {\n        intermediateValue = context.view[name];\n\n        /**\n         * Only checking against `hasProperty`, which always returns `false` if\n         * `context.view` is not an object. Deliberately omitting the check\n         * against `primitiveHasOwnProperty` if dot notation is not used.\n         *\n         * Consider this example:\n         * ```\n         * Mustache.render(\"The length of a football field is {{#length}}{{length}}{{/length}}.\", {length: \"100 yards\"})\n         * ```\n         *\n         * If we were to check also against `primitiveHasOwnProperty`, as we do\n         * in the dot notation case, then render call would return:\n         *\n         * \"The length of a football field is 9.\"\n         *\n         * rather than the expected:\n         *\n         * \"The length of a football field is 100 yards.\"\n         **/\n        lookupHit = hasProperty(context.view, name);\n      }\n\n      if (lookupHit) {\n        value = intermediateValue;\n        break;\n      }\n\n      context = context.parent;\n    }\n\n    cache[name] = value;\n  }\n\n  if (isFunction(value))\n    value = value.call(this.view);\n\n  return value;\n};\n\n/**\n * A Writer knows how to take a stream of tokens and render them to a\n * string, given a context. It also maintains a cache of templates to\n * avoid the need to parse the same template twice.\n */\nfunction Writer () {\n  this.templateCache = {\n    _cache: {},\n    set: function set (key, value) {\n      this._cache[key] = value;\n    },\n    get: function get (key) {\n      return this._cache[key];\n    },\n    clear: function clear () {\n      this._cache = {};\n    }\n  };\n}\n\n/**\n * Clears all cached templates in this writer.\n */\nWriter.prototype.clearCache = function clearCache () {\n  if (typeof this.templateCache !== 'undefined') {\n    this.templateCache.clear();\n  }\n};\n\n/**\n * Parses and caches the given `template` according to the given `tags` or\n * `mustache.tags` if `tags` is omitted,  and returns the array of tokens\n * that is generated from the parse.\n */\nWriter.prototype.parse = function parse (template, tags) {\n  var cache = this.templateCache;\n  var cacheKey = template + ':' + (tags || mustache.tags).join(':');\n  var isCacheEnabled = typeof cache !== 'undefined';\n  var tokens = isCacheEnabled ? cache.get(cacheKey) : undefined;\n\n  if (tokens == undefined) {\n    tokens = parseTemplate(template, tags);\n    isCacheEnabled && cache.set(cacheKey, tokens);\n  }\n  return tokens;\n};\n\n/**\n * High-level method that is used to render the given `template` with\n * the given `view`.\n *\n * The optional `partials` argument may be an object that contains the\n * names and templates of partials that are used in the template. It may\n * also be a function that is used to load partial templates on the fly\n * that takes a single argument: the name of the partial.\n *\n * If the optional `config` argument is given here, then it should be an\n * object with a `tags` attribute or an `escape` attribute or both.\n * If an array is passed, then it will be interpreted the same way as\n * a `tags` attribute on a `config` object.\n *\n * The `tags` attribute of a `config` object must be an array with two\n * string values: the opening and closing tags used in the template (e.g.\n * [ \"<%\", \"%>\" ]). The default is to mustache.tags.\n *\n * The `escape` attribute of a `config` object must be a function which\n * accepts a string as input and outputs a safely escaped string.\n * If an `escape` function is not provided, then an HTML-safe string\n * escaping function is used as the default.\n */\nWriter.prototype.render = function render (template, view, partials, config) {\n  var tags = this.getConfigTags(config);\n  var tokens = this.parse(template, tags);\n  var context = (view instanceof Context) ? view : new Context(view, undefined);\n  return this.renderTokens(tokens, context, partials, template, config);\n};\n\n/**\n * Low-level method that renders the given array of `tokens` using\n * the given `context` and `partials`.\n *\n * Note: The `originalTemplate` is only ever used to extract the portion\n * of the original template that was contained in a higher-order section.\n * If the template doesn't use higher-order sections, this argument may\n * be omitted.\n */\nWriter.prototype.renderTokens = function renderTokens (tokens, context, partials, originalTemplate, config) {\n  var buffer = '';\n\n  var token, symbol, value;\n  for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {\n    value = undefined;\n    token = tokens[i];\n    symbol = token[0];\n\n    if (symbol === '#') value = this.renderSection(token, context, partials, originalTemplate, config);\n    else if (symbol === '^') value = this.renderInverted(token, context, partials, originalTemplate, config);\n    else if (symbol === '>') value = this.renderPartial(token, context, partials, config);\n    else if (symbol === '&') value = this.unescapedValue(token, context);\n    else if (symbol === 'name') value = this.escapedValue(token, context, config);\n    else if (symbol === 'text') value = this.rawValue(token);\n\n    if (value !== undefined)\n      buffer += value;\n  }\n\n  return buffer;\n};\n\nWriter.prototype.renderSection = function renderSection (token, context, partials, originalTemplate, config) {\n  var self = this;\n  var buffer = '';\n  var value = context.lookup(token[1]);\n\n  // This function is used to render an arbitrary template\n  // in the current context by higher-order sections.\n  function subRender (template) {\n    return self.render(template, context, partials, config);\n  }\n\n  if (!value) return;\n\n  if (isArray(value)) {\n    for (var j = 0, valueLength = value.length; j < valueLength; ++j) {\n      buffer += this.renderTokens(token[4], context.push(value[j]), partials, originalTemplate, config);\n    }\n  } else if (typeof value === 'object' || typeof value === 'string' || typeof value === 'number') {\n    buffer += this.renderTokens(token[4], context.push(value), partials, originalTemplate, config);\n  } else if (isFunction(value)) {\n    if (typeof originalTemplate !== 'string')\n      throw new Error('Cannot use higher-order sections without the original template');\n\n    // Extract the portion of the original template that the section contains.\n    value = value.call(context.view, originalTemplate.slice(token[3], token[5]), subRender);\n\n    if (value != null)\n      buffer += value;\n  } else {\n    buffer += this.renderTokens(token[4], context, partials, originalTemplate, config);\n  }\n  return buffer;\n};\n\nWriter.prototype.renderInverted = function renderInverted (token, context, partials, originalTemplate, config) {\n  var value = context.lookup(token[1]);\n\n  // Use JavaScript's definition of falsy. Include empty arrays.\n  // See https://github.com/janl/mustache.js/issues/186\n  if (!value || (isArray(value) && value.length === 0))\n    return this.renderTokens(token[4], context, partials, originalTemplate, config);\n};\n\nWriter.prototype.indentPartial = function indentPartial (partial, indentation, lineHasNonSpace) {\n  var filteredIndentation = indentation.replace(/[^ \\t]/g, '');\n  var partialByNl = partial.split('\\n');\n  for (var i = 0; i < partialByNl.length; i++) {\n    if (partialByNl[i].length && (i > 0 || !lineHasNonSpace)) {\n      partialByNl[i] = filteredIndentation + partialByNl[i];\n    }\n  }\n  return partialByNl.join('\\n');\n};\n\nWriter.prototype.renderPartial = function renderPartial (token, context, partials, config) {\n  if (!partials) return;\n  var tags = this.getConfigTags(config);\n\n  var value = isFunction(partials) ? partials(token[1]) : partials[token[1]];\n  if (value != null) {\n    var lineHasNonSpace = token[6];\n    var tagIndex = token[5];\n    var indentation = token[4];\n    var indentedValue = value;\n    if (tagIndex == 0 && indentation) {\n      indentedValue = this.indentPartial(value, indentation, lineHasNonSpace);\n    }\n    var tokens = this.parse(indentedValue, tags);\n    return this.renderTokens(tokens, context, partials, indentedValue, config);\n  }\n};\n\nWriter.prototype.unescapedValue = function unescapedValue (token, context) {\n  var value = context.lookup(token[1]);\n  if (value != null)\n    return value;\n};\n\nWriter.prototype.escapedValue = function escapedValue (token, context, config) {\n  var escape = this.getConfigEscape(config) || mustache.escape;\n  var value = context.lookup(token[1]);\n  if (value != null)\n    return (typeof value === 'number' && escape === mustache.escape) ? String(value) : escape(value);\n};\n\nWriter.prototype.rawValue = function rawValue (token) {\n  return token[1];\n};\n\nWriter.prototype.getConfigTags = function getConfigTags (config) {\n  if (isArray(config)) {\n    return config;\n  }\n  else if (config && typeof config === 'object') {\n    return config.tags;\n  }\n  else {\n    return undefined;\n  }\n};\n\nWriter.prototype.getConfigEscape = function getConfigEscape (config) {\n  if (config && typeof config === 'object' && !isArray(config)) {\n    return config.escape;\n  }\n  else {\n    return undefined;\n  }\n};\n\nvar mustache = {\n  name: 'mustache.js',\n  version: '4.2.0',\n  tags: [ '{{', '}}' ],\n  clearCache: undefined,\n  escape: undefined,\n  parse: undefined,\n  render: undefined,\n  Scanner: undefined,\n  Context: undefined,\n  Writer: undefined,\n  /**\n   * Allows a user to override the default caching strategy, by providing an\n   * object with set, get and clear methods. This can also be used to disable\n   * the cache by setting it to the literal `undefined`.\n   */\n  set templateCache (cache) {\n    defaultWriter.templateCache = cache;\n  },\n  /**\n   * Gets the default or overridden caching object from the default writer.\n   */\n  get templateCache () {\n    return defaultWriter.templateCache;\n  }\n};\n\n// All high-level mustache.* functions use this writer.\nvar defaultWriter = new Writer();\n\n/**\n * Clears all cached templates in the default writer.\n */\nmustache.clearCache = function clearCache () {\n  return defaultWriter.clearCache();\n};\n\n/**\n * Parses and caches the given template in the default writer and returns the\n * array of tokens it contains. Doing this ahead of time avoids the need to\n * parse templates on the fly as they are rendered.\n */\nmustache.parse = function parse (template, tags) {\n  return defaultWriter.parse(template, tags);\n};\n\n/**\n * Renders the `template` with the given `view`, `partials`, and `config`\n * using the default writer.\n */\nmustache.render = function render (template, view, partials, config) {\n  if (typeof template !== 'string') {\n    throw new TypeError('Invalid template! Template should be a \"string\" ' +\n                        'but \"' + typeStr(template) + '\" was given as the first ' +\n                        'argument for mustache#render(template, view, partials)');\n  }\n\n  return defaultWriter.render(template, view, partials, config);\n};\n\n// Export the escaping function so that the user may override it.\n// See https://github.com/janl/mustache.js/issues/244\nmustache.escape = escapeHtml;\n\n// Export these mainly for testing, but also for advanced usage.\nmustache.Scanner = Scanner;\nmustache.Context = Context;\nmustache.Writer = Writer;\n\nexport default mustache;\n","import { createBrowserHistory } from 'history';\n\nimport * as $ from \"jquery\";\nimport algoliasearch from 'algoliasearch';\nimport { AlgoliaSearchHelper } from 'algoliasearch-helper';\nimport type { SearchResults } from 'algoliasearch-helper';\nimport ellipsize from 'ellipsize';\nimport mustache from 'mustache';\nimport parse from 'url-parse';\nimport browser from \"../../utils/browser\";\nimport url from '../../utils/url';\n\nfunction debounce(func: Function, wait: number, immediate?: boolean) {\n  let timeout: NodeJS.Timeout | null;\n  return function () {\n    // @ts-ignore\n    const context = this;\n    const args = arguments;\n\n    timeout && clearTimeout(timeout);\n    timeout = setTimeout(function () {\n      timeout = null;\n      if (!immediate) func.apply(context, args);\n    }, wait);\n    if (immediate && !timeout) func.apply(context, args);\n  };\n}\n\n/**\n * @type {Object}\n */\nconst history = createBrowserHistory();\n\n/**\n * Maximum number of pages to load automatically on scroll.\n * @type {number}\n */\nconst MAX_AUTO_LOAD_PAGES = 2;\n\nconst SEARCH_STATE = {\n  error: 'wac-search__state--error',\n  idle: 'wac-search__state--idle',\n  hasMoreResults: 'wac-search__state--has-more-results',\n  loading: 'wac-search__state--loading',\n  noMoreResults: 'wac-search__state--no-more-results',\n  noResults: 'wac-search__state--no-results'\n};\n\nconst ERROR_STATE = 'error';\nconst IDLE_STATE = 'idle';\nconst HAS_MORE_RESULTS_STATE = 'hasMoreResults';\nconst LOADING_STATE = 'loading';\n\nconst CONTAINER_LOADING_CLASS = 'loading';\nconst ERROR_TEMPLATE_ID = 'wac-search__error-template';\nconst EVENT_SCROLL_AUTOLOAD_RESULTS = 'scroll.loadNextPage';\nconst FACET_LOAD_CLASS = 'load';\nconst FACET_SELECTED_CLASS = 'selected';\nconst FACETS_TEMPLATE_ID = 'wac-search__search-facets-template';\nconst FIXED_MENU_BOTTOM_CLASS = 'fixed-menu-bottom';\nconst FIXED_MENU_CLASS = 'fixed-menu';\nconst NO_RESULTS_TEMPLATE_ID = 'wac-search__no-results-template';\nconst RESULTS_LINK_CLASS = 'results-wrapper--organic';\nconst RESULTS_TEMPLATE_ID = 'wac-search__search-results-template';\nconst SNIPPET_MAX_LENGTH = 300;\n\n// Algolia stuff\nconst ALGOLIA_APP_ID = 'CU5KFWE75C';\nconst ALGOLIA_SEARCH_API_KEY = '8cb0497a0549da256319b1b8178e5421';\nconst ALGOLIA_SEARCH_INDEX_NAME = 'www.atlassian.com.v1';\nconst ALGOLIA_FACET_KEY = 'category';\nconst ALGOLIA_SNIPPET_KEY = 'description';\nconst algoliaSearchClient = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY);\n\nclass WacSearch {\n  $searchContainer: JQuery<HTMLElement>;\n  $facetsList: JQuery<HTMLElement>;\n  $loadButton: JQuery<HTMLElement>;\n  $results: JQuery<HTMLElement>;\n  $searchForm: JQuery<HTMLElement>;\n  $searchInput: JQuery<HTMLElement>;\n  $globalHeader: JQuery<HTMLElement>;\n  $globalFooter: JQuery<HTMLElement>;\n  hasNextPage: boolean;\n  searchHelper: AlgoliaSearchHelper;\n  activeQuery: any;\n  activeFacet: any;\n\n  constructor() {\n    this.$searchContainer = $('#atlassianSearch');\n\n    this.$facetsList   = $('#wac-search__facet-list');\n    this.$loadButton   = $('#wac-search__load-results-button');\n    this.$results      = $('#wac-search__search-results-container');\n    this.$searchForm   = $('#wac-search__search-page-form');\n    this.$searchInput  = $('#wac-search__search-page-input');\n    this.$globalHeader = $('body > header');\n    this.$globalFooter = $('body > footer');\n    this.hasNextPage   = false;\n\n    this.searchHelper = new AlgoliaSearchHelper(algoliaSearchClient, ALGOLIA_SEARCH_INDEX_NAME, {\n      facets: [ALGOLIA_FACET_KEY]\n    });\n  }\n\n  /**\n   * Initialize the \"search\" application.\n   */\n  init() {\n    var urlVal = parse(window.location, true);\n\n    this.activeQuery = urlVal.query.q ? url.htmlEscape(encodeURIComponent(urlVal.query.q)) : null;\n    this.activeFacet = urlVal.query.f ? url.htmlEscape(encodeURIComponent(urlVal.query.f)) : null;\n\n    this.bindEvents();\n  }\n\n  /**\n   * Do all the things!\n   */\n  bindEvents() {\n\n    /**\n     * When the page loads with a \"query\" or (optionally) a \"facet\" URL parameters,\n     * the page's search form should reflect these inputs as well as display results for them.\n     */\n\n    this.search(this.activeQuery, this.activeFacet);\n\n    /**\n     * When a facet is clicked on,\n     * the all facets will be removed from the query and the results updated.\n     */\n    this.$facetsList.on('click', 'a', (e) => {\n\n      e.preventDefault();\n\n      const $facetLink = $(e.currentTarget);\n      const query = $facetLink.attr('data-q');\n      const facet = $facetLink.attr('data-f');\n\n      let newUrl = `?q=${query}`;\n      if (facet) {\n        newUrl += `&f=${facet}`;\n      }\n\n      history.push(newUrl);\n    });\n\n    /**\n     * When the URL changes, update the search results.\n     */\n    history.listen(({ action, location }) => {\n\n      if (action === 'PUSH' || action === 'POP') {\n\n        const urlVal = parse(location.search, true);\n        const query = urlVal.query.q ? url.htmlEscape(encodeURIComponent(urlVal.query.q)) : null;\n        const facet = urlVal.query.f ? url.htmlEscape(encodeURIComponent(urlVal.query.f)) : null;\n\n        $('title').text(`${query} | Search | Atlassian`);\n\n        this.activeQuery = query;\n        this.activeFacet = facet;\n\n        this.search(query, facet);\n      }\n    });\n\n    /**\n     * Hijax search form submission.\n     */\n    this.$searchForm.on('submit', e => {\n\n      e.preventDefault();\n\n      const serializeFormData = $(e.currentTarget).serialize();\n\n      history.push(`?${serializeFormData}`);\n    });\n\n    /**\n     * Manually load more results when clicking button.\n     */\n    this.$loadButton.on('click', this.$searchContainer, () => {\n      this.goToNextPage();\n    });\n\n    /**\n     * Make the facet nav sticky.\n     */\n    $(window).on('scroll', this.repositionFacetNav.bind(this));\n\n    /**\n     * Assign width to facets list so it renders properly when 'display: fixed' is applied\n     */\n    if (!browser.isMobile()) {\n      this.setFacetWidth();\n    }\n\n    const screenWidth = $(window).width();\n    $(window).on(\"resize\", debounce(() => {\n      if ($(window).width() !== screenWidth) {\n        this.setFacetWidth();\n      }\n    }, 500));\n\n    /**\n     * Do all the Algoia things!\n     */\n    this.bindAlgoliaEvents();\n  }\n\n  /**\n   * Bind Algolia events.\n   */\n  bindAlgoliaEvents() {\n\n    /**\n     * Do this at the end of every search or error.\n     * @param {Object} results\n     * @param {Object} error\n     */\n    const onCompleteSearch = (results: SearchResults | null, error?: Error) => {\n      this.$searchContainer.removeClass(CONTAINER_LOADING_CLASS);\n      this.$facetsList.find('a').removeClass(FACET_LOAD_CLASS);\n\n      if (error) {\n        this.setState(ERROR_STATE);\n      } else if (!results?.nbHits) {\n        this.setState(IDLE_STATE);\n      } else {\n        if (this.hasNextPage) {\n          if (results.page >= MAX_AUTO_LOAD_PAGES) {\n            this.setState(HAS_MORE_RESULTS_STATE);\n          } else {\n            this.setState(LOADING_STATE);\n          }\n        } else {\n          this.setState(IDLE_STATE);\n        }\n      }\n    };\n\n    /**\n     * The \"this.searchHelper\" object maintains the status of the search results.\n     * Do this any time it changes.\n     */\n    this.searchHelper.on('change', () => {\n      // Refresh the facet links\n      this.renderFacetsNav();\n    });\n\n    /**\n     * Do this as soon as you send the search request.\n     */\n    this.searchHelper.on('search', ({ state }) => {\n\n      // Display \"loading\" icon next to the facet link\n      let $facetLink;\n      if (state.facetsRefinements.hasOwnProperty(ALGOLIA_FACET_KEY)) {\n        const facet = state.facetsRefinements[ALGOLIA_FACET_KEY][0];\n        $facetLink = this.$facetsList.find(`a[data-f=\"${facet}\"]`);\n      } else {\n        $facetLink = this.$facetsList.find('a').first();\n      }\n      $facetLink.addClass(FACET_LOAD_CLASS);\n    });\n\n    /**\n     * Do this when you get a search response.\n     */\n    this.searchHelper.on('result', ({ results, state }) => {\n\n      this.hasNextPage = (results.nbPages - 1) > results.page;\n\n      // If we got any   results\n      if (results.nbHits) {\n        const hits = Object.keys(results.hits).map(index => {\n          let hit = results.hits[index as unknown as number];\n          if (hit.hasOwnProperty(ALGOLIA_SNIPPET_KEY)) {\n            hit[ALGOLIA_SNIPPET_KEY] = ellipsize(hit[ALGOLIA_SNIPPET_KEY], SNIPPET_MAX_LENGTH);\n          }\n          return hit;\n        }) as unknown as SearchResults;\n\n        // If this is a new query\n        if (results.page == 0) {\n          this.renderFacetsNav();\n\n          this.renderResults(hits);\n\n          // Clear currently highlighted facet\n          this.$facetsList.find(`a.${FACET_SELECTED_CLASS}`).removeClass(FACET_SELECTED_CLASS);\n\n          // Highlight selected facet\n          let $facetLink;\n          if (this.activeFacet) {\n            $facetLink = this.$facetsList.find(`a[data-f=\"${this.activeFacet}\"]`);\n          } else {\n            $facetLink = this.$facetsList.find('a').first();\n          }\n          $facetLink.addClass(FACET_SELECTED_CLASS);\n\n          // Activate autoloading if there are more pages\n          if (this.hasNextPage) {\n            this.initAutoloadResults();\n          }\n        }\n\n        // If it's not a new query, then we're fetching the next page.\n        else {\n          this.renderNextPage(hits);\n\n          // Stop autoloading results if we can't or don't want to.\n          if (state.page === MAX_AUTO_LOAD_PAGES || !this.hasNextPage) {\n            $(window).off(EVENT_SCROLL_AUTOLOAD_RESULTS);\n          }\n        }\n      } else {\n        this.setState(IDLE_STATE);\n        this.renderNoResults();\n      }\n\n      onCompleteSearch(results);\n    });\n\n    /**\n     * Something went wrong with the query, do something about it.\n     * This can be triggered by, for example, providing a wrong index name.\n     */\n    this.searchHelper.on('error', ({ error }) => {\n      onCompleteSearch(null, error);\n      this.renderError();\n    });\n  }\n\n  /**\n   * Increase the current page by 1, then search for the corresponding results.\n   */\n  goToNextPage() {\n    this.searchHelper.nextPage();\n    this.searchHelper.search();\n  }\n\n  /**\n   * Automatically load more results as you scroll down.\n   * This is triggered when you scroll to the top of the las result.\n   */\n  initAutoloadResults() {\n    $(window).on(EVENT_SCROLL_AUTOLOAD_RESULTS, debounce(() => {\n      if (this.$results.find(`.${RESULTS_LINK_CLASS}`).length) {\n        if (window.scrollY + $('body').height() > this.$results.find(`.${RESULTS_LINK_CLASS}`).eq(-8).offset().top) {\n          this.goToNextPage();\n        }\n      }\n    }, 600));\n  }\n\n  /**\n   * Render generic error message.\n   */\n  renderError() {\n    const template = document.getElementById(ERROR_TEMPLATE_ID)?.innerHTML || '';\n    this.$results.html(template);\n  }\n\n  /**\n   * Render facet navigation.\n   */\n  renderFacetsNav() {\n\n    // This is a one-off search independent of the actual search results.\n    // We want to display all the available facets of the given query, that's why\n    // we have to perform a one-off search; we remove the active \"facet\" so nothing\n    // is filtered out.\n    this.searchHelper.searchOnce({\n      hitsPerPage: 1,\n      facetsRefinements: {},\n      query: this.activeQuery\n    }, (error, content) => {\n      const facets = content.getFacetValues(ALGOLIA_FACET_KEY, {sortBy: ['name:asc']});\n\n      if (facets.length) {\n        const template = $(`#${FACETS_TEMPLATE_ID}`).html();\n        const output = mustache.render(template, {\n          facets: facets,\n          query: this.activeQuery\n        });\n\n        this.$facetsList.html(output);\n      } else {\n        this.$facetsList.html('');\n      }\n    });\n  }\n\n  /**\n   * Append the results of the next page to the bottom of the results.\n   * @param {Array} results\n   */\n  renderNextPage(results: SearchResults) {\n\n    const template = document.getElementById(RESULTS_TEMPLATE_ID)?.innerHTML;\n    const output = mustache.render(template, {\n      results: results,\n      hasNextPage: this.hasNextPage\n    });\n    this.$results.append(output);\n    this.repositionFacetNav();\n  }\n\n  /**\n   * No results. Let'em down easy.\n   */\n  renderNoResults() {\n\n    const template = document.getElementById(NO_RESULTS_TEMPLATE_ID)?.innerHTML || '';\n    this.$results.html(template);\n  }\n\n  /**\n   * Deliver the goods.\n   * @param {Array} results\n   */\n  renderResults(results: SearchResults) {\n\n    const template = document.getElementById(RESULTS_TEMPLATE_ID)?.innerHTML;\n    const output = mustache.render(template, {\n      results: results,\n      hasNextPage: this.hasNextPage\n    });\n    this.$results.html(output);\n  }\n\n  /**\n   * Make the facets-nav sticky when and where it should.\n   */\n  repositionFacetNav() {\n    var scrollTop = $(document).scrollTop();\n\n    // Stick facets list to top of window when scrolling through results\n    if (!browser.isMobile()) {\n      if (this.$results.height() > this.$facetsList.height()) {\n        const topOffset = (this.$globalHeader.outerHeight() + this.$searchForm.outerHeight() + 50);\n        const bottomOffset = this.$globalFooter.outerHeight();\n\n        if (scrollTop >= topOffset) {\n          this.$facetsList.addClass(FIXED_MENU_CLASS);\n\n          if ($(window).height() < (bottomOffset + this.$facetsList.outerHeight() ) && ( (scrollTop + $(window).height()) >= ($(document).height() - (bottomOffset + 30)) )) {\n            this.$facetsList.addClass(FIXED_MENU_BOTTOM_CLASS);\n          } else {\n            this.$facetsList.removeClass(FIXED_MENU_BOTTOM_CLASS);\n          }\n        } else {\n          this.$facetsList.removeClass(FIXED_MENU_CLASS);\n        }\n      }\n    }\n  }\n\n  /**\n   * Actually perform the search.\n   * @param {String} query\n   * @param {String} facet\n   */\n  search(query: string, facet: string) {\n\n    // If a query is available.\n    if (query) {\n\n      this.setState(LOADING_STATE);\n\n      query = decodeURIComponent(query);\n\n      this.searchHelper.setQuery(query);\n\n      // We have to remove any facet refinements so they're replaced and not added to the request.\n      this.searchHelper.removeFacetRefinement(ALGOLIA_FACET_KEY);\n      if (facet) {\n        this.searchHelper.addFacetRefinement(ALGOLIA_FACET_KEY, facet);\n      }\n\n      this.$searchInput.val(query.trim());\n      this.searchHelper.search();\n    }\n  }\n\n  /**\n   * Umm... set facet-nav width.\n   */\n  setFacetWidth() {\n    const parentWidth = this.$facetsList.parent('.facets-column').width();\n    this.$facetsList.width(parentWidth);\n  }\n\n  /**\n   * The state of the \"search\" application (loading, no-results, etc.)\n   * Not to be confused with \"searchHelper\" state.\n   *\n   * @param {String} newState\n   */\n  setState(newState) {\n    if (SEARCH_STATE.hasOwnProperty(newState)) {\n      Object.keys(SEARCH_STATE).forEach(state => {\n        const stateClass = SEARCH_STATE[state];\n        this.$searchContainer.removeClass(stateClass);\n      });\n\n      this.$searchContainer.addClass(SEARCH_STATE[newState]);\n    }\n  }\n}\n\n/**\n * Let's do this...\n */\nnew WacSearch().init();\n","import axios from 'axios';\nimport * as Sentry from \"@sentry/browser\";\n\n\nlet capturedEventsPromise: Array<Function> = [];\nlet onAnalyticsLoad = () => {\n  Promise.all(capturedEventsPromise.map(fn => fn()));\n};\n\nexport const piiScrub = (val: string) => {\n  return val.replace(\n    /(([^\\/]*@[^\\/]*\\.[^\\/]*)|([^\\/]*%40[^\\/]*\\.[^\\/]*))/g,\n    '[REDACTED]'\n  )\n}\n\nexport const trackEvent = function (event: string, data?: Record<string, any>) {\n  const trySentryErrorLog = () => {\n    try {\n      Sentry.captureMessage(\n        'Analytics wrapper errored',\n        Sentry.Severity.Error\n      );\n    } catch (error) {\n      // Intentionally leaving this blank since there's nothing we can do at this point  \n    }\n  }\n  // First try to use the atl-global wrapper\n  try {\n    if (typeof ace !== \"undefined\") {\n      ace.analytics.Tracking.trackEvent(event, data);\n    } else {\n      capturedEventsPromise.push(\n        () => new Promise((resolve) => {\n          trackEvent(event, data);\n          resolve(null);\n        })\n      );\n\n      window.segmentPageReady = onAnalyticsLoad;\n    }\n  } catch (error) {\n    trySentryErrorLog()\n  }\n};\n\n/**\n* Iterates through event keys, ensures that values are lowercase,\n* and replaces whitespace with `-` character\n**/\nexport const sanitizeEventProperties = function (propertiesObj) {\n  let result = {};\n  Object.keys(propertiesObj).map(key => {\n    // do a quick check just in case values are null\n    result[key] = propertiesObj[key] && propertiesObj[key].replace(/\\s+/g, '-').toLowerCase();\n  });\n  return result;\n}\n\nexport const trackGas = function (postBody) {\n  const analyticsApiUrl = 'https://mgas.prod.public.atl-paas.net/v1/event';\n  const options = {\n    headers: {\n      'content-type': 'application/json'\n    },\n    withCredentials: true\n  };\n\n  return axios.post(analyticsApiUrl, postBody, options)\n    .then(() => Promise.resolve());\n};\n","import stgConfig from \"../../../config\";\nconst ENV_DEV = \"dev\";\nconst ENV_STAGING = \"staging\";\nconst ENV_PRODUCTION = \"production\";\nconst ENV_AUTHOR = \"author\";\n\nexport default class Environment {\n  static getWindowLocation() {\n    return window.location;\n  }\n\n  static getSubdomain() {\n    const urlParts = this.getWindowLocation().hostname.split(\".\");\n\n    if (urlParts[1] === \"dev\") {\n      return \"localhost\";\n    }\n\n    return urlParts[0];\n  }\n\n  static getSubdirectory() {\n    const urlParts = this.getWindowLocation().pathname.split(\"/\");\n    if (urlParts[1] === \"wac\") {\n      return urlParts.length > 1 ? urlParts[2] : \"\";\n    } else {\n      return urlParts[1];\n    }\n  }\n\n  static isStagingPublicEnvironment() {\n    return (\n      this.getWindowLocation().hostname.indexOf(\"wac.stg.internal.atlassian\") >\n      -1 || this.getWindowLocation().hostname.indexOf(\"qa-wac.atlassian\") > -1\n    );\n  }\n\n  static getEnvironment() {\n    const forceStaging = window.location.search.includes('forceProdTesting=true');\n    \n    if (forceStaging) {\n      return ENV_PRODUCTION;\n    }\n    switch (this.getSubdomain()) {\n      case \"wac\":\n      case \"qa-wac\":\n      case \"author\":\n      case \"proof\":\n        return ENV_STAGING;\n      case \"localhost\":\n      case \"local\":\n        return ENV_DEV;\n      case \"truth\":\n      case \"www\":\n      case \"atlassian\":\n      case \"bitbucket\":\n      case \"sourcetreeapp\":\n      case \"agile\": \n      case \"git\":\n      case \"software\":\n        return ENV_PRODUCTION;\n      default:\n        /* for omlet instances */\n        return ENV_STAGING;\n    }\n  }\n\n  static getInternationalSubdomain() {\n    const hostnameSubdomain = this.getSubdomain();\n    const validLocales = [\n      \"cn\",\n      \"cs\",\n      \"de\",\n      \"es\",\n      \"fr\",\n      \"it\",\n      \"ko\",\n      \"hu\",\n      \"nl\",\n      \"ja\",\n      \"pl\",\n      \"br\",\n      \"ro\",\n      \"fi\",\n      \"ru\",\n    ];\n\n    if (validLocales.indexOf(hostnameSubdomain) === -1) {\n      return false;\n    }\n\n    return hostnameSubdomain;\n  }\n\n  static getInternationalSubdirectory() {\n    const subdirectory = this.getSubdirectory();\n    const validLocales = [\n      \"zh\",\n      \"cs\",\n      \"de\",\n      \"es\",\n      \"fr\",\n      \"it\",\n      \"ko\",\n      \"hu\",\n      \"nl\",\n      \"ja\",\n      \"pl\",\n      \"br\",\n      \"ro\",\n      \"fi\",\n      \"ru\",\n    ];\n\n    if (validLocales.indexOf(subdirectory) === -1) {\n      return false;\n    }\n\n    return subdirectory;\n  }\n\n  static isInternationalSubdomain() {\n    return !!this.getInternationalSubdomain();\n  }\n\n  static production() {\n    return ENV_PRODUCTION;\n  }\n\n  static staging() {\n    return ENV_STAGING;\n  }\n\n  static dev() {\n    return ENV_DEV;\n  }\n\n  static author() {\n    return ENV_AUTHOR;\n  }\n\n  static isProduction() {\n    return this.getEnvironment() === this.production();\n  }\n\n  static isStaging() {\n    return this.getEnvironment() === this.staging();\n  }\n\n  static isDev() {\n    return this.getEnvironment() === this.dev();\n  }\n\n  static isAuthor() {\n    return this.getSubdomain() === this.author();\n  }\n\n  static getIdentityBaseUrl() {\n    if (this.isStaging() || this.isDev()) {\n      return \"https://id.stg.internal.atlassian.com\";\n    } else {\n      return \"https://id.atlassian.com\";\n    }\n  }\n\n  static getLoginUrl(skipEncoding: boolean) {\n    const continueUrl = this.getWindowLocation().href;\n    if (!skipEncoding) {\n      return `${this.getIdentityBaseUrl()}/login?continue=${encodeURIComponent(\n        continueUrl\n      )}`;\n    } else {\n      return `${this.getIdentityBaseUrl()}/login?continue=${continueUrl}`;\n    }\n  }\n\n  static getLogoutUrl() {\n    const continueUrl = this.getWindowLocation().href;\n    return `${this.getIdentityBaseUrl()}/logout?continue=${encodeURIComponent(\n      continueUrl\n    )}`;\n  }\n\n  static getSwitchAccountURL(continueUrlParam?: string) {\n    const continueUrl = continueUrlParam ? continueUrlParam : this.getWindowLocation().href;\n    return `${this.getIdentityBaseUrl()}/login/select-account?continue=${encodeURIComponent(\n      continueUrl\n    )}`;\n  }\n  \n  static getManageProfileUrl(userEmail: string) {\n    const applicationParam = encodeURIComponent(\"wac\")\n    const continueUrlParam = encodeURIComponent(`${this.getIdentityBaseUrl()}/manage-profile`)\n    const loginHintParam = encodeURIComponent(userEmail)\n    \n    return `${this.getIdentityBaseUrl()}/login?application=${applicationParam}&continue=${continueUrlParam}&login_hint=${loginHintParam}`;\n  }\n\n  static getMacUrl() {\n    if (this.isStaging() || this.isDev()) {\n      return \"https://my.stg.internal.atlassian.com\";\n    } else {\n      return \"https://my.atlassian.com\";\n    }\n  }\n\n  static getStartUrl() {\n    if (this.isStaging() || this.isDev()) {\n      return \"https://start.stg.atlassian.com\";\n    } else {\n      return \"https://start.atlassian.com\";\n    }\n  }\n\n  static getAPIPrivateURL() {\n    if (this.isStaging() || this.isDev()) {\n      return \"https://wac.stg.internal.atlassian.com/gateway/api\";\n    }\n\n    return \"https://www.atlassian.com/gateway/api\";\n  }\n\n  static getMyAdminAtlasBaseURL() {\n    if (this.isStaging() || this.isDev()) {\n      return \"https://admin.stg.atlassian.com\";\n    }\n\n    return \"https://admin.atlassian.com\";\n  }\n\n  static getBaseURL() {\n    if (this.isStaging() || this.isDev()) {\n      return \"https://wac.stg.internal.atlassian.com\";\n    }\n\n    return \"https://www.atlassian.com\";\n  }\n\n  static getWacIntegrationUrl() {\n    if (this.isStaging() || this.isDev()) {\n      const useQaWAC =\n        window.location.hostname.indexOf(\"qa-wac\") > -1 ||\n        window.location.hostname.indexOf(\"author\") > -1;\n      return `${useQaWAC\n        ? \"https://qa-wac.internal.atlassian.com\"\n        : stgConfig.stgWacInternalUrl\n        }`;\n    } else {\n      return \"https://www.atlassian.com\";\n    }\n  }\n\n  static getProductTld = (): string => {\n    return this.getEnvironment() === ENV_PRODUCTION ? '.atlassian.net' : '.jira-dev.com';\n  };\n\n  static getBBIntegrationUrl() {\n    if (this.isStaging() || this.isDev()) {\n      return \"https://integration.bb-inf.net\";\n    } else {\n      return \"https://bitbucket.org\";\n    }\n  }\n}\n","import { trackAllPlatforms } from './platforms';\n\nclass Tracking {\n  /**\n   * Process the value attribute to remove newlines, if the value attribute exists.\n   *\n   * @param {any} attributes\n   */\n  processAttributes(attributes: { [x: string]: any; value?: any; }) {\n    if (!attributes) return {};\n\n    let { value, ...additionalAttributes } = attributes;\n    if (value) {\n      value = value.replace(/\\r?\\n|\\r/g, \"\");\n    }\n    return { value, ...additionalAttributes };\n  }\n\n  /**\n   * Send a tracking event to any tracking platforms defined in the `trackAllPlatforms` array.\n   *\n   * @param {string} category The event category, e.g. \"cart-cloud\" or \"bxp.formCloudSignup\".\n   * @param {string} action The action name, e.g. \"page-unload\" or \"time-to-form-ready\".\n   * @param {string} label An event label, e.g. \"form-event\" or \"signup-social-login\". Not used by all platforms.\n   * @param {any} attributes Additional attributes passed to the tracking platform.\n   * @param {boolean} isNonInteraction Whether or not the event is a non-interaction event (Google Analytics). See also, https://support.google.com/analytics/answer/1033068#NonInteractionEvents\n   */\n  trackAll(category: string, action: string, label: string, attributes = {}, isNonInteraction: boolean | undefined) {\n    const attrs = this.processAttributes(attributes);\n\n    trackAllPlatforms.forEach(platform => {\n      platform.track({\n        category,\n        action,\n        label,\n        attributes: attrs,\n        isNonInteraction,\n      });\n    })\n  }\n}\n\nexport { Tracking };\n\nexport default new Tracking();\n","import Environment from './environment';\n\nconst debug = Environment.isDev();\n\nexport const log = function (msg: string, title = '') {\n  if (debug) {\n    console.log(msg, title);\n  }\n};\n\nexport const todo = function (msg: string) {\n  if (debug) {\n    console.log(`%c todo: ${msg}`, 'background: #2684FF; color: #fff; padding-right: 10px;');\n  }\n};\n\nexport const warn = function (msg: string) {\n  if (debug) {\n    console.warn(msg);\n  }\n};\n\nexport const error = function (msg: string, title = '') {\n  if (debug) {\n    console.error(msg, title);\n  } else {\n    // @todo: track error somewhere\n  }\n};\n\n","export default {\n  categories: {\n    none: 'no-category',\n    googleAnalyticsTracking: 'google-analytics-tracking',\n    gasv2Tracking: 'gas-v2-tracking',\n  },\n  actions: {\n    none: 'no-action',\n    inferredNameMatch: 'inferred-name-match',\n    inferredNameMismatch: 'inferred-name-mismatch',\n    noNameProvided: 'no-name-provided',\n    trackingFailure: 'tracking-failure',\n  },\n  labels: {\n    none: 'no-label',\n  },\n  reasons: {\n    trackingNotLoaded: 'tracking-not-loaded',\n  },\n  urls: {\n    gasv2Url: 'https://mgas.prod.public.atl-paas.net/v1/event',\n  },\n};\n","import axios from 'axios';\nimport * as Logger from '../../logger';\nimport Constants from '../constants';\n\nclass GASv2 {\n  hasShownWarning: boolean;\n  \n  constructor() {\n    this.hasShownWarning = false;\n  }\n\n  track(postBody: any) {\n    if (!this.hasShownWarning) {\n      this.hasShownWarning = true;\n      Logger.warn('GASv2 is deprecated! Please migrate to GASv3 when possible.');\n    }\n\n    let options = {\n      headers: {\n        'content-type': 'application/json'\n      },\n      withCredentials: true\n    };\n\n    return axios.post(Constants.urls.gasv2Url, postBody, options)\n      .then(d => {\n        return d;\n      })\n      .catch(e => {\n        return Promise.reject(e);\n      });\n  }\n}\n\nexport { GASv2 };\n\nexport default new GASv2();\n","class GASv3 {\n  track() {\n    return Promise.reject('Not yet implemented.');\n  }\n}\n\nexport { GASv3 };\n\nexport default new GASv3();\n","class GoogleAnalytics {\n  track(data: any) {\n    const { action, attributes, category, label, isNonInteraction } = data;\n    const { value } = (attributes || {});\n\n    if (typeof ga !== 'undefined') {\n      ga('send', 'event', category, action, label, value, {\n        nonInteraction: isNonInteraction\n      });\n    }\n  }\n}\n\nexport { GoogleAnalytics };\n\nexport default new GoogleAnalytics();\n","import tracking from '../../../utils/tracking';\nimport url from '../../../utils/url';\n\nclass Segment {\n  track(data: any) {\n    const { action, attributes, category, label } = data;\n    const { value, ...additionalAttributes } = (attributes || {});\n\n    var eventProperties = {\n      category,\n      label,\n      value,\n      eventAction: action,\n      urlParams: url.getUrlParams() || {},\n      ...additionalAttributes\n    };\n    tracking.trackEvent(action, eventProperties);\n  }\n}\n\nexport { Segment };\n\nexport default new Segment();\n","import GASv2 from './gasv2';\nimport GASv3 from './gasv3';\nimport GoogleAnalytics from './googleAnalytics';\nimport Segment from './segment';\n\n// platforms to send to when Tracking.trackAll() is called.\nexport const trackAllPlatforms = [GoogleAnalytics, Segment];\n\n// all supported platforms.\nexport {\n  GASv2,\n  GASv3,\n  GoogleAnalytics,\n  Segment,\n};\n","import api from \"./utils/api\";\nimport browser from \"./utils/browser\";\nimport getScript from \"./utils/get-script\";\nimport tracking from \"./utils/tracking\";\nimport general from \"./utils/general\";\nimport history from \"./utils/history\";\nimport string from \"./utils/string\"\nimport storage from \"./utils/storage\";\nimport url from \"./utils/url\";\n\n// @ts-ignore\nconst imkt: { [property: string]: any } = window.imkt = window.imkt || {\n    core: {\n        /*\n         * this parses the DOM and finds any type=\"text/x-component\" scripts and initializes a component for each\n         */\n        init: async function (domRoot: HTMLElement) {\n            var self = this;\n\n            this.featureDetect();\n\n            const LocalizedPricing = (await import(\"./utils/localized-pricing\")).default;\n\n            const localizedPricing = new LocalizedPricing();\n\n            $(\"script[type='text/x-component']\", domRoot).each(function (i, elem) {\n                var componentInfo = JSON.parse(elem.innerHTML.trim()),\n                    componentRoot = elem.parentNode;\n\n                const {\n                    productKey,\n                    productKeyArray,\n                    period,\n                    offeringSku,\n                    countryISOCodeReq,\n                } = componentInfo.params;\n\n                if (productKey) {\n                    componentInfo.params.pricing = localizedPricing.getPricingPromise(\n                        productKey,\n                        period\n                    );\n                }\n\n                if (offeringSku) {\n                    componentInfo.params.pricing = localizedPricing.getPricingPromise(\n                        null,\n                        period,\n                        null,\n                        null,\n                        offeringSku\n                    );\n                }\n\n                if (productKeyArray) {\n                    componentInfo.params.pricingObject = productKeyArray.map((product: any) => {\n                        return localizedPricing.getPricingPromise(\n                            product.key,\n                            product.period,\n                            product.identifiers,\n                            product.customCurrency,\n                            product.offeringSku\n                        );\n                    });\n                }\n\n                if (countryISOCodeReq) {\n                    componentInfo.params.countryISOCodePromise =\n                        localizedPricing.getLocale();\n                }\n\n                try {\n                    self.componentInit.call(self, componentRoot, componentInfo);\n                } catch (e) {\n                    console.log(e);\n                }\n            });\n\n            localizedPricing.resolvePricingPromises();\n\n            // Init component scripts with Smartling Translation\n            $(\"script[type='text/x-component-translate']\", domRoot).each(function (\n                i,\n                elem\n            ) {\n                var innerHTML = elem.innerHTML\n                    .trim()\n                    .replace(\"/* <sl:translate_json> */\", \"\")\n                    .replace(\"/* </sl:translate_json> */\", \"\");\n                var componentInfo = JSON.parse(innerHTML),\n                    componentRoot = elem.parentNode;\n                self.componentInit.call(self, componentRoot, componentInfo);\n            });\n\n            $(document).trigger(\"appInitialized\");\n            this.appInitialized = true;\n        },\n        onInitialized(cb) {\n            if (this.appInitialized) {\n                cb();\n            } else {\n                $(document).on(\"appInitialized\", cb);\n            }\n        },\n        featureDetect() {\n            var bodyClasses = [];\n            if (!this.supports.svg()) {\n                bodyClasses.push(\"no-svg\");\n            }\n            if (!this.supports.backgroundSize()) {\n                bodyClasses.push(\"no-backgroundsize\");\n            }\n            if (!this.supports.flexBox()) {\n                bodyClasses.push(\"no-flexbox\");\n            }\n            $(\"body\").addClass(bodyClasses.join(\" \"));\n        },\n        extend(supertype, subtype, overrides = {}) {\n            var ctor = function () { },\n                name;\n            ctor.prototype = supertype.prototype;\n            subtype.prototype = new ctor();\n            for (name in overrides) {\n                subtype.prototype[name] = overrides[name];\n            }\n            subtype.prototype.constructor = supertype;\n        },\n        /*\n         * this takes a namespaced string like \"imkt.components.tabs\" and returns the actual JS object (if found)\n         */\n        resolve(str, createIfNotExists) {\n            var basis = window;\n            if (!str) {\n                return null;\n            } else if (typeof str === \"function\") {\n                return str;\n            } else {\n                var last = basis,\n                    names = str.split(\".\"),\n                    name,\n                    i,\n                    j;\n                for (i = 0, j = names.length; i < j; i++) {\n                    name = names[i];\n                    basis = basis[name];\n                    if (!basis) {\n                        if (createIfNotExists) {\n                            basis = last[name] = {};\n                        } else {\n                            return null;\n                        }\n                    }\n                    last = basis;\n                }\n            }\n            return basis;\n        },\n        /*\n         * tries to resolve the component name and if so, initializes it\n         */\n        componentInit(componentRoot, componentInfo) {\n            var componentType = this.resolve(componentInfo.type);\n            if (componentType) {\n                return new componentType(\n                    componentRoot,\n                    Object.assign({}, componentInfo.params, $(componentRoot).data())\n                );\n            } else {\n                // could not find component\n            }\n        },\n        supports: {\n            flexBox() {\n                return (\n                    \"flexWrap\" in document.documentElement.style ||\n                    \"webkitFlexWrap\" in document.documentElement.style\n                );\n            },\n            history() {\n                return window.history && window.history.pushState;\n            },\n            svg() {\n                return document.implementation.hasFeature(\n                    \"http://www.w3.org/TR/SVG11/feature#Image\",\n                    \"1.1\"\n                );\n            },\n            backgroundSize() {\n                return \"backgroundSize\" in document.documentElement.style;\n            },\n            touch() {\n                return \"ontouchstart\" in window;\n            },\n            placeholder() {\n                var i = document.createElement(\"input\");\n                return \"placeholder\" in i;\n            },\n            localStorage() {\n                // Bugfix WTF-15606, try/catch for localStorage empty object (private browsers)\n                try {\n                    window.localStorage.setItem(\"hasStorage\", \"1\");\n                    return (\n                        window.localStorage &&\n                        window.localStorage.setItem &&\n                        window.localStorage.removeItem\n                    );\n                } catch (error) {\n                    return false;\n                }\n            },\n            transitions() {\n                var b = document.body || document.documentElement,\n                    s = b.style,\n                    p = \"transition\";\n\n                if (typeof s[p] == \"string\") {\n                    return true;\n                }\n\n                // Tests for vendor specific prop\n                var v = [\"Moz\", \"webkit\", \"Webkit\", \"Khtml\", \"O\", \"ms\"];\n                p = p.charAt(0).toUpperCase() + p.substr(1);\n\n                for (var i = 0; i < v.length; i++) {\n                    if (typeof s[v[i] + p] == \"string\") {\n                        return true;\n                    }\n                }\n\n                return false;\n            },\n        },\n        is: {\n            mobile() {\n                return imkt.core.supports.touch() && screen.width && screen.width < 768;\n            },\n        },\n    },\n    utils: {\n        api,\n        browser,\n        getScript,\n        tracking,\n        general,\n        history,\n        string,\n        storage,\n        url,\n    },\n    wpl: {\n        globals: {\n            mediaQueries: {\n                \"xs\": { \"minWidth\": 0, \"maxWidth\": 539 },\n                \"sm\": { \"minWidth\": 540, \"maxWidth\": 767 },\n                \"md\": { \"minWidth\": 768, \"maxWidth\": 1023 },\n                \"lg\": { \"minWidth\": 1024, \"maxWidth\": 1439 },\n                \"xl\": { \"minWidth\": 1440, \"maxWidth\": null }\n            }\n        }\n    },\n    common: {},\n    wac: {},\n    landing: {},\n    experts: {},\n    legal: {},\n    components: {},\n    software: {},\n    bxp: {},\n    customers: {},\n    pages: {},\n    teamPatterns: {},\n};\n\nexport default imkt;","import stgConfig from \"../../../config\";\nimport imkt from '../imkt';\n\n/**\n * Get an api endpoint relative to current environment\n * @todo: define what a dev environment is (BizBox?) in this context\n */\n\nexport default {\n  urls: {\n    apiGetAuthToken: {\n      public:\n        \"https://www.atlassian.com/hamlet/1.0/auth/xsrf/html?domain=atlassian.com\",\n      staging: `${\n        window.location.hostname.indexOf(\"qa-wac\") > -1\n          ? \"https://qa-wac.internal.atlassian.com\"\n          : stgConfig.stgWacInternalUrl\n      }/apis/stg/hamlet/1.0/auth/xsrf/html?domain=atlassian.com`,\n      dev: \"\",\n    },\n    apiGetSites: {\n      public: \"https://api-private.atlassian.com/available-sites\",\n      staging: \"https://api-private.stg.atlassian.com/available-sites\",\n      dev: \"\",\n    },\n    apiGetUser: {\n      public: \"https://api-private.atlassian.com/me\",\n      staging: \"https://api-private.stg.atlassian.com/me\",\n      dev: \"\",\n    },\n  },\n\n  getUrl: function (endpoint: string) {\n    var env = imkt.constants.public ? \"public\" : \"staging\";\n    var url =\n      typeof this.urls[endpoint] !== \"undefined\"\n        ? this.urls[endpoint][env]\n        : \"\";\n    return url;\n  },\n}\n","import imkt from '../imkt';\n\nexport default {\n  // Get Browser OS\n  getBrowserOs: function () {\n    var nAgt = navigator.userAgent;\n\n    var clientStrings = [\n      { s: 'Windows 10', r: /(Windows 10.0|Windows NT 10.0)/ },\n      { s: 'Windows 8.1', r: /(Windows 8.1|Windows NT 6.3)/ },\n      { s: 'Windows 8', r: /(Windows 8|Windows NT 6.2)/ },\n      { s: 'Windows 7', r: /(Windows 7|Windows NT 6.1)/ },\n      { s: 'Windows Vista', r: /Windows NT 6.0/ },\n      { s: 'Windows Server 2003', r: /Windows NT 5.2/ },\n      { s: 'Windows XP', r: /(Windows NT 5.1|Windows XP)/ },\n      { s: 'Windows 2000', r: /(Windows NT 5.0|Windows 2000)/ },\n      { s: 'Windows ME', r: /(Win 9x 4.90|Windows ME)/ },\n      { s: 'Windows 98', r: /(Windows 98|Win98)/ },\n      { s: 'Windows 95', r: /(Windows 95|Win95|Windows_95)/ },\n      { s: 'Windows NT 4.0', r: /(Windows NT 4.0|WinNT4.0|WinNT|Windows NT)/ },\n      { s: 'Windows CE', r: /Windows CE/ },\n      { s: 'Windows 3.11', r: /Win16/ },\n      { s: 'Android', r: /Android/ },\n      { s: 'Open BSD', r: /OpenBSD/ },\n      { s: 'Sun OS', r: /SunOS/ },\n      { s: 'Linux', r: /(Linux|X11)/ },\n      { s: 'iOS', r: /(iPhone|iPad|iPod)/ },\n      { s: 'Mac OS X', r: /Mac OS X/ },\n      { s: 'Mac OS', r: /(MacPPC|MacIntel|Mac_PowerPC|Macintosh)/ },\n      { s: 'QNX', r: /QNX/ },\n      { s: 'UNIX', r: /UNIX/ },\n      { s: 'BeOS', r: /BeOS/ },\n      { s: 'OS/2', r: /OS\\/2/ },\n      { s: 'Search Bot', r: /(nuhk|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask Jeeves\\/Teoma|ia_archiver)/ }\n    ];\n\n    for (var id in clientStrings) {\n      var cs = clientStrings[id];\n      if (cs.r.test(nAgt)) {\n        return cs.s;\n      }\n    }\n\n    return \"unknown\";\n  },\n  // Check if browser is windows\n  isWindows: function () {\n    var os = this.getBrowserOs();\n    return os.indexOf(\"Windows\") > -1;\n  },\n  // NOTE: We have a similar function inside app.js (imkt.core.is.mobile) but the breakpoint is 768px\n  // This breakpoint is consistent with imkt.constants.mobileBreakpoint and our CSS breakpoint\n  isMobile: function () {\n    return (imkt.core.supports.touch() && screen.width && screen.width <= (imkt.constants.mobileBreakpoint));\n  }\n};\n","export default {\n  // url without any query string\n  randomString: function (l: number) {\n    var s = \"\";\n    while (s.length < l && l > 0) {\n      var r = Math.random();\n      s +=\n        r < 0.1\n          ? Math.floor(r * 100)\n          : String.fromCharCode(Math.floor(r * 26) + (r > 0.5 ? 97 : 65));\n    }\n    return s;\n  },\n  numberWithCommas: function (n: number) {\n    return n.toString().replace(/\\B(?=(\\d{3})+(?!\\d))/g, \",\");\n  },\n  elementInViewport: function (el: HTMLElement) {\n    var top = el.offsetTop;\n    var left = el.offsetLeft;\n    var width = el.offsetWidth;\n    var height = el.offsetHeight;\n\n    while (el.offsetParent) {\n      el = el.offsetParent as HTMLElement;\n      top += el.offsetTop;\n      left += el.offsetLeft;\n    }\n\n    return (\n      top >= window.pageYOffset &&\n      left >= window.pageXOffset &&\n      top + height <= window.pageYOffset + window.innerHeight &&\n      left + width <= window.pageXOffset + window.innerWidth\n    );\n  },\n};\n","import * as $ from \"jquery\";\nimport imkt from '../imkt';\n\nvar datepickerRequest = $.Deferred();\nvar select2Request = $.Deferred();\nvar underscoreRequest = $.Deferred();\n\nvar getStyle = function (url: string, params: any) {\n  \"use strict\";\n\n  // If there is no URL to load, no point in continuing.\n  if (typeof url === \"undefined\") {\n    return;\n  }\n\n  // If this stylesheet has already been loaded, no point in continuing.\n  if (\n    params.hasOwnProperty(\"id\") &&\n    $(\"head\").find(\"#\" + params.id).length\n  ) {\n    return;\n  }\n\n  var linkAttrs = {\n    rel: \"stylesheet\",\n    media: \"screen\",\n    href: url,\n  };\n\n  if ($.isPlainObject(params)) {\n    linkAttrs = Object.assign({}, linkAttrs, params);\n  }\n\n  var link = $(\"<link>\").attr(linkAttrs);\n  $(\"head\").append(link);\n};\n\nexport default {\n  datepicker: function (callback) {\n    if (typeof datepickerRequest === \"undefined\") {\n      datepickerRequest = $.getScript(\n        imkt.constants.libPath +\n          \"air-datepicker.js\" +\n          imkt.constants.cdnVersionQuery\n      );\n      getStyle(\n        imkt.constants.libPath +\n          \"air-datepicker.css\" +\n          imkt.constants.cdnVersionQuery,\n        {\n          id: \"datepicker-style\",\n        }\n      );\n    } else {\n      // Select2 already exists\n      datepickerRequest.resolve();\n    }\n    $.when(datepickerRequest).then(callback);\n    return this;\n  },\n  select2: function (callback) {\n    // Select2 is a dependency, so load that first\n    if (typeof select2Request === \"undefined\") {\n      select2Request = $.getScript(\n        imkt.constants.libPath + \"select2.js\" + imkt.constants.cdnVersionQuery\n      );\n    } else {\n      // Select2 already exists\n      select2Request.resolve();\n    }\n    $.when(select2Request).then(callback);\n    return this;\n  },\n  underscore: function (callback) {\n    // underscore is a dependency, so load that first\n    if (typeof underscoreRequest === \"undefined\") {\n      underscoreRequest = $.getScript(\n        imkt.constants.libPath +\n          \"underscore.js\" +\n          imkt.constants.cdnVersionQuery\n      );\n    } else {\n      // underscore already exists\n      underscoreRequest.resolve();\n    }\n    $.when(underscoreRequest).then(callback);\n    return this;\n  },\n};\n","// Wrapping the History API here to push analytics when state is pushed\nexport default {\n  supportsHistory() {\n    return window.history && window.history.pushState;\n  },\n  pushState(data: any, title: string, url: string) {\n    if (this.supportsHistory()) {\n      window.history.pushState(data, title, url);\n\n      // Trigger Analytics\n      if (typeof analytics !== \"undefined\") {\n        analytics.page();\n      }\n    }\n  },\n  pushStateNoTracking(data: any, title: string, url: string) {\n    if (this.supportsHistory()) {\n      window.history.pushState(data, title, url);\n    }\n  },\n}\n","// Util to handle get/set of local storage\n// @todo: Test need for fallback to cookies\nexport default {\n  hasStorage: localStorage && typeof localStorage.getItem === \"function\",\n\n  getLocalStorage(key: string) {\n    // Get value from local storage or cookies\n\n    if (!this.hasStorage) {\n      return this.getCookie(key);\n    }\n\n    var value = localStorage.getItem(key);\n    return value;\n  },\n\n  setLocalStorage(key: string, value: string) {\n    // Set value in local storage or cookies\n\n    if (!this.hasStorage) {\n      this.setCookie(key, value);\n    }\n\n    try {\n      localStorage.setItem(key, value);\n    } catch (e) {\n      // Don't store for private browsing\n      console.log(\n        \"Local Storage failed, check if browsing in Safari private window.\"\n      );\n    }\n  },\n\n  removeLocalStorage(key: string) {\n    if (!this.hasStorage) {\n      this.removeCookie(key);\n    }\n    try {\n      localStorage.removeItem(key);\n    } catch (e) {\n      // Don't remove for private browsing\n      console.log(\n        \"Local Storage failed, check if browsing in Safari private window.\"\n      );\n    }\n  },\n\n  getSessionStorage(key: string) {\n    // Get value from Session storage or cookies\n\n    if (!this.hasStorage) {\n      return this.getCookie(key);\n    }\n\n    var value = sessionStorage.getItem(key);\n    return value;\n  },\n\n  setSessionStorage(key: string, value: string) {\n    // Set value in Session storage or cookies\n\n    if (!this.hasStorage) {\n      this.setCookie(key, value);\n    }\n\n    try {\n      sessionStorage.setItem(key, value);\n    } catch (e) {\n      // Don't store for private browsing\n      console.log(\n        \"Session Storage failed, check if browsing in Safari private window.\"\n      );\n    }\n  },\n\n  removeSessionStorage(key: string) {\n    if (!this.hasStorage) {\n      this.removeCookie(key);\n    }\n    try {\n      sessionStorage.removeItem(key);\n    } catch (e) {\n      // Don't remove for private browsing\n      console.log(\n        \"Session Storage failed, check if browsing in Safari private window.\"\n      );\n    }\n  },\n\n  getCookie(key: string) {\n    // Get value from cookie\n\n    var encodedName = encodeURIComponent(key).replace(/[\\-\\.\\+\\*]/g, \"\\\\$&\");\n    var regex = new RegExp(\n      \"(?:(?:^|.*;)\\\\s*\" + encodedName + \"\\\\s*\\\\=\\\\s*([^;]*).*$)|^.*$\"\n    );\n\n    return decodeURIComponent(document.cookie.replace(regex, \"$1\")) || null;\n  },\n\n  setCookie(key: string, value: any, days?: number, sameSite?: string, domain?: string) {\n    let expires = \"\";\n    let domainLevel = ``;\n    if (domain) {\n      domainLevel = `; domain=${domain}`;\n    }\n    let sameSiteVal = sameSite ? sameSite.toLowerCase() : false;\n    let sameSiteString = `samesite=${\n      (sameSiteVal && sameSiteVal == \"strict\") || sameSiteVal == \"lax\"\n        ? sameSiteVal\n        : \"none\"\n    }`;\n    if (days) {\n      let date = new Date();\n      date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);\n      // @ts-ignore\n      expires = \"; expires=\" + date.toGMTString();\n    }\n    document.cookie =\n      key + \"=\" + value + \";path=/;\" + sameSiteString + expires + domainLevel;\n  },\n  removeCookie: function (key: string) {\n    this.setCookie(key, \"\", -1);\n  },\n}\n","import general from '../utils/general';\n\nexport default {\n  /**\n   * Reverse string\n   * @param {string} str - String you want to reverse\n   * @returns {string} Reverse of str\n   * @example\n   * // returns \"olleh\"\n   * imkt.utils.string.reverse(\"hello\")\n   */\n  reverse(str: string) {\n    if (typeof str !== \"string\") {\n      return \"\";\n    }\n\n    if (str.trim() === \"\") {\n      return str;\n    }\n\n    return str.split(\"\").reverse().join(\"\");\n  },\n};\n\nexport const replaceText = (srcObj: any, inputText: string, replaceMap: any) =>\n  Object.keys(replaceMap).reduce(\n    (outputText, replaceKey) =>\n      srcObj[replaceKey]\n        ? outputText.replace(`{{${replaceKey}}}`, srcObj[replaceKey])\n        : outputText,\n    inputText\n  );\n\nexport const getStrWithCommas = (input: any) =>\n  general.numberWithCommas(input.toString());\n","import { trackEvent, sanitizeEventProperties } from \"../common/analytics\";\nimport Tracking from \"../common/tracking\";\nimport * as Platforms from \"../common/tracking/platforms\";\n\nexport default class ImktTracking {\n  // expose utils for Apollo to call from external experiment code.\n  apollo = {\n    Tracking,\n    Platforms,\n  };\n\n  // Track events for analytics\n  static trackEvent(eventName: string, eventProperties?: {}) {\n    trackEvent(eventName, eventProperties);\n  }\n\n  static sanitizeEventProperties(eventProperty: {}) {\n    return sanitizeEventProperties(eventProperty);\n  }\n\n  /* use the below function for tracking content that was not rendered server-side and has thus escaped the purview of the tracking wrapper */\n  static trackLateRenderedEvent(eventName: string, eventTarget: HTMLElement) {\n    if (\n      eventTarget.tagName == \"A\" ||\n      (eventTarget.tagName == \"BUTTON\" && eventTarget.dataset.uuid)\n    ) {\n      let attributes = [\n        \"uuid\",\n        \"event\",\n        \"eventComponent\",\n        \"eventContainer\",\n        \"parentLabel\",\n        \"eventColumn\",\n        \"schemaVersion\",\n      ];\n      let eventData = {\n        label: eventTarget.dataset.label\n          ? eventTarget.dataset.label\n          : eventTarget.innerText,\n      };\n      attributes.forEach((attribute) => {\n        eventData[attribute] = eventTarget.dataset[attribute];\n      });\n      this.trackEvent(eventName, eventData);\n    }\n  }\n}\n","import history from '../utils/history';\n\nexport default {\n  // url without any query string\n  getBareUrl(url?: string) {\n    var questionIndex;\n    url = url || window.location.href;\n    questionIndex = url.indexOf(\"?\");\n    return url.substring(0, questionIndex > -1 ? questionIndex : url.length);\n  },\n  // url without any hash\n  getUnhashedUrl(url?: string) {\n    var hashIndex;\n    url = url || window.location.href;\n    hashIndex = url.indexOf(\"#\");\n    return url.substring(0, hashIndex > -1 ? hashIndex : url.length);\n  },\n  getProtocol(url?: string) {\n    var r = \"\",\n      i;\n    url = this.getBareUrl(url || window.location.href);\n    i = url.indexOf(\"://\");\n    if (i > -1) {\n      r = url.substring(0, i);\n    }\n    return r;\n  },\n  getHostname(url?: string) {\n    var protocol, start;\n    url = this.getBareUrl(url || window.location.href);\n    protocol = this.getProtocol(url);\n    start = protocol ? protocol.length + 3 : 0;\n    return url.substring(start, url.indexOf(\"/\", start));\n  },\n  // query string only (no question mark)\n  getQueryString(url?: string) {\n    var questionIndex,\n      r = window.location.search.substring(1, window.location.search.length);\n    if (url) {\n      url = this.getUnhashedUrl(url);\n      questionIndex = url.indexOf(\"?\");\n      r = questionIndex > -1 ? url.substring(questionIndex + 1) : \"\";\n    }\n    return r;\n  },\n  updateQueryStringParam(key: string, value: string) {\n    var baseUrl = [\n        location.protocol,\n        \"//\",\n        location.host,\n        location.pathname,\n      ].join(\"\"),\n      queryString = document.location.search,\n      newParam = key + \"=\" + value,\n      params = \"?\" + newParam;\n\n    if (queryString) {\n      var keyRegex = new RegExp(\"([?&])\" + key + \"[^&]*\");\n\n      if (queryString.match(keyRegex) !== null) {\n        params = queryString.replace(keyRegex, \"$1\" + newParam);\n      } else {\n        params = queryString + \"&\" + newParam;\n      }\n    }\n\n    history.pushState({}, \"\", baseUrl + params);\n  },\n  getPathname(url?: string) {\n    var hostname, questionIndex;\n    url = url || window.location.href;\n    hostname = this.getHostname(url);\n    questionIndex = url.indexOf(\"?\");\n    return url.substring(\n      url.indexOf(hostname) + hostname.length,\n      questionIndex > -1 ? questionIndex : url.length\n    );\n  },\n  // serialize an object literal into a url encoded string\n  serialize(params: { [key: string]: string }) {\n    var r = [],\n      tempArray;\n    for (var prop in params) {\n      if (params[prop] !== null) {\n        tempArray = [prop];\n        tempArray.push(\"=\");\n        tempArray.push(encodeURIComponent(params[prop]));\n        r.push(tempArray.join(\"\"));\n      }\n    }\n    return r.join(\"&\");\n  },\n  htmlEscape(str) {\n    return String(str)\n      .replace(/&/g, \"&amp;\")\n      .replace(/\"/g, \"&quot;\")\n      .replace(/'/g, \"&#39;\")\n      .replace(/</g, \"&lt;\")\n      .replace(/>/g, \"&gt;\");\n  },\n  // returns an object literal of the url params on a url\n  getUrlParams(url?: string) {\n    var r: { [key: string]: string } | null = null,\n      qs,\n      paramPairs,\n      keyValuePair,\n      i = 0;\n\n    qs = this.getQueryString(url);\n\n    if (qs) {\n      paramPairs = qs.split(\"&\");\n      for (i; i < paramPairs.length; i++) {\n        if (!r) {\n          r = {};\n        }\n        keyValuePair = paramPairs[i].split(\"=\");\n        r[keyValuePair[0]] =\n          keyValuePair.length > 1\n            ? this.htmlEscape(decodeURIComponent(keyValuePair[1]))\n            : null;\n      }\n    }\n\n    return r;\n  },\n  // returns a url with additional params added (params is an object literal)\n  addUrlParams(params: {}, url?: string) {\n    var r = [],\n      qs;\n\n    url = url || window.location.href;\n    r.push(this.getBareUrl(url));\n    params = { ...this.getUrlParams(url), ...params };\n    qs = this.serialize(params);\n    if (qs) {\n      r.push(\"?\");\n      r.push(qs);\n    }\n\n    return r.join(\"\");\n  },\n  // returns a url with params removed (params is an array of url param keys)\n  removeUrlParams(params: {}, url?: string) {\n    var r = [],\n      qs;\n\n    url = url || window.location.href;\n    r.push(this.getBareUrl(url));\n    var currentParams = this.getUrlParams(url);\n    for (var i = params.length - 1; i >= 0; i--) {\n      if (typeof currentParams[params[i]] !== \"undefined\") {\n        delete currentParams[params[i]];\n      }\n    }\n\n    qs = this.serialize(currentParams);\n    if (qs) {\n      r.push(\"?\");\n      r.push(qs);\n    }\n\n    return r.join(\"\");\n  },\n  // returns a url without http(s)://(www.) and without trailing slash, optionally with url vars\n  getSimpleUrl(url: string | null, matchUrlVars?: boolean) {\n    url = url || window.location.href;\n\n    var simpleMatch = /^((https?|):\\/\\/)?(www\\.)?/;\n    var trailingSlashMatch = /\\/$/;\n\n    var bareUrl = this.getBareUrl(url);\n    var hashUrlArray = bareUrl.split(\"#\");\n    var hashUrl = \"\";\n\n    bareUrl = hashUrlArray[0];\n    if (hashUrlArray.length > 1) {\n      hashUrl = \"#\" + hashUrlArray[1];\n    }\n\n    var result = bareUrl\n      .replace(simpleMatch, \"\")\n      .replace(trailingSlashMatch, \"\");\n\n    if (matchUrlVars) {\n      var queryString = this.getQueryString(url);\n\n      if (queryString) {\n        result += \"?\" + queryString;\n      }\n      result += hashUrl;\n    }\n\n    return result;\n  },\n}\n","'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","module.exports = jQuery;","'use strict';\n\nexport default function bind(fn, thisArg) {\n  return function wrap() {\n    return fn.apply(thisArg, arguments);\n  };\n}\n","'use strict';\n\nimport bind from './helpers/bind.js';\n\n// utils is a library of generic helper functions non-specific to axios\n\nconst {toString} = Object.prototype;\nconst {getPrototypeOf} = Object;\n\nconst kindOf = (cache => thing => {\n    const str = toString.call(thing);\n    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());\n})(Object.create(null));\n\nconst kindOfTest = (type) => {\n  type = type.toLowerCase();\n  return (thing) => kindOf(thing) === type\n}\n\nconst typeOfTest = type => thing => typeof thing === type;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n *\n * @returns {boolean} True if value is an Array, otherwise false\n */\nconst {isArray} = Array;\n\n/**\n * Determine if a value is undefined\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nconst isUndefined = typeOfTest('undefined');\n\n/**\n * Determine if a value is a Buffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Buffer, otherwise false\n */\nfunction isBuffer(val) {\n  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)\n    && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nconst isArrayBuffer = kindOfTest('ArrayBuffer');\n\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n  let result;\n  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n    result = ArrayBuffer.isView(val);\n  } else {\n    result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));\n  }\n  return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a String, otherwise false\n */\nconst isString = typeOfTest('string');\n\n/**\n * Determine if a value is a Function\n *\n * @param {*} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nconst isFunction = typeOfTest('function');\n\n/**\n * Determine if a value is a Number\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Number, otherwise false\n */\nconst isNumber = typeOfTest('number');\n\n/**\n * Determine if a value is an Object\n *\n * @param {*} thing The value to test\n *\n * @returns {boolean} True if value is an Object, otherwise false\n */\nconst isObject = (thing) => thing !== null && typeof thing === 'object';\n\n/**\n * Determine if a value is a Boolean\n *\n * @param {*} thing The value to test\n * @returns {boolean} True if value is a Boolean, otherwise false\n */\nconst isBoolean = thing => thing === true || thing === false;\n\n/**\n * Determine if a value is a plain Object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a plain Object, otherwise false\n */\nconst isPlainObject = (val) => {\n  if (kindOf(val) !== 'object') {\n    return false;\n  }\n\n  const prototype = getPrototypeOf(val);\n  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val);\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Date, otherwise false\n */\nconst isDate = kindOfTest('Date');\n\n/**\n * Determine if a value is a File\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a File, otherwise false\n */\nconst isFile = kindOfTest('File');\n\n/**\n * Determine if a value is a Blob\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nconst isBlob = kindOfTest('Blob');\n\n/**\n * Determine if a value is a FileList\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a File, otherwise false\n */\nconst isFileList = kindOfTest('FileList');\n\n/**\n * Determine if a value is a Stream\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nconst isStream = (val) => isObject(val) && isFunction(val.pipe);\n\n/**\n * Determine if a value is a FormData\n *\n * @param {*} thing The value to test\n *\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nconst isFormData = (thing) => {\n  let kind;\n  return thing && (\n    (typeof FormData === 'function' && thing instanceof FormData) || (\n      isFunction(thing.append) && (\n        (kind = kindOf(thing)) === 'formdata' ||\n        // detect form-data instance\n        (kind === 'object' && isFunction(thing.toString) && thing.toString() === '[object FormData]')\n      )\n    )\n  )\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nconst isURLSearchParams = kindOfTest('URLSearchParams');\n\nconst [isReadableStream, isRequest, isResponse, isHeaders] = ['ReadableStream', 'Request', 'Response', 'Headers'].map(kindOfTest);\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n *\n * @returns {String} The String freed of excess whitespace\n */\nconst trim = (str) => str.trim ?\n  str.trim() : str.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n *\n * @param {Boolean} [allOwnKeys = false]\n * @returns {any}\n */\nfunction forEach(obj, fn, {allOwnKeys = false} = {}) {\n  // Don't bother if no value provided\n  if (obj === null || typeof obj === 'undefined') {\n    return;\n  }\n\n  let i;\n  let l;\n\n  // Force an array if not already something iterable\n  if (typeof obj !== 'object') {\n    /*eslint no-param-reassign:0*/\n    obj = [obj];\n  }\n\n  if (isArray(obj)) {\n    // Iterate over array values\n    for (i = 0, l = obj.length; i < l; i++) {\n      fn.call(null, obj[i], i, obj);\n    }\n  } else {\n    // Iterate over object keys\n    const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);\n    const len = keys.length;\n    let key;\n\n    for (i = 0; i < len; i++) {\n      key = keys[i];\n      fn.call(null, obj[key], key, obj);\n    }\n  }\n}\n\nfunction findKey(obj, key) {\n  key = key.toLowerCase();\n  const keys = Object.keys(obj);\n  let i = keys.length;\n  let _key;\n  while (i-- > 0) {\n    _key = keys[i];\n    if (key === _key.toLowerCase()) {\n      return _key;\n    }\n  }\n  return null;\n}\n\nconst _global = (() => {\n  /*eslint no-undef:0*/\n  if (typeof globalThis !== \"undefined\") return globalThis;\n  return typeof self !== \"undefined\" ? self : (typeof window !== 'undefined' ? window : global)\n})();\n\nconst isContextDefined = (context) => !isUndefined(context) && context !== _global;\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n *\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n  const {caseless} = isContextDefined(this) && this || {};\n  const result = {};\n  const assignValue = (val, key) => {\n    const targetKey = caseless && findKey(result, key) || key;\n    if (isPlainObject(result[targetKey]) && isPlainObject(val)) {\n      result[targetKey] = merge(result[targetKey], val);\n    } else if (isPlainObject(val)) {\n      result[targetKey] = merge({}, val);\n    } else if (isArray(val)) {\n      result[targetKey] = val.slice();\n    } else {\n      result[targetKey] = val;\n    }\n  }\n\n  for (let i = 0, l = arguments.length; i < l; i++) {\n    arguments[i] && forEach(arguments[i], assignValue);\n  }\n  return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n *\n * @param {Boolean} [allOwnKeys]\n * @returns {Object} The resulting value of object a\n */\nconst extend = (a, b, thisArg, {allOwnKeys}= {}) => {\n  forEach(b, (val, key) => {\n    if (thisArg && isFunction(val)) {\n      a[key] = bind(val, thisArg);\n    } else {\n      a[key] = val;\n    }\n  }, {allOwnKeys});\n  return a;\n}\n\n/**\n * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)\n *\n * @param {string} content with BOM\n *\n * @returns {string} content value without BOM\n */\nconst stripBOM = (content) => {\n  if (content.charCodeAt(0) === 0xFEFF) {\n    content = content.slice(1);\n  }\n  return content;\n}\n\n/**\n * Inherit the prototype methods from one constructor into another\n * @param {function} constructor\n * @param {function} superConstructor\n * @param {object} [props]\n * @param {object} [descriptors]\n *\n * @returns {void}\n */\nconst inherits = (constructor, superConstructor, props, descriptors) => {\n  constructor.prototype = Object.create(superConstructor.prototype, descriptors);\n  constructor.prototype.constructor = constructor;\n  Object.defineProperty(constructor, 'super', {\n    value: superConstructor.prototype\n  });\n  props && Object.assign(constructor.prototype, props);\n}\n\n/**\n * Resolve object with deep prototype chain to a flat object\n * @param {Object} sourceObj source object\n * @param {Object} [destObj]\n * @param {Function|Boolean} [filter]\n * @param {Function} [propFilter]\n *\n * @returns {Object}\n */\nconst toFlatObject = (sourceObj, destObj, filter, propFilter) => {\n  let props;\n  let i;\n  let prop;\n  const merged = {};\n\n  destObj = destObj || {};\n  // eslint-disable-next-line no-eq-null,eqeqeq\n  if (sourceObj == null) return destObj;\n\n  do {\n    props = Object.getOwnPropertyNames(sourceObj);\n    i = props.length;\n    while (i-- > 0) {\n      prop = props[i];\n      if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {\n        destObj[prop] = sourceObj[prop];\n        merged[prop] = true;\n      }\n    }\n    sourceObj = filter !== false && getPrototypeOf(sourceObj);\n  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);\n\n  return destObj;\n}\n\n/**\n * Determines whether a string ends with the characters of a specified string\n *\n * @param {String} str\n * @param {String} searchString\n * @param {Number} [position= 0]\n *\n * @returns {boolean}\n */\nconst endsWith = (str, searchString, position) => {\n  str = String(str);\n  if (position === undefined || position > str.length) {\n    position = str.length;\n  }\n  position -= searchString.length;\n  const lastIndex = str.indexOf(searchString, position);\n  return lastIndex !== -1 && lastIndex === position;\n}\n\n\n/**\n * Returns new array from array like object or null if failed\n *\n * @param {*} [thing]\n *\n * @returns {?Array}\n */\nconst toArray = (thing) => {\n  if (!thing) return null;\n  if (isArray(thing)) return thing;\n  let i = thing.length;\n  if (!isNumber(i)) return null;\n  const arr = new Array(i);\n  while (i-- > 0) {\n    arr[i] = thing[i];\n  }\n  return arr;\n}\n\n/**\n * Checking if the Uint8Array exists and if it does, it returns a function that checks if the\n * thing passed in is an instance of Uint8Array\n *\n * @param {TypedArray}\n *\n * @returns {Array}\n */\n// eslint-disable-next-line func-names\nconst isTypedArray = (TypedArray => {\n  // eslint-disable-next-line func-names\n  return thing => {\n    return TypedArray && thing instanceof TypedArray;\n  };\n})(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array));\n\n/**\n * For each entry in the object, call the function with the key and value.\n *\n * @param {Object<any, any>} obj - The object to iterate over.\n * @param {Function} fn - The function to call for each entry.\n *\n * @returns {void}\n */\nconst forEachEntry = (obj, fn) => {\n  const generator = obj && obj[Symbol.iterator];\n\n  const iterator = generator.call(obj);\n\n  let result;\n\n  while ((result = iterator.next()) && !result.done) {\n    const pair = result.value;\n    fn.call(obj, pair[0], pair[1]);\n  }\n}\n\n/**\n * It takes a regular expression and a string, and returns an array of all the matches\n *\n * @param {string} regExp - The regular expression to match against.\n * @param {string} str - The string to search.\n *\n * @returns {Array<boolean>}\n */\nconst matchAll = (regExp, str) => {\n  let matches;\n  const arr = [];\n\n  while ((matches = regExp.exec(str)) !== null) {\n    arr.push(matches);\n  }\n\n  return arr;\n}\n\n/* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */\nconst isHTMLForm = kindOfTest('HTMLFormElement');\n\nconst toCamelCase = str => {\n  return str.toLowerCase().replace(/[-_\\s]([a-z\\d])(\\w*)/g,\n    function replacer(m, p1, p2) {\n      return p1.toUpperCase() + p2;\n    }\n  );\n};\n\n/* Creating a function that will check if an object has a property. */\nconst hasOwnProperty = (({hasOwnProperty}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);\n\n/**\n * Determine if a value is a RegExp object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a RegExp object, otherwise false\n */\nconst isRegExp = kindOfTest('RegExp');\n\nconst reduceDescriptors = (obj, reducer) => {\n  const descriptors = Object.getOwnPropertyDescriptors(obj);\n  const reducedDescriptors = {};\n\n  forEach(descriptors, (descriptor, name) => {\n    let ret;\n    if ((ret = reducer(descriptor, name, obj)) !== false) {\n      reducedDescriptors[name] = ret || descriptor;\n    }\n  });\n\n  Object.defineProperties(obj, reducedDescriptors);\n}\n\n/**\n * Makes all methods read-only\n * @param {Object} obj\n */\n\nconst freezeMethods = (obj) => {\n  reduceDescriptors(obj, (descriptor, name) => {\n    // skip restricted props in strict mode\n    if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {\n      return false;\n    }\n\n    const value = obj[name];\n\n    if (!isFunction(value)) return;\n\n    descriptor.enumerable = false;\n\n    if ('writable' in descriptor) {\n      descriptor.writable = false;\n      return;\n    }\n\n    if (!descriptor.set) {\n      descriptor.set = () => {\n        throw Error('Can not rewrite read-only method \\'' + name + '\\'');\n      };\n    }\n  });\n}\n\nconst toObjectSet = (arrayOrString, delimiter) => {\n  const obj = {};\n\n  const define = (arr) => {\n    arr.forEach(value => {\n      obj[value] = true;\n    });\n  }\n\n  isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));\n\n  return obj;\n}\n\nconst noop = () => {}\n\nconst toFiniteNumber = (value, defaultValue) => {\n  return value != null && Number.isFinite(value = +value) ? value : defaultValue;\n}\n\nconst ALPHA = 'abcdefghijklmnopqrstuvwxyz'\n\nconst DIGIT = '0123456789';\n\nconst ALPHABET = {\n  DIGIT,\n  ALPHA,\n  ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT\n}\n\nconst generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {\n  let str = '';\n  const {length} = alphabet;\n  while (size--) {\n    str += alphabet[Math.random() * length|0]\n  }\n\n  return str;\n}\n\n/**\n * If the thing is a FormData object, return true, otherwise return false.\n *\n * @param {unknown} thing - The thing to check.\n *\n * @returns {boolean}\n */\nfunction isSpecCompliantForm(thing) {\n  return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === 'FormData' && thing[Symbol.iterator]);\n}\n\nconst toJSONObject = (obj) => {\n  const stack = new Array(10);\n\n  const visit = (source, i) => {\n\n    if (isObject(source)) {\n      if (stack.indexOf(source) >= 0) {\n        return;\n      }\n\n      if(!('toJSON' in source)) {\n        stack[i] = source;\n        const target = isArray(source) ? [] : {};\n\n        forEach(source, (value, key) => {\n          const reducedValue = visit(value, i + 1);\n          !isUndefined(reducedValue) && (target[key] = reducedValue);\n        });\n\n        stack[i] = undefined;\n\n        return target;\n      }\n    }\n\n    return source;\n  }\n\n  return visit(obj, 0);\n}\n\nconst isAsyncFn = kindOfTest('AsyncFunction');\n\nconst isThenable = (thing) =>\n  thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);\n\nexport default {\n  isArray,\n  isArrayBuffer,\n  isBuffer,\n  isFormData,\n  isArrayBufferView,\n  isString,\n  isNumber,\n  isBoolean,\n  isObject,\n  isPlainObject,\n  isReadableStream,\n  isRequest,\n  isResponse,\n  isHeaders,\n  isUndefined,\n  isDate,\n  isFile,\n  isBlob,\n  isRegExp,\n  isFunction,\n  isStream,\n  isURLSearchParams,\n  isTypedArray,\n  isFileList,\n  forEach,\n  merge,\n  extend,\n  trim,\n  stripBOM,\n  inherits,\n  toFlatObject,\n  kindOf,\n  kindOfTest,\n  endsWith,\n  toArray,\n  forEachEntry,\n  matchAll,\n  isHTMLForm,\n  hasOwnProperty,\n  hasOwnProp: hasOwnProperty, // an alias to avoid ESLint no-prototype-builtins detection\n  reduceDescriptors,\n  freezeMethods,\n  toObjectSet,\n  toCamelCase,\n  noop,\n  toFiniteNumber,\n  findKey,\n  global: _global,\n  isContextDefined,\n  ALPHABET,\n  generateString,\n  isSpecCompliantForm,\n  toJSONObject,\n  isAsyncFn,\n  isThenable\n};\n","'use strict';\n\nimport utils from '../utils.js';\n\n/**\n * Create an Error with the specified message, config, error code, request and response.\n *\n * @param {string} message The error message.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [config] The config.\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n *\n * @returns {Error} The created error.\n */\nfunction AxiosError(message, code, config, request, response) {\n  Error.call(this);\n\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, this.constructor);\n  } else {\n    this.stack = (new Error()).stack;\n  }\n\n  this.message = message;\n  this.name = 'AxiosError';\n  code && (this.code = code);\n  config && (this.config = config);\n  request && (this.request = request);\n  response && (this.response = response);\n}\n\nutils.inherits(AxiosError, Error, {\n  toJSON: function toJSON() {\n    return {\n      // Standard\n      message: this.message,\n      name: this.name,\n      // Microsoft\n      description: this.description,\n      number: this.number,\n      // Mozilla\n      fileName: this.fileName,\n      lineNumber: this.lineNumber,\n      columnNumber: this.columnNumber,\n      stack: this.stack,\n      // Axios\n      config: utils.toJSONObject(this.config),\n      code: this.code,\n      status: this.response && this.response.status ? this.response.status : null\n    };\n  }\n});\n\nconst prototype = AxiosError.prototype;\nconst descriptors = {};\n\n[\n  'ERR_BAD_OPTION_VALUE',\n  'ERR_BAD_OPTION',\n  'ECONNABORTED',\n  'ETIMEDOUT',\n  'ERR_NETWORK',\n  'ERR_FR_TOO_MANY_REDIRECTS',\n  'ERR_DEPRECATED',\n  'ERR_BAD_RESPONSE',\n  'ERR_BAD_REQUEST',\n  'ERR_CANCELED',\n  'ERR_NOT_SUPPORT',\n  'ERR_INVALID_URL'\n// eslint-disable-next-line func-names\n].forEach(code => {\n  descriptors[code] = {value: code};\n});\n\nObject.defineProperties(AxiosError, descriptors);\nObject.defineProperty(prototype, 'isAxiosError', {value: true});\n\n// eslint-disable-next-line func-names\nAxiosError.from = (error, code, config, request, response, customProps) => {\n  const axiosError = Object.create(prototype);\n\n  utils.toFlatObject(error, axiosError, function filter(obj) {\n    return obj !== Error.prototype;\n  }, prop => {\n    return prop !== 'isAxiosError';\n  });\n\n  AxiosError.call(axiosError, error.message, code, config, request, response);\n\n  axiosError.cause = error;\n\n  axiosError.name = error.name;\n\n  customProps && Object.assign(axiosError, customProps);\n\n  return axiosError;\n};\n\nexport default AxiosError;\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosError from '../core/AxiosError.js';\n// temporary hotfix to avoid circular references until AxiosURLSearchParams is refactored\nimport PlatformFormData from '../platform/node/classes/FormData.js';\n\n/**\n * Determines if the given thing is a array or js object.\n *\n * @param {string} thing - The object or array to be visited.\n *\n * @returns {boolean}\n */\nfunction isVisitable(thing) {\n  return utils.isPlainObject(thing) || utils.isArray(thing);\n}\n\n/**\n * It removes the brackets from the end of a string\n *\n * @param {string} key - The key of the parameter.\n *\n * @returns {string} the key without the brackets.\n */\nfunction removeBrackets(key) {\n  return utils.endsWith(key, '[]') ? key.slice(0, -2) : key;\n}\n\n/**\n * It takes a path, a key, and a boolean, and returns a string\n *\n * @param {string} path - The path to the current key.\n * @param {string} key - The key of the current object being iterated over.\n * @param {string} dots - If true, the key will be rendered with dots instead of brackets.\n *\n * @returns {string} The path to the current key.\n */\nfunction renderKey(path, key, dots) {\n  if (!path) return key;\n  return path.concat(key).map(function each(token, i) {\n    // eslint-disable-next-line no-param-reassign\n    token = removeBrackets(token);\n    return !dots && i ? '[' + token + ']' : token;\n  }).join(dots ? '.' : '');\n}\n\n/**\n * If the array is an array and none of its elements are visitable, then it's a flat array.\n *\n * @param {Array<any>} arr - The array to check\n *\n * @returns {boolean}\n */\nfunction isFlatArray(arr) {\n  return utils.isArray(arr) && !arr.some(isVisitable);\n}\n\nconst predicates = utils.toFlatObject(utils, {}, null, function filter(prop) {\n  return /^is[A-Z]/.test(prop);\n});\n\n/**\n * Convert a data object to FormData\n *\n * @param {Object} obj\n * @param {?Object} [formData]\n * @param {?Object} [options]\n * @param {Function} [options.visitor]\n * @param {Boolean} [options.metaTokens = true]\n * @param {Boolean} [options.dots = false]\n * @param {?Boolean} [options.indexes = false]\n *\n * @returns {Object}\n **/\n\n/**\n * It converts an object into a FormData object\n *\n * @param {Object<any, any>} obj - The object to convert to form data.\n * @param {string} formData - The FormData object to append to.\n * @param {Object<string, any>} options\n *\n * @returns\n */\nfunction toFormData(obj, formData, options) {\n  if (!utils.isObject(obj)) {\n    throw new TypeError('target must be an object');\n  }\n\n  // eslint-disable-next-line no-param-reassign\n  formData = formData || new (PlatformFormData || FormData)();\n\n  // eslint-disable-next-line no-param-reassign\n  options = utils.toFlatObject(options, {\n    metaTokens: true,\n    dots: false,\n    indexes: false\n  }, false, function defined(option, source) {\n    // eslint-disable-next-line no-eq-null,eqeqeq\n    return !utils.isUndefined(source[option]);\n  });\n\n  const metaTokens = options.metaTokens;\n  // eslint-disable-next-line no-use-before-define\n  const visitor = options.visitor || defaultVisitor;\n  const dots = options.dots;\n  const indexes = options.indexes;\n  const _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;\n  const useBlob = _Blob && utils.isSpecCompliantForm(formData);\n\n  if (!utils.isFunction(visitor)) {\n    throw new TypeError('visitor must be a function');\n  }\n\n  function convertValue(value) {\n    if (value === null) return '';\n\n    if (utils.isDate(value)) {\n      return value.toISOString();\n    }\n\n    if (!useBlob && utils.isBlob(value)) {\n      throw new AxiosError('Blob is not supported. Use a Buffer instead.');\n    }\n\n    if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {\n      return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);\n    }\n\n    return value;\n  }\n\n  /**\n   * Default visitor.\n   *\n   * @param {*} value\n   * @param {String|Number} key\n   * @param {Array<String|Number>} path\n   * @this {FormData}\n   *\n   * @returns {boolean} return true to visit the each prop of the value recursively\n   */\n  function defaultVisitor(value, key, path) {\n    let arr = value;\n\n    if (value && !path && typeof value === 'object') {\n      if (utils.endsWith(key, '{}')) {\n        // eslint-disable-next-line no-param-reassign\n        key = metaTokens ? key : key.slice(0, -2);\n        // eslint-disable-next-line no-param-reassign\n        value = JSON.stringify(value);\n      } else if (\n        (utils.isArray(value) && isFlatArray(value)) ||\n        ((utils.isFileList(value) || utils.endsWith(key, '[]')) && (arr = utils.toArray(value))\n        )) {\n        // eslint-disable-next-line no-param-reassign\n        key = removeBrackets(key);\n\n        arr.forEach(function each(el, index) {\n          !(utils.isUndefined(el) || el === null) && formData.append(\n            // eslint-disable-next-line no-nested-ternary\n            indexes === true ? renderKey([key], index, dots) : (indexes === null ? key : key + '[]'),\n            convertValue(el)\n          );\n        });\n        return false;\n      }\n    }\n\n    if (isVisitable(value)) {\n      return true;\n    }\n\n    formData.append(renderKey(path, key, dots), convertValue(value));\n\n    return false;\n  }\n\n  const stack = [];\n\n  const exposedHelpers = Object.assign(predicates, {\n    defaultVisitor,\n    convertValue,\n    isVisitable\n  });\n\n  function build(value, path) {\n    if (utils.isUndefined(value)) return;\n\n    if (stack.indexOf(value) !== -1) {\n      throw Error('Circular reference detected in ' + path.join('.'));\n    }\n\n    stack.push(value);\n\n    utils.forEach(value, function each(el, key) {\n      const result = !(utils.isUndefined(el) || el === null) && visitor.call(\n        formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers\n      );\n\n      if (result === true) {\n        build(el, path ? path.concat(key) : [key]);\n      }\n    });\n\n    stack.pop();\n  }\n\n  if (!utils.isObject(obj)) {\n    throw new TypeError('data must be an object');\n  }\n\n  build(obj);\n\n  return formData;\n}\n\nexport default toFormData;\n","'use strict';\n\nimport toFormData from './toFormData.js';\n\n/**\n * It encodes a string by replacing all characters that are not in the unreserved set with\n * their percent-encoded equivalents\n *\n * @param {string} str - The string to encode.\n *\n * @returns {string} The encoded string.\n */\nfunction encode(str) {\n  const charMap = {\n    '!': '%21',\n    \"'\": '%27',\n    '(': '%28',\n    ')': '%29',\n    '~': '%7E',\n    '%20': '+',\n    '%00': '\\x00'\n  };\n  return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {\n    return charMap[match];\n  });\n}\n\n/**\n * It takes a params object and converts it to a FormData object\n *\n * @param {Object<string, any>} params - The parameters to be converted to a FormData object.\n * @param {Object<string, any>} options - The options object passed to the Axios constructor.\n *\n * @returns {void}\n */\nfunction AxiosURLSearchParams(params, options) {\n  this._pairs = [];\n\n  params && toFormData(params, this, options);\n}\n\nconst prototype = AxiosURLSearchParams.prototype;\n\nprototype.append = function append(name, value) {\n  this._pairs.push([name, value]);\n};\n\nprototype.toString = function toString(encoder) {\n  const _encode = encoder ? function(value) {\n    return encoder.call(this, value, encode);\n  } : encode;\n\n  return this._pairs.map(function each(pair) {\n    return _encode(pair[0]) + '=' + _encode(pair[1]);\n  }, '').join('&');\n};\n\nexport default AxiosURLSearchParams;\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosURLSearchParams from '../helpers/AxiosURLSearchParams.js';\n\n/**\n * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their\n * URI encoded counterparts\n *\n * @param {string} val The value to be encoded.\n *\n * @returns {string} The encoded value.\n */\nfunction encode(val) {\n  return encodeURIComponent(val).\n    replace(/%3A/gi, ':').\n    replace(/%24/g, '$').\n    replace(/%2C/gi, ',').\n    replace(/%20/g, '+').\n    replace(/%5B/gi, '[').\n    replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @param {?object} options\n *\n * @returns {string} The formatted url\n */\nexport default function buildURL(url, params, options) {\n  /*eslint no-param-reassign:0*/\n  if (!params) {\n    return url;\n  }\n  \n  const _encode = options && options.encode || encode;\n\n  const serializeFn = options && options.serialize;\n\n  let serializedParams;\n\n  if (serializeFn) {\n    serializedParams = serializeFn(params, options);\n  } else {\n    serializedParams = utils.isURLSearchParams(params) ?\n      params.toString() :\n      new AxiosURLSearchParams(params, options).toString(_encode);\n  }\n\n  if (serializedParams) {\n    const hashmarkIndex = url.indexOf(\"#\");\n\n    if (hashmarkIndex !== -1) {\n      url = url.slice(0, hashmarkIndex);\n    }\n    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n  }\n\n  return url;\n}\n","'use strict';\n\nimport utils from './../utils.js';\n\nclass InterceptorManager {\n  constructor() {\n    this.handlers = [];\n  }\n\n  /**\n   * Add a new interceptor to the stack\n   *\n   * @param {Function} fulfilled The function to handle `then` for a `Promise`\n   * @param {Function} rejected The function to handle `reject` for a `Promise`\n   *\n   * @return {Number} An ID used to remove interceptor later\n   */\n  use(fulfilled, rejected, options) {\n    this.handlers.push({\n      fulfilled,\n      rejected,\n      synchronous: options ? options.synchronous : false,\n      runWhen: options ? options.runWhen : null\n    });\n    return this.handlers.length - 1;\n  }\n\n  /**\n   * Remove an interceptor from the stack\n   *\n   * @param {Number} id The ID that was returned by `use`\n   *\n   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise\n   */\n  eject(id) {\n    if (this.handlers[id]) {\n      this.handlers[id] = null;\n    }\n  }\n\n  /**\n   * Clear all interceptors from the stack\n   *\n   * @returns {void}\n   */\n  clear() {\n    if (this.handlers) {\n      this.handlers = [];\n    }\n  }\n\n  /**\n   * Iterate over all the registered interceptors\n   *\n   * This method is particularly useful for skipping over any\n   * interceptors that may have become `null` calling `eject`.\n   *\n   * @param {Function} fn The function to call for each interceptor\n   *\n   * @returns {void}\n   */\n  forEach(fn) {\n    utils.forEach(this.handlers, function forEachHandler(h) {\n      if (h !== null) {\n        fn(h);\n      }\n    });\n  }\n}\n\nexport default InterceptorManager;\n","'use strict';\n\nexport default {\n  silentJSONParsing: true,\n  forcedJSONParsing: true,\n  clarifyTimeoutError: false\n};\n","import URLSearchParams from './classes/URLSearchParams.js'\nimport FormData from './classes/FormData.js'\nimport Blob from './classes/Blob.js'\n\nexport default {\n  isBrowser: true,\n  classes: {\n    URLSearchParams,\n    FormData,\n    Blob\n  },\n  protocols: ['http', 'https', 'file', 'blob', 'url', 'data']\n};\n","'use strict';\n\nimport AxiosURLSearchParams from '../../../helpers/AxiosURLSearchParams.js';\nexport default typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;\n","'use strict';\n\nexport default typeof FormData !== 'undefined' ? FormData : null;\n","'use strict'\n\nexport default typeof Blob !== 'undefined' ? Blob : null\n","const hasBrowserEnv = typeof window !== 'undefined' && typeof document !== 'undefined';\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n *  typeof window -> undefined\n *  typeof document -> undefined\n *\n * react-native:\n *  navigator.product -> 'ReactNative'\n * nativescript\n *  navigator.product -> 'NativeScript' or 'NS'\n *\n * @returns {boolean}\n */\nconst hasStandardBrowserEnv = (\n  (product) => {\n    return hasBrowserEnv && ['ReactNative', 'NativeScript', 'NS'].indexOf(product) < 0\n  })(typeof navigator !== 'undefined' && navigator.product);\n\n/**\n * Determine if we're running in a standard browser webWorker environment\n *\n * Although the `isStandardBrowserEnv` method indicates that\n * `allows axios to run in a web worker`, the WebWorker will still be\n * filtered out due to its judgment standard\n * `typeof window !== 'undefined' && typeof document !== 'undefined'`.\n * This leads to a problem when axios post `FormData` in webWorker\n */\nconst hasStandardBrowserWebWorkerEnv = (() => {\n  return (\n    typeof WorkerGlobalScope !== 'undefined' &&\n    // eslint-disable-next-line no-undef\n    self instanceof WorkerGlobalScope &&\n    typeof self.importScripts === 'function'\n  );\n})();\n\nconst origin = hasBrowserEnv && window.location.href || 'http://localhost';\n\nexport {\n  hasBrowserEnv,\n  hasStandardBrowserWebWorkerEnv,\n  hasStandardBrowserEnv,\n  origin\n}\n","import platform from './node/index.js';\nimport * as utils from './common/utils.js';\n\nexport default {\n  ...utils,\n  ...platform\n}\n","'use strict';\n\nimport utils from '../utils.js';\n\n/**\n * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']\n *\n * @param {string} name - The name of the property to get.\n *\n * @returns An array of strings.\n */\nfunction parsePropPath(name) {\n  // foo[x][y][z]\n  // foo.x.y.z\n  // foo-x-y-z\n  // foo x y z\n  return utils.matchAll(/\\w+|\\[(\\w*)]/g, name).map(match => {\n    return match[0] === '[]' ? '' : match[1] || match[0];\n  });\n}\n\n/**\n * Convert an array to an object.\n *\n * @param {Array<any>} arr - The array to convert to an object.\n *\n * @returns An object with the same keys and values as the array.\n */\nfunction arrayToObject(arr) {\n  const obj = {};\n  const keys = Object.keys(arr);\n  let i;\n  const len = keys.length;\n  let key;\n  for (i = 0; i < len; i++) {\n    key = keys[i];\n    obj[key] = arr[key];\n  }\n  return obj;\n}\n\n/**\n * It takes a FormData object and returns a JavaScript object\n *\n * @param {string} formData The FormData object to convert to JSON.\n *\n * @returns {Object<string, any> | null} The converted object.\n */\nfunction formDataToJSON(formData) {\n  function buildPath(path, value, target, index) {\n    let name = path[index++];\n\n    if (name === '__proto__') return true;\n\n    const isNumericKey = Number.isFinite(+name);\n    const isLast = index >= path.length;\n    name = !name && utils.isArray(target) ? target.length : name;\n\n    if (isLast) {\n      if (utils.hasOwnProp(target, name)) {\n        target[name] = [target[name], value];\n      } else {\n        target[name] = value;\n      }\n\n      return !isNumericKey;\n    }\n\n    if (!target[name] || !utils.isObject(target[name])) {\n      target[name] = [];\n    }\n\n    const result = buildPath(path, value, target[name], index);\n\n    if (result && utils.isArray(target[name])) {\n      target[name] = arrayToObject(target[name]);\n    }\n\n    return !isNumericKey;\n  }\n\n  if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {\n    const obj = {};\n\n    utils.forEachEntry(formData, (name, value) => {\n      buildPath(parsePropPath(name), value, obj, 0);\n    });\n\n    return obj;\n  }\n\n  return null;\n}\n\nexport default formDataToJSON;\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosError from '../core/AxiosError.js';\nimport transitionalDefaults from './transitional.js';\nimport toFormData from '../helpers/toFormData.js';\nimport toURLEncodedForm from '../helpers/toURLEncodedForm.js';\nimport platform from '../platform/index.js';\nimport formDataToJSON from '../helpers/formDataToJSON.js';\n\n/**\n * It takes a string, tries to parse it, and if it fails, it returns the stringified version\n * of the input\n *\n * @param {any} rawValue - The value to be stringified.\n * @param {Function} parser - A function that parses a string into a JavaScript object.\n * @param {Function} encoder - A function that takes a value and returns a string.\n *\n * @returns {string} A stringified version of the rawValue.\n */\nfunction stringifySafely(rawValue, parser, encoder) {\n  if (utils.isString(rawValue)) {\n    try {\n      (parser || JSON.parse)(rawValue);\n      return utils.trim(rawValue);\n    } catch (e) {\n      if (e.name !== 'SyntaxError') {\n        throw e;\n      }\n    }\n  }\n\n  return (encoder || JSON.stringify)(rawValue);\n}\n\nconst defaults = {\n\n  transitional: transitionalDefaults,\n\n  adapter: ['xhr', 'http', 'fetch'],\n\n  transformRequest: [function transformRequest(data, headers) {\n    const contentType = headers.getContentType() || '';\n    const hasJSONContentType = contentType.indexOf('application/json') > -1;\n    const isObjectPayload = utils.isObject(data);\n\n    if (isObjectPayload && utils.isHTMLForm(data)) {\n      data = new FormData(data);\n    }\n\n    const isFormData = utils.isFormData(data);\n\n    if (isFormData) {\n      return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;\n    }\n\n    if (utils.isArrayBuffer(data) ||\n      utils.isBuffer(data) ||\n      utils.isStream(data) ||\n      utils.isFile(data) ||\n      utils.isBlob(data) ||\n      utils.isReadableStream(data)\n    ) {\n      return data;\n    }\n    if (utils.isArrayBufferView(data)) {\n      return data.buffer;\n    }\n    if (utils.isURLSearchParams(data)) {\n      headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);\n      return data.toString();\n    }\n\n    let isFileList;\n\n    if (isObjectPayload) {\n      if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {\n        return toURLEncodedForm(data, this.formSerializer).toString();\n      }\n\n      if ((isFileList = utils.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {\n        const _FormData = this.env && this.env.FormData;\n\n        return toFormData(\n          isFileList ? {'files[]': data} : data,\n          _FormData && new _FormData(),\n          this.formSerializer\n        );\n      }\n    }\n\n    if (isObjectPayload || hasJSONContentType ) {\n      headers.setContentType('application/json', false);\n      return stringifySafely(data);\n    }\n\n    return data;\n  }],\n\n  transformResponse: [function transformResponse(data) {\n    const transitional = this.transitional || defaults.transitional;\n    const forcedJSONParsing = transitional && transitional.forcedJSONParsing;\n    const JSONRequested = this.responseType === 'json';\n\n    if (utils.isResponse(data) || utils.isReadableStream(data)) {\n      return data;\n    }\n\n    if (data && utils.isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) {\n      const silentJSONParsing = transitional && transitional.silentJSONParsing;\n      const strictJSONParsing = !silentJSONParsing && JSONRequested;\n\n      try {\n        return JSON.parse(data);\n      } catch (e) {\n        if (strictJSONParsing) {\n          if (e.name === 'SyntaxError') {\n            throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);\n          }\n          throw e;\n        }\n      }\n    }\n\n    return data;\n  }],\n\n  /**\n   * A timeout in milliseconds to abort a request. If set to 0 (default) a\n   * timeout is not created.\n   */\n  timeout: 0,\n\n  xsrfCookieName: 'XSRF-TOKEN',\n  xsrfHeaderName: 'X-XSRF-TOKEN',\n\n  maxContentLength: -1,\n  maxBodyLength: -1,\n\n  env: {\n    FormData: platform.classes.FormData,\n    Blob: platform.classes.Blob\n  },\n\n  validateStatus: function validateStatus(status) {\n    return status >= 200 && status < 300;\n  },\n\n  headers: {\n    common: {\n      'Accept': 'application/json, text/plain, */*',\n      'Content-Type': undefined\n    }\n  }\n};\n\nutils.forEach(['delete', 'get', 'head', 'post', 'put', 'patch'], (method) => {\n  defaults.headers[method] = {};\n});\n\nexport default defaults;\n","'use strict';\n\nimport utils from '../utils.js';\nimport toFormData from './toFormData.js';\nimport platform from '../platform/index.js';\n\nexport default function toURLEncodedForm(data, options) {\n  return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({\n    visitor: function(value, key, path, helpers) {\n      if (platform.isNode && utils.isBuffer(value)) {\n        this.append(key, value.toString('base64'));\n        return false;\n      }\n\n      return helpers.defaultVisitor.apply(this, arguments);\n    }\n  }, options));\n}\n","'use strict';\n\nimport utils from './../utils.js';\n\n// RawAxiosHeaders whose duplicates are ignored by node\n// c.f. https://nodejs.org/api/http.html#http_message_headers\nconst ignoreDuplicateOf = utils.toObjectSet([\n  'age', 'authorization', 'content-length', 'content-type', 'etag',\n  'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',\n  'last-modified', 'location', 'max-forwards', 'proxy-authorization',\n  'referer', 'retry-after', 'user-agent'\n]);\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} rawHeaders Headers needing to be parsed\n *\n * @returns {Object} Headers parsed into an object\n */\nexport default rawHeaders => {\n  const parsed = {};\n  let key;\n  let val;\n  let i;\n\n  rawHeaders && rawHeaders.split('\\n').forEach(function parser(line) {\n    i = line.indexOf(':');\n    key = line.substring(0, i).trim().toLowerCase();\n    val = line.substring(i + 1).trim();\n\n    if (!key || (parsed[key] && ignoreDuplicateOf[key])) {\n      return;\n    }\n\n    if (key === 'set-cookie') {\n      if (parsed[key]) {\n        parsed[key].push(val);\n      } else {\n        parsed[key] = [val];\n      }\n    } else {\n      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n    }\n  });\n\n  return parsed;\n};\n","'use strict';\n\nimport utils from '../utils.js';\nimport parseHeaders from '../helpers/parseHeaders.js';\n\nconst $internals = Symbol('internals');\n\nfunction normalizeHeader(header) {\n  return header && String(header).trim().toLowerCase();\n}\n\nfunction normalizeValue(value) {\n  if (value === false || value == null) {\n    return value;\n  }\n\n  return utils.isArray(value) ? value.map(normalizeValue) : String(value);\n}\n\nfunction parseTokens(str) {\n  const tokens = Object.create(null);\n  const tokensRE = /([^\\s,;=]+)\\s*(?:=\\s*([^,;]+))?/g;\n  let match;\n\n  while ((match = tokensRE.exec(str))) {\n    tokens[match[1]] = match[2];\n  }\n\n  return tokens;\n}\n\nconst isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());\n\nfunction matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {\n  if (utils.isFunction(filter)) {\n    return filter.call(this, value, header);\n  }\n\n  if (isHeaderNameFilter) {\n    value = header;\n  }\n\n  if (!utils.isString(value)) return;\n\n  if (utils.isString(filter)) {\n    return value.indexOf(filter) !== -1;\n  }\n\n  if (utils.isRegExp(filter)) {\n    return filter.test(value);\n  }\n}\n\nfunction formatHeader(header) {\n  return header.trim()\n    .toLowerCase().replace(/([a-z\\d])(\\w*)/g, (w, char, str) => {\n      return char.toUpperCase() + str;\n    });\n}\n\nfunction buildAccessors(obj, header) {\n  const accessorName = utils.toCamelCase(' ' + header);\n\n  ['get', 'set', 'has'].forEach(methodName => {\n    Object.defineProperty(obj, methodName + accessorName, {\n      value: function(arg1, arg2, arg3) {\n        return this[methodName].call(this, header, arg1, arg2, arg3);\n      },\n      configurable: true\n    });\n  });\n}\n\nclass AxiosHeaders {\n  constructor(headers) {\n    headers && this.set(headers);\n  }\n\n  set(header, valueOrRewrite, rewrite) {\n    const self = this;\n\n    function setHeader(_value, _header, _rewrite) {\n      const lHeader = normalizeHeader(_header);\n\n      if (!lHeader) {\n        throw new Error('header name must be a non-empty string');\n      }\n\n      const key = utils.findKey(self, lHeader);\n\n      if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) {\n        self[key || _header] = normalizeValue(_value);\n      }\n    }\n\n    const setHeaders = (headers, _rewrite) =>\n      utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));\n\n    if (utils.isPlainObject(header) || header instanceof this.constructor) {\n      setHeaders(header, valueOrRewrite)\n    } else if(utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {\n      setHeaders(parseHeaders(header), valueOrRewrite);\n    } else if (utils.isHeaders(header)) {\n      for (const [key, value] of header.entries()) {\n        setHeader(value, key, rewrite);\n      }\n    } else {\n      header != null && setHeader(valueOrRewrite, header, rewrite);\n    }\n\n    return this;\n  }\n\n  get(header, parser) {\n    header = normalizeHeader(header);\n\n    if (header) {\n      const key = utils.findKey(this, header);\n\n      if (key) {\n        const value = this[key];\n\n        if (!parser) {\n          return value;\n        }\n\n        if (parser === true) {\n          return parseTokens(value);\n        }\n\n        if (utils.isFunction(parser)) {\n          return parser.call(this, value, key);\n        }\n\n        if (utils.isRegExp(parser)) {\n          return parser.exec(value);\n        }\n\n        throw new TypeError('parser must be boolean|regexp|function');\n      }\n    }\n  }\n\n  has(header, matcher) {\n    header = normalizeHeader(header);\n\n    if (header) {\n      const key = utils.findKey(this, header);\n\n      return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));\n    }\n\n    return false;\n  }\n\n  delete(header, matcher) {\n    const self = this;\n    let deleted = false;\n\n    function deleteHeader(_header) {\n      _header = normalizeHeader(_header);\n\n      if (_header) {\n        const key = utils.findKey(self, _header);\n\n        if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {\n          delete self[key];\n\n          deleted = true;\n        }\n      }\n    }\n\n    if (utils.isArray(header)) {\n      header.forEach(deleteHeader);\n    } else {\n      deleteHeader(header);\n    }\n\n    return deleted;\n  }\n\n  clear(matcher) {\n    const keys = Object.keys(this);\n    let i = keys.length;\n    let deleted = false;\n\n    while (i--) {\n      const key = keys[i];\n      if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {\n        delete this[key];\n        deleted = true;\n      }\n    }\n\n    return deleted;\n  }\n\n  normalize(format) {\n    const self = this;\n    const headers = {};\n\n    utils.forEach(this, (value, header) => {\n      const key = utils.findKey(headers, header);\n\n      if (key) {\n        self[key] = normalizeValue(value);\n        delete self[header];\n        return;\n      }\n\n      const normalized = format ? formatHeader(header) : String(header).trim();\n\n      if (normalized !== header) {\n        delete self[header];\n      }\n\n      self[normalized] = normalizeValue(value);\n\n      headers[normalized] = true;\n    });\n\n    return this;\n  }\n\n  concat(...targets) {\n    return this.constructor.concat(this, ...targets);\n  }\n\n  toJSON(asStrings) {\n    const obj = Object.create(null);\n\n    utils.forEach(this, (value, header) => {\n      value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);\n    });\n\n    return obj;\n  }\n\n  [Symbol.iterator]() {\n    return Object.entries(this.toJSON())[Symbol.iterator]();\n  }\n\n  toString() {\n    return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\\n');\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'AxiosHeaders';\n  }\n\n  static from(thing) {\n    return thing instanceof this ? thing : new this(thing);\n  }\n\n  static concat(first, ...targets) {\n    const computed = new this(first);\n\n    targets.forEach((target) => computed.set(target));\n\n    return computed;\n  }\n\n  static accessor(header) {\n    const internals = this[$internals] = (this[$internals] = {\n      accessors: {}\n    });\n\n    const accessors = internals.accessors;\n    const prototype = this.prototype;\n\n    function defineAccessor(_header) {\n      const lHeader = normalizeHeader(_header);\n\n      if (!accessors[lHeader]) {\n        buildAccessors(prototype, _header);\n        accessors[lHeader] = true;\n      }\n    }\n\n    utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);\n\n    return this;\n  }\n}\n\nAxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);\n\n// reserved names hotfix\nutils.reduceDescriptors(AxiosHeaders.prototype, ({value}, key) => {\n  let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`\n  return {\n    get: () => value,\n    set(headerValue) {\n      this[mapped] = headerValue;\n    }\n  }\n});\n\nutils.freezeMethods(AxiosHeaders);\n\nexport default AxiosHeaders;\n","'use strict';\n\nimport utils from './../utils.js';\nimport defaults from '../defaults/index.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Array|Function} fns A single function or Array of functions\n * @param {?Object} response The response object\n *\n * @returns {*} The resulting transformed data\n */\nexport default function transformData(fns, response) {\n  const config = this || defaults;\n  const context = response || config;\n  const headers = AxiosHeaders.from(context.headers);\n  let data = context.data;\n\n  utils.forEach(fns, function transform(fn) {\n    data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);\n  });\n\n  headers.normalize();\n\n  return data;\n}\n","'use strict';\n\nexport default function isCancel(value) {\n  return !!(value && value.__CANCEL__);\n}\n","'use strict';\n\nimport AxiosError from '../core/AxiosError.js';\nimport utils from '../utils.js';\n\n/**\n * A `CanceledError` is an object that is thrown when an operation is canceled.\n *\n * @param {string=} message The message.\n * @param {Object=} config The config.\n * @param {Object=} request The request.\n *\n * @returns {CanceledError} The created error.\n */\nfunction CanceledError(message, config, request) {\n  // eslint-disable-next-line no-eq-null,eqeqeq\n  AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);\n  this.name = 'CanceledError';\n}\n\nutils.inherits(CanceledError, AxiosError, {\n  __CANCEL__: true\n});\n\nexport default CanceledError;\n","'use strict';\n\nimport AxiosError from './AxiosError.js';\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n *\n * @returns {object} The response.\n */\nexport default function settle(resolve, reject, response) {\n  const validateStatus = response.config.validateStatus;\n  if (!response.status || !validateStatus || validateStatus(response.status)) {\n    resolve(response);\n  } else {\n    reject(new AxiosError(\n      'Request failed with status code ' + response.status,\n      [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],\n      response.config,\n      response.request,\n      response\n    ));\n  }\n}\n","'use strict';\n\n/**\n * Calculate data maxRate\n * @param {Number} [samplesCount= 10]\n * @param {Number} [min= 1000]\n * @returns {Function}\n */\nfunction speedometer(samplesCount, min) {\n  samplesCount = samplesCount || 10;\n  const bytes = new Array(samplesCount);\n  const timestamps = new Array(samplesCount);\n  let head = 0;\n  let tail = 0;\n  let firstSampleTS;\n\n  min = min !== undefined ? min : 1000;\n\n  return function push(chunkLength) {\n    const now = Date.now();\n\n    const startedAt = timestamps[tail];\n\n    if (!firstSampleTS) {\n      firstSampleTS = now;\n    }\n\n    bytes[head] = chunkLength;\n    timestamps[head] = now;\n\n    let i = tail;\n    let bytesCount = 0;\n\n    while (i !== head) {\n      bytesCount += bytes[i++];\n      i = i % samplesCount;\n    }\n\n    head = (head + 1) % samplesCount;\n\n    if (head === tail) {\n      tail = (tail + 1) % samplesCount;\n    }\n\n    if (now - firstSampleTS < min) {\n      return;\n    }\n\n    const passed = startedAt && now - startedAt;\n\n    return passed ? Math.round(bytesCount * 1000 / passed) : undefined;\n  };\n}\n\nexport default speedometer;\n","import speedometer from \"./speedometer.js\";\nimport throttle from \"./throttle.js\";\n\nexport default (listener, isDownloadStream, freq = 3) => {\n  let bytesNotified = 0;\n  const _speedometer = speedometer(50, 250);\n\n  return throttle(e => {\n    const loaded = e.loaded;\n    const total = e.lengthComputable ? e.total : undefined;\n    const progressBytes = loaded - bytesNotified;\n    const rate = _speedometer(progressBytes);\n    const inRange = loaded <= total;\n\n    bytesNotified = loaded;\n\n    const data = {\n      loaded,\n      total,\n      progress: total ? (loaded / total) : undefined,\n      bytes: progressBytes,\n      rate: rate ? rate : undefined,\n      estimated: rate && total && inRange ? (total - loaded) / rate : undefined,\n      event: e,\n      lengthComputable: total != null\n    };\n\n    data[isDownloadStream ? 'download' : 'upload'] = true;\n\n    listener(data);\n  }, freq);\n}\n","'use strict';\n\n/**\n * Throttle decorator\n * @param {Function} fn\n * @param {Number} freq\n * @return {Function}\n */\nfunction throttle(fn, freq) {\n  let timestamp = 0;\n  const threshold = 1000 / freq;\n  let timer = null;\n  return function throttled() {\n    const force = this === true;\n\n    const now = Date.now();\n    if (force || now - timestamp > threshold) {\n      if (timer) {\n        clearTimeout(timer);\n        timer = null;\n      }\n      timestamp = now;\n      return fn.apply(null, arguments);\n    }\n    if (!timer) {\n      timer = setTimeout(() => {\n        timer = null;\n        timestamp = Date.now();\n        return fn.apply(null, arguments);\n      }, threshold - (now - timestamp));\n    }\n  };\n}\n\nexport default throttle;\n","'use strict';\n\nimport utils from './../utils.js';\nimport platform from '../platform/index.js';\n\nexport default platform.hasStandardBrowserEnv ?\n\n// Standard browser envs have full support of the APIs needed to test\n// whether the request URL is of the same origin as current location.\n  (function standardBrowserEnv() {\n    const msie = /(msie|trident)/i.test(navigator.userAgent);\n    const urlParsingNode = document.createElement('a');\n    let originURL;\n\n    /**\n    * Parse a URL to discover its components\n    *\n    * @param {String} url The URL to be parsed\n    * @returns {Object}\n    */\n    function resolveURL(url) {\n      let href = url;\n\n      if (msie) {\n        // IE needs attribute set twice to normalize properties\n        urlParsingNode.setAttribute('href', href);\n        href = urlParsingNode.href;\n      }\n\n      urlParsingNode.setAttribute('href', href);\n\n      // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n      return {\n        href: urlParsingNode.href,\n        protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n        host: urlParsingNode.host,\n        search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n        hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n        hostname: urlParsingNode.hostname,\n        port: urlParsingNode.port,\n        pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n          urlParsingNode.pathname :\n          '/' + urlParsingNode.pathname\n      };\n    }\n\n    originURL = resolveURL(window.location.href);\n\n    /**\n    * Determine if a URL shares the same origin as the current location\n    *\n    * @param {String} requestURL The URL to test\n    * @returns {boolean} True if URL shares the same origin, otherwise false\n    */\n    return function isURLSameOrigin(requestURL) {\n      const parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n      return (parsed.protocol === originURL.protocol &&\n          parsed.host === originURL.host);\n    };\n  })() :\n\n  // Non standard browser envs (web workers, react-native) lack needed support.\n  (function nonStandardBrowserEnv() {\n    return function isURLSameOrigin() {\n      return true;\n    };\n  })();\n","import utils from './../utils.js';\nimport platform from '../platform/index.js';\n\nexport default platform.hasStandardBrowserEnv ?\n\n  // Standard browser envs support document.cookie\n  {\n    write(name, value, expires, path, domain, secure) {\n      const cookie = [name + '=' + encodeURIComponent(value)];\n\n      utils.isNumber(expires) && cookie.push('expires=' + new Date(expires).toGMTString());\n\n      utils.isString(path) && cookie.push('path=' + path);\n\n      utils.isString(domain) && cookie.push('domain=' + domain);\n\n      secure === true && cookie.push('secure');\n\n      document.cookie = cookie.join('; ');\n    },\n\n    read(name) {\n      const match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n      return (match ? decodeURIComponent(match[3]) : null);\n    },\n\n    remove(name) {\n      this.write(name, '', Date.now() - 86400000);\n    }\n  }\n\n  :\n\n  // Non-standard browser env (web workers, react-native) lack needed support.\n  {\n    write() {},\n    read() {\n      return null;\n    },\n    remove() {}\n  };\n\n","'use strict';\n\nimport isAbsoluteURL from '../helpers/isAbsoluteURL.js';\nimport combineURLs from '../helpers/combineURLs.js';\n\n/**\n * Creates a new URL by combining the baseURL with the requestedURL,\n * only when the requestedURL is not already an absolute URL.\n * If the requestURL is absolute, this function returns the requestedURL untouched.\n *\n * @param {string} baseURL The base URL\n * @param {string} requestedURL Absolute or relative URL to combine\n *\n * @returns {string} The combined full path\n */\nexport default function buildFullPath(baseURL, requestedURL) {\n  if (baseURL && !isAbsoluteURL(requestedURL)) {\n    return combineURLs(baseURL, requestedURL);\n  }\n  return requestedURL;\n}\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n *\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nexport default function isAbsoluteURL(url) {\n  // A URL is considered absolute if it begins with \"<scheme>://\" or \"//\" (protocol-relative URL).\n  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n  // by any combination of letters, digits, plus, period, or hyphen.\n  return /^([a-z][a-z\\d+\\-.]*:)?\\/\\//i.test(url);\n}\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n *\n * @returns {string} The combined URL\n */\nexport default function combineURLs(baseURL, relativeURL) {\n  return relativeURL\n    ? baseURL.replace(/\\/?\\/$/, '') + '/' + relativeURL.replace(/^\\/+/, '')\n    : baseURL;\n}\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosHeaders from \"./AxiosHeaders.js\";\n\nconst headersToObject = (thing) => thing instanceof AxiosHeaders ? { ...thing } : thing;\n\n/**\n * Config-specific merge-function which creates a new config-object\n * by merging two configuration objects together.\n *\n * @param {Object} config1\n * @param {Object} config2\n *\n * @returns {Object} New object resulting from merging config2 to config1\n */\nexport default function mergeConfig(config1, config2) {\n  // eslint-disable-next-line no-param-reassign\n  config2 = config2 || {};\n  const config = {};\n\n  function getMergedValue(target, source, caseless) {\n    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {\n      return utils.merge.call({caseless}, target, source);\n    } else if (utils.isPlainObject(source)) {\n      return utils.merge({}, source);\n    } else if (utils.isArray(source)) {\n      return source.slice();\n    }\n    return source;\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDeepProperties(a, b, caseless) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(a, b, caseless);\n    } else if (!utils.isUndefined(a)) {\n      return getMergedValue(undefined, a, caseless);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function valueFromConfig2(a, b) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(undefined, b);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function defaultToConfig2(a, b) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(undefined, b);\n    } else if (!utils.isUndefined(a)) {\n      return getMergedValue(undefined, a);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDirectKeys(a, b, prop) {\n    if (prop in config2) {\n      return getMergedValue(a, b);\n    } else if (prop in config1) {\n      return getMergedValue(undefined, a);\n    }\n  }\n\n  const mergeMap = {\n    url: valueFromConfig2,\n    method: valueFromConfig2,\n    data: valueFromConfig2,\n    baseURL: defaultToConfig2,\n    transformRequest: defaultToConfig2,\n    transformResponse: defaultToConfig2,\n    paramsSerializer: defaultToConfig2,\n    timeout: defaultToConfig2,\n    timeoutMessage: defaultToConfig2,\n    withCredentials: defaultToConfig2,\n    withXSRFToken: defaultToConfig2,\n    adapter: defaultToConfig2,\n    responseType: defaultToConfig2,\n    xsrfCookieName: defaultToConfig2,\n    xsrfHeaderName: defaultToConfig2,\n    onUploadProgress: defaultToConfig2,\n    onDownloadProgress: defaultToConfig2,\n    decompress: defaultToConfig2,\n    maxContentLength: defaultToConfig2,\n    maxBodyLength: defaultToConfig2,\n    beforeRedirect: defaultToConfig2,\n    transport: defaultToConfig2,\n    httpAgent: defaultToConfig2,\n    httpsAgent: defaultToConfig2,\n    cancelToken: defaultToConfig2,\n    socketPath: defaultToConfig2,\n    responseEncoding: defaultToConfig2,\n    validateStatus: mergeDirectKeys,\n    headers: (a, b) => mergeDeepProperties(headersToObject(a), headersToObject(b), true)\n  };\n\n  utils.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {\n    const merge = mergeMap[prop] || mergeDeepProperties;\n    const configValue = merge(config1[prop], config2[prop], prop);\n    (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);\n  });\n\n  return config;\n}\n","import platform from \"../platform/index.js\";\nimport utils from \"../utils.js\";\nimport isURLSameOrigin from \"./isURLSameOrigin.js\";\nimport cookies from \"./cookies.js\";\nimport buildFullPath from \"../core/buildFullPath.js\";\nimport mergeConfig from \"../core/mergeConfig.js\";\nimport AxiosHeaders from \"../core/AxiosHeaders.js\";\nimport buildURL from \"./buildURL.js\";\n\nexport default (config) => {\n  const newConfig = mergeConfig({}, config);\n\n  let {data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth} = newConfig;\n\n  newConfig.headers = headers = AxiosHeaders.from(headers);\n\n  newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url), config.params, config.paramsSerializer);\n\n  // HTTP basic authentication\n  if (auth) {\n    headers.set('Authorization', 'Basic ' +\n      btoa((auth.username || '') + ':' + (auth.password ? unescape(encodeURIComponent(auth.password)) : ''))\n    );\n  }\n\n  let contentType;\n\n  if (utils.isFormData(data)) {\n    if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {\n      headers.setContentType(undefined); // Let the browser set it\n    } else if ((contentType = headers.getContentType()) !== false) {\n      // fix semicolon duplication issue for ReactNative FormData implementation\n      const [type, ...tokens] = contentType ? contentType.split(';').map(token => token.trim()).filter(Boolean) : [];\n      headers.setContentType([type || 'multipart/form-data', ...tokens].join('; '));\n    }\n  }\n\n  // Add xsrf header\n  // This is only done if running in a standard browser environment.\n  // Specifically not if we're in a web worker, or react-native.\n\n  if (platform.hasStandardBrowserEnv) {\n    withXSRFToken && utils.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig));\n\n    if (withXSRFToken || (withXSRFToken !== false && isURLSameOrigin(newConfig.url))) {\n      // Add xsrf header\n      const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies.read(xsrfCookieName);\n\n      if (xsrfValue) {\n        headers.set(xsrfHeaderName, xsrfValue);\n      }\n    }\n  }\n\n  return newConfig;\n}\n\n","import utils from './../utils.js';\nimport settle from './../core/settle.js';\nimport transitionalDefaults from '../defaults/transitional.js';\nimport AxiosError from '../core/AxiosError.js';\nimport CanceledError from '../cancel/CanceledError.js';\nimport parseProtocol from '../helpers/parseProtocol.js';\nimport platform from '../platform/index.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\nimport progressEventReducer from '../helpers/progressEventReducer.js';\nimport resolveConfig from \"../helpers/resolveConfig.js\";\n\nconst isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';\n\nexport default isXHRAdapterSupported && function (config) {\n  return new Promise(function dispatchXhrRequest(resolve, reject) {\n    const _config = resolveConfig(config);\n    let requestData = _config.data;\n    const requestHeaders = AxiosHeaders.from(_config.headers).normalize();\n    let {responseType} = _config;\n    let onCanceled;\n    function done() {\n      if (_config.cancelToken) {\n        _config.cancelToken.unsubscribe(onCanceled);\n      }\n\n      if (_config.signal) {\n        _config.signal.removeEventListener('abort', onCanceled);\n      }\n    }\n\n    let request = new XMLHttpRequest();\n\n    request.open(_config.method.toUpperCase(), _config.url, true);\n\n    // Set the request timeout in MS\n    request.timeout = _config.timeout;\n\n    function onloadend() {\n      if (!request) {\n        return;\n      }\n      // Prepare the response\n      const responseHeaders = AxiosHeaders.from(\n        'getAllResponseHeaders' in request && request.getAllResponseHeaders()\n      );\n      const responseData = !responseType || responseType === 'text' || responseType === 'json' ?\n        request.responseText : request.response;\n      const response = {\n        data: responseData,\n        status: request.status,\n        statusText: request.statusText,\n        headers: responseHeaders,\n        config,\n        request\n      };\n\n      settle(function _resolve(value) {\n        resolve(value);\n        done();\n      }, function _reject(err) {\n        reject(err);\n        done();\n      }, response);\n\n      // Clean up request\n      request = null;\n    }\n\n    if ('onloadend' in request) {\n      // Use onloadend if available\n      request.onloadend = onloadend;\n    } else {\n      // Listen for ready state to emulate onloadend\n      request.onreadystatechange = function handleLoad() {\n        if (!request || request.readyState !== 4) {\n          return;\n        }\n\n        // The request errored out and we didn't get a response, this will be\n        // handled by onerror instead\n        // With one exception: request that using file: protocol, most browsers\n        // will return status as 0 even though it's a successful request\n        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n          return;\n        }\n        // readystate handler is calling before onerror or ontimeout handlers,\n        // so we should call onloadend on the next 'tick'\n        setTimeout(onloadend);\n      };\n    }\n\n    // Handle browser request cancellation (as opposed to a manual cancellation)\n    request.onabort = function handleAbort() {\n      if (!request) {\n        return;\n      }\n\n      reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, _config, request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle low level network errors\n    request.onerror = function handleError() {\n      // Real errors are hidden from us by the browser\n      // onerror should only fire if it's a network error\n      reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, _config, request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle timeout\n    request.ontimeout = function handleTimeout() {\n      let timeoutErrorMessage = _config.timeout ? 'timeout of ' + _config.timeout + 'ms exceeded' : 'timeout exceeded';\n      const transitional = _config.transitional || transitionalDefaults;\n      if (_config.timeoutErrorMessage) {\n        timeoutErrorMessage = _config.timeoutErrorMessage;\n      }\n      reject(new AxiosError(\n        timeoutErrorMessage,\n        transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,\n        _config,\n        request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Remove Content-Type if data is undefined\n    requestData === undefined && requestHeaders.setContentType(null);\n\n    // Add headers to the request\n    if ('setRequestHeader' in request) {\n      utils.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {\n        request.setRequestHeader(key, val);\n      });\n    }\n\n    // Add withCredentials to request if needed\n    if (!utils.isUndefined(_config.withCredentials)) {\n      request.withCredentials = !!_config.withCredentials;\n    }\n\n    // Add responseType to request if needed\n    if (responseType && responseType !== 'json') {\n      request.responseType = _config.responseType;\n    }\n\n    // Handle progress if needed\n    if (typeof _config.onDownloadProgress === 'function') {\n      request.addEventListener('progress', progressEventReducer(_config.onDownloadProgress, true));\n    }\n\n    // Not all browsers support upload events\n    if (typeof _config.onUploadProgress === 'function' && request.upload) {\n      request.upload.addEventListener('progress', progressEventReducer(_config.onUploadProgress));\n    }\n\n    if (_config.cancelToken || _config.signal) {\n      // Handle cancellation\n      // eslint-disable-next-line func-names\n      onCanceled = cancel => {\n        if (!request) {\n          return;\n        }\n        reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);\n        request.abort();\n        request = null;\n      };\n\n      _config.cancelToken && _config.cancelToken.subscribe(onCanceled);\n      if (_config.signal) {\n        _config.signal.aborted ? onCanceled() : _config.signal.addEventListener('abort', onCanceled);\n      }\n    }\n\n    const protocol = parseProtocol(_config.url);\n\n    if (protocol && platform.protocols.indexOf(protocol) === -1) {\n      reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config));\n      return;\n    }\n\n\n    // Send the request\n    request.send(requestData || null);\n  });\n}\n","'use strict';\n\nexport default function parseProtocol(url) {\n  const match = /^([-+\\w]{1,25})(:?\\/\\/|:)/.exec(url);\n  return match && match[1] || '';\n}\n","import CanceledError from \"../cancel/CanceledError.js\";\nimport AxiosError from \"../core/AxiosError.js\";\n\nconst composeSignals = (signals, timeout) => {\n  let controller = new AbortController();\n\n  let aborted;\n\n  const onabort = function (cancel) {\n    if (!aborted) {\n      aborted = true;\n      unsubscribe();\n      const err = cancel instanceof Error ? cancel : this.reason;\n      controller.abort(err instanceof AxiosError ? err : new CanceledError(err instanceof Error ? err.message : err));\n    }\n  }\n\n  let timer = timeout && setTimeout(() => {\n    onabort(new AxiosError(`timeout ${timeout} of ms exceeded`, AxiosError.ETIMEDOUT))\n  }, timeout)\n\n  const unsubscribe = () => {\n    if (signals) {\n      timer && clearTimeout(timer);\n      timer = null;\n      signals.forEach(signal => {\n        signal &&\n        (signal.removeEventListener ? signal.removeEventListener('abort', onabort) : signal.unsubscribe(onabort));\n      });\n      signals = null;\n    }\n  }\n\n  signals.forEach((signal) => signal && signal.addEventListener && signal.addEventListener('abort', onabort));\n\n  const {signal} = controller;\n\n  signal.unsubscribe = unsubscribe;\n\n  return [signal, () => {\n    timer && clearTimeout(timer);\n    timer = null;\n  }];\n}\n\nexport default composeSignals;\n","\n\nexport const streamChunk = function* (chunk, chunkSize) {\n  let len = chunk.byteLength;\n\n  if (!chunkSize || len < chunkSize) {\n    yield chunk;\n    return;\n  }\n\n  let pos = 0;\n  let end;\n\n  while (pos < len) {\n    end = pos + chunkSize;\n    yield chunk.slice(pos, end);\n    pos = end;\n  }\n}\n\nexport const readBytes = async function* (iterable, chunkSize, encode) {\n  for await (const chunk of iterable) {\n    yield* streamChunk(ArrayBuffer.isView(chunk) ? chunk : (await encode(String(chunk))), chunkSize);\n  }\n}\n\nexport const trackStream = (stream, chunkSize, onProgress, onFinish, encode) => {\n  const iterator = readBytes(stream, chunkSize, encode);\n\n  let bytes = 0;\n\n  return new ReadableStream({\n    type: 'bytes',\n\n    async pull(controller) {\n      const {done, value} = await iterator.next();\n\n      if (done) {\n        controller.close();\n        onFinish();\n        return;\n      }\n\n      let len = value.byteLength;\n      onProgress && onProgress(bytes += len);\n      controller.enqueue(new Uint8Array(value));\n    },\n    cancel(reason) {\n      onFinish(reason);\n      return iterator.return();\n    }\n  }, {\n    highWaterMark: 2\n  })\n}\n","import platform from \"../platform/index.js\";\nimport utils from \"../utils.js\";\nimport AxiosError from \"../core/AxiosError.js\";\nimport composeSignals from \"../helpers/composeSignals.js\";\nimport {trackStream} from \"../helpers/trackStream.js\";\nimport AxiosHeaders from \"../core/AxiosHeaders.js\";\nimport progressEventReducer from \"../helpers/progressEventReducer.js\";\nimport resolveConfig from \"../helpers/resolveConfig.js\";\nimport settle from \"../core/settle.js\";\n\nconst fetchProgressDecorator = (total, fn) => {\n  const lengthComputable = total != null;\n  return (loaded) => setTimeout(() => fn({\n    lengthComputable,\n    total,\n    loaded\n  }));\n}\n\nconst isFetchSupported = typeof fetch === 'function' && typeof Request === 'function' && typeof Response === 'function';\nconst isReadableStreamSupported = isFetchSupported && typeof ReadableStream === 'function';\n\n// used only inside the fetch adapter\nconst encodeText = isFetchSupported && (typeof TextEncoder === 'function' ?\n    ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) :\n    async (str) => new Uint8Array(await new Response(str).arrayBuffer())\n);\n\nconst supportsRequestStream = isReadableStreamSupported && (() => {\n  let duplexAccessed = false;\n\n  const hasContentType = new Request(platform.origin, {\n    body: new ReadableStream(),\n    method: 'POST',\n    get duplex() {\n      duplexAccessed = true;\n      return 'half';\n    },\n  }).headers.has('Content-Type');\n\n  return duplexAccessed && !hasContentType;\n})();\n\nconst DEFAULT_CHUNK_SIZE = 64 * 1024;\n\nconst supportsResponseStream = isReadableStreamSupported && !!(()=> {\n  try {\n    return utils.isReadableStream(new Response('').body);\n  } catch(err) {\n    // return undefined\n  }\n})();\n\nconst resolvers = {\n  stream: supportsResponseStream && ((res) => res.body)\n};\n\nisFetchSupported && (((res) => {\n  ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach(type => {\n    !resolvers[type] && (resolvers[type] = utils.isFunction(res[type]) ? (res) => res[type]() :\n      (_, config) => {\n        throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);\n      })\n  });\n})(new Response));\n\nconst getBodyLength = async (body) => {\n  if (body == null) {\n    return 0;\n  }\n\n  if(utils.isBlob(body)) {\n    return body.size;\n  }\n\n  if(utils.isSpecCompliantForm(body)) {\n    return (await new Request(body).arrayBuffer()).byteLength;\n  }\n\n  if(utils.isArrayBufferView(body)) {\n    return body.byteLength;\n  }\n\n  if(utils.isURLSearchParams(body)) {\n    body = body + '';\n  }\n\n  if(utils.isString(body)) {\n    return (await encodeText(body)).byteLength;\n  }\n}\n\nconst resolveBodyLength = async (headers, body) => {\n  const length = utils.toFiniteNumber(headers.getContentLength());\n\n  return length == null ? getBodyLength(body) : length;\n}\n\nexport default isFetchSupported && (async (config) => {\n  let {\n    url,\n    method,\n    data,\n    signal,\n    cancelToken,\n    timeout,\n    onDownloadProgress,\n    onUploadProgress,\n    responseType,\n    headers,\n    withCredentials = 'same-origin',\n    fetchOptions\n  } = resolveConfig(config);\n\n  responseType = responseType ? (responseType + '').toLowerCase() : 'text';\n\n  let [composedSignal, stopTimeout] = (signal || cancelToken || timeout) ?\n    composeSignals([signal, cancelToken], timeout) : [];\n\n  let finished, request;\n\n  const onFinish = () => {\n    !finished && setTimeout(() => {\n      composedSignal && composedSignal.unsubscribe();\n    });\n\n    finished = true;\n  }\n\n  let requestContentLength;\n\n  try {\n    if (\n      onUploadProgress && supportsRequestStream && method !== 'get' && method !== 'head' &&\n      (requestContentLength = await resolveBodyLength(headers, data)) !== 0\n    ) {\n      let _request = new Request(url, {\n        method: 'POST',\n        body: data,\n        duplex: \"half\"\n      });\n\n      let contentTypeHeader;\n\n      if (utils.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {\n        headers.setContentType(contentTypeHeader)\n      }\n\n      if (_request.body) {\n        data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, fetchProgressDecorator(\n          requestContentLength,\n          progressEventReducer(onUploadProgress)\n        ), null, encodeText);\n      }\n    }\n\n    if (!utils.isString(withCredentials)) {\n      withCredentials = withCredentials ? 'cors' : 'omit';\n    }\n\n    request = new Request(url, {\n      ...fetchOptions,\n      signal: composedSignal,\n      method: method.toUpperCase(),\n      headers: headers.normalize().toJSON(),\n      body: data,\n      duplex: \"half\",\n      withCredentials\n    });\n\n    let response = await fetch(request);\n\n    const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');\n\n    if (supportsResponseStream && (onDownloadProgress || isStreamResponse)) {\n      const options = {};\n\n      ['status', 'statusText', 'headers'].forEach(prop => {\n        options[prop] = response[prop];\n      });\n\n      const responseContentLength = utils.toFiniteNumber(response.headers.get('content-length'));\n\n      response = new Response(\n        trackStream(response.body, DEFAULT_CHUNK_SIZE, onDownloadProgress && fetchProgressDecorator(\n          responseContentLength,\n          progressEventReducer(onDownloadProgress, true)\n        ), isStreamResponse && onFinish, encodeText),\n        options\n      );\n    }\n\n    responseType = responseType || 'text';\n\n    let responseData = await resolvers[utils.findKey(resolvers, responseType) || 'text'](response, config);\n\n    !isStreamResponse && onFinish();\n\n    stopTimeout && stopTimeout();\n\n    return await new Promise((resolve, reject) => {\n      settle(resolve, reject, {\n        data: responseData,\n        headers: AxiosHeaders.from(response.headers),\n        status: response.status,\n        statusText: response.statusText,\n        config,\n        request\n      })\n    })\n  } catch (err) {\n    onFinish();\n\n    if (err && err.name === 'TypeError' && /fetch/i.test(err.message)) {\n      throw Object.assign(\n        new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request),\n        {\n          cause: err.cause || err\n        }\n      )\n    }\n\n    throw AxiosError.from(err, err && err.code, config, request);\n  }\n});\n\n\n","import utils from '../utils.js';\nimport httpAdapter from './http.js';\nimport xhrAdapter from './xhr.js';\nimport fetchAdapter from './fetch.js';\nimport AxiosError from \"../core/AxiosError.js\";\n\nconst knownAdapters = {\n  http: httpAdapter,\n  xhr: xhrAdapter,\n  fetch: fetchAdapter\n}\n\nutils.forEach(knownAdapters, (fn, value) => {\n  if (fn) {\n    try {\n      Object.defineProperty(fn, 'name', {value});\n    } catch (e) {\n      // eslint-disable-next-line no-empty\n    }\n    Object.defineProperty(fn, 'adapterName', {value});\n  }\n});\n\nconst renderReason = (reason) => `- ${reason}`;\n\nconst isResolvedHandle = (adapter) => utils.isFunction(adapter) || adapter === null || adapter === false;\n\nexport default {\n  getAdapter: (adapters) => {\n    adapters = utils.isArray(adapters) ? adapters : [adapters];\n\n    const {length} = adapters;\n    let nameOrAdapter;\n    let adapter;\n\n    const rejectedReasons = {};\n\n    for (let i = 0; i < length; i++) {\n      nameOrAdapter = adapters[i];\n      let id;\n\n      adapter = nameOrAdapter;\n\n      if (!isResolvedHandle(nameOrAdapter)) {\n        adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];\n\n        if (adapter === undefined) {\n          throw new AxiosError(`Unknown adapter '${id}'`);\n        }\n      }\n\n      if (adapter) {\n        break;\n      }\n\n      rejectedReasons[id || '#' + i] = adapter;\n    }\n\n    if (!adapter) {\n\n      const reasons = Object.entries(rejectedReasons)\n        .map(([id, state]) => `adapter ${id} ` +\n          (state === false ? 'is not supported by the environment' : 'is not available in the build')\n        );\n\n      let s = length ?\n        (reasons.length > 1 ? 'since :\\n' + reasons.map(renderReason).join('\\n') : ' ' + renderReason(reasons[0])) :\n        'as no adapter specified';\n\n      throw new AxiosError(\n        `There is no suitable adapter to dispatch the request ` + s,\n        'ERR_NOT_SUPPORT'\n      );\n    }\n\n    return adapter;\n  },\n  adapters: knownAdapters\n}\n","// eslint-disable-next-line strict\nexport default null;\n","'use strict';\n\nimport transformData from './transformData.js';\nimport isCancel from '../cancel/isCancel.js';\nimport defaults from '../defaults/index.js';\nimport CanceledError from '../cancel/CanceledError.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\nimport adapters from \"../adapters/adapters.js\";\n\n/**\n * Throws a `CanceledError` if cancellation has been requested.\n *\n * @param {Object} config The config that is to be used for the request\n *\n * @returns {void}\n */\nfunction throwIfCancellationRequested(config) {\n  if (config.cancelToken) {\n    config.cancelToken.throwIfRequested();\n  }\n\n  if (config.signal && config.signal.aborted) {\n    throw new CanceledError(null, config);\n  }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n *\n * @returns {Promise} The Promise to be fulfilled\n */\nexport default function dispatchRequest(config) {\n  throwIfCancellationRequested(config);\n\n  config.headers = AxiosHeaders.from(config.headers);\n\n  // Transform request data\n  config.data = transformData.call(\n    config,\n    config.transformRequest\n  );\n\n  if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {\n    config.headers.setContentType('application/x-www-form-urlencoded', false);\n  }\n\n  const adapter = adapters.getAdapter(config.adapter || defaults.adapter);\n\n  return adapter(config).then(function onAdapterResolution(response) {\n    throwIfCancellationRequested(config);\n\n    // Transform response data\n    response.data = transformData.call(\n      config,\n      config.transformResponse,\n      response\n    );\n\n    response.headers = AxiosHeaders.from(response.headers);\n\n    return response;\n  }, function onAdapterRejection(reason) {\n    if (!isCancel(reason)) {\n      throwIfCancellationRequested(config);\n\n      // Transform response data\n      if (reason && reason.response) {\n        reason.response.data = transformData.call(\n          config,\n          config.transformResponse,\n          reason.response\n        );\n        reason.response.headers = AxiosHeaders.from(reason.response.headers);\n      }\n    }\n\n    return Promise.reject(reason);\n  });\n}\n","export const VERSION = \"1.7.2\";","'use strict';\n\nimport {VERSION} from '../env/data.js';\nimport AxiosError from '../core/AxiosError.js';\n\nconst validators = {};\n\n// eslint-disable-next-line func-names\n['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => {\n  validators[type] = function validator(thing) {\n    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;\n  };\n});\n\nconst deprecatedWarnings = {};\n\n/**\n * Transitional option validator\n *\n * @param {function|boolean?} validator - set to false if the transitional option has been removed\n * @param {string?} version - deprecated version / removed since version\n * @param {string?} message - some message with additional info\n *\n * @returns {function}\n */\nvalidators.transitional = function transitional(validator, version, message) {\n  function formatMessage(opt, desc) {\n    return '[Axios v' + VERSION + '] Transitional option \\'' + opt + '\\'' + desc + (message ? '. ' + message : '');\n  }\n\n  // eslint-disable-next-line func-names\n  return (value, opt, opts) => {\n    if (validator === false) {\n      throw new AxiosError(\n        formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),\n        AxiosError.ERR_DEPRECATED\n      );\n    }\n\n    if (version && !deprecatedWarnings[opt]) {\n      deprecatedWarnings[opt] = true;\n      // eslint-disable-next-line no-console\n      console.warn(\n        formatMessage(\n          opt,\n          ' has been deprecated since v' + version + ' and will be removed in the near future'\n        )\n      );\n    }\n\n    return validator ? validator(value, opt, opts) : true;\n  };\n};\n\n/**\n * Assert object's properties type\n *\n * @param {object} options\n * @param {object} schema\n * @param {boolean?} allowUnknown\n *\n * @returns {object}\n */\n\nfunction assertOptions(options, schema, allowUnknown) {\n  if (typeof options !== 'object') {\n    throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);\n  }\n  const keys = Object.keys(options);\n  let i = keys.length;\n  while (i-- > 0) {\n    const opt = keys[i];\n    const validator = schema[opt];\n    if (validator) {\n      const value = options[opt];\n      const result = value === undefined || validator(value, opt, options);\n      if (result !== true) {\n        throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE);\n      }\n      continue;\n    }\n    if (allowUnknown !== true) {\n      throw new AxiosError('Unknown option ' + opt, AxiosError.ERR_BAD_OPTION);\n    }\n  }\n}\n\nexport default {\n  assertOptions,\n  validators\n};\n","'use strict';\n\nimport utils from './../utils.js';\nimport buildURL from '../helpers/buildURL.js';\nimport InterceptorManager from './InterceptorManager.js';\nimport dispatchRequest from './dispatchRequest.js';\nimport mergeConfig from './mergeConfig.js';\nimport buildFullPath from './buildFullPath.js';\nimport validator from '../helpers/validator.js';\nimport AxiosHeaders from './AxiosHeaders.js';\n\nconst validators = validator.validators;\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n *\n * @return {Axios} A new instance of Axios\n */\nclass Axios {\n  constructor(instanceConfig) {\n    this.defaults = instanceConfig;\n    this.interceptors = {\n      request: new InterceptorManager(),\n      response: new InterceptorManager()\n    };\n  }\n\n  /**\n   * Dispatch a request\n   *\n   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)\n   * @param {?Object} config\n   *\n   * @returns {Promise} The Promise to be fulfilled\n   */\n  async request(configOrUrl, config) {\n    try {\n      return await this._request(configOrUrl, config);\n    } catch (err) {\n      if (err instanceof Error) {\n        let dummy;\n\n        Error.captureStackTrace ? Error.captureStackTrace(dummy = {}) : (dummy = new Error());\n\n        // slice off the Error: ... line\n        const stack = dummy.stack ? dummy.stack.replace(/^.+\\n/, '') : '';\n        try {\n          if (!err.stack) {\n            err.stack = stack;\n            // match without the 2 top stack lines\n          } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\\n.+\\n/, ''))) {\n            err.stack += '\\n' + stack\n          }\n        } catch (e) {\n          // ignore the case where \"stack\" is an un-writable property\n        }\n      }\n\n      throw err;\n    }\n  }\n\n  _request(configOrUrl, config) {\n    /*eslint no-param-reassign:0*/\n    // Allow for axios('example/url'[, config]) a la fetch API\n    if (typeof configOrUrl === 'string') {\n      config = config || {};\n      config.url = configOrUrl;\n    } else {\n      config = configOrUrl || {};\n    }\n\n    config = mergeConfig(this.defaults, config);\n\n    const {transitional, paramsSerializer, headers} = config;\n\n    if (transitional !== undefined) {\n      validator.assertOptions(transitional, {\n        silentJSONParsing: validators.transitional(validators.boolean),\n        forcedJSONParsing: validators.transitional(validators.boolean),\n        clarifyTimeoutError: validators.transitional(validators.boolean)\n      }, false);\n    }\n\n    if (paramsSerializer != null) {\n      if (utils.isFunction(paramsSerializer)) {\n        config.paramsSerializer = {\n          serialize: paramsSerializer\n        }\n      } else {\n        validator.assertOptions(paramsSerializer, {\n          encode: validators.function,\n          serialize: validators.function\n        }, true);\n      }\n    }\n\n    // Set config.method\n    config.method = (config.method || this.defaults.method || 'get').toLowerCase();\n\n    // Flatten headers\n    let contextHeaders = headers && utils.merge(\n      headers.common,\n      headers[config.method]\n    );\n\n    headers && utils.forEach(\n      ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n      (method) => {\n        delete headers[method];\n      }\n    );\n\n    config.headers = AxiosHeaders.concat(contextHeaders, headers);\n\n    // filter out skipped interceptors\n    const requestInterceptorChain = [];\n    let synchronousRequestInterceptors = true;\n    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n      if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {\n        return;\n      }\n\n      synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;\n\n      requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);\n    });\n\n    const responseInterceptorChain = [];\n    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n      responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);\n    });\n\n    let promise;\n    let i = 0;\n    let len;\n\n    if (!synchronousRequestInterceptors) {\n      const chain = [dispatchRequest.bind(this), undefined];\n      chain.unshift.apply(chain, requestInterceptorChain);\n      chain.push.apply(chain, responseInterceptorChain);\n      len = chain.length;\n\n      promise = Promise.resolve(config);\n\n      while (i < len) {\n        promise = promise.then(chain[i++], chain[i++]);\n      }\n\n      return promise;\n    }\n\n    len = requestInterceptorChain.length;\n\n    let newConfig = config;\n\n    i = 0;\n\n    while (i < len) {\n      const onFulfilled = requestInterceptorChain[i++];\n      const onRejected = requestInterceptorChain[i++];\n      try {\n        newConfig = onFulfilled(newConfig);\n      } catch (error) {\n        onRejected.call(this, error);\n        break;\n      }\n    }\n\n    try {\n      promise = dispatchRequest.call(this, newConfig);\n    } catch (error) {\n      return Promise.reject(error);\n    }\n\n    i = 0;\n    len = responseInterceptorChain.length;\n\n    while (i < len) {\n      promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);\n    }\n\n    return promise;\n  }\n\n  getUri(config) {\n    config = mergeConfig(this.defaults, config);\n    const fullPath = buildFullPath(config.baseURL, config.url);\n    return buildURL(fullPath, config.params, config.paramsSerializer);\n  }\n}\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, config) {\n    return this.request(mergeConfig(config || {}, {\n      method,\n      url,\n      data: (config || {}).data\n    }));\n  };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  /*eslint func-names:0*/\n\n  function generateHTTPMethod(isForm) {\n    return function httpMethod(url, data, config) {\n      return this.request(mergeConfig(config || {}, {\n        method,\n        headers: isForm ? {\n          'Content-Type': 'multipart/form-data'\n        } : {},\n        url,\n        data\n      }));\n    };\n  }\n\n  Axios.prototype[method] = generateHTTPMethod();\n\n  Axios.prototype[method + 'Form'] = generateHTTPMethod(true);\n});\n\nexport default Axios;\n","'use strict';\n\nimport CanceledError from './CanceledError.js';\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @param {Function} executor The executor function.\n *\n * @returns {CancelToken}\n */\nclass CancelToken {\n  constructor(executor) {\n    if (typeof executor !== 'function') {\n      throw new TypeError('executor must be a function.');\n    }\n\n    let resolvePromise;\n\n    this.promise = new Promise(function promiseExecutor(resolve) {\n      resolvePromise = resolve;\n    });\n\n    const token = this;\n\n    // eslint-disable-next-line func-names\n    this.promise.then(cancel => {\n      if (!token._listeners) return;\n\n      let i = token._listeners.length;\n\n      while (i-- > 0) {\n        token._listeners[i](cancel);\n      }\n      token._listeners = null;\n    });\n\n    // eslint-disable-next-line func-names\n    this.promise.then = onfulfilled => {\n      let _resolve;\n      // eslint-disable-next-line func-names\n      const promise = new Promise(resolve => {\n        token.subscribe(resolve);\n        _resolve = resolve;\n      }).then(onfulfilled);\n\n      promise.cancel = function reject() {\n        token.unsubscribe(_resolve);\n      };\n\n      return promise;\n    };\n\n    executor(function cancel(message, config, request) {\n      if (token.reason) {\n        // Cancellation has already been requested\n        return;\n      }\n\n      token.reason = new CanceledError(message, config, request);\n      resolvePromise(token.reason);\n    });\n  }\n\n  /**\n   * Throws a `CanceledError` if cancellation has been requested.\n   */\n  throwIfRequested() {\n    if (this.reason) {\n      throw this.reason;\n    }\n  }\n\n  /**\n   * Subscribe to the cancel signal\n   */\n\n  subscribe(listener) {\n    if (this.reason) {\n      listener(this.reason);\n      return;\n    }\n\n    if (this._listeners) {\n      this._listeners.push(listener);\n    } else {\n      this._listeners = [listener];\n    }\n  }\n\n  /**\n   * Unsubscribe from the cancel signal\n   */\n\n  unsubscribe(listener) {\n    if (!this._listeners) {\n      return;\n    }\n    const index = this._listeners.indexOf(listener);\n    if (index !== -1) {\n      this._listeners.splice(index, 1);\n    }\n  }\n\n  /**\n   * Returns an object that contains a new `CancelToken` and a function that, when called,\n   * cancels the `CancelToken`.\n   */\n  static source() {\n    let cancel;\n    const token = new CancelToken(function executor(c) {\n      cancel = c;\n    });\n    return {\n      token,\n      cancel\n    };\n  }\n}\n\nexport default CancelToken;\n","const HttpStatusCode = {\n  Continue: 100,\n  SwitchingProtocols: 101,\n  Processing: 102,\n  EarlyHints: 103,\n  Ok: 200,\n  Created: 201,\n  Accepted: 202,\n  NonAuthoritativeInformation: 203,\n  NoContent: 204,\n  ResetContent: 205,\n  PartialContent: 206,\n  MultiStatus: 207,\n  AlreadyReported: 208,\n  ImUsed: 226,\n  MultipleChoices: 300,\n  MovedPermanently: 301,\n  Found: 302,\n  SeeOther: 303,\n  NotModified: 304,\n  UseProxy: 305,\n  Unused: 306,\n  TemporaryRedirect: 307,\n  PermanentRedirect: 308,\n  BadRequest: 400,\n  Unauthorized: 401,\n  PaymentRequired: 402,\n  Forbidden: 403,\n  NotFound: 404,\n  MethodNotAllowed: 405,\n  NotAcceptable: 406,\n  ProxyAuthenticationRequired: 407,\n  RequestTimeout: 408,\n  Conflict: 409,\n  Gone: 410,\n  LengthRequired: 411,\n  PreconditionFailed: 412,\n  PayloadTooLarge: 413,\n  UriTooLong: 414,\n  UnsupportedMediaType: 415,\n  RangeNotSatisfiable: 416,\n  ExpectationFailed: 417,\n  ImATeapot: 418,\n  MisdirectedRequest: 421,\n  UnprocessableEntity: 422,\n  Locked: 423,\n  FailedDependency: 424,\n  TooEarly: 425,\n  UpgradeRequired: 426,\n  PreconditionRequired: 428,\n  TooManyRequests: 429,\n  RequestHeaderFieldsTooLarge: 431,\n  UnavailableForLegalReasons: 451,\n  InternalServerError: 500,\n  NotImplemented: 501,\n  BadGateway: 502,\n  ServiceUnavailable: 503,\n  GatewayTimeout: 504,\n  HttpVersionNotSupported: 505,\n  VariantAlsoNegotiates: 506,\n  InsufficientStorage: 507,\n  LoopDetected: 508,\n  NotExtended: 510,\n  NetworkAuthenticationRequired: 511,\n};\n\nObject.entries(HttpStatusCode).forEach(([key, value]) => {\n  HttpStatusCode[value] = key;\n});\n\nexport default HttpStatusCode;\n","'use strict';\n\nimport utils from './utils.js';\nimport bind from './helpers/bind.js';\nimport Axios from './core/Axios.js';\nimport mergeConfig from './core/mergeConfig.js';\nimport defaults from './defaults/index.js';\nimport formDataToJSON from './helpers/formDataToJSON.js';\nimport CanceledError from './cancel/CanceledError.js';\nimport CancelToken from './cancel/CancelToken.js';\nimport isCancel from './cancel/isCancel.js';\nimport {VERSION} from './env/data.js';\nimport toFormData from './helpers/toFormData.js';\nimport AxiosError from './core/AxiosError.js';\nimport spread from './helpers/spread.js';\nimport isAxiosError from './helpers/isAxiosError.js';\nimport AxiosHeaders from \"./core/AxiosHeaders.js\";\nimport adapters from './adapters/adapters.js';\nimport HttpStatusCode from './helpers/HttpStatusCode.js';\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n *\n * @returns {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n  const context = new Axios(defaultConfig);\n  const instance = bind(Axios.prototype.request, context);\n\n  // Copy axios.prototype to instance\n  utils.extend(instance, Axios.prototype, context, {allOwnKeys: true});\n\n  // Copy context to instance\n  utils.extend(instance, context, null, {allOwnKeys: true});\n\n  // Factory for creating new instances\n  instance.create = function create(instanceConfig) {\n    return createInstance(mergeConfig(defaultConfig, instanceConfig));\n  };\n\n  return instance;\n}\n\n// Create the default instance to be exported\nconst axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Expose Cancel & CancelToken\naxios.CanceledError = CanceledError;\naxios.CancelToken = CancelToken;\naxios.isCancel = isCancel;\naxios.VERSION = VERSION;\naxios.toFormData = toFormData;\n\n// Expose AxiosError class\naxios.AxiosError = AxiosError;\n\n// alias for CanceledError for backward compatibility\naxios.Cancel = axios.CanceledError;\n\n// Expose all/spread\naxios.all = function all(promises) {\n  return Promise.all(promises);\n};\n\naxios.spread = spread;\n\n// Expose isAxiosError\naxios.isAxiosError = isAxiosError;\n\n// Expose mergeConfig\naxios.mergeConfig = mergeConfig;\n\naxios.AxiosHeaders = AxiosHeaders;\n\naxios.formToJSON = thing => formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);\n\naxios.getAdapter = adapters.getAdapter;\n\naxios.HttpStatusCode = HttpStatusCode;\n\naxios.default = axios;\n\n// this module should only have a default export\nexport default axios\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n *  ```js\n *  function f(x, y, z) {}\n *  var args = [1, 2, 3];\n *  f.apply(null, args);\n *  ```\n *\n * With `spread` this example can be re-written.\n *\n *  ```js\n *  spread(function(x, y, z) {})([1, 2, 3]);\n *  ```\n *\n * @param {Function} callback\n *\n * @returns {Function}\n */\nexport default function spread(callback) {\n  return function wrap(arr) {\n    return callback.apply(null, arr);\n  };\n}\n","'use strict';\n\nimport utils from './../utils.js';\n\n/**\n * Determines whether the payload is an error thrown by Axios\n *\n * @param {*} payload The value to test\n *\n * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false\n */\nexport default function isAxiosError(payload) {\n  return utils.isObject(payload) && (payload.isAxiosError === true);\n}\n"],"names":["EventEmitter","this","_events","_maxListeners","undefined","isFunction","arg","isObject","isUndefined","module","exports","prototype","defaultMaxListeners","setMaxListeners","n","isNaN","TypeError","emit","type","er","handler","len","args","i","listeners","error","length","arguments","Error","err","context","call","Array","slice","apply","addListener","listener","m","newListener","push","warned","console","trace","on","once","fired","g","removeListener","list","position","splice","removeAllListeners","key","listenerCount","evlistener","emitter","__SENTRY_DEBUG__","Session","errors","sid","duration","status","init","ignoreDuration","startingTime","time","timestamp","started","update","user","ipAddress","ip_address","did","id","email","username","release","environment","userAgent","close","toJSON","Date","toISOString","attrs","user_agent","API_VERSION","Hub","client","scope","_version","_stack","getStackTop","bindClient","isOlderThan","version","setupIntegrations","pushScope","getScope","getStack","getClient","popScope","pop","withScope","callback","captureException","exception","hint","eventId","_lastEventId","event_id","finalHint","syntheticException","originalException","_invokeClient","captureMessage","message","level","captureEvent","event","lastEventId","addBreadcrumb","breadcrumb","_a","_b","getOptions","_c","beforeBreadcrumb","_d","maxBreadcrumbs","mergedBreadcrumb","finalBreadcrumb","setUser","setTags","tags","setExtras","extras","setTag","value","setExtra","extra","setContext","name","configureScope","run","oldHub","makeMain","getIntegration","integration","_oO","startSpan","_callExtensionMethod","startTransaction","customSamplingContext","traceHeaders","captureSession","endSession","_sendSessionUpdate","layer","session","getSession","setSession","startSession","navigator","getUser","currentSession","method","_i","sentry","getMainCarrier","__SENTRY__","extensions","carrier","hub","registry","getHubFromCarrier","setHubOnCarrier","getCurrentHub","hasHubOnCarrier","activeDomain","domain","active","registryHubTopStack","_Oo","getHubFromActiveDomain","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","clone","newScope","_level","_span","_session","_transactionName","_fingerprint","_requestSession","addScopeListener","addEventProcessor","_notifyScopeListeners","getRequestSession","setRequestSession","requestSession","setFingerprint","fingerprint","setLevel","setTransactionName","setTransaction","setSpan","span","getSpan","getTransaction","transaction","captureContext","updatedScope","Object","keys","contexts","clear","maxCrumbs","Math","min","clearBreadcrumbs","applyToEvent","getTraceContext","transactionName","_applyFingerprint","breadcrumbs","sdkProcessingMetadata","_notifyEventProcessors","getGlobalEventProcessors","setSDKProcessingMetadata","newData","processors","index","_this","resolve","reject","processor","result","then","final","forEach","isArray","concat","addGlobalEventProcessor","__assign","assign","t","s","p","hasOwnProperty","__read","o","Symbol","iterator","r","e","ar","next","done","__spread","callOnHub","Severity","htmlTreeAsString","elem","keyAttrs","currentElem","out","height","nextStr","_htmlElementAsString","separator","parentNode","reverse","join","el","className","classes","attr","tagName","toLowerCase","keyAttrPairs","filter","keyAttr","getAttribute","map","keyAttrPair","split","allowedAttrs","getLocationHref","global","document","location","href","oO","IS_DEBUG_BUILD","fallbackGlobalObject","getGlobalObject","window","self","getGlobalSingleton","creator","obj","objectToString","toString","isError","wat","isInstanceOf","isBuiltin","ty","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","Boolean","isSyntheticEvent","base","_e","logger","CONSOLE_LEVELS","consoleSandbox","originalConsole","wrappedLevels","originalWrappedFunc","__sentry_original__","makeLogger","enabled","enable","disable","PREFIX","uuid4","crypto","msCrypto","getRandomValues","arr","Uint16Array","pad","num","v","replace","c","random","parseUrl","url","match","query","fragment","host","path","protocol","relative","getFirstException","values","getEventDescription","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","currentMechanism","mechanism","handled","mergedData","data","checkOrSetAlreadyCaught","__sentry_captured__","isNodeEnv","__SENTRY_BROWSER_BUNDLE__","dynamicRequire","mod","request","require","fill","source","replacementFactory","original","wrapped","markFunctionWrapped","addNonEnumerableProperty","defineProperty","writable","configurable","proto","getOriginalFunction","func","urlEncode","object","encodeURIComponent","convertToPlainObject","newObj","stack","getOwnProperties","event_1","target","serializeEventTarget","currentTarget","CustomEvent","detail","extractedProps","property","extractExceptionKeysForMessage","maxLength","sort","includedKeys","serialized","dropUndefinedKeys","val","e_1","rv","e_1_1","return","truncate","str","max","substr","safeJoin","input","delimiter","output","String","isMatchingPattern","pattern","test","indexOf","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","reason","_","executor","_state","_handlers","_resolve","_setResult","_reject","state","_value","_executeHandlers","cachedHandlers","onfulfilled","onrejected","catch","finally","onfinally","isRejected","dateTimestampSource","nowSeconds","now","platformPerformance","performance","getNodePerformance","timeOrigin","getBrowserPerformance","timestampSource","dateTimestampInSeconds","bind","timestampInSeconds","threshold","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","extendStatics","d","b","setPrototypeOf","__proto__","__extends","__","constructor","create","__values","AlgoliaSearchHelper","SearchParameters","SearchResults","algoliasearchHelper","opts","DerivedHelper","mainHelper","fn","main","lastResults","inherits","detach","detachDerivedHelper","getModifiedState","parameters","defaultsPure","omit","objectHasKeys","lib","addRefinement","refinementList","attribute","isRefined","valueAsString","facetRefinement","removeRefinement","clearRefinement","f","toggleRefinement","refinementType","hasChanged","newRefinementList","reduce","memo","facetList","refinementValue","containsRefinements","refinementValueAsString","merge","intersection","find","valToNumber","isValidUserToken","RefinementList","isEqualNumericRefinement","a","every","newParameters","params","_parseNumbers","userToken","warn","facets","disjunctiveFacets","hierarchicalFacets","facetsRefinements","facetsExcludes","disjunctiveFacetsRefinements","numericRefinements","tagRefinements","hierarchicalFacetsRefinements","paramName","isKeyKnown","PARAMETERS","isValueDefined","partialState","numbers","k","parsedValue","parseFloat","insideBoundingBox","geoRect","operators","operator","parsedValues","vPrime","make","instance","facet","rootPath","currentRefinement","getHierarchicalRefinement","clearRefinements","toggleHierarchicalFacetRefinement","validate","currentState","tagFilters","numericFilters","patch","_clearNumericRefinements","setQueryParameters","clearTags","setIndex","setQuery","newQuery","setPage","newPage","page","setFacets","setDisjunctiveFacets","setHitsPerPage","hitsPerPage","setTypoTolerance","typoTolerance","addNumericRefinement","isNumericRefined","getConjunctiveRefinements","facetName","isConjunctiveFacet","getDisjunctiveRefinements","isDisjunctiveFacet","getExcludeRefinements","removeNumericRefinement","paramValue","op","getNumericRefinements","getNumericRefinement","newNumericRefinements","operatorList","outValues","addFacet","addDisjunctiveFacet","addHierarchicalFacet","hierarchicalFacet","isHierarchicalFacet","addFacetRefinement","addExcludeRefinement","addDisjunctiveFacetRefinement","addTagRefinement","tag","isTagRefined","modification","removeFacet","removeDisjunctiveFacet","removeHierarchicalFacet","removeFacetRefinement","removeExcludeRefinement","removeDisjunctiveFacetRefinement","removeTagRefinement","toggleFacetRefinement","toggleConjunctiveFacetRefinement","toggleDisjunctiveFacetRefinement","toggleExcludeFacetRefinement","_getHierarchicalFacetSeparator","getHierarchicalFacetByName","lastIndexOf","addHierarchicalFacetRefinement","isHierarchicalFacetRefined","removeHierarchicalFacetRefinement","toggleTagRefinement","isFacetRefined","isExcludeRefined","isDisjunctiveFacetRefined","refinements","isOperatorDefined","array","searchedValue","isAttributeValueDefined","currentValue","getRefinedDisjunctiveFacets","disjunctiveNumericRefinedFacets","getRefinedHierarchicalFacets","getUnrefinedDisjunctiveFacets","refinedFacets","managedParameters","getQueryParams","queryParams","setQueryParameter","parameter","nextWithNumbers","previousPlainObject","acc","nextPlainObject","previous","isPreviousValueDefined","isNextValueDefined","resetPage","_getHierarchicalFacetSortBy","sortBy","_getHierarchicalRootPath","_getHierarchicalShowParentLevel","showParentLevel","hierarchicalFacetName","getHierarchicalFacetBreadcrumb","refinement","part","trim","JSON","stringify","hierarchicalFacetResult","hierarchicalFacetIndex","hierarchicalFacetRefinement","hierarchicalSeparator","hierarchicalRootPath","hierarchicalShowParentLevel","prepareHierarchicalFacetSortBy","rootExhaustive","facetResult","exhaustive","generateTreeFn","hierarchicalTree","currentHierarchicalLevel","parent","subtree","picked","facetValue","tuple","parentPath","onlyMatchingTree","orderBy","facetCount","parts","escapedValue","escapeFacetValue","count","format","unescapeFacetValue","generateHierarchicalTree","results","fv","compact","findIndex","formatSort","getIndices","attributes","indices","idx","assignFacetStats","dest","facetStats","stats","options","mainSubResponse","_rawResults","processingTimeMS","sum","facetsIndices","disjunctiveFacetsIndices","nextDisjunctiveResult","mainFacets","facetKey","hierarchicalAttributeName","facetValueObject","facetIndex","idxAttributeName","exhaustiveFacetsCount","isFacetDisjunctive","isFacetConjunctive","facets_stats","disjunctiveFacet","dfacet","facetResults","attributeIndex","dataFromMainRequest","refinedFacet","defaultData","root","excludes","recSort","sortFn","node","names","children","childNode","sortedChildren","getFacetStatsIfAvailable","getRefinement","attributeName","resultsFacets","getFacetByName","predicate","DEFAULT_SORT","getFacetValues","facetValues","isExcluded","extractNormalizedFacetValues","facetOrdering","renderingContent","getFacetOrdering","orderedFacets","remainingFacets","reverseOrder","order","item","ordering","sortRemainingBy","sortViaFacetOrdering","vanillaSortFn","getFacetStats","getRefinements","res","facetDeclaration","rootFacet","intermediateFacet","newFacet","numericValue","requestBuilder","addAlgoliaAgent","setClient","_queryId","_lastQueryIdReceived","derivedHelpers","_currentNbQueries","setCurrentPage","_change","isPageReset","getCurrentPage","search","_search","onlyWithDerivedHelpers","searchOnlyWithDerivedHelpers","getQuery","_getHitsSearchParams","searchOnce","cb","tempState","queries","_getQueries","content","_originalResponse","findAnswers","derivedHelper","Promise","derivedState","attributesForPrediction","nbHits","errorMessage","initIndex","queryLanguages","searchForFacetValues","maxFacetHits","userState","clientHasSFFV","clientHasInitIndex","isDisjunctive","algoliaQuery","getSearchForFacetQuery","searchForFacetValuesPromise","indexName","response","facetHits","q","addDisjunctiveRefine","addRefine","addFacetExclusion","addExclude","addTag","removeDisjunctiveRefine","removeRefine","removeFacetExclusion","removeExclude","removeTag","toggleFacetExclusion","toggleExclude","toggleRefine","toggleTag","nextPage","previousPage","setState","newState","overrideStateWithoutTriggeringChangeEvent","hasRefinements","isDisjunctiveRefined","hasTag","hasTagRefinements","getIndex","getPage","getTags","states","mainQueries","queriesCount","helper","derivedQueries","derivedStateQueries","queryId","_dispatchAlgoliaResponse","_dispatchAlgoliaError","specificResults","formattedResponse","containsRefinement","facetFilters","_hasDisjunctiveRefinements","disjunctiveRefinements","clearCache","newClient","derive","pos","hasPendingRequests","reduceRight","comparator","defaults","defaultInstructions","sortInstruction","matchingDefault","defaultInstruction","ctor","superCtor","enumerable","arr1","arr2","isObjectOrArrayOrFunction","_merge","sourceVal","targetVal","l","excluded","sourceKeys","compareAscending","other","valIsDefined","valIsNull","othIsDefined","othIsNull","collection","iteratees","orders","criteria","iteratee","sortObject","localeCompare","curr","_getDisjunctiveFacetSearchParams","filtersMap","segment","_getHitsHierarchicalFacetsAttributes","_getFacetFilters","_getNumericFilters","_getTagFilters","additionalParams","hierarchicalRootLevel","analytics","clickAnalytics","_getDisjunctiveHierarchicalFacetAttribute","vs","orFilters","attributeToRefine","attributesIndex","allAttributes","hierarchicalRefinement","newAttributes","rootLevel","parentLevel","stateForSearchForFacetValues","searchForFacetSearchParameters","facetQuery","getOwnPropertySymbols","getOwnPropertyDescriptor","getOwnPropertyDescriptors","defineProperties","propertyIsEnumerable","u","from","localStorage","parse","getItem","get","miss","all","set","setItem","delete","removeItem","caches","shift","serializable","headers","WithinHeaders","queryParameters","WithinQueryParameters","setTimeout","wait","floor","h","y","entries","timeout","cacheable","Read","Write","Any","P","w","lastUpdate","O","accept","I","x","j","D","S","transporterStackTrace","R","N","connectTimeout","timeouts","connect","responseTimeout","triesLeft","onSuccess","onRetry","isTimedOut","info","A","hostsCache","onFail","requester","send","getTimeout","statelessHosts","requestsCache","responsesCache","hosts","read","mappedRequestOptions","transporter","write","T","add","E","charAt","C","U","z","J","F","H","M","K","batch","hits","shouldStop","cursor","W","acl","tt","B","cluster","Q","users","G","clearExistingDictionaryEntries","requests","action","body","jt","taskID","L","operation","destination","ut","methods","waitTask","de","V","pe","Rules","Settings","X","Synonyms","Y","Z","$","objectID","et","rt","nt","at","ot","it","retrieveMappings","getClusters","appId","st","ct","ft","dt","lt","pt","ht","mt","yt","ue","gt","vt","bt","Pt","wt","Ot","It","xt","Dt","qt","St","se","_highlightResult","kt","ce","Tt","batchSize","taskIDs","objectIDs","Nt","Et","forwardToReplicas","Rt","At","Ct","Ut","zt","le","DeleteObject","Jt","Ft","Ht","Lt","Mt","Kt","paginate","ie","parseInt","nbPages","Wt","Bt","Qt","attributesToRetrieve","Gt","getVersion","Vt","_t","Xt","createIfNotExists","PartialUpdateObject","PartialUpdateObjectNoCreate","Yt","safe","autoGenerateObjectIDIfNotExist","substring","ee","Zt","ne","clearExistingRules","$t","oe","clearExistingSynonyms","te","AddObject","UpdateObject","re","ae","replaceExistingSynonyms","fe","DeleteIndex","ClearIndex","ge","apiKey","XMLHttpRequest","open","setRequestHeader","abort","onreadystatechange","readyState","OPENED","clearTimeout","onerror","responseText","onload","debug","region","getPersonalizationStrategy","setPersonalizationStrategy","authMode","multipleBatch","multipleGetObjects","multipleQueries","copyIndex","copySettings","copySynonyms","copyRules","moveIndex","listIndices","getLogs","listClusters","multipleSearchForFacetValues","getApiKey","addApiKey","listApiKeys","updateApiKey","deleteApiKey","restoreApiKey","assignUserID","assignUserIDs","getUserID","searchUserIDs","listUserIDs","getTopUserIDs","removeUserID","hasPendingMappings","clearDictionaryEntries","deleteDictionaryEntries","getDictionarySettings","getAppTask","replaceDictionaryEntries","saveDictionaryEntries","searchDictionaryEntries","setDictionarySettings","waitAppTask","customRequest","getObject","getObjects","saveObject","saveObjects","setSettings","getSettings","partialUpdateObject","partialUpdateObjects","deleteObject","deleteObjects","deleteBy","clearObjects","browseObjects","getObjectPosition","findObject","exists","saveSynonym","saveSynonyms","getSynonym","searchSynonyms","browseSynonyms","deleteSynonym","clearSynonyms","replaceAllObjects","replaceAllSynonyms","searchRules","getRule","deleteRule","saveRule","saveRules","replaceAllRules","browseRules","clearRules","initAnalytics","addABTest","getABTest","getABTests","stopABTest","deleteABTest","initPersonalization","initRecommendation","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","Arr","_byteLength","curByte","revLookup","charCodeAt","fromByteArray","uint8","extraBytes","maxChunkLength","len2","encodeChunk","lookup","Uint8Array","code","start","end","base64","ieee754","customInspectSymbol","Buffer","K_MAX_LENGTH","createBuffer","RangeError","buf","encodingOrOffset","allocUnsafe","string","encoding","isEncoding","actual","fromString","ArrayBuffer","isView","arrayView","isInstance","copy","fromArrayBuffer","buffer","byteOffset","fromArrayLike","fromArrayView","SharedArrayBuffer","valueOf","isBuffer","checked","numberIsNaN","fromObject","toPrimitive","assertSize","size","mustMatch","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","bidirectionalIndexOf","dir","arrayIndexOf","indexSize","arrLength","valLength","readUInt16BE","foundIndex","found","hexWrite","offset","Number","remaining","strLen","parsed","utf8Write","blitBuffer","asciiWrite","byteArray","asciiToBytes","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","decodeCodePointsArray","TYPED_ARRAY_SUPPORT","foo","typedArraySupport","poolSize","alloc","allocUnsafeSlow","_isBuffer","compare","swap16","swap32","swap64","toLocaleString","equals","inspect","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","_arr","ret","hexSliceLookupTable","bytes","checkOffset","ext","checkInt","checkIEEE754","writeFloat","littleEndian","noAssert","writeDouble","newBuf","subarray","readUintLE","readUIntLE","mul","readUintBE","readUIntBE","readUint8","readUInt8","readUint16LE","readUInt16LE","readUint16BE","readUint32LE","readUInt32LE","readUint32BE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUintLE","writeUIntLE","writeUintBE","writeUIntBE","writeUint8","writeUInt8","writeUint16LE","writeUInt16LE","writeUint16BE","writeUInt16BE","writeUint32LE","writeUInt32LE","writeUint32BE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","INVALID_BASE64_RE","Infinity","leadSurrogate","base64clean","src","dst","alphabet","table","i16","ellipse","chars","ellipsizeMiddle","maxLen","middle","left","right","charLeft","posRight","charRight","ellipsize","char","Action","readOnly","BeforeUnloadEventType","HashChangeEventType","PopStateEventType","createBrowserHistory","_options$window","defaultView","globalHistory","history","getIndexAndLocation","_window$location","pathname","hash","usr","blockedPopTx","addEventListener","blockers","nextAction","Pop","_getIndexAndLocation","nextIndex","nextLocation","delta","retry","go","applyTx","_getIndexAndLocation2","createEvents","createHref","to","createPath","getNextLocation","parsePath","createKey","getHistoryStateAndUrl","allowTx","_getIndexAndLocation3","replaceState","Push","_getHistoryStateAndUr","historyState","pushState","Replace","_getHistoryStateAndUr2","back","forward","listen","block","blocker","unblock","promptBeforeUnload","removeEventListener","createHashHistory","_options2$window","_parsePath","_parsePath$pathname","_parsePath$search","_parsePath$hash","handlePop","_getIndexAndLocation4","_getIndexAndLocation6","querySelector","hashIndex","getBaseHref","_getIndexAndLocation7","_getHistoryStateAndUr3","_getHistoryStateAndUr4","preventDefault","returnValue","handlers","_ref","_ref$pathname","_ref$search","_ref$hash","parsedPath","searchIndex","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","log","LN2","has","decode","decodeURIComponent","encode","prefix","pairs","parser","exec","port","stgWacInternalUrl","escapeRegExp","hasProperty","propName","regExpTest","RegExp","nonSpaceRe","entityMap","whiteRe","spaceRe","equalsRe","curlyRe","tagRe","Scanner","tail","Context","view","parentContext","cache","Writer","templateCache","_cache","eos","scan","scanUntil","primitive","intermediateValue","lookupHit","template","cacheKey","mustache","isCacheEnabled","tokens","openingTagRe","closingTagRe","closingCurlyRe","lineHasNonSpace","sections","spaces","nonSpace","indentation","tagIndex","stripSpace","compileTags","tagsToCompile","chr","token","openSection","scanner","valueLength","testRegExp","nestedTokens","collector","numTokens","nestTokens","lastToken","squashedTokens","squashTokens","parseTemplate","render","partials","config","getConfigTags","renderTokens","originalTemplate","symbol","renderSection","renderInverted","renderPartial","unescapedValue","rawValue","indentPartial","partial","filteredIndentation","partialByNl","indentedValue","escape","getConfigEscape","defaultWriter","debounce","immediate","SEARCH_STATE","idle","hasMoreResults","loading","noMoreResults","noResults","IDLE_STATE","LOADING_STATE","EVENT_SCROLL_AUTOLOAD_RESULTS","FACET_LOAD_CLASS","FACET_SELECTED_CLASS","FIXED_MENU_BOTTOM_CLASS","FIXED_MENU_CLASS","RESULTS_LINK_CLASS","RESULTS_TEMPLATE_ID","ALGOLIA_FACET_KEY","ALGOLIA_SNIPPET_KEY","algoliaSearchClient","algoliasearch","WacSearch","_classCallCheck","$searchContainer","$facetsList","$loadButton","$results","$searchForm","$searchInput","$globalHeader","$globalFooter","hasNextPage","searchHelper","urlVal","activeQuery","activeFacet","bindEvents","$facetLink","newUrl","text","serializeFormData","serialize","goToNextPage","repositionFacetNav","browser","setFacetWidth","screenWidth","width","bindAlgoliaEvents","_this2","onCompleteSearch","removeClass","renderFacetsNav","_ref2","first","addClass","_ref3","hit","renderResults","initAutoloadResults","renderNextPage","off","renderNoResults","_ref4","renderError","_this3","scrollY","eq","top","_document$getElementB","getElementById","innerHTML","html","_this4","_document$getElementB2","append","_document$getElementB3","_document$getElementB4","scrollTop","topOffset","outerHeight","bottomOffset","parentWidth","_this5","stateClass","capturedEventsPromise","onAnalyticsLoad","piiScrub","trackEvent","ace","Tracking","segmentPageReady","Sentry","trySentryErrorLog","sanitizeEventProperties","propertiesObj","ENV_STAGING","ENV_PRODUCTION","Environment","urlParts","getWindowLocation","hostname","getSubdomain","hostnameSubdomain","subdirectory","getSubdirectory","getInternationalSubdomain","getEnvironment","production","staging","dev","author","isStaging","isDev","skipEncoding","continueUrl","getIdentityBaseUrl","continueUrlParam","userEmail","applicationParam","loginHintParam","useQaWAC","stgConfig","additionalAttributes","_objectWithoutProperties","_excluded","_objectSpread","category","label","isNonInteraction","processAttributes","trackAllPlatforms","platform","track","GASv2","hasShownWarning","postBody","axios","Constants","withCredentials","GASv3","GoogleAnalytics","ga","nonInteraction","Segment","eventProperties","eventAction","urlParams","tracking","_regeneratorRuntime","Op","hasOwn","desc","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","wrap","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","makeInvokeMethod","tryCatch","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","Gp","defineIteratorMethods","_invoke","AsyncIterator","PromiseImpl","invoke","record","_typeof","__await","unwrapped","previousPromise","callInvokeWithMethodAndArg","delegate","delegateResult","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","methodName","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","doneResult","displayName","isGeneratorFunction","genFun","mark","awrap","async","iter","skipTempReset","prev","stop","rootRecord","rval","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","asyncGeneratorStep","gen","_next","_throw","_init","imkt","core","_callee","domRoot","LocalizedPricing","localizedPricing","_context","featureDetect","each","componentInfo","componentRoot","_componentInfo$params","productKey","productKeyArray","period","offeringSku","countryISOCodeReq","pricing","getPricingPromise","pricingObject","product","identifiers","customCurrency","countryISOCodePromise","getLocale","componentInit","resolvePricingPromises","trigger","appInitialized","_x","onInitialized","bodyClasses","supports","svg","backgroundSize","flexBox","extend","supertype","subtype","overrides","basis","last","componentType","documentElement","style","implementation","hasFeature","touch","placeholder","createElement","transitions","toUpperCase","is","mobile","screen","utils","api","getScript","general","storage","wpl","globals","mediaQueries","common","wac","landing","experts","legal","components","software","bxp","customers","pages","teamPatterns","urls","apiGetAuthToken","public","apiGetSites","apiGetUser","getUrl","endpoint","env","getBrowserOs","nAgt","clientStrings","cs","isWindows","isMobile","randomString","numberWithCommas","elementInViewport","offsetTop","offsetLeft","offsetWidth","offsetHeight","offsetParent","pageYOffset","pageXOffset","innerHeight","innerWidth","datepickerRequest","select2Request","underscoreRequest","datepicker","linkAttrs","rel","media","link","getStyle","select2","underscore","supportsHistory","title","pushStateNoTracking","hasStorage","getLocalStorage","getCookie","setLocalStorage","setCookie","removeLocalStorage","removeCookie","getSessionStorage","sessionStorage","setSessionStorage","removeSessionStorage","encodedName","regex","cookie","days","sameSite","expires","domainLevel","sameSiteVal","sameSiteString","date","setTime","getTime","toGMTString","replaceText","srcObj","inputText","replaceMap","outputText","replaceKey","getStrWithCommas","ImktTracking","Platforms","eventName","eventProperty","eventTarget","dataset","uuid","eventData","innerText","getBareUrl","questionIndex","getUnhashedUrl","getProtocol","getHostname","getQueryString","updateQueryStringParam","baseUrl","queryString","newParam","keyRegex","getPathname","tempArray","prop","htmlEscape","getUrlParams","qs","paramPairs","keyValuePair","addUrlParams","removeUrlParams","currentParams","getSimpleUrl","matchUrlVars","bareUrl","hashUrlArray","hashUrl","required","controlOrWhitespace","CRHTLF","slashes","protocolre","windowsDriveLetter","trimLeft","rules","address","isSpecial","ignore","lolcation","finaldestination","Url","unescape","scheme","extractProtocol","rest","forwardSlashes","otherSlashes","slashesCount","extracted","instruction","instructions","unshift","up","password","auth","origin","ins","jQuery","thisArg","kindOf","thing","kindOfTest","typeOfTest","isArrayBuffer","isNumber","isDate","isFile","isBlob","isFileList","isURLSearchParams","isReadableStream","isRequest","isResponse","isHeaders","allOwnKeys","getOwnPropertyNames","findKey","_key","_global","globalThis","isContextDefined","isTypedArray","TypedArray","isHTMLForm","reduceDescriptors","reducer","descriptors","reducedDescriptors","descriptor","ALPHA","DIGIT","ALPHABET","ALPHA_DIGIT","isAsyncFn","isFormData","kind","FormData","isArrayBufferView","isBoolean","isStream","pipe","caseless","assignValue","targetKey","stripBOM","superConstructor","props","toFlatObject","sourceObj","destObj","propFilter","merged","endsWith","searchString","lastIndex","toArray","forEachEntry","pair","matchAll","regExp","matches","hasOwnProp","freezeMethods","toObjectSet","arrayOrString","toCamelCase","p1","p2","noop","toFiniteNumber","defaultValue","generateString","isSpecCompliantForm","toJSONObject","visit","reducedValue","AxiosError","captureStackTrace","description","number","fileName","lineNumber","columnNumber","customProps","axiosError","cause","isVisitable","removeBrackets","renderKey","dots","predicates","formData","metaTokens","indexes","option","visitor","defaultVisitor","useBlob","Blob","convertValue","some","isFlatArray","exposedHelpers","build","charMap","AxiosURLSearchParams","_pairs","encoder","_encode","buildURL","serializeFn","serializedParams","hashmarkIndex","use","fulfilled","rejected","synchronous","runWhen","eject","silentJSONParsing","forcedJSONParsing","clarifyTimeoutError","isBrowser","URLSearchParams","protocols","hasBrowserEnv","hasStandardBrowserEnv","hasStandardBrowserWebWorkerEnv","WorkerGlobalScope","importScripts","buildPath","isNumericKey","isLast","arrayToObject","parsePropPath","transitional","adapter","transformRequest","contentType","getContentType","hasJSONContentType","isObjectPayload","setContentType","helpers","isNode","toURLEncodedForm","formSerializer","_FormData","stringifySafely","transformResponse","JSONRequested","responseType","strictJSONParsing","xsrfCookieName","xsrfHeaderName","maxContentLength","maxBodyLength","validateStatus","ignoreDuplicateOf","$internals","normalizeHeader","header","normalizeValue","matchHeaderValue","isHeaderNameFilter","AxiosHeaders","valueOrRewrite","rewrite","setHeader","_header","_rewrite","lHeader","setHeaders","rawHeaders","line","parseHeaders","tokensRE","parseTokens","matcher","deleted","deleteHeader","normalize","normalized","formatHeader","targets","asStrings","static","computed","accessors","defineAccessor","accessorName","arg1","arg2","arg3","buildAccessors","accessor","mapped","headerValue","transformData","fns","isCancel","__CANCEL__","CanceledError","settle","isDownloadStream","freq","bytesNotified","_speedometer","samplesCount","timestamps","firstSampleTS","head","chunkLength","startedAt","bytesCount","passed","round","timer","force","loaded","total","lengthComputable","progressBytes","rate","progress","estimated","msie","urlParsingNode","originURL","resolveURL","setAttribute","requestURL","secure","remove","buildFullPath","baseURL","requestedURL","relativeURL","combineURLs","headersToObject","mergeConfig","config1","config2","getMergedValue","mergeDeepProperties","valueFromConfig2","defaultToConfig2","mergeDirectKeys","mergeMap","paramsSerializer","timeoutMessage","withXSRFToken","onUploadProgress","onDownloadProgress","decompress","beforeRedirect","transport","httpAgent","httpsAgent","cancelToken","socketPath","responseEncoding","configValue","newConfig","btoa","isURLSameOrigin","xsrfValue","cookies","_config","resolveConfig","requestData","requestHeaders","onCanceled","unsubscribe","signal","onloadend","responseHeaders","getAllResponseHeaders","statusText","responseURL","onabort","ontimeout","timeoutErrorMessage","progressEventReducer","upload","cancel","subscribe","aborted","parseProtocol","signals","controller","AbortController","streamChunk","chunk","chunkSize","trackStream","stream","onProgress","onFinish","readBytes","ReadableStream","enqueue","highWaterMark","fetchProgressDecorator","isFetchSupported","fetch","Request","Response","isReadableStreamSupported","encodeText","TextEncoder","arrayBuffer","supportsRequestStream","duplexAccessed","hasContentType","duplex","supportsResponseStream","resolvers","knownAdapters","http","xhr","fetchOptions","finished","composedSignal","stopTimeout","requestContentLength","getContentLength","getBodyLength","resolveBodyLength","contentTypeHeader","_request","isStreamResponse","responseContentLength","responseData","renderReason","isResolvedHandle","adapters","nameOrAdapter","rejectedReasons","reasons","throwIfCancellationRequested","throwIfRequested","dispatchRequest","validators","deprecatedWarnings","validator","formatMessage","opt","assertOptions","schema","allowUnknown","Axios","instanceConfig","interceptors","configOrUrl","dummy","boolean","function","contextHeaders","requestInterceptorChain","synchronousRequestInterceptors","interceptor","responseInterceptorChain","promise","chain","onFulfilled","onRejected","getUri","generateHTTPMethod","isForm","CancelToken","resolvePromise","_listeners","HttpStatusCode","Continue","SwitchingProtocols","Processing","EarlyHints","Ok","Created","Accepted","NonAuthoritativeInformation","NoContent","ResetContent","PartialContent","MultiStatus","AlreadyReported","ImUsed","MultipleChoices","MovedPermanently","Found","SeeOther","NotModified","UseProxy","Unused","TemporaryRedirect","PermanentRedirect","BadRequest","Unauthorized","PaymentRequired","Forbidden","NotFound","MethodNotAllowed","NotAcceptable","ProxyAuthenticationRequired","RequestTimeout","Conflict","Gone","LengthRequired","PreconditionFailed","PayloadTooLarge","UriTooLong","UnsupportedMediaType","RangeNotSatisfiable","ExpectationFailed","ImATeapot","MisdirectedRequest","UnprocessableEntity","Locked","FailedDependency","TooEarly","UpgradeRequired","PreconditionRequired","TooManyRequests","RequestHeaderFieldsTooLarge","UnavailableForLegalReasons","InternalServerError","NotImplemented","BadGateway","ServiceUnavailable","GatewayTimeout","HttpVersionNotSupported","VariantAlsoNegotiates","InsufficientStorage","LoopDetected","NotExtended","NetworkAuthenticationRequired","createInstance","defaultConfig","VERSION","toFormData","Cancel","promises","spread","isAxiosError","payload","formToJSON","getAdapter","default"],"sourceRoot":""}