{"version":3,"file":"app.s2018-final.min.js","mappings":"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","sources":["/node_modules/core-js/internals/a-callable.js","/node_modules/core-js/internals/add-to-unscopables.js","/node_modules/core-js/internals/an-object.js","/node_modules/core-js/internals/array-includes.js","/node_modules/core-js/internals/classof-raw.js","/node_modules/core-js/internals/copy-constructor-properties.js","/node_modules/core-js/internals/create-non-enumerable-property.js","/node_modules/core-js/internals/create-property-descriptor.js","/node_modules/core-js/internals/define-built-in.js","/node_modules/core-js/internals/define-global-property.js","/node_modules/core-js/internals/descriptors.js","/node_modules/core-js/internals/document-create-element.js","/node_modules/core-js/internals/engine-user-agent.js","/node_modules/core-js/internals/engine-v8-version.js","/node_modules/core-js/internals/enum-bug-keys.js","/node_modules/core-js/internals/export.js","/node_modules/core-js/internals/fails.js","/node_modules/core-js/internals/function-bind-native.js","/node_modules/core-js/internals/function-call.js","/node_modules/core-js/internals/function-name.js","/node_modules/core-js/internals/function-uncurry-this.js","/node_modules/core-js/internals/get-built-in.js","/node_modules/core-js/internals/get-method.js","/node_modules/core-js/internals/global.js","/node_modules/core-js/internals/has-own-property.js","/node_modules/core-js/internals/hidden-keys.js","/node_modules/core-js/internals/html.js","/node_modules/core-js/internals/ie8-dom-define.js","/node_modules/core-js/internals/indexed-object.js","/node_modules/core-js/internals/inspect-source.js","/node_modules/core-js/internals/internal-state.js","/node_modules/core-js/internals/is-callable.js","/node_modules/core-js/internals/is-forced.js","/node_modules/core-js/internals/is-null-or-undefined.js","/node_modules/core-js/internals/is-object.js","/node_modules/core-js/internals/is-pure.js","/node_modules/core-js/internals/is-symbol.js","/node_modules/core-js/internals/length-of-array-like.js","/node_modules/core-js/internals/make-built-in.js","/node_modules/core-js/internals/math-trunc.js","/node_modules/core-js/internals/object-create.js","/node_modules/core-js/internals/object-define-properties.js","/node_modules/core-js/internals/object-define-property.js","/node_modules/core-js/internals/object-get-own-property-descriptor.js","/node_modules/core-js/internals/object-get-own-property-names.js","/node_modules/core-js/internals/object-get-own-property-symbols.js","/node_modules/core-js/internals/object-is-prototype-of.js","/node_modules/core-js/internals/object-keys-internal.js","/node_modules/core-js/internals/object-keys.js","/node_modules/core-js/internals/object-property-is-enumerable.js","/node_modules/core-js/internals/ordinary-to-primitive.js","/node_modules/core-js/internals/own-keys.js","/node_modules/core-js/internals/require-object-coercible.js","/node_modules/core-js/internals/shared-key.js","/node_modules/core-js/internals/shared-store.js","/node_modules/core-js/internals/shared.js","/node_modules/core-js/internals/symbol-constructor-detection.js","/node_modules/core-js/internals/to-absolute-index.js","/node_modules/core-js/internals/to-indexed-object.js","/node_modules/core-js/internals/to-integer-or-infinity.js","/node_modules/core-js/internals/to-length.js","/node_modules/core-js/internals/to-object.js","/node_modules/core-js/internals/to-primitive.js","/node_modules/core-js/internals/to-property-key.js","/node_modules/core-js/internals/try-to-string.js","/node_modules/core-js/internals/uid.js","/node_modules/core-js/internals/use-symbol-as-uid.js","/node_modules/core-js/internals/v8-prototype-define-bug.js","/node_modules/core-js/internals/weak-map-basic-detection.js","/node_modules/core-js/internals/well-known-symbol.js","/node_modules/core-js/modules/es.array.includes.js","webpack/bootstrap","webpack/runtime/global","/node_modules/@birchill/bugsnag-zero/dist/esm/index.js","/packages/bugsnag-config/lib/bugsnag-config.ts"],"sourcesContent":["'use strict';\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n  if (isCallable(argument)) return argument;\n  throw new $TypeError(tryToString(argument) + ' is not a function');\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar defineProperty = require('../internals/object-define-property').f;\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] === undefined) {\n  defineProperty(ArrayPrototype, UNSCOPABLES, {\n    configurable: true,\n    value: create(null)\n  });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n  ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","'use strict';\nvar isObject = require('../internals/is-object');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n  if (isObject(argument)) return argument;\n  throw new $TypeError($String(argument) + ' is not an object');\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIndexedObject($this);\n    var length = lengthOfArrayLike(O);\n    if (length === 0) return !IS_INCLUDES && -1;\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare -- NaN check\n    if (IS_INCLUDES && el !== el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare -- NaN check\n      if (value !== value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) {\n      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.includes` method\n  // https://tc39.es/ecma262/#sec-array.prototype.includes\n  includes: createMethod(true),\n  // `Array.prototype.indexOf` method\n  // https://tc39.es/ecma262/#sec-array.prototype.indexof\n  indexOf: createMethod(false)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n  return stringSlice(toString(it), 8, -1);\n};\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source, exceptions) {\n  var keys = ownKeys(source);\n  var defineProperty = definePropertyModule.f;\n  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {\n      defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n    }\n  }\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\n","'use strict';\nmodule.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar definePropertyModule = require('../internals/object-define-property');\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nmodule.exports = function (O, key, value, options) {\n  if (!options) options = {};\n  var simple = options.enumerable;\n  var name = options.name !== undefined ? options.name : key;\n  if (isCallable(value)) makeBuiltIn(value, name, options);\n  if (options.global) {\n    if (simple) O[key] = value;\n    else defineGlobalProperty(key, value);\n  } else {\n    try {\n      if (!options.unsafe) delete O[key];\n      else if (O[key]) simple = true;\n    } catch (error) { /* empty */ }\n    if (simple) O[key] = value;\n    else definePropertyModule.f(O, key, {\n      value: value,\n      enumerable: false,\n      configurable: !options.nonConfigurable,\n      writable: !options.nonWritable\n    });\n  } return O;\n};\n","'use strict';\nvar global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n  try {\n    defineProperty(global, key, { value: value, configurable: true, writable: true });\n  } catch (error) {\n    global[key] = value;\n  } return value;\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;\n});\n","'use strict';\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n  return EXISTS ? document.createElement(it) : {};\n};\n","'use strict';\nmodule.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';\n","'use strict';\nvar global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n  match = v8.split('.');\n  // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n  // but their correct versions are not interesting for us\n  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n  match = userAgent.match(/Edge\\/(\\d+)/);\n  if (!match || match[1] >= 74) {\n    match = userAgent.match(/Chrome\\/(\\d+)/);\n    if (match) version = +match[1];\n  }\n}\n\nmodule.exports = version;\n","'use strict';\n// IE8- don't enum bug keys\nmodule.exports = [\n  'constructor',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  'toLocaleString',\n  'toString',\n  'valueOf'\n];\n","'use strict';\nvar global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n  options.target         - name of the target object\n  options.global         - target is the global object\n  options.stat           - export as static methods of target\n  options.proto          - export as prototype methods of target\n  options.real           - real prototype method for the `pure` version\n  options.forced         - export even if the native feature is available\n  options.bind           - bind methods to the target, required for the `pure` version\n  options.wrap           - wrap constructors to preventing global pollution, required for the `pure` version\n  options.unsafe         - use the simple assignment of property instead of delete + defineProperty\n  options.sham           - add a flag to not completely full polyfills\n  options.enumerable     - export as enumerable property\n  options.dontCallGetSet - prevent calling a getter on target\n  options.name           - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n  var TARGET = options.target;\n  var GLOBAL = options.global;\n  var STATIC = options.stat;\n  var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n  if (GLOBAL) {\n    target = global;\n  } else if (STATIC) {\n    target = global[TARGET] || defineGlobalProperty(TARGET, {});\n  } else {\n    target = global[TARGET] && global[TARGET].prototype;\n  }\n  if (target) for (key in source) {\n    sourceProperty = source[key];\n    if (options.dontCallGetSet) {\n      descriptor = getOwnPropertyDescriptor(target, key);\n      targetProperty = descriptor && descriptor.value;\n    } else targetProperty = target[key];\n    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n    // contained in target\n    if (!FORCED && targetProperty !== undefined) {\n      if (typeof sourceProperty == typeof targetProperty) continue;\n      copyConstructorProperties(sourceProperty, targetProperty);\n    }\n    // add a flag to not completely full polyfills\n    if (options.sham || (targetProperty && targetProperty.sham)) {\n      createNonEnumerableProperty(sourceProperty, 'sham', true);\n    }\n    defineBuiltIn(target, key, sourceProperty, options);\n  }\n};\n","'use strict';\nmodule.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (error) {\n    return true;\n  }\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  // eslint-disable-next-line es/no-function-prototype-bind -- safe\n  var test = (function () { /* empty */ }).bind();\n  // eslint-disable-next-line no-prototype-builtins -- safe\n  return typeof test != 'function' || test.hasOwnProperty('prototype');\n});\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar call = Function.prototype.call;\n\nmodule.exports = NATIVE_BIND ? call.bind(call) : function () {\n  return call.apply(call, arguments);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n  EXISTS: EXISTS,\n  PROPER: PROPER,\n  CONFIGURABLE: CONFIGURABLE\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar call = FunctionPrototype.call;\nvar uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);\n\nmodule.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {\n  return function () {\n    return call.apply(fn, arguments);\n  };\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n  return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n  return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n  var func = V[P];\n  return isNullOrUndefined(func) ? undefined : aCallable(func);\n};\n","'use strict';\nvar check = function (it) {\n  return it && it.Math === Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n  // eslint-disable-next-line es/no-global-this -- safe\n  check(typeof globalThis == 'object' && globalThis) ||\n  check(typeof window == 'object' && window) ||\n  // eslint-disable-next-line no-restricted-globals -- safe\n  check(typeof self == 'object' && self) ||\n  check(typeof global == 'object' && global) ||\n  check(typeof this == 'object' && this) ||\n  // eslint-disable-next-line no-new-func -- fallback\n  (function () { return this; })() || Function('return this')();\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\n// eslint-disable-next-line es/no-object-hasown -- safe\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n  return hasOwnProperty(toObject(it), key);\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thanks to IE8 for its funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n  return Object.defineProperty(createElement('div'), 'a', {\n    get: function () { return 7; }\n  }).a !== 7;\n});\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar $Object = Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n  // eslint-disable-next-line no-prototype-builtins -- safe\n  return !$Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n  return classof(it) === 'String' ? split(it, '') : $Object(it);\n} : $Object;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n  store.inspectSource = function (it) {\n    return functionToString(it);\n  };\n}\n\nmodule.exports = store.inspectSource;\n","'use strict';\nvar NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n  return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n  return function (it) {\n    var state;\n    if (!isObject(it) || (state = get(it)).type !== TYPE) {\n      throw new TypeError('Incompatible receiver, ' + TYPE + ' required');\n    } return state;\n  };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n  var store = shared.state || (shared.state = new WeakMap());\n  /* eslint-disable no-self-assign -- prototype methods protection */\n  store.get = store.get;\n  store.has = store.has;\n  store.set = store.set;\n  /* eslint-enable no-self-assign -- prototype methods protection */\n  set = function (it, metadata) {\n    if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n    metadata.facade = it;\n    store.set(it, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return store.get(it) || {};\n  };\n  has = function (it) {\n    return store.has(it);\n  };\n} else {\n  var STATE = sharedKey('state');\n  hiddenKeys[STATE] = true;\n  set = function (it, metadata) {\n    if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n    metadata.facade = it;\n    createNonEnumerableProperty(it, STATE, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return hasOwn(it, STATE) ? it[STATE] : {};\n  };\n  has = function (it) {\n    return hasOwn(it, STATE);\n  };\n}\n\nmodule.exports = {\n  set: set,\n  get: get,\n  has: has,\n  enforce: enforce,\n  getterFor: getterFor\n};\n","'use strict';\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot\nvar documentAll = typeof document == 'object' && document.all;\n\n// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\n// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing\nmodule.exports = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {\n  return typeof argument == 'function' || argument === documentAll;\n} : function (argument) {\n  return typeof argument == 'function';\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n  var value = data[normalize(feature)];\n  return value === POLYFILL ? true\n    : value === NATIVE ? false\n    : isCallable(detection) ? fails(detection)\n    : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n  return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","'use strict';\n// we can't use just `it == null` since of `document.all` special case\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec\nmodule.exports = function (it) {\n  return it === null || it === undefined;\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\n\nmodule.exports = function (it) {\n  return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","'use strict';\nmodule.exports = false;\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar $Object = Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n  return typeof it == 'symbol';\n} : function (it) {\n  var $Symbol = getBuiltIn('Symbol');\n  return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));\n};\n","'use strict';\nvar toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n  return toLength(obj.length);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar enforceInternalState = InternalStateModule.enforce;\nvar getInternalState = InternalStateModule.get;\nvar $String = String;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\nvar stringSlice = uncurryThis(''.slice);\nvar replace = uncurryThis(''.replace);\nvar join = uncurryThis([].join);\n\nvar CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {\n  return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;\n});\n\nvar TEMPLATE = String(String).split('String');\n\nvar makeBuiltIn = module.exports = function (value, name, options) {\n  if (stringSlice($String(name), 0, 7) === 'Symbol(') {\n    name = '[' + replace($String(name), /^Symbol\\(([^)]*)\\).*$/, '$1') + ']';\n  }\n  if (options && options.getter) name = 'get ' + name;\n  if (options && options.setter) name = 'set ' + name;\n  if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n    if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });\n    else value.name = name;\n  }\n  if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {\n    defineProperty(value, 'length', { value: options.arity });\n  }\n  try {\n    if (options && hasOwn(options, 'constructor') && options.constructor) {\n      if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });\n    // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable\n    } else if (value.prototype) value.prototype = undefined;\n  } catch (error) { /* empty */ }\n  var state = enforceInternalState(value);\n  if (!hasOwn(state, 'source')) {\n    state.source = join(TEMPLATE, typeof name == 'string' ? name : '');\n  } return value;\n};\n\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n// eslint-disable-next-line no-extend-native -- required\nFunction.prototype.toString = makeBuiltIn(function toString() {\n  return isCallable(this) && getInternalState(this).source || inspectSource(this);\n}, 'toString');\n","'use strict';\nvar ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `Math.trunc` method\n// https://tc39.es/ecma262/#sec-math.trunc\n// eslint-disable-next-line es/no-math-trunc -- safe\nmodule.exports = Math.trunc || function trunc(x) {\n  var n = +x;\n  return (n > 0 ? floor : ceil)(n);\n};\n","'use strict';\n/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar definePropertiesModule = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n  activeXDocument.write(scriptTag(''));\n  activeXDocument.close();\n  var temp = activeXDocument.parentWindow.Object;\n  activeXDocument = null; // avoid memory leak\n  return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = documentCreateElement('iframe');\n  var JS = 'java' + SCRIPT + ':';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  html.appendChild(iframe);\n  // https://github.com/zloirock/core-js/issues/475\n  iframe.src = String(JS);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(scriptTag('document.F=Object'));\n  iframeDocument.close();\n  return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n  try {\n    activeXDocument = new ActiveXObject('htmlfile');\n  } catch (error) { /* ignore */ }\n  NullProtoObject = typeof document != 'undefined'\n    ? document.domain && activeXDocument\n      ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n      : NullProtoObjectViaIFrame()\n    : NullProtoObjectViaActiveX(activeXDocument); // WSH\n  var length = enumBugKeys.length;\n  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n  return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\n// eslint-disable-next-line es/no-object-create -- safe\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    EmptyConstructor[PROTOTYPE] = anObject(O);\n    result = new EmptyConstructor();\n    EmptyConstructor[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = NullProtoObject();\n  return Properties === undefined ? result : definePropertiesModule.f(result, Properties);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nexports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var props = toIndexedObject(Properties);\n  var keys = objectKeys(Properties);\n  var length = keys.length;\n  var index = 0;\n  var key;\n  while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n  return O;\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar $TypeError = TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar ENUMERABLE = 'enumerable';\nvar CONFIGURABLE = 'configurable';\nvar WRITABLE = 'writable';\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPropertyKey(P);\n  anObject(Attributes);\n  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {\n    var current = $getOwnPropertyDescriptor(O, P);\n    if (current && current[WRITABLE]) {\n      O[P] = Attributes.value;\n      Attributes = {\n        configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],\n        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],\n        writable: false\n      };\n    }\n  } return $defineProperty(O, P, Attributes);\n} : $defineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPropertyKey(P);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return $defineProperty(O, P, Attributes);\n  } catch (error) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n  O = toIndexedObject(O);\n  P = toPropertyKey(P);\n  if (IE8_DOM_DEFINE) try {\n    return $getOwnPropertyDescriptor(O, P);\n  } catch (error) { /* empty */ }\n  if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return internalObjectKeys(O, hiddenKeys);\n};\n","'use strict';\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n  var O = toIndexedObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (hasOwn(O, key = names[i++])) {\n    ~indexOf(result, key) || push(result, key);\n  }\n  return result;\n};\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n  return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n  var descriptor = getOwnPropertyDescriptor(this, V);\n  return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","'use strict';\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar $TypeError = TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n  var fn, val;\n  if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n  if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n  if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n  throw new $TypeError(\"Can't convert object to primitive value\");\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n  var keys = getOwnPropertyNamesModule.f(anObject(it));\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","'use strict';\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\nvar $TypeError = TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n  if (isNullOrUndefined(it)) throw new $TypeError(\"Can't call method on \" + it);\n  return it;\n};\n","'use strict';\nvar shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n  return keys[key] || (keys[key] = uid(key));\n};\n","'use strict';\nvar IS_PURE = require('../internals/is-pure');\nvar globalThis = require('../internals/global');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nvar SHARED = '__core-js_shared__';\nvar store = module.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});\n\n(store.versions || (store.versions = [])).push({\n  version: '3.37.0',\n  mode: IS_PURE ? 'pure' : 'global',\n  copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',\n  license: 'https://github.com/zloirock/core-js/blob/v3.37.0/LICENSE',\n  source: 'https://github.com/zloirock/core-js'\n});\n","'use strict';\nvar store = require('../internals/shared-store');\n\nmodule.exports = function (key, value) {\n  return store[key] || (store[key] = value || {});\n};\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\nvar $String = global.String;\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n  var symbol = Symbol('symbol detection');\n  // Chrome 38 Symbol has incorrect toString conversion\n  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n  // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,\n  // of course, fail.\n  return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||\n    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n    !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n  var integer = toIntegerOrInfinity(index);\n  return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","'use strict';\n// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n  return IndexedObject(requireObjectCoercible(it));\n};\n","'use strict';\nvar trunc = require('../internals/math-trunc');\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n  var number = +argument;\n  // eslint-disable-next-line no-self-compare -- NaN check\n  return number !== number || number === 0 ? 0 : trunc(number);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n  var len = toIntegerOrInfinity(argument);\n  return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","'use strict';\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar $Object = Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n  return $Object(requireObjectCoercible(argument));\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar $TypeError = TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n  if (!isObject(input) || isSymbol(input)) return input;\n  var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n  var result;\n  if (exoticToPrim) {\n    if (pref === undefined) pref = 'default';\n    result = call(exoticToPrim, input, pref);\n    if (!isObject(result) || isSymbol(result)) return result;\n    throw new $TypeError(\"Can't convert object to primitive value\");\n  }\n  if (pref === undefined) pref = 'number';\n  return ordinaryToPrimitive(input, pref);\n};\n","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n  var key = toPrimitive(argument, 'string');\n  return isSymbol(key) ? key : key + '';\n};\n","'use strict';\nvar $String = String;\n\nmodule.exports = function (argument) {\n  try {\n    return $String(argument);\n  } catch (error) {\n    return 'Object';\n  }\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\n\nmodule.exports = NATIVE_SYMBOL\n  && !Symbol.sham\n  && typeof Symbol.iterator == 'symbol';\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\n\n// V8 ~ Chrome 36-\n// https://bugs.chromium.org/p/v8/issues/detail?id=3334\nmodule.exports = DESCRIPTORS && fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n  return Object.defineProperty(function () { /* empty */ }, 'prototype', {\n    value: 42,\n    writable: false\n  }).prototype !== 42;\n});\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));\n","'use strict';\nvar global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Symbol = global.Symbol;\nvar WellKnownSymbolsStore = shared('wks');\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n  if (!hasOwn(WellKnownSymbolsStore, name)) {\n    WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)\n      ? Symbol[name]\n      : createWellKnownSymbol('Symbol.' + name);\n  } return WellKnownSymbolsStore[name];\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $includes = require('../internals/array-includes').includes;\nvar fails = require('../internals/fails');\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\n// FF99+ bug\nvar BROKEN_ON_SPARSE = fails(function () {\n  // eslint-disable-next-line es/no-array-prototype-includes -- detection\n  return !Array(1).includes();\n});\n\n// `Array.prototype.includes` method\n// https://tc39.es/ecma262/#sec-array.prototype.includes\n$({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {\n  includes: function includes(el /* , fromIndex = 0 */) {\n    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('includes');\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","class FetchDelivery {\n    constructor(client) {\n        this.client = client;\n    }\n    async sendEvent({ apiKey, events, notifier, payloadVersion, }) {\n        const sentAt = new Date().toISOString();\n        const body = JSON.stringify({\n            apiKey,\n            payloadVersion,\n            notifier,\n            events,\n        });\n        await fetch(this.client.endpoints.notify, {\n            method: 'POST',\n            mode: 'cors',\n            credentials: 'omit',\n            headers: {\n                'Content-Type': 'application/json',\n                'Bugsnag-Api-Key': apiKey,\n                'Bugsnag-Payload-Version': payloadVersion,\n                'Bugsnag-Sent-At': sentAt,\n            },\n            referrerPolicy: 'no-referrer',\n            body,\n        });\n    }\n}\n\nconst CircularReference = Symbol('Circular');\nconst AccessError = Symbol('AccessError');\n/**\n * Iterate through an object's properties and return a copy with the values\n * replaced by the result of the replacer function.\n *\n * Detects circular references and replaces them with the `CircularReference`\n * symbol.\n *\n * Detects errors accessing properties and replaces them with the `AccessError`\n * symbol.\n *\n * For any objects with a `toJSON` function, it will be called instead of\n * traversing the object's properties.\n */\nfunction safeFilter(input, replacer, options) {\n    return filter({\n        key: '',\n        value: input,\n        replacer,\n        seen: [],\n        depth: 0,\n        depthLimit: options === null || options === void 0 ? void 0 : options.depthLimit,\n        edgeIndex: 0,\n        edgesLimit: options === null || options === void 0 ? void 0 : options.edgesLimit,\n    });\n}\nfunction filter({ key, value, replacer, seen, depthLimit = Infinity, depth, edgeIndex, edgesLimit = Infinity, }) {\n    let replacement = value;\n    if (seen.includes(replacement)) {\n        replacement = CircularReference;\n    }\n    if (replacer) {\n        replacement = replacer(key, replacement);\n    }\n    if (hasToJson(replacement)) {\n        replacement = safeAccess(() => replacement.toJSON(String(key)));\n    }\n    // TODO: We really should re-run our cyclic dependency check at this point in\n    // case the replacer or toJSON has created a new cyclic dependency.\n    //\n    // Surely no-one would do that though, right?\n    if (replacement === null || typeof replacement !== 'object') {\n        return replacement;\n    }\n    if (depth > depthLimit || edgeIndex + 1 > edgesLimit) {\n        return '[...]';\n    }\n    seen.push(value);\n    if (Array.isArray(replacement)) {\n        const copy = [];\n        const limit = Math.min(replacement.length, edgesLimit);\n        for (let i = 0; i < limit; i++) {\n            const item = safeAccess(() => replacement[i]);\n            copy.push(filter({\n                key: i,\n                value: item,\n                replacer,\n                seen,\n                depth,\n                depthLimit,\n                edgeIndex: i,\n                edgesLimit,\n            }));\n        }\n        if (limit < replacement.length) {\n            copy.push('[...]');\n        }\n        replacement = copy;\n    }\n    else {\n        const copy = {};\n        const keys = Object.keys(replacement);\n        for (let i = 0; i < keys.length; i++) {\n            const currentKey = keys[i];\n            const value = safeAccess(() => replacement[currentKey]);\n            copy[currentKey] = filter({\n                key: currentKey,\n                value,\n                replacer,\n                seen,\n                depth,\n                depthLimit,\n                edgeIndex: i,\n                edgesLimit,\n            });\n        }\n        replacement = copy;\n    }\n    seen.pop();\n    return replacement;\n}\nfunction safeAccess(accessor) {\n    try {\n        return accessor();\n    }\n    catch (_a) {\n        return AccessError;\n    }\n}\nfunction hasToJson(value) {\n    return (typeof value === 'object' &&\n        value !== null &&\n        'toJSON' in value &&\n        typeof value.toJSON === 'function');\n}\n\n// Based heavily on: https://github.com/mk-pmb/is-error-js\n//\n// which has the following license:\n//\n// Copyright (c) 2015 is-error.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\nconst objectToString = Object.prototype.toString;\nconst getPrototypeOf = Object.getPrototypeOf;\nconst ERROR_TYPE = '[object Error]';\nfunction isError(a) {\n    if (a instanceof Error) {\n        return true;\n    }\n    let err = a;\n    while (err) {\n        if (objectToString.call(err) === ERROR_TYPE) {\n            return true;\n        }\n        err = getPrototypeOf(err);\n    }\n    return false;\n}\n\nfunction isObject(a) {\n    return typeof a === 'object' && a !== null && !Array.isArray(a);\n}\n\n// The following code is based on:\n//\n// https://github.com/stacktracejs/error-stack-parser/blob/master/error-stack-parser.js\n//\n// which is released under the MIT license. Its copyright and license terms\n// are as follows:\n//\n// Copyright (c) 2017 Eric Wendelin and other contributors\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n//\n// It has been modified to match Bugsnag's stackframe format, remove unneeded\n// Opera stackframe handling, and use TypeScript and more modern JavaScript.\nconst CHROME_IE_STACK_REGEXP = /^\\s*at .*(\\S+:\\d+|\\(native\\))/m;\nconst SAFARI_NATIVE_CODE_REGEXP = /^(eval@)?(\\[native code])?$/;\nfunction parseStack(stackString) {\n    const partialResult = stackString.match(CHROME_IE_STACK_REGEXP)\n        ? parseV8OrIE(stackString)\n        : parseFFOrSafari(stackString);\n    return partialResult.reduce((result, stack) => {\n        // Drop empty stack frames\n        if (JSON.stringify(stack) === '{}') {\n            return result;\n        }\n        // If we have no file or method but we _do_ have a line number, it must be\n        // global code.\n        let file = !stack.file && !stack.method && typeof stack.lineNumber === 'number'\n            ? 'global code'\n            : stack.file || '(unknown file)';\n        // Strip the query string / fragment from filenames\n        file = file.replace(/\\?.*$/, '').replace(/#.*$/, '');\n        // Case normalize \"global code\" function names\n        let method = stack.method || '(unknown function)';\n        method = /^global code$/i.test(method) ? 'global code' : method;\n        return result.concat([\n            {\n                file,\n                lineNumber: stack.lineNumber,\n                columnNumber: stack.columnNumber,\n                method,\n            },\n        ]);\n    }, []);\n}\nfunction parseV8OrIE(stackString) {\n    const filtered = stackString\n        .split('\\n')\n        .filter((line) => !!line.match(CHROME_IE_STACK_REGEXP));\n    return filtered.map((line) => {\n        // Bugsnag stack frames don't have a way of representing eval origins\n        // so we just throw that information away for now.\n        //\n        // stacktrace.js can represent this but it still throws this information\n        // away.\n        if (line.indexOf('(eval ') > -1) {\n            line = line\n                .replace(/eval code/g, 'eval')\n                .replace(/(\\(eval at [^()]*)|(\\),.*$)/g, '');\n        }\n        let sanitizedLine = line.replace(/^\\s+/, '').replace(/\\(eval code/g, '(');\n        // Capture and preserve the parenthesized location \"(/foo/my bar.js:12:87)\"\n        // in case it has spaces in it, as the string is split on \\s+ later on.\n        const location = sanitizedLine.match(/ (\\((.+):(\\d+):(\\d+)\\)$)/);\n        // Remove the parenthesized location from the line, if it was matched.\n        sanitizedLine = location\n            ? sanitizedLine.replace(location[0], '')\n            : sanitizedLine;\n        const tokens = sanitizedLine.split(/\\s+/).slice(1);\n        // If a location was matched, pass it to extractLocation(), otherwise pop\n        // the last token.\n        const locationParts = extractLocation(location ? location[1] : tokens.pop() || '(no location)');\n        const method = tokens.join(' ') || undefined;\n        const file = ['eval', '<anonymous>'].indexOf(locationParts[0]) > -1\n            ? undefined\n            : locationParts[0];\n        return {\n            file,\n            lineNumber: locationParts[1],\n            columnNumber: locationParts[2],\n            method,\n        };\n    });\n}\nfunction parseFFOrSafari(stackString) {\n    const filtered = stackString\n        .split('\\n')\n        .filter((line) => !line.match(SAFARI_NATIVE_CODE_REGEXP));\n    return filtered.map((line) => {\n        // Bugsnag stack frames don't have a way of representing eval origins\n        // so we just throw that information away for now.\n        //\n        // stacktrace.js can represent this but it still throws this information\n        // away.\n        if (line.indexOf(' > eval') > -1) {\n            line = line.replace(/ line (\\d+)(?: > eval line \\d+)* > eval:\\d+:\\d+/g, ':$1');\n        }\n        if (line.indexOf('@') === -1 && line.indexOf(':') === -1) {\n            // Safari eval frames only have function names and nothing else\n            return {\n                method: line,\n            };\n        }\n        else {\n            const functionNameRegex = /((.*\".+\"[^@]*)?[^@]*)(?:@)/;\n            const matches = line.match(functionNameRegex);\n            const method = matches && matches[1] ? matches[1] : undefined;\n            const locationParts = extractLocation(line.replace(functionNameRegex, ''));\n            return {\n                file: locationParts[0],\n                lineNumber: locationParts[1],\n                columnNumber: locationParts[2],\n                method,\n            };\n        }\n    });\n}\n// Separate line and column numbers from a string of the form: (URI:Line:Column)\nfunction extractLocation(urlLike) {\n    // Fail-fast but return locations like \"(native)\"\n    if (urlLike.indexOf(':') === -1) {\n        return [urlLike];\n    }\n    const regExp = /(.+?)(?::(\\d+))?(?::(\\d+))?$/;\n    const parts = regExp.exec(urlLike.replace(/[()]/g, ''));\n    if (!parts) {\n        return [urlLike];\n    }\n    const line = parts[2] ? parseInt(parts[2], 10) : undefined;\n    const col = parts[3] ? parseInt(parts[3], 10) : undefined;\n    return [parts[1], line, col];\n}\n\nfunction toException(maybeError, component) {\n    const error = normalizeError(maybeError, component);\n    // Add metadata for non-errors\n    let metadata;\n    if (error.name === 'InvalidError') {\n        metadata = {\n            [component]: {\n                'non-error parameter': maybeError,\n            },\n        };\n    }\n    // Merge any metadata defined on the object itself\n    if (typeof error.metadata !== 'undefined' &&\n        isObject(error.metadata)) {\n        metadata = { ...metadata, [error.name]: error.metadata };\n    }\n    return {\n        exception: {\n            errorClass: error.name,\n            message: error.message,\n            stacktrace: getStacktrace(error),\n            type: typeof self === 'object' && self.navigator\n                ? 'browserjs'\n                : 'nodejs',\n        },\n        metadata,\n    };\n}\nfunction normalizeError(maybeError, component) {\n    if (isError(maybeError)) {\n        return maybeError;\n    }\n    let error = fromSimpleError(maybeError);\n    if (error) {\n        return error;\n    }\n    switch (typeof error) {\n        case 'string':\n        case 'number':\n        case 'boolean':\n            return new Error(String(maybeError));\n        default: {\n            error = new Error(`${component} received a non-error. See \"${component}\" tab for more detail.`);\n            error.name = 'InvalidError';\n            return error;\n        }\n    }\n}\nfunction fromSimpleError(error) {\n    if (!isObject(error)) {\n        return null;\n    }\n    const getStringMember = (field) => typeof error[field] === 'string' && error[field].length\n        ? error[field]\n        : undefined;\n    const name = getStringMember('name') || getStringMember('errorClass');\n    const message = getStringMember('message') || getStringMember('errorMessage');\n    if (!name || !message) {\n        return null;\n    }\n    const newError = new Error(message);\n    newError.name = name;\n    return newError;\n}\nfunction getStacktrace(error) {\n    const stackString = getStackString(error);\n    if (stackString) {\n        return parseStack(stackString);\n    }\n    else {\n        // TODO: We'll probably want to trim this to remove some of our own\n        // frames from it but let's wait until we actually have some examples of\n        // that to work with.\n        return generateBacktrace();\n    }\n}\nfunction getStackString(error) {\n    const stack = error.stack || error.stacktrace;\n    return typeof stack === 'string' &&\n        stack.length &&\n        stack !== `${error.name}: ${error.message}`\n        ? stack\n        : undefined;\n}\nconst MAX_STACK_SIZE = 20;\n// The following is based on\n//\n// https://github.com/stacktracejs/stack-generator/blob/master/stack-generator.js\n//\n// which is licensed to the Public Domain.\nfunction generateBacktrace() {\n    const stack = [];\n    // arguments.callee cannot be accessed in strict mode.\n    /* eslint @typescript-eslint/ban-types: 0 */\n    let curr;\n    try {\n        curr = arguments.callee;\n    }\n    catch (_e) {\n        return [];\n    }\n    while (curr && stack.length < MAX_STACK_SIZE) {\n        if (curr.name) {\n            stack.push({ method: curr.name, file: '(unknown file)' });\n        }\n        else if (/function(?:\\s+([\\w$]+))+\\s*\\(/.test(curr.toString())) {\n            stack.push({ method: RegExp.$1, file: '(unknown file)' });\n        }\n        try {\n            curr = curr.caller;\n        }\n        catch (e) {\n            break;\n        }\n    }\n    return stack;\n}\n\nconst browserNotifyUnhandledExceptions = {\n    name: 'browserNotifyUnhandledExceptions',\n    load(client) {\n        self.addEventListener('error', (evt) => {\n            var _a, _b;\n            let exception;\n            let metadata;\n            if (evt instanceof ErrorEvent) {\n                const { message, filename: file, lineno, colno, error } = evt;\n                const lineNumber = Number.isSafeInteger(lineno) ? lineno : undefined;\n                if (lineNumber === 0 && /Script error\\.?/.test(message)) {\n                    console.log('Ignoring cross-domain or eval script error.');\n                    return;\n                }\n                ({ exception, metadata } = toException(error, 'window onerror'));\n                // Augment first stacktrace if we have more info in the ErrorEvent than\n                // the stack trace we got.\n                const columnNumber = Number.isSafeInteger(colno) ? colno : undefined;\n                const { stacktrace } = exception;\n                if (!stacktrace.length) {\n                    stacktrace.push({\n                        file,\n                        lineNumber,\n                        columnNumber,\n                        method: '(unknown file)',\n                    });\n                }\n                else {\n                    const firstStackFrame = stacktrace[0];\n                    firstStackFrame.file = firstStackFrame.file || file;\n                    firstStackFrame.lineNumber = (_a = firstStackFrame.lineNumber) !== null && _a !== void 0 ? _a : lineNumber;\n                    firstStackFrame.columnNumber =\n                        (_b = firstStackFrame.columnNumber) !== null && _b !== void 0 ? _b : columnNumber;\n                }\n            }\n            else {\n                ({ exception, metadata } = toException(evt, 'window onerror'));\n            }\n            client.notifyEvent({\n                exceptions: [exception],\n                unhandled: true,\n                severity: 'error',\n                severityReason: {\n                    type: 'unhandledException',\n                },\n                metadata,\n            }, evt);\n        });\n    },\n};\n\nconst browserNotifyUnhandledRejections = {\n    name: 'browserNotifyUnhandledRejections',\n    load(client) {\n        self.addEventListener('unhandledrejection', (evt) => {\n            const error = evt.reason;\n            const { exception, metadata } = toException(error, 'unhandledrejection');\n            // The official bugsnag client digs into `error` and, if it has no\n            // stack, but is an Error object, it pulls out the name, message, code\n            // and adds them to a metadata tab called 'unhandledRejection handler'.\n            //\n            // I don't understand this. Surely we'll have the same information in\n            // our exception object already?\n            client.notifyEvent({\n                exceptions: [exception],\n                unhandled: true,\n                severity: 'error',\n                severityReason: {\n                    type: 'unhandledPromiseRejection',\n                },\n                metadata,\n            }, error);\n        });\n    },\n};\n\nconst consoleBreadcrumbs = {\n    name: 'consoleBreadcrumbs',\n    load(client) {\n        const methodsToHook = ['log', 'debug', 'info', 'warn', 'error'].filter((method) => typeof console !== 'undefined' && typeof console[method] === 'function');\n        for (const method of methodsToHook) {\n            const original = console[method];\n            console[method] = (...args) => {\n                client.leaveBreadcrumb('Console output', args.reduce((metadata, arg, i) => {\n                    // Try to stringify each argument\n                    let stringified = '[Unknown value]';\n                    // Try to use toString.\n                    //\n                    // This may fail if the input is:\n                    //\n                    // - an object whose [[Prototype]] is null (no toString), or\n                    // - an object with a broken toString or @@toPrimitive\n                    //   implementation\n                    try {\n                        stringified = String(arg);\n                    }\n                    catch (_e) {\n                        /* Ignore */\n                    }\n                    // If it stringifies to [object Object] attempt to JSON stringify\n                    if (stringified === '[object Object]') {\n                        // But catch any stringify errors (falling back to\n                        // [object Object])\n                        try {\n                            stringified = JSON.stringify(arg);\n                        }\n                        catch (_e) {\n                            /* Ignore */\n                        }\n                    }\n                    metadata[`[${i}]`] = stringified;\n                    return metadata;\n                }, {\n                    // The official client attempts to map console.group to 'log' here\n                    // but it never actually hooks console.group.\n                    severity: method,\n                }), 'log');\n                original.apply(console, args);\n            };\n        }\n    },\n};\n\nconst errorBreadcrumbs = {\n    name: 'errorBreadcrumbs',\n    load(client) {\n        client.addOnPostError((event) => {\n            client.leaveBreadcrumb(event.exceptions[0].errorClass, {\n                errorClass: event.exceptions[0].errorClass,\n                errorMessage: event.exceptions[0].message,\n                severity: event.severity,\n            }, 'error');\n        });\n    },\n};\n\n// Unlike the official bugsnag JS client this does NOT cover XHR.\n// Furthermore, it does not provide a way to be cleaned up.\nconst fetchBreadcrumbs = {\n    name: 'fetchBreadcrumbs',\n    load(client) {\n        if (!('fetch' in self)) {\n            return;\n        }\n        const oldFetch = self.fetch;\n        self.fetch = function fetch(input, init) {\n            let method = 'GET';\n            let url;\n            if (isRequest(input)) {\n                url = input.url;\n                method = input.method;\n            }\n            else {\n                url = input.toString();\n            }\n            // Per the fetch algorithm, the method specified in the RequestInit takes\n            // precedence over the method specified in the Request.\n            if (init && typeof init.method === 'string' && init.method.length) {\n                method = init.method;\n            }\n            const leaveBreadcrumb = client.leaveBreadcrumb.bind(client);\n            return new Promise((resolve, reject) => {\n                oldFetch(input, init)\n                    .then((response) => {\n                    handleFetchSuccess({ response, method, url, leaveBreadcrumb });\n                    resolve(response);\n                })\n                    .catch((error) => {\n                    handleFetchError({ method, url, leaveBreadcrumb });\n                    reject(error);\n                });\n            });\n        };\n    },\n};\nfunction isRequest(input) {\n    // instanceof alone won't work for objects from different realms\n    return input instanceof Request || (isObject(input) && 'url' in input);\n}\nfunction handleFetchSuccess({ response, method, url, leaveBreadcrumb, }) {\n    // The official bugsnag client ignores bugsnag requests for XHR but not for\n    // fetch. I think it means to ignore it for fetch, though.\n    if (url.startsWith('https://notify.bugsnag.com')) {\n        return;\n    }\n    const metadata = {\n        status: response.status,\n        request: `${method} ${url}`,\n    };\n    if (response.status >= 400) {\n        leaveBreadcrumb('fetch() failed', metadata, 'request');\n    }\n    else {\n        leaveBreadcrumb('fetch() succeeded', metadata, 'request');\n    }\n}\nfunction handleFetchError({ method, url, leaveBreadcrumb, }) {\n    if (url.startsWith('https://notify.bugsnag.com')) {\n        return;\n    }\n    leaveBreadcrumb('fetch() error', { request: `${method} ${url}` }, 'request');\n}\n\nconst interactionBreadcrumbs = {\n    name: 'interactionBreadcrumbs',\n    load(client) {\n        if (!('addEventListener' in self)) {\n            return;\n        }\n        self.addEventListener('click', (event) => {\n            let targetText, targetSelector;\n            try {\n                targetText = isHtmlElement(event.target)\n                    ? getNodeText(event.target)\n                    : '(Non-HTML Element)';\n                targetSelector = isElement(event.target)\n                    ? getNodeSelector(event.target)\n                    : '(Non-element target)';\n            }\n            catch (e) {\n                targetText = '[hidden]';\n                targetSelector = '[hidden]';\n            }\n            client.leaveBreadcrumb('UI click', { targetText, targetSelector }, 'user');\n        }, true);\n    },\n};\nfunction isElement(target) {\n    return isObject(target) && target.nodeType === Node.ELEMENT_NODE;\n}\nfunction isHtmlElement(target) {\n    return (isElement(target) && target.namespaceURI === 'http://www.w3.org/1999/xhtml');\n}\nfunction getNodeText(elem) {\n    let text = elem.textContent || elem.innerText || '';\n    if (!text &&\n        (elem.type === 'submit' ||\n            elem.type === 'button')) {\n        text = elem.value;\n    }\n    // Truncate text first to avoid running our whitespace regex on a large string\n    text = truncate(text, 140);\n    return text.replace(/^\\s+|\\s+$/g, ''); // trim whitespace\n}\n// Create a label from tagname, id and css class of the element\nfunction getNodeSelector(elem) {\n    // Generate an initial selector using ID + class names\n    //\n    // (This is particularly unsuitable for utility CSS frameworks like Tailwind\n    // but oh well)\n    const parts = [elem.tagName];\n    if (elem.id) {\n        parts.push('#' + elem.id);\n    }\n    if (elem.className && elem.className.length) {\n        parts.push(`.${elem.className.split(' ').join('.')}`);\n    }\n    // We can't try out the selector in this context so just return it as-is.\n    if (!self.document.querySelectorAll) {\n        return parts.join('');\n    }\n    // See if the selector we have generated is sufficiently specific\n    try {\n        if (self.document.querySelectorAll(parts.join('')).length === 1) {\n            return parts.join('');\n        }\n    }\n    catch (_a) {\n        // Sometimes the query selector can be invalid just return it as-is.\n        return parts.join('');\n    }\n    // Try to get a more specific selector if this one matches more than one\n    // element.\n    if (elem.parentNode && elem.parentNode.childNodes.length > 1) {\n        const index = Array.from(elem.parentNode.children).indexOf(elem) + 1;\n        parts.push(`:nth-child(${index})`);\n    }\n    if (self.document.querySelectorAll(parts.join('')).length === 1) {\n        return parts.join('');\n    }\n    // Try prepending the parent element selector\n    if (elem.parentElement) {\n        return `${getNodeSelector(elem.parentElement)} > ${parts.join('')}`;\n    }\n    return parts.join('');\n}\nfunction truncate(value, length) {\n    const ommision = '(...)';\n    return value.length <= length\n        ? value\n        : value.slice(0, length - ommision.length) + ommision;\n}\n\nconst navigationBreadcrumbs = {\n    name: 'navigationBreadcrumbs',\n    load(client) {\n        if (!('addEventListener' in self)) {\n            return;\n        }\n        const drop = (name) => () => client.leaveBreadcrumb(name, undefined, 'navigation');\n        self.addEventListener('pagehide', drop('Page hidden'), true);\n        self.addEventListener('pageshow', drop('Page shown'), true);\n        self.addEventListener('load', drop('Page loaded'), true);\n        if (self.document) {\n            self.document.addEventListener('DOMContentLoaded', drop('DOMContentLoaded'), true);\n        }\n        // Some browsers like to emit popstate when the page loads, so only add the\n        // popstate listener after that\n        self.addEventListener('load', () => self.addEventListener('popstate', drop('Navigated back'), true));\n        // hashchange has some metadata that we care about\n        if (self.location) {\n            self.addEventListener('hashchange', (event) => {\n                const metadata = event.oldURL\n                    ? {\n                        from: relativeLocation(event.oldURL),\n                        to: relativeLocation(event.newURL),\n                        state: getCurrentState(self),\n                    }\n                    : { to: relativeLocation(self.location.href) };\n                client.leaveBreadcrumb('Hash changed', metadata, 'navigation');\n            }, true);\n        }\n        // Wrap replaceState/pushState\n        const leaveBreadcrumb = client.leaveBreadcrumb.bind(client);\n        if (self.history && self instanceof Window) {\n            if (typeof self.history.replaceState === 'function') {\n                wrapHistoryFn({\n                    fn: 'replaceState',\n                    target: self.history,\n                    leaveBreadcrumb,\n                    win: self,\n                });\n            }\n            if (typeof self.history.pushState === 'function') {\n                wrapHistoryFn({\n                    fn: 'pushState',\n                    target: self.history,\n                    leaveBreadcrumb,\n                    win: self,\n                });\n            }\n        }\n    },\n};\n// Takes a full url like http://foo.com:1234/pages/01.html?yes=no#section-2 and\n// returns just the path and hash parts, e.g. /pages/01.html?yes=no#section-2\n//\n// Compatibility: This uses the URL constructor which is not available in IE\n// or Edge < 12.\nfunction relativeLocation(url) {\n    try {\n        const urlObj = new URL(url);\n        return `${urlObj.pathname}${urlObj.search}${urlObj.hash}`;\n    }\n    catch (e) {\n        return url;\n    }\n}\nfunction getCurrentState(win) {\n    try {\n        return win.history.state;\n    }\n    catch (e) {\n        return {};\n    }\n}\nfunction wrapHistoryFn({ fn, leaveBreadcrumb, target, win, }) {\n    const orig = target[fn];\n    target[fn] = (state, title, url) => {\n        leaveBreadcrumb(`History ${fn}`, stateChangeToMetadata({ win, state, title, url }), 'navigation');\n        // TODO: If we implement maxEvents, reset that count here.\n        orig.apply(target, [state, title, url]);\n    };\n}\nfunction stateChangeToMetadata({ win, state, title, url, }) {\n    const currentPath = relativeLocation(win.location.href);\n    return {\n        title,\n        state,\n        prevState: getCurrentState(win),\n        to: url || currentPath,\n        from: currentPath,\n    };\n}\n\nlet appStart = Date.now();\nconst reset = () => {\n    appStart = Date.now();\n};\nconst appDuration = {\n    name: 'appDuration',\n    load(client) {\n        client.addOnError((event) => {\n            const now = Date.now();\n            event.app = event.app || {};\n            event.app.duration = now - appStart;\n        });\n        return { reset };\n    },\n};\n\n// The Bugsnag v5 API requires doing your own UA string parsing, requiring a\n// `browserName`, `browserVersion`, `osName`, `osVersion`, etc.\n//\n// That's very unfriendly and probably why the official client still uses the v4\n// API which takes a `userAgent` parameter and appears to parse it on the\n// server.\n//\n// Nevertheless, we're using the v5 API for now so we should do the parsing\n// ourselves.\n//\n// Note that UA parser libraries typically are very heavyweight since they try\n// to cover every user agent that ever existed including various bots etc.\n//\n// However, all we really care about is differentiating between the most common\n// _browsers_ and their respective platforms / OSes.\n//\n// Furthermore, we want this to be as lightweight as possible so this is very\n// deliberately a very barebones approach. We can add other user agents if and\n// when they become interesting.\n//\n// This is based on\n// https://github.com/DamonOehlman/detect-browser/blob/master/src/index.ts but\n// adapted quite heavily.\nfunction parseUserAgent(userAgent) {\n    const matchedRule = matchUserAgent(userAgent);\n    if (!matchedRule) {\n        return {};\n    }\n    const [name, match] = matchedRule;\n    const os = detectOS(userAgent);\n    const device = (os === null || os === void 0 ? void 0 : os.osName) === 'iOS' ? detectAppleDevice(userAgent) : {};\n    return {\n        browserName: name,\n        browserVersion: match[1],\n        osName: os === null || os === void 0 ? void 0 : os.osName,\n        osVersion: os === null || os === void 0 ? void 0 : os.osVersion,\n        manufacturer: device === null || device === void 0 ? void 0 : device.manufacturer,\n        model: device === null || device === void 0 ? void 0 : device.model,\n    };\n}\nconst userAgentRules = [\n    ['Edge (EdgeHTML)', /Edge\\/([0-9\\._]+)/],\n    ['Edge (iOS)', /EdgiOS\\/([0-9\\._]+)/],\n    ['Yandex', /YaBrowser\\/([0-9\\._]+)/],\n    ['KakaoTalk', /KAKAOTALK\\s([0-9\\.]+)/],\n    ['Samsung', /SamsungBrowser\\/([0-9\\.]+)/],\n    ['Silk', /\\bSilk\\/([0-9._-]+)\\b/],\n    ['MIUI', /MiuiBrowser\\/([0-9\\.]+)$/],\n    ['Beaker', /BeakerBrowser\\/([0-9\\.]+)/],\n    ['Edge (Chromium)', /EdgA?\\/([0-9\\.]+)/],\n    [\n        'Chromium WebView',\n        /(?!Chrom.*OPR)wv\\).*Chrom(?:e|ium)\\/([0-9\\.]+)(:?\\s|$)/,\n    ],\n    ['Chrome', /(?!Chrom.*OPR)Chrom(?:e|ium)\\/([0-9\\.]+)(:?\\s|$)/],\n    ['Chrome (iOS)', /CriOS\\/([0-9\\.]+)(:?\\s|$)/],\n    ['Firefox', /Firefox\\/([0-9\\.]+)(?:\\s|$)/],\n    ['Firefox (iOS)', /FxiOS\\/([0-9\\.]+)/],\n    ['Opera Mini', /Opera Mini.*Version\\/([0-9\\.]+)/],\n    ['Opera', /Opera\\/([0-9\\.]+)(?:\\s|$)/],\n    ['Opera', /OPR\\/([0-9\\.]+)(:?\\s|$)/],\n    ['Internet Explorer', /Trident\\/7\\.0.*rv\\:([0-9\\.]+).*\\).*Gecko$/],\n    ['Internet Explorer', /MSIE\\s([0-9\\.]+);.*Trident\\/[4-7].0/],\n    ['Internet Explorer', /MSIE\\s(7\\.0)/],\n    ['Blackberry', /BB10;\\sTouch.*Version\\/([0-9\\.]+)/],\n    ['Android', /Android\\s([0-9\\.]+)/],\n    ['Safari (iOS)', /Version\\/([0-9\\._]+).*Mobile.*Safari.*/],\n    ['Safari', /Version\\/([0-9\\._]+).*Safari/],\n    ['Facebook', /FB[AS]V\\/([0-9\\.]+)/],\n    ['Instagram', /Instagram\\s([0-9\\.]+)/],\n    ['iOS WebView', /AppleWebKit\\/([0-9\\.]+).*Mobile/],\n    ['iOS WebView', /AppleWebKit\\/([0-9\\.]+).*Gecko\\)$/],\n];\nfunction matchUserAgent(userAgent) {\n    return (userAgent !== '' &&\n        userAgentRules.reduce((matched, [browser, regex]) => {\n            if (matched) {\n                return matched;\n            }\n            const uaMatch = regex.exec(userAgent);\n            return !!uaMatch && [browser, uaMatch];\n        }, false));\n}\nconst operatingSystemRules = [\n    ['iOS', undefined, /iP(hone|od|ad)/],\n    ['Android', undefined, /Android/],\n    ['BlackBerry', undefined, /BlackBerry|BB10/],\n    ['Windows Mobile', undefined, /IEMobile/],\n    ['Kindle', undefined, /Kindle/],\n    ['Windows', '3.11', /Win16/],\n    ['Windows', '95', /(Windows 95)|(Win95)|(Windows_95)/],\n    ['Windows', '98', /(Windows 98)|(Win98)/],\n    ['Windows', '2000', /(Windows NT 5.0)|(Windows 2000)/],\n    ['Windows', 'XP', /(Windows NT 5.1)|(Windows XP)/],\n    ['Windows', 'Server 2003', /(Windows NT 5.2)/],\n    ['Windows', 'Vista', /(Windows NT 6.0)/],\n    ['Windows', '7', /(Windows NT 6.1)/],\n    ['Windows', '8', /(Windows NT 6.2)/],\n    ['Windows', '8.1', /(Windows NT 6.3)/],\n    ['Windows', '10+', /(Windows NT 10.0)/],\n    ['Windows', 'ME', /Windows ME/],\n    ['Open BSD', undefined, /OpenBSD/],\n    ['Sun OS', undefined, /SunOS/],\n    ['Chrome OS', undefined, /CrOS/],\n    ['Linux', undefined, /(Linux)|(X11)/],\n    ['Mac OS', undefined, /(Mac_PowerPC)|(Macintosh)/],\n    ['QNX', undefined, /QNX/],\n    ['BeOS', undefined, /BeOS/],\n    ['OS/2', undefined, /OS\\/2/],\n];\nfunction detectOS(userAgent) {\n    for (const [osName, osVersion, regex] of operatingSystemRules) {\n        const match = regex.exec(userAgent);\n        if (match) {\n            return { osName, osVersion };\n        }\n    }\n    return null;\n}\nfunction detectAppleDevice(userAgent) {\n    const matches = /iPad|iPhone|iPod/.exec(userAgent);\n    if (matches) {\n        return { manufacturer: 'Apple', model: matches[0] };\n    }\n    if (/MacIntel/.test(userAgent) &&\n        self.navigator &&\n        self.navigator.maxTouchPoints &&\n        self.navigator.maxTouchPoints > 2) {\n        return { manufacturer: 'Apple', model: 'iPad' };\n    }\n    return null;\n}\n\nconst browserContextWithUaParser = (uaParser) => {\n    return {\n        name: 'browserContext',\n        load(client) {\n            client.addOnError((event) => {\n                event.request = { ...event.request, url: self.location.href };\n                event.context = event.context || self.location.pathname;\n                event.device = {\n                    ...event.device,\n                    ...uaParser(self.navigator.userAgent),\n                    locale: self.navigator.language,\n                    userAgent: self.navigator.userAgent,\n                };\n                let languages = ['n/a'];\n                try {\n                    languages = self.navigator.languages;\n                }\n                catch (_a) {\n                    /* Ignore */\n                }\n                event.metaData = {\n                    ...event.metaData,\n                    language: {\n                        language: self.navigator.language,\n                        languages,\n                    },\n                };\n            });\n        },\n    };\n};\nconst browserContext = browserContextWithUaParser(parseUserAgent);\n\nconst deviceOrientation = {\n    name: 'deviceOrientation',\n    load(client) {\n        client.addOnError((event) => {\n            let orientation;\n            const screen = self.screen;\n            if (screen && screen.orientation && screen.orientation.type) {\n                orientation = screen.orientation.type;\n            }\n            else if (self.document && self.document.documentElement) {\n                orientation =\n                    self.document.documentElement.clientWidth >\n                        self.document.documentElement.clientHeight\n                        ? 'landscape'\n                        : 'portrait';\n            }\n            if (orientation) {\n                event.device = { ...event.device, orientation };\n            }\n        });\n    },\n};\n\nconst limitEvents = (limit) => {\n    let n = 0;\n    const reset = () => {\n        n = 0;\n    };\n    if (typeof window !== 'undefined') {\n        window.addEventListener('popstate', reset);\n    }\n    return {\n        name: 'limitEvents',\n        load(client) {\n            client.addOnError(function throttle() {\n                if (n >= limit) {\n                    return false;\n                }\n                n++;\n            });\n            return { reset };\n        },\n    };\n};\n\nconst redactKeys = (keys) => ({\n    name: 'redactKeys',\n    load(client) {\n        client.addOnError(function redact(event) {\n            redactObject(event, keys);\n        });\n        return {\n            redactEvent: (event) => redactEvent(event, keys),\n            redactObject: (obj) => redactObject(obj, keys),\n        };\n    },\n});\nfunction redactEvent(event, keys) {\n    event.request = redactObject(event.request, keys);\n    if (event.metaData) {\n        event.metaData = redactObject(event.metaData, keys);\n    }\n    if (event.breadcrumbs) {\n        event.breadcrumbs = event.breadcrumbs.map((breadcrumb) => ({\n            ...breadcrumb,\n            metaData: redactObject(breadcrumb.metaData, keys),\n        }));\n    }\n    return event;\n}\nfunction redactObject(object, keys) {\n    // The following cast isn't strictly correct since by redacting we could be\n    // changing the type but it's good enough for our purposes.\n    return safeFilter(object, (key, value) => {\n        return typeof key === 'string' && keys.includes(key) ? '[REDACTED]' : value;\n    });\n}\n\nfunction stringify(input, options) {\n    return safeFilter(input, (_key, value) => {\n        if (value === CircularReference) {\n            return '[Circular]';\n        }\n        if (value === AccessError) {\n            return '[Error]';\n        }\n        if (typeof value === 'bigint' ||\n            typeof value === 'symbol' ||\n            value instanceof RegExp) {\n            return safeAccess(() => value.toString());\n        }\n        if (value instanceof Map) {\n            return {\n                type: 'Map',\n                value: safeAccess(() => [...value.entries()]),\n            };\n        }\n        if (value instanceof Set) {\n            return {\n                type: 'Set',\n                value: safeAccess(() => [...value.values()]),\n            };\n        }\n        if (typeof value === 'function') {\n            return safeAccess(() => truncateString(value.toString().replace(/\\s+/g, ' '), 50));\n        }\n        if (value instanceof Error) {\n            const replacement = {};\n            for (const key of Object.getOwnPropertyNames(value)) {\n                replacement[key] = safeAccess(() => value[key]);\n            }\n            return replacement;\n        }\n        if (value instanceof ArrayBuffer) {\n            return `ArrayBuffer(${value.byteLength})`;\n        }\n        return value;\n    }, options);\n}\nfunction truncateString(input, maxLength) {\n    return input.length > maxLength\n        ? input.substring(0, maxLength - 3) + '...'\n        : input;\n}\n\n/**\n * Plugin to try to stringify various unserializable JS objects (e.g. bigints,\n * Maps, Sets, functions, Error objects, Regexps) in Bugsnag events.\n */\nconst stringifyValues = {\n    name: 'stringifyValues',\n    load(client) {\n        client.addOnError(function stringifyValues(event) {\n            if (event.metaData) {\n                event.metaData = stringify(event.metaData);\n            }\n            if (event.breadcrumbs) {\n                event.breadcrumbs = event.breadcrumbs.map((breadcrumb) => ({\n                    ...breadcrumb,\n                    metaData: stringify(breadcrumb.metaData),\n                }));\n            }\n        });\n    },\n};\n\n// Auto-detect errors\nfunction fromLegacyConfig(input) {\n    const legacyConfig = typeof input === 'string' ? { apiKey: input } : input;\n    const plugins = legacyConfig.plugins || [];\n    // Auto-detect errors\n    const { autoDetectErrors, enabledErrorTypes } = legacyConfig;\n    if (autoDetectErrors !== false &&\n        (enabledErrorTypes === null || enabledErrorTypes === void 0 ? void 0 : enabledErrorTypes.unhandledExceptions) !== false) {\n        plugins.push(browserNotifyUnhandledExceptions);\n    }\n    if (autoDetectErrors !== false &&\n        (enabledErrorTypes === null || enabledErrorTypes === void 0 ? void 0 : enabledErrorTypes.unhandledRejections) !== false) {\n        plugins.push(browserNotifyUnhandledRejections);\n    }\n    // Breadcrumbs\n    const { enabledBreadcrumbTypes } = legacyConfig;\n    const breadcrumbEnabled = (breadcrumb) => typeof enabledBreadcrumbTypes === 'undefined' ||\n        (Array.isArray(enabledBreadcrumbTypes) &&\n            enabledBreadcrumbTypes.includes(breadcrumb));\n    if (breadcrumbEnabled('request')) {\n        plugins.push(fetchBreadcrumbs);\n    }\n    if (breadcrumbEnabled('navigation')) {\n        plugins.push(navigationBreadcrumbs);\n    }\n    if (breadcrumbEnabled('user')) {\n        plugins.push(interactionBreadcrumbs);\n    }\n    const { releaseStage } = legacyConfig;\n    const isDev = (releaseStage && releaseStage === 'dev') || releaseStage === 'development';\n    if (!isDev && breadcrumbEnabled('log')) {\n        plugins.push(consoleBreadcrumbs);\n    }\n    if (breadcrumbEnabled('error')) {\n        plugins.push(errorBreadcrumbs);\n    }\n    // Other plugins\n    plugins.push(appDuration);\n    if (typeof self.navigator !== 'undefined') {\n        plugins.push(browserContext);\n    }\n    plugins.push(deviceOrientation);\n    plugins.push(limitEvents(legacyConfig.maxEvents || 10));\n    plugins.push(stringifyValues);\n    const keys = legacyConfig.redactedKeys || ['password'];\n    if (keys.length) {\n        plugins.push(redactKeys(keys));\n    }\n    // We don't currently include the onHandledRejectionLogger by default because\n    // it's something new to bugsnag-zero that's not in the official client and a\n    // lot of applications probably don't want it.\n    return {\n        ...legacyConfig,\n        plugins,\n    };\n}\n\nconst browserHandledRejectionBreadcrumbs = {\n    name: 'browserHandledRejectionBreadcrumbs',\n    load(client) {\n        self.addEventListener('rejectionhandled', (evt) => {\n            const error = evt.reason;\n            const { exception } = toException(error, 'handledrejection');\n            const message = `Handled Promise rejection: [${exception.errorClass}] ${exception.message}`;\n            client.leaveBreadcrumb(message, { stacktrace: exception.stacktrace }, 'error');\n        });\n    },\n};\n\nconst nodeNotifyUnhandledRejections = {\n    name: 'nodeNotifyUnhandledRejections',\n    load(client) {\n        process.prependListener('unhandledRejection', (reason, promise) => {\n            const { exception, metadata } = toException(reason, 'unhandledrejection');\n            client.notifyEvent({\n                exceptions: [exception],\n                unhandled: true,\n                severity: 'error',\n                severityReason: {\n                    type: 'unhandledPromiseRejection',\n                },\n                metadata: { ...metadata, promise },\n            }, reason);\n        });\n    },\n};\n\nconst nodeNotifyUnhandledExceptions = {\n    name: 'nodeNotifyUnhandledExceptions',\n    load(client) {\n        process.on('uncaughtException', (error, origin) => {\n            const { exception, metadata } = toException(error, 'uncaughtException');\n            client.notifyEvent({\n                exceptions: [exception],\n                unhandled: true,\n                severity: 'error',\n                severityReason: {\n                    type: 'unhandledException',\n                },\n                metadata: { ...metadata, origin },\n            }, error);\n        });\n    },\n};\n\n// ------------------------------------------------------------------------\n//\n// Public interface\n//\n// ------------------------------------------------------------------------\n// The typing in this is incredibly convoluted because we want to:\n//\n// 1. Avoid introducing a dependency on React\n// 2. Allow users to easily substitute in Preact instead.\n//\n// Hence we basically have these type definitions that represent the minimal\n// subset of what we need from React.\n//\n// This means the call site needs to define a few parameters themselves.\n//\n// e.g. for Preact we'd have something like:\n//\n//   const MyBugsnagErrorBoundary = React.useMemo(\n//     () =>\n//       Bugsnag.getPlugin('react')!.createErrorBoundary<\n//         ComponentType,\n//         VNode,\n//         ComponentType<ErrorBoundaryProps<ComponentType<FallbackComponentProps>>>\n//       >(React.Component, React.createElement),\n//     []\n//   );\n//\n// I'm not sure about React-proper, however.\n//\n// This would be a lot simpler with higher-kinded types.\n// Unlike the official client, we don't allow passing in React to the\n// constructor. Instead we always require a call to createErrorBoundary.\nconst ReactPlugin = {\n    name: 'react',\n    load(client) {\n        return {\n            createErrorBoundary: (component, createElement) => {\n                return createClass(client, component, createElement);\n            },\n        };\n    },\n};\nfunction createClass(client, component, createElement) {\n    class BugsnagErrorBoundaryComponent extends component {\n        constructor(...args) {\n            super(args);\n            this.state = {\n                error: undefined,\n                info: undefined,\n            };\n            this.handleClearError = this.handleClearError.bind(this);\n        }\n        handleClearError() {\n            this.setState({ error: undefined, info: undefined });\n        }\n        componentDidCatch(error, info) {\n            const { exception, metadata } = toException(error, 'notify');\n            if (info && info.componentStack) {\n                info.componentStack = formatComponentStack(info.componentStack);\n            }\n            const { onError } = this.props;\n            client.notifyEvent({\n                exceptions: [exception],\n                unhandled: true,\n                severity: 'error',\n                severityReason: {\n                    type: 'unhandledException',\n                },\n                metadata: { ...metadata, react: info },\n                onError,\n            }, error);\n            this.setState({ error, info });\n        }\n        render() {\n            const { error } = this.state;\n            if (error) {\n                const { FallbackComponent } = this.props;\n                if (FallbackComponent) {\n                    return createElement(FallbackComponent, {\n                        ...this.state,\n                        clearError: this.handleClearError,\n                    });\n                }\n                return null;\n            }\n            return this.props.children;\n        }\n    }\n    return BugsnagErrorBoundaryComponent;\n}\nfunction formatComponentStack(str) {\n    const lines = str.split(/\\s*\\n\\s*/g);\n    let ret = '';\n    for (let line = 0, len = lines.length; line < len; line++) {\n        if (lines[line].length)\n            ret += `${ret.length ? '\\n' : ''}${lines[line]}`;\n    }\n    return ret;\n}\n\nclass BugsnagStatic {\n    constructor() {\n        this.breadcrumbs = [];\n        this.delivery = new FetchDelivery(this);\n        this.errorCallbacks = new Set();\n        this.postErrorCallbacks = new Set();\n        this.plugins = [];\n    }\n    start(config) {\n        if (this.config) {\n            console.error('Bugsnag.start called multiple times. Subsequent invocations will be ignored');\n            return this;\n        }\n        this.config = config;\n        let errorCallbacks = undefined;\n        if (this.config.onError) {\n            errorCallbacks =\n                typeof this.config.onError === 'function'\n                    ? [this.config.onError]\n                    : this.config.onError;\n        }\n        this.errorCallbacks = new Set(errorCallbacks);\n        for (const plugin of this.config.plugins || []) {\n            this.plugins.push({\n                name: plugin.name || 'unknown',\n                plugin: plugin.load(this),\n            });\n        }\n        this.leaveBreadcrumb('Bugsnag loaded', {}, 'state');\n        return this;\n    }\n    get endpoints() {\n        var _a, _b;\n        return {\n            notify: ((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.endpoints) === null || _b === void 0 ? void 0 : _b.notify) || 'https://notify.bugsnag.com/',\n        };\n    }\n    notify(error, options = {}) {\n        let { exception, metadata } = toException(error, 'notify');\n        let onError;\n        let severity;\n        if (typeof options === 'function') {\n            onError = options;\n        }\n        else {\n            severity = options.severity;\n            if (options.metadata) {\n                metadata = { ...metadata, ...options.metadata };\n            }\n        }\n        return this.notifyEvent({\n            exceptions: [exception],\n            metadata,\n            severity,\n            onError,\n        }, error);\n    }\n    leaveBreadcrumb(message, metadata, type) {\n        if (!this.config) {\n            // The official bugsnag client will produce a console eror in this case\n            // but that's annoying since often unit tests will exercise code that\n            // calls notify/leaveBreadcrumb and we don't want to have to either:\n            //\n            // (a) wrap each call to bugsnag in an \"isTest\" conditional, or\n            // (b) ensure the bugsnag client is initialized at the start of each\n            //     test\n            return;\n        }\n        // It appears we sometimes get non-string `message` values here.\n        if (typeof message !== 'string') {\n            try {\n                message = String(message);\n            }\n            catch (_a) {\n                message = 'Unable to stringify breadcrumb message';\n            }\n        }\n        if (!message.length) {\n            return;\n        }\n        this.breadcrumbs.push({\n            name: message,\n            metaData: metadata,\n            type: type || 'manual',\n            timestamp: new Date().toISOString(),\n        });\n        const { maxBreadcrumbs = 25 } = this.config;\n        if (this.breadcrumbs.length > maxBreadcrumbs) {\n            this.breadcrumbs.splice(0, this.breadcrumbs.length - maxBreadcrumbs);\n        }\n    }\n    async notifyEvent({ exceptions, unhandled, severity, severityReason, metadata, onError, }, originalError) {\n        if (!this.config) {\n            // The official bugsnag client will produce a console eror in this case\n            // but that's annoying since often unit tests will exercise code that\n            // calls notify/leaveBreadcrumb and we don't want to have to either:\n            //\n            // (a) wrap each call to bugsnag in an \"isTest\" conditional, or\n            // (b) ensure the bugsnag client is initialized at the start of each\n            //     test\n            return;\n        }\n        // Check if the current release stage is enabled\n        const releaseStage = this.config.releaseStage || 'production';\n        if (this.config.enabledReleaseStages &&\n            !this.config.enabledReleaseStages.includes(releaseStage)) {\n            return;\n        }\n        const event = {\n            exceptions,\n            breadcrumbs: this.breadcrumbs.length ? this.breadcrumbs : undefined,\n            originalError,\n            unhandled: typeof unhandled !== 'boolean' ? false : unhandled,\n            severity: severity || 'warning',\n            severityReason,\n            user: this.config.user || undefined,\n            app: {\n                releaseStage,\n                version: this.config.appVersion,\n                type: this.config.appType ||\n                    (typeof window === 'object' ? 'browser' : 'node'),\n            },\n            device: { time: new Date().toISOString() },\n            metaData: metadata || {},\n        };\n        // Error callbacks\n        const errorCallbacks = [...this.errorCallbacks];\n        if (onError) {\n            errorCallbacks.push(onError);\n        }\n        // Make sure the redact and stringifyValues callbacks come last\n        const sortLast = ['stringifyValues', 'redact'];\n        errorCallbacks.sort((a, b) => {\n            if (sortLast.includes(a.name) && sortLast.includes(b.name)) {\n                return 0;\n            }\n            else if (sortLast.includes(a.name)) {\n                return 1;\n            }\n            else if (sortLast.includes(b.name)) {\n                return -1;\n            }\n            else {\n                return 0;\n            }\n        });\n        for (const callback of errorCallbacks) {\n            const callbackResult = await callback(event);\n            if (typeof callbackResult === 'boolean' && !callbackResult) {\n                return;\n            }\n        }\n        const notifier = {\n            name: '@birchill/bugsnag-zero',\n            version: '1',\n            url: 'https://github.com/birchill/bugsnag-zero',\n        };\n        const eventForDelivery = safeFilter(event, (key, value) => {\n            if (key === 'originalError') {\n                return undefined;\n            }\n            return value;\n        }, { depthLimit: 20, edgesLimit: 500 });\n        let body;\n        const payload = {\n            apiKey: this.config.apiKey,\n            payloadVersion: '5',\n            notifier,\n            events: [eventForDelivery],\n        };\n        try {\n            body = JSON.stringify(payload);\n        }\n        catch (_a) {\n            eventForDelivery.metaData = {\n                notifier: 'Unable to serialize metadata',\n            };\n            body = JSON.stringify(payload);\n        }\n        // Check the size of the payload\n        if (body.length > 10e5) {\n            eventForDelivery.metaData = {\n                notifier: `Payload was ${body.length / 10e5}Mb. Metadata removed.`,\n            };\n            body = JSON.stringify(payload);\n            if (body.length > 10e5) {\n                throw new Error('Payload exceeded 1Mb limit');\n            }\n        }\n        // Although it's called \"post error\" we run these callbacks before we\n        // actually send the event over the network since sending is async and if\n        // the callback is logging the fact that an error was recorded then we want\n        // that log entry to appear in the correct sequence, particularly if other\n        // things take place while the fetch is still happenning.\n        for (const callback of this.postErrorCallbacks) {\n            callback(event);\n        }\n        try {\n            await this.delivery.sendEvent(payload);\n        }\n        catch (e) {\n            console.error('Failed to post report to Bugsnag', e);\n        }\n    }\n    getUser() {\n        var _a;\n        return ((_a = this.config) === null || _a === void 0 ? void 0 : _a.user) || {};\n    }\n    setUser(id, email, name) {\n        if (!this.config) {\n            return;\n        }\n        this.config.user = { id, email, name };\n    }\n    addOnError(fn) {\n        this.errorCallbacks.add(fn);\n    }\n    removeOnError(fn) {\n        this.errorCallbacks.delete(fn);\n    }\n    addOnPostError(fn) {\n        this.postErrorCallbacks.add(fn);\n    }\n    removeOnPostError(fn) {\n        this.postErrorCallbacks.delete(fn);\n    }\n    getPlugin(name) {\n        var _a;\n        return (_a = this.plugins.find((plugin) => plugin.name === name)) === null || _a === void 0 ? void 0 : _a.plugin;\n    }\n    setDelivery(delivery) {\n        this.delivery = delivery;\n    }\n}\nconst Bugsnag = new BugsnagStatic();\n\nexport { FetchDelivery, ReactPlugin, appDuration, browserContext, browserContextWithUaParser, browserHandledRejectionBreadcrumbs, browserNotifyUnhandledExceptions, browserNotifyUnhandledRejections, consoleBreadcrumbs, Bugsnag as default, deviceOrientation, errorBreadcrumbs, fetchBreadcrumbs, fromLegacyConfig, interactionBreadcrumbs, limitEvents, navigationBreadcrumbs, nodeNotifyUnhandledExceptions, nodeNotifyUnhandledRejections, redactEvent, redactKeys, redactObject, stringifyValues };\n//# sourceMappingURL=index.js.map\n","import Bugsnag, { Client,\n\tbrowserContext,\n\tbrowserHandledRejectionBreadcrumbs,\n\tbrowserNotifyUnhandledExceptions,\n\tbrowserNotifyUnhandledRejections,\n\tconsoleBreadcrumbs,\n\terrorBreadcrumbs,\n\tlimitEvents,\n\tstringifyValues } from '@birchill/bugsnag-zero';\n\nconst metaValue = ( name: string ): string | null => {\n\tif ( !document || !document.head ) {\n\t\treturn null;\n\t}\n\n\tconst metaTag: HTMLMetaElement | null = document.head.querySelector( 'meta[name=\"' + name + '\"][content]' );\n\tif ( !metaTag || !metaTag.content ) {\n\t\treturn null;\n\t}\n\n\treturn metaTag.content;\n};\n\nexport const bugsnagClient = Bugsnag.start( {\n\tapiKey: metaValue( 'mrh:bugsnag' ) || '',\n\tappType: metaValue( 'mrh:theme' ) || 'unknown theme',\n\tcollectUserIp: false,\n\tenabledReleaseStages: [\n\t\t'production',\n\t],\n\treleaseStage: metaValue( 'mrh:stage' ) || 'production',\n\tplugins: [\n\t\tbrowserContext,\n\t\tbrowserHandledRejectionBreadcrumbs,\n\t\tbrowserNotifyUnhandledExceptions,\n\t\tbrowserNotifyUnhandledRejections,\n\t\tconsoleBreadcrumbs,\n\t\terrorBreadcrumbs,\n\t\tlimitEvents( 10 ),\n\t\tstringifyValues,\n\t],\n\tonError: ( event ) => {\n\t\t// Ignore bogus Outlook error\n\t\tif ( `${event.metaData?.unhandledrejection}`.includes( 'Object Not Found Matching Id' ) ) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Update Context\n\t\tconst theme = metaValue( 'mrh:theme' );\n\t\tif ( theme ) {\n\t\t\tevent.context = event.context + ' - ' + theme;\n\t\t}\n\n\t\t// Update Meta Data\n\t\tconst id = metaValue( 'mrh:id' );\n\t\tif ( id && theme ) {\n\t\t\tevent.metaData = event.metaData || {};\n\t\t\tevent.metaData.site = {\n\t\t\t\tid: id,\n\t\t\t\ttheme: theme,\n\t\t\t};\n\t\t}\n\n\t\tconst target = metaValue( 'mrh:browser-target' );\n\t\tif ( target ) {\n\t\t\tevent.metaData = event.metaData || {};\n\t\t\tevent.metaData['js-bundle'] = {\n\t\t\t\ttarget: target,\n\t\t\t};\n\t\t}\n\t},\n} );\n\ndeclare global {\n\tinterface Window {\n\t\tbugsnagClient: Client\n\t}\n}\n\nwindow.bugsnagClient = bugsnagClient;\n"],"names":["isCallable","tryToString","$TypeError","TypeError","module","exports","argument","wellKnownSymbol","create","defineProperty","UNSCOPABLES","ArrayPrototype","Array","prototype","undefined","configurable","value","key","isObject","$String","String","toIndexedObject","toAbsoluteIndex","lengthOfArrayLike","createMethod","IS_INCLUDES","$this","el","fromIndex","O","length","index","includes","indexOf","uncurryThis","toString","stringSlice","slice","it","hasOwn","ownKeys","getOwnPropertyDescriptorModule","definePropertyModule","target","source","exceptions","keys","f","getOwnPropertyDescriptor","i","DESCRIPTORS","createPropertyDescriptor","object","bitmap","enumerable","writable","makeBuiltIn","defineGlobalProperty","options","simple","name","global","unsafe","error","nonConfigurable","nonWritable","Object","fails","get","document","EXISTS","createElement","navigator","userAgent","match","version","process","Deno","versions","v8","split","createNonEnumerableProperty","defineBuiltIn","copyConstructorProperties","isForced","targetProperty","sourceProperty","descriptor","TARGET","GLOBAL","STATIC","stat","dontCallGetSet","forced","sham","exec","test","bind","hasOwnProperty","NATIVE_BIND","call","Function","apply","arguments","FunctionPrototype","getDescriptor","PROPER","CONFIGURABLE","uncurryThisWithBind","fn","namespace","method","aCallable","isNullOrUndefined","V","P","func","check","Math","globalThis","window","self","g","this","toObject","getBuiltIn","a","classof","$Object","propertyIsEnumerable","store","functionToString","inspectSource","set","has","NATIVE_WEAK_MAP","shared","sharedKey","hiddenKeys","OBJECT_ALREADY_INITIALIZED","WeakMap","state","metadata","facade","STATE","enforce","getterFor","TYPE","type","documentAll","all","replacement","feature","detection","data","normalize","POLYFILL","NATIVE","string","replace","toLowerCase","isPrototypeOf","USE_SYMBOL_AS_UID","$Symbol","toLength","obj","CONFIGURABLE_FUNCTION_NAME","InternalStateModule","enforceInternalState","getInternalState","join","CONFIGURABLE_LENGTH","TEMPLATE","getter","setter","arity","constructor","ceil","floor","trunc","x","n","activeXDocument","anObject","definePropertiesModule","enumBugKeys","html","documentCreateElement","PROTOTYPE","SCRIPT","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObjectViaActiveX","write","close","temp","parentWindow","NullProtoObject","ActiveXObject","iframeDocument","iframe","JS","domain","style","display","appendChild","src","contentWindow","open","F","Properties","result","V8_PROTOTYPE_DEFINE_BUG","objectKeys","defineProperties","props","IE8_DOM_DEFINE","toPropertyKey","$defineProperty","$getOwnPropertyDescriptor","ENUMERABLE","WRITABLE","Attributes","current","propertyIsEnumerableModule","internalObjectKeys","concat","getOwnPropertyNames","getOwnPropertySymbols","push","names","$propertyIsEnumerable","NASHORN_BUG","input","pref","val","valueOf","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","uid","IS_PURE","SHARED","mode","copyright","license","V8_VERSION","symbol","Symbol","toIntegerOrInfinity","max","min","integer","IndexedObject","requireObjectCoercible","number","len","isSymbol","getMethod","ordinaryToPrimitive","TO_PRIMITIVE","exoticToPrim","toPrimitive","id","postfix","random","NATIVE_SYMBOL","iterator","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","$","$includes","addToUnscopables","proto","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","e","FetchDelivery","client","sendEvent","apiKey","events","notifier","payloadVersion","sentAt","Date","toISOString","body","JSON","stringify","fetch","endpoints","notify","credentials","headers","referrerPolicy","CircularReference","AccessError","safeFilter","replacer","filter","seen","depth","depthLimit","edgeIndex","edgesLimit","Infinity","toJSON","hasToJson","safeAccess","isArray","copy","limit","item","currentKey","pop","accessor","_a","objectToString","getPrototypeOf","CHROME_IE_STACK_REGEXP","SAFARI_NATIVE_CODE_REGEXP","extractLocation","urlLike","parts","line","parseInt","col","toException","maybeError","component","Error","err","isError","getStringMember","field","message","newError","fromSimpleError","normalizeError","exception","errorClass","stacktrace","getStacktrace","stackString","stack","getStackString","map","sanitizedLine","location","tokens","locationParts","file","lineNumber","columnNumber","parseV8OrIE","functionNameRegex","matches","parseFFOrSafari","reduce","parseStack","curr","callee","_e","MAX_STACK_SIZE","RegExp","$1","caller","generateBacktrace","browserNotifyUnhandledExceptions","load","addEventListener","evt","_b","ErrorEvent","filename","lineno","colno","Number","isSafeInteger","console","log","firstStackFrame","notifyEvent","unhandled","severity","severityReason","browserNotifyUnhandledRejections","reason","consoleBreadcrumbs","methodsToHook","original","args","leaveBreadcrumb","arg","stringified","errorBreadcrumbs","addOnPostError","event","errorMessage","now","userAgentRules","operatingSystemRules","browserContext","uaParser","matchedRule","matched","browser","regex","uaMatch","matchUserAgent","os","osName","osVersion","detectOS","device","manufacturer","model","maxTouchPoints","detectAppleDevice","browserName","browserVersion","addOnError","request","url","href","context","pathname","locale","language","languages","metaData","_key","Map","entries","Set","values","maxLength","substring","truncateString","ArrayBuffer","byteLength","stringifyValues","breadcrumbs","breadcrumb","browserHandledRejectionBreadcrumbs","Bugsnag","delivery","errorCallbacks","postErrorCallbacks","plugins","start","config","onError","plugin","timestamp","maxBreadcrumbs","splice","originalError","releaseStage","enabledReleaseStages","user","app","appVersion","appType","time","sortLast","sort","b","callback","callbackResult","eventForDelivery","payload","getUser","setUser","email","add","removeOnError","delete","removeOnPostError","getPlugin","find","setDelivery","metaValue","head","metaTag","querySelector","bugsnagClient","collectUserIp","reset","limitEvents","_event$metaData","unhandledrejection","theme","site"],"sourceRoot":""}