{"version":3,"sources":["webpack:///./node_modules/@sentry/tracing/esm/hubextensions.js","webpack:///./node_modules/@sentry/tracing/esm/transaction.js","webpack:///./node_modules/@sentry/tracing/esm/utils.js","webpack:///./node_modules/@sentry/utils/esm/normalize.js","webpack:///./node_modules/@sentry/utils/esm/syncpromise.js","webpack:///./node_modules/@sentry/hub/esm/scope.js","webpack:///./node_modules/@sentry/tracing/esm/idletransaction.js","webpack:///./node_modules/@sentry/utils/esm/clientreport.js","webpack:///./node_modules/@sentry/utils/esm/buildPolyfills/_nullishCoalesce.js","webpack:///./node_modules/@sentry/utils/esm/env.js","webpack:///./node_modules/@sentry/tracing/esm/span.js","webpack:///./node_modules/@sentry/utils/esm/dsn.js","webpack:///./node_modules/@sentry/utils/esm/promisebuffer.js","webpack:///./node_modules/@sentry/tracing/esm/browser/backgroundtab.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/bindReporter.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/generateUniqueID.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/initMetric.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/observe.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/onHidden.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/getCLS.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/getVisibilityWatcher.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/getFID.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/getLCP.js","webpack:///./node_modules/@sentry/tracing/esm/browser/metrics/utils.js","webpack:///./node_modules/@sentry/tracing/esm/browser/metrics/index.js","webpack:///./node_modules/@sentry/tracing/esm/browser/request.js","webpack:///./node_modules/@sentry/tracing/esm/browser/router.js","webpack:///./node_modules/@sentry/tracing/esm/browser/browsertracing.js","webpack:///./node_modules/@sentry/tracing/esm/index.js","webpack:///./node_modules/@sentry/utils/esm/buildPolyfills/_optionalChain.js","webpack:///./node_modules/@sentry/utils/esm/ratelimit.js","webpack:///./node_modules/@sentry/utils/esm/baggage.js","webpack:///./node_modules/@sentry/utils/esm/time.js","webpack:///./node_modules/@sentry/hub/esm/hub.js","webpack:///./node_modules/@sentry/utils/esm/envelope.js","webpack:///./node_modules/@sentry/utils/esm/stacktrace.js","webpack:///./node_modules/@sentry/utils/esm/browser.js","webpack:///./node_modules/@sentry/utils/esm/memo.js","webpack:///./node_modules/@sentry/hub/esm/exports.js","webpack:///./node_modules/@sentry/hub/esm/session.js","webpack:///./node_modules/@sentry/utils/esm/severity.js","webpack:///./node_modules/@sentry/utils/esm/global.js","webpack:///./node_modules/@sentry/tracing/esm/errors.js","webpack:///./node_modules/@sentry/utils/esm/supports.js","webpack:///./node_modules/@sentry/utils/esm/object.js","webpack:///./node_modules/@sentry/utils/esm/instrument.js","webpack:///./node_modules/@sentry/utils/esm/logger.js","webpack:///./node_modules/@sentry/utils/esm/tracing.js","webpack:///./node_modules/@sentry/utils/esm/is.js","webpack:///./node_modules/@sentry/utils/esm/error.js","webpack:///./node_modules/@sentry/utils/esm/misc.js","webpack:///./node_modules/@sentry/utils/esm/node.js","webpack:///./node_modules/@sentry/utils/esm/string.js"],"names":["traceHeaders","scope","this","getScope","span","getSpan","toTraceparent","sample","transaction","options","samplingContext","sampled","undefined","setMetadata","transactionSampling","method","sampleRate","tracesSampler","rate","Number","parentSampled","tracesSampleRate","isValidSampleRate","Math","random","__SENTRY_DEBUG__","log","op","name","warn","JSON","stringify","_startTransaction","transactionContext","customSamplingContext","client","getClient","getOptions","initSpanRecorder","_experiments","startIdleTransaction","hub","idleTimeout","finalTimeout","onScope","_addTracingExtensions","carrier","__SENTRY__","extensions","startTransaction","_autoloadDatabaseIntegrations","packageToIntegrationMapping","integration","module","Mongo","mongoose","Mysql","Postgres","mappedPackages","Object","keys","filter","moduleName","map","pkg","e","p","length","integrations","addExtensionMethods","Transaction","_measurements","super","prototype","__init","call","_hub","_name","metadata","spanMetadata","_trimEnd","trimEnd","newName","source","maxlen","spanRecorder","add","value","unit","newMetadata","endTimestamp","finish","finishedSpans","spans","s","reduce","prev","current","contexts","trace","getTraceContext","start_timestamp","startTimestamp","tags","timestamp","type","sdkProcessingMetadata","baggage","getBaggage","transaction_info","hasMeasurements","measurements","captureEvent","recordDroppedEvent","spanContext","toContext","updateWithContext","existingBaggage","finalBaggage","_populateBaggageWithSentryValues","environment","release","publicKey","public_key","getDsn","sample_rate","toString","segment","user_segment","getUser","trace_id","traceId","hasTracingEnabled","maybeOptions","getActiveTransaction","maybeHub","getTransaction","msToSec","time","normalize","input","depth","Infinity","maxProperties","visit","err","ERROR","normalizeToSize","object","maxSize","normalized","jsonSize","key","memo","memoize","unmemoize","includes","stringified","stringifyValue","startsWith","replace","valueWithToJSON","toJSON","jsonValue","Array","isArray","numAdded","visitable","visitKey","hasOwnProperty","visitValue","_events","global","window","document","String","getPrototypeOf","constructor","utf8Length","encodeURI","split","States","resolvedSyncPromise","SyncPromise","resolve","rejectedSyncPromise","reason","_","reject","PENDING","RESOLVED","REJECTED","_state","_handlers","executor","__init2","__init3","__init4","__init5","__init6","_resolve","_reject","onfulfilled","onrejected","push","result","_executeHandlers","then","val","onfinally","isRejected","_setResult","state","_value","cachedHandlers","slice","forEach","handler","MAX_BREADCRUMBS","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","newScope","_level","_span","_session","_transactionName","_fingerprint","_requestSession","callback","user","_notifyScopeListeners","requestSession","extras","extra","fingerprint","level","context","session","captureContext","updatedScope","breadcrumb","maxBreadcrumbs","maxCrumbs","min","mergedBreadcrumb","attachment","event","hint","transactionName","_applyFingerprint","breadcrumbs","_notifyEventProcessors","getGlobalEventProcessors","newData","processors","index","processor","id","final","concat","addGlobalEventProcessor","DEFAULT_IDLE_TIMEOUT","DEFAULT_FINAL_TIMEOUT","HEARTBEAT_INTERVAL","IdleTransactionSpanRecorder","_pushActivity","_popActivity","transactionSpanId","spanId","IdleTransaction","activities","_heartbeatCounter","_finished","_beforeFinishCallbacks","_idleHub","_idleTimeout","_finalTimeout","_onScope","clearActiveTransaction","configureScope","setSpan","_startIdleTimeout","setTimeout","setStatus","Date","toISOString","keepSpan","pushActivity","popActivity","_pingHeartbeat","_idleTimeoutID","clearTimeout","_cancelIdleTimeout","heartbeatString","join","_prevHeartbeatString","_beat","createClientReportEnvelope","discarded_events","dsn","clientReportItem","_nullishCoalesce","lhs","rhsFn","isBrowserBundle","__SENTRY_BROWSER_BUNDLE__","SpanRecorder","_maxlen","Span","substring","data","parentSpanId","description","status","childSpan","opStr","nameStr","idStr","logMessage","httpStatus","setTag","spanStatus","spanStatusfromHttpCode","sampledString","parent_span_id","span_id","DSN_REGEX","isValidProtocol","protocol","dsnToString","withPassword","host","path","pass","port","projectId","dsnFromString","str","match","exec","lastPath","pop","projectMatch","dsnFromComponents","components","validateDsn","requiredComponents","component","isNaN","parseInt","makeDsn","from","makePromiseBuffer","limit","buffer","isReady","remove","task","splice","indexOf","taskProducer","drain","timeout","counter","capturedSetTimeout","item","$","registerBackgroundTabDetection","addEventListener","activeTransaction","hidden","statusType","logger","bindReporter","metric","reportAllChanges","prevValue","forceReport","delta","generateUniqueID","now","floor","initMetric","entries","observe","PerformanceObserver","supportedEntryTypes","self","po","l","getEntries","buffered","onHidden","cb","once","onHiddenOrPageHide","visibilityState","removeEventListener","getCLS","onReport","report","sessionValue","sessionEntries","entryHandler","entry","hadRecentInput","firstSessionEntry","lastSessionEntry","startTime","takeRecords","firstHiddenTime","initHiddenTime","trackChanges","timeStamp","getVisibilityWatcher","getFID","visibilityWatcher","processingStart","disconnect","reportedMetricIDs","getLCP","stopListening","capture","isMeasurementValue","isFinite","_startChild","ctx","startChild","getBrowserPerformanceAPI","performance","_lcpEntry","_clsEntry","_performanceCursor","startTrackingWebVitals","mark","_trackCLS","_trackLCP","_trackFID","timeOrigin","addPerformanceEntries","performanceEntries","responseStartTimestamp","requestStartTimestamp","duration","entryType","_addNavigationSpans","responseStart","requestStart","_addMeasureSpans","firstHidden","shouldRecord","resourceName","location","origin","_addResourceSpans","max","_trackNavigator","oldValue","measurementTimestamp","normalizedValue","abs","cls","measurementName","setMeasurement","_tagMetricInfo","measureStartTimestamp","measureEndTimestamp","_addPerformanceNavigationTiming","_addRequest","eventEnd","end","start","responseEnd","initiatorType","transferSize","encodedBodySize","decodedBodySize","navigator","connection","effectiveType","rtt","downlink","deviceMemory","hardwareConcurrency","element","url","trim","size","sources","node","DEFAULT_TRACING_ORIGINS","defaultRequestInstrumentationOptions","traceFetch","traceXHR","tracingOrigins","instrumentOutgoingRequests","_options","shouldCreateSpanForRequest","urlMap","defaultShouldCreateSpan","origins","some","shouldCreateSpan","handlerData","fetchCallback","xhrCallback","fetchData","__span","response","setHttpStatus","error","request","args","headers","addTracingHeaders","incomingBaggage","is","Request","append","get","headerBaggageString","find","xhr","__sentry_own_request__","__sentry_xhr__","__sentry_xhr_span_id__","status_code","setRequestHeader","getRequestHeader","instrumentRoutingWithDefaults","customStartTransaction","startTransactionOnPageLoad","startTransactionOnLocationChange","startingUrl","href","pathname","to","BROWSER_TRACING_INTEGRATION_ID","DEFAULT_BROWSER_TRACING_OPTIONS","markBackgroundTransactions","routingInstrumentation","_emitOptionsWarning","_metricOptions","_reportAllChanges","getCurrentHub","_getCurrentHub","instrumentRouting","_createRouteTransaction","beforeNavigate","parentContextFromHeader","extractTraceDataFromMetaTags","expandedContext","modifiedContext","finalContext","idleTransaction","registerBeforeFinishCallback","Boolean","sentrytraceValue","getMetaContent","baggageValue","sentrytraceData","metaName","globalObject","querySelector","el","getAttribute","__SENTRY_TRACING__","_optionalChain","ops","lastAccessLHS","i","fn","DEFAULT_RETRY_AFTER","parseRetryAfterHeader","header","headerDelay","headerDate","parse","disabledUntil","limits","category","all","isRateLimited","updateRateLimits","statusCode","updatedRateLimits","rateLimitHeader","retryAfterHeader","retryAfter","categories","delay","BAGGAGE_HEADER_NAME","SENTRY_BAGGAGE_KEY_PREFIX","SENTRY_BAGGAGE_KEY_PREFIX_REGEX","MAX_BAGGAGE_STRING_LENGTH","createBaggage","initItems","baggageString","mutable","isSentryBaggageEmpty","getSentryBaggageItems","getThirdPartyBaggage","isBaggageMutable","setBaggageImmutable","serializeBaggage","baggageEntry","encodeURIComponent","newVal","parseBaggageHeader","inputBaggageValue","includeThirdPartyEntries","baggageEntries","test","baggageObj","curr","baggageKey","decodeURIComponent","mergeAndSerializeBaggage","thirdPartyBaggageHeader","headerBaggage","thirdPartyHeaderBaggage","parseBaggageSetMutability","rawBaggageValue","sentryTraceHeader","dateTimestampSource","nowSeconds","getBrowserPerformance","getNodePerformance","perfHooks","platformPerformance","timestampSource","dateTimestampInSeconds","bind","timestampInSeconds","timestampWithMs","_browserPerformanceTimeOriginMode","browserPerformanceTimeOrigin","threshold","performanceNow","dateNow","timeOriginDelta","timeOriginIsReliable","navigationStart","timing","hasNavigationStart","navigationStartDelta","navigationStartIsReliable","API_VERSION","DEFAULT_BREADCRUMBS","Hub","_stack","_version","getStackTop","bindClient","version","top","setupIntegrations","clone","getStack","pushScope","popScope","exception","eventId","_lastEventId","event_id","syntheticException","Error","_withClient","captureException","originalException","message","captureMessage","beforeBreadcrumb","finalBreadcrumb","addBreadcrumb","setUser","setTags","setExtras","setExtra","setContext","oldHub","makeMain","getIntegration","_oO","_callExtensionMethod","endSession","_sendSessionUpdate","layer","getSession","setSession","userAgent","currentSession","sendDefaultPii","captureSession","getMainCarrier","sentry","apply","registry","getHubFromCarrier","setHubOnCarrier","hasHubOnCarrier","isOlderThan","getHubFromActiveDomain","activeDomain","domain","active","registryHubTopStack","_Oo","createEnvelope","items","addItemToEnvelope","envelope","newItem","forEachEnvelopeItem","envelopeItems","envelopeItem","envelopeItemType","encodeUTF8","textEncoder","utf8","TextEncoder","encode","serializeEnvelope","envHeaders","parts","next","itemHeaders","payload","Uint8Array","concatBuffers","buffers","totalLength","acc","buf","merged","offset","set","createAttachmentEnvelopeItem","filename","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","sessions","client_report","user_report","envelopeItemTypeToDataCategory","STACKTRACE_LIMIT","createStackParser","parsers","sortedParsers","sort","a","b","stack","skipFirst","frames","line","parser","frame","stripSentryFramesAndReverse","stackParserFromStackParserOptions","stackParser","localStack","firstFrameFunction","function","lastFrameFunction","reverse","defaultFunctionName","getFunctionName","htmlTreeAsString","elem","keyAttrs","currentElem","MAX_TRAVERSE_HEIGHT","MAX_OUTPUT_LEN","out","height","len","separator","sepLength","nextStr","_htmlElementAsString","parentNode","className","classes","attr","tagName","toLowerCase","keyAttrPairs","keyAttr","keyAttrPair","allowedAttrs","getLocationHref","oO","memoBuilder","hasWeakSet","WeakSet","inner","obj","has","delete","withScope","makeSession","startingTime","sid","init","started","errors","ignoreDuration","sessionToJSON","updateSession","ipAddress","ip_address","did","email","username","closeSession","attrs","user_agent","validSeverityLevels","severityLevelFromString","fallbackGlobalObject","getGlobalObject","getGlobalSingleton","creator","singleton","registerErrorInstrumentation","errorCallback","supportsFetch","Headers","Response","isNativeFetch","func","supportsNativeFetch","fetch","doc","sandbox","createElement","head","appendChild","contentWindow","removeChild","supportsHistory","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","fill","replacementFactory","original","wrapped","markFunctionWrapped","addNonEnumerableProperty","defineProperty","writable","configurable","proto","getOriginalFunction","__sentry_original__","urlEncode","convertToPlainObject","getOwnProperties","newObj","target","serializeEventTarget","currentTarget","CustomEvent","detail","extractedProps","property","extractExceptionKeysForMessage","maxLength","includedKeys","serialized","dropUndefinedKeys","inputValue","memoizationMap","Map","_dropUndefinedKeys","memoVal","returnValue","handlers","instrumented","instrument","instrumentConsole","instrumentDOM","instrumentXHR","instrumentFetch","instrumentHistory","instrumentError","instrumentUnhandledRejection","addInstrumentationHandler","triggerHandlers","console","originalConsoleMethod","originalFetch","getFetchMethod","getFetchUrl","fetchArgs","toUpperCase","xhrproto","XMLHttpRequest","originalOpen","xhrInfo","onreadystatechangeHandler","readyState","onreadystatechange","readyStateArgs","originalSend","body","lastHref","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","debounceDuration","debounceTimerID","lastCapturedEvent","shouldShortcircuitPreviousDebounce","previous","shouldSkipDOMEvent","isContentEditable","makeDOMEventHandler","globalListener","triggerDOMHandler","globalDOMEventHandler","originalAddEventListener","listener","__sentry_instrumentation_handlers__","handlerForType","refCount","originalRemoveEventListener","_oldOnErrorHandler","onerror","msg","column","arguments","_oldOnUnhandledRejectionHandler","onunhandledrejection","PREFIX","CONSOLE_LEVELS","consoleSandbox","originalConsole","wrappedLevels","originalWrappedFunc","makeLogger","enabled","enable","disable","TRACEPARENT_REGEXP","RegExp","extractTraceparentData","traceparent","matches","objectToString","isError","wat","isInstanceOf","isBuiltin","ty","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","isSyntheticEvent","base","_e","SentryError","setPrototypeOf","uuid4","crypto","msCrypto","randomUUID","getRandomByte","getRandomValues","c","parseUrl","query","fragment","relative","getFirstException","values","getEventDescription","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","defaultMechanism","handled","currentMechanism","mechanism","mergedData","checkOrSetAlreadyCaught","__sentry_captured__","isNodeEnv","process","dynamicRequire","mod","require","loadModule","cwd","truncate","substr","snipLine","colno","newLine","lineLength","safeJoin","delimiter","output","isMatchingPattern","pattern"],"mappings":"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","file":"js/chunk-vendors~a05af556.398096e2.js","sourcesContent":["import { getMainCarrier } from '@sentry/hub';\nimport { logger, isNaN, dynamicRequire, loadModule, isNodeEnv } from '@sentry/utils';\nimport { registerErrorInstrumentation } from './errors.js';\nimport { IdleTransaction } from './idletransaction.js';\nimport { Transaction } from './transaction.js';\nimport { hasTracingEnabled } from './utils.js';\n\n/** Returns all trace headers that are currently on the top scope. */\nfunction traceHeaders() {\n  var scope = this.getScope();\n  if (scope) {\n    var span = scope.getSpan();\n    if (span) {\n      return {\n        'sentry-trace': span.toTraceparent(),\n      };\n    }\n  }\n  return {};\n}\n\n/**\n * Makes a sampling decision for the given transaction and stores it on the transaction.\n *\n * Called every time a transaction is created. Only transactions which emerge with a `sampled` value of `true` will be\n * sent to Sentry.\n *\n * @param transaction: The transaction needing a sampling decision\n * @param options: The current client's options, so we can access `tracesSampleRate` and/or `tracesSampler`\n * @param samplingContext: Default and user-provided data which may be used to help make the decision\n *\n * @returns The given transaction with its `sampled` value set\n */\nfunction sample(\n  transaction,\n  options,\n  samplingContext,\n) {\n  // nothing to do if tracing is not enabled\n  if (!hasTracingEnabled(options)) {\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // if the user has forced a sampling decision by passing a `sampled` value in their transaction context, go with that\n  if (transaction.sampled !== undefined) {\n    transaction.setMetadata({\n      transactionSampling: { method: 'explicitly_set' },\n    });\n    return transaction;\n  }\n\n  // we would have bailed already if neither `tracesSampler` nor `tracesSampleRate` were defined, so one of these should\n  // work; prefer the hook if so\n  let sampleRate;\n  if (typeof options.tracesSampler === 'function') {\n    sampleRate = options.tracesSampler(samplingContext);\n    transaction.setMetadata({\n      transactionSampling: {\n        method: 'client_sampler',\n        // cast to number in case it's a boolean\n        rate: Number(sampleRate),\n      },\n    });\n  } else if (samplingContext.parentSampled !== undefined) {\n    sampleRate = samplingContext.parentSampled;\n    transaction.setMetadata({\n      transactionSampling: { method: 'inheritance' },\n    });\n  } else {\n    sampleRate = options.tracesSampleRate;\n    transaction.setMetadata({\n      transactionSampling: {\n        method: 'client_rate',\n        // cast to number in case it's a boolean\n        rate: Number(sampleRate),\n      },\n    });\n  }\n\n  // Since this is coming from the user (or from a function provided by the user), who knows what we might get. (The\n  // only valid values are booleans or numbers between 0 and 1.)\n  if (!isValidSampleRate(sampleRate)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('[Tracing] Discarding transaction because of invalid sample rate.');\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // if the function returned 0 (or false), or if `tracesSampleRate` is 0, it's a sign the transaction should be dropped\n  if (!sampleRate) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.log(\n        `[Tracing] Discarding transaction because ${\n          typeof options.tracesSampler === 'function'\n            ? 'tracesSampler returned 0 or false'\n            : 'a negative sampling decision was inherited or tracesSampleRate is set to 0'\n        }`,\n      );\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // Now we roll the dice. Math.random is inclusive of 0, but not of 1, so strict < is safe here. In case sampleRate is\n  // a boolean, the < comparison will cause it to be automatically cast to 1 if it's true and 0 if it's false.\n  transaction.sampled = Math.random() < (sampleRate );\n\n  // if we're not going to keep it, we're done\n  if (!transaction.sampled) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.log(\n        `[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = ${Number(\n          sampleRate,\n        )})`,\n      );\n    return transaction;\n  }\n\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] starting ${transaction.op} transaction - ${transaction.name}`);\n  return transaction;\n}\n\n/**\n * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).\n */\nfunction isValidSampleRate(rate) {\n  // we need to check NaN explicitly because it's of type 'number' and therefore wouldn't get caught by this typecheck\n    if (isNaN(rate) || !(typeof rate === 'number' || typeof rate === 'boolean')) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        `[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(\n          rate,\n        )} of type ${JSON.stringify(typeof rate)}.`,\n      );\n    return false;\n  }\n\n  // in case sampleRate is a boolean, it will get automatically cast to 1 if it's true and 0 if it's false\n  if (rate < 0 || rate > 1) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(`[Tracing] Given sample rate is invalid. Sample rate must be between 0 and 1. Got ${rate}.`);\n    return false;\n  }\n  return true;\n}\n\n/**\n * Creates a new transaction and adds a sampling decision if it doesn't yet have one.\n *\n * The Hub.startTransaction method delegates to this method to do its work, passing the Hub instance in as `this`, as if\n * it had been called on the hub directly. Exists as a separate function so that it can be injected into the class as an\n * \"extension method.\"\n *\n * @param this: The Hub starting the transaction\n * @param transactionContext: Data used to configure the transaction\n * @param CustomSamplingContext: Optional data to be provided to the `tracesSampler` function (if any)\n *\n * @returns The new transaction\n *\n * @see {@link Hub.startTransaction}\n */\nfunction _startTransaction(\n  \n  transactionContext,\n  customSamplingContext,\n) {\n  var client = this.getClient();\n  var options = (client && client.getOptions()) || {};\n\n  let transaction = new Transaction(transactionContext, this);\n  transaction = sample(transaction, options, {\n    parentSampled: transactionContext.parentSampled,\n    transactionContext,\n    ...customSamplingContext,\n  });\n  if (transaction.sampled) {\n    transaction.initSpanRecorder(options._experiments && (options._experiments.maxSpans ));\n  }\n  return transaction;\n}\n\n/**\n * Create new idle transaction.\n */\nfunction startIdleTransaction(\n  hub,\n  transactionContext,\n  idleTimeout,\n  finalTimeout,\n  onScope,\n  customSamplingContext,\n) {\n  var client = hub.getClient();\n  var options = (client && client.getOptions()) || {};\n\n  let transaction = new IdleTransaction(transactionContext, hub, idleTimeout, finalTimeout, onScope);\n  transaction = sample(transaction, options, {\n    parentSampled: transactionContext.parentSampled,\n    transactionContext,\n    ...customSamplingContext,\n  });\n  if (transaction.sampled) {\n    transaction.initSpanRecorder(options._experiments && (options._experiments.maxSpans ));\n  }\n  return transaction;\n}\n\n/**\n * @private\n */\nfunction _addTracingExtensions() {\n  var carrier = getMainCarrier();\n  if (!carrier.__SENTRY__) {\n    return;\n  }\n  carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};\n  if (!carrier.__SENTRY__.extensions.startTransaction) {\n    carrier.__SENTRY__.extensions.startTransaction = _startTransaction;\n  }\n  if (!carrier.__SENTRY__.extensions.traceHeaders) {\n    carrier.__SENTRY__.extensions.traceHeaders = traceHeaders;\n  }\n}\n\n/**\n * @private\n */\nfunction _autoloadDatabaseIntegrations() {\n  var carrier = getMainCarrier();\n  if (!carrier.__SENTRY__) {\n    return;\n  }\n\n  var packageToIntegrationMapping = {\n    mongodb() {\n      var integration = dynamicRequire(module, './integrations/node/mongo') \n\n;\n      return new integration.Mongo();\n    },\n    mongoose() {\n      var integration = dynamicRequire(module, './integrations/node/mongo') \n\n;\n      return new integration.Mongo({ mongoose: true });\n    },\n    mysql() {\n      var integration = dynamicRequire(module, './integrations/node/mysql') \n\n;\n      return new integration.Mysql();\n    },\n    pg() {\n      var integration = dynamicRequire(module, './integrations/node/postgres') \n\n;\n      return new integration.Postgres();\n    },\n  };\n\n  var mappedPackages = Object.keys(packageToIntegrationMapping)\n    .filter(moduleName => !!loadModule(moduleName))\n    .map(pkg => {\n      try {\n        return packageToIntegrationMapping[pkg]();\n      } catch (e) {\n        return undefined;\n      }\n    })\n    .filter(p => p) ;\n\n  if (mappedPackages.length > 0) {\n    carrier.__SENTRY__.integrations = [...(carrier.__SENTRY__.integrations || []), ...mappedPackages];\n  }\n}\n\n/**\n * This patches the global object and injects the Tracing extensions methods\n */\nfunction addExtensionMethods() {\n  _addTracingExtensions();\n\n  // Detect and automatically load specified integrations.\n  if (isNodeEnv()) {\n    _autoloadDatabaseIntegrations();\n  }\n\n  // If an error happens globally, we should make sure transaction status is set to error.\n  registerErrorInstrumentation();\n}\n\nexport { _addTracingExtensions, addExtensionMethods, startIdleTransaction };\n//# sourceMappingURL=hubextensions.js.map\n","import { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { getCurrentHub } from '@sentry/hub';\nimport { logger, dropUndefinedKeys, isBaggageMutable, createBaggage, getSentryBaggageItems } from '@sentry/utils';\nimport { Span, SpanRecorder } from './span.js';\n\n/** JSDoc */\nclass Transaction extends Span  {\n  \n\n  /**\n   * The reference to the current hub.\n   */\n  \n\n   __init() {this._measurements = {};}\n\n  /**\n   * This constructor should never be called manually. Those instrumenting tracing should use\n   * `Sentry.startTransaction()`, and internal methods should use `hub.startTransaction()`.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n   constructor(transactionContext, hub) {\n    super(transactionContext);Transaction.prototype.__init.call(this);;\n\n    this._hub = hub || getCurrentHub();\n\n    this._name = transactionContext.name || '';\n\n    this.metadata = {\n      ...transactionContext.metadata,\n      spanMetadata: {},\n    };\n\n    this._trimEnd = transactionContext.trimEnd;\n\n    // this is because transactions are also spans, and spans have a transaction pointer\n    this.transaction = this;\n  }\n\n  /** Getter for `name` property */\n   get name() {\n    return this._name;\n  }\n\n  /** Setter for `name` property, which also sets `source` */\n   set name(newName) {\n    this._name = newName;\n    this.metadata.source = 'custom';\n  }\n\n  /**\n   * JSDoc\n   */\n   setName(name, source = 'custom') {\n    this.name = name;\n    this.metadata.source = source;\n  }\n\n  /**\n   * Attaches SpanRecorder to the span itself\n   * @param maxlen maximum number of spans that can be recorded\n   */\n   initSpanRecorder(maxlen = 1000) {\n    if (!this.spanRecorder) {\n      this.spanRecorder = new SpanRecorder(maxlen);\n    }\n    this.spanRecorder.add(this);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setMeasurement(name, value, unit = '') {\n    this._measurements[name] = { value, unit };\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setMetadata(newMetadata) {\n    this.metadata = { ...this.metadata, ...newMetadata };\n  }\n\n  /**\n   * @inheritDoc\n   */\n   finish(endTimestamp) {\n    // This transaction is already finished, so we should not flush it again.\n    if (this.endTimestamp !== undefined) {\n      return undefined;\n    }\n\n    if (!this.name) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Transaction has no name, falling back to `<unlabeled transaction>`.');\n      this.name = '<unlabeled transaction>';\n    }\n\n    // just sets the end timestamp\n    super.finish(endTimestamp);\n\n    if (this.sampled !== true) {\n      // At this point if `sampled !== true` we want to discard the transaction.\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Discarding transaction because its trace was not chosen to be sampled.');\n\n      var client = this._hub.getClient();\n      if (client) {\n        client.recordDroppedEvent('sample_rate', 'transaction');\n      }\n\n      return undefined;\n    }\n\n    var finishedSpans = this.spanRecorder ? this.spanRecorder.spans.filter(s => s !== this && s.endTimestamp) : [];\n\n    if (this._trimEnd && finishedSpans.length > 0) {\n      this.endTimestamp = finishedSpans.reduce((prev, current) => {\n        if (prev.endTimestamp && current.endTimestamp) {\n          return prev.endTimestamp > current.endTimestamp ? prev : current;\n        }\n        return prev;\n      }).endTimestamp;\n    }\n\n    var metadata = this.metadata;\n\n    var transaction = {\n      contexts: {\n        trace: this.getTraceContext(),\n      },\n      spans: finishedSpans,\n      start_timestamp: this.startTimestamp,\n      tags: this.tags,\n      timestamp: this.endTimestamp,\n      transaction: this.name,\n      type: 'transaction',\n      sdkProcessingMetadata: {\n        ...metadata,\n        baggage: this.getBaggage(),\n      },\n      ...(metadata.source && {\n        transaction_info: {\n          source: metadata.source,\n        },\n      }),\n    };\n\n    var hasMeasurements = Object.keys(this._measurements).length > 0;\n\n    if (hasMeasurements) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.log(\n          '[Measurements] Adding measurements to transaction',\n          JSON.stringify(this._measurements, undefined, 2),\n        );\n      transaction.measurements = this._measurements;\n    }\n\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Finishing ${this.op} transaction: ${this.name}.`);\n\n    return this._hub.captureEvent(transaction);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   toContext() {\n    var spanContext = super.toContext();\n\n    return dropUndefinedKeys({\n      ...spanContext,\n      name: this.name,\n      trimEnd: this._trimEnd,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n   updateWithContext(transactionContext) {\n    super.updateWithContext(transactionContext);\n\n    this.name = _nullishCoalesce(transactionContext.name, () => ( ''));\n\n    this._trimEnd = transactionContext.trimEnd;\n\n    return this;\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * @experimental\n   */\n   getBaggage() {\n    var existingBaggage = this.metadata.baggage;\n\n    // Only add Sentry baggage items to baggage, if baggage does not exist yet or it is still\n    // empty and mutable\n    var finalBaggage =\n      !existingBaggage || isBaggageMutable(existingBaggage)\n        ? this._populateBaggageWithSentryValues(existingBaggage)\n        : existingBaggage;\n\n    // Update the baggage stored on the transaction.\n    this.metadata.baggage = finalBaggage;\n\n    return finalBaggage;\n  }\n\n  /**\n   * Collects and adds data to the passed baggage object.\n   *\n   * Note: This function does not explicitly check if the passed baggage object is allowed\n   * to be modified. Implicitly, `setBaggageValue` will not make modification to the object\n   * if it was already set immutable.\n   *\n   * After adding the data, the baggage object is set immutable to prevent further modifications.\n   *\n   * @param baggage\n   *\n   * @returns modified and immutable baggage object\n   */\n   _populateBaggageWithSentryValues(baggage = createBaggage({})) {\n    var hub = this._hub || getCurrentHub();\n    var client = hub && hub.getClient();\n\n    if (!client) return baggage;\n\n    const { environment, release } = client.getOptions() || {};\n    const { publicKey: public_key } = client.getDsn() || {};\n\n    var sample_rate =\n      this.metadata &&\n      this.metadata.transactionSampling &&\n      this.metadata.transactionSampling.rate &&\n      this.metadata.transactionSampling.rate.toString();\n\n    var scope = hub.getScope();\n    const { segment: user_segment } = (scope && scope.getUser()) || {};\n\n    var source = this.metadata.source;\n    var transaction = source && source !== 'url' ? this.name : undefined;\n\n    return createBaggage(\n      dropUndefinedKeys({\n        environment,\n        release,\n        transaction,\n        user_segment,\n        public_key,\n        trace_id: this.traceId,\n        sample_rate,\n        ...getSentryBaggageItems(baggage), // keep user-added values\n      } ),\n      '',\n      false, // set baggage immutable\n    );\n  }\n}\n\nexport { Transaction };\n//# sourceMappingURL=transaction.js.map\n","import { getCurrentHub } from '@sentry/hub';\nexport { TRACEPARENT_REGEXP, extractTraceparentData, stripUrlQueryAndFragment } from '@sentry/utils';\n\n/**\n * Determines if tracing is currently enabled.\n *\n * Tracing is enabled when at least one of `tracesSampleRate` and `tracesSampler` is defined in the SDK config.\n */\nfunction hasTracingEnabled(\n  maybeOptions,\n) {\n  var client = getCurrentHub().getClient();\n  var options = maybeOptions || (client && client.getOptions());\n  return !!options && ('tracesSampleRate' in options || 'tracesSampler' in options);\n}\n\n/** Grabs active transaction off scope, if any */\nfunction getActiveTransaction(maybeHub) {\n  var hub = maybeHub || getCurrentHub();\n  var scope = hub.getScope();\n  return scope && (scope.getTransaction() );\n}\n\n/**\n * Converts from milliseconds to seconds\n * @param time time in ms\n */\nfunction msToSec(time) {\n  return time / 1000;\n}\n\n/**\n * Converts from seconds to milliseconds\n * @param time time in seconds\n */\nfunction secToMs(time) {\n  return time * 1000;\n}\n\nexport { getActiveTransaction, hasTracingEnabled, msToSec, secToMs };\n//# sourceMappingURL=utils.js.map\n","import { isNaN, isSyntheticEvent } from './is.js';\nimport { memoBuilder } from './memo.js';\nimport { convertToPlainObject } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\n\n/**\n * Recursively normalizes the given object.\n *\n * - Creates a copy to prevent original input mutation\n * - Skips non-enumerable properties\n * - When stringifying, calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format\n * - Translates known global objects/classes to a string representations\n * - Takes care of `Error` object serialization\n * - Optionally limits depth of final output\n * - Optionally limits number of properties/elements included in any single object/array\n *\n * @param input The object to be normalized.\n * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)\n * @param maxProperties The max number of elements or properties to be included in any single array or\n * object in the normallized output..\n * @returns A normalized version of the object, or `\"**non-serializable**\"` if any errors are thrown during normalization.\n */\nfunction normalize(input, depth = +Infinity, maxProperties = +Infinity) {\n  try {\n    // since we're at the outermost level, we don't provide a key\n    return visit('', input, depth, maxProperties);\n  } catch (err) {\n    return { ERROR: `**non-serializable** (${err})` };\n  }\n}\n\n/** JSDoc */\nfunction normalizeToSize(\n    object,\n  // Default Node.js REPL depth\n  depth = 3,\n  // 100kB, as 200kB is max payload size, so half sounds reasonable\n  maxSize = 100 * 1024,\n) {\n  var normalized = normalize(object, depth);\n\n  if (jsonSize(normalized) > maxSize) {\n    return normalizeToSize(object, depth - 1, maxSize);\n  }\n\n  return normalized ;\n}\n\n/**\n * Visits a node to perform normalization on it\n *\n * @param key The key corresponding to the given node\n * @param value The node to be visited\n * @param depth Optional number indicating the maximum recursion depth\n * @param maxProperties Optional maximum number of properties/elements included in any single object/array\n * @param memo Optional Memo class handling decycling\n */\nfunction visit(\n  key,\n  value,\n  depth = +Infinity,\n  maxProperties = +Infinity,\n  memo = memoBuilder(),\n) {\n  const [memoize, unmemoize] = memo;\n\n  // Get the simple cases out of the way first\n  if (value === null || (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))) {\n    return value ;\n  }\n\n  var stringified = stringifyValue(key, value);\n\n  // Anything we could potentially dig into more (objects or arrays) will have come back as `\"[object XXXX]\"`.\n  // Everything else will have already been serialized, so if we don't see that pattern, we're done.\n  if (!stringified.startsWith('[object ')) {\n    return stringified;\n  }\n\n  // From here on, we can assert that `value` is either an object or an array.\n\n  // Do not normalize objects that we know have already been normalized. As a general rule, the\n  // \"__sentry_skip_normalization__\" property should only be used sparingly and only should only be set on objects that\n  // have already been normalized.\n  if ((value )['__sentry_skip_normalization__']) {\n    return value ;\n  }\n\n  // We're also done if we've reached the max depth\n  if (depth === 0) {\n    // At this point we know `serialized` is a string of the form `\"[object XXXX]\"`. Clean it up so it's just `\"[XXXX]\"`.\n    return stringified.replace('object ', '');\n  }\n\n  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.\n  if (memoize(value)) {\n    return '[Circular ~]';\n  }\n\n  // If the value has a `toJSON` method, we call it to extract more information\n  var valueWithToJSON = value ;\n  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {\n    try {\n      var jsonValue = valueWithToJSON.toJSON();\n      // We need to normalize the return value of `.toJSON()` in case it has circular references\n      return visit('', jsonValue, depth - 1, maxProperties, memo);\n    } catch (err) {\n      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)\n    }\n  }\n\n  // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse\n  // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each\n  // property/entry, and keep track of the number of items we add to it.\n  var normalized = (Array.isArray(value) ? [] : {}) ;\n  let numAdded = 0;\n\n  // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant\n  // properties are non-enumerable and otherwise would get missed.\n  var visitable = convertToPlainObject(value );\n\n  for (var visitKey in visitable) {\n    // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n    if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {\n      continue;\n    }\n\n    if (numAdded >= maxProperties) {\n      normalized[visitKey] = '[MaxProperties ~]';\n      break;\n    }\n\n    // Recursively visit all the child nodes\n    var visitValue = visitable[visitKey];\n    normalized[visitKey] = visit(visitKey, visitValue, depth - 1, maxProperties, memo);\n\n    numAdded += 1;\n  }\n\n  // Once we've visited all the branches, remove the parent from memo storage\n  unmemoize(value);\n\n  // Return accumulated values\n  return normalized;\n}\n\n/**\n * Stringify the given value. Handles various known special values and types.\n *\n * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn\n * the number 1231 into \"[Object Number]\", nor on `null`, as it will throw.\n *\n * @param value The value to stringify\n * @returns A stringified representation of the given value\n */\nfunction stringifyValue(\n  key,\n  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for\n  // our internal use, it'll do\n  value,\n) {\n  try {\n    if (key === 'domain' && value && typeof value === 'object' && (value )._events) {\n      return '[Domain]';\n    }\n\n    if (key === 'domainEmitter') {\n      return '[DomainEmitter]';\n    }\n\n    // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first\n    // which won't throw if they are not present.\n\n    if (typeof global !== 'undefined' && value === global) {\n      return '[Global]';\n    }\n\n        if (typeof window !== 'undefined' && value === window) {\n      return '[Window]';\n    }\n\n        if (typeof document !== 'undefined' && value === document) {\n      return '[Document]';\n    }\n\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n      return '[SyntheticEvent]';\n    }\n\n    if (typeof value === 'number' && value !== value) {\n      return '[NaN]';\n    }\n\n    // this catches `undefined` (but not `null`, which is a primitive and can be serialized on its own)\n    if (value === void 0) {\n      return '[undefined]';\n    }\n\n    if (typeof value === 'function') {\n      return `[Function: ${getFunctionName(value)}]`;\n    }\n\n    if (typeof value === 'symbol') {\n      return `[${String(value)}]`;\n    }\n\n    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n    if (typeof value === 'bigint') {\n      return `[BigInt: ${String(value)}]`;\n    }\n\n    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting\n    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as\n    // `\"[object Object]\"`. If we instead look at the constructor's name (which is the same as the name of the class),\n    // we can make sure that only plain objects come out that way.\n    return `[object ${(Object.getPrototypeOf(value) ).constructor.name}]`;\n  } catch (err) {\n    return `**non-serializable** (${err})`;\n  }\n}\n\n/** Calculates bytes size of input string */\nfunction utf8Length(value) {\n    return ~-encodeURI(value).split(/%..|./).length;\n}\n\n/** Calculates bytes size of input object */\nfunction jsonSize(value) {\n  return utf8Length(JSON.stringify(value));\n}\n\nexport { normalize, normalizeToSize, visit as walk };\n//# sourceMappingURL=normalize.js.map\n","import { isThenable } from './is.js';\n\n/** SyncPromise internal states */\nvar States; (function (States) {\n  /** Pending */\n  var PENDING = 0; States[States[\"PENDING\"] = PENDING] = \"PENDING\";\n  /** Resolved / OK */\n  var RESOLVED = 1; States[States[\"RESOLVED\"] = RESOLVED] = \"RESOLVED\";\n  /** Rejected / Error */\n  var REJECTED = 2; States[States[\"REJECTED\"] = REJECTED] = \"REJECTED\";\n})(States || (States = {}));\n\n// Overloads so we can call resolvedSyncPromise without arguments and generic argument\n\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nfunction resolvedSyncPromise(value) {\n  return new SyncPromise(resolve => {\n    resolve(value);\n  });\n}\n\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nfunction rejectedSyncPromise(reason) {\n  return new SyncPromise((_, reject) => {\n    reject(reason);\n  });\n}\n\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nclass SyncPromise {\n   __init() {this._state = States.PENDING;}\n   __init2() {this._handlers = [];}\n  \n\n   constructor(\n    executor,\n  ) {;SyncPromise.prototype.__init.call(this);SyncPromise.prototype.__init2.call(this);SyncPromise.prototype.__init3.call(this);SyncPromise.prototype.__init4.call(this);SyncPromise.prototype.__init5.call(this);SyncPromise.prototype.__init6.call(this);\n    try {\n      executor(this._resolve, this._reject);\n    } catch (e) {\n      this._reject(e);\n    }\n  }\n\n  /** JSDoc */\n   then(\n    onfulfilled,\n    onrejected,\n  ) {\n    return new SyncPromise((resolve, reject) => {\n      this._handlers.push([\n        false,\n        result => {\n          if (!onfulfilled) {\n            // TODO: ¯\\_(ツ)_/¯\n            // TODO: FIXME\n            resolve(result );\n          } else {\n            try {\n              resolve(onfulfilled(result));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n        reason => {\n          if (!onrejected) {\n            reject(reason);\n          } else {\n            try {\n              resolve(onrejected(reason));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n      ]);\n      this._executeHandlers();\n    });\n  }\n\n  /** JSDoc */\n   catch(\n    onrejected,\n  ) {\n    return this.then(val => val, onrejected);\n  }\n\n  /** JSDoc */\n   finally(onfinally) {\n    return new SyncPromise((resolve, reject) => {\n      let val;\n      let isRejected;\n\n      return this.then(\n        value => {\n          isRejected = false;\n          val = value;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n        reason => {\n          isRejected = true;\n          val = reason;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n      ).then(() => {\n        if (isRejected) {\n          reject(val);\n          return;\n        }\n\n        resolve(val );\n      });\n    });\n  }\n\n  /** JSDoc */\n    __init3() {this._resolve = (value) => {\n    this._setResult(States.RESOLVED, value);\n  };}\n\n  /** JSDoc */\n    __init4() {this._reject = (reason) => {\n    this._setResult(States.REJECTED, reason);\n  };}\n\n  /** JSDoc */\n    __init5() {this._setResult = (state, value) => {\n    if (this._state !== States.PENDING) {\n      return;\n    }\n\n    if (isThenable(value)) {\n      void (value ).then(this._resolve, this._reject);\n      return;\n    }\n\n    this._state = state;\n    this._value = value;\n\n    this._executeHandlers();\n  };}\n\n  /** JSDoc */\n    __init6() {this._executeHandlers = () => {\n    if (this._state === States.PENDING) {\n      return;\n    }\n\n    var cachedHandlers = this._handlers.slice();\n    this._handlers = [];\n\n    cachedHandlers.forEach(handler => {\n      if (handler[0]) {\n        return;\n      }\n\n      if (this._state === States.RESOLVED) {\n                handler[1](this._value );\n      }\n\n      if (this._state === States.REJECTED) {\n        handler[2](this._value);\n      }\n\n      handler[0] = true;\n    });\n  };}\n}\n\nexport { SyncPromise, rejectedSyncPromise, resolvedSyncPromise };\n//# sourceMappingURL=syncpromise.js.map\n","import { isPlainObject, dateTimestampInSeconds, getGlobalSingleton, SyncPromise, logger, isThenable } from '@sentry/utils';\nimport { updateSession } from './session.js';\n\n/**\n * Absolute maximum number of breadcrumbs added to an event.\n * The `maxBreadcrumbs` option cannot be higher than this value.\n */\nvar MAX_BREADCRUMBS = 100;\n\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nclass Scope  {\n  /** Flag if notifying is happening. */\n  \n\n  /** Callback for client to receive scope changes. */\n  \n\n  /** Callback list that will be called after {@link applyToEvent}. */\n  \n\n  /** Array of breadcrumbs. */\n  \n\n  /** User */\n  \n\n  /** Tags */\n  \n\n  /** Extra */\n  \n\n  /** Contexts */\n  \n\n  /** Attachments */\n  \n\n  /**\n   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get\n   * sent to Sentry\n   */\n  \n\n  /** Fingerprint */\n  \n\n  /** Severity */\n    \n\n  /** Transaction Name */\n  \n\n  /** Span */\n  \n\n  /** Session */\n  \n\n  /** Request Mode Session Status */\n  \n\n   constructor() {\n    this._notifyingListeners = false;\n    this._scopeListeners = [];\n    this._eventProcessors = [];\n    this._breadcrumbs = [];\n    this._attachments = [];\n    this._user = {};\n    this._tags = {};\n    this._extra = {};\n    this._contexts = {};\n    this._sdkProcessingMetadata = {};\n  }\n\n  /**\n   * Inherit values from the parent scope.\n   * @param scope to clone.\n   */\n   static clone(scope) {\n    var newScope = new Scope();\n    if (scope) {\n      newScope._breadcrumbs = [...scope._breadcrumbs];\n      newScope._tags = { ...scope._tags };\n      newScope._extra = { ...scope._extra };\n      newScope._contexts = { ...scope._contexts };\n      newScope._user = scope._user;\n      newScope._level = scope._level;\n      newScope._span = scope._span;\n      newScope._session = scope._session;\n      newScope._transactionName = scope._transactionName;\n      newScope._fingerprint = scope._fingerprint;\n      newScope._eventProcessors = [...scope._eventProcessors];\n      newScope._requestSession = scope._requestSession;\n      newScope._attachments = [...scope._attachments];\n    }\n    return newScope;\n  }\n\n  /**\n   * Add internal on change listener. Used for sub SDKs that need to store the scope.\n   * @hidden\n   */\n   addScopeListener(callback) {\n    this._scopeListeners.push(callback);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addEventProcessor(callback) {\n    this._eventProcessors.push(callback);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setUser(user) {\n    this._user = user || {};\n    if (this._session) {\n      updateSession(this._session, { user });\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getUser() {\n    return this._user;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getRequestSession() {\n    return this._requestSession;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setRequestSession(requestSession) {\n    this._requestSession = requestSession;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTags(tags) {\n    this._tags = {\n      ...this._tags,\n      ...tags,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTag(key, value) {\n    this._tags = { ...this._tags, [key]: value };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtras(extras) {\n    this._extra = {\n      ...this._extra,\n      ...extras,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtra(key, extra) {\n    this._extra = { ...this._extra, [key]: extra };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setFingerprint(fingerprint) {\n    this._fingerprint = fingerprint;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setLevel(\n        level,\n  ) {\n    this._level = level;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTransactionName(name) {\n    this._transactionName = name;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setContext(key, context) {\n    if (context === null) {\n            delete this._contexts[key];\n    } else {\n      this._contexts = { ...this._contexts, [key]: context };\n    }\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setSpan(span) {\n    this._span = span;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getSpan() {\n    return this._span;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getTransaction() {\n    // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will\n    // have a pointer to the currently-active transaction.\n    var span = this.getSpan();\n    return span && span.transaction;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setSession(session) {\n    if (!session) {\n      delete this._session;\n    } else {\n      this._session = session;\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getSession() {\n    return this._session;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   update(captureContext) {\n    if (!captureContext) {\n      return this;\n    }\n\n    if (typeof captureContext === 'function') {\n      var updatedScope = (captureContext )(this);\n      return updatedScope instanceof Scope ? updatedScope : this;\n    }\n\n    if (captureContext instanceof Scope) {\n      this._tags = { ...this._tags, ...captureContext._tags };\n      this._extra = { ...this._extra, ...captureContext._extra };\n      this._contexts = { ...this._contexts, ...captureContext._contexts };\n      if (captureContext._user && Object.keys(captureContext._user).length) {\n        this._user = captureContext._user;\n      }\n      if (captureContext._level) {\n        this._level = captureContext._level;\n      }\n      if (captureContext._fingerprint) {\n        this._fingerprint = captureContext._fingerprint;\n      }\n      if (captureContext._requestSession) {\n        this._requestSession = captureContext._requestSession;\n      }\n    } else if (isPlainObject(captureContext)) {\n            captureContext = captureContext ;\n      this._tags = { ...this._tags, ...captureContext.tags };\n      this._extra = { ...this._extra, ...captureContext.extra };\n      this._contexts = { ...this._contexts, ...captureContext.contexts };\n      if (captureContext.user) {\n        this._user = captureContext.user;\n      }\n      if (captureContext.level) {\n        this._level = captureContext.level;\n      }\n      if (captureContext.fingerprint) {\n        this._fingerprint = captureContext.fingerprint;\n      }\n      if (captureContext.requestSession) {\n        this._requestSession = captureContext.requestSession;\n      }\n    }\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   clear() {\n    this._breadcrumbs = [];\n    this._tags = {};\n    this._extra = {};\n    this._user = {};\n    this._contexts = {};\n    this._level = undefined;\n    this._transactionName = undefined;\n    this._fingerprint = undefined;\n    this._requestSession = undefined;\n    this._span = undefined;\n    this._session = undefined;\n    this._notifyScopeListeners();\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addBreadcrumb(breadcrumb, maxBreadcrumbs) {\n    var maxCrumbs = typeof maxBreadcrumbs === 'number' ? Math.min(maxBreadcrumbs, MAX_BREADCRUMBS) : MAX_BREADCRUMBS;\n\n    // No data has been changed, so don't notify scope listeners\n    if (maxCrumbs <= 0) {\n      return this;\n    }\n\n    var mergedBreadcrumb = {\n      timestamp: dateTimestampInSeconds(),\n      ...breadcrumb,\n    };\n    this._breadcrumbs = [...this._breadcrumbs, mergedBreadcrumb].slice(-maxCrumbs);\n    this._notifyScopeListeners();\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   clearBreadcrumbs() {\n    this._breadcrumbs = [];\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addAttachment(attachment) {\n    this._attachments.push(attachment);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getAttachments() {\n    return this._attachments;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   clearAttachments() {\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * Applies the current context and fingerprint to the event.\n   * Note that breadcrumbs will be added by the client.\n   * Also if the event has already breadcrumbs on it, we do not merge them.\n   * @param event Event\n   * @param hint May contain additional information about the original exception.\n   * @hidden\n   */\n   applyToEvent(event, hint = {}) {\n    if (this._extra && Object.keys(this._extra).length) {\n      event.extra = { ...this._extra, ...event.extra };\n    }\n    if (this._tags && Object.keys(this._tags).length) {\n      event.tags = { ...this._tags, ...event.tags };\n    }\n    if (this._user && Object.keys(this._user).length) {\n      event.user = { ...this._user, ...event.user };\n    }\n    if (this._contexts && Object.keys(this._contexts).length) {\n      event.contexts = { ...this._contexts, ...event.contexts };\n    }\n    if (this._level) {\n      event.level = this._level;\n    }\n    if (this._transactionName) {\n      event.transaction = this._transactionName;\n    }\n\n    // We want to set the trace context for normal events only if there isn't already\n    // a trace context on the event. There is a product feature in place where we link\n    // errors with transaction and it relies on that.\n    if (this._span) {\n      event.contexts = { trace: this._span.getTraceContext(), ...event.contexts };\n      var transactionName = this._span.transaction && this._span.transaction.name;\n      if (transactionName) {\n        event.tags = { transaction: transactionName, ...event.tags };\n      }\n    }\n\n    this._applyFingerprint(event);\n\n    event.breadcrumbs = [...(event.breadcrumbs || []), ...this._breadcrumbs];\n    event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n\n    event.sdkProcessingMetadata = { ...event.sdkProcessingMetadata, ...this._sdkProcessingMetadata };\n\n    return this._notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);\n  }\n\n  /**\n   * Add data which will be accessible during event processing but won't get sent to Sentry\n   */\n   setSDKProcessingMetadata(newData) {\n    this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };\n\n    return this;\n  }\n\n  /**\n   * This will be called after {@link applyToEvent} is finished.\n   */\n   _notifyEventProcessors(\n    processors,\n    event,\n    hint,\n    index = 0,\n  ) {\n    return new SyncPromise((resolve, reject) => {\n      var processor = processors[index];\n      if (event === null || typeof processor !== 'function') {\n        resolve(event);\n      } else {\n        var result = processor({ ...event }, hint) ;\n\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n          processor.id &&\n          result === null &&\n          logger.log(`Event processor \"${processor.id}\" dropped event`);\n\n        if (isThenable(result)) {\n          void result\n            .then(final => this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n            .then(null, reject);\n        } else {\n          void this._notifyEventProcessors(processors, result, hint, index + 1)\n            .then(resolve)\n            .then(null, reject);\n        }\n      }\n    });\n  }\n\n  /**\n   * This will be called on every set call.\n   */\n   _notifyScopeListeners() {\n    // We need this check for this._notifyingListeners to be able to work on scope during updates\n    // If this check is not here we'll produce endless recursion when something is done with the scope\n    // during the callback.\n    if (!this._notifyingListeners) {\n      this._notifyingListeners = true;\n      this._scopeListeners.forEach(callback => {\n        callback(this);\n      });\n      this._notifyingListeners = false;\n    }\n  }\n\n  /**\n   * Applies fingerprint from the scope to the event if there's one,\n   * uses message if there's one instead or get rid of empty fingerprint\n   */\n   _applyFingerprint(event) {\n    // Make sure it's an array first and we actually have something in place\n    event.fingerprint = event.fingerprint\n      ? Array.isArray(event.fingerprint)\n        ? event.fingerprint\n        : [event.fingerprint]\n      : [];\n\n    // If we have something on the scope, then merge it with event\n    if (this._fingerprint) {\n      event.fingerprint = event.fingerprint.concat(this._fingerprint);\n    }\n\n    // If we have no data at all, remove empty array default\n    if (event.fingerprint && !event.fingerprint.length) {\n      delete event.fingerprint;\n    }\n  }\n}\n\n/**\n * Returns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n  return getGlobalSingleton('globalEventProcessors', () => []);\n}\n\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nfunction addGlobalEventProcessor(callback) {\n  getGlobalEventProcessors().push(callback);\n}\n\nexport { Scope, addGlobalEventProcessor };\n//# sourceMappingURL=scope.js.map\n","import { timestampWithMs, logger } from '@sentry/utils';\nimport { SpanRecorder } from './span.js';\nimport { Transaction } from './transaction.js';\n\nvar DEFAULT_IDLE_TIMEOUT = 1000;\nvar DEFAULT_FINAL_TIMEOUT = 30000;\nvar HEARTBEAT_INTERVAL = 5000;\n\n/**\n * @inheritDoc\n */\nclass IdleTransactionSpanRecorder extends SpanRecorder {\n   constructor(\n      _pushActivity,\n      _popActivity,\n     transactionSpanId,\n    maxlen,\n  ) {\n    super(maxlen);this._pushActivity = _pushActivity;this._popActivity = _popActivity;this.transactionSpanId = transactionSpanId;;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   add(span) {\n    // We should make sure we do not push and pop activities for\n    // the transaction that this span recorder belongs to.\n    if (span.spanId !== this.transactionSpanId) {\n      // We patch span.finish() to pop an activity after setting an endTimestamp.\n      span.finish = (endTimestamp) => {\n        span.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampWithMs();\n        this._popActivity(span.spanId);\n      };\n\n      // We should only push new activities if the span does not have an end timestamp.\n      if (span.endTimestamp === undefined) {\n        this._pushActivity(span.spanId);\n      }\n    }\n\n    super.add(span);\n  }\n}\n\n/**\n * An IdleTransaction is a transaction that automatically finishes. It does this by tracking child spans as activities.\n * You can have multiple IdleTransactions active, but if the `onScope` option is specified, the idle transaction will\n * put itself on the scope on creation.\n */\nclass IdleTransaction extends Transaction {\n  // Activities store a list of active spans\n   __init() {this.activities = {};}\n\n  // Track state of activities in previous heartbeat\n  \n\n  // Amount of times heartbeat has counted. Will cause transaction to finish after 3 beats.\n   __init2() {this._heartbeatCounter = 0;}\n\n  // We should not use heartbeat if we finished a transaction\n   __init3() {this._finished = false;}\n\n    __init4() {this._beforeFinishCallbacks = [];}\n\n  /**\n   * Timer that tracks Transaction idleTimeout\n   */\n  \n\n   constructor(\n    transactionContext,\n      _idleHub,\n    /**\n     * The time to wait in ms until the idle transaction will be finished. This timer is started each time\n     * there are no active spans on this transaction.\n     */\n      _idleTimeout = DEFAULT_IDLE_TIMEOUT,\n    /**\n     * The final value in ms that a transaction cannot exceed\n     */\n      _finalTimeout = DEFAULT_FINAL_TIMEOUT,\n    // Whether or not the transaction should put itself on the scope when it starts and pop itself off when it ends\n      _onScope = false,\n  ) {\n    super(transactionContext, _idleHub);this._idleHub = _idleHub;this._idleTimeout = _idleTimeout;this._finalTimeout = _finalTimeout;this._onScope = _onScope;IdleTransaction.prototype.__init.call(this);IdleTransaction.prototype.__init2.call(this);IdleTransaction.prototype.__init3.call(this);IdleTransaction.prototype.__init4.call(this);;\n\n    if (_onScope) {\n      // There should only be one active transaction on the scope\n      clearActiveTransaction(_idleHub);\n\n      // We set the transaction here on the scope so error events pick up the trace\n      // context and attach it to the error.\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Setting idle transaction on scope. Span ID: ${this.spanId}`);\n      _idleHub.configureScope(scope => scope.setSpan(this));\n    }\n\n    this._startIdleTimeout();\n    setTimeout(() => {\n      if (!this._finished) {\n        this.setStatus('deadline_exceeded');\n        this.finish();\n      }\n    }, this._finalTimeout);\n  }\n\n  /** {@inheritDoc} */\n   finish(endTimestamp = timestampWithMs()) {\n    this._finished = true;\n    this.activities = {};\n\n    if (this.spanRecorder) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.log('[Tracing] finishing IdleTransaction', new Date(endTimestamp * 1000).toISOString(), this.op);\n\n      for (var callback of this._beforeFinishCallbacks) {\n        callback(this, endTimestamp);\n      }\n\n      this.spanRecorder.spans = this.spanRecorder.spans.filter((span) => {\n        // If we are dealing with the transaction itself, we just return it\n        if (span.spanId === this.spanId) {\n          return true;\n        }\n\n        // We cancel all pending spans with status \"cancelled\" to indicate the idle transaction was finished early\n        if (!span.endTimestamp) {\n          span.endTimestamp = endTimestamp;\n          span.setStatus('cancelled');\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n            logger.log('[Tracing] cancelling span since transaction ended early', JSON.stringify(span, undefined, 2));\n        }\n\n        var keepSpan = span.startTimestamp < endTimestamp;\n        if (!keepSpan) {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n            logger.log(\n              '[Tracing] discarding Span since it happened after Transaction was finished',\n              JSON.stringify(span, undefined, 2),\n            );\n        }\n        return keepSpan;\n      });\n\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] flushing IdleTransaction');\n    } else {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] No active IdleTransaction');\n    }\n\n    // if `this._onScope` is `true`, the transaction put itself on the scope when it started\n    if (this._onScope) {\n      clearActiveTransaction(this._idleHub);\n    }\n\n    return super.finish(endTimestamp);\n  }\n\n  /**\n   * Register a callback function that gets excecuted before the transaction finishes.\n   * Useful for cleanup or if you want to add any additional spans based on current context.\n   *\n   * This is exposed because users have no other way of running something before an idle transaction\n   * finishes.\n   */\n   registerBeforeFinishCallback(callback) {\n    this._beforeFinishCallbacks.push(callback);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   initSpanRecorder(maxlen) {\n    if (!this.spanRecorder) {\n      var pushActivity = (id) => {\n        if (this._finished) {\n          return;\n        }\n        this._pushActivity(id);\n      };\n      var popActivity = (id) => {\n        if (this._finished) {\n          return;\n        }\n        this._popActivity(id);\n      };\n\n      this.spanRecorder = new IdleTransactionSpanRecorder(pushActivity, popActivity, this.spanId, maxlen);\n\n      // Start heartbeat so that transactions do not run forever.\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('Starting heartbeat');\n      this._pingHeartbeat();\n    }\n    this.spanRecorder.add(this);\n  }\n\n  /**\n   * Cancels the existing idletimeout, if there is one\n   */\n   _cancelIdleTimeout() {\n    if (this._idleTimeoutID) {\n      clearTimeout(this._idleTimeoutID);\n      this._idleTimeoutID = undefined;\n    }\n  }\n\n  /**\n   * Creates an idletimeout\n   */\n   _startIdleTimeout(endTimestamp) {\n    this._cancelIdleTimeout();\n    this._idleTimeoutID = setTimeout(() => {\n      if (!this._finished && Object.keys(this.activities).length === 0) {\n        this.finish(endTimestamp);\n      }\n    }, this._idleTimeout);\n  }\n\n  /**\n   * Start tracking a specific activity.\n   * @param spanId The span id that represents the activity\n   */\n   _pushActivity(spanId) {\n    this._cancelIdleTimeout();\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] pushActivity: ${spanId}`);\n    this.activities[spanId] = true;\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n  }\n\n  /**\n   * Remove an activity from usage\n   * @param spanId The span id that represents the activity\n   */\n   _popActivity(spanId) {\n    if (this.activities[spanId]) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] popActivity ${spanId}`);\n            delete this.activities[spanId];\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n    }\n\n    if (Object.keys(this.activities).length === 0) {\n      // We need to add the timeout here to have the real endtimestamp of the transaction\n      // Remember timestampWithMs is in seconds, timeout is in ms\n      var endTimestamp = timestampWithMs() + this._idleTimeout / 1000;\n      this._startIdleTimeout(endTimestamp);\n    }\n  }\n\n  /**\n   * Checks when entries of this.activities are not changing for 3 beats.\n   * If this occurs we finish the transaction.\n   */\n   _beat() {\n    // We should not be running heartbeat if the idle transaction is finished.\n    if (this._finished) {\n      return;\n    }\n\n    var heartbeatString = Object.keys(this.activities).join('');\n\n    if (heartbeatString === this._prevHeartbeatString) {\n      this._heartbeatCounter += 1;\n    } else {\n      this._heartbeatCounter = 1;\n    }\n\n    this._prevHeartbeatString = heartbeatString;\n\n    if (this._heartbeatCounter >= 3) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Transaction finished because of no change for 3 heart beats');\n      this.setStatus('deadline_exceeded');\n      this.finish();\n    } else {\n      this._pingHeartbeat();\n    }\n  }\n\n  /**\n   * Pings the heartbeat\n   */\n   _pingHeartbeat() {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`pinging Heartbeat -> current counter: ${this._heartbeatCounter}`);\n    setTimeout(() => {\n      this._beat();\n    }, HEARTBEAT_INTERVAL);\n  }\n}\n\n/**\n * Reset transaction on scope to `undefined`\n */\nfunction clearActiveTransaction(hub) {\n  var scope = hub.getScope();\n  if (scope) {\n    var transaction = scope.getTransaction();\n    if (transaction) {\n      scope.setSpan(undefined);\n    }\n  }\n}\n\nexport { DEFAULT_FINAL_TIMEOUT, DEFAULT_IDLE_TIMEOUT, HEARTBEAT_INTERVAL, IdleTransaction, IdleTransactionSpanRecorder };\n//# sourceMappingURL=idletransaction.js.map\n","import { createEnvelope } from './envelope.js';\nimport { dateTimestampInSeconds } from './time.js';\n\n/**\n * Creates client report envelope\n * @param discarded_events An array of discard events\n * @param dsn A DSN that can be set on the header. Optional.\n */\nfunction createClientReportEnvelope(\n  discarded_events,\n  dsn,\n  timestamp,\n) {\n  var clientReportItem = [\n    { type: 'client_report' },\n    {\n      timestamp: timestamp || dateTimestampInSeconds(),\n      discarded_events,\n    },\n  ];\n  return createEnvelope(dsn ? { dsn } : {}, [clientReportItem]);\n}\n\nexport { createClientReportEnvelope };\n//# sourceMappingURL=clientreport.js.map\n","/**\n * Polyfill for the nullish coalescing operator (`??`).\n *\n * Note that the RHS is wrapped in a function so that if it's a computed value, that evaluation won't happen unless the\n * LHS evaluates to a nullish value, to mimic the operator's short-circuiting behavior.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n *\n * @param lhs The value of the expression to the left of the `??`\n * @param rhsFn A function returning the value of the expression to the right of the `??`\n * @returns The LHS value, unless it's `null` or `undefined`, in which case, the RHS value\n */\nfunction _nullishCoalesce(lhs, rhsFn) {\n  // by checking for loose equality to `null`, we catch both `null` and `undefined`\n  return lhs != null ? lhs : rhsFn();\n}\n\n// Sucrase version:\n// function _nullishCoalesce(lhs, rhsFn) {\n//   if (lhs != null) {\n//     return lhs;\n//   } else {\n//     return rhsFn();\n//   }\n// }\n\nexport { _nullishCoalesce };\n//# sourceMappingURL=_nullishCoalesce.js.map\n","/*\n * This module exists for optimizations in the build process through rollup and terser.  We define some global\n * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these\n * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will\n * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to\n * `logger` and preventing node-related code from appearing in browser bundles.\n *\n * Attention:\n * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by\n * users. These fags should live in their respective packages, as we identified user tooling (specifically webpack)\n * having issues tree-shaking these constants across package boundaries.\n * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want\n * users to be able to shake away expressions that it guards.\n */\n\n/**\n * Figures out if we're building a browser bundle.\n *\n * @returns true if this is a browser bundle build.\n */\nfunction isBrowserBundle() {\n  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;\n}\n\nexport { isBrowserBundle };\n//# sourceMappingURL=env.js.map\n","import { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { uuid4, timestampWithMs, logger, dropUndefinedKeys } from '@sentry/utils';\n\n/**\n * Keeps track of finished spans for a given transaction\n * @internal\n * @hideconstructor\n * @hidden\n */\nclass SpanRecorder {\n   __init() {this.spans = [];}\n\n   constructor(maxlen = 1000) {;SpanRecorder.prototype.__init.call(this);\n    this._maxlen = maxlen;\n  }\n\n  /**\n   * This is just so that we don't run out of memory while recording a lot\n   * of spans. At some point we just stop and flush out the start of the\n   * trace tree (i.e.the first n spans with the smallest\n   * start_timestamp).\n   */\n   add(span) {\n    if (this.spans.length > this._maxlen) {\n      span.spanRecorder = undefined;\n    } else {\n      this.spans.push(span);\n    }\n  }\n}\n\n/**\n * Span contains all data about a span\n */\nclass Span  {\n  /**\n   * @inheritDoc\n   */\n   __init2() {this.traceId = uuid4();}\n\n  /**\n   * @inheritDoc\n   */\n   __init3() {this.spanId = uuid4().substring(16);}\n\n  /**\n   * @inheritDoc\n   */\n  \n\n  /**\n   * Internal keeper of the status\n   */\n  \n\n  /**\n   * @inheritDoc\n   */\n  \n\n  /**\n   * Timestamp in seconds when the span was created.\n   */\n   __init4() {this.startTimestamp = timestampWithMs();}\n\n  /**\n   * Timestamp in seconds when the span ended.\n   */\n  \n\n  /**\n   * @inheritDoc\n   */\n  \n\n  /**\n   * @inheritDoc\n   */\n  \n\n  /**\n   * @inheritDoc\n   */\n   __init5() {this.tags = {};}\n\n  /**\n   * @inheritDoc\n   */\n     __init6() {this.data = {};}\n\n  /**\n   * List of spans that were finalized\n   */\n  \n\n  /**\n   * @inheritDoc\n   */\n  \n\n  /**\n   * You should never call the constructor manually, always use `Sentry.startTransaction()`\n   * or call `startChild()` on an existing span.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n   constructor(spanContext) {;Span.prototype.__init2.call(this);Span.prototype.__init3.call(this);Span.prototype.__init4.call(this);Span.prototype.__init5.call(this);Span.prototype.__init6.call(this);\n    if (!spanContext) {\n      return this;\n    }\n    if (spanContext.traceId) {\n      this.traceId = spanContext.traceId;\n    }\n    if (spanContext.spanId) {\n      this.spanId = spanContext.spanId;\n    }\n    if (spanContext.parentSpanId) {\n      this.parentSpanId = spanContext.parentSpanId;\n    }\n    // We want to include booleans as well here\n    if ('sampled' in spanContext) {\n      this.sampled = spanContext.sampled;\n    }\n    if (spanContext.op) {\n      this.op = spanContext.op;\n    }\n    if (spanContext.description) {\n      this.description = spanContext.description;\n    }\n    if (spanContext.data) {\n      this.data = spanContext.data;\n    }\n    if (spanContext.tags) {\n      this.tags = spanContext.tags;\n    }\n    if (spanContext.status) {\n      this.status = spanContext.status;\n    }\n    if (spanContext.startTimestamp) {\n      this.startTimestamp = spanContext.startTimestamp;\n    }\n    if (spanContext.endTimestamp) {\n      this.endTimestamp = spanContext.endTimestamp;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   startChild(\n    spanContext,\n  ) {\n    var childSpan = new Span({\n      ...spanContext,\n      parentSpanId: this.spanId,\n      sampled: this.sampled,\n      traceId: this.traceId,\n    });\n\n    childSpan.spanRecorder = this.spanRecorder;\n    if (childSpan.spanRecorder) {\n      childSpan.spanRecorder.add(childSpan);\n    }\n\n    childSpan.transaction = this.transaction;\n\n    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && childSpan.transaction) {\n      var opStr = (spanContext && spanContext.op) || '< unknown op >';\n      var nameStr = childSpan.transaction.name || '< unknown name >';\n      var idStr = childSpan.transaction.spanId;\n\n      var logMessage = `[Tracing] Starting '${opStr}' span on transaction '${nameStr}' (${idStr}).`;\n      childSpan.transaction.metadata.spanMetadata[childSpan.spanId] = { logMessage };\n      logger.log(logMessage);\n    }\n\n    return childSpan;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTag(key, value) {\n    this.tags = { ...this.tags, [key]: value };\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n     setData(key, value) {\n    this.data = { ...this.data, [key]: value };\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setStatus(value) {\n    this.status = value;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setHttpStatus(httpStatus) {\n    this.setTag('http.status_code', String(httpStatus));\n    var spanStatus = spanStatusfromHttpCode(httpStatus);\n    if (spanStatus !== 'unknown_error') {\n      this.setStatus(spanStatus);\n    }\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   isSuccess() {\n    return this.status === 'ok';\n  }\n\n  /**\n   * @inheritDoc\n   */\n   finish(endTimestamp) {\n    if (\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      // Don't call this for transactions\n      this.transaction &&\n      this.transaction.spanId !== this.spanId\n    ) {\n      const { logMessage } = this.transaction.metadata.spanMetadata[this.spanId];\n      if (logMessage) {\n        logger.log((logMessage ).replace('Starting', 'Finishing'));\n      }\n    }\n\n    this.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampWithMs();\n  }\n\n  /**\n   * @inheritDoc\n   */\n   toTraceparent() {\n    let sampledString = '';\n    if (this.sampled !== undefined) {\n      sampledString = this.sampled ? '-1' : '-0';\n    }\n    return `${this.traceId}-${this.spanId}${sampledString}`;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   toContext() {\n    return dropUndefinedKeys({\n      data: this.data,\n      description: this.description,\n      endTimestamp: this.endTimestamp,\n      op: this.op,\n      parentSpanId: this.parentSpanId,\n      sampled: this.sampled,\n      spanId: this.spanId,\n      startTimestamp: this.startTimestamp,\n      status: this.status,\n      tags: this.tags,\n      traceId: this.traceId,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n   updateWithContext(spanContext) {\n    this.data = _nullishCoalesce(spanContext.data, () => ( {}));\n    this.description = spanContext.description;\n    this.endTimestamp = spanContext.endTimestamp;\n    this.op = spanContext.op;\n    this.parentSpanId = spanContext.parentSpanId;\n    this.sampled = spanContext.sampled;\n    this.spanId = _nullishCoalesce(spanContext.spanId, () => ( this.spanId));\n    this.startTimestamp = _nullishCoalesce(spanContext.startTimestamp, () => ( this.startTimestamp));\n    this.status = spanContext.status;\n    this.tags = _nullishCoalesce(spanContext.tags, () => ( {}));\n    this.traceId = _nullishCoalesce(spanContext.traceId, () => ( this.traceId));\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getTraceContext()\n\n {\n    return dropUndefinedKeys({\n      data: Object.keys(this.data).length > 0 ? this.data : undefined,\n      description: this.description,\n      op: this.op,\n      parent_span_id: this.parentSpanId,\n      span_id: this.spanId,\n      status: this.status,\n      tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n      trace_id: this.traceId,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n   toJSON()\n\n {\n    return dropUndefinedKeys({\n      data: Object.keys(this.data).length > 0 ? this.data : undefined,\n      description: this.description,\n      op: this.op,\n      parent_span_id: this.parentSpanId,\n      span_id: this.spanId,\n      start_timestamp: this.startTimestamp,\n      status: this.status,\n      tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n      timestamp: this.endTimestamp,\n      trace_id: this.traceId,\n    });\n  }\n}\n\n/**\n * Converts a HTTP status code into a {@link SpanStatusType}.\n *\n * @param httpStatus The HTTP response status code.\n * @returns The span status or unknown_error.\n */\nfunction spanStatusfromHttpCode(httpStatus) {\n  if (httpStatus < 400 && httpStatus >= 100) {\n    return 'ok';\n  }\n\n  if (httpStatus >= 400 && httpStatus < 500) {\n    switch (httpStatus) {\n      case 401:\n        return 'unauthenticated';\n      case 403:\n        return 'permission_denied';\n      case 404:\n        return 'not_found';\n      case 409:\n        return 'already_exists';\n      case 413:\n        return 'failed_precondition';\n      case 429:\n        return 'resource_exhausted';\n      default:\n        return 'invalid_argument';\n    }\n  }\n\n  if (httpStatus >= 500 && httpStatus < 600) {\n    switch (httpStatus) {\n      case 501:\n        return 'unimplemented';\n      case 503:\n        return 'unavailable';\n      case 504:\n        return 'deadline_exceeded';\n      default:\n        return 'internal_error';\n    }\n  }\n\n  return 'unknown_error';\n}\n\nexport { Span, SpanRecorder, spanStatusfromHttpCode };\n//# sourceMappingURL=span.js.map\n","import { SentryError } from './error.js';\n\n/** Regular expression used to parse a Dsn. */\nvar DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+))?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n\nfunction isValidProtocol(protocol) {\n  return protocol === 'http' || protocol === 'https';\n}\n\n/**\n * Renders the string representation of this Dsn.\n *\n * By default, this will render the public representation without the password\n * component. To get the deprecated private representation, set `withPassword`\n * to true.\n *\n * @param withPassword When set to true, the password will be included.\n */\nfunction dsnToString(dsn, withPassword = false) {\n  const { host, path, pass, port, projectId, protocol, publicKey } = dsn;\n  return (\n    `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +\n    `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`\n  );\n}\n\n/**\n * Parses a Dsn from a given string.\n *\n * @param str A Dsn as string\n * @returns Dsn as DsnComponents\n */\nfunction dsnFromString(str) {\n  var match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    throw new SentryError(`Invalid Sentry Dsn: ${str}`);\n  }\n\n  const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);\n  let path = '';\n  let projectId = lastPath;\n\n  var split = projectId.split('/');\n  if (split.length > 1) {\n    path = split.slice(0, -1).join('/');\n    projectId = split.pop() ;\n  }\n\n  if (projectId) {\n    var projectMatch = projectId.match(/^\\d+/);\n    if (projectMatch) {\n      projectId = projectMatch[0];\n    }\n  }\n\n  return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol , publicKey });\n}\n\nfunction dsnFromComponents(components) {\n  return {\n    protocol: components.protocol,\n    publicKey: components.publicKey || '',\n    pass: components.pass || '',\n    host: components.host,\n    port: components.port || '',\n    path: components.path || '',\n    projectId: components.projectId,\n  };\n}\n\nfunction validateDsn(dsn) {\n  if (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n    return;\n  }\n\n  const { port, projectId, protocol } = dsn;\n\n  var requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];\n  requiredComponents.forEach(component => {\n    if (!dsn[component]) {\n      throw new SentryError(`Invalid Sentry Dsn: ${component} missing`);\n    }\n  });\n\n  if (!projectId.match(/^\\d+$/)) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);\n  }\n\n  if (!isValidProtocol(protocol)) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid port ${port}`);\n  }\n\n  return true;\n}\n\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nfunction makeDsn(from) {\n  var components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n  validateDsn(components);\n  return components;\n}\n\nexport { dsnFromString, dsnToString, makeDsn };\n//# sourceMappingURL=dsn.js.map\n","import { SentryError } from './error.js';\nimport { rejectedSyncPromise, SyncPromise, resolvedSyncPromise } from './syncpromise.js';\n\n/**\n * Creates an new PromiseBuffer object with the specified limit\n * @param limit max number of promises that can be stored in the buffer\n */\nfunction makePromiseBuffer(limit) {\n  var buffer = [];\n\n  function isReady() {\n    return limit === undefined || buffer.length < limit;\n  }\n\n  /**\n   * Remove a promise from the queue.\n   *\n   * @param task Can be any PromiseLike<T>\n   * @returns Removed promise.\n   */\n  function remove(task) {\n    return buffer.splice(buffer.indexOf(task), 1)[0];\n  }\n\n  /**\n   * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.\n   *\n   * @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task:\n   *        PromiseLike<T>`, but under that model, Promises were instantly created on the call-site and their executor\n   *        functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By\n   *        requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer\n   *        limit check.\n   * @returns The original promise.\n   */\n  function add(taskProducer) {\n    if (!isReady()) {\n      return rejectedSyncPromise(new SentryError('Not adding Promise due to buffer limit reached.'));\n    }\n\n    // start the task and add its promise to the queue\n    var task = taskProducer();\n    if (buffer.indexOf(task) === -1) {\n      buffer.push(task);\n    }\n    void task\n      .then(() => remove(task))\n      // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`\n      // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't\n      // have promises, so TS has to polyfill when down-compiling.)\n      .then(null, () =>\n        remove(task).then(null, () => {\n          // We have to add another catch here because `remove()` starts a new promise chain.\n        }),\n      );\n    return task;\n  }\n\n  /**\n   * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or\n   * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and\n   * `false` otherwise\n   */\n  function drain(timeout) {\n    return new SyncPromise((resolve, reject) => {\n      let counter = buffer.length;\n\n      if (!counter) {\n        return resolve(true);\n      }\n\n      // wait for `timeout` ms and then resolve to `false` (if not cancelled first)\n      var capturedSetTimeout = setTimeout(() => {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout);\n\n      // if all promises resolve in time, cancel the timer and resolve to `true`\n      buffer.forEach(item => {\n        void resolvedSyncPromise(item).then(() => {\n                    if (!--counter) {\n            clearTimeout(capturedSetTimeout);\n            resolve(true);\n          }\n        }, reject);\n      });\n    });\n  }\n\n  return {\n    $: buffer,\n    add,\n    drain,\n  };\n}\n\nexport { makePromiseBuffer };\n//# sourceMappingURL=promisebuffer.js.map\n","import { getGlobalObject, logger } from '@sentry/utils';\nimport { getActiveTransaction } from '../utils.js';\n\nvar global = getGlobalObject();\n\n/**\n * Add a listener that cancels and finishes a transaction when the global\n * document is hidden.\n */\nfunction registerBackgroundTabDetection() {\n  if (global && global.document) {\n    global.document.addEventListener('visibilitychange', () => {\n      var activeTransaction = getActiveTransaction() ;\n      if (global.document.hidden && activeTransaction) {\n        var statusType = 'cancelled';\n\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n          logger.log(\n            `[Tracing] Transaction: ${statusType} -> since tab moved to the background, op: ${activeTransaction.op}`,\n          );\n        // We should not set status if it is already set, this prevent important statuses like\n        // error or data loss from being overwritten on transaction.\n        if (!activeTransaction.status) {\n          activeTransaction.setStatus(statusType);\n        }\n        activeTransaction.setTag('visibilitychange', 'document.hidden');\n        activeTransaction.finish();\n      }\n    });\n  } else {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn('[Tracing] Could not set up background tab detection due to lack of global document');\n  }\n}\n\nexport { registerBackgroundTabDetection };\n//# sourceMappingURL=backgroundtab.js.map\n","var bindReporter = (\n  callback,\n  metric,\n  reportAllChanges,\n) => {\n  let prevValue;\n  return (forceReport) => {\n    if (metric.value >= 0) {\n      if (forceReport || reportAllChanges) {\n        metric.delta = metric.value - (prevValue || 0);\n\n        // Report the metric if there's a non-zero delta or if no previous\n        // value exists (which can happen in the case of the document becoming\n        // hidden when the metric value is 0).\n        // See: https://github.com/GoogleChrome/web-vitals/issues/14\n        if (metric.delta || prevValue === undefined) {\n          prevValue = metric.value;\n          callback(metric);\n        }\n      }\n    }\n  };\n};\n\nexport { bindReporter };\n//# sourceMappingURL=bindReporter.js.map\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Performantly generate a unique, 30-char string by combining a version\n * number, the current timestamp with a 13-digit number integer.\n * @return {string}\n */\nvar generateUniqueID = () => {\n  return `v2-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`;\n};\n\nexport { generateUniqueID };\n//# sourceMappingURL=generateUniqueID.js.map\n","import { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { generateUniqueID } from './generateUniqueID.js';\n\nvar initMetric = (name, value) => {\n  return {\n    name,\n    value: _nullishCoalesce(value, () => ( -1)),\n    delta: 0,\n    entries: [],\n    id: generateUniqueID(),\n  };\n};\n\nexport { initMetric };\n//# sourceMappingURL=initMetric.js.map\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Takes a performance entry type and a callback function, and creates a\n * `PerformanceObserver` instance that will observe the specified entry type\n * with buffering enabled and call the callback _for each entry_.\n *\n * This function also feature-detects entry support and wraps the logic in a\n * try/catch to avoid errors in unsupporting browsers.\n */\nvar observe = (type, callback) => {\n  try {\n    if (PerformanceObserver.supportedEntryTypes.includes(type)) {\n      // More extensive feature detect needed for Firefox due to:\n      // https://github.com/GoogleChrome/web-vitals/issues/142\n      if (type === 'first-input' && !('PerformanceEventTiming' in self)) {\n        return;\n      }\n\n      var po = new PerformanceObserver(l => l.getEntries().map(callback));\n\n      po.observe({ type, buffered: true });\n      return po;\n    }\n  } catch (e) {\n    // Do nothing.\n  }\n  return;\n};\n\nexport { observe };\n//# sourceMappingURL=observe.js.map\n","import { getGlobalObject } from '@sentry/utils';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar onHidden = (cb, once) => {\n  var onHiddenOrPageHide = (event) => {\n    if (event.type === 'pagehide' || getGlobalObject().document.visibilityState === 'hidden') {\n      cb(event);\n      if (once) {\n        removeEventListener('visibilitychange', onHiddenOrPageHide, true);\n        removeEventListener('pagehide', onHiddenOrPageHide, true);\n      }\n    }\n  };\n  addEventListener('visibilitychange', onHiddenOrPageHide, true);\n  // Some browsers have buggy implementations of visibilitychange,\n  // so we use pagehide in addition, just to be safe.\n  addEventListener('pagehide', onHiddenOrPageHide, true);\n};\n\nexport { onHidden };\n//# sourceMappingURL=onHidden.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// https://wicg.github.io/layout-instability/#sec-layout-shift\n\nvar getCLS = (onReport, reportAllChanges) => {\n  var metric = initMetric('CLS', 0);\n  let report;\n\n  let sessionValue = 0;\n  let sessionEntries = [];\n\n  var entryHandler = (entry) => {\n    // Only count layout shifts without recent user input.\n    // TODO: Figure out why entry can be undefined\n    if (entry && !entry.hadRecentInput) {\n      var firstSessionEntry = sessionEntries[0];\n      var lastSessionEntry = sessionEntries[sessionEntries.length - 1];\n\n      // If the entry occurred less than 1 second after the previous entry and\n      // less than 5 seconds after the first entry in the session, include the\n      // entry in the current session. Otherwise, start a new session.\n      if (\n        sessionValue &&\n        sessionEntries.length !== 0 &&\n        entry.startTime - lastSessionEntry.startTime < 1000 &&\n        entry.startTime - firstSessionEntry.startTime < 5000\n      ) {\n        sessionValue += entry.value;\n        sessionEntries.push(entry);\n      } else {\n        sessionValue = entry.value;\n        sessionEntries = [entry];\n      }\n\n      // If the current session value is larger than the current CLS value,\n      // update CLS and the entries contributing to it.\n      if (sessionValue > metric.value) {\n        metric.value = sessionValue;\n        metric.entries = sessionEntries;\n        if (report) {\n          report();\n        }\n      }\n    }\n  };\n\n  var po = observe('layout-shift', entryHandler );\n  if (po) {\n    report = bindReporter(onReport, metric, reportAllChanges);\n\n    onHidden(() => {\n      po.takeRecords().map(entryHandler );\n      report(true);\n    });\n  }\n};\n\nexport { getCLS };\n//# sourceMappingURL=getCLS.js.map\n","import { getGlobalObject } from '@sentry/utils';\nimport { onHidden } from './onHidden.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nlet firstHiddenTime = -1;\n\nvar initHiddenTime = () => {\n  return getGlobalObject().document.visibilityState === 'hidden' ? 0 : Infinity;\n};\n\nvar trackChanges = () => {\n  // Update the time if/when the document becomes hidden.\n  onHidden(({ timeStamp }) => {\n    firstHiddenTime = timeStamp;\n  }, true);\n};\n\nvar getVisibilityWatcher = (\n\n) => {\n  if (firstHiddenTime < 0) {\n    // If the document is hidden when this code runs, assume it was hidden\n    // since navigation start. This isn't a perfect heuristic, but it's the\n    // best we can do until an API is available to support querying past\n    // visibilityState.\n    firstHiddenTime = initHiddenTime();\n    trackChanges();\n  }\n  return {\n    get firstHiddenTime() {\n      return firstHiddenTime;\n    },\n  };\n};\n\nexport { getVisibilityWatcher };\n//# sourceMappingURL=getVisibilityWatcher.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar getFID = (onReport, reportAllChanges) => {\n  var visibilityWatcher = getVisibilityWatcher();\n  var metric = initMetric('FID');\n  let report;\n\n  var entryHandler = (entry) => {\n    // Only report if the page wasn't hidden prior to the first input.\n    if (report && entry.startTime < visibilityWatcher.firstHiddenTime) {\n      metric.value = entry.processingStart - entry.startTime;\n      metric.entries.push(entry);\n      report(true);\n    }\n  };\n\n  var po = observe('first-input', entryHandler );\n  if (po) {\n    report = bindReporter(onReport, metric, reportAllChanges);\n    onHidden(() => {\n      po.takeRecords().map(entryHandler );\n      po.disconnect();\n    }, true);\n  }\n};\n\nexport { getFID };\n//# sourceMappingURL=getFID.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// https://wicg.github.io/largest-contentful-paint/#sec-largest-contentful-paint-interface\n\nvar reportedMetricIDs = {};\n\nvar getLCP = (onReport, reportAllChanges) => {\n  var visibilityWatcher = getVisibilityWatcher();\n  var metric = initMetric('LCP');\n  let report;\n\n  var entryHandler = (entry) => {\n    // The startTime attribute returns the value of the renderTime if it is not 0,\n    // and the value of the loadTime otherwise.\n    var value = entry.startTime;\n\n    // If the page was hidden prior to paint time of the entry,\n    // ignore it and mark the metric as final, otherwise add the entry.\n    if (value < visibilityWatcher.firstHiddenTime) {\n      metric.value = value;\n      metric.entries.push(entry);\n    }\n\n    if (report) {\n      report();\n    }\n  };\n\n  var po = observe('largest-contentful-paint', entryHandler);\n\n  if (po) {\n    report = bindReporter(onReport, metric, reportAllChanges);\n\n    var stopListening = () => {\n      if (!reportedMetricIDs[metric.id]) {\n        po.takeRecords().map(entryHandler );\n        po.disconnect();\n        reportedMetricIDs[metric.id] = true;\n        report(true);\n      }\n    };\n\n    // Stop listening after input. Note: while scrolling is an input that\n    // stop LCP observation, it's unreliable since it can be programmatically\n    // generated. See: https://github.com/GoogleChrome/web-vitals/issues/75\n    ['keydown', 'click'].forEach(type => {\n      addEventListener(type, stopListening, { once: true, capture: true });\n    });\n\n    onHidden(stopListening, true);\n  }\n};\n\nexport { getLCP };\n//# sourceMappingURL=getLCP.js.map\n","/**\n * Checks if a given value is a valid measurement value.\n */\nfunction isMeasurementValue(value) {\n  return typeof value === 'number' && isFinite(value);\n}\n\n/**\n * Helper function to start child on transactions. This function will make sure that the transaction will\n * use the start timestamp of the created child span if it is earlier than the transactions actual\n * start timestamp.\n */\nfunction _startChild(transaction, { startTimestamp, ...ctx }) {\n  if (startTimestamp && transaction.startTimestamp > startTimestamp) {\n    transaction.startTimestamp = startTimestamp;\n  }\n\n  return transaction.startChild({\n    startTimestamp,\n    ...ctx,\n  });\n}\n\nexport { _startChild, isMeasurementValue };\n//# sourceMappingURL=utils.js.map\n","import { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { getGlobalObject, browserPerformanceTimeOrigin, logger, htmlTreeAsString } from '@sentry/utils';\nimport { msToSec } from '../../utils.js';\nimport { getCLS } from '../web-vitals/getCLS.js';\nimport { getFID } from '../web-vitals/getFID.js';\nimport { getLCP } from '../web-vitals/getLCP.js';\nimport { getVisibilityWatcher } from '../web-vitals/lib/getVisibilityWatcher.js';\nimport { _startChild, isMeasurementValue } from './utils.js';\n\nvar global = getGlobalObject();\n\nfunction getBrowserPerformanceAPI() {\n  return global && global.addEventListener && global.performance;\n}\n\nlet _performanceCursor = 0;\n\nlet _measurements = {};\nlet _lcpEntry;\nlet _clsEntry;\n\n/**\n * Start tracking web vitals\n */\nfunction startTrackingWebVitals(reportAllChanges = false) {\n  var performance = getBrowserPerformanceAPI();\n  if (performance && browserPerformanceTimeOrigin) {\n    if (performance.mark) {\n      global.performance.mark('sentry-tracing-init');\n    }\n    _trackCLS();\n    _trackLCP(reportAllChanges);\n    _trackFID();\n  }\n}\n\n/** Starts tracking the Cumulative Layout Shift on the current page. */\nfunction _trackCLS() {\n  // See:\n  // https://web.dev/evolving-cls/\n  // https://web.dev/cls-web-tooling/\n  getCLS(metric => {\n    var entry = metric.entries.pop();\n    if (!entry) {\n      return;\n    }\n\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding CLS');\n    _measurements['cls'] = { value: metric.value, unit: '' };\n    _clsEntry = entry ;\n  });\n}\n\n/** Starts tracking the Largest Contentful Paint on the current page. */\nfunction _trackLCP(reportAllChanges) {\n  getLCP(metric => {\n    var entry = metric.entries.pop();\n    if (!entry) {\n      return;\n    }\n\n    var timeOrigin = msToSec(browserPerformanceTimeOrigin );\n    var startTime = msToSec(entry.startTime);\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding LCP');\n    _measurements['lcp'] = { value: metric.value, unit: 'millisecond' };\n    _measurements['mark.lcp'] = { value: timeOrigin + startTime, unit: 'second' };\n    _lcpEntry = entry ;\n  }, reportAllChanges);\n}\n\n/** Starts tracking the First Input Delay on the current page. */\nfunction _trackFID() {\n  getFID(metric => {\n    var entry = metric.entries.pop();\n    if (!entry) {\n      return;\n    }\n\n    var timeOrigin = msToSec(browserPerformanceTimeOrigin );\n    var startTime = msToSec(entry.startTime);\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FID');\n    _measurements['fid'] = { value: metric.value, unit: 'millisecond' };\n    _measurements['mark.fid'] = { value: timeOrigin + startTime, unit: 'second' };\n  });\n}\n\n/** Add performance related spans to a transaction */\nfunction addPerformanceEntries(transaction) {\n  var performance = getBrowserPerformanceAPI();\n  if (!performance || !global.performance.getEntries || !browserPerformanceTimeOrigin) {\n    // Gatekeeper if performance API not available\n    return;\n  }\n\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Adding & adjusting spans using Performance API');\n  var timeOrigin = msToSec(browserPerformanceTimeOrigin);\n\n  var performanceEntries = performance.getEntries();\n\n  let responseStartTimestamp;\n  let requestStartTimestamp;\n\n    performanceEntries.slice(_performanceCursor).forEach((entry) => {\n    var startTime = msToSec(entry.startTime);\n    var duration = msToSec(entry.duration);\n\n    if (transaction.op === 'navigation' && timeOrigin + startTime < transaction.startTimestamp) {\n      return;\n    }\n\n    switch (entry.entryType) {\n      case 'navigation': {\n        _addNavigationSpans(transaction, entry, timeOrigin);\n        responseStartTimestamp = timeOrigin + msToSec(entry.responseStart);\n        requestStartTimestamp = timeOrigin + msToSec(entry.requestStart);\n        break;\n      }\n      case 'mark':\n      case 'paint':\n      case 'measure': {\n        var startTimestamp = _addMeasureSpans(transaction, entry, startTime, duration, timeOrigin);\n\n        // capture web vitals\n        var firstHidden = getVisibilityWatcher();\n        // Only report if the page wasn't hidden prior to the web vital.\n        var shouldRecord = entry.startTime < firstHidden.firstHiddenTime;\n\n        if (entry.name === 'first-paint' && shouldRecord) {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FP');\n          _measurements['fp'] = { value: entry.startTime, unit: 'millisecond' };\n          _measurements['mark.fp'] = { value: startTimestamp, unit: 'second' };\n        }\n        if (entry.name === 'first-contentful-paint' && shouldRecord) {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FCP');\n          _measurements['fcp'] = { value: entry.startTime, unit: 'millisecond' };\n          _measurements['mark.fcp'] = { value: startTimestamp, unit: 'second' };\n        }\n        break;\n      }\n      case 'resource': {\n        var resourceName = (entry.name ).replace(global.location.origin, '');\n        _addResourceSpans(transaction, entry, resourceName, startTime, duration, timeOrigin);\n        break;\n      }\n      default:\n      // Ignore other entry types.\n    }\n  });\n\n  _performanceCursor = Math.max(performanceEntries.length - 1, 0);\n\n  _trackNavigator(transaction);\n\n  // Measurements are only available for pageload transactions\n  if (transaction.op === 'pageload') {\n    // Generate TTFB (Time to First Byte), which measured as the time between the beginning of the transaction and the\n    // start of the response in milliseconds\n    if (typeof responseStartTimestamp === 'number') {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding TTFB');\n      _measurements['ttfb'] = {\n        value: (responseStartTimestamp - transaction.startTimestamp) * 1000,\n        unit: 'millisecond',\n      };\n\n      if (typeof requestStartTimestamp === 'number' && requestStartTimestamp <= responseStartTimestamp) {\n        // Capture the time spent making the request and receiving the first byte of the response.\n        // This is the time between the start of the request and the start of the response in milliseconds.\n        _measurements['ttfb.requestTime'] = {\n          value: (responseStartTimestamp - requestStartTimestamp) * 1000,\n          unit: 'millisecond',\n        };\n      }\n    }\n\n    ['fcp', 'fp', 'lcp'].forEach(name => {\n      if (!_measurements[name] || timeOrigin >= transaction.startTimestamp) {\n        return;\n      }\n      // The web vitals, fcp, fp, lcp, and ttfb, all measure relative to timeOrigin.\n      // Unfortunately, timeOrigin is not captured within the transaction span data, so these web vitals will need\n      // to be adjusted to be relative to transaction.startTimestamp.\n      var oldValue = _measurements[name].value;\n      var measurementTimestamp = timeOrigin + msToSec(oldValue);\n\n      // normalizedValue should be in milliseconds\n      var normalizedValue = Math.abs((measurementTimestamp - transaction.startTimestamp) * 1000);\n      var delta = normalizedValue - oldValue;\n\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.log(`[Measurements] Normalized ${name} from ${oldValue} to ${normalizedValue} (${delta})`);\n      _measurements[name].value = normalizedValue;\n    });\n\n    if (_measurements['mark.fid'] && _measurements['fid']) {\n      // create span for FID\n      _startChild(transaction, {\n        description: 'first input delay',\n        endTimestamp: _measurements['mark.fid'].value + msToSec(_measurements['fid'].value),\n        op: 'web.vitals',\n        startTimestamp: _measurements['mark.fid'].value,\n      });\n    }\n\n    // If FCP is not recorded we should not record the cls value\n    // according to the new definition of CLS.\n    if (!('fcp' in _measurements)) {\n      delete _measurements.cls;\n    }\n\n    Object.keys(_measurements).forEach(measurementName => {\n      transaction.setMeasurement(\n        measurementName,\n        _measurements[measurementName].value,\n        _measurements[measurementName].unit,\n      );\n    });\n\n    _tagMetricInfo(transaction);\n  }\n\n  _lcpEntry = undefined;\n  _clsEntry = undefined;\n  _measurements = {};\n}\n\n/** Create measure related spans */\nfunction _addMeasureSpans(\n  transaction,\n    entry,\n  startTime,\n  duration,\n  timeOrigin,\n) {\n  var measureStartTimestamp = timeOrigin + startTime;\n  var measureEndTimestamp = measureStartTimestamp + duration;\n\n  _startChild(transaction, {\n    description: entry.name ,\n    endTimestamp: measureEndTimestamp,\n    op: entry.entryType ,\n    startTimestamp: measureStartTimestamp,\n  });\n\n  return measureStartTimestamp;\n}\n\n/** Instrument navigation entries */\nfunction _addNavigationSpans(transaction, entry, timeOrigin) {\n  ['unloadEvent', 'redirect', 'domContentLoadedEvent', 'loadEvent', 'connect'].forEach(event => {\n    _addPerformanceNavigationTiming(transaction, entry, event, timeOrigin);\n  });\n  _addPerformanceNavigationTiming(transaction, entry, 'secureConnection', timeOrigin, 'TLS/SSL', 'connectEnd');\n  _addPerformanceNavigationTiming(transaction, entry, 'fetch', timeOrigin, 'cache', 'domainLookupStart');\n  _addPerformanceNavigationTiming(transaction, entry, 'domainLookup', timeOrigin, 'DNS');\n  _addRequest(transaction, entry, timeOrigin);\n}\n\n/** Create performance navigation related spans */\nfunction _addPerformanceNavigationTiming(\n  transaction,\n    entry,\n  event,\n  timeOrigin,\n  description,\n  eventEnd,\n) {\n  var end = eventEnd ? (entry[eventEnd] ) : (entry[`${event}End`] );\n  var start = entry[`${event}Start`] ;\n  if (!start || !end) {\n    return;\n  }\n  _startChild(transaction, {\n    op: 'browser',\n    description: _nullishCoalesce(description, () => ( event)),\n    startTimestamp: timeOrigin + msToSec(start),\n    endTimestamp: timeOrigin + msToSec(end),\n  });\n}\n\n/** Create request and response related spans */\nfunction _addRequest(transaction, entry, timeOrigin) {\n  _startChild(transaction, {\n    op: 'browser',\n    description: 'request',\n    startTimestamp: timeOrigin + msToSec(entry.requestStart ),\n    endTimestamp: timeOrigin + msToSec(entry.responseEnd ),\n  });\n\n  _startChild(transaction, {\n    op: 'browser',\n    description: 'response',\n    startTimestamp: timeOrigin + msToSec(entry.responseStart ),\n    endTimestamp: timeOrigin + msToSec(entry.responseEnd ),\n  });\n}\n\n/** Create resource-related spans */\nfunction _addResourceSpans(\n  transaction,\n  entry,\n  resourceName,\n  startTime,\n  duration,\n  timeOrigin,\n) {\n  // we already instrument based on fetch and xhr, so we don't need to\n  // duplicate spans here.\n  if (entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch') {\n    return;\n  }\n\n    var data = {};\n  if ('transferSize' in entry) {\n    data['Transfer Size'] = entry.transferSize;\n  }\n  if ('encodedBodySize' in entry) {\n    data['Encoded Body Size'] = entry.encodedBodySize;\n  }\n  if ('decodedBodySize' in entry) {\n    data['Decoded Body Size'] = entry.decodedBodySize;\n  }\n\n  var startTimestamp = timeOrigin + startTime;\n  var endTimestamp = startTimestamp + duration;\n\n  _startChild(transaction, {\n    description: resourceName,\n    endTimestamp,\n    op: entry.initiatorType ? `resource.${entry.initiatorType}` : 'resource',\n    startTimestamp,\n    data,\n  });\n}\n\n/**\n * Capture the information of the user agent.\n */\nfunction _trackNavigator(transaction) {\n  var navigator = global.navigator ;\n  if (!navigator) {\n    return;\n  }\n\n  // track network connectivity\n  var connection = navigator.connection;\n  if (connection) {\n    if (connection.effectiveType) {\n      transaction.setTag('effectiveConnectionType', connection.effectiveType);\n    }\n\n    if (connection.type) {\n      transaction.setTag('connectionType', connection.type);\n    }\n\n    if (isMeasurementValue(connection.rtt)) {\n      _measurements['connection.rtt'] = { value: connection.rtt, unit: 'millisecond' };\n    }\n\n    if (isMeasurementValue(connection.downlink)) {\n      _measurements['connection.downlink'] = { value: connection.downlink, unit: '' }; // unit is empty string for now, while relay doesn't support download speed units\n    }\n  }\n\n  if (isMeasurementValue(navigator.deviceMemory)) {\n    transaction.setTag('deviceMemory', `${navigator.deviceMemory} GB`);\n  }\n\n  if (isMeasurementValue(navigator.hardwareConcurrency)) {\n    transaction.setTag('hardwareConcurrency', String(navigator.hardwareConcurrency));\n  }\n}\n\n/** Add LCP / CLS data to transaction to allow debugging */\nfunction _tagMetricInfo(transaction) {\n  if (_lcpEntry) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding LCP Data');\n\n    // Capture Properties of the LCP element that contributes to the LCP.\n\n    if (_lcpEntry.element) {\n      transaction.setTag('lcp.element', htmlTreeAsString(_lcpEntry.element));\n    }\n\n    if (_lcpEntry.id) {\n      transaction.setTag('lcp.id', _lcpEntry.id);\n    }\n\n    if (_lcpEntry.url) {\n      // Trim URL to the first 200 characters.\n      transaction.setTag('lcp.url', _lcpEntry.url.trim().slice(0, 200));\n    }\n\n    transaction.setTag('lcp.size', _lcpEntry.size);\n  }\n\n  // See: https://developer.mozilla.org/en-US/docs/Web/API/LayoutShift\n  if (_clsEntry && _clsEntry.sources) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding CLS Data');\n    _clsEntry.sources.forEach((source, index) =>\n      transaction.setTag(`cls.source.${index + 1}`, htmlTreeAsString(source.node)),\n    );\n  }\n}\n\nexport { _addMeasureSpans, _addResourceSpans, addPerformanceEntries, startTrackingWebVitals };\n//# sourceMappingURL=index.js.map\n","import { isMatchingPattern, addInstrumentationHandler, isInstanceOf, BAGGAGE_HEADER_NAME, mergeAndSerializeBaggage } from '@sentry/utils';\nimport { hasTracingEnabled, getActiveTransaction } from '../utils.js';\n\nvar DEFAULT_TRACING_ORIGINS = ['localhost', /^\\//];\n\n/** Options for Request Instrumentation */\n\nvar defaultRequestInstrumentationOptions = {\n  traceFetch: true,\n  traceXHR: true,\n  tracingOrigins: DEFAULT_TRACING_ORIGINS,\n};\n\n/** Registers span creators for xhr and fetch requests  */\nfunction instrumentOutgoingRequests(_options) {\n    const { traceFetch, traceXHR, tracingOrigins, shouldCreateSpanForRequest } = {\n    ...defaultRequestInstrumentationOptions,\n    ..._options,\n  };\n\n  // We should cache url -> decision so that we don't have to compute\n  // regexp everytime we create a request.\n  var urlMap = {};\n\n  var defaultShouldCreateSpan = (url) => {\n    if (urlMap[url]) {\n      return urlMap[url];\n    }\n    var origins = tracingOrigins;\n    urlMap[url] =\n      origins.some((origin) => isMatchingPattern(url, origin)) &&\n      !isMatchingPattern(url, 'sentry_key');\n    return urlMap[url];\n  };\n\n  // We want that our users don't have to re-implement shouldCreateSpanForRequest themselves\n  // That's why we filter out already unwanted Spans from tracingOrigins\n  let shouldCreateSpan = defaultShouldCreateSpan;\n  if (typeof shouldCreateSpanForRequest === 'function') {\n    shouldCreateSpan = (url) => {\n      return defaultShouldCreateSpan(url) && shouldCreateSpanForRequest(url);\n    };\n  }\n\n  var spans = {};\n\n  if (traceFetch) {\n    addInstrumentationHandler('fetch', (handlerData) => {\n      fetchCallback(handlerData, shouldCreateSpan, spans);\n    });\n  }\n\n  if (traceXHR) {\n    addInstrumentationHandler('xhr', (handlerData) => {\n      xhrCallback(handlerData, shouldCreateSpan, spans);\n    });\n  }\n}\n\n/**\n * Create and track fetch request spans\n */\nfunction fetchCallback(\n  handlerData,\n  shouldCreateSpan,\n  spans,\n) {\n  if (!hasTracingEnabled() || !(handlerData.fetchData && shouldCreateSpan(handlerData.fetchData.url))) {\n    return;\n  }\n\n  if (handlerData.endTimestamp) {\n    var spanId = handlerData.fetchData.__span;\n    if (!spanId) return;\n\n    var span = spans[spanId];\n    if (span) {\n      if (handlerData.response) {\n        // TODO (kmclb) remove this once types PR goes through\n                span.setHttpStatus(handlerData.response.status);\n      } else if (handlerData.error) {\n        span.setStatus('internal_error');\n      }\n      span.finish();\n\n            delete spans[spanId];\n    }\n    return;\n  }\n\n  var activeTransaction = getActiveTransaction();\n  if (activeTransaction) {\n    var span = activeTransaction.startChild({\n      data: {\n        ...handlerData.fetchData,\n        type: 'fetch',\n      },\n      description: `${handlerData.fetchData.method} ${handlerData.fetchData.url}`,\n      op: 'http.client',\n    });\n\n    handlerData.fetchData.__span = span.spanId;\n    spans[span.spanId] = span;\n\n    var request = (handlerData.args[0] = handlerData.args[0] );\n        var options = (handlerData.args[1] = (handlerData.args[1] ) || {});\n    options.headers = addTracingHeaders(request, activeTransaction.getBaggage(), span, options);\n  }\n}\n\nfunction addTracingHeaders(\n  request,\n  incomingBaggage,\n  span,\n  options,\n) {\n  let headers = options.headers;\n\n  if (isInstanceOf(request, Request)) {\n    headers = (request ).headers;\n  }\n\n  if (headers) {\n        if (typeof headers.append === 'function') {\n            headers.append('sentry-trace', span.toTraceparent());\n            headers.append(BAGGAGE_HEADER_NAME, mergeAndSerializeBaggage(incomingBaggage, headers.get(BAGGAGE_HEADER_NAME)));\n    } else if (Array.isArray(headers)) {\n      const [, headerBaggageString] = headers.find(([key, _]) => key === BAGGAGE_HEADER_NAME);\n      headers = [\n        ...headers,\n        ['sentry-trace', span.toTraceparent()],\n        [BAGGAGE_HEADER_NAME, mergeAndSerializeBaggage(incomingBaggage, headerBaggageString)],\n      ];\n    } else {\n      headers = {\n        ...headers,\n        'sentry-trace': span.toTraceparent(),\n                baggage: mergeAndSerializeBaggage(incomingBaggage, headers.baggage),\n      };\n    }\n  } else {\n    headers = { 'sentry-trace': span.toTraceparent(), baggage: mergeAndSerializeBaggage(incomingBaggage) };\n  }\n  return headers;\n}\n\n/**\n * Create and track xhr request spans\n */\nfunction xhrCallback(\n  handlerData,\n  shouldCreateSpan,\n  spans,\n) {\n  if (\n    !hasTracingEnabled() ||\n    (handlerData.xhr && handlerData.xhr.__sentry_own_request__) ||\n    !(handlerData.xhr && handlerData.xhr.__sentry_xhr__ && shouldCreateSpan(handlerData.xhr.__sentry_xhr__.url))\n  ) {\n    return;\n  }\n\n  var xhr = handlerData.xhr.__sentry_xhr__;\n\n  // check first if the request has finished and is tracked by an existing span which should now end\n  if (handlerData.endTimestamp) {\n    var spanId = handlerData.xhr.__sentry_xhr_span_id__;\n    if (!spanId) return;\n\n    var span = spans[spanId];\n    if (span) {\n      span.setHttpStatus(xhr.status_code);\n      span.finish();\n\n            delete spans[spanId];\n    }\n    return;\n  }\n\n  // if not, create a new span to track it\n  var activeTransaction = getActiveTransaction();\n  if (activeTransaction) {\n    var span = activeTransaction.startChild({\n      data: {\n        ...xhr.data,\n        type: 'xhr',\n        method: xhr.method,\n        url: xhr.url,\n      },\n      description: `${xhr.method} ${xhr.url}`,\n      op: 'http.client',\n    });\n\n    handlerData.xhr.__sentry_xhr_span_id__ = span.spanId;\n    spans[handlerData.xhr.__sentry_xhr_span_id__] = span;\n\n    if (handlerData.xhr.setRequestHeader) {\n      try {\n        handlerData.xhr.setRequestHeader('sentry-trace', span.toTraceparent());\n\n        var headerBaggageString =\n          handlerData.xhr.getRequestHeader && handlerData.xhr.getRequestHeader(BAGGAGE_HEADER_NAME);\n\n        handlerData.xhr.setRequestHeader(\n          BAGGAGE_HEADER_NAME,\n          mergeAndSerializeBaggage(activeTransaction.getBaggage(), headerBaggageString),\n        );\n      } catch (_) {\n        // Error: InvalidStateError: Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.\n      }\n    }\n  }\n}\n\nexport { DEFAULT_TRACING_ORIGINS, defaultRequestInstrumentationOptions, fetchCallback, instrumentOutgoingRequests, xhrCallback };\n//# sourceMappingURL=request.js.map\n","import { getGlobalObject, logger, addInstrumentationHandler } from '@sentry/utils';\n\nvar global = getGlobalObject();\n\n/**\n * Default function implementing pageload and navigation transactions\n */\nfunction instrumentRoutingWithDefaults(\n  customStartTransaction,\n  startTransactionOnPageLoad = true,\n  startTransactionOnLocationChange = true,\n) {\n  if (!global || !global.location) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Could not initialize routing instrumentation due to invalid location');\n    return;\n  }\n\n  let startingUrl = global.location.href;\n\n  let activeTransaction;\n  if (startTransactionOnPageLoad) {\n    activeTransaction = customStartTransaction({\n      name: global.location.pathname,\n      op: 'pageload',\n      metadata: { source: 'url' },\n    });\n  }\n\n  if (startTransactionOnLocationChange) {\n    addInstrumentationHandler('history', ({ to, from }) => {\n      /**\n       * This early return is there to account for some cases where a navigation transaction starts right after\n       * long-running pageload. We make sure that if `from` is undefined and a valid `startingURL` exists, we don't\n       * create an uneccessary navigation transaction.\n       *\n       * This was hard to duplicate, but this behavior stopped as soon as this fix was applied. This issue might also\n       * only be caused in certain development environments where the usage of a hot module reloader is causing\n       * errors.\n       */\n      if (from === undefined && startingUrl && startingUrl.indexOf(to) !== -1) {\n        startingUrl = undefined;\n        return;\n      }\n\n      if (from !== to) {\n        startingUrl = undefined;\n        if (activeTransaction) {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Finishing current transaction with op: ${activeTransaction.op}`);\n          // If there's an open transaction on the scope, we need to finish it before creating an new one.\n          activeTransaction.finish();\n        }\n        activeTransaction = customStartTransaction({\n          name: global.location.pathname,\n          op: 'navigation',\n          metadata: { source: 'url' },\n        });\n      }\n    });\n  }\n}\n\nexport { instrumentRoutingWithDefaults };\n//# sourceMappingURL=router.js.map\n","import { logger, getGlobalObject, extractTraceparentData, parseBaggageSetMutability } from '@sentry/utils';\nimport { startIdleTransaction } from '../hubextensions.js';\nimport { DEFAULT_IDLE_TIMEOUT, DEFAULT_FINAL_TIMEOUT } from '../idletransaction.js';\nimport '../utils.js';\nimport { registerBackgroundTabDetection } from './backgroundtab.js';\nimport { startTrackingWebVitals, addPerformanceEntries } from './metrics/index.js';\nimport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './request.js';\nimport { instrumentRoutingWithDefaults } from './router.js';\n\nvar BROWSER_TRACING_INTEGRATION_ID = 'BrowserTracing';\n\n/** Options for Browser Tracing integration */\n\nvar DEFAULT_BROWSER_TRACING_OPTIONS = {\n  idleTimeout: DEFAULT_IDLE_TIMEOUT,\n  finalTimeout: DEFAULT_FINAL_TIMEOUT,\n  markBackgroundTransactions: true,\n  routingInstrumentation: instrumentRoutingWithDefaults,\n  startTransactionOnLocationChange: true,\n  startTransactionOnPageLoad: true,\n  ...defaultRequestInstrumentationOptions,\n};\n\n/**\n * The Browser Tracing integration automatically instruments browser pageload/navigation\n * actions as transactions, and captures requests, metrics and errors as spans.\n *\n * The integration can be configured with a variety of options, and can be extended to use\n * any routing library. This integration uses {@see IdleTransaction} to create transactions.\n */\nclass BrowserTracing  {\n  // This class currently doesn't have a static `id` field like the other integration classes, because it prevented\n  // @sentry/tracing from being treeshaken. Tree shakers do not like static fields, because they behave like side effects.\n  // TODO: Come up with a better plan, than using static fields on integration classes, and use that plan on all\n  // integrations.\n\n  /** Browser Tracing integration options */\n  \n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = BROWSER_TRACING_INTEGRATION_ID;}\n\n   constructor(_options) {;BrowserTracing.prototype.__init.call(this);\n    let tracingOrigins = defaultRequestInstrumentationOptions.tracingOrigins;\n    // NOTE: Logger doesn't work in constructors, as it's initialized after integrations instances\n    if (_options) {\n      if (_options.tracingOrigins && Array.isArray(_options.tracingOrigins) && _options.tracingOrigins.length !== 0) {\n        tracingOrigins = _options.tracingOrigins;\n      } else {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && (this._emitOptionsWarning = true);\n      }\n    }\n\n    this.options = {\n      ...DEFAULT_BROWSER_TRACING_OPTIONS,\n      ..._options,\n      tracingOrigins,\n    };\n\n    const { _metricOptions } = this.options;\n    startTrackingWebVitals(_metricOptions && _metricOptions._reportAllChanges);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce(_, getCurrentHub) {\n    this._getCurrentHub = getCurrentHub;\n\n    if (this._emitOptionsWarning) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn(\n          '[Tracing] You need to define `tracingOrigins` in the options. Set an array of urls or patterns to trace.',\n        );\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn(\n          `[Tracing] We added a reasonable default for you: ${defaultRequestInstrumentationOptions.tracingOrigins}`,\n        );\n    }\n\n        const {\n      routingInstrumentation: instrumentRouting,\n      startTransactionOnLocationChange,\n      startTransactionOnPageLoad,\n      markBackgroundTransactions,\n      traceFetch,\n      traceXHR,\n      tracingOrigins,\n      shouldCreateSpanForRequest,\n    } = this.options;\n\n    instrumentRouting(\n      (context) => this._createRouteTransaction(context),\n      startTransactionOnPageLoad,\n      startTransactionOnLocationChange,\n    );\n\n    if (markBackgroundTransactions) {\n      registerBackgroundTabDetection();\n    }\n\n    instrumentOutgoingRequests({ traceFetch, traceXHR, tracingOrigins, shouldCreateSpanForRequest });\n  }\n\n  /** Create routing idle transaction. */\n   _createRouteTransaction(context) {\n    if (!this._getCurrentHub) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn(`[Tracing] Did not create ${context.op} transaction because _getCurrentHub is invalid.`);\n      return undefined;\n    }\n\n        const { beforeNavigate, idleTimeout, finalTimeout } = this.options;\n\n    var parentContextFromHeader = context.op === 'pageload' ? extractTraceDataFromMetaTags() : undefined;\n\n    var expandedContext = {\n      ...context,\n      ...parentContextFromHeader,\n      ...(parentContextFromHeader && {\n        metadata: {\n          ...context.metadata,\n          ...parentContextFromHeader.metadata,\n        },\n      }),\n      trimEnd: true,\n    };\n    var modifiedContext = typeof beforeNavigate === 'function' ? beforeNavigate(expandedContext) : expandedContext;\n\n    // For backwards compatibility reasons, beforeNavigate can return undefined to \"drop\" the transaction (prevent it\n    // from being sent to Sentry).\n    var finalContext = modifiedContext === undefined ? { ...expandedContext, sampled: false } : modifiedContext;\n\n    // If `beforeNavigate` set a custom name, record that fact\n    finalContext.metadata =\n      finalContext.name !== expandedContext.name\n        ? { ...finalContext.metadata, source: 'custom' }\n        : finalContext.metadata;\n\n    if (finalContext.sampled === false) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.log(`[Tracing] Will not send ${finalContext.op} transaction because of beforeNavigate.`);\n    }\n\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Starting ${finalContext.op} transaction on scope`);\n\n    var hub = this._getCurrentHub();\n    const { location } = getGlobalObject() ;\n\n    var idleTransaction = startIdleTransaction(\n      hub,\n      finalContext,\n      idleTimeout,\n      finalTimeout,\n      true,\n      { location }, // for use in the tracesSampler\n    );\n    idleTransaction.registerBeforeFinishCallback(transaction => {\n      addPerformanceEntries(transaction);\n      transaction.setTag(\n        'sentry_reportAllChanges',\n        Boolean(this.options._metricOptions && this.options._metricOptions._reportAllChanges),\n      );\n    });\n\n    return idleTransaction ;\n  }\n}\n\n/**\n * Gets transaction context data from `sentry-trace` and `baggage` <meta> tags.\n * @returns Transaction context data or undefined neither tag exists or has valid data\n */\nfunction extractTraceDataFromMetaTags() {\n  var sentrytraceValue = getMetaContent('sentry-trace');\n  var baggageValue = getMetaContent('baggage');\n\n  var sentrytraceData = sentrytraceValue ? extractTraceparentData(sentrytraceValue) : undefined;\n  var baggage = parseBaggageSetMutability(baggageValue, sentrytraceValue);\n\n  // TODO more extensive checks for baggage validity/emptyness?\n  if (sentrytraceData || baggage) {\n    return {\n      ...(sentrytraceData && sentrytraceData),\n      ...(baggage && { metadata: { baggage } }),\n    };\n  }\n\n  return undefined;\n}\n\n/** Returns the value of a meta tag */\nfunction getMetaContent(metaName) {\n  var globalObject = getGlobalObject();\n\n  // DOM/querySelector is not available in all environments\n  if (globalObject.document && globalObject.document.querySelector) {\n    var el = globalObject.document.querySelector(`meta[name=${metaName}]`);\n    return el ? el.getAttribute('content') : null;\n  } else {\n    return null;\n  }\n}\n\nexport { BROWSER_TRACING_INTEGRATION_ID, BrowserTracing, extractTraceDataFromMetaTags, getMetaContent };\n//# sourceMappingURL=browsertracing.js.map\n","import { addExtensionMethods } from './hubextensions.js';\nexport { addExtensionMethods, startIdleTransaction } from './hubextensions.js';\nimport * as index from './integrations/index.js';\nexport { index as Integrations };\nimport './browser/index.js';\nexport { Span, spanStatusfromHttpCode } from './span.js';\nexport { SpanStatus } from './spanstatus.js';\nexport { Transaction } from './transaction.js';\nexport { IdleTransaction } from './idletransaction.js';\nexport { getActiveTransaction, hasTracingEnabled } from './utils.js';\nexport { BROWSER_TRACING_INTEGRATION_ID, BrowserTracing } from './browser/browsertracing.js';\nexport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './browser/request.js';\nexport { TRACEPARENT_REGEXP, extractTraceparentData, stripUrlQueryAndFragment } from '@sentry/utils';\n\n;\n;\n\n// Treeshakable guard to remove all code related to tracing\n\n// Guard for tree\nif (typeof __SENTRY_TRACING__ === 'undefined' || __SENTRY_TRACING__) {\n  // We are patching the global object with our hub extension methods\n  addExtensionMethods();\n}\n//# sourceMappingURL=index.js.map\n","/**\n * Polyfill for the optional chain operator, `?.`, given previous conversion of the expression into an array of values,\n * descriptors, and functions.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n * See https://github.com/alangpierce/sucrase/blob/265887868966917f3b924ce38dfad01fbab1329f/src/transformers/OptionalChainingNullishTransformer.ts#L15\n *\n * @param ops Array result of expression conversion\n * @returns The value of the expression\n */\nfunction _optionalChain(ops) {\n  let lastAccessLHS = undefined;\n  let value = ops[0];\n  let i = 1;\n  while (i < ops.length) {\n    var op = ops[i] ;\n    var fn = ops[i + 1] ;\n    i += 2;\n    // by checking for loose equality to `null`, we catch both `null` and `undefined`\n    if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n      // really we're meaning to return `undefined` as an actual value here, but it saves bytes not to write it\n      return;\n    }\n    if (op === 'access' || op === 'optionalAccess') {\n      lastAccessLHS = value;\n      value = fn(value);\n    } else if (op === 'call' || op === 'optionalCall') {\n      value = fn((...args) => (value ).call(lastAccessLHS, ...args));\n      lastAccessLHS = undefined;\n    }\n  }\n  return value;\n}\n\n// Sucrase version\n// function _optionalChain(ops) {\n//   let lastAccessLHS = undefined;\n//   let value = ops[0];\n//   let i = 1;\n//   while (i < ops.length) {\n//     var op = ops[i];\n//     var fn = ops[i + 1];\n//     i += 2;\n//     if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n//       return undefined;\n//     }\n//     if (op === 'access' || op === 'optionalAccess') {\n//       lastAccessLHS = value;\n//       value = fn(value);\n//     } else if (op === 'call' || op === 'optionalCall') {\n//       value = fn((...args) => value.call(lastAccessLHS, ...args));\n//       lastAccessLHS = undefined;\n//     }\n//   }\n//   return value;\n// }\n\nexport { _optionalChain };\n//# sourceMappingURL=_optionalChain.js.map\n","// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend\n\nvar DEFAULT_RETRY_AFTER = 60 * 1000; // 60 seconds\n\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param header string representation of 'Retry-After' header\n * @param now current unix timestamp\n *\n */\nfunction parseRetryAfterHeader(header, now = Date.now()) {\n  var headerDelay = parseInt(`${header}`, 10);\n  if (!isNaN(headerDelay)) {\n    return headerDelay * 1000;\n  }\n\n  var headerDate = Date.parse(`${header}`);\n  if (!isNaN(headerDate)) {\n    return headerDate - now;\n  }\n\n  return DEFAULT_RETRY_AFTER;\n}\n\n/**\n * Gets the time that given category is disabled until for rate limiting\n */\nfunction disabledUntil(limits, category) {\n  return limits[category] || limits.all || 0;\n}\n\n/**\n * Checks if a category is rate limited\n */\nfunction isRateLimited(limits, category, now = Date.now()) {\n  return disabledUntil(limits, category) > now;\n}\n\n/**\n * Update ratelimits from incoming headers.\n * Returns true if headers contains a non-empty rate limiting header.\n */\nfunction updateRateLimits(\n  limits,\n  { statusCode, headers },\n  now = Date.now(),\n) {\n  var updatedRateLimits = {\n    ...limits,\n  };\n\n  // \"The name is case-insensitive.\"\n  // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n  var rateLimitHeader = headers && headers['x-sentry-rate-limits'];\n  var retryAfterHeader = headers && headers['retry-after'];\n\n  if (rateLimitHeader) {\n    /**\n     * rate limit headers are of the form\n     *     <header>,<header>,..\n     * where each <header> is of the form\n     *     <retry_after>: <categories>: <scope>: <reason_code>\n     * where\n     *     <retry_after> is a delay in seconds\n     *     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form\n     *         <category>;<category>;...\n     *     <scope> is what's being limited (org, project, or key) - ignored by SDK\n     *     <reason_code> is an arbitrary string like \"org_quota\" - ignored by SDK\n     */\n    for (var limit of rateLimitHeader.trim().split(',')) {\n      const [retryAfter, categories] = limit.split(':', 2);\n      var headerDelay = parseInt(retryAfter, 10);\n      var delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n      if (!categories) {\n        updatedRateLimits.all = now + delay;\n      } else {\n        for (var category of categories.split(';')) {\n          updatedRateLimits[category] = now + delay;\n        }\n      }\n    }\n  } else if (retryAfterHeader) {\n    updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);\n  } else if (statusCode === 429) {\n    updatedRateLimits.all = now + 60 * 1000;\n  }\n\n  return updatedRateLimits;\n}\n\nexport { DEFAULT_RETRY_AFTER, disabledUntil, isRateLimited, parseRetryAfterHeader, updateRateLimits };\n//# sourceMappingURL=ratelimit.js.map\n","import { isString } from './is.js';\nimport { logger } from './logger.js';\n\nvar BAGGAGE_HEADER_NAME = 'baggage';\n\nvar SENTRY_BAGGAGE_KEY_PREFIX = 'sentry-';\n\nvar SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;\n\n/**\n * Max length of a serialized baggage string\n *\n * https://www.w3.org/TR/baggage/#limits\n */\nvar MAX_BAGGAGE_STRING_LENGTH = 8192;\n\n/** Create an instance of Baggage */\nfunction createBaggage(initItems, baggageString = '', mutable = true) {\n  return [{ ...initItems }, baggageString, mutable];\n}\n\n/** Get a value from baggage */\nfunction getBaggageValue(baggage, key) {\n  return baggage[0][key];\n}\n\n/** Add a value to baggage */\nfunction setBaggageValue(baggage, key, value) {\n  if (isBaggageMutable(baggage)) {\n    baggage[0][key] = value;\n  }\n}\n\n/** Check if the Sentry part of the passed baggage (i.e. the first element in the tuple) is empty */\nfunction isSentryBaggageEmpty(baggage) {\n  return Object.keys(baggage[0]).length === 0;\n}\n\n/** Returns Sentry specific baggage values */\nfunction getSentryBaggageItems(baggage) {\n  return baggage[0];\n}\n\n/**\n * Returns 3rd party baggage string of @param baggage\n * @param baggage\n */\nfunction getThirdPartyBaggage(baggage) {\n  return baggage[1];\n}\n\n/**\n * Checks if baggage is mutable\n * @param baggage\n * @returns true if baggage is mutable, else false\n */\nfunction isBaggageMutable(baggage) {\n  return baggage[2];\n}\n\n/**\n * Sets the passed baggage immutable\n * @param baggage\n */\nfunction setBaggageImmutable(baggage) {\n  baggage[2] = false;\n}\n\n/** Serialize a baggage object */\nfunction serializeBaggage(baggage) {\n  return Object.keys(baggage[0]).reduce((prev, key) => {\n    var val = baggage[0][key] ;\n    var baggageEntry = `${SENTRY_BAGGAGE_KEY_PREFIX}${encodeURIComponent(key)}=${encodeURIComponent(val)}`;\n    var newVal = prev === '' ? baggageEntry : `${prev},${baggageEntry}`;\n    if (newVal.length > MAX_BAGGAGE_STRING_LENGTH) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn(`Not adding key: ${key} with val: ${val} to baggage due to exceeding baggage size limits.`);\n      return prev;\n    } else {\n      return newVal;\n    }\n  }, baggage[1]);\n}\n\n/**\n * Parse a baggage header from a string or a string array and return a Baggage object\n *\n * If @param includeThirdPartyEntries is set to true, third party baggage entries are added to the Baggage object\n * (This is necessary for merging potentially pre-existing baggage headers in outgoing requests with\n * our `sentry-` values)\n */\nfunction parseBaggageHeader(\n  inputBaggageValue,\n  includeThirdPartyEntries = false,\n) {\n  // Adding this check here because we got reports of this function failing due to the input value\n  // not being a string. This debug log might help us determine what's going on here.\n  if ((!Array.isArray(inputBaggageValue) && !isString(inputBaggageValue)) || typeof inputBaggageValue === 'number') {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        '[parseBaggageHeader] Received input value of incompatible type: ',\n        typeof inputBaggageValue,\n        inputBaggageValue,\n      );\n\n    // Gonna early-return an empty baggage object so that we don't fail later on\n    return createBaggage({}, '');\n  }\n\n  var baggageEntries = (isString(inputBaggageValue) ? inputBaggageValue : inputBaggageValue.join(','))\n    .split(',')\n    .map(entry => entry.trim())\n    .filter(entry => entry !== '' && (includeThirdPartyEntries || SENTRY_BAGGAGE_KEY_PREFIX_REGEX.test(entry)));\n\n  return baggageEntries.reduce(\n    ([baggageObj, baggageString], curr) => {\n      const [key, val] = curr.split('=');\n      if (SENTRY_BAGGAGE_KEY_PREFIX_REGEX.test(key)) {\n        var baggageKey = decodeURIComponent(key.split('-')[1]);\n        return [\n          {\n            ...baggageObj,\n            [baggageKey]: decodeURIComponent(val),\n          },\n          baggageString,\n          true,\n        ];\n      } else {\n        return [baggageObj, baggageString === '' ? curr : `${baggageString},${curr}`, true];\n      }\n    },\n    [{}, '', true],\n  );\n}\n\n/**\n * Merges the baggage header we saved from the incoming request (or meta tag) with\n * a possibly created or modified baggage header by a third party that's been added\n * to the outgoing request header.\n *\n * In case @param headerBaggageString exists, we can safely add the the 3rd party part of @param headerBaggage\n * with our @param incomingBaggage. This is possible because if we modified anything beforehand,\n * it would only affect parts of the sentry baggage (@see Baggage interface).\n *\n * @param incomingBaggage the baggage header of the incoming request that might contain sentry entries\n * @param thirdPartyBaggageHeader possibly existing baggage header string or string[] added from a third\n *        party to the request headers\n *\n * @return a merged and serialized baggage string to be propagated with the outgoing request\n */\nfunction mergeAndSerializeBaggage(incomingBaggage, thirdPartyBaggageHeader) {\n  if (!incomingBaggage && !thirdPartyBaggageHeader) {\n    return '';\n  }\n\n  var headerBaggage = (thirdPartyBaggageHeader && parseBaggageHeader(thirdPartyBaggageHeader, true)) || undefined;\n  var thirdPartyHeaderBaggage = headerBaggage && getThirdPartyBaggage(headerBaggage);\n\n  var finalBaggage = createBaggage((incomingBaggage && incomingBaggage[0]) || {}, thirdPartyHeaderBaggage || '');\n  return serializeBaggage(finalBaggage);\n}\n\n/**\n * Helper function that takes a raw baggage string (if available) and the processed sentry-trace header\n * data (if available), parses the baggage string and creates a Baggage object\n * If there is no baggage string, it will create an empty Baggage object.\n * In a second step, this functions determines if the created Baggage object should be set immutable\n * to prevent mutation of the Sentry data.\n *\n * Extracted this logic to a function because it's duplicated in a lot of places.\n *\n * @param rawBaggageValue\n * @param sentryTraceHeader\n */\nfunction parseBaggageSetMutability(\n  rawBaggageValue,\n  sentryTraceHeader,\n) {\n  var baggage = parseBaggageHeader(rawBaggageValue || '');\n\n  // Because we are always creating a Baggage object by calling `parseBaggageHeader` above\n  // (either a filled one or an empty one, even if we didn't get a `baggage` header),\n  // we only need to check if we have a sentry-trace header or not. As soon as we have it,\n  // we set baggage immutable. In case we don't get a sentry-trace header, we can assume that\n  // this SDK is the head of the trace and thus we still permit mutation at this time.\n  // There is one exception though, which is that we get a baggage-header with `sentry-`\n  // items but NO sentry-trace header. In this case we also set the baggage immutable for now\n  // but if smoething like this would ever happen, we should revisit this and determine\n  // what this would actually mean for the trace (i.e. is this SDK the head?, what happened\n  // before that we don't have a sentry-trace header?, etc)\n  (sentryTraceHeader || !isSentryBaggageEmpty(baggage)) && setBaggageImmutable(baggage);\n\n  return baggage;\n}\n\nexport { BAGGAGE_HEADER_NAME, MAX_BAGGAGE_STRING_LENGTH, SENTRY_BAGGAGE_KEY_PREFIX, SENTRY_BAGGAGE_KEY_PREFIX_REGEX, createBaggage, getBaggageValue, getSentryBaggageItems, getThirdPartyBaggage, isBaggageMutable, isSentryBaggageEmpty, mergeAndSerializeBaggage, parseBaggageHeader, parseBaggageSetMutability, serializeBaggage, setBaggageImmutable, setBaggageValue };\n//# sourceMappingURL=baggage.js.map\n","import { getGlobalObject } from './global.js';\nimport { dynamicRequire, isNodeEnv } from './node.js';\n\n/**\n * An object that can return the current timestamp in seconds since the UNIX epoch.\n */\n\n/**\n * A TimestampSource implementation for environments that do not support the Performance Web API natively.\n *\n * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier\n * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It\n * is more obvious to explain \"why does my span have negative duration\" than \"why my spans have zero duration\".\n */\nvar dateTimestampSource = {\n  nowSeconds: () => Date.now() / 1000,\n};\n\n/**\n * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}\n * for accessing a high-resolution monotonic clock.\n */\n\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction getBrowserPerformance() {\n  const { performance } = getGlobalObject();\n  if (!performance || !performance.now) {\n    return undefined;\n  }\n\n  // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n  //\n  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n  // performance.now() gives a date arbitrarily in the past.\n  //\n  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n  // undefined.\n  //\n  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n  // interact with data coming out of performance entries.\n  //\n  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n  // observed skews that can be as long as days, weeks or months.\n  //\n  // See https://github.com/getsentry/sentry-javascript/issues/2590.\n  //\n  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n  // transactions of long-lived web pages.\n  var timeOrigin = Date.now() - performance.now();\n\n  return {\n    now: () => performance.now(),\n    timeOrigin,\n  };\n}\n\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\nfunction getNodePerformance() {\n  try {\n    var perfHooks = dynamicRequire(module, 'perf_hooks') ;\n    return perfHooks.performance;\n  } catch (_) {\n    return undefined;\n  }\n}\n\n/**\n * The Performance API implementation for the current platform, if available.\n */\nvar platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\n\nvar timestampSource =\n  platformPerformance === undefined\n    ? dateTimestampSource\n    : {\n        nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,\n      };\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nvar dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * See `usingPerformanceAPI` to test whether the Performance API is used.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nvar timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);\n\n// Re-exported with an old name for backwards-compatibility.\nvar timestampWithMs = timestampInSeconds;\n\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nvar usingPerformanceAPI = platformPerformance !== undefined;\n\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n */\nlet _browserPerformanceTimeOriginMode;\n\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nvar browserPerformanceTimeOrigin = (() => {\n  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or\n  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin\n  // data as reliable if they are within a reasonable threshold of the current time.\n\n  const { performance } = getGlobalObject();\n  if (!performance || !performance.now) {\n    _browserPerformanceTimeOriginMode = 'none';\n    return undefined;\n  }\n\n  var threshold = 3600 * 1000;\n  var performanceNow = performance.now();\n  var dateNow = Date.now();\n\n  // if timeOrigin isn't available set delta to threshold so it isn't used\n  var timeOriginDelta = performance.timeOrigin\n    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)\n    : threshold;\n  var timeOriginIsReliable = timeOriginDelta < threshold;\n\n  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n  // Date API.\n    var navigationStart = performance.timing && performance.timing.navigationStart;\n  var hasNavigationStart = typeof navigationStart === 'number';\n  // if navigationStart isn't available set delta to threshold so it isn't used\n  var navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n  var navigationStartIsReliable = navigationStartDelta < threshold;\n\n  if (timeOriginIsReliable || navigationStartIsReliable) {\n    // Use the more reliable time origin\n    if (timeOriginDelta <= navigationStartDelta) {\n      _browserPerformanceTimeOriginMode = 'timeOrigin';\n      return performance.timeOrigin;\n    } else {\n      _browserPerformanceTimeOriginMode = 'navigationStart';\n      return navigationStart;\n    }\n  }\n\n  // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n  _browserPerformanceTimeOriginMode = 'dateNow';\n  return dateNow;\n})();\n\nexport { _browserPerformanceTimeOriginMode, browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds, timestampWithMs, usingPerformanceAPI };\n//# sourceMappingURL=time.js.map\n","import { uuid4, dateTimestampInSeconds, consoleSandbox, logger, getGlobalObject, getGlobalSingleton, isNodeEnv } from '@sentry/utils';\nimport { Scope } from './scope.js';\nimport { closeSession, makeSession, updateSession } from './session.js';\n\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nvar API_VERSION = 4;\n\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nvar DEFAULT_BREADCRUMBS = 100;\n\n/**\n * A layer in the process stack.\n * @hidden\n */\n\n/**\n * @inheritDoc\n */\nclass Hub  {\n  /** Is a {@link Layer}[] containing the client and scope */\n    __init() {this._stack = [{}];}\n\n  /** Contains the last event id of a captured event.  */\n  \n\n  /**\n   * Creates a new instance of the hub, will push one {@link Layer} into the\n   * internal stack on creation.\n   *\n   * @param client bound to the hub.\n   * @param scope bound to the hub.\n   * @param version number, higher number means higher priority.\n   */\n   constructor(client, scope = new Scope(),   _version = API_VERSION) {;this._version = _version;Hub.prototype.__init.call(this);\n    this.getStackTop().scope = scope;\n    if (client) {\n      this.bindClient(client);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   isOlderThan(version) {\n    return this._version < version;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   bindClient(client) {\n    var top = this.getStackTop();\n    top.client = client;\n    if (client && client.setupIntegrations) {\n      client.setupIntegrations();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   pushScope() {\n    // We want to clone the content of prev scope\n    var scope = Scope.clone(this.getScope());\n    this.getStack().push({\n      client: this.getClient(),\n      scope,\n    });\n    return scope;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   popScope() {\n    if (this.getStack().length <= 1) return false;\n    return !!this.getStack().pop();\n  }\n\n  /**\n   * @inheritDoc\n   */\n   withScope(callback) {\n    var scope = this.pushScope();\n    try {\n      callback(scope);\n    } finally {\n      this.popScope();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getClient() {\n    return this.getStackTop().client ;\n  }\n\n  /** Returns the scope of the top stack. */\n   getScope() {\n    return this.getStackTop().scope;\n  }\n\n  /** Returns the scope stack for domains or the process. */\n   getStack() {\n    return this._stack;\n  }\n\n  /** Returns the topmost scope layer in the order domain > local > process. */\n   getStackTop() {\n    return this._stack[this._stack.length - 1];\n  }\n\n  /**\n   * @inheritDoc\n   */\n     captureException(exception, hint) {\n    var eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    var syntheticException = new Error('Sentry syntheticException');\n    this._withClient((client, scope) => {\n      client.captureException(\n        exception,\n        {\n          originalException: exception,\n          syntheticException,\n          ...hint,\n          event_id: eventId,\n        },\n        scope,\n      );\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureMessage(\n    message,\n        level,\n    hint,\n  ) {\n    var eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    var syntheticException = new Error(message);\n    this._withClient((client, scope) => {\n      client.captureMessage(\n        message,\n        level,\n        {\n          originalException: message,\n          syntheticException,\n          ...hint,\n          event_id: eventId,\n        },\n        scope,\n      );\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureEvent(event, hint) {\n    var eventId = hint && hint.event_id ? hint.event_id : uuid4();\n    if (event.type !== 'transaction') {\n      this._lastEventId = eventId;\n    }\n\n    this._withClient((client, scope) => {\n      client.captureEvent(event, { ...hint, event_id: eventId }, scope);\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   lastEventId() {\n    return this._lastEventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addBreadcrumb(breadcrumb, hint) {\n    const { scope, client } = this.getStackTop();\n\n    if (!scope || !client) return;\n\n        const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =\n      (client.getOptions && client.getOptions()) || {};\n\n    if (maxBreadcrumbs <= 0) return;\n\n    var timestamp = dateTimestampInSeconds();\n    var mergedBreadcrumb = { timestamp, ...breadcrumb };\n    var finalBreadcrumb = beforeBreadcrumb\n      ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) )\n      : mergedBreadcrumb;\n\n    if (finalBreadcrumb === null) return;\n\n    scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setUser(user) {\n    var scope = this.getScope();\n    if (scope) scope.setUser(user);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTags(tags) {\n    var scope = this.getScope();\n    if (scope) scope.setTags(tags);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtras(extras) {\n    var scope = this.getScope();\n    if (scope) scope.setExtras(extras);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTag(key, value) {\n    var scope = this.getScope();\n    if (scope) scope.setTag(key, value);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtra(key, extra) {\n    var scope = this.getScope();\n    if (scope) scope.setExtra(key, extra);\n  }\n\n  /**\n   * @inheritDoc\n   */\n     setContext(name, context) {\n    var scope = this.getScope();\n    if (scope) scope.setContext(name, context);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   configureScope(callback) {\n    const { scope, client } = this.getStackTop();\n    if (scope && client) {\n      callback(scope);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   run(callback) {\n    var oldHub = makeMain(this);\n    try {\n      callback(this);\n    } finally {\n      makeMain(oldHub);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getIntegration(integration) {\n    var client = this.getClient();\n    if (!client) return null;\n    try {\n      return client.getIntegration(integration);\n    } catch (_oO) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   startTransaction(context, customSamplingContext) {\n    return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   traceHeaders() {\n    return this._callExtensionMethod('traceHeaders');\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureSession(endSession = false) {\n    // both send the update and pull the session from the scope\n    if (endSession) {\n      return this.endSession();\n    }\n\n    // only send the update\n    this._sendSessionUpdate();\n  }\n\n  /**\n   * @inheritDoc\n   */\n   endSession() {\n    var layer = this.getStackTop();\n    var scope = layer && layer.scope;\n    var session = scope && scope.getSession();\n    if (session) {\n      closeSession(session);\n    }\n    this._sendSessionUpdate();\n\n    // the session is over; take it off of the scope\n    if (scope) {\n      scope.setSession();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   startSession(context) {\n    const { scope, client } = this.getStackTop();\n    const { release, environment } = (client && client.getOptions()) || {};\n\n    // Will fetch userAgent if called from browser sdk\n    var global = getGlobalObject();\n    const { userAgent } = global.navigator || {};\n\n    var session = makeSession({\n      release,\n      environment,\n      ...(scope && { user: scope.getUser() }),\n      ...(userAgent && { userAgent }),\n      ...context,\n    });\n\n    if (scope) {\n      // End existing session if there's one\n      var currentSession = scope.getSession && scope.getSession();\n      if (currentSession && currentSession.status === 'ok') {\n        updateSession(currentSession, { status: 'exited' });\n      }\n      this.endSession();\n\n      // Afterwards we set the new session on the scope\n      scope.setSession(session);\n    }\n\n    return session;\n  }\n\n  /**\n   * Returns if default PII should be sent to Sentry and propagated in ourgoing requests\n   * when Tracing is used.\n   */\n   shouldSendDefaultPii() {\n    var client = this.getClient();\n    var options = client && client.getOptions();\n    return Boolean(options && options.sendDefaultPii);\n  }\n\n  /**\n   * Sends the current Session on the scope\n   */\n   _sendSessionUpdate() {\n    const { scope, client } = this.getStackTop();\n    if (!scope) return;\n\n    var session = scope.getSession();\n    if (session) {\n      if (client && client.captureSession) {\n        client.captureSession(session);\n      }\n    }\n  }\n\n  /**\n   * Internal helper function to call a method on the top client if it exists.\n   *\n   * @param method The method to call on the client.\n   * @param args Arguments to pass to the client function.\n   */\n   _withClient(callback) {\n    const { scope, client } = this.getStackTop();\n    if (client) {\n      callback(client, scope);\n    }\n  }\n\n  /**\n   * Calls global extension method and binding current instance to the function call\n   */\n  // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n     _callExtensionMethod(method, ...args) {\n    var carrier = getMainCarrier();\n    var sentry = carrier.__SENTRY__;\n    if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n      return sentry.extensions[method].apply(this, args);\n    }\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);\n  }\n}\n\n/**\n * Returns the global shim registry.\n *\n * FIXME: This function is problematic, because despite always returning a valid Carrier,\n * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check\n * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.\n **/\nfunction getMainCarrier() {\n  var carrier = getGlobalObject();\n  carrier.__SENTRY__ = carrier.__SENTRY__ || {\n    extensions: {},\n    hub: undefined,\n  };\n  return carrier;\n}\n\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nfunction makeMain(hub) {\n  var registry = getMainCarrier();\n  var oldHub = getHubFromCarrier(registry);\n  setHubOnCarrier(registry, hub);\n  return oldHub;\n}\n\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nfunction getCurrentHub() {\n  // Get main carrier (global for every environment)\n  var registry = getMainCarrier();\n\n  // If there's no hub, or its an old API, assign a new one\n  if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n    setHubOnCarrier(registry, new Hub());\n  }\n\n  // Prefer domains over global if they are there (applicable only to Node environment)\n  if (isNodeEnv()) {\n    return getHubFromActiveDomain(registry);\n  }\n  // Return hub that lives on a global object\n  return getHubFromCarrier(registry);\n}\n\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n  try {\n    var sentry = getMainCarrier().__SENTRY__;\n    var activeDomain = sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n\n    // If there's no active domain, just return global hub\n    if (!activeDomain) {\n      return getHubFromCarrier(registry);\n    }\n\n    // If there's no hub on current domain, or it's an old API, assign a new one\n    if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n      var registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n      setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n    }\n\n    // Return hub that lives on a domain\n    return getHubFromCarrier(activeDomain);\n  } catch (_Oo) {\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n  }\n}\n\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier) {\n  return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nfunction getHubFromCarrier(carrier) {\n  return getGlobalSingleton('hub', () => new Hub(), carrier);\n}\n\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n * @returns A boolean indicating success or failure\n */\nfunction setHubOnCarrier(carrier, hub) {\n  if (!carrier) return false;\n  var __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});\n  __SENTRY__.hub = hub;\n  return true;\n}\n\nexport { API_VERSION, Hub, getCurrentHub, getHubFromCarrier, getMainCarrier, makeMain, setHubOnCarrier };\n//# sourceMappingURL=hub.js.map\n","import { dropUndefinedKeys } from './object.js';\n\n/**\n * Creates an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction createEnvelope(headers, items = []) {\n  return [headers, items] ;\n}\n\n/**\n * Add an item to an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction addItemToEnvelope(envelope, newItem) {\n  const [headers, items] = envelope;\n  return [headers, [...items, newItem]] ;\n}\n\n/**\n * Convenience function to loop through the items and item types of an envelope.\n * (This function was mostly created because working with envelope types is painful at the moment)\n */\nfunction forEachEnvelopeItem(\n  envelope,\n  callback,\n) {\n  var envelopeItems = envelope[1];\n  envelopeItems.forEach((envelopeItem) => {\n    var envelopeItemType = envelopeItem[0].type;\n    callback(envelopeItem, envelopeItemType);\n  });\n}\n\nfunction encodeUTF8(input, textEncoder) {\n  var utf8 = textEncoder || new TextEncoder();\n  return utf8.encode(input);\n}\n\n/**\n * Serializes an envelope.\n */\nfunction serializeEnvelope(envelope, textEncoder) {\n  const [envHeaders, items] = envelope;\n\n  // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data\n  let parts = JSON.stringify(envHeaders);\n\n  function append(next) {\n    if (typeof parts === 'string') {\n      parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts, textEncoder), next];\n    } else {\n      parts.push(typeof next === 'string' ? encodeUTF8(next, textEncoder) : next);\n    }\n  }\n\n  for (var item of items) {\n    const [itemHeaders, payload] = item ;\n    append(`\\n${JSON.stringify(itemHeaders)}\\n`);\n    append(typeof payload === 'string' || payload instanceof Uint8Array ? payload : JSON.stringify(payload));\n  }\n\n  return typeof parts === 'string' ? parts : concatBuffers(parts);\n}\n\nfunction concatBuffers(buffers) {\n  var totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);\n\n  var merged = new Uint8Array(totalLength);\n  let offset = 0;\n  for (var buffer of buffers) {\n    merged.set(buffer, offset);\n    offset += buffer.length;\n  }\n\n  return merged;\n}\n\n/**\n * Creates attachment envelope items\n */\nfunction createAttachmentEnvelopeItem(\n  attachment,\n  textEncoder,\n) {\n  var buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data, textEncoder) : attachment.data;\n\n  return [\n    dropUndefinedKeys({\n      type: 'attachment',\n      length: buffer.length,\n      filename: attachment.filename,\n      content_type: attachment.contentType,\n      attachment_type: attachment.attachmentType,\n    }),\n    buffer,\n  ];\n}\n\nvar ITEM_TYPE_TO_DATA_CATEGORY_MAP = {\n  session: 'session',\n  sessions: 'session',\n  attachment: 'attachment',\n  transaction: 'transaction',\n  event: 'error',\n  client_report: 'internal',\n  user_report: 'default',\n};\n\n/**\n * Maps the type of an envelope item to a data category.\n */\nfunction envelopeItemTypeToDataCategory(type) {\n  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];\n}\n\nexport { addItemToEnvelope, createAttachmentEnvelopeItem, createEnvelope, envelopeItemTypeToDataCategory, forEachEnvelopeItem, serializeEnvelope };\n//# sourceMappingURL=envelope.js.map\n","import { _optionalChain } from './buildPolyfills';\n\nvar STACKTRACE_LIMIT = 50;\n\n/**\n * Creates a stack parser with the supplied line parsers\n *\n * StackFrames are returned in the correct order for Sentry Exception\n * frames and with Sentry SDK internal frames removed from the top and bottom\n *\n */\nfunction createStackParser(...parsers) {\n  var sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);\n\n  return (stack, skipFirst = 0) => {\n    var frames = [];\n\n    for (var line of stack.split('\\n').slice(skipFirst)) {\n      for (var parser of sortedParsers) {\n        var frame = parser(line);\n\n        if (frame) {\n          frames.push(frame);\n          break;\n        }\n      }\n    }\n\n    return stripSentryFramesAndReverse(frames);\n  };\n}\n\n/**\n * Gets a stack parser implementation from Options.stackParser\n * @see Options\n *\n * If options contains an array of line parsers, it is converted into a parser\n */\nfunction stackParserFromStackParserOptions(stackParser) {\n  if (Array.isArray(stackParser)) {\n    return createStackParser(...stackParser);\n  }\n  return stackParser;\n}\n\n/**\n * @hidden\n */\nfunction stripSentryFramesAndReverse(stack) {\n  if (!stack.length) {\n    return [];\n  }\n\n  let localStack = stack;\n\n  var firstFrameFunction = localStack[0].function || '';\n  var lastFrameFunction = localStack[localStack.length - 1].function || '';\n\n  // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n  if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {\n    localStack = localStack.slice(1);\n  }\n\n  // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n  if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {\n    localStack = localStack.slice(0, -1);\n  }\n\n  // The frame where the crash happened, should be the last entry in the array\n  return localStack\n    .slice(0, STACKTRACE_LIMIT)\n    .map(frame => ({\n      ...frame,\n      filename: frame.filename || localStack[0].filename,\n      function: frame.function || '?',\n    }))\n    .reverse();\n}\n\nvar defaultFunctionName = '<anonymous>';\n\n/**\n * Safely extract function name from itself\n */\nfunction getFunctionName(fn) {\n  try {\n    if (!fn || typeof fn !== 'function') {\n      return defaultFunctionName;\n    }\n    return fn.name || defaultFunctionName;\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    return defaultFunctionName;\n  }\n}\n\nfunction node(getModule) {\n  var FILENAME_MATCH = /^\\s*[-]{4,}$/;\n  var FULL_MATCH = /at (?:async )?(?:(.+?)\\s+\\()?(?:(.+?):(\\d+)(?::(\\d+))?|([^)]+))\\)?/;\n\n    return (line) => {\n    if (line.match(FILENAME_MATCH)) {\n      return {\n        filename: line,\n      };\n    }\n\n    var lineMatch = line.match(FULL_MATCH);\n    if (!lineMatch) {\n      return undefined;\n    }\n\n    let object;\n    let method;\n    let functionName;\n    let typeName;\n    let methodName;\n\n    if (lineMatch[1]) {\n      functionName = lineMatch[1];\n\n      let methodStart = functionName.lastIndexOf('.');\n      if (functionName[methodStart - 1] === '.') {\n                methodStart--;\n      }\n\n      if (methodStart > 0) {\n        object = functionName.substr(0, methodStart);\n        method = functionName.substr(methodStart + 1);\n        var objectEnd = object.indexOf('.Module');\n        if (objectEnd > 0) {\n          functionName = functionName.substr(objectEnd + 1);\n          object = object.substr(0, objectEnd);\n        }\n      }\n      typeName = undefined;\n    }\n\n    if (method) {\n      typeName = object;\n      methodName = method;\n    }\n\n    if (method === '<anonymous>') {\n      methodName = undefined;\n      functionName = undefined;\n    }\n\n    if (functionName === undefined) {\n      methodName = methodName || '<anonymous>';\n      functionName = typeName ? `${typeName}.${methodName}` : methodName;\n    }\n\n    var filename = _optionalChain([lineMatch, 'access', _ => _[2], 'optionalAccess', _2 => _2.startsWith, 'call', _3 => _3('file://')]) ? lineMatch[2].substr(7) : lineMatch[2];\n    var isNative = lineMatch[5] === 'native';\n    var isInternal =\n      isNative || (filename && !filename.startsWith('/') && !filename.startsWith('.') && filename.indexOf(':\\\\') !== 1);\n\n    // in_app is all that's not an internal Node function or a module within node_modules\n    // note that isNative appears to return true even for node core libraries\n    // see https://github.com/getsentry/raven-node/issues/176\n    var in_app = !isInternal && filename !== undefined && !filename.includes('node_modules/');\n\n    return {\n      filename,\n      module: _optionalChain([getModule, 'optionalCall', _4 => _4(filename)]),\n      function: functionName,\n      lineno: parseInt(lineMatch[3], 10) || undefined,\n      colno: parseInt(lineMatch[4], 10) || undefined,\n      in_app,\n    };\n  };\n}\n\n/**\n * Node.js stack line parser\n *\n * This is in @sentry/utils so it can be used from the Electron SDK in the browser for when `nodeIntegration == true`.\n * This allows it to be used without referencing or importing any node specific code which causes bundlers to complain\n */\nfunction nodeStackLineParser(getModule) {\n  return [90, node(getModule)];\n}\n\nexport { createStackParser, getFunctionName, nodeStackLineParser, stackParserFromStackParserOptions, stripSentryFramesAndReverse };\n//# sourceMappingURL=stacktrace.js.map\n","import { getGlobalObject } from './global.js';\nimport { isString } from './is.js';\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction htmlTreeAsString(elem, keyAttrs) {\n  \n\n  // try/catch both:\n  // - accessing event.target (see getsentry/raven-js#838, #768)\n  // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n  // - can throw an exception in some circumstances.\n  try {\n    let currentElem = elem ;\n    var MAX_TRAVERSE_HEIGHT = 5;\n    var MAX_OUTPUT_LEN = 80;\n    var out = [];\n    let height = 0;\n    let len = 0;\n    var separator = ' > ';\n    var sepLength = separator.length;\n    let nextStr;\n\n        while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n      nextStr = _htmlElementAsString(currentElem, keyAttrs);\n      // bail out if\n      // - nextStr is the 'html' element\n      // - the length of the string that would be created exceeds MAX_OUTPUT_LEN\n      //   (ignore this limit if we are on the first iteration)\n      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {\n        break;\n      }\n\n      out.push(nextStr);\n\n      len += nextStr.length;\n      currentElem = currentElem.parentNode;\n    }\n\n    return out.reverse().join(separator);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el, keyAttrs) {\n  var elem = el \n\n;\n\n  var out = [];\n  let className;\n  let classes;\n  let key;\n  let attr;\n  let i;\n\n  if (!elem || !elem.tagName) {\n    return '';\n  }\n\n  out.push(elem.tagName.toLowerCase());\n\n  // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n  var keyAttrPairs =\n    keyAttrs && keyAttrs.length\n      ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])\n      : null;\n\n  if (keyAttrPairs && keyAttrPairs.length) {\n    keyAttrPairs.forEach(keyAttrPair => {\n      out.push(`[${keyAttrPair[0]}=\"${keyAttrPair[1]}\"]`);\n    });\n  } else {\n    if (elem.id) {\n      out.push(`#${elem.id}`);\n    }\n\n        className = elem.className;\n    if (className && isString(className)) {\n      classes = className.split(/\\s+/);\n      for (i = 0; i < classes.length; i++) {\n        out.push(`.${classes[i]}`);\n      }\n    }\n  }\n  var allowedAttrs = ['type', 'name', 'title', 'alt'];\n  for (i = 0; i < allowedAttrs.length; i++) {\n    key = allowedAttrs[i];\n    attr = elem.getAttribute(key);\n    if (attr) {\n      out.push(`[${key}=\"${attr}\"]`);\n    }\n  }\n  return out.join('');\n}\n\n/**\n * A safe form of location.href\n */\nfunction getLocationHref() {\n  var global = getGlobalObject();\n  try {\n    return global.document.location.href;\n  } catch (oO) {\n    return '';\n  }\n}\n\nexport { getLocationHref, htmlTreeAsString };\n//# sourceMappingURL=browser.js.map\n","/**\n * Helper to decycle json objects\n */\nfunction memoBuilder() {\n  var hasWeakSet = typeof WeakSet === 'function';\n  var inner = hasWeakSet ? new WeakSet() : [];\n  function memoize(obj) {\n    if (hasWeakSet) {\n      if (inner.has(obj)) {\n        return true;\n      }\n      inner.add(obj);\n      return false;\n    }\n        for (let i = 0; i < inner.length; i++) {\n      var value = inner[i];\n      if (value === obj) {\n        return true;\n      }\n    }\n    inner.push(obj);\n    return false;\n  }\n\n  function unmemoize(obj) {\n    if (hasWeakSet) {\n      inner.delete(obj);\n    } else {\n      for (let i = 0; i < inner.length; i++) {\n        if (inner[i] === obj) {\n          inner.splice(i, 1);\n          break;\n        }\n      }\n    }\n  }\n  return [memoize, unmemoize];\n}\n\nexport { memoBuilder };\n//# sourceMappingURL=memo.js.map\n","import { getCurrentHub } from './hub.js';\n\n// Note: All functions in this file are typed with a return value of `ReturnType<Hub[HUB_FUNCTION]>`,\n// where HUB_FUNCTION is some method on the Hub class.\n//\n// This is done to make sure the top level SDK methods stay in sync with the hub methods.\n// Although every method here has an explicit return type, some of them (that map to void returns) do not\n// contain `return` keywords. This is done to save on bundle size, as `return` is not minifiable.\n\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @param captureContext Additional scope data to apply to exception event.\n * @returns The generated eventId.\n */\nfunction captureException(exception, captureContext) {\n  return getCurrentHub().captureException(exception, { captureContext });\n}\n\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param Severity Define the level of the message.\n * @returns The generated eventId.\n */\nfunction captureMessage(\n  message,\n    captureContext,\n) {\n  // This is necessary to provide explicit scopes upgrade, without changing the original\n  // arity of the `captureMessage(message, level)` method.\n  var level = typeof captureContext === 'string' ? captureContext : undefined;\n  var context = typeof captureContext !== 'string' ? { captureContext } : undefined;\n  return getCurrentHub().captureMessage(message, level, context);\n}\n\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nfunction captureEvent(event, hint) {\n  return getCurrentHub().captureEvent(event, hint);\n}\n\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nfunction configureScope(callback) {\n  getCurrentHub().configureScope(callback);\n}\n\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nfunction addBreadcrumb(breadcrumb) {\n  getCurrentHub().addBreadcrumb(breadcrumb);\n}\n\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\nfunction setContext(name, context) {\n  getCurrentHub().setContext(name, context);\n}\n\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nfunction setExtras(extras) {\n  getCurrentHub().setExtras(extras);\n}\n\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nfunction setExtra(key, extra) {\n  getCurrentHub().setExtra(key, extra);\n}\n\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nfunction setTags(tags) {\n  getCurrentHub().setTags(tags);\n}\n\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nfunction setTag(key, value) {\n  getCurrentHub().setTag(key, value);\n}\n\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nfunction setUser(user) {\n  getCurrentHub().setUser(user);\n}\n\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nfunction withScope(callback) {\n  getCurrentHub().withScope(callback);\n}\n\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * NOTE: This function should only be used for *manual* instrumentation. Auto-instrumentation should call\n * `startTransaction` directly on the hub.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n */\nfunction startTransaction(\n  context,\n  customSamplingContext,\n) {\n  return getCurrentHub().startTransaction(\n    {\n      metadata: { source: 'custom' },\n      ...context,\n    },\n    customSamplingContext,\n  );\n}\n\nexport { addBreadcrumb, captureEvent, captureException, captureMessage, configureScope, setContext, setExtra, setExtras, setTag, setTags, setUser, startTransaction, withScope };\n//# sourceMappingURL=exports.js.map\n","import { timestampInSeconds, uuid4, dropUndefinedKeys } from '@sentry/utils';\n\n/**\n * Creates a new `Session` object by setting certain default parameters. If optional @param context\n * is passed, the passed properties are applied to the session object.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns a new `Session` object\n */\nfunction makeSession(context) {\n  // Both timestamp and started are in seconds since the UNIX epoch.\n  var startingTime = timestampInSeconds();\n\n  var session = {\n    sid: uuid4(),\n    init: true,\n    timestamp: startingTime,\n    started: startingTime,\n    duration: 0,\n    status: 'ok',\n    errors: 0,\n    ignoreDuration: false,\n    toJSON: () => sessionToJSON(session),\n  };\n\n  if (context) {\n    updateSession(session, context);\n  }\n\n  return session;\n}\n\n/**\n * Updates a session object with the properties passed in the context.\n *\n * Note that this function mutates the passed object and returns void.\n * (Had to do this instead of returning a new and updated session because closing and sending a session\n * makes an update to the session after it was passed to the sending logic.\n * @see BaseClient.captureSession )\n *\n * @param session the `Session` to update\n * @param context the `SessionContext` holding the properties that should be updated in @param session\n */\nfunction updateSession(session, context = {}) {\n  if (context.user) {\n    if (!session.ipAddress && context.user.ip_address) {\n      session.ipAddress = context.user.ip_address;\n    }\n\n    if (!session.did && !context.did) {\n      session.did = context.user.id || context.user.email || context.user.username;\n    }\n  }\n\n  session.timestamp = context.timestamp || timestampInSeconds();\n\n  if (context.ignoreDuration) {\n    session.ignoreDuration = context.ignoreDuration;\n  }\n  if (context.sid) {\n    // Good enough uuid validation. — Kamil\n    session.sid = context.sid.length === 32 ? context.sid : uuid4();\n  }\n  if (context.init !== undefined) {\n    session.init = context.init;\n  }\n  if (!session.did && context.did) {\n    session.did = `${context.did}`;\n  }\n  if (typeof context.started === 'number') {\n    session.started = context.started;\n  }\n  if (session.ignoreDuration) {\n    session.duration = undefined;\n  } else if (typeof context.duration === 'number') {\n    session.duration = context.duration;\n  } else {\n    var duration = session.timestamp - session.started;\n    session.duration = duration >= 0 ? duration : 0;\n  }\n  if (context.release) {\n    session.release = context.release;\n  }\n  if (context.environment) {\n    session.environment = context.environment;\n  }\n  if (!session.ipAddress && context.ipAddress) {\n    session.ipAddress = context.ipAddress;\n  }\n  if (!session.userAgent && context.userAgent) {\n    session.userAgent = context.userAgent;\n  }\n  if (typeof context.errors === 'number') {\n    session.errors = context.errors;\n  }\n  if (context.status) {\n    session.status = context.status;\n  }\n}\n\n/**\n * Closes a session by setting its status and updating the session object with it.\n * Internally calls `updateSession` to update the passed session object.\n *\n * Note that this function mutates the passed session (@see updateSession for explanation).\n *\n * @param session the `Session` object to be closed\n * @param status the `SessionStatus` with which the session was closed. If you don't pass a status,\n *               this function will keep the previously set status, unless it was `'ok'` in which case\n *               it is changed to `'exited'`.\n */\nfunction closeSession(session, status) {\n  let context = {};\n  if (status) {\n    context = { status };\n  } else if (session.status === 'ok') {\n    context = { status: 'exited' };\n  }\n\n  updateSession(session, context);\n}\n\n/**\n * Serializes a passed session object to a JSON object with a slightly different structure.\n * This is necessary because the Sentry backend requires a slightly different schema of a session\n * than the one the JS SDKs use internally.\n *\n * @param session the session to be converted\n *\n * @returns a JSON object of the passed session\n */\nfunction sessionToJSON(session) {\n  return dropUndefinedKeys({\n    sid: `${session.sid}`,\n    init: session.init,\n    // Make sure that sec is converted to ms for date constructor\n    started: new Date(session.started * 1000).toISOString(),\n    timestamp: new Date(session.timestamp * 1000).toISOString(),\n    status: session.status,\n    errors: session.errors,\n    did: typeof session.did === 'number' || typeof session.did === 'string' ? `${session.did}` : undefined,\n    duration: session.duration,\n    attrs: {\n      release: session.release,\n      environment: session.environment,\n      ip_address: session.ipAddress,\n      user_agent: session.userAgent,\n    },\n  });\n}\n\nexport { closeSession, makeSession, updateSession };\n//# sourceMappingURL=session.js.map\n","// Note: Ideally the `SeverityLevel` type would be derived from `validSeverityLevels`, but that would mean either\n//\n// a) moving `validSeverityLevels` to `@sentry/types`,\n// b) moving the`SeverityLevel` type here, or\n// c) importing `validSeverityLevels` from here into `@sentry/types`.\n//\n// Option A would make `@sentry/types` a runtime dependency of `@sentry/utils` (not good), and options B and C would\n// create a circular dependency between `@sentry/types` and `@sentry/utils` (also not good). So a TODO accompanying the\n// type, reminding anyone who changes it to change this list also, will have to do.\n\nvar validSeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];\n\n/**\n * Converts a string-based level into a member of the deprecated {@link Severity} enum.\n *\n * @deprecated `severityFromString` is deprecated. Please use `severityLevelFromString` instead.\n *\n * @param level String representation of Severity\n * @returns Severity\n */\nfunction severityFromString(level) {\n  return severityLevelFromString(level) ;\n}\n\n/**\n * Converts a string-based level into a `SeverityLevel`, normalizing it along the way.\n *\n * @param level String representation of desired `SeverityLevel`.\n * @returns The `SeverityLevel` corresponding to the given string, or 'log' if the string isn't a valid level.\n */\nfunction severityLevelFromString(level) {\n  return (level === 'warn' ? 'warning' : validSeverityLevels.includes(level) ? level : 'log') ;\n}\n\nexport { severityFromString, severityLevelFromString, validSeverityLevels };\n//# sourceMappingURL=severity.js.map\n","import { isNodeEnv } from './node.js';\n\n/** Internal */\n\nvar fallbackGlobalObject = {};\n\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nfunction getGlobalObject() {\n  return (\n    isNodeEnv()\n      ? global\n      : typeof window !== 'undefined'       ? window       : typeof self !== 'undefined'\n      ? self\n      : fallbackGlobalObject\n  ) ;\n}\n\n/**\n * Returns a global singleton contained in the global `__SENTRY__` object.\n *\n * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory\n * function and added to the `__SENTRY__` object.\n *\n * @param name name of the global singleton on __SENTRY__\n * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`\n * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `getGlobalObject`'s return value\n * @returns the singleton\n */\nfunction getGlobalSingleton(name, creator, obj) {\n  var global = (obj || getGlobalObject()) ;\n  var __SENTRY__ = (global.__SENTRY__ = global.__SENTRY__ || {});\n  var singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n  return singleton;\n}\n\nexport { getGlobalObject, getGlobalSingleton };\n//# sourceMappingURL=global.js.map\n","import { addInstrumentationHandler, logger } from '@sentry/utils';\nimport { getActiveTransaction } from './utils.js';\n\n/**\n * Configures global error listeners\n */\nfunction registerErrorInstrumentation() {\n  addInstrumentationHandler('error', errorCallback);\n  addInstrumentationHandler('unhandledrejection', errorCallback);\n}\n\n/**\n * If an error or unhandled promise occurs, we mark the active transaction as failed\n */\nfunction errorCallback() {\n  var activeTransaction = getActiveTransaction();\n  if (activeTransaction) {\n    var status = 'internal_error';\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Transaction: ${status} -> Global error occured`);\n    activeTransaction.setStatus(status);\n  }\n}\n\nexport { registerErrorInstrumentation };\n//# sourceMappingURL=errors.js.map\n","import { getGlobalObject } from './global.js';\nimport { logger } from './logger.js';\n\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsErrorEvent() {\n  try {\n    new ErrorEvent('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMError() {\n  try {\n    // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n    // 1 argument required, but only 0 present.\n    // @ts-ignore It really needs 1 argument, not 0.\n    new DOMError('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMException() {\n  try {\n    new DOMException('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsFetch() {\n  if (!('fetch' in getGlobalObject())) {\n    return false;\n  }\n\n  try {\n    new Headers();\n    new Request('');\n    new Response();\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\nfunction isNativeFetch(func) {\n  return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nfunction supportsNativeFetch() {\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  var global = getGlobalObject();\n\n  // Fast path to avoid DOM I/O\n    if (isNativeFetch(global.fetch)) {\n    return true;\n  }\n\n  // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n  // so create a \"pure\" iframe to see if that has native fetch\n  let result = false;\n  var doc = global.document;\n    if (doc && typeof (doc.createElement ) === 'function') {\n    try {\n      var sandbox = doc.createElement('iframe');\n      sandbox.hidden = true;\n      doc.head.appendChild(sandbox);\n      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n                result = isNativeFetch(sandbox.contentWindow.fetch);\n      }\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReportingObserver() {\n  return 'ReportingObserver' in getGlobalObject();\n}\n\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReferrerPolicy() {\n  // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'\n  // (see https://caniuse.com/#feat=referrer-policy),\n  // it doesn't. And it throws an exception instead of ignoring this parameter...\n  // REF: https://github.com/getsentry/raven-js/issues/1233\n\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  try {\n    new Request('_', {\n      referrerPolicy: 'origin' ,\n    });\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsHistory() {\n  // NOTE: in Chrome App environment, touching history.pushState, *even inside\n  //       a try/catch block*, will cause Chrome to output an error to console.error\n  // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n  var global = getGlobalObject();\n      var chrome = (global ).chrome;\n  var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n    var hasHistoryApi = 'history' in global && !!global.history.pushState && !!global.history.replaceState;\n\n  return !isChromePackagedApp && hasHistoryApi;\n}\n\nexport { isNativeFetch, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, supportsHistory, supportsNativeFetch, supportsReferrerPolicy, supportsReportingObserver };\n//# sourceMappingURL=supports.js.map\n","import { htmlTreeAsString } from './browser.js';\nimport { isError, isEvent, isInstanceOf, isElement, isPlainObject, isPrimitive } from './is.js';\nimport { truncate } from './string.js';\n\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * @param source An object that contains a method to be wrapped.\n * @param name The name of the method to be wrapped.\n * @param replacementFactory A higher-order function that takes the original version of the given method and returns a\n * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to\n * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other\n * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\nfunction fill(source, name, replacementFactory) {\n  if (!(name in source)) {\n    return;\n  }\n\n  var original = source[name] ;\n  var wrapped = replacementFactory(original) ;\n\n  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n  // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n  if (typeof wrapped === 'function') {\n    try {\n      markFunctionWrapped(wrapped, original);\n    } catch (_Oo) {\n      // This can throw if multiple fill happens on a global object like XMLHttpRequest\n      // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n    }\n  }\n\n  source[name] = wrapped;\n}\n\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nfunction addNonEnumerableProperty(obj, name, value) {\n  Object.defineProperty(obj, name, {\n    // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n    value: value,\n    writable: true,\n    configurable: true,\n  });\n}\n\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nfunction markFunctionWrapped(wrapped, original) {\n  var proto = original.prototype || {};\n  wrapped.prototype = original.prototype = proto;\n  addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n}\n\n/**\n * This extracts the original function if available.  See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\nfunction getOriginalFunction(func) {\n  return func.__sentry_original__;\n}\n\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nfunction urlEncode(object) {\n  return Object.keys(object)\n    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)\n    .join('&');\n}\n\n/**\n * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their\n * non-enumerable properties attached.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor\n *  an Error.\n */\nfunction convertToPlainObject(\n  value,\n)\n\n {\n  if (isError(value)) {\n    return {\n      message: value.message,\n      name: value.name,\n      stack: value.stack,\n      ...getOwnProperties(value),\n    };\n  } else if (isEvent(value)) {\n    var newObj\n\n = {\n      type: value.type,\n      target: serializeEventTarget(value.target),\n      currentTarget: serializeEventTarget(value.currentTarget),\n      ...getOwnProperties(value),\n    };\n\n    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n      newObj.detail = value.detail;\n    }\n\n    return newObj;\n  } else {\n    return value;\n  }\n}\n\n/** Creates a string representation of the target of an `Event` object */\nfunction serializeEventTarget(target) {\n  try {\n    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/** Filters out all but an object's own properties */\nfunction getOwnProperties(obj) {\n  if (typeof obj === 'object' && obj !== null) {\n    var extractedProps = {};\n    for (var property in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, property)) {\n        extractedProps[property] = (obj )[property];\n      }\n    }\n    return extractedProps;\n  } else {\n    return {};\n  }\n}\n\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\nfunction extractExceptionKeysForMessage(exception, maxLength = 40) {\n  var keys = Object.keys(convertToPlainObject(exception));\n  keys.sort();\n\n  if (!keys.length) {\n    return '[object has no keys]';\n  }\n\n  if (keys[0].length >= maxLength) {\n    return truncate(keys[0], maxLength);\n  }\n\n  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n    var serialized = keys.slice(0, includedKeys).join(', ');\n    if (serialized.length > maxLength) {\n      continue;\n    }\n    if (includedKeys === keys.length) {\n      return serialized;\n    }\n    return truncate(serialized, maxLength);\n  }\n\n  return '';\n}\n\n/**\n * Given any object, return a new object having removed all fields whose value was `undefined`.\n * Works recursively on objects and arrays.\n *\n * Attention: This function keeps circular references in the returned object.\n */\nfunction dropUndefinedKeys(inputValue) {\n  // This map keeps track of what already visited nodes map to.\n  // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular\n  // references as the input object.\n  var memoizationMap = new Map();\n\n  // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API\n  return _dropUndefinedKeys(inputValue, memoizationMap);\n}\n\nfunction _dropUndefinedKeys(inputValue, memoizationMap) {\n  if (isPlainObject(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object\n    var memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal ;\n    }\n\n    var returnValue = {};\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    for (var key of Object.keys(inputValue)) {\n      if (typeof inputValue[key] !== 'undefined') {\n        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);\n      }\n    }\n\n    return returnValue ;\n  }\n\n  if (Array.isArray(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object\n    var memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal ;\n    }\n\n    var returnValue = [];\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    inputValue.forEach((item) => {\n      returnValue.push(_dropUndefinedKeys(item, memoizationMap));\n    });\n\n    return returnValue ;\n  }\n\n  return inputValue;\n}\n\n/**\n * Ensure that something is an object.\n *\n * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper\n * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.\n *\n * @param wat The subject of the objectification\n * @returns A version of `wat` which can safely be used with `Object` class methods\n */\nfunction objectify(wat) {\n  let objectified;\n  switch (true) {\n    case wat === undefined || wat === null:\n      objectified = new String(wat);\n      break;\n\n    // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason\n    // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as\n    // an object in order to wrap it.\n    case typeof wat === 'symbol' || typeof wat === 'bigint':\n      objectified = Object(wat);\n      break;\n\n    // this will catch the remaining primitives: `String`, `Number`, and `Boolean`\n    case isPrimitive(wat):\n            objectified = new (wat ).constructor(wat);\n      break;\n\n    // by process of elimination, at this point we know that `wat` must already be an object\n    default:\n      objectified = wat;\n      break;\n  }\n  return objectified;\n}\n\nexport { addNonEnumerableProperty, convertToPlainObject, dropUndefinedKeys, extractExceptionKeysForMessage, fill, getOriginalFunction, markFunctionWrapped, objectify, urlEncode };\n//# sourceMappingURL=object.js.map\n","import { getGlobalObject } from './global.js';\nimport { isInstanceOf, isString } from './is.js';\nimport { logger, CONSOLE_LEVELS } from './logger.js';\nimport { fill } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\nimport { supportsNativeFetch, supportsHistory } from './supports.js';\n\nvar global = getGlobalObject();\n\n/**\n * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.\n *  - Console API\n *  - Fetch API\n *  - XHR API\n *  - History API\n *  - DOM API (click/typing)\n *  - Error API\n *  - UnhandledRejection API\n */\n\nvar handlers = {};\nvar instrumented = {};\n\n/** Instruments given API */\nfunction instrument(type) {\n  if (instrumented[type]) {\n    return;\n  }\n\n  instrumented[type] = true;\n\n  switch (type) {\n    case 'console':\n      instrumentConsole();\n      break;\n    case 'dom':\n      instrumentDOM();\n      break;\n    case 'xhr':\n      instrumentXHR();\n      break;\n    case 'fetch':\n      instrumentFetch();\n      break;\n    case 'history':\n      instrumentHistory();\n      break;\n    case 'error':\n      instrumentError();\n      break;\n    case 'unhandledrejection':\n      instrumentUnhandledRejection();\n      break;\n    default:\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('unknown instrumentation type:', type);\n      return;\n  }\n}\n\n/**\n * Add handler that will be called when given type of instrumentation triggers.\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addInstrumentationHandler(type, callback) {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] ).push(callback);\n  instrument(type);\n}\n\n/** JSDoc */\nfunction triggerHandlers(type, data) {\n  if (!type || !handlers[type]) {\n    return;\n  }\n\n  for (var handler of handlers[type] || []) {\n    try {\n      handler(data);\n    } catch (e) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.error(\n          `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n          e,\n        );\n    }\n  }\n}\n\n/** JSDoc */\nfunction instrumentConsole() {\n  if (!('console' in global)) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach(function (level) {\n    if (!(level in global.console)) {\n      return;\n    }\n\n    fill(global.console, level, function (originalConsoleMethod) {\n      return function (...args) {\n        triggerHandlers('console', { args, level });\n\n        // this fails for some browsers. :(\n        if (originalConsoleMethod) {\n          originalConsoleMethod.apply(global.console, args);\n        }\n      };\n    });\n  });\n}\n\n/** JSDoc */\nfunction instrumentFetch() {\n  if (!supportsNativeFetch()) {\n    return;\n  }\n\n  fill(global, 'fetch', function (originalFetch) {\n    return function (...args) {\n      var handlerData = {\n        args,\n        fetchData: {\n          method: getFetchMethod(args),\n          url: getFetchUrl(args),\n        },\n        startTimestamp: Date.now(),\n      };\n\n      triggerHandlers('fetch', {\n        ...handlerData,\n      });\n\n            return originalFetch.apply(global, args).then(\n        (response) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            response,\n          });\n          return response;\n        },\n        (error) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            error,\n          });\n          // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n          //       it means the sentry.javascript SDK caught an error invoking your application code.\n          //       This is expected behavior and NOT indicative of a bug with sentry.javascript.\n          throw error;\n        },\n      );\n    };\n  });\n}\n\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs = []) {\n  if ('Request' in global && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {\n    return String(fetchArgs[0].method).toUpperCase();\n  }\n  if (fetchArgs[1] && fetchArgs[1].method) {\n    return String(fetchArgs[1].method).toUpperCase();\n  }\n  return 'GET';\n}\n\n/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs = []) {\n  if (typeof fetchArgs[0] === 'string') {\n    return fetchArgs[0];\n  }\n  if ('Request' in global && isInstanceOf(fetchArgs[0], Request)) {\n    return fetchArgs[0].url;\n  }\n  return String(fetchArgs[0]);\n}\n\n/** JSDoc */\nfunction instrumentXHR() {\n  if (!('XMLHttpRequest' in global)) {\n    return;\n  }\n\n  var xhrproto = XMLHttpRequest.prototype;\n\n  fill(xhrproto, 'open', function (originalOpen) {\n    return function ( ...args) {\n            var xhr = this;\n      var url = args[1];\n      var xhrInfo = (xhr.__sentry_xhr__ = {\n                method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n        url: args[1],\n      });\n\n      // if Sentry key appears in URL, don't capture it as a request\n            if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {\n        xhr.__sentry_own_request__ = true;\n      }\n\n      var onreadystatechangeHandler = function () {\n        if (xhr.readyState === 4) {\n          try {\n            // touching statusCode in some platforms throws\n            // an exception\n            xhrInfo.status_code = xhr.status;\n          } catch (e) {\n            /* do nothing */\n          }\n\n          triggerHandlers('xhr', {\n            args,\n            endTimestamp: Date.now(),\n            startTimestamp: Date.now(),\n            xhr,\n          });\n        }\n      };\n\n      if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n        fill(xhr, 'onreadystatechange', function (original) {\n          return function (...readyStateArgs) {\n            onreadystatechangeHandler();\n            return original.apply(xhr, readyStateArgs);\n          };\n        });\n      } else {\n        xhr.addEventListener('readystatechange', onreadystatechangeHandler);\n      }\n\n      return originalOpen.apply(xhr, args);\n    };\n  });\n\n  fill(xhrproto, 'send', function (originalSend) {\n    return function ( ...args) {\n      if (this.__sentry_xhr__ && args[0] !== undefined) {\n        this.__sentry_xhr__.body = args[0];\n      }\n\n      triggerHandlers('xhr', {\n        args,\n        startTimestamp: Date.now(),\n        xhr: this,\n      });\n\n      return originalSend.apply(this, args);\n    };\n  });\n}\n\nlet lastHref;\n\n/** JSDoc */\nfunction instrumentHistory() {\n  if (!supportsHistory()) {\n    return;\n  }\n\n  var oldOnPopState = global.onpopstate;\n  global.onpopstate = function ( ...args) {\n    var to = global.location.href;\n    // keep track of the current URL state, as we always receive only the updated state\n    var from = lastHref;\n    lastHref = to;\n    triggerHandlers('history', {\n      from,\n      to,\n    });\n    if (oldOnPopState) {\n      // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.\n      // https://github.com/getsentry/sentry-javascript/issues/3344\n      // https://github.com/bugsnag/bugsnag-js/issues/469\n      try {\n        return oldOnPopState.apply(this, args);\n      } catch (_oO) {\n        // no-empty\n      }\n    }\n  };\n\n  /** @hidden */\n  function historyReplacementFunction(originalHistoryFunction) {\n    return function ( ...args) {\n      var url = args.length > 2 ? args[2] : undefined;\n      if (url) {\n        // coerce to string (this is what pushState does)\n        var from = lastHref;\n        var to = String(url);\n        // keep track of the current URL state, as we always receive only the updated state\n        lastHref = to;\n        triggerHandlers('history', {\n          from,\n          to,\n        });\n      }\n      return originalHistoryFunction.apply(this, args);\n    };\n  }\n\n  fill(global.history, 'pushState', historyReplacementFunction);\n  fill(global.history, 'replaceState', historyReplacementFunction);\n}\n\nvar debounceDuration = 1000;\nlet debounceTimerID;\nlet lastCapturedEvent;\n\n/**\n * Decide whether the current event should finish the debounce of previously captured one.\n * @param previous previously captured event\n * @param current event to be captured\n */\nfunction shouldShortcircuitPreviousDebounce(previous, current) {\n  // If there was no previous event, it should always be swapped for the new one.\n  if (!previous) {\n    return true;\n  }\n\n  // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.\n  if (previous.type !== current.type) {\n    return true;\n  }\n\n  try {\n    // If both events have the same type, it's still possible that actions were performed on different targets.\n    // e.g. 2 clicks on different buttons.\n    if (previous.target !== current.target) {\n      return true;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_\n  // to which an event listener was attached), we treat them as the same action, as we want to capture\n  // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.\n  return false;\n}\n\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\nfunction shouldSkipDOMEvent(event) {\n  // We are only interested in filtering `keypress` events for now.\n  if (event.type !== 'keypress') {\n    return false;\n  }\n\n  try {\n    var target = event.target ;\n\n    if (!target || !target.tagName) {\n      return true;\n    }\n\n    // Only consider keypress events on actual input elements. This will disregard keypresses targeting body\n    // e.g.tabbing through elements, hotkeys, etc.\n    if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {\n      return false;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  return true;\n}\n\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param handler function that will be triggered\n * @param globalListener indicates whether event was captured by the global event listener\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\nfunction makeDOMEventHandler(handler, globalListener = false) {\n  return (event) => {\n    // It's possible this handler might trigger multiple times for the same\n    // event (e.g. event propagation through node ancestors).\n    // Ignore if we've already captured that event.\n    if (!event || lastCapturedEvent === event) {\n      return;\n    }\n\n    // We always want to skip _some_ events.\n    if (shouldSkipDOMEvent(event)) {\n      return;\n    }\n\n    var name = event.type === 'keypress' ? 'input' : event.type;\n\n    // If there is no debounce timer, it means that we can safely capture the new event and store it for future comparisons.\n    if (debounceTimerID === undefined) {\n      handler({\n        event: event,\n        name,\n        global: globalListener,\n      });\n      lastCapturedEvent = event;\n    }\n    // If there is a debounce awaiting, see if the new event is different enough to treat it as a unique one.\n    // If that's the case, emit the previous event and store locally the newly-captured DOM event.\n    else if (shouldShortcircuitPreviousDebounce(lastCapturedEvent, event)) {\n      handler({\n        event: event,\n        name,\n        global: globalListener,\n      });\n      lastCapturedEvent = event;\n    }\n\n    // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.\n    clearTimeout(debounceTimerID);\n    debounceTimerID = global.setTimeout(() => {\n      debounceTimerID = undefined;\n    }, debounceDuration);\n  };\n}\n\n/** JSDoc */\nfunction instrumentDOM() {\n  if (!('document' in global)) {\n    return;\n  }\n\n  // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom\n  // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before\n  // we instrument `addEventListener` so that we don't end up attaching this handler twice.\n  var triggerDOMHandler = triggerHandlers.bind(null, 'dom');\n  var globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);\n  global.document.addEventListener('click', globalDOMEventHandler, false);\n  global.document.addEventListener('keypress', globalDOMEventHandler, false);\n\n  // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled\n  // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That\n  // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler\n  // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still\n  // guaranteed to fire at least once.)\n  ['EventTarget', 'Node'].forEach((target) => {\n        var proto = (global )[target] && (global )[target].prototype;\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function (originalAddEventListener) {\n      return function (\n        \n        type,\n        listener,\n        options,\n      ) {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            var el = this ;\n            var handlers = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});\n            var handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });\n\n            if (!handlerForType.handler) {\n              var handler = makeDOMEventHandler(triggerDOMHandler);\n              handlerForType.handler = handler;\n              originalAddEventListener.call(this, type, handler, options);\n            }\n\n            handlerForType.refCount += 1;\n          } catch (e) {\n            // Accessing dom properties is always fragile.\n            // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n          }\n        }\n\n        return originalAddEventListener.call(this, type, listener, options);\n      };\n    });\n\n    fill(\n      proto,\n      'removeEventListener',\n      function (originalRemoveEventListener) {\n        return function (\n          \n          type,\n          listener,\n          options,\n        ) {\n          if (type === 'click' || type == 'keypress') {\n            try {\n              var el = this ;\n              var handlers = el.__sentry_instrumentation_handlers__ || {};\n              var handlerForType = handlers[type];\n\n              if (handlerForType) {\n                handlerForType.refCount -= 1;\n                // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.\n                if (handlerForType.refCount <= 0) {\n                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);\n                  handlerForType.handler = undefined;\n                  delete handlers[type];                 }\n\n                // If there are no longer any custom handlers of any type on this element, cleanup everything.\n                if (Object.keys(handlers).length === 0) {\n                  delete el.__sentry_instrumentation_handlers__;\n                }\n              }\n            } catch (e) {\n              // Accessing dom properties is always fragile.\n              // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n            }\n          }\n\n          return originalRemoveEventListener.call(this, type, listener, options);\n        };\n      },\n    );\n  });\n}\n\nlet _oldOnErrorHandler = null;\n/** JSDoc */\nfunction instrumentError() {\n  _oldOnErrorHandler = global.onerror;\n\n  global.onerror = function (msg, url, line, column, error) {\n    triggerHandlers('error', {\n      column,\n      error,\n      line,\n      msg,\n      url,\n    });\n\n    if (_oldOnErrorHandler) {\n            return _oldOnErrorHandler.apply(this, arguments);\n    }\n\n    return false;\n  };\n}\n\nlet _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection() {\n  _oldOnUnhandledRejectionHandler = global.onunhandledrejection;\n\n  global.onunhandledrejection = function (e) {\n    triggerHandlers('unhandledrejection', e);\n\n    if (_oldOnUnhandledRejectionHandler) {\n            return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n    }\n\n    return true;\n  };\n}\n\nexport { addInstrumentationHandler };\n//# sourceMappingURL=instrument.js.map\n","import { getGlobalObject, getGlobalSingleton } from './global.js';\n\n// TODO: Implement different loggers for different environments\nvar global = getGlobalObject();\n\n/** Prefix for logging strings */\nvar PREFIX = 'Sentry Logger ';\n\nvar CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] ;\n\n/**\n * Temporarily disable sentry console instrumentations.\n *\n * @param callback The function to run against the original `console` messages\n * @returns The results of the callback\n */\nfunction consoleSandbox(callback) {\n  var global = getGlobalObject();\n\n  if (!('console' in global)) {\n    return callback();\n  }\n\n  var originalConsole = global.console ;\n  var wrappedLevels = {};\n\n  // Restore all wrapped console methods\n  CONSOLE_LEVELS.forEach(level => {\n    // TODO(v7): Remove this check as it's only needed for Node 6\n    var originalWrappedFunc =\n      originalConsole[level] && (originalConsole[level] ).__sentry_original__;\n    if (level in global.console && originalWrappedFunc) {\n      wrappedLevels[level] = originalConsole[level] ;\n      originalConsole[level] = originalWrappedFunc ;\n    }\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(level => {\n      originalConsole[level] = wrappedLevels[level ];\n    });\n  }\n}\n\nfunction makeLogger() {\n  let enabled = false;\n  var logger = {\n    enable: () => {\n      enabled = true;\n    },\n    disable: () => {\n      enabled = false;\n    },\n  };\n\n  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n    CONSOLE_LEVELS.forEach(name => {\n            logger[name] = (...args) => {\n        if (enabled) {\n          consoleSandbox(() => {\n            global.console[name](`${PREFIX}[${name}]:`, ...args);\n          });\n        }\n      };\n    });\n  } else {\n    CONSOLE_LEVELS.forEach(name => {\n      logger[name] = () => undefined;\n    });\n  }\n\n  return logger ;\n}\n\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nlet logger;\nif ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n  logger = getGlobalSingleton('logger', makeLogger);\n} else {\n  logger = makeLogger();\n}\n\nexport { CONSOLE_LEVELS, consoleSandbox, logger };\n//# sourceMappingURL=logger.js.map\n","var TRACEPARENT_REGEXP = new RegExp(\n  '^[ \\\\t]*' + // whitespace\n    '([0-9a-f]{32})?' + // trace_id\n    '-?([0-9a-f]{16})?' + // span_id\n    '-?([01])?' + // sampled\n    '[ \\\\t]*$', // whitespace\n);\n\n/**\n * Extract transaction context data from a `sentry-trace` header.\n *\n * @param traceparent Traceparent string\n *\n * @returns Object containing data from the header, or undefined if traceparent string is malformed\n */\nfunction extractTraceparentData(traceparent) {\n  var matches = traceparent.match(TRACEPARENT_REGEXP);\n  if (matches) {\n    let parentSampled;\n    if (matches[3] === '1') {\n      parentSampled = true;\n    } else if (matches[3] === '0') {\n      parentSampled = false;\n    }\n    return {\n      traceId: matches[1],\n      parentSampled,\n      parentSpanId: matches[2],\n    };\n  }\n  return undefined;\n}\n\nexport { TRACEPARENT_REGEXP, extractTraceparentData };\n//# sourceMappingURL=tracing.js.map\n","var objectToString = Object.prototype.toString;\n\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isError(wat) {\n  switch (objectToString.call(wat)) {\n    case '[object Error]':\n    case '[object Exception]':\n    case '[object DOMException]':\n      return true;\n    default:\n      return isInstanceOf(wat, Error);\n  }\n}\n\nfunction isBuiltin(wat, ty) {\n  return objectToString.call(wat) === `[object ${ty}]`;\n}\n\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isErrorEvent(wat) {\n  return isBuiltin(wat, 'ErrorEvent');\n}\n\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMError(wat) {\n  return isBuiltin(wat, 'DOMError');\n}\n\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMException(wat) {\n  return isBuiltin(wat, 'DOMException');\n}\n\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isString(wat) {\n  return isBuiltin(wat, 'String');\n}\n\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPrimitive(wat) {\n  return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPlainObject(wat) {\n  return isBuiltin(wat, 'Object');\n}\n\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isEvent(wat) {\n  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isElement(wat) {\n  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isRegExp(wat) {\n  return isBuiltin(wat, 'RegExp');\n}\n\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nfunction isThenable(wat) {\n    return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isSyntheticEvent(wat) {\n  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n\n/**\n * Checks whether given value is NaN\n * {@link isNaN}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isNaN(wat) {\n  return typeof wat === 'number' && wat !== wat;\n}\n\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nfunction isInstanceOf(wat, base) {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\n  }\n}\n\nexport { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isNaN, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable };\n//# sourceMappingURL=is.js.map\n","/** An error emitted by Sentry SDKs and related utilities. */\nclass SentryError extends Error {\n  /** Display name of this error instance. */\n  \n\n   constructor( message) {\n    super(message);this.message = message;;\n\n    this.name = new.target.prototype.constructor.name;\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\nexport { SentryError };\n//# sourceMappingURL=error.js.map\n","import { getGlobalObject } from './global.js';\nimport { addNonEnumerableProperty } from './object.js';\nimport { snipLine } from './string.js';\n\n/**\n * Extended Window interface that allows for Crypto API usage in IE browsers\n */\n\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nfunction uuid4() {\n  var global = getGlobalObject() ;\n  var crypto = (global.crypto || global.msCrypto) ;\n\n  if (crypto && crypto.randomUUID) {\n    return crypto.randomUUID().replace(/-/g, '');\n  }\n\n  var getRandomByte =\n    crypto && crypto.getRandomValues ? () => crypto.getRandomValues(new Uint8Array(1))[0] : () => Math.random() * 16;\n\n  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'\n  return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>\n        ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),\n  );\n}\n\n/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nfunction parseUrl(url)\n\n {\n  if (!url) {\n    return {};\n  }\n\n  var match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n\n  if (!match) {\n    return {};\n  }\n\n  // coerce to undefined values to empty string so we don't get 'undefined'\n  var query = match[6] || '';\n  var fragment = match[8] || '';\n  return {\n    host: match[4],\n    path: match[5],\n    protocol: match[2],\n    relative: match[5] + query + fragment, // everything minus origin\n  };\n}\n\nfunction getFirstException(event) {\n  return event.exception && event.exception.values ? event.exception.values[0] : undefined;\n}\n\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nfunction getEventDescription(event) {\n  const { message, event_id: eventId } = event;\n  if (message) {\n    return message;\n  }\n\n  var firstException = getFirstException(event);\n  if (firstException) {\n    if (firstException.type && firstException.value) {\n      return `${firstException.type}: ${firstException.value}`;\n    }\n    return firstException.type || firstException.value || eventId || '<unknown>';\n  }\n  return eventId || '<unknown>';\n}\n\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nfunction addExceptionTypeValue(event, value, type) {\n  var exception = (event.exception = event.exception || {});\n  var values = (exception.values = exception.values || []);\n  var firstException = (values[0] = values[0] || {});\n  if (!firstException.value) {\n    firstException.value = value || '';\n  }\n  if (!firstException.type) {\n    firstException.type = type || 'Error';\n  }\n}\n\n/**\n * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.\n *\n * @param event The event to modify.\n * @param newMechanism Mechanism data to add to the event.\n * @hidden\n */\nfunction addExceptionMechanism(event, newMechanism) {\n  var firstException = getFirstException(event);\n  if (!firstException) {\n    return;\n  }\n\n  var defaultMechanism = { type: 'generic', handled: true };\n  var currentMechanism = firstException.mechanism;\n  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };\n\n  if (newMechanism && 'data' in newMechanism) {\n    var mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };\n    firstException.mechanism.data = mergedData;\n  }\n}\n\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nvar SEMVER_REGEXP =\n  /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n\n/**\n * Represents Semantic Versioning object\n */\n\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nfunction parseSemver(input) {\n  var match = input.match(SEMVER_REGEXP) || [];\n  var major = parseInt(match[1], 10);\n  var minor = parseInt(match[2], 10);\n  var patch = parseInt(match[3], 10);\n  return {\n    buildmetadata: match[5],\n    major: isNaN(major) ? undefined : major,\n    minor: isNaN(minor) ? undefined : minor,\n    patch: isNaN(patch) ? undefined : patch,\n    prerelease: match[4],\n  };\n}\n\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nfunction addContextToFrame(lines, frame, linesOfContext = 5) {\n  var lineno = frame.lineno || 0;\n  var maxLines = lines.length;\n  var sourceLine = Math.max(Math.min(maxLines, lineno - 1), 0);\n\n  frame.pre_context = lines\n    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n    .map((line) => snipLine(line, 0));\n\n  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n\n  frame.post_context = lines\n    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n    .map((line) => snipLine(line, 0));\n}\n\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nfunction stripUrlQueryAndFragment(urlPath) {\n    return urlPath.split(/[\\?#]/, 1)[0];\n}\n\n/**\n * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object\n * in question), and marks it captured if not.\n *\n * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and\n * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so\n * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because\n * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not\n * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This\n * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we\n * see it.\n *\n * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on\n * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent\n * object wrapper forms so that this check will always work. However, because we need to flag the exact object which\n * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification\n * must be done before the exception captured.\n *\n * @param A thrown exception to check or flag as having been seen\n * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)\n */\nfunction checkOrSetAlreadyCaught(exception) {\n    if (exception && (exception ).__sentry_captured__) {\n    return true;\n  }\n\n  try {\n    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the\n    // `ExtraErrorData` integration\n    addNonEnumerableProperty(exception , '__sentry_captured__', true);\n  } catch (err) {\n    // `exception` is a primitive, so we can't mark it seen\n  }\n\n  return false;\n}\n\nexport { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, checkOrSetAlreadyCaught, getEventDescription, parseSemver, parseUrl, stripUrlQueryAndFragment, uuid4 };\n//# sourceMappingURL=misc.js.map\n","import { isBrowserBundle } from './env.js';\n\n/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n */\n\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nfunction isNodeEnv() {\n  // explicitly check for browser bundles as those can be optimized statically\n  // by terser/rollup.\n  return (\n    !isBrowserBundle() &&\n    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'\n  );\n}\n\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\nfunction dynamicRequire(mod, request) {\n    return mod.require(request);\n}\n\n/**\n * Helper for dynamically loading module that should work with linked dependencies.\n * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`\n * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during\n * build time. `require.resolve` is also not available in any other way, so we cannot create,\n * a fake helper like we do with `dynamicRequire`.\n *\n * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.\n * That is to mimic the behavior of `require.resolve` exactly.\n *\n * @param moduleName module name to require\n * @returns possibly required module\n */\nfunction loadModule(moduleName) {\n  let mod;\n\n  try {\n    mod = dynamicRequire(module, moduleName);\n  } catch (e) {\n    // no-empty\n  }\n\n  try {\n    const { cwd } = dynamicRequire(module, 'process');\n    mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) ;\n  } catch (e) {\n    // no-empty\n  }\n\n  return mod;\n}\n\nexport { dynamicRequire, isNodeEnv, loadModule };\n//# sourceMappingURL=node.js.map\n","import { isString, isRegExp } from './is.js';\n\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nfunction truncate(str, max = 0) {\n  if (typeof str !== 'string' || max === 0) {\n    return str;\n  }\n  return str.length <= max ? str : `${str.substr(0, max)}...`;\n}\n\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nfunction snipLine(line, colno) {\n  let newLine = line;\n  var lineLength = newLine.length;\n  if (lineLength <= 150) {\n    return newLine;\n  }\n  if (colno > lineLength) {\n        colno = lineLength;\n  }\n\n  let start = Math.max(colno - 60, 0);\n  if (start < 5) {\n    start = 0;\n  }\n\n  let end = Math.min(start + 140, lineLength);\n  if (end > lineLength - 5) {\n    end = lineLength;\n  }\n  if (end === lineLength) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n  if (start > 0) {\n    newLine = `'{snip} ${newLine}`;\n  }\n  if (end < lineLength) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\n}\n\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\nfunction safeJoin(input, delimiter) {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  var output = [];\n    for (let i = 0; i < input.length; i++) {\n    var value = input[i];\n    try {\n      output.push(String(value));\n    } catch (e) {\n      output.push('[value cannot be serialized]');\n    }\n  }\n\n  return output.join(delimiter);\n}\n\n/**\n * Checks if the value matches a regex or includes the string\n * @param value The string value to be checked against\n * @param pattern Either a regex or a string that must be contained in value\n */\nfunction isMatchingPattern(value, pattern) {\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n  if (typeof pattern === 'string') {\n    return value.indexOf(pattern) !== -1;\n  }\n  return false;\n}\n\n/**\n * Given a string, escape characters which have meaning in the regex grammar, such that the result is safe to feed to\n * `new RegExp()`.\n *\n * Based on https://github.com/sindresorhus/escape-string-regexp. Vendored to a) reduce the size by skipping the runtime\n * type-checking, and b) ensure it gets down-compiled for old versions of Node (the published package only supports Node\n * 12+).\n *\n * @param regexString The string to escape\n * @returns An version of the string with all special regex characters escaped\n */\nfunction escapeStringForRegex(regexString) {\n  // escape the hyphen separately so we can also replace it with a unicode literal hyphen, to avoid the problems\n  // discussed in https://github.com/sindresorhus/escape-string-regexp/issues/20.\n  return regexString.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d');\n}\n\nexport { escapeStringForRegex, isMatchingPattern, safeJoin, snipLine, truncate };\n//# sourceMappingURL=string.js.map\n"],"sourceRoot":""}