{"version":3,"sources":["webpack:///./node_modules/@sentry/core/esm/transports/base.js","webpack:///./node_modules/@sentry/core/esm/integration.js","webpack:///./node_modules/@sentry/core/esm/sdk.js","webpack:///./node_modules/@sentry/core/esm/envelope.js","webpack:///./node_modules/@sentry/core/esm/baseclient.js","webpack:///./node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack:///./node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack:///./node_modules/@sentry/core/esm/index.js","webpack:///./node_modules/@sentry/core/esm/api.js","webpack:///./node_modules/@sentry/core/esm/version.js"],"names":["DEFAULT_TRANSPORT_BUFFER_SIZE","createTransport","options","makeRequest","buffer","bufferSize","rateLimits","flush","timeout","drain","send","envelope","filteredEnvelopeItems","item","type","envelopeItemDataCategory","recordDroppedEvent","push","length","filteredEnvelope","recordEnvelopeLoss","reason","_","requestTask","body","textEncoder","then","response","undefined","statusCode","__SENTRY_DEBUG__","warn","error","add","result","installedIntegrations","filterDuplicates","integrations","reduce","acc","every","accIntegration","name","getIntegrationsToSetup","defaultIntegrations","userIntegrations","Array","isArray","filter","userIntegration","integrationsNames","map","i","alwaysLastToRun","indexOf","splice","setupIntegrations","integrationIndex","forEach","integration","setupOnce","log","initAndBind","clientClass","debug","enable","console","hub","scope","getScope","update","initialScope","client","bindClient","getSdkMetadataForEnvelopeHeader","metadata","sdk","version","enhanceEventWithSdkInfo","event","sdkInfo","packages","createSessionEnvelope","session","dsn","tunnel","envelopeHeaders","sent_at","Date","toISOString","envelopeItem","createEventEnvelope","eventType","transactionSampling","sdkProcessingMetadata","method","samplingMethod","rate","sampleRate","createEventEnvelopeHeaders","eventItem","sample_rates","id","baggage","dynamicSamplingContext","event_id","trace","ALREADY_SEEN_ERROR","this","_integrations","_integrationsInitialized","_numProcessing","_outcomes","prototype","__init","call","__init2","__init3","__init4","_options","_dsn","url","_transport","transport","bind","transportOptions","logger","exception","hint","eventId","_process","eventFromException","_captureEvent","message","level","promisedEvent","is","eventFromMessage","String","originalException","_isEnabled","release","sendSession","init","_isClientDoneProcessing","clientFinished","transportFlushed","getOptions","enabled","integrationId","_oO","env","_metadata","attachment","attachments","_sendEnvelope","category","sendClientReports","key","crashed","errored","exceptions","values","ex","mechanism","handled","sessionNonTerminal","status","shouldUpdateAndSend","errors","Number","captureSession","resolve","ticked","tick","interval","setInterval","clearInterval","normalizeDepth","normalizeMaxBreadth","prepared","timestamp","_applyClientOptions","_applyIntegrationsMetadata","finalScope","captureContext","clone","getAttachments","applyToEvent","evt","_normalizeEvent","depth","maxBreadth","normalized","breadcrumbs","b","data","normalize","user","contexts","extra","spans","span","environment","dist","maxValueLength","value","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","e","originalFunctionToString","Function","toString","args","context","apply","__initStatic","DEFAULT_IGNORE_ERRORS","InboundFilters","addGlobalEventProcessor","getCurrentHub","eventProcess","self","getIntegration","getClient","clientOptions","_mergeOptions","_shouldDropEvent","internalOptions","allowUrls","denyUrls","ignoreErrors","ignoreInternal","_isSentryError","_isIgnoredError","_isDeniedUrl","_getEventFilterUrl","_isAllowedUrl","_getPossibleEventMessages","some","pattern","oO","_getLastValidUrl","frames","frame","filename","stacktrace","SENTRY_API_VERSION","getBaseApiEndpoint","protocol","port","host","path","_getIngestEndpoint","projectId","_encodedAuth","sentry_key","publicKey","sentry_version","sentry_client","getEnvelopeEndpointWithUrlEncodedAuth","tunnelOrOptions","getReportDialogEndpoint","dsnLike","dialogOptions","endpoint","encodedOptions","encodeURIComponent","email","SDK_VERSION"],"mappings":"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","file":"js/chunk-vendors~497c279b.a44043a3.js","sourcesContent":["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 { 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 { 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","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 { 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","export { Hub, Scope, addBreadcrumb, addGlobalEventProcessor, captureEvent, captureException, captureMessage, configureScope, getCurrentHub, getHubFromCarrier, makeMain, setContext, setExtra, setExtras, setTag, setTags, setUser, startTransaction, withScope } from '@sentry/hub';\nexport { getEnvelopeEndpointWithUrlEncodedAuth, getReportDialogEndpoint } from './api.js';\nexport { BaseClient } from './baseclient.js';\nexport { initAndBind } from './sdk.js';\nexport { createTransport } from './transports/base.js';\nexport { SDK_VERSION } from './version.js';\nexport { getIntegrationsToSetup } from './integration.js';\nimport * as index from './integrations/index.js';\nexport { index as Integrations };\nexport { FunctionToString } from './integrations/functiontostring.js';\nexport { InboundFilters } from './integrations/inboundfilters.js';\n\n;\n//# sourceMappingURL=index.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","var SDK_VERSION = '7.8.1';\n\nexport { SDK_VERSION };\n//# sourceMappingURL=version.js.map\n"],"sourceRoot":""}