{"version":3,"sources":["webpack:////workdir/node_modules/@sentry/core/esm/version.js","webpack:////workdir/node_modules/@sentry/core/esm/integration.js","webpack:////workdir/node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack:////workdir/node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack:////workdir/node_modules/@sentry/core/esm/transports/base.js","webpack:////workdir/node_modules/@sentry/core/esm/api.js","webpack:////workdir/node_modules/@sentry/core/esm/envelope.js","webpack:////workdir/node_modules/@sentry/core/esm/baseclient.js","webpack:////workdir/node_modules/@sentry/core/esm/sdk.js"],"names":["SDK_VERSION","installedIntegrations","filterDuplicates","integrations","reduce","acc","every","accIntegration","name","push","getIntegrationsToSetup","options","defaultIntegrations","userIntegrations","Array","isArray","filter","userIntegration","integrationsNames","map","i","alwaysLastToRun","indexOf","splice","setupIntegrations","integrationIndex","forEach","integration","setupOnce","__SENTRY_DEBUG__","log","originalFunctionToString","prototype","__init","call","this","id","Function","toString","args","context","apply","__initStatic","DEFAULT_IGNORE_ERRORS","InboundFilters","_options","addGlobalEventProcessor","getCurrentHub","eventProcess","event","hub","self","getIntegration","client","getClient","clientOptions","getOptions","_mergeOptions","_shouldDropEvent","internalOptions","allowUrls","denyUrls","ignoreErrors","ignoreInternal","undefined","_isSentryError","logger","warn","_isIgnoredError","_isDeniedUrl","_getEventFilterUrl","_isAllowedUrl","length","_getPossibleEventMessages","some","message","pattern","url","exception","type","value","values","oO","error","e","_getLastValidUrl","frames","frame","filename","stacktrace","DEFAULT_TRANSPORT_BUFFER_SIZE","createTransport","makeRequest","buffer","bufferSize","rateLimits","flush","timeout","drain","send","envelope","filteredEnvelopeItems","item","envelopeItemDataCategory","recordDroppedEvent","filteredEnvelope","recordEnvelopeLoss","reason","_","requestTask","body","textEncoder","then","response","statusCode","add","result","SENTRY_API_VERSION","getBaseApiEndpoint","dsn","protocol","port","host","path","_getIngestEndpoint","projectId","_encodedAuth","sdkInfo","sentry_key","publicKey","sentry_version","sentry_client","version","getEnvelopeEndpointWithUrlEncodedAuth","tunnelOrOptions","tunnel","_metadata","sdk","getReportDialogEndpoint","dsnLike","dialogOptions","endpoint","encodedOptions","key","user","encodeURIComponent","email","getSdkMetadataForEnvelopeHeader","metadata","enhanceEventWithSdkInfo","packages","createSessionEnvelope","session","envelopeHeaders","sent_at","Date","toISOString","envelopeItem","createEventEnvelope","eventType","transactionSampling","sdkProcessingMetadata","method","samplingMethod","rate","sampleRate","createEventEnvelopeHeaders","eventItem","sample_rates","baggage","dynamicSamplingContext","event_id","trace","ALREADY_SEEN_ERROR","_integrations","_integrationsInitialized","_numProcessing","_outcomes","__init2","__init3","__init4","_dsn","_transport","transport","bind","transportOptions","hint","scope","eventId","_process","eventFromException","_captureEvent","level","promisedEvent","is","eventFromMessage","String","originalException","_isEnabled","release","sendSession","init","_isClientDoneProcessing","clientFinished","transportFlushed","enabled","integrationId","_oO","env","attachment","attachments","_sendEnvelope","category","sendClientReports","crashed","errored","exceptions","ex","mechanism","handled","sessionNonTerminal","status","shouldUpdateAndSend","errors","Number","captureSession","resolve","ticked","tick","interval","setInterval","clearInterval","normalizeDepth","normalizeMaxBreadth","prepared","timestamp","_applyClientOptions","_applyIntegrationsMetadata","finalScope","captureContext","clone","update","getAttachments","applyToEvent","evt","_normalizeEvent","depth","maxBreadth","normalized","breadcrumbs","b","data","normalize","contexts","extra","spans","span","environment","dist","maxValueLength","request","integrationsArray","Object","keys","_processEvent","finalEvent","beforeSend","isTransaction","Math","random","_prepareEvent","isInternalException","__sentry__","beforeSendResult","_ensureBeforeSendRv","processedEvent","getSession","_updateSessionFromEvent","sendEvent","captureException","promise","outcomes","split","quantity","rv","nullErr","initAndBind","clientClass","debug","enable","console","getScope","initialScope","bindClient"],"mappings":"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","file":"static/js/app-c2a7cc4c.js","sourcesContent":["var SDK_VERSION = '7.10.0';\n\nexport { SDK_VERSION };\n//# sourceMappingURL=version.js.map\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\n\nvar installedIntegrations = [];\n\n/** Map of integrations assigned to a client */\n\n/**\n * @private\n */\nfunction filterDuplicates(integrations) {\n  return integrations.reduce((acc, integrations) => {\n    if (acc.every(accIntegration => integrations.name !== accIntegration.name)) {\n      acc.push(integrations);\n    }\n    return acc;\n  }, [] );\n}\n\n/** Gets integration to install */\nfunction getIntegrationsToSetup(options) {\n  var defaultIntegrations = (options.defaultIntegrations && [...options.defaultIntegrations]) || [];\n  var userIntegrations = options.integrations;\n\n  let integrations = [...filterDuplicates(defaultIntegrations)];\n\n  if (Array.isArray(userIntegrations)) {\n    // Filter out integrations that are also included in user options\n    integrations = [\n      ...integrations.filter(integrations =>\n        userIntegrations.every(userIntegration => userIntegration.name !== integrations.name),\n      ),\n      // And filter out duplicated user options integrations\n      ...filterDuplicates(userIntegrations),\n    ];\n  } else if (typeof userIntegrations === 'function') {\n    integrations = userIntegrations(integrations);\n    integrations = Array.isArray(integrations) ? integrations : [integrations];\n  }\n\n  // Make sure that if present, `Debug` integration will always run last\n  var integrationsNames = integrations.map(i => i.name);\n  var alwaysLastToRun = 'Debug';\n  if (integrationsNames.indexOf(alwaysLastToRun) !== -1) {\n    integrations.push(...integrations.splice(integrationsNames.indexOf(alwaysLastToRun), 1));\n  }\n\n  return integrations;\n}\n\n/**\n * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default\n * integrations are added unless they were already provided before.\n * @param integrations array of integration instances\n * @param withDefault should enable default integrations\n */\nfunction setupIntegrations(integrations) {\n  var integrationIndex = {};\n\n  integrations.forEach(integration => {\n    integrationIndex[integration.name] = integration;\n\n    if (installedIntegrations.indexOf(integration.name) === -1) {\n      integration.setupOnce(addGlobalEventProcessor, getCurrentHub);\n      installedIntegrations.push(integration.name);\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Integration installed: ${integration.name}`);\n    }\n  });\n\n  return integrationIndex;\n}\n\nexport { getIntegrationsToSetup, installedIntegrations, setupIntegrations };\n//# sourceMappingURL=integration.js.map\n","import { getOriginalFunction } from '@sentry/utils';\n\nlet originalFunctionToString;\n\n/** Patch toString calls to return proper name for wrapped functions */\nclass FunctionToString  {constructor() { FunctionToString.prototype.__init.call(this); }\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'FunctionToString';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = FunctionToString.id;}\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n        originalFunctionToString = Function.prototype.toString;\n\n        Function.prototype.toString = function ( ...args) {\n      var context = getOriginalFunction(this) || this;\n      return originalFunctionToString.apply(context, args);\n    };\n  }\n} FunctionToString.__initStatic();\n\nexport { FunctionToString };\n//# sourceMappingURL=functiontostring.js.map\n","import { logger, getEventDescription, isMatchingPattern } from '@sentry/utils';\n\n// \"Script error.\" is hard coded into browsers for errors that it can't read.\n// this is the result of a script being pulled in from an external domain and CORS.\nvar DEFAULT_IGNORE_ERRORS = [/^Script error\\.?$/, /^Javascript error: Script error\\.? on line 0$/];\n\n/** Options for the InboundFilters integration */\n\n/** Inbound filters configurable by the user */\nclass InboundFilters  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'InboundFilters';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = InboundFilters.id;}\n\n   constructor(  _options = {}) {;this._options = _options;InboundFilters.prototype.__init.call(this);}\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce(addGlobalEventProcessor, getCurrentHub) {\n    var eventProcess = (event) => {\n      var hub = getCurrentHub();\n      if (hub) {\n        var self = hub.getIntegration(InboundFilters);\n        if (self) {\n          var client = hub.getClient();\n          var clientOptions = client ? client.getOptions() : {};\n          var options = _mergeOptions(self._options, clientOptions);\n          return _shouldDropEvent(event, options) ? null : event;\n        }\n      }\n      return event;\n    };\n\n    eventProcess.id = this.name;\n    addGlobalEventProcessor(eventProcess);\n  }\n} InboundFilters.__initStatic();\n\n/** JSDoc */\nfunction _mergeOptions(\n  internalOptions = {},\n  clientOptions = {},\n) {\n  return {\n    allowUrls: [...(internalOptions.allowUrls || []), ...(clientOptions.allowUrls || [])],\n    denyUrls: [...(internalOptions.denyUrls || []), ...(clientOptions.denyUrls || [])],\n    ignoreErrors: [\n      ...(internalOptions.ignoreErrors || []),\n      ...(clientOptions.ignoreErrors || []),\n      ...DEFAULT_IGNORE_ERRORS,\n    ],\n    ignoreInternal: internalOptions.ignoreInternal !== undefined ? internalOptions.ignoreInternal : true,\n  };\n}\n\n/** JSDoc */\nfunction _shouldDropEvent(event, options) {\n  if (options.ignoreInternal && _isSentryError(event)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(`Event dropped due to being internal Sentry Error.\\nEvent: ${getEventDescription(event)}`);\n    return true;\n  }\n  if (_isIgnoredError(event, options.ignoreErrors)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        `Event dropped due to being matched by \\`ignoreErrors\\` option.\\nEvent: ${getEventDescription(event)}`,\n      );\n    return true;\n  }\n  if (_isDeniedUrl(event, options.denyUrls)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        `Event dropped due to being matched by \\`denyUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  if (!_isAllowedUrl(event, options.allowUrls)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        `Event dropped due to not being matched by \\`allowUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  return false;\n}\n\nfunction _isIgnoredError(event, ignoreErrors) {\n  if (!ignoreErrors || !ignoreErrors.length) {\n    return false;\n  }\n\n  return _getPossibleEventMessages(event).some(message =>\n    ignoreErrors.some(pattern => isMatchingPattern(message, pattern)),\n  );\n}\n\nfunction _isDeniedUrl(event, denyUrls) {\n  // TODO: Use Glob instead?\n  if (!denyUrls || !denyUrls.length) {\n    return false;\n  }\n  var url = _getEventFilterUrl(event);\n  return !url ? false : denyUrls.some(pattern => isMatchingPattern(url, pattern));\n}\n\nfunction _isAllowedUrl(event, allowUrls) {\n  // TODO: Use Glob instead?\n  if (!allowUrls || !allowUrls.length) {\n    return true;\n  }\n  var url = _getEventFilterUrl(event);\n  return !url ? true : allowUrls.some(pattern => isMatchingPattern(url, pattern));\n}\n\nfunction _getPossibleEventMessages(event) {\n  if (event.message) {\n    return [event.message];\n  }\n  if (event.exception) {\n    try {\n      const { type = '', value = '' } = (event.exception.values && event.exception.values[0]) || {};\n      return [`${value}`, `${type}: ${value}`];\n    } catch (oO) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(`Cannot extract message for event ${getEventDescription(event)}`);\n      return [];\n    }\n  }\n  return [];\n}\n\nfunction _isSentryError(event) {\n  try {\n    // @ts-ignore can't be a sentry error if undefined\n        return event.exception.values[0].type === 'SentryError';\n  } catch (e) {\n    // ignore\n  }\n  return false;\n}\n\nfunction _getLastValidUrl(frames = []) {\n  for (let i = frames.length - 1; i >= 0; i--) {\n    var frame = frames[i];\n\n    if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {\n      return frame.filename || null;\n    }\n  }\n\n  return null;\n}\n\nfunction _getEventFilterUrl(event) {\n  try {\n    let frames;\n    try {\n      // @ts-ignore we only care about frames if the whole thing here is defined\n      frames = event.exception.values[0].stacktrace.frames;\n    } catch (e) {\n      // ignore\n    }\n    return frames ? _getLastValidUrl(frames) : null;\n  } catch (oO) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(`Cannot extract url for event ${getEventDescription(event)}`);\n    return null;\n  }\n}\n\nexport { InboundFilters, _mergeOptions, _shouldDropEvent };\n//# sourceMappingURL=inboundfilters.js.map\n","import { makePromiseBuffer, forEachEnvelopeItem, envelopeItemTypeToDataCategory, isRateLimited, resolvedSyncPromise, createEnvelope, serializeEnvelope, logger, updateRateLimits, SentryError } from '@sentry/utils';\n\nvar DEFAULT_TRANSPORT_BUFFER_SIZE = 30;\n\n/**\n * Creates an instance of a Sentry `Transport`\n *\n * @param options\n * @param makeRequest\n */\nfunction createTransport(\n  options,\n  makeRequest,\n  buffer = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE),\n) {\n  let rateLimits = {};\n\n  var flush = (timeout) => buffer.drain(timeout);\n\n  function send(envelope) {\n    var filteredEnvelopeItems = [];\n\n    // Drop rate limited items from envelope\n    forEachEnvelopeItem(envelope, (item, type) => {\n      var envelopeItemDataCategory = envelopeItemTypeToDataCategory(type);\n      if (isRateLimited(rateLimits, envelopeItemDataCategory)) {\n        options.recordDroppedEvent('ratelimit_backoff', envelopeItemDataCategory);\n      } else {\n        filteredEnvelopeItems.push(item);\n      }\n    });\n\n    // Skip sending if envelope is empty after filtering out rate limited events\n    if (filteredEnvelopeItems.length === 0) {\n      return resolvedSyncPromise();\n    }\n\n        var filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems );\n\n    // Creates client report for each item in an envelope\n    var recordEnvelopeLoss = (reason) => {\n      forEachEnvelopeItem(filteredEnvelope, (_, type) => {\n        options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type));\n      });\n    };\n\n    var requestTask = () =>\n      makeRequest({ body: serializeEnvelope(filteredEnvelope, options.textEncoder) }).then(\n        response => {\n          // We don't want to throw on NOK responses, but we want to at least log them\n          if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {\n            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);\n          }\n\n          rateLimits = updateRateLimits(rateLimits, response);\n        },\n        error => {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Failed while sending event:', error);\n          recordEnvelopeLoss('network_error');\n        },\n      );\n\n    return buffer.add(requestTask).then(\n      result => result,\n      error => {\n        if (error instanceof SentryError) {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Skipped sending event due to full buffer');\n          recordEnvelopeLoss('queue_overflow');\n          return resolvedSyncPromise();\n        } else {\n          throw error;\n        }\n      },\n    );\n  }\n\n  return {\n    send,\n    flush,\n  };\n}\n\nexport { DEFAULT_TRANSPORT_BUFFER_SIZE, createTransport };\n//# sourceMappingURL=base.js.map\n","import { urlEncode, makeDsn, dsnToString } from '@sentry/utils';\n\nvar SENTRY_API_VERSION = '7';\n\n/** Returns the prefix to construct Sentry ingestion API endpoints. */\nfunction getBaseApiEndpoint(dsn) {\n  var protocol = dsn.protocol ? `${dsn.protocol}:` : '';\n  var port = dsn.port ? `:${dsn.port}` : '';\n  return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;\n}\n\n/** Returns the ingest API endpoint for target. */\nfunction _getIngestEndpoint(dsn) {\n  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;\n}\n\n/** Returns a URL-encoded string with auth config suitable for a query string. */\nfunction _encodedAuth(dsn, sdkInfo) {\n  return urlEncode({\n    // We send only the minimum set of required information. See\n    // https://github.com/getsentry/sentry-javascript/issues/2572.\n    sentry_key: dsn.publicKey,\n    sentry_version: SENTRY_API_VERSION,\n    ...(sdkInfo && { sentry_client: `${sdkInfo.name}/${sdkInfo.version}` }),\n  });\n}\n\n/**\n * Returns the envelope endpoint URL with auth in the query string.\n *\n * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n */\nfunction getEnvelopeEndpointWithUrlEncodedAuth(\n  dsn,\n  // TODO (v8): Remove `tunnelOrOptions` in favor of `options`, and use the substitute code below\n  // options: ClientOptions = {} as ClientOptions,\n  tunnelOrOptions = {} ,\n) {\n  // TODO (v8): Use this code instead\n  // const { tunnel, _metadata = {} } = options;\n  // return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, _metadata.sdk)}`;\n\n  var tunnel = typeof tunnelOrOptions === 'string' ? tunnelOrOptions : tunnelOrOptions.tunnel;\n  var sdkInfo =\n    typeof tunnelOrOptions === 'string' || !tunnelOrOptions._metadata ? undefined : tunnelOrOptions._metadata.sdk;\n\n  return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;\n}\n\n/** Returns the url to the report dialog endpoint. */\nfunction getReportDialogEndpoint(\n  dsnLike,\n  dialogOptions\n\n,\n) {\n  var dsn = makeDsn(dsnLike);\n  var endpoint = `${getBaseApiEndpoint(dsn)}embed/error-page/`;\n\n  let encodedOptions = `dsn=${dsnToString(dsn)}`;\n  for (var key in dialogOptions) {\n    if (key === 'dsn') {\n      continue;\n    }\n\n    if (key === 'user') {\n      var user = dialogOptions.user;\n      if (!user) {\n        continue;\n      }\n      if (user.name) {\n        encodedOptions += `&name=${encodeURIComponent(user.name)}`;\n      }\n      if (user.email) {\n        encodedOptions += `&email=${encodeURIComponent(user.email)}`;\n      }\n    } else {\n      encodedOptions += `&${encodeURIComponent(key)}=${encodeURIComponent(dialogOptions[key] )}`;\n    }\n  }\n\n  return `${endpoint}?${encodedOptions}`;\n}\n\nexport { getEnvelopeEndpointWithUrlEncodedAuth, getReportDialogEndpoint };\n//# sourceMappingURL=api.js.map\n","import { dsnToString, createEnvelope, dropUndefinedKeys, getSentryBaggageItems } from '@sentry/utils';\n\n/** Extract sdk info from from the API metadata */\nfunction getSdkMetadataForEnvelopeHeader(metadata) {\n  if (!metadata || !metadata.sdk) {\n    return;\n  }\n  const { name, version } = metadata.sdk;\n  return { name, version };\n}\n\n/**\n * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.\n * Merge with existing data if any.\n **/\nfunction enhanceEventWithSdkInfo(event, sdkInfo) {\n  if (!sdkInfo) {\n    return event;\n  }\n  event.sdk = event.sdk || {};\n  event.sdk.name = event.sdk.name || sdkInfo.name;\n  event.sdk.version = event.sdk.version || sdkInfo.version;\n  event.sdk.integrations = [...(event.sdk.integrations || []), ...(sdkInfo.integrations || [])];\n  event.sdk.packages = [...(event.sdk.packages || []), ...(sdkInfo.packages || [])];\n  return event;\n}\n\n/** Creates an envelope from a Session */\nfunction createSessionEnvelope(\n  session,\n  dsn,\n  metadata,\n  tunnel,\n) {\n  var sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n  var envelopeHeaders = {\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && { dsn: dsnToString(dsn) }),\n  };\n\n  var envelopeItem =\n    'aggregates' in session ? [{ type: 'sessions' }, session] : [{ type: 'session' }, session];\n\n  return createEnvelope(envelopeHeaders, [envelopeItem]);\n}\n\n/**\n * Create an Envelope from an event.\n */\nfunction createEventEnvelope(\n  event,\n  dsn,\n  metadata,\n  tunnel,\n) {\n  var sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n  var eventType = event.type || 'event';\n\n  const { transactionSampling } = event.sdkProcessingMetadata || {};\n  const { method: samplingMethod, rate: sampleRate } = transactionSampling || {};\n\n  enhanceEventWithSdkInfo(event, metadata && metadata.sdk);\n\n  var envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn);\n\n  // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to\n  // sentry. (Note: Our use of this property comes and goes with whatever we might be debugging, whatever hacks we may\n  // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid\n  // of this `delete`, lest we miss putting it back in the next time the property is in use.)\n  delete event.sdkProcessingMetadata;\n\n  var eventItem = [\n    {\n      type: eventType,\n      sample_rates: [{ id: samplingMethod, rate: sampleRate }],\n    },\n    event,\n  ];\n  return createEnvelope(envelopeHeaders, [eventItem]);\n}\n\nfunction createEventEnvelopeHeaders(\n  event,\n  sdkInfo,\n  tunnel,\n  dsn,\n) {\n  var baggage = event.sdkProcessingMetadata && event.sdkProcessingMetadata.baggage;\n  var dynamicSamplingContext = baggage && getSentryBaggageItems(baggage);\n\n  return {\n    event_id: event.event_id ,\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && { dsn: dsnToString(dsn) }),\n    ...(event.type === 'transaction' &&\n      dynamicSamplingContext && {\n        trace: dropUndefinedKeys({ ...dynamicSamplingContext }) ,\n      }),\n  };\n}\n\nexport { createEventEnvelope, createSessionEnvelope };\n//# sourceMappingURL=envelope.js.map\n","import { updateSession, Scope } from '@sentry/hub';\nimport { makeDsn, logger, checkOrSetAlreadyCaught, isPrimitive, resolvedSyncPromise, addItemToEnvelope, createAttachmentEnvelopeItem, SyncPromise, uuid4, dateTimestampInSeconds, normalize, truncate, rejectedSyncPromise, SentryError, isThenable, isPlainObject } from '@sentry/utils';\nimport { getEnvelopeEndpointWithUrlEncodedAuth } from './api.js';\nimport { createEventEnvelope, createSessionEnvelope } from './envelope.js';\nimport { setupIntegrations } from './integration.js';\n\nvar ALREADY_SEEN_ERROR = \"Not capturing exception because it's already been captured.\";\n\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}.\n *\n * If a Dsn is specified in the options, it will be parsed and stored. Use\n * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is\n * invalid, the constructor will throw a {@link SentryException}. Note that\n * without a valid Dsn, the SDK will not send any events to Sentry.\n *\n * Before sending an event, it is passed through\n * {@link BaseClient._prepareEvent} to add SDK information and scope data\n * (breadcrumbs and context). To add more custom information, override this\n * method and extend the resulting prepared event.\n *\n * To issue automatically created events (e.g. via instrumentation), use\n * {@link Client.captureEvent}. It will prepare the event and pass it through\n * the callback lifecycle. To issue auto-breadcrumbs, use\n * {@link Client.addBreadcrumb}.\n *\n * @example\n * class NodeClient extends BaseClient<NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(options);\n *   }\n *\n *   // ...\n * }\n */\nclass BaseClient {\n  /** Options passed to the SDK. */\n  \n\n  /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */\n  \n\n  /** Array of set up integrations. */\n   __init() {this._integrations = {};}\n\n  /** Indicates whether this client's integrations have been set up. */\n   __init2() {this._integrationsInitialized = false;}\n\n  /** Number of calls being processed */\n   __init3() {this._numProcessing = 0;}\n\n  /** Holds flushable  */\n   __init4() {this._outcomes = {};}\n\n  /**\n   * Initializes this client instance.\n   *\n   * @param options Options for the client.\n   */\n   constructor(options) {;BaseClient.prototype.__init.call(this);BaseClient.prototype.__init2.call(this);BaseClient.prototype.__init3.call(this);BaseClient.prototype.__init4.call(this);\n    this._options = options;\n    if (options.dsn) {\n      this._dsn = makeDsn(options.dsn);\n      var url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options);\n      this._transport = options.transport({\n        recordDroppedEvent: this.recordDroppedEvent.bind(this),\n        ...options.transportOptions,\n        url,\n      });\n    } else {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('No DSN provided, client will not do anything.');\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n     captureException(exception, hint, scope) {\n    // ensure we haven't captured this very object before\n    if (checkOrSetAlreadyCaught(exception)) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(ALREADY_SEEN_ERROR);\n      return;\n    }\n\n    let eventId = hint && hint.event_id;\n\n    this._process(\n      this.eventFromException(exception, hint)\n        .then(event => this._captureEvent(event, hint, scope))\n        .then(result => {\n          eventId = result;\n        }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureMessage(\n    message,\n        level,\n    hint,\n    scope,\n  ) {\n    let eventId = hint && hint.event_id;\n\n    var promisedEvent = isPrimitive(message)\n      ? this.eventFromMessage(String(message), level, hint)\n      : this.eventFromException(message, hint);\n\n    this._process(\n      promisedEvent\n        .then(event => this._captureEvent(event, hint, scope))\n        .then(result => {\n          eventId = result;\n        }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureEvent(event, hint, scope) {\n    // ensure we haven't captured this very object before\n    if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(ALREADY_SEEN_ERROR);\n      return;\n    }\n\n    let eventId = hint && hint.event_id;\n\n    this._process(\n      this._captureEvent(event, hint, scope).then(result => {\n        eventId = result;\n      }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureSession(session) {\n    if (!this._isEnabled()) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('SDK not enabled, will not capture session.');\n      return;\n    }\n\n    if (!(typeof session.release === 'string')) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Discarded session because of missing or non-string release');\n    } else {\n      this.sendSession(session);\n      // After sending, we set init false to indicate it's not the first occurrence\n      updateSession(session, { init: false });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getDsn() {\n    return this._dsn;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getOptions() {\n    return this._options;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getTransport() {\n    return this._transport;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   flush(timeout) {\n    var transport = this._transport;\n    if (transport) {\n      return this._isClientDoneProcessing(timeout).then(clientFinished => {\n        return transport.flush(timeout).then(transportFlushed => clientFinished && transportFlushed);\n      });\n    } else {\n      return resolvedSyncPromise(true);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   close(timeout) {\n    return this.flush(timeout).then(result => {\n      this.getOptions().enabled = false;\n      return result;\n    });\n  }\n\n  /**\n   * Sets up the integrations\n   */\n   setupIntegrations() {\n    if (this._isEnabled() && !this._integrationsInitialized) {\n      this._integrations = setupIntegrations(this._options.integrations);\n      this._integrationsInitialized = true;\n    }\n  }\n\n  /**\n   * Gets an installed integration by its `id`.\n   *\n   * @returns The installed integration or `undefined` if no integration with that `id` was installed.\n   */\n   getIntegrationById(integrationId) {\n    return this._integrations[integrationId];\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getIntegration(integration) {\n    try {\n      return (this._integrations[integration.id] ) || null;\n    } catch (_oO) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Cannot retrieve integration ${integration.id} from the current Client`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendEvent(event, hint = {}) {\n    if (this._dsn) {\n      let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);\n\n      for (var attachment of hint.attachments || []) {\n        env = addItemToEnvelope(\n          env,\n          createAttachmentEnvelopeItem(\n            attachment,\n            this._options.transportOptions && this._options.transportOptions.textEncoder,\n          ),\n        );\n      }\n\n      this._sendEnvelope(env);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendSession(session) {\n    if (this._dsn) {\n      var env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);\n      this._sendEnvelope(env);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   recordDroppedEvent(reason, category) {\n    if (this._options.sendClientReports) {\n      // We want to track each category (error, transaction, session) separately\n      // but still keep the distinction between different type of outcomes.\n      // We could use nested maps, but it's much easier to read and type this way.\n      // A correct type for map-based implementation if we want to go that route\n      // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`\n      // With typescript 4.1 we could even use template literal types\n      var key = `${reason}:${category}`;\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Adding outcome: \"${key}\"`);\n\n      // The following works because undefined + 1 === NaN and NaN is falsy\n      this._outcomes[key] = this._outcomes[key] + 1 || 1;\n    }\n  }\n\n  /** Updates existing session based on the provided event */\n   _updateSessionFromEvent(session, event) {\n    let crashed = false;\n    let errored = false;\n    var exceptions = event.exception && event.exception.values;\n\n    if (exceptions) {\n      errored = true;\n\n      for (var ex of exceptions) {\n        var mechanism = ex.mechanism;\n        if (mechanism && mechanism.handled === false) {\n          crashed = true;\n          break;\n        }\n      }\n    }\n\n    // A session is updated and that session update is sent in only one of the two following scenarios:\n    // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update\n    // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update\n    var sessionNonTerminal = session.status === 'ok';\n    var shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);\n\n    if (shouldUpdateAndSend) {\n      updateSession(session, {\n        ...(crashed && { status: 'crashed' }),\n        errors: session.errors || Number(errored || crashed),\n      });\n      this.captureSession(session);\n    }\n  }\n\n  /**\n   * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying\n   * \"no\" (resolving to `false`) in order to give the client a chance to potentially finish first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not\n   * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and\n   * `false` otherwise\n   */\n   _isClientDoneProcessing(timeout) {\n    return new SyncPromise(resolve => {\n      let ticked = 0;\n      var tick = 1;\n\n      var interval = setInterval(() => {\n        if (this._numProcessing == 0) {\n          clearInterval(interval);\n          resolve(true);\n        } else {\n          ticked += tick;\n          if (timeout && ticked >= timeout) {\n            clearInterval(interval);\n            resolve(false);\n          }\n        }\n      }, tick);\n    });\n  }\n\n  /** Determines whether this SDK is enabled and a valid Dsn is present. */\n   _isEnabled() {\n    return this.getOptions().enabled !== false && this._dsn !== undefined;\n  }\n\n  /**\n   * Adds common information to events.\n   *\n   * The information includes release and environment from `options`,\n   * breadcrumbs and context (extra, tags and user) from the scope.\n   *\n   * Information that is already present in the event is never overwritten. For\n   * nested objects, such as the context, keys are merged.\n   *\n   * @param event The original event.\n   * @param hint May contain additional information about the original exception.\n   * @param scope A scope containing event metadata.\n   * @returns A new event with more information.\n   */\n   _prepareEvent(event, hint, scope) {\n    const { normalizeDepth = 3, normalizeMaxBreadth = 1000 } = this.getOptions();\n    var prepared = {\n      ...event,\n      event_id: event.event_id || hint.event_id || uuid4(),\n      timestamp: event.timestamp || dateTimestampInSeconds(),\n    };\n\n    this._applyClientOptions(prepared);\n    this._applyIntegrationsMetadata(prepared);\n\n    // If we have scope given to us, use it as the base for further modifications.\n    // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.\n    let finalScope = scope;\n    if (hint.captureContext) {\n      finalScope = Scope.clone(finalScope).update(hint.captureContext);\n    }\n\n    // We prepare the result here with a resolved Event.\n    let result = resolvedSyncPromise(prepared);\n\n    // This should be the last thing called, since we want that\n    // {@link Hub.addEventProcessor} gets the finished prepared event.\n    if (finalScope) {\n      // Collect attachments from the hint and scope\n      var attachments = [...(hint.attachments || []), ...finalScope.getAttachments()];\n\n      if (attachments.length) {\n        hint.attachments = attachments;\n      }\n\n      // In case we have a hub we reassign it.\n      result = finalScope.applyToEvent(prepared, hint);\n    }\n\n    return result.then(evt => {\n      if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n        return this._normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);\n      }\n      return evt;\n    });\n  }\n\n  /**\n   * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.\n   * Normalized keys:\n   * - `breadcrumbs.data`\n   * - `user`\n   * - `contexts`\n   * - `extra`\n   * @param event Event\n   * @returns Normalized event\n   */\n   _normalizeEvent(event, depth, maxBreadth) {\n    if (!event) {\n      return null;\n    }\n\n    var normalized = {\n      ...event,\n      ...(event.breadcrumbs && {\n        breadcrumbs: event.breadcrumbs.map(b => ({\n          ...b,\n          ...(b.data && {\n            data: normalize(b.data, depth, maxBreadth),\n          }),\n        })),\n      }),\n      ...(event.user && {\n        user: normalize(event.user, depth, maxBreadth),\n      }),\n      ...(event.contexts && {\n        contexts: normalize(event.contexts, depth, maxBreadth),\n      }),\n      ...(event.extra && {\n        extra: normalize(event.extra, depth, maxBreadth),\n      }),\n    };\n\n    // event.contexts.trace stores information about a Transaction. Similarly,\n    // event.spans[] stores information about child Spans. Given that a\n    // Transaction is conceptually a Span, normalization should apply to both\n    // Transactions and Spans consistently.\n    // For now the decision is to skip normalization of Transactions and Spans,\n    // so this block overwrites the normalized event to add back the original\n    // Transaction information prior to normalization.\n    if (event.contexts && event.contexts.trace && normalized.contexts) {\n      normalized.contexts.trace = event.contexts.trace;\n\n      // event.contexts.trace.data may contain circular/dangerous data so we need to normalize it\n      if (event.contexts.trace.data) {\n        normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);\n      }\n    }\n\n    // event.spans[].data may contain circular/dangerous data so we need to normalize it\n    if (event.spans) {\n      normalized.spans = event.spans.map(span => {\n        // We cannot use the spread operator here because `toJSON` on `span` is non-enumerable\n        if (span.data) {\n          span.data = normalize(span.data, depth, maxBreadth);\n        }\n        return span;\n      });\n    }\n\n    return normalized;\n  }\n\n  /**\n   *  Enhances event using the client configuration.\n   *  It takes care of all \"static\" values like environment, release and `dist`,\n   *  as well as truncating overly long values.\n   * @param event event instance to be enhanced\n   */\n   _applyClientOptions(event) {\n    var options = this.getOptions();\n    const { environment, release, dist, maxValueLength = 250 } = options;\n\n    if (!('environment' in event)) {\n      event.environment = 'environment' in options ? environment : 'production';\n    }\n\n    if (event.release === undefined && release !== undefined) {\n      event.release = release;\n    }\n\n    if (event.dist === undefined && dist !== undefined) {\n      event.dist = dist;\n    }\n\n    if (event.message) {\n      event.message = truncate(event.message, maxValueLength);\n    }\n\n    var exception = event.exception && event.exception.values && event.exception.values[0];\n    if (exception && exception.value) {\n      exception.value = truncate(exception.value, maxValueLength);\n    }\n\n    var request = event.request;\n    if (request && request.url) {\n      request.url = truncate(request.url, maxValueLength);\n    }\n  }\n\n  /**\n   * This function adds all used integrations to the SDK info in the event.\n   * @param event The event that will be filled with all integrations.\n   */\n   _applyIntegrationsMetadata(event) {\n    var integrationsArray = Object.keys(this._integrations);\n    if (integrationsArray.length > 0) {\n      event.sdk = event.sdk || {};\n      event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationsArray];\n    }\n  }\n\n  /**\n   * Processes the event and logs an error in case of rejection\n   * @param event\n   * @param hint\n   * @param scope\n   */\n   _captureEvent(event, hint = {}, scope) {\n    return this._processEvent(event, hint, scope).then(\n      finalEvent => {\n        return finalEvent.event_id;\n      },\n      reason => {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(reason);\n        return undefined;\n      },\n    );\n  }\n\n  /**\n   * Processes an event (either error or message) and sends it to Sentry.\n   *\n   * This also adds breadcrumbs and context information to the event. However,\n   * platform specific meta data (such as the User's IP address) must be added\n   * by the SDK implementor.\n   *\n   *\n   * @param event The event to send to Sentry.\n   * @param hint May contain additional information about the original exception.\n   * @param scope A scope containing event metadata.\n   * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.\n   */\n   _processEvent(event, hint, scope) {\n    const { beforeSend, sampleRate } = this.getOptions();\n\n    if (!this._isEnabled()) {\n      return rejectedSyncPromise(new SentryError('SDK not enabled, will not capture event.'));\n    }\n\n    var isTransaction = event.type === 'transaction';\n    // 1.0 === 100% events are sent\n    // 0.0 === 0% events are sent\n    // Sampling for transaction happens somewhere else\n    if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {\n      this.recordDroppedEvent('sample_rate', 'error');\n      return rejectedSyncPromise(\n        new SentryError(\n          `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,\n        ),\n      );\n    }\n\n    return this._prepareEvent(event, hint, scope)\n      .then(prepared => {\n        if (prepared === null) {\n          this.recordDroppedEvent('event_processor', event.type || 'error');\n          throw new SentryError('An event processor returned null, will not send event.');\n        }\n\n        var isInternalException = hint.data && (hint.data ).__sentry__ === true;\n        if (isInternalException || isTransaction || !beforeSend) {\n          return prepared;\n        }\n\n        var beforeSendResult = beforeSend(prepared, hint);\n        return _ensureBeforeSendRv(beforeSendResult);\n      })\n      .then(processedEvent => {\n        if (processedEvent === null) {\n          this.recordDroppedEvent('before_send', event.type || 'error');\n          throw new SentryError('`beforeSend` returned `null`, will not send event.');\n        }\n\n        var session = scope && scope.getSession();\n        if (!isTransaction && session) {\n          this._updateSessionFromEvent(session, processedEvent);\n        }\n\n        this.sendEvent(processedEvent, hint);\n        return processedEvent;\n      })\n      .then(null, reason => {\n        if (reason instanceof SentryError) {\n          throw reason;\n        }\n\n        this.captureException(reason, {\n          data: {\n            __sentry__: true,\n          },\n          originalException: reason ,\n        });\n        throw new SentryError(\n          `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: ${reason}`,\n        );\n      });\n  }\n\n  /**\n   * Occupies the client with processing and event\n   */\n   _process(promise) {\n    this._numProcessing += 1;\n    void promise.then(\n      value => {\n        this._numProcessing -= 1;\n        return value;\n      },\n      reason => {\n        this._numProcessing -= 1;\n        return reason;\n      },\n    );\n  }\n\n  /**\n   * @inheritdoc\n   */\n   _sendEnvelope(envelope) {\n    if (this._transport && this._dsn) {\n      this._transport.send(envelope).then(null, reason => {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Error while sending event:', reason);\n      });\n    } else {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Transport disabled');\n    }\n  }\n\n  /**\n   * Clears outcomes on this client and returns them.\n   */\n   _clearOutcomes() {\n    var outcomes = this._outcomes;\n    this._outcomes = {};\n    return Object.keys(outcomes).map(key => {\n      const [reason, category] = key.split(':') ;\n      return {\n        reason,\n        category,\n        quantity: outcomes[key],\n      };\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n    \n\n}\n\n/**\n * Verifies that return value of configured `beforeSend` is of expected type.\n */\nfunction _ensureBeforeSendRv(rv) {\n  var nullErr = '`beforeSend` method has to return `null` or a valid event.';\n  if (isThenable(rv)) {\n    return rv.then(\n      event => {\n        if (!(isPlainObject(event) || event === null)) {\n          throw new SentryError(nullErr);\n        }\n        return event;\n      },\n      e => {\n        throw new SentryError(`beforeSend rejected with ${e}`);\n      },\n    );\n  } else if (!(isPlainObject(rv) || rv === null)) {\n    throw new SentryError(nullErr);\n  }\n  return rv;\n}\n\nexport { BaseClient };\n//# sourceMappingURL=baseclient.js.map\n","import { getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\n\n/** A class object that can instantiate Client objects. */\n\n/**\n * Internal function to create a new SDK client instance. The client is\n * installed and then bound to the current scope.\n *\n * @param clientClass The client class to instantiate.\n * @param options Options to pass to the client.\n */\nfunction initAndBind(\n  clientClass,\n  options,\n) {\n  if (options.debug === true) {\n    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n      logger.enable();\n    } else {\n      // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped\n            console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');\n    }\n  }\n  var hub = getCurrentHub();\n  var scope = hub.getScope();\n  if (scope) {\n    scope.update(options.initialScope);\n  }\n\n  var client = new clientClass(options);\n  hub.bindClient(client);\n}\n\nexport { initAndBind };\n//# sourceMappingURL=sdk.js.map\n"],"sourceRoot":""}