{"version":3,"sources":["webpack:///./node_modules/@sentry/browser/esm/eventbuilder.js","webpack:///./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack:///./node_modules/@sentry/browser/esm/transports/utils.js","webpack:///./node_modules/@sentry/browser/esm/client.js","webpack:///./node_modules/@sentry/browser/esm/helpers.js","webpack:///./node_modules/@sentry/browser/esm/stack-parsers.js","webpack:///./node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack:///./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack:///./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack:///./node_modules/@sentry/browser/esm/integrations/dedupe.js","webpack:///./node_modules/@sentry/browser/esm/integrations/httpcontext.js","webpack:///./node_modules/@sentry/browser/esm/transports/fetch.js","webpack:///./node_modules/@sentry/browser/esm/transports/xhr.js","webpack:///./node_modules/@sentry/browser/esm/sdk.js"],"names":["exceptionFromError","stackParser","ex","frames","parseStackFrames","exception","type","name","value","extractMessage","length","stacktrace","undefined","eventFromPlainObject","syntheticException","isUnhandledRejection","event","values","is","constructor","extra","__serialized__","normalize","eventFromError","stack","popSize","getPopSize","e","reactMinifiedRegexp","framesToPop","test","message","error","eventFromException","hint","attachStacktrace","eventFromUnknownInput","level","event_id","eventFromMessage","eventFromString","errorEvent","domException","tags","code","objectException","synthetic","input","BREADCRUMB_INTEGRATION_ID","this","id","options","prototype","__init","call","console","dom","fetch","history","sentry","xhr","_consoleBreadcrumb","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","_innerDomBreadcrumb","handlerData","target","keyAttrs","serializeAttribute","addBreadcrumb","category","global","breadcrumb","data","arguments","args","logger","severity","slice","endTimestamp","__sentry_own_request__","method","url","status_code","body","__sentry_xhr__","fetchData","match","response","status","from","to","parsedLoc","location","href","parsedFrom","parsedTo","path","protocol","host","relative","__initStatic","cachedFetchImpl","getNativeFetchImplementation","bind","document","fetchImpl","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","__SENTRY_DEBUG__","warn","sendReport","isRealNavigator","Object","toString","navigator","hasSendBeacon","sendBeacon","supports","credentials","keepalive","then","globalObject","_metadata","sdk","packages","version","super","sendClientReports","addEventListener","visibilityState","_flushOutcomes","_options","breadcrumbIntegration","getIntegrationById","sendEvent","scope","platform","_prepareEvent","outcomes","_clearOutcomes","_dsn","log","envelope","tunnel","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","setTimeout","wrap","fn","before","wrapper","__sentry_wrapped__","sentryWrapped","Array","apply","wrappedArguments","map","arg","addEventProcessor","mechanism","property","hasOwnProperty","_oO","descriptor","getOwnPropertyDescriptor","configurable","defineProperty","UNKNOWN_FUNCTION","CHROME_PRIORITY","WINJS_PRIORITY","GECKO_PRIORITY","createFrame","filename","func","lineno","colno","frame","function","in_app","chromeRegex","chromeEvalRegex","chrome","line","parts","exec","isEval","indexOf","subMatch","extractSafariExtensionDetails","chromeStackLineParser","geckoREgex","geckoEvalRegex","gecko","geckoStackLineParser","winjsRegex","winjs","winjsStackLineParser","defaultStackLineParsers","defaultStackParser","isSafariExtension","isSafariWebExtension","split","DEFAULT_EVENT_TARGET","XMLHttpRequest","eventTarget","requestAnimationFrame","setInterval","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","isArray","forEach","_wrapEventTarget","original","originalCallback","handled","callback","handler","originalSend","xmlHttpRequestProps","prop","wrapOptions","originalFunction","proto","eventName","handleEvent","err","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","GlobalHandlers","_installFunc","onerror","_installGlobalOnErrorHandler","onunhandledrejection","_installGlobalOnUnhandledRejectionHandler","__init2","Error","stackTraceLimit","key","installFunc","globalHandlerLog","hub","getHubAndOptions","getIntegration","msg","column","_eventFromIncompleteOnError","_enhanceEventWithInitialFrame","addMechanismAndCapture","reason","detail","_eventFromRejectionWithPrimitive","String","ERROR_TYPES_RE","groups","ev","ev0","ev0s","ev0sf","isNaN","parseInt","push","captureEvent","originalException","client","getClient","getOptions","DEFAULT_KEY","DEFAULT_LIMIT","_key","_limit","limit","self","_handler","parser","linkedErrors","_walkErrorTree","addGlobalEventProcessor","getCurrentHub","eventProcessor","currentEvent","_shouldDropEvent","_previousEvent","previousEvent","_isSameMessageEvent","_isSameExceptionEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","previousException","_getExceptionFromEvent","currentException","currentFrames","_getFramesFromEvent","previousFrames","i","frameA","frameB","currentFingerprint","fingerprint","previousFingerprint","join","request","referrer","userAgent","headers","Referer","makeFetchTransport","nativeFetch","makeRequest","requestOptions","referrerPolicy","fetchOptions","statusCode","get","XHR_READYSTATE_DONE","makeXHRTransport","resolve","reject","header","onreadystatechange","readyState","getResponseHeader","open","setRequestHeader","send","defaultIntegrations","InboundFilters","FunctionToString","init","release","window","SENTRY_RELEASE","autoSessionTracking","clientOptions","integrations","transport","startSessionTracking","startSessionOnHub","startSession","ignoreDuration","captureSession"],"mappings":"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","file":"js/chunk-vendors~1e017b1d.0888f698.js","sourcesContent":["import { isEvent, extractExceptionKeysForMessage, normalizeToSize, addExceptionMechanism, resolvedSyncPromise, isErrorEvent, isDOMError, isDOMException, addExceptionTypeValue, isError, isPlainObject } from '@sentry/utils';\n\n/**\n * This function creates an exception from a JavaScript Error\n */\nfunction exceptionFromError(stackParser, ex) {\n  // Get the frames first since Opera can lose the stack if we touch anything else first\n  var frames = parseStackFrames(stackParser, ex);\n\n  var exception = {\n    type: ex && ex.name,\n    value: extractMessage(ex),\n  };\n\n  if (frames.length) {\n    exception.stacktrace = { frames };\n  }\n\n  if (exception.type === undefined && exception.value === '') {\n    exception.value = 'Unrecoverable error caught';\n  }\n\n  return exception;\n}\n\n/**\n * @hidden\n */\nfunction eventFromPlainObject(\n  stackParser,\n  exception,\n  syntheticException,\n  isUnhandledRejection,\n) {\n  var event = {\n    exception: {\n      values: [\n        {\n          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n          value: `Non-Error ${\n            isUnhandledRejection ? 'promise rejection' : 'exception'\n          } captured with keys: ${extractExceptionKeysForMessage(exception)}`,\n        },\n      ],\n    },\n    extra: {\n      __serialized__: normalizeToSize(exception),\n    },\n  };\n\n  if (syntheticException) {\n    var frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      // event.exception.values[0] has been set above\n      (event.exception ).values[0].stacktrace = { frames };\n    }\n  }\n\n  return event;\n}\n\n/**\n * @hidden\n */\nfunction eventFromError(stackParser, ex) {\n  return {\n    exception: {\n      values: [exceptionFromError(stackParser, ex)],\n    },\n  };\n}\n\n/** Parses stack frames from an error */\nfunction parseStackFrames(\n  stackParser,\n  ex,\n) {\n  // Access and store the stacktrace property before doing ANYTHING\n  // else to it because Opera is not very good at providing it\n  // reliably in other circumstances.\n  var stacktrace = ex.stacktrace || ex.stack || '';\n\n  var popSize = getPopSize(ex);\n\n  try {\n    return stackParser(stacktrace, popSize);\n  } catch (e) {\n    // no-empty\n  }\n\n  return [];\n}\n\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nvar reactMinifiedRegexp = /Minified React error #\\d+;/i;\n\nfunction getPopSize(ex) {\n  if (ex) {\n    if (typeof ex.framesToPop === 'number') {\n      return ex.framesToPop;\n    }\n\n    if (reactMinifiedRegexp.test(ex.message)) {\n      return 1;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\nfunction extractMessage(ex) {\n  var message = ex && ex.message;\n  if (!message) {\n    return 'No error message';\n  }\n  if (message.error && typeof message.error.message === 'string') {\n    return message.error.message;\n  }\n  return message;\n}\n\n/**\n * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n * @hidden\n */\nfunction eventFromException(\n  stackParser,\n  exception,\n  hint,\n  attachStacktrace,\n) {\n  var syntheticException = (hint && hint.syntheticException) || undefined;\n  var event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);\n  addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n  event.level = 'error';\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * Builds and Event from a Message\n * @hidden\n */\nfunction eventFromMessage(\n  stackParser,\n  message,\n    level = 'info',\n  hint,\n  attachStacktrace,\n) {\n  var syntheticException = (hint && hint.syntheticException) || undefined;\n  var event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n  event.level = level;\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * @hidden\n */\nfunction eventFromUnknownInput(\n  stackParser,\n  exception,\n  syntheticException,\n  attachStacktrace,\n  isUnhandledRejection,\n) {\n  let event;\n\n  if (isErrorEvent(exception ) && (exception ).error) {\n    // If it is an ErrorEvent with `error` property, extract it to get actual Error\n    var errorEvent = exception ;\n    return eventFromError(stackParser, errorEvent.error );\n  }\n\n  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name\n  // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be\n  // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.\n  //\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n  // https://webidl.spec.whatwg.org/#es-DOMException-specialness\n  if (isDOMError(exception ) || isDOMException(exception )) {\n    var domException = exception ;\n\n    if ('stack' in (exception )) {\n      event = eventFromError(stackParser, exception );\n    } else {\n      var name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n      var message = domException.message ? `${name}: ${domException.message}` : name;\n      event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n      addExceptionTypeValue(event, message);\n    }\n    if ('code' in domException) {\n      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };\n    }\n\n    return event;\n  }\n  if (isError(exception)) {\n    // we have a real Error object, do nothing\n    return eventFromError(stackParser, exception);\n  }\n  if (isPlainObject(exception) || isEvent(exception)) {\n    // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize\n    // it manually. This will allow us to group events based on top-level keys which is much better than creating a new\n    // group on any key/value change.\n    var objectException = exception ;\n    event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);\n    addExceptionMechanism(event, {\n      synthetic: true,\n    });\n    return event;\n  }\n\n  // If none of previous checks were valid, then it means that it's not:\n  // - an instance of DOMError\n  // - an instance of DOMException\n  // - an instance of Event\n  // - an instance of Error\n  // - a valid ErrorEvent (one with an error property)\n  // - a plain Object\n  //\n  // So bail out and capture it as a simple message:\n  event = eventFromString(stackParser, exception , syntheticException, attachStacktrace);\n  addExceptionTypeValue(event, `${exception}`, undefined);\n  addExceptionMechanism(event, {\n    synthetic: true,\n  });\n\n  return event;\n}\n\n/**\n * @hidden\n */\nfunction eventFromString(\n  stackParser,\n  input,\n  syntheticException,\n  attachStacktrace,\n) {\n  var event = {\n    message: input,\n  };\n\n  if (attachStacktrace && syntheticException) {\n    var frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      event.exception = {\n        values: [{ value: input, stacktrace: { frames } }],\n      };\n    }\n  }\n\n  return event;\n}\n\nexport { eventFromError, eventFromException, eventFromMessage, eventFromPlainObject, eventFromString, eventFromUnknownInput, exceptionFromError, parseStackFrames };\n//# sourceMappingURL=eventbuilder.js.map\n","import { getCurrentHub } from '@sentry/core';\nimport { addInstrumentationHandler, htmlTreeAsString, severityLevelFromString, safeJoin, getGlobalObject, parseUrl } from '@sentry/utils';\n\n/** JSDoc */\n\nvar BREADCRUMB_INTEGRATION_ID = 'Breadcrumbs';\n\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nclass Breadcrumbs  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = BREADCRUMB_INTEGRATION_ID;}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = Breadcrumbs.id;}\n\n  /**\n   * Options of the breadcrumbs integration.\n   */\n  // This field is public, because we use it in the browser client to check if the `sentry` option is enabled.\n  \n\n  /**\n   * @inheritDoc\n   */\n   constructor(options) {;Breadcrumbs.prototype.__init.call(this);\n    this.options = {\n      console: true,\n      dom: true,\n      fetch: true,\n      history: true,\n      sentry: true,\n      xhr: true,\n      ...options,\n    };\n  }\n\n  /**\n   * Instrument browser built-ins w/ breadcrumb capturing\n   *  - Console API\n   *  - DOM API (click/typing)\n   *  - XMLHttpRequest API\n   *  - Fetch API\n   *  - History API\n   */\n   setupOnce() {\n    if (this.options.console) {\n      addInstrumentationHandler('console', _consoleBreadcrumb);\n    }\n    if (this.options.dom) {\n      addInstrumentationHandler('dom', _domBreadcrumb(this.options.dom));\n    }\n    if (this.options.xhr) {\n      addInstrumentationHandler('xhr', _xhrBreadcrumb);\n    }\n    if (this.options.fetch) {\n      addInstrumentationHandler('fetch', _fetchBreadcrumb);\n    }\n    if (this.options.history) {\n      addInstrumentationHandler('history', _historyBreadcrumb);\n    }\n  }\n} Breadcrumbs.__initStatic();\n\n/**\n * A HOC that creaes a function that creates breadcrumbs from DOM API calls.\n * This is a HOC so that we get access to dom options in the closure.\n */\nfunction _domBreadcrumb(dom) {\n    function _innerDomBreadcrumb(handlerData) {\n    let target;\n    let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;\n\n    if (typeof keyAttrs === 'string') {\n      keyAttrs = [keyAttrs];\n    }\n\n    // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n    try {\n      target = handlerData.event.target\n        ? htmlTreeAsString(handlerData.event.target , keyAttrs)\n        : htmlTreeAsString(handlerData.event , keyAttrs);\n    } catch (e) {\n      target = '<unknown>';\n    }\n\n    if (target.length === 0) {\n      return;\n    }\n\n    getCurrentHub().addBreadcrumb(\n      {\n        category: `ui.${handlerData.name}`,\n        message: target,\n      },\n      {\n        event: handlerData.event,\n        name: handlerData.name,\n        global: handlerData.global,\n      },\n    );\n  }\n\n  return _innerDomBreadcrumb;\n}\n\n/**\n * Creates breadcrumbs from console API calls\n */\nfunction _consoleBreadcrumb(handlerData) {\n  var breadcrumb = {\n    category: 'console',\n    data: {\n      arguments: handlerData.args,\n      logger: 'console',\n    },\n    level: severityLevelFromString(handlerData.level),\n    message: safeJoin(handlerData.args, ' '),\n  };\n\n  if (handlerData.level === 'assert') {\n    if (handlerData.args[0] === false) {\n      breadcrumb.message = `Assertion failed: ${safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;\n      breadcrumb.data.arguments = handlerData.args.slice(1);\n    } else {\n      // Don't capture a breadcrumb for passed assertions\n      return;\n    }\n  }\n\n  getCurrentHub().addBreadcrumb(breadcrumb, {\n    input: handlerData.args,\n    level: handlerData.level,\n  });\n}\n\n/**\n * Creates breadcrumbs from XHR API calls\n */\nfunction _xhrBreadcrumb(handlerData) {\n  if (handlerData.endTimestamp) {\n    // We only capture complete, non-sentry requests\n    if (handlerData.xhr.__sentry_own_request__) {\n      return;\n    }\n\n    const { method, url, status_code, body } = handlerData.xhr.__sentry_xhr__ || {};\n\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'xhr',\n        data: {\n          method,\n          url,\n          status_code,\n        },\n        type: 'http',\n      },\n      {\n        xhr: handlerData.xhr,\n        input: body,\n      },\n    );\n\n    return;\n  }\n}\n\n/**\n * Creates breadcrumbs from fetch API calls\n */\nfunction _fetchBreadcrumb(handlerData) {\n  // We only capture complete fetch requests\n  if (!handlerData.endTimestamp) {\n    return;\n  }\n\n  if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {\n    // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)\n    return;\n  }\n\n  if (handlerData.error) {\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'fetch',\n        data: handlerData.fetchData,\n        level: 'error',\n        type: 'http',\n      },\n      {\n        data: handlerData.error,\n        input: handlerData.args,\n      },\n    );\n  } else {\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'fetch',\n        data: {\n          ...handlerData.fetchData,\n          status_code: handlerData.response.status,\n        },\n        type: 'http',\n      },\n      {\n        input: handlerData.args,\n        response: handlerData.response,\n      },\n    );\n  }\n}\n\n/**\n * Creates breadcrumbs from history API calls\n */\nfunction _historyBreadcrumb(handlerData) {\n  var global = getGlobalObject();\n  let from = handlerData.from;\n  let to = handlerData.to;\n  var parsedLoc = parseUrl(global.location.href);\n  let parsedFrom = parseUrl(from);\n  var parsedTo = parseUrl(to);\n\n  // Initial pushState doesn't provide `from` information\n  if (!parsedFrom.path) {\n    parsedFrom = parsedLoc;\n  }\n\n  // Use only the path component of the URL if the URL matches the current\n  // document (almost all the time when using pushState)\n  if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n    to = parsedTo.relative;\n  }\n  if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n    from = parsedFrom.relative;\n  }\n\n  getCurrentHub().addBreadcrumb({\n    category: 'navigation',\n    data: {\n      from,\n      to,\n    },\n  });\n}\n\nexport { BREADCRUMB_INTEGRATION_ID, Breadcrumbs };\n//# sourceMappingURL=breadcrumbs.js.map\n","import { getGlobalObject, isNativeFetch, logger, supportsFetch } from '@sentry/utils';\n\nvar global = getGlobalObject();\nlet cachedFetchImpl;\n\n/**\n * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.\n * Whenever someone wraps the Fetch API and returns the wrong promise chain,\n * this chain becomes orphaned and there is no possible way to capture it's rejections\n * other than allowing it bubble up to this very handler. eg.\n *\n * var f = window.fetch;\n * window.fetch = function () {\n *   var p = f.apply(this, arguments);\n *\n *   p.then(function() {\n *     console.log('hi.');\n *   });\n *\n *   return p;\n * }\n *\n * `p.then(function () { ... })` is producing a completely separate promise chain,\n * however, what's returned is `p` - the result of original `fetch` call.\n *\n * This mean, that whenever we use the Fetch API to send our own requests, _and_\n * some ad-blocker blocks it, this orphaned chain will _always_ reject,\n * effectively causing another event to be captured.\n * This makes a whole process become an infinite loop, which we need to somehow\n * deal with, and break it in one way or another.\n *\n * To deal with this issue, we are making sure that we _always_ use the real\n * browser Fetch API, instead of relying on what `window.fetch` exposes.\n * The only downside to this would be missing our own requests as breadcrumbs,\n * but because we are already not doing this, it should be just fine.\n *\n * Possible failed fetch error messages per-browser:\n *\n * Chrome:  Failed to fetch\n * Edge:    Failed to Fetch\n * Firefox: NetworkError when attempting to fetch resource\n * Safari:  resource blocked by content blocker\n */\nfunction getNativeFetchImplementation() {\n  if (cachedFetchImpl) {\n    return cachedFetchImpl;\n  }\n\n  // Fast path to avoid DOM I/O\n  if (isNativeFetch(global.fetch)) {\n    return (cachedFetchImpl = global.fetch.bind(global));\n  }\n\n  var document = global.document;\n  let fetchImpl = global.fetch;\n    if (document && typeof document.createElement === 'function') {\n    try {\n      var sandbox = document.createElement('iframe');\n      sandbox.hidden = true;\n      document.head.appendChild(sandbox);\n      var contentWindow = sandbox.contentWindow;\n      if (contentWindow && contentWindow.fetch) {\n        fetchImpl = contentWindow.fetch;\n      }\n      document.head.removeChild(sandbox);\n    } catch (e) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);\n    }\n  }\n\n  return (cachedFetchImpl = fetchImpl.bind(global));\n  }\n\n/**\n * Sends sdk client report using sendBeacon or fetch as a fallback if available\n *\n * @param url report endpoint\n * @param body report payload\n */\nfunction sendReport(url, body) {\n  var isRealNavigator = Object.prototype.toString.call(global && global.navigator) === '[object Navigator]';\n  var hasSendBeacon = isRealNavigator && typeof global.navigator.sendBeacon === 'function';\n\n  if (hasSendBeacon) {\n    // Prevent illegal invocations - https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch\n    var sendBeacon = global.navigator.sendBeacon.bind(global.navigator);\n    sendBeacon(url, body);\n  } else if (supportsFetch()) {\n    var fetch = getNativeFetchImplementation();\n    fetch(url, {\n      body,\n      method: 'POST',\n      credentials: 'omit',\n      keepalive: true,\n    }).then(null, error => {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(error);\n    });\n  }\n}\n\nexport { getNativeFetchImplementation, sendReport };\n//# sourceMappingURL=utils.js.map\n","import { BaseClient, SDK_VERSION, getCurrentHub, getEnvelopeEndpointWithUrlEncodedAuth } from '@sentry/core';\nimport { getGlobalObject, getEventDescription, logger, createClientReportEnvelope, dsnToString, serializeEnvelope } from '@sentry/utils';\nimport { eventFromException, eventFromMessage } from './eventbuilder.js';\nimport { BREADCRUMB_INTEGRATION_ID } from './integrations/breadcrumbs.js';\nimport { sendReport } from './transports/utils.js';\n\nvar globalObject = getGlobalObject();\n\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nclass BrowserClient extends BaseClient {\n  /**\n   * Creates a new Browser SDK instance.\n   *\n   * @param options Configuration options for this SDK.\n   */\n   constructor(options) {\n    options._metadata = options._metadata || {};\n    options._metadata.sdk = options._metadata.sdk || {\n      name: 'sentry.javascript.browser',\n      packages: [\n        {\n          name: 'npm:@sentry/browser',\n          version: SDK_VERSION,\n        },\n      ],\n      version: SDK_VERSION,\n    };\n\n    super(options);\n\n    if (options.sendClientReports && globalObject.document) {\n      globalObject.document.addEventListener('visibilitychange', () => {\n        if (globalObject.document.visibilityState === 'hidden') {\n          this._flushOutcomes();\n        }\n      });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   eventFromException(exception, hint) {\n    return eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   eventFromMessage(\n    message,\n        level = 'info',\n    hint,\n  ) {\n    return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendEvent(event, hint) {\n    // We only want to add the sentry event breadcrumb when the user has the breadcrumb integration installed and\n    // activated its `sentry` option.\n    // We also do not want to use the `Breadcrumbs` class here directly, because we do not want it to be included in\n    // bundles, if it is not used by the SDK.\n    // This all sadly is a bit ugly, but we currently don't have a \"pre-send\" hook on the integrations so we do it this\n    // way for now.\n    var breadcrumbIntegration = this.getIntegrationById(BREADCRUMB_INTEGRATION_ID) ;\n    if (\n      breadcrumbIntegration &&\n      // We check for definedness of `options`, even though it is not strictly necessary, because that access to\n      // `.sentry` below does not throw, in case users provided their own integration with id \"Breadcrumbs\" that does\n      // not have an`options` field\n      breadcrumbIntegration.options &&\n      breadcrumbIntegration.options.sentry\n    ) {\n      getCurrentHub().addBreadcrumb(\n        {\n          category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,\n          event_id: event.event_id,\n          level: event.level,\n          message: getEventDescription(event),\n        },\n        {\n          event,\n        },\n      );\n    }\n\n    super.sendEvent(event, hint);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   _prepareEvent(event, hint, scope) {\n    event.platform = event.platform || 'javascript';\n    return super._prepareEvent(event, hint, scope);\n  }\n\n  /**\n   * Sends client reports as an envelope.\n   */\n   _flushOutcomes() {\n    var outcomes = this._clearOutcomes();\n\n    if (outcomes.length === 0) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('No outcomes to send');\n      return;\n    }\n\n    if (!this._dsn) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('No dsn provided, will not send outcomes');\n      return;\n    }\n\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('Sending outcomes:', outcomes);\n\n    var url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, this._options);\n    var envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));\n\n    try {\n      sendReport(url, serializeEnvelope(envelope));\n    } catch (e) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(e);\n    }\n  }\n}\n\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map\n","import { withScope, captureException } from '@sentry/core';\nimport { getOriginalFunction, addExceptionTypeValue, addExceptionMechanism, markFunctionWrapped, addNonEnumerableProperty } from '@sentry/utils';\n\nlet ignoreOnError = 0;\n\n/**\n * @hidden\n */\nfunction shouldIgnoreOnError() {\n  return ignoreOnError > 0;\n}\n\n/**\n * @hidden\n */\nfunction ignoreNextOnError() {\n  // onerror should trigger before setTimeout\n  ignoreOnError += 1;\n  setTimeout(() => {\n    ignoreOnError -= 1;\n  });\n}\n\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap. It is generally safe to pass an unbound function, because the returned wrapper always\n * has a correct `this` context.\n * @returns The wrapped function.\n * @hidden\n */\nfunction wrap(\n  fn,\n  options\n\n = {},\n  before,\n  ) {\n  // for future readers what this does is wrap a function and then create\n  // a bi-directional wrapping between them.\n  //\n  // example: wrapped = wrap(original);\n  //  original.__sentry_wrapped__ -> wrapped\n  //  wrapped.__sentry_original__ -> original\n\n  if (typeof fn !== 'function') {\n    return fn;\n  }\n\n  try {\n    // if we're dealing with a function that was previously wrapped, return\n    // the original wrapper.\n    var wrapper = fn.__sentry_wrapped__;\n    if (wrapper) {\n      return wrapper;\n    }\n\n    // We don't wanna wrap it twice\n    if (getOriginalFunction(fn)) {\n      return fn;\n    }\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    // Bail on wrapping and return the function as-is (defers to window.onerror).\n    return fn;\n  }\n\n    // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n  var sentryWrapped = function () {\n    var args = Array.prototype.slice.call(arguments);\n\n    try {\n      if (before && typeof before === 'function') {\n        before.apply(this, arguments);\n      }\n\n            var wrappedArguments = args.map((arg) => wrap(arg, options));\n\n      // Attempt to invoke user-land function\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n      //       means the sentry.javascript SDK caught an error invoking your application code. This\n      //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n      return fn.apply(this, wrappedArguments);\n    } catch (ex) {\n      ignoreNextOnError();\n\n      withScope((scope) => {\n        scope.addEventProcessor((event) => {\n          if (options.mechanism) {\n            addExceptionTypeValue(event, undefined, undefined);\n            addExceptionMechanism(event, options.mechanism);\n          }\n\n          event.extra = {\n            ...event.extra,\n            arguments: args,\n          };\n\n          return event;\n        });\n\n        captureException(ex);\n      });\n\n      throw ex;\n    }\n  };\n  \n  // Accessing some objects may throw\n  // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n  try {\n    for (var property in fn) {\n      if (Object.prototype.hasOwnProperty.call(fn, property)) {\n        sentryWrapped[property] = fn[property];\n      }\n    }\n  } catch (_oO) {} \n  // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n  markFunctionWrapped(sentryWrapped, fn);\n\n  addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);\n\n  // Restore original function name (not all browsers allow that)\n  try {\n    var descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name') ;\n    if (descriptor.configurable) {\n      Object.defineProperty(sentryWrapped, 'name', {\n        get() {\n          return fn.name;\n        },\n      });\n    }\n      } catch (_oO) {}\n\n  return sentryWrapped;\n}\n\n/**\n * All properties the report dialog supports\n */\n\nexport { ignoreNextOnError, shouldIgnoreOnError, wrap };\n//# sourceMappingURL=helpers.js.map\n","import { createStackParser } from '@sentry/utils';\n\n// global reference to slice\nvar UNKNOWN_FUNCTION = '?';\n\nvar OPERA10_PRIORITY = 10;\nvar OPERA11_PRIORITY = 20;\nvar CHROME_PRIORITY = 30;\nvar WINJS_PRIORITY = 40;\nvar GECKO_PRIORITY = 50;\n\nfunction createFrame(filename, func, lineno, colno) {\n  var frame = {\n    filename,\n    function: func,\n    // All browser frames are considered in_app\n    in_app: true,\n  };\n\n  if (lineno !== undefined) {\n    frame.lineno = lineno;\n  }\n\n  if (colno !== undefined) {\n    frame.colno = colno;\n  }\n\n  return frame;\n}\n\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nvar chromeRegex =\n  /^\\s*at (?:(.*?) ?\\((?:address at )?)?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nvar chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\nvar chrome = line => {\n  var parts = chromeRegex.exec(line);\n\n  if (parts) {\n    var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n\n    if (isEval) {\n      var subMatch = chromeEvalRegex.exec(parts[2]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = subMatch[1]; // url\n        parts[3] = subMatch[2]; // line\n        parts[4] = subMatch[3]; // column\n      }\n    }\n\n    // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now\n    // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)\n    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);\n\n    return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);\n  }\n\n  return;\n};\n\nvar chromeStackLineParser = [CHROME_PRIORITY, chrome];\n\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nvar geckoREgex =\n  /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|capacitor).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar geckoEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\n\nvar gecko = line => {\n  var parts = geckoREgex.exec(line);\n\n  if (parts) {\n    var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    if (isEval) {\n      var subMatch = geckoEvalRegex.exec(parts[3]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line number\n        parts[1] = parts[1] || 'eval';\n        parts[3] = subMatch[1];\n        parts[4] = subMatch[2];\n        parts[5] = ''; // no column when eval\n      }\n    }\n\n    let filename = parts[3];\n    let func = parts[1] || UNKNOWN_FUNCTION;\n    [func, filename] = extractSafariExtensionDetails(func, filename);\n\n    return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);\n  }\n\n  return;\n};\n\nvar geckoStackLineParser = [GECKO_PRIORITY, gecko];\n\nvar winjsRegex =\n  /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n\nvar winjs = line => {\n  var parts = winjsRegex.exec(line);\n\n  return parts\n    ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)\n    : undefined;\n};\n\nvar winjsStackLineParser = [WINJS_PRIORITY, winjs];\n\nvar opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n\nvar opera10 = line => {\n  var parts = opera10Regex.exec(line);\n  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\n\nvar opera10StackLineParser = [OPERA10_PRIORITY, opera10];\n\nvar opera11Regex =\n  / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\(.*\\))? in (.*):\\s*$/i;\n\nvar opera11 = line => {\n  var parts = opera11Regex.exec(line);\n  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\n\nvar opera11StackLineParser = [OPERA11_PRIORITY, opera11];\n\nvar defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser, winjsStackLineParser];\n\nvar defaultStackParser = createStackParser(...defaultStackLineParsers);\n\n/**\n * Safari web extensions, starting version unknown, can produce \"frames-only\" stacktraces.\n * What it means, is that instead of format like:\n *\n * Error: wat\n *   at function@url:row:col\n *   at function@url:row:col\n *   at function@url:row:col\n *\n * it produces something like:\n *\n *   function@url:row:col\n *   function@url:row:col\n *   function@url:row:col\n *\n * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.\n * This function is extracted so that we can use it in both places without duplicating the logic.\n * Unfortunately \"just\" changing RegExp is too complicated now and making it pass all tests\n * and fix this case seems like an impossible, or at least way too time-consuming task.\n */\nvar extractSafariExtensionDetails = (func, filename) => {\n  var isSafariExtension = func.indexOf('safari-extension') !== -1;\n  var isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;\n\n  return isSafariExtension || isSafariWebExtension\n    ? [\n        func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION,\n        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,\n      ]\n    : [func, filename];\n};\n\nexport { chromeStackLineParser, defaultStackLineParsers, defaultStackParser, geckoStackLineParser, opera10StackLineParser, opera11StackLineParser, winjsStackLineParser };\n//# sourceMappingURL=stack-parsers.js.map\n","import { getGlobalObject, fill, getFunctionName, getOriginalFunction } from '@sentry/utils';\nimport { wrap } from '../helpers.js';\n\nvar DEFAULT_EVENT_TARGET = [\n  'EventTarget',\n  'Window',\n  'Node',\n  'ApplicationCache',\n  'AudioTrackList',\n  'ChannelMergerNode',\n  'CryptoOperation',\n  'EventSource',\n  'FileReader',\n  'HTMLUnknownElement',\n  'IDBDatabase',\n  'IDBRequest',\n  'IDBTransaction',\n  'KeyOperation',\n  'MediaController',\n  'MessagePort',\n  'ModalWindow',\n  'Notification',\n  'SVGElementInstance',\n  'Screen',\n  'TextTrack',\n  'TextTrackCue',\n  'TextTrackList',\n  'WebSocket',\n  'WebSocketWorker',\n  'Worker',\n  'XMLHttpRequest',\n  'XMLHttpRequestEventTarget',\n  'XMLHttpRequestUpload',\n];\n\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\nclass TryCatch  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'TryCatch';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = TryCatch.id;}\n\n  /** JSDoc */\n  \n\n  /**\n   * @inheritDoc\n   */\n   constructor(options) {;TryCatch.prototype.__init.call(this);\n    this._options = {\n      XMLHttpRequest: true,\n      eventTarget: true,\n      requestAnimationFrame: true,\n      setInterval: true,\n      setTimeout: true,\n      ...options,\n    };\n  }\n\n  /**\n   * Wrap timer functions and event targets to catch errors\n   * and provide better metadata.\n   */\n   setupOnce() {\n    var global = getGlobalObject();\n\n    if (this._options.setTimeout) {\n      fill(global, 'setTimeout', _wrapTimeFunction);\n    }\n\n    if (this._options.setInterval) {\n      fill(global, 'setInterval', _wrapTimeFunction);\n    }\n\n    if (this._options.requestAnimationFrame) {\n      fill(global, 'requestAnimationFrame', _wrapRAF);\n    }\n\n    if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {\n      fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n    }\n\n    var eventTargetOption = this._options.eventTarget;\n    if (eventTargetOption) {\n      var eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n      eventTarget.forEach(_wrapEventTarget);\n    }\n  }\n} TryCatch.__initStatic();\n\n/** JSDoc */\nfunction _wrapTimeFunction(original) {\n    return function ( ...args) {\n    var originalCallback = args[0];\n    args[0] = wrap(originalCallback, {\n      mechanism: {\n        data: { function: getFunctionName(original) },\n        handled: true,\n        type: 'instrument',\n      },\n    });\n    return original.apply(this, args);\n  };\n}\n\n/** JSDoc */\nfunction _wrapRAF(original) {\n    return function ( callback) {\n        return original.apply(this, [\n      wrap(callback, {\n        mechanism: {\n          data: {\n            function: 'requestAnimationFrame',\n            handler: getFunctionName(original),\n          },\n          handled: true,\n          type: 'instrument',\n        },\n      }),\n    ]);\n  };\n}\n\n/** JSDoc */\nfunction _wrapXHR(originalSend) {\n    return function ( ...args) {\n        var xhr = this;\n    var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n\n    xmlHttpRequestProps.forEach(prop => {\n      if (prop in xhr && typeof xhr[prop] === 'function') {\n                fill(xhr, prop, function (original) {\n          var wrapOptions = {\n            mechanism: {\n              data: {\n                function: prop,\n                handler: getFunctionName(original),\n              },\n              handled: true,\n              type: 'instrument',\n            },\n          };\n\n          // If Instrument integration has been called before TryCatch, get the name of original function\n          var originalFunction = getOriginalFunction(original);\n          if (originalFunction) {\n            wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n          }\n\n          // Otherwise wrap directly\n          return wrap(original, wrapOptions);\n        });\n      }\n    });\n\n    return originalSend.apply(this, args);\n  };\n}\n\n/** JSDoc */\nfunction _wrapEventTarget(target) {\n    var global = getGlobalObject() ;\n    var proto = global[target] && global[target].prototype;\n\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n    return;\n  }\n\n  fill(proto, 'addEventListener', function (original)\n\n {\n    return function (\n            \n      eventName,\n      fn,\n      options,\n    ) {\n      try {\n        if (typeof fn.handleEvent === 'function') {\n          // ESlint disable explanation:\n          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would\n          //  introduce a bug here, because bind returns a new function that doesn't have our\n          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.\n          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.\n                    fn.handleEvent = wrap(fn.handleEvent, {\n            mechanism: {\n              data: {\n                function: 'handleEvent',\n                handler: getFunctionName(fn),\n                target,\n              },\n              handled: true,\n              type: 'instrument',\n            },\n          });\n        }\n      } catch (err) {\n        // can sometimes get 'Permission denied to access property \"handle Event'\n      }\n\n      return original.apply(this, [\n        eventName,\n                wrap(fn , {\n          mechanism: {\n            data: {\n              function: 'addEventListener',\n              handler: getFunctionName(fn),\n              target,\n            },\n            handled: true,\n            type: 'instrument',\n          },\n        }),\n        options,\n      ]);\n    };\n  });\n\n  fill(\n    proto,\n    'removeEventListener',\n    function (\n      originalRemoveEventListener,\n          ) {\n      return function (\n                \n        eventName,\n        fn,\n        options,\n      ) {\n        /**\n         * There are 2 possible scenarios here:\n         *\n         * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified\n         * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function\n         * as a pass-through, and call original `removeEventListener` with it.\n         *\n         * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using\n         * our wrapped version of `addEventListener`, which internally calls `wrap` helper.\n         * This helper \"wraps\" whole callback inside a try/catch statement, and attached appropriate metadata to it,\n         * in order for us to make a distinction between wrapped/non-wrapped functions possible.\n         * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.\n         *\n         * When someone adds a handler prior to initialization, and then do it again, but after,\n         * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible\n         * to get rid of the initial handler and it'd stick there forever.\n         */\n        var wrappedEventHandler = fn ;\n        try {\n          var originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;\n          if (originalEventHandler) {\n            originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n          }\n        } catch (e) {\n          // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n        }\n        return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);\n      };\n    },\n  );\n}\n\nexport { TryCatch };\n//# sourceMappingURL=trycatch.js.map\n","import { getCurrentHub } from '@sentry/core';\nimport { addInstrumentationHandler, isString, isPrimitive, isErrorEvent, getLocationHref, logger, addExceptionMechanism } from '@sentry/utils';\nimport { eventFromUnknownInput } from '../eventbuilder.js';\nimport { shouldIgnoreOnError } from '../helpers.js';\n\n/** Global handlers */\nclass GlobalHandlers  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'GlobalHandlers';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = GlobalHandlers.id;}\n\n  /** JSDoc */\n  \n\n  /**\n   * Stores references functions to installing handlers. Will set to undefined\n   * after they have been run so that they are not used twice.\n   */\n   __init2() {this._installFunc = {\n    onerror: _installGlobalOnErrorHandler,\n    onunhandledrejection: _installGlobalOnUnhandledRejectionHandler,\n  };}\n\n  /** JSDoc */\n   constructor(options) {;GlobalHandlers.prototype.__init.call(this);GlobalHandlers.prototype.__init2.call(this);\n    this._options = {\n      onerror: true,\n      onunhandledrejection: true,\n      ...options,\n    };\n  }\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n    Error.stackTraceLimit = 50;\n    var options = this._options;\n\n    // We can disable guard-for-in as we construct the options object above + do checks against\n    // `this._installFunc` for the property.\n        for (var key in options) {\n      var installFunc = this._installFunc[key ];\n      if (installFunc && options[key ]) {\n        globalHandlerLog(key);\n        installFunc();\n        this._installFunc[key ] = undefined;\n      }\n    }\n  }\n} GlobalHandlers.__initStatic();\n\n/** JSDoc */\nfunction _installGlobalOnErrorHandler() {\n  addInstrumentationHandler(\n    'error',\n        (data) => {\n      const [hub, stackParser, attachStacktrace] = getHubAndOptions();\n      if (!hub.getIntegration(GlobalHandlers)) {\n        return;\n      }\n      const { msg, url, line, column, error } = data;\n      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n        return;\n      }\n\n      var event =\n        error === undefined && isString(msg)\n          ? _eventFromIncompleteOnError(msg, url, line, column)\n          : _enhanceEventWithInitialFrame(\n              eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false),\n              url,\n              line,\n              column,\n            );\n\n      event.level = 'error';\n\n      addMechanismAndCapture(hub, error, event, 'onerror');\n    },\n  );\n}\n\n/** JSDoc */\nfunction _installGlobalOnUnhandledRejectionHandler() {\n  addInstrumentationHandler(\n    'unhandledrejection',\n        (e) => {\n      const [hub, stackParser, attachStacktrace] = getHubAndOptions();\n      if (!hub.getIntegration(GlobalHandlers)) {\n        return;\n      }\n      let error = e;\n\n      // dig the object of the rejection out of known event types\n      try {\n        // PromiseRejectionEvents store the object of the rejection under 'reason'\n        // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent\n        if ('reason' in e) {\n          error = e.reason;\n        }\n        // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n        // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n        // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n        // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n        // https://github.com/getsentry/sentry-javascript/issues/2380\n        else if ('detail' in e && 'reason' in e.detail) {\n          error = e.detail.reason;\n        }\n      } catch (_oO) {\n        // no-empty\n      }\n\n      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n        return true;\n      }\n\n      var event = isPrimitive(error)\n        ? _eventFromRejectionWithPrimitive(error)\n        : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);\n\n      event.level = 'error';\n\n      addMechanismAndCapture(hub, error, event, 'onunhandledrejection');\n      return;\n    },\n  );\n}\n\n/**\n * Create an event from a promise rejection where the `reason` is a primitive.\n *\n * @param reason: The `reason` property of the promise rejection\n * @returns An Event object with an appropriate `exception` value\n */\nfunction _eventFromRejectionWithPrimitive(reason) {\n  return {\n    exception: {\n      values: [\n        {\n          type: 'UnhandledRejection',\n          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n          value: `Non-Error promise rejection captured with value: ${String(reason)}`,\n        },\n      ],\n    },\n  };\n}\n\n/**\n * This function creates a stack from an old, error-less onerror handler.\n */\nfunction _eventFromIncompleteOnError(msg, url, line, column) {\n  var ERROR_TYPES_RE =\n    /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n\n  // If 'message' is ErrorEvent, get real message from inside\n  let message = isErrorEvent(msg) ? msg.message : msg;\n  let name = 'Error';\n\n  var groups = message.match(ERROR_TYPES_RE);\n  if (groups) {\n    name = groups[1];\n    message = groups[2];\n  }\n\n  var event = {\n    exception: {\n      values: [\n        {\n          type: name,\n          value: message,\n        },\n      ],\n    },\n  };\n\n  return _enhanceEventWithInitialFrame(event, url, line, column);\n}\n\n/** JSDoc */\nfunction _enhanceEventWithInitialFrame(event, url, line, column) {\n  // event.exception\n  var e = (event.exception = event.exception || {});\n  // event.exception.values\n  var ev = (e.values = e.values || []);\n  // event.exception.values[0]\n  var ev0 = (ev[0] = ev[0] || {});\n  // event.exception.values[0].stacktrace\n  var ev0s = (ev0.stacktrace = ev0.stacktrace || {});\n  // event.exception.values[0].stacktrace.frames\n  var ev0sf = (ev0s.frames = ev0s.frames || []);\n\n  var colno = isNaN(parseInt(column, 10)) ? undefined : column;\n  var lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n  var filename = isString(url) && url.length > 0 ? url : getLocationHref();\n\n  // event.exception.values[0].stacktrace.frames\n  if (ev0sf.length === 0) {\n    ev0sf.push({\n      colno,\n      filename,\n      function: '?',\n      in_app: true,\n      lineno,\n    });\n  }\n\n  return event;\n}\n\nfunction globalHandlerLog(type) {\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Global Handler attached: ${type}`);\n}\n\nfunction addMechanismAndCapture(hub, error, event, type) {\n  addExceptionMechanism(event, {\n    handled: false,\n    type,\n  });\n  hub.captureEvent(event, {\n    originalException: error,\n  });\n}\n\nfunction getHubAndOptions() {\n  var hub = getCurrentHub();\n  var client = hub.getClient();\n  var options = (client && client.getOptions()) || {\n    stackParser: () => [],\n    attachStacktrace: false,\n  };\n  return [hub, options.stackParser, options.attachStacktrace];\n}\n\nexport { GlobalHandlers };\n//# sourceMappingURL=globalhandlers.js.map\n","import { getCurrentHub, addGlobalEventProcessor } from '@sentry/core';\nimport { isInstanceOf } from '@sentry/utils';\nimport { exceptionFromError } from '../eventbuilder.js';\n\nvar DEFAULT_KEY = 'cause';\nvar DEFAULT_LIMIT = 5;\n\n/** Adds SDK info to an event. */\nclass LinkedErrors  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'LinkedErrors';}\n\n  /**\n   * @inheritDoc\n   */\n    __init() {this.name = LinkedErrors.id;}\n\n  /**\n   * @inheritDoc\n   */\n  \n\n  /**\n   * @inheritDoc\n   */\n  \n\n  /**\n   * @inheritDoc\n   */\n   constructor(options = {}) {;LinkedErrors.prototype.__init.call(this);\n    this._key = options.key || DEFAULT_KEY;\n    this._limit = options.limit || DEFAULT_LIMIT;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n    var client = getCurrentHub().getClient();\n    if (!client) {\n      return;\n    }\n    addGlobalEventProcessor((event, hint) => {\n      var self = getCurrentHub().getIntegration(LinkedErrors);\n      return self ? _handler(client.getOptions().stackParser, self._key, self._limit, event, hint) : event;\n    });\n  }\n} LinkedErrors.__initStatic();\n\n/**\n * @inheritDoc\n */\nfunction _handler(\n  parser,\n  key,\n  limit,\n  event,\n  hint,\n) {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return event;\n  }\n  var linkedErrors = _walkErrorTree(parser, limit, hint.originalException , key);\n  event.exception.values = [...linkedErrors, ...event.exception.values];\n  return event;\n}\n\n/**\n * JSDOC\n */\nfunction _walkErrorTree(\n  parser,\n  limit,\n  error,\n  key,\n  stack = [],\n) {\n  if (!isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {\n    return stack;\n  }\n  var exception = exceptionFromError(parser, error[key]);\n  return _walkErrorTree(parser, limit, error[key], key, [exception, ...stack]);\n}\n\nexport { LinkedErrors, _handler, _walkErrorTree };\n//# sourceMappingURL=linkederrors.js.map\n","import { logger } from '@sentry/utils';\n\n/** Deduplication filter */\nclass Dedupe  {constructor() { Dedupe.prototype.__init.call(this); }\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'Dedupe';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = Dedupe.id;}\n\n  /**\n   * @inheritDoc\n   */\n  \n\n  /**\n   * @inheritDoc\n   */\n   setupOnce(addGlobalEventProcessor, getCurrentHub) {\n    var eventProcessor = currentEvent => {\n      var self = getCurrentHub().getIntegration(Dedupe);\n      if (self) {\n        // Juuust in case something goes wrong\n        try {\n          if (_shouldDropEvent(currentEvent, self._previousEvent)) {\n            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Event dropped due to being a duplicate of previously captured event.');\n            return null;\n          }\n        } catch (_oO) {\n          return (self._previousEvent = currentEvent);\n        }\n\n        return (self._previousEvent = currentEvent);\n      }\n      return currentEvent;\n    };\n\n    eventProcessor.id = this.name;\n    addGlobalEventProcessor(eventProcessor);\n  }\n} Dedupe.__initStatic();\n\n/** JSDoc */\nfunction _shouldDropEvent(currentEvent, previousEvent) {\n  if (!previousEvent) {\n    return false;\n  }\n\n  if (_isSameMessageEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  if (_isSameExceptionEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  return false;\n}\n\n/** JSDoc */\nfunction _isSameMessageEvent(currentEvent, previousEvent) {\n  var currentMessage = currentEvent.message;\n  var previousMessage = previousEvent.message;\n\n  // If neither event has a message property, they were both exceptions, so bail out\n  if (!currentMessage && !previousMessage) {\n    return false;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {\n    return false;\n  }\n\n  if (currentMessage !== previousMessage) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameExceptionEvent(currentEvent, previousEvent) {\n  var previousException = _getExceptionFromEvent(previousEvent);\n  var currentException = _getExceptionFromEvent(currentEvent);\n\n  if (!previousException || !currentException) {\n    return false;\n  }\n\n  if (previousException.type !== currentException.type || previousException.value !== currentException.value) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameStacktrace(currentEvent, previousEvent) {\n  let currentFrames = _getFramesFromEvent(currentEvent);\n  let previousFrames = _getFramesFromEvent(previousEvent);\n\n  // If neither event has a stacktrace, they are assumed to be the same\n  if (!currentFrames && !previousFrames) {\n    return true;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {\n    return false;\n  }\n\n  currentFrames = currentFrames ;\n  previousFrames = previousFrames ;\n\n  // If number of frames differ, they are not the same\n  if (previousFrames.length !== currentFrames.length) {\n    return false;\n  }\n\n  // Otherwise, compare the two\n  for (let i = 0; i < previousFrames.length; i++) {\n    var frameA = previousFrames[i];\n    var frameB = currentFrames[i];\n\n    if (\n      frameA.filename !== frameB.filename ||\n      frameA.lineno !== frameB.lineno ||\n      frameA.colno !== frameB.colno ||\n      frameA.function !== frameB.function\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameFingerprint(currentEvent, previousEvent) {\n  let currentFingerprint = currentEvent.fingerprint;\n  let previousFingerprint = previousEvent.fingerprint;\n\n  // If neither event has a fingerprint, they are assumed to be the same\n  if (!currentFingerprint && !previousFingerprint) {\n    return true;\n  }\n\n  // If only one event has a fingerprint, but not the other one, they are not the same\n  if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {\n    return false;\n  }\n\n  currentFingerprint = currentFingerprint ;\n  previousFingerprint = previousFingerprint ;\n\n  // Otherwise, compare the two\n  try {\n    return !!(currentFingerprint.join('') === previousFingerprint.join(''));\n  } catch (_oO) {\n    return false;\n  }\n}\n\n/** JSDoc */\nfunction _getExceptionFromEvent(event) {\n  return event.exception && event.exception.values && event.exception.values[0];\n}\n\n/** JSDoc */\nfunction _getFramesFromEvent(event) {\n  var exception = event.exception;\n\n  if (exception) {\n    try {\n      // @ts-ignore Object could be undefined\n      return exception.values[0].stacktrace.frames;\n    } catch (_oO) {\n      return undefined;\n    }\n  }\n  return undefined;\n}\n\nexport { Dedupe };\n//# sourceMappingURL=dedupe.js.map\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\n\nvar global = getGlobalObject();\n\n/** HttpContext integration collects information about HTTP request headers */\nclass HttpContext  {constructor() { HttpContext.prototype.__init.call(this); }\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'HttpContext';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = HttpContext.id;}\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n    addGlobalEventProcessor((event) => {\n      if (getCurrentHub().getIntegration(HttpContext)) {\n        // if none of the information we want exists, don't bother\n        if (!global.navigator && !global.location && !global.document) {\n          return event;\n        }\n\n        // grab as much info as exists and add it to the event\n        var url = (event.request && event.request.url) || (global.location && global.location.href);\n        const { referrer } = global.document || {};\n        const { userAgent } = global.navigator || {};\n\n        var headers = {\n          ...(event.request && event.request.headers),\n          ...(referrer && { Referer: referrer }),\n          ...(userAgent && { 'User-Agent': userAgent }),\n        };\n        var request = { ...(url && { url }), headers };\n\n        return { ...event, request };\n      }\n      return event;\n    });\n  }\n} HttpContext.__initStatic();\n\nexport { HttpContext };\n//# sourceMappingURL=httpcontext.js.map\n","import { createTransport } from '@sentry/core';\nimport { getNativeFetchImplementation } from './utils.js';\n\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nfunction makeFetchTransport(\n  options,\n  nativeFetch = getNativeFetchImplementation(),\n) {\n  function makeRequest(request) {\n    var requestOptions = {\n      body: request.body,\n      method: 'POST',\n      referrerPolicy: 'origin',\n      headers: options.headers,\n      ...options.fetchOptions,\n    };\n\n    return nativeFetch(options.url, requestOptions).then(response => ({\n      statusCode: response.status,\n      headers: {\n        'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n        'retry-after': response.headers.get('Retry-After'),\n      },\n    }));\n  }\n\n  return createTransport(options, makeRequest);\n}\n\nexport { makeFetchTransport };\n//# sourceMappingURL=fetch.js.map\n","import { createTransport } from '@sentry/core';\nimport { SyncPromise } from '@sentry/utils';\n\n/**\n * The DONE ready state for XmlHttpRequest\n *\n * Defining it here as a constant b/c XMLHttpRequest.DONE is not always defined\n * (e.g. during testing, it is `undefined`)\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState}\n */\nvar XHR_READYSTATE_DONE = 4;\n\n/**\n * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.\n */\nfunction makeXHRTransport(options) {\n  function makeRequest(request) {\n    return new SyncPromise((resolve, reject) => {\n      var xhr = new XMLHttpRequest();\n\n      xhr.onerror = reject;\n\n      xhr.onreadystatechange = () => {\n        if (xhr.readyState === XHR_READYSTATE_DONE) {\n          resolve({\n            statusCode: xhr.status,\n            headers: {\n              'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),\n              'retry-after': xhr.getResponseHeader('Retry-After'),\n            },\n          });\n        }\n      };\n\n      xhr.open('POST', options.url);\n\n      for (var header in options.headers) {\n        if (Object.prototype.hasOwnProperty.call(options.headers, header)) {\n          xhr.setRequestHeader(header, options.headers[header]);\n        }\n      }\n\n      xhr.send(request.body);\n    });\n  }\n\n  return createTransport(options, makeRequest);\n}\n\nexport { makeXHRTransport };\n//# sourceMappingURL=xhr.js.map\n","import { Integrations, getIntegrationsToSetup, initAndBind, getCurrentHub, getReportDialogEndpoint } from '@sentry/core';\nimport { getGlobalObject, stackParserFromStackParserOptions, supportsFetch, logger, resolvedSyncPromise, addInstrumentationHandler } from '@sentry/utils';\nimport { BrowserClient } from './client.js';\nimport { wrap as wrap$1 } from './helpers.js';\nimport './integrations/index.js';\nimport { defaultStackParser } from './stack-parsers.js';\nimport './transports/index.js';\nimport { TryCatch } from './integrations/trycatch.js';\nimport { Breadcrumbs } from './integrations/breadcrumbs.js';\nimport { GlobalHandlers } from './integrations/globalhandlers.js';\nimport { LinkedErrors } from './integrations/linkederrors.js';\nimport { Dedupe } from './integrations/dedupe.js';\nimport { HttpContext } from './integrations/httpcontext.js';\nimport { makeFetchTransport } from './transports/fetch.js';\nimport { makeXHRTransport } from './transports/xhr.js';\n\nvar defaultIntegrations = [\n  new Integrations.InboundFilters(),\n  new Integrations.FunctionToString(),\n  new TryCatch(),\n  new Breadcrumbs(),\n  new GlobalHandlers(),\n  new LinkedErrors(),\n  new Dedupe(),\n  new HttpContext(),\n];\n\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { configureScope } from '@sentry/browser';\n * configureScope((scope: Scope) => {\n *   scope.setExtra({ battery: 0.7 });\n *   scope.setTag({ user_mode: 'admin' });\n *   scope.setUser({ id: '4711' });\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n *   message: 'My Breadcrumb',\n *   // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n *   message: 'Manual',\n *   stacktrace: [\n *     // ...\n *   ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nfunction init(options = {}) {\n  if (options.defaultIntegrations === undefined) {\n    options.defaultIntegrations = defaultIntegrations;\n  }\n  if (options.release === undefined) {\n    var window = getGlobalObject();\n    // This supports the variable that sentry-webpack-plugin injects\n    if (window.SENTRY_RELEASE && window.SENTRY_RELEASE.id) {\n      options.release = window.SENTRY_RELEASE.id;\n    }\n  }\n  if (options.autoSessionTracking === undefined) {\n    options.autoSessionTracking = true;\n  }\n  if (options.sendClientReports === undefined) {\n    options.sendClientReports = true;\n  }\n\n  var clientOptions = {\n    ...options,\n    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n    integrations: getIntegrationsToSetup(options),\n    transport: options.transport || (supportsFetch() ? makeFetchTransport : makeXHRTransport),\n  };\n\n  initAndBind(BrowserClient, clientOptions);\n\n  if (options.autoSessionTracking) {\n    startSessionTracking();\n  }\n}\n\n/**\n * Present the user with a report dialog.\n *\n * @param options Everything is optional, we try to fetch all info need from the global scope.\n */\nfunction showReportDialog(options = {}, hub = getCurrentHub()) {\n  // doesn't work without a document (React Native)\n  var global = getGlobalObject();\n  if (!global.document) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Global document not defined in showReportDialog call');\n    return;\n  }\n\n  const { client, scope } = hub.getStackTop();\n  var dsn = options.dsn || (client && client.getDsn());\n  if (!dsn) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('DSN not configured for showReportDialog call');\n    return;\n  }\n\n  if (scope) {\n    options.user = {\n      ...scope.getUser(),\n      ...options.user,\n    };\n  }\n\n  if (!options.eventId) {\n    options.eventId = hub.lastEventId();\n  }\n\n  var script = global.document.createElement('script');\n  script.async = true;\n  script.src = getReportDialogEndpoint(dsn, options);\n\n  if (options.onLoad) {\n        script.onload = options.onLoad;\n  }\n\n  var injectionPoint = global.document.head || global.document.body;\n  if (injectionPoint) {\n    injectionPoint.appendChild(script);\n  } else {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Not injecting report dialog. No injection point found in HTML');\n  }\n}\n\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nfunction lastEventId() {\n  return getCurrentHub().lastEventId();\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction forceLoad() {\n  // Noop\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction onLoad(callback) {\n  callback();\n}\n\n/**\n * Call `flush()` on the current client, if there is one. See {@link Client.flush}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause\n * the client to wait until all events are sent before resolving the promise.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nfunction flush(timeout) {\n  var client = getCurrentHub().getClient();\n  if (client) {\n    return client.flush(timeout);\n  }\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events. No client defined.');\n  return resolvedSyncPromise(false);\n}\n\n/**\n * Call `close()` on the current client, if there is one. See {@link Client.close}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this\n * parameter will cause the client to wait until all events are sent before disabling itself.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nfunction close(timeout) {\n  var client = getCurrentHub().getClient();\n  if (client) {\n    return client.close(timeout);\n  }\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events and disable SDK. No client defined.');\n  return resolvedSyncPromise(false);\n}\n\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\nfunction wrap(fn) {\n  return wrap$1(fn)();\n}\n\nfunction startSessionOnHub(hub) {\n  hub.startSession({ ignoreDuration: true });\n  hub.captureSession();\n}\n\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking() {\n  var window = getGlobalObject();\n  var document = window.document;\n\n  if (typeof document === 'undefined') {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\n    return;\n  }\n\n  var hub = getCurrentHub();\n\n  // The only way for this to be false is for there to be a version mismatch between @sentry/browser (>= 6.0.0) and\n  // @sentry/hub (< 5.27.0). In the simple case, there won't ever be such a mismatch, because the two packages are\n  // pinned at the same version in package.json, but there are edge cases where it's possible. See\n  // https://github.com/getsentry/sentry-javascript/issues/3207 and\n  // https://github.com/getsentry/sentry-javascript/issues/3234 and\n  // https://github.com/getsentry/sentry-javascript/issues/3278.\n  if (!hub.captureSession) {\n    return;\n  }\n\n  // The session duration for browser sessions does not track a meaningful\n  // concept that can be used as a metric.\n  // Automatically captured sessions are akin to page views, and thus we\n  // discard their duration.\n  startSessionOnHub(hub);\n\n  // We want to create a session for every navigation as well\n  addInstrumentationHandler('history', ({ from, to }) => {\n    // Don't create an additional session for the initial route or if the location did not change\n    if (!(from === undefined || from === to)) {\n      startSessionOnHub(getCurrentHub());\n    }\n  });\n}\n\nexport { close, defaultIntegrations, flush, forceLoad, init, lastEventId, onLoad, showReportDialog, wrap };\n//# sourceMappingURL=sdk.js.map\n"],"sourceRoot":""}