{"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/enum-bug-keys.js","/node_modules/core-js/internals/environment-user-agent.js","/node_modules/core-js/internals/environment-v8-version.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-this.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 globalThis = require('../internals/global-this');\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(globalThis, key, { value: value, configurable: true, writable: true });\n  } catch (error) {\n    globalThis[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 globalThis = require('../internals/global-this');\nvar isObject = require('../internals/is-object');\n\nvar document = globalThis.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';\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 globalThis = require('../internals/global-this');\n\nvar navigator = globalThis.navigator;\nvar userAgent = navigator && navigator.userAgent;\n\nmodule.exports = userAgent ? String(userAgent) : '';\n","'use strict';\nvar globalThis = require('../internals/global-this');\nvar userAgent = require('../internals/environment-user-agent');\n\nvar process = globalThis.process;\nvar Deno = globalThis.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';\nvar globalThis = require('../internals/global-this');\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 = globalThis;\n  } else if (STATIC) {\n    target = globalThis[TARGET] || defineGlobalProperty(TARGET, {});\n  } else {\n    target = globalThis[TARGET] && globalThis[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 globalThis = require('../internals/global-this');\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(globalThis[namespace]) : globalThis[namespace] && globalThis[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 globalThis = require('../internals/global-this');\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 = globalThis.TypeError;\nvar WeakMap = globalThis.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  // eslint-disable-next-line no-useless-assignment -- avoid memory leak\n  activeXDocument = null;\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-this');\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.38.1',\n  mode: IS_PURE ? 'pure' : 'global',\n  copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',\n  license: 'https://github.com/zloirock/core-js/blob/v3.38.1/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/environment-v8-version');\nvar fails = require('../internals/fails');\nvar globalThis = require('../internals/global-this');\n\nvar $String = globalThis.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 globalThis = require('../internals/global-this');\nvar isCallable = require('../internals/is-callable');\n\nvar WeakMap = globalThis.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));\n","'use strict';\nvar globalThis = require('../internals/global-this');\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 = globalThis.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    client;\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?.depthLimit,\n        edgeIndex: 0,\n        edgesLimit: 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 {\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 toExceptions(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    const exceptions = [makeException(error)];\n    // Add any causes\n    exceptions.push(...getCauses(error).map((cause) => makeException(cause, { backtrace: false })));\n    return { exceptions, metadata };\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 makeException(error, stackOptions = { backtrace: false }) {\n    return {\n        errorClass: error.name,\n        message: error.message,\n        stacktrace: getStacktrace(error, stackOptions),\n        type: typeof self === 'object' && self.navigator\n            ? 'browserjs'\n            : 'nodejs',\n    };\n}\nfunction getStacktrace(error, { backtrace }) {\n    const stackString = getStackString(error);\n    if (stackString) {\n        return parseStack(stackString);\n    }\n    else if (backtrace) {\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    else {\n        return [];\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    let curr;\n    try {\n        // eslint-disable-next-line no-caller\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}\nfunction getCauses(error) {\n    if (!error.cause) {\n        return [];\n    }\n    const cause = normalizeError(error.cause, 'cause');\n    if (cause.name === 'InvalidError') {\n        return [];\n    }\n    return [cause].concat(getCauses(cause));\n}\n\nconst browserNotifyUnhandledExceptions = {\n    name: 'browserNotifyUnhandledExceptions',\n    load(client) {\n        self.addEventListener('error', (evt) => {\n            let exceptions;\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                ({ exceptions, metadata } = toExceptions(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 } = exceptions[0];\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 = firstStackFrame.lineNumber ?? lineNumber;\n                    firstStackFrame.columnNumber =\n                        firstStackFrame.columnNumber ?? columnNumber;\n                }\n            }\n            else {\n                ({ exceptions, metadata } = toExceptions(evt, 'window onerror'));\n            }\n            client.notifyEvent({\n                exceptions,\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 { exceptions, metadata } = toExceptions(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,\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    return truncate(text.trim(), 140);\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 {\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?.osName === 'iOS' ? detectAppleDevice(userAgent) : {};\n    return {\n        browserName: name,\n        browserVersion: match[1],\n        osName: os?.osName,\n        osVersion: os?.osVersion,\n        manufacturer: device?.manufacturer,\n        model: 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    ['Chromium WebView', /(?!Chrom.*OPR)wv\\).*Chrom(?:e|ium)\\/([0-9.]+)(:?\\s|$)/],\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 {\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?.unhandledExceptions !== false) {\n        plugins.push(browserNotifyUnhandledExceptions);\n    }\n    if (autoDetectErrors !== false &&\n        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 { exceptions } = toExceptions(error, 'handledrejection');\n            const message = `Handled Promise rejection: [${exceptions[0].errorClass}] ${exceptions[0].message}`;\n            client.leaveBreadcrumb(message, { stacktrace: exceptions[0].stacktrace }, 'error');\n        });\n    },\n};\n\nconst nodeNotifyUnhandledRejections = {\n    name: 'nodeNotifyUnhandledRejections',\n    load(client) {\n        process.prependListener('unhandledRejection', (reason, promise) => {\n            const { exceptions, metadata } = toExceptions(reason, 'unhandledrejection');\n            client.notifyEvent({\n                exceptions,\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 { exceptions, metadata } = toExceptions(error, 'uncaughtException');\n            client.notifyEvent({\n                exceptions,\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 { exceptions, metadata } = toExceptions(error, 'notify');\n            if (info && info.componentStack) {\n                info.componentStack = formatComponentStack(info.componentStack);\n            }\n            const { onError } = this.props;\n            client.notifyEvent({\n                exceptions,\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\n// eslint-disable-next-line typescript-eslint(no-unsafe-declaration-merging)\nclass BugsnagStatic {\n    breadcrumbs = [];\n    config;\n    delivery = new FetchDelivery(this);\n    errorCallbacks = new Set();\n    postErrorCallbacks = new Set();\n    plugins = [];\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        return {\n            notify: this.config?.endpoints?.notify || 'https://notify.bugsnag.com/',\n        };\n    }\n    notify(error, options = {}) {\n        let { exceptions, metadata } = toExceptions(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,\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 {\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 {\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        return this.config?.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        return this.plugins.find((plugin) => plugin.name === name)?.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\tif ( event.exceptions.some( ( x ) => {\n\t\t\tif ( !x.message ) {\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\t// Ignore bogus Outlook error\n\t\t\treturn x.message.includes( 'Object Not Found Matching Id' ) ||\n\t\t\t\t// Ignore bogus Chrome error\n\t\t\t\tx.message.includes( '__gCrWeb' );\n\t\t} ) ) {\n\t\t\treturn false;\n\t\t}\n\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","globalThis","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","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","objectToString","getPrototypeOf","ERROR_TYPE","CHROME_IE_STACK_REGEXP","SAFARI_NATIVE_CODE_REGEXP","extractLocation","urlLike","parts","line","parseInt","col","toExceptions","maybeError","component","normalizeError","makeException","getCauses","map","cause","backtrace","Error","err","isError","getStringMember","field","message","newError","fromSimpleError","stackOptions","errorClass","stacktrace","getStacktrace","stackString","stack","getStackString","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","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","substring","maxLength","truncateString","ArrayBuffer","byteLength","stringifyValues","breadcrumbs","breadcrumb","browserHandledRejectionBreadcrumbs","Bugsnag","config","delivery","errorCallbacks","postErrorCallbacks","plugins","start","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","some","unhandledrejection","theme","site"],"sourceRoot":""}