{"version":3,"sources":["webpack:///../node_modules/process/browser.js","webpack:///../node_modules/tslib/tslib.es6.js","webpack:///../node_modules/@sentry/utils/esm/is.js","webpack:///../node_modules/@sentry/utils/esm/misc.js","webpack:///../node_modules/webpack/buildin/harmony-module.js","webpack:///../node_modules/@sentry/utils/esm/node.js","webpack:///../node_modules/@sentry/utils/esm/string.js","webpack:///../node_modules/@sentry/utils/esm/stacktrace.js","webpack:///../node_modules/@sentry/utils/esm/object.js","webpack:///../node_modules/@sentry/utils/esm/browser.js","webpack:///../node_modules/@sentry/utils/esm/memo.js","webpack:///../node_modules/@sentry/utils/esm/time.js","webpack:///../node_modules/@sentry/types/esm/severity.js","webpack:///../node_modules/@sentry/types/esm/status.js","webpack:///../node_modules/@sentry/utils/esm/syncpromise.js","webpack:///../node_modules/@sentry/types/esm/session.js","webpack:///../node_modules/@sentry/hub/esm/scope.js","webpack:///../node_modules/@sentry/utils/esm/logger.js","webpack:///../node_modules/@sentry/hub/esm/session.js","webpack:///../node_modules/@sentry/hub/esm/hub.js","webpack:///../node_modules/@sentry/minimal/esm/index.js","webpack:///../node_modules/@sentry/core/esm/version.js","webpack:///../node_modules/@sentry/utils/esm/polyfill.js","webpack:///../node_modules/@sentry/utils/esm/error.js","webpack:///../node_modules/@sentry/utils/esm/dsn.js","webpack:///../node_modules/@sentry/core/esm/integration.js","webpack:///../node_modules/@sentry/core/esm/baseclient.js","webpack:///../node_modules/@sentry/core/esm/transports/noop.js","webpack:///../node_modules/@sentry/core/esm/basebackend.js","webpack:///../node_modules/@sentry/utils/esm/supports.js","webpack:///../node_modules/@sentry/browser/esm/tracekit.js","webpack:///../node_modules/@sentry/browser/esm/parsers.js","webpack:///../node_modules/@sentry/browser/esm/eventbuilder.js","webpack:///../node_modules/@sentry/core/esm/request.js","webpack:///../node_modules/@sentry/core/esm/api.js","webpack:///../node_modules/@sentry/utils/esm/promisebuffer.js","webpack:///../node_modules/@sentry/browser/esm/transports/base.js","webpack:///../node_modules/@sentry/browser/esm/transports/fetch.js","webpack:///../node_modules/@sentry/browser/esm/transports/xhr.js","webpack:///../node_modules/@sentry/browser/esm/backend.js","webpack:///../node_modules/@sentry/browser/esm/helpers.js","webpack:///../node_modules/@sentry/utils/esm/instrument.js","webpack:///../node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack:///../node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack:///../node_modules/@sentry/browser/esm/client.js","webpack:///../node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack:///../node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack:///../node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack:///../node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack:///../node_modules/@sentry/browser/esm/integrations/useragent.js","webpack:///../node_modules/@sentry/browser/esm/sdk.js","webpack:///../node_modules/@sentry/core/esm/sdk.js","webpack:///../node_modules/@sentry/browser/esm/version.js","webpack:///../node_modules/@sentry/browser/esm/index.js"],"names":["cachedSetTimeout","cachedClearTimeout","process","module","exports","defaultSetTimout","Error","defaultClearTimeout","runTimeout","fun","setTimeout","e","call","this","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","length","concat","drainQueue","timeout","len","run","marker","runClearTimeout","Item","array","noop","nextTick","args","Array","arguments","i","push","prototype","apply","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","name","binding","cwd","chdir","dir","umask","extendStatics","d","b","Object","setPrototypeOf","__proto__","p","hasOwnProperty","__extends","__","constructor","create","__assign","assign","t","s","n","__rest","indexOf","getOwnPropertySymbols","__values","o","m","Symbol","iterator","next","value","done","__read","r","ar","error","__spread","isError","wat","toString","isInstanceOf","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","Boolean","then","isSyntheticEvent","base","_e","fallbackGlobalObject","getGlobalObject","global","window","self","uuid4","crypto","msCrypto","getRandomValues","arr","Uint16Array","pad","num","v","replace","c","Math","random","parseUrl","url","match","query","fragment","host","path","protocol","relative","getEventDescription","event","message","exception","values","type","event_id","consoleSandbox","callback","originalConsole","console","wrappedLevels","forEach","level","__sentry_original__","result","keys","addExceptionTypeValue","addExceptionMechanism","mechanism","key","_oO","getLocationHref","document","location","href","oO","parseRetryAfterHeader","now","header","headerDelay","parseInt","isNaN","headerDate","Date","parse","originalModule","webpackPolyfill","children","defineProperty","enumerable","get","l","isNodeEnv","dynamicRequire","mod","request","require","truncate","str","max","substr","snipLine","line","colno","newLine","ll","start","end","min","slice","safeJoin","input","delimiter","isArray","output","String","join","isMatchingPattern","pattern","test","getFunctionName","fn","fill","source","replacementFactory","original","wrapped","defineProperties","_Oo","urlEncode","object","map","encodeURIComponent","getWalkSource","err","stack","event_1","target","currentTarget","CustomEvent","detail","jsonSize","encodeURI","split","utf8Length","JSON","stringify","normalizeToSize","depth","maxSize","serialized","normalize","normalizeValue","_events","walk","memo","Infinity","normalized","serializeValue","toJSON","acc","memoize","innerKey","unmemoize","extractExceptionKeysForMessage","maxLength","sort","includedKeys","dropUndefinedKeys","val","e_1","_a","obj","rv","_b","_c","e_1_1","return","htmlTreeAsString","elem","currentElem","out","height","sepLength","nextStr","_htmlElementAsString","parentNode","reverse","el","className","classes","attr","tagName","toLowerCase","id","allowedAttrs","getAttribute","Memo","_hasWeakSet","WeakSet","_inner","has","add","delete","splice","dateTimestampSource","nowSeconds","platformPerformance","performance","_","getNodePerformance","timeOrigin","getBrowserPerformance","timestampSource","undefined","dateTimestampInSeconds","bind","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","Severity","Status","fromString","Debug","Info","Warning","Fatal","Critical","Log","fromHttpCode","code","Success","RateLimit","Invalid","Failed","Unknown","States","SessionStatus","RequestSessionStatus","SyncPromise","executor","_this","_state","PENDING","_handlers","_resolve","_setResult","RESOLVED","_reject","reason","REJECTED","state","is","_value","_executeHandlers","_attachHandler","handler","cachedHandlers","onfulfilled","onrejected","resolve","reject","all","collection","counter","resolvedCollection","item","index","TypeError","catch","finally","onfinally","isRejected","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_user","_tags","_extra","_contexts","clone","scope","newScope","_level","_span","_session","_transactionName","_fingerprint","_requestSession","addScopeListener","addEventProcessor","setUser","user","update","_notifyScopeListeners","getUser","getRequestSession","setRequestSession","requestSession","setTags","tags","setTag","setExtras","extras","setExtra","extra","setFingerprint","fingerprint","setLevel","setTransactionName","setTransaction","setContext","context","setSpan","span","getSpan","getTransaction","_d","transaction","spanRecorder","spans","setSession","session","getSession","captureContext","updatedScope","contexts","clear","addBreadcrumb","breadcrumb","maxBreadcrumbs","mergedBreadcrumb","timestamp","clearBreadcrumbs","applyToEvent","hint","trace","getTraceContext","transactionName","_applyFingerprint","breadcrumbs","_notifyEventProcessors","getGlobalEventProcessors","processors","processor","final","__SENTRY__","globalEventProcessors","addGlobalEventProcessor","PREFIX","Logger","_enabled","disable","enable","log","_i","warn","logger","Session","errors","sid","started","duration","status","Ok","init","ip_address","ipAddress","did","email","username","release","environment","userAgent","close","Exited","toISOString","attrs","user_agent","SessionFlusher","transport","flushTimeout","_pendingAggregates","_isEnabled","_transport","_intervalId","setInterval","flush","_sessionAttrs","sendSessionAggregates","sessionAggregates","sendSession","getSessionAggregates","aggregates","clearInterval","incrementSessionStatusCount","getCurrentHub","getScope","_incrementSessionStatusCount","date","sessionStartedTrunc","setSeconds","aggregationCounts","Errored","errored","exited","Crashed","crashed","Hub","client","_version","_stack","getStackTop","bindClient","isOlderThan","setupIntegrations","pushScope","getStack","getClient","popScope","pop","withScope","captureException","eventId","_lastEventId","finalHint","syntheticException","originalException","_invokeClient","captureMessage","captureEvent","lastEventId","getOptions","beforeBreadcrumb","finalBreadcrumb","configureScope","oldHub","makeMain","getIntegration","integration","startSpan","_callExtensionMethod","startTransaction","customSamplingContext","traceHeaders","captureSession","endSession","_sendSessionUpdate","startSession","currentSession","method","carrier","getMainCarrier","sentry","extensions","hub","registry","getHubFromCarrier","setHubOnCarrier","hasHubOnCarrier","activeDomain","domain","active","registryHubTopStack","getHubFromActiveDomain","callOnHub","SDK_VERSION","proto","prop","_super","SentryError","_newTarget","DSN_REGEX","Dsn","from","_fromString","_fromComponents","_validate","withPassword","pass","port","projectId","publicKey","exec","projectMatch","components","component","ERROR_MESSAGE","installedIntegrations","filterDuplicates","integrations","reduce","every","accIntegration","options","defaultIntegrations","userIntegrations","filter","userIntegration","integrationsNames","getIntegrationsToSetup","setupOnce","setupIntegration","BaseClient","backendClass","_integrations","_processing","_backend","_options","dsn","_dsn","_process","_getBackend","eventFromException","_captureEvent","promisedEvent","eventFromMessage","_sendSession","getDsn","_isClientProcessing","ready","getTransport","transportFlushed","enabled","_updateSessionFromEvent","exceptions","exceptions_1","exceptions_1_1","handled","headers","Number","ticked","interval","_prepareEvent","normalizeDepth","prepared","_applyClientOptions","_applyIntegrationsMetadata","finalScope","evt","_normalizeEvent","data","dist","maxValueLength","integrationsArray","sdk","_sendEvent","sendEvent","_processEvent","finalEvent","beforeSend","sampleRate","isTransaction","__sentry__","beforeSendResult","processedEvent","promise","NoopTransport","Skipped","BaseBackend","_setupTransport","_exception","_hint","_message","supportsFetch","Headers","Request","Response","isNativeFetch","func","supportsReferrerPolicy","referrerPolicy","gecko","winjs","geckoEval","chromeEval","reactMinifiedRegexp","computeStackTrace","ex","popSize","framesToPop","stacktrace","parts","opera10Regex","opera11Regex","lines","element","column","extractMessage","computeStackTraceFromStacktraceProp","popFrames","submatch","isNative","isSafariExtension","isSafariWebExtension","columnNumber","computeStackTraceFromStackProp","failed","exceptionFromStacktrace","frames","prepareFramesForEvent","eventFromStacktrace","localStack","firstFrameFunction","lastFrameFunction","frame","filename","function","in_app","lineno","eventFromUnknownInput","attachStacktrace","eventFromString","domException","name_1","rejection","__serialized__","frames_1","eventFromPlainObject","synthetic","getSdkMetadataForEnvelopeHeader","api","metadata","enhanceEventWithSdkInfo","sdkInfo","packages","sessionToSentryRequest","body","sent_at","getEnvelopeEndpointWithUrlEncodedAuth","eventToSentryRequest","eventType","useEnvelope","debug_meta","transactionSampling","samplingMethod","rate","req","getStoreEndpointWithUrlEncodedAuth","envelope","sample_rates","API","_dsnObject","getBaseApiEndpoint","getStoreEndpoint","_getIngestEndpoint","_encodedAuth","_getEnvelopeEndpoint","getStoreEndpointPath","getRequestHeaders","clientName","clientVersion","getReportDialogEndpoint","dialogOptions","endpoint","encodedOptions","auth","sentry_key","sentry_version","PromiseBuffer","_limit","_buffer","isReady","task","remove","drain","capturedSetTimeout","CATEGORY_MAPPING","attachment","BaseTransport","_rateLimits","_api","_metadata","_handleResponse","requestType","response","_handleRateLimit","_disabledUntil","category","_isRateLimited","e_2","rlHeader","raHeader","trim","parameters","delay","_f","e_2_1","FetchTransport","fetchImpl","fetch","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","getNativeFetchImplementation","_fetch","_sendRequest","sentryRequest","originalPayload","Promise","fetchParameters","XHRTransport","XMLHttpRequest","onreadystatechange","readyState","getResponseHeader","open","setRequestHeader","send","BrowserBackend","transportOptions","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","wrap","before","__sentry_wrapped__","sentryWrapped","wrappedArguments","arg","handleEvent","property","getOwnPropertyDescriptor","configurable","injectReportDialog","script","async","src","onLoad","onload","lastHref","handlers","instrumented","instrument","originalConsoleLevel","triggerHandlers","Function","instrumentConsole","triggerDOMHandler","globalDOMEventHandler","makeDOMEventHandler","addEventListener","originalAddEventListener","listener","handlers_1","__sentry_instrumentation_handlers__","handlerForType","refCount","originalRemoveEventListener","handlers_2","instrumentDOM","requestKeys","requestValues","xhrproto","originalOpen","xhr","__sentry_xhr__","toUpperCase","__sentry_own_request__","onreadystatechangeHandler","status_code","requestPos","args_1","endTimestamp","startTimestamp","readyStateArgs","originalSend","instrumentXHR","doc","supportsNativeFetch","originalFetch","handlerData","fetchData","getFetchMethod","getFetchUrl","instrumentFetch","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","to","instrumentHistory","_oldOnErrorHandler","onerror","msg","_oldOnUnhandledRejectionHandler","onunhandledrejection","addInstrumentationHandler","fetchArgs","debounceTimerID","lastCapturedEvent","globalListener","isContentEditable","shouldSkipDOMEvent","previous","current","shouldShortcircuitPreviousDebounce","originalFunctionToString","Breadcrumbs","dom","addSentryBreadcrumb","_consoleBreadcrumb","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","parsedLoc","parsedFrom","parsedTo","BrowserClient","showReportDialog","platform","FunctionToString","DEFAULT_IGNORE_ERRORS","InboundFilters","clientOptions","_mergeOptions","_shouldDropEvent","_isSentryError","_isIgnoredError","_isDeniedUrl","_getEventFilterUrl","_isAllowedUrl","ignoreInternal","ignoreErrors","_getPossibleEventMessages","some","denyUrls","allowUrls","whitelistUrls","blacklistUrls","frames_2","DEFAULT_EVENT_TARGET","TryCatch","eventTarget","requestAnimationFrame","_wrapTimeFunction","_wrapRAF","_wrapXHR","_wrapEventTarget","originalCallback","eventName","wrappedEventHandler","originalEventHandler","xmlHttpRequestProps","wrapOptions","GlobalHandlers","_onErrorHandlerInstalled","_onUnhandledRejectionHandlerInstalled","stackTraceLimit","_installGlobalOnErrorHandler","_installGlobalOnUnhandledRejectionHandler","currentHub","hasIntegration","isFailedOwnDelivery","_eventFromIncompleteOnError","_enhanceEventWithInitialFrame","_eventFromRejectionWithPrimitive","groups","LinkedErrors","_key","limit","_handler","linkedErrors","_walkErrorTree","UserAgent","navigator","referrer","Referer","window_1","SENTRY_RELEASE","autoSessionTracking","clientClass","debug","initialScope","initAndBind","startSessionTracking","forceLoad","SDK_NAME","windowIntegrations","_window","Sentry","Integrations","INTEGRATIONS"],"mappings":"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","file":"4.1705a05022cddccbcce2.js","sourcesContent":["// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\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 */\nexport function isError(wat) {\n    switch (Object.prototype.toString.call(wat)) {\n        case '[object Error]':\n            return true;\n        case '[object Exception]':\n            return true;\n        case '[object DOMException]':\n            return true;\n        default:\n            return isInstanceOf(wat, Error);\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 */\nexport function isErrorEvent(wat) {\n    return Object.prototype.toString.call(wat) === '[object ErrorEvent]';\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 */\nexport function isDOMError(wat) {\n    return Object.prototype.toString.call(wat) === '[object DOMError]';\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 */\nexport function isDOMException(wat) {\n    return Object.prototype.toString.call(wat) === '[object DOMException]';\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 */\nexport function isString(wat) {\n    return Object.prototype.toString.call(wat) === '[object String]';\n}\n/**\n * Checks whether given value's 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 */\nexport function isPrimitive(wat) {\n    return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\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 */\nexport function isPlainObject(wat) {\n    return Object.prototype.toString.call(wat) === '[object Object]';\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 */\nexport function isEvent(wat) {\n    return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\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 */\nexport function isElement(wat) {\n    return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\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 */\nexport function isRegExp(wat) {\n    return Object.prototype.toString.call(wat) === '[object RegExp]';\n}\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nexport function isThenable(wat) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return Boolean(wat && wat.then && typeof wat.then === 'function');\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 */\nexport function isSyntheticEvent(wat) {\n    return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\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 */\nexport function isInstanceOf(wat, base) {\n    try {\n        return wat instanceof base;\n    }\n    catch (_e) {\n        return false;\n    }\n}\n//# sourceMappingURL=is.js.map","import { isNodeEnv } from './node';\nimport { snipLine } from './string';\nvar fallbackGlobalObject = {};\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nexport function getGlobalObject() {\n    return (isNodeEnv()\n        ? global\n        : typeof window !== 'undefined'\n            ? window\n            : typeof self !== 'undefined'\n                ? self\n                : fallbackGlobalObject);\n}\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nexport function uuid4() {\n    var global = getGlobalObject();\n    var crypto = global.crypto || global.msCrypto;\n    if (!(crypto === void 0) && crypto.getRandomValues) {\n        // Use window.crypto API if available\n        var arr = new Uint16Array(8);\n        crypto.getRandomValues(arr);\n        // set 4 in byte 7\n        // eslint-disable-next-line no-bitwise\n        arr[3] = (arr[3] & 0xfff) | 0x4000;\n        // set 2 most significant bits of byte 9 to '10'\n        // eslint-disable-next-line no-bitwise\n        arr[4] = (arr[4] & 0x3fff) | 0x8000;\n        var pad = function (num) {\n            var v = num.toString(16);\n            while (v.length < 4) {\n                v = \"0\" + v;\n            }\n            return v;\n        };\n        return (pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) + pad(arr[5]) + pad(arr[6]) + pad(arr[7]));\n    }\n    // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n    return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n        // eslint-disable-next-line no-bitwise\n        var r = (Math.random() * 16) | 0;\n        // eslint-disable-next-line no-bitwise\n        var v = c === 'x' ? r : (r & 0x3) | 0x8;\n        return v.toString(16);\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 */\nexport function parseUrl(url) {\n    if (!url) {\n        return {};\n    }\n    var match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n    if (!match) {\n        return {};\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,\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 */\nexport function getEventDescription(event) {\n    if (event.message) {\n        return event.message;\n    }\n    if (event.exception && event.exception.values && event.exception.values[0]) {\n        var exception = event.exception.values[0];\n        if (exception.type && exception.value) {\n            return exception.type + \": \" + exception.value;\n        }\n        return exception.type || exception.value || event.event_id || '<unknown>';\n    }\n    return event.event_id || '<unknown>';\n}\n/** JSDoc */\nexport function consoleSandbox(callback) {\n    var global = getGlobalObject();\n    var levels = ['debug', 'info', 'warn', 'error', 'log', 'assert'];\n    if (!('console' in global)) {\n        return callback();\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    var originalConsole = global.console;\n    var wrappedLevels = {};\n    // Restore all wrapped console methods\n    levels.forEach(function (level) {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        if (level in global.console && originalConsole[level].__sentry_original__) {\n            wrappedLevels[level] = originalConsole[level];\n            originalConsole[level] = originalConsole[level].__sentry_original__;\n        }\n    });\n    // Perform callback manipulations\n    var result = callback();\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(function (level) {\n        originalConsole[level] = wrappedLevels[level];\n    });\n    return result;\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 */\nexport function addExceptionTypeValue(event, value, type) {\n    event.exception = event.exception || {};\n    event.exception.values = event.exception.values || [];\n    event.exception.values[0] = event.exception.values[0] || {};\n    event.exception.values[0].value = event.exception.values[0].value || value || '';\n    event.exception.values[0].type = event.exception.values[0].type || type || 'Error';\n}\n/**\n * Adds exception mechanism to a given event.\n * @param event The event to modify.\n * @param mechanism Mechanism of the mechanism.\n * @hidden\n */\nexport function addExceptionMechanism(event, mechanism) {\n    if (mechanism === void 0) { mechanism = {}; }\n    // TODO: Use real type with `keyof Mechanism` thingy and maybe make it better?\n    try {\n        // @ts-ignore Type 'Mechanism | {}' is not assignable to type 'Mechanism | undefined'\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        event.exception.values[0].mechanism = event.exception.values[0].mechanism || {};\n        Object.keys(mechanism).forEach(function (key) {\n            // @ts-ignore Mechanism has no index signature\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            event.exception.values[0].mechanism[key] = mechanism[key];\n        });\n    }\n    catch (_oO) {\n        // no-empty\n    }\n}\n/**\n * A safe form of location.href\n */\nexport function getLocationHref() {\n    try {\n        return document.location.href;\n    }\n    catch (oO) {\n        return '';\n    }\n}\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nvar SEMVER_REGEXP = /^(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 * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nexport function 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}\nvar defaultRetryAfter = 60 * 1000; // 60 seconds\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param now current unix timestamp\n * @param header string representation of 'Retry-After' header\n */\nexport function parseRetryAfterHeader(now, header) {\n    if (!header) {\n        return defaultRetryAfter;\n    }\n    var headerDelay = parseInt(\"\" + header, 10);\n    if (!isNaN(headerDelay)) {\n        return headerDelay * 1000;\n    }\n    var headerDate = Date.parse(\"\" + header);\n    if (!isNaN(headerDate)) {\n        return headerDate - now;\n    }\n    return defaultRetryAfter;\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 */\nexport function addContextToFrame(lines, frame, linesOfContext) {\n    if (linesOfContext === void 0) { 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    frame.pre_context = lines\n        .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n        .map(function (line) { return snipLine(line, 0); });\n    frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n    frame.post_context = lines\n        .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n        .map(function (line) { return snipLine(line, 0); });\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 */\nexport function stripUrlQueryAndFragment(urlPath) {\n    // eslint-disable-next-line no-useless-escape\n    return urlPath.split(/[\\?#]/, 1)[0];\n}\n//# sourceMappingURL=misc.js.map","module.exports = function(originalModule) {\n\tif (!originalModule.webpackPolyfill) {\n\t\tvar module = Object.create(originalModule);\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"exports\", {\n\t\t\tenumerable: true\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nexport function isNodeEnv() {\n    return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';\n}\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any\nexport function dynamicRequire(mod, request) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return mod.require(request);\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 */\nexport function loadModule(moduleName) {\n    var mod;\n    try {\n        mod = dynamicRequire(module, moduleName);\n    }\n    catch (e) {\n        // no-empty\n    }\n    try {\n        var cwd = dynamicRequire(module, 'process').cwd;\n        mod = dynamicRequire(module, cwd() + \"/node_modules/\" + moduleName);\n    }\n    catch (e) {\n        // no-empty\n    }\n    return mod;\n}\n//# sourceMappingURL=node.js.map","import { isRegExp, isString } from './is';\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 */\nexport function truncate(str, max) {\n    if (max === void 0) { 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 * 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 */\nexport function snipLine(line, colno) {\n    var newLine = line;\n    var ll = newLine.length;\n    if (ll <= 150) {\n        return newLine;\n    }\n    if (colno > ll) {\n        // eslint-disable-next-line no-param-reassign\n        colno = ll;\n    }\n    var start = Math.max(colno - 60, 0);\n    if (start < 5) {\n        start = 0;\n    }\n    var end = Math.min(start + 140, ll);\n    if (end > ll - 5) {\n        end = ll;\n    }\n    if (end === ll) {\n        start = Math.max(end - 140, 0);\n    }\n    newLine = newLine.slice(start, end);\n    if (start > 0) {\n        newLine = \"'{snip} \" + newLine;\n    }\n    if (end < ll) {\n        newLine += ' {snip}';\n    }\n    return newLine;\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function safeJoin(input, delimiter) {\n    if (!Array.isArray(input)) {\n        return '';\n    }\n    var output = [];\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (var i = 0; i < input.length; i++) {\n        var value = input[i];\n        try {\n            output.push(String(value));\n        }\n        catch (e) {\n            output.push('[value cannot be serialized]');\n        }\n    }\n    return output.join(delimiter);\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 */\nexport function isMatchingPattern(value, pattern) {\n    if (!isString(value)) {\n        return false;\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//# sourceMappingURL=string.js.map","var defaultFunctionName = '<anonymous>';\n/**\n * Safely extract function name from itself\n */\nexport function getFunctionName(fn) {\n    try {\n        if (!fn || typeof fn !== 'function') {\n            return defaultFunctionName;\n        }\n        return fn.name || defaultFunctionName;\n    }\n    catch (e) {\n        // Just accessing custom props in some Selenium environments\n        // can cause a \"Permission denied\" exception (see raven-js#495).\n        return defaultFunctionName;\n    }\n}\n//# sourceMappingURL=stacktrace.js.map","import { __values } from \"tslib\";\nimport { htmlTreeAsString } from './browser';\nimport { isElement, isError, isEvent, isInstanceOf, isPlainObject, isPrimitive, isSyntheticEvent } from './is';\nimport { Memo } from './memo';\nimport { getFunctionName } from './stacktrace';\nimport { truncate } from './string';\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 */\nexport function fill(source, name, replacementFactory) {\n    if (!(name in source)) {\n        return;\n    }\n    var original = source[name];\n    var wrapped = replacementFactory(original);\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            wrapped.prototype = wrapped.prototype || {};\n            Object.defineProperties(wrapped, {\n                __sentry_original__: {\n                    enumerable: false,\n                    value: original,\n                },\n            });\n        }\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    source[name] = wrapped;\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 */\nexport function urlEncode(object) {\n    return Object.keys(object)\n        .map(function (key) { return encodeURIComponent(key) + \"=\" + encodeURIComponent(object[key]); })\n        .join('&');\n}\n/**\n * Transforms any object into an object literal with all its attributes\n * attached to it.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n */\nfunction getWalkSource(value) {\n    if (isError(value)) {\n        var error = value;\n        var err = {\n            message: error.message,\n            name: error.name,\n            stack: error.stack,\n        };\n        for (var i in error) {\n            if (Object.prototype.hasOwnProperty.call(error, i)) {\n                err[i] = error[i];\n            }\n        }\n        return err;\n    }\n    if (isEvent(value)) {\n        var event_1 = value;\n        var source = {};\n        source.type = event_1.type;\n        // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n        try {\n            source.target = isElement(event_1.target)\n                ? htmlTreeAsString(event_1.target)\n                : Object.prototype.toString.call(event_1.target);\n        }\n        catch (_oO) {\n            source.target = '<unknown>';\n        }\n        try {\n            source.currentTarget = isElement(event_1.currentTarget)\n                ? htmlTreeAsString(event_1.currentTarget)\n                : Object.prototype.toString.call(event_1.currentTarget);\n        }\n        catch (_oO) {\n            source.currentTarget = '<unknown>';\n        }\n        if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n            source.detail = event_1.detail;\n        }\n        for (var i in event_1) {\n            if (Object.prototype.hasOwnProperty.call(event_1, i)) {\n                source[i] = event_1;\n            }\n        }\n        return source;\n    }\n    return value;\n}\n/** Calculates bytes size of input string */\nfunction utf8Length(value) {\n    // eslint-disable-next-line no-bitwise\n    return ~-encodeURI(value).split(/%..|./).length;\n}\n/** Calculates bytes size of input object */\nfunction jsonSize(value) {\n    return utf8Length(JSON.stringify(value));\n}\n/** JSDoc */\nexport function normalizeToSize(object, \n// Default Node.js REPL depth\ndepth, \n// 100kB, as 200kB is max payload size, so half sounds reasonable\nmaxSize) {\n    if (depth === void 0) { depth = 3; }\n    if (maxSize === void 0) { maxSize = 100 * 1024; }\n    var serialized = normalize(object, depth);\n    if (jsonSize(serialized) > maxSize) {\n        return normalizeToSize(object, depth - 1, maxSize);\n    }\n    return serialized;\n}\n/**\n * Transform any non-primitive, BigInt, or Symbol-type value into a string. Acts as a no-op on strings, numbers,\n * booleans, null, and undefined.\n *\n * @param value The value to stringify\n * @returns For non-primitive, BigInt, and Symbol-type values, a string denoting the value's type, type and value, or\n *  type and `description` property, respectively. For non-BigInt, non-Symbol primitives, returns the original value,\n *  unchanged.\n */\nfunction serializeValue(value) {\n    var type = Object.prototype.toString.call(value);\n    // Node.js REPL notation\n    if (typeof value === 'string') {\n        return value;\n    }\n    if (type === '[object Object]') {\n        return '[Object]';\n    }\n    if (type === '[object Array]') {\n        return '[Array]';\n    }\n    var normalized = normalizeValue(value);\n    return isPrimitive(normalized) ? normalized : type;\n}\n/**\n * normalizeValue()\n *\n * Takes unserializable input and make it serializable friendly\n *\n * - translates undefined/NaN values to \"[undefined]\"/\"[NaN]\" respectively,\n * - serializes Error objects\n * - filter global objects\n */\nfunction normalizeValue(value, key) {\n    if (key === 'domain' && value && typeof value === 'object' && value._events) {\n        return '[Domain]';\n    }\n    if (key === 'domainEmitter') {\n        return '[DomainEmitter]';\n    }\n    if (typeof global !== 'undefined' && value === global) {\n        return '[Global]';\n    }\n    if (typeof window !== 'undefined' && value === window) {\n        return '[Window]';\n    }\n    if (typeof document !== 'undefined' && value === document) {\n        return '[Document]';\n    }\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n        return '[SyntheticEvent]';\n    }\n    if (typeof value === 'number' && value !== value) {\n        return '[NaN]';\n    }\n    if (value === void 0) {\n        return '[undefined]';\n    }\n    if (typeof value === 'function') {\n        return \"[Function: \" + getFunctionName(value) + \"]\";\n    }\n    // symbols and bigints are considered primitives by TS, but aren't natively JSON-serilaizable\n    if (typeof value === 'symbol') {\n        return \"[\" + String(value) + \"]\";\n    }\n    if (typeof value === 'bigint') {\n        return \"[BigInt: \" + String(value) + \"]\";\n    }\n    return value;\n}\n/**\n * Walks an object to perform a normalization on it\n *\n * @param key of object that's walked in current iteration\n * @param value object to be walked\n * @param depth Optional number indicating how deep should walking be performed\n * @param memo Optional Memo class handling decycling\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function walk(key, value, depth, memo) {\n    if (depth === void 0) { depth = +Infinity; }\n    if (memo === void 0) { memo = new Memo(); }\n    // If we reach the maximum depth, serialize whatever has left\n    if (depth === 0) {\n        return serializeValue(value);\n    }\n    /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n    // If value implements `toJSON` method, call it and return early\n    if (value !== null && value !== undefined && typeof value.toJSON === 'function') {\n        return value.toJSON();\n    }\n    /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n    // If normalized value is a primitive, there are no branches left to walk, so we can just bail out, as theres no point in going down that branch any further\n    var normalized = normalizeValue(value, key);\n    if (isPrimitive(normalized)) {\n        return normalized;\n    }\n    // Create source that we will use for next itterations, either objectified error object (Error type with extracted keys:value pairs) or the input itself\n    var source = getWalkSource(value);\n    // Create an accumulator that will act as a parent for all future itterations of that branch\n    var acc = Array.isArray(value) ? [] : {};\n    // If we already walked that branch, bail out, as it's circular reference\n    if (memo.memoize(value)) {\n        return '[Circular ~]';\n    }\n    // Walk all keys of the source\n    for (var innerKey in source) {\n        // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n        if (!Object.prototype.hasOwnProperty.call(source, innerKey)) {\n            continue;\n        }\n        // Recursively walk through all the child nodes\n        acc[innerKey] = walk(innerKey, source[innerKey], depth - 1, memo);\n    }\n    // Once walked through all the branches, remove the parent from memo storage\n    memo.unmemoize(value);\n    // Return accumulated values\n    return acc;\n}\n/**\n * normalize()\n *\n * - Creates a copy to prevent original input mutation\n * - Skip non-enumerablers\n * - Calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializeable values (undefined/NaN/Functions) to serializable format\n * - Translates known global objects/Classes to a string representations\n * - Takes care of Error objects serialization\n * - Optionally limit depth of final output\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function normalize(input, depth) {\n    try {\n        return JSON.parse(JSON.stringify(input, function (key, value) { return walk(key, value, depth); }));\n    }\n    catch (_oO) {\n        return '**non-serializable**';\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 */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function extractExceptionKeysForMessage(exception, maxLength) {\n    if (maxLength === void 0) { maxLength = 40; }\n    var keys = Object.keys(getWalkSource(exception));\n    keys.sort();\n    if (!keys.length) {\n        return '[object has no keys]';\n    }\n    if (keys[0].length >= maxLength) {\n        return truncate(keys[0], maxLength);\n    }\n    for (var 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    return '';\n}\n/**\n * Given any object, return the new object with removed keys that value was `undefined`.\n * Works recursively on objects and arrays.\n */\nexport function dropUndefinedKeys(val) {\n    var e_1, _a;\n    if (isPlainObject(val)) {\n        var obj = val;\n        var rv = {};\n        try {\n            for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {\n                var key = _c.value;\n                if (typeof obj[key] !== 'undefined') {\n                    rv[key] = dropUndefinedKeys(obj[key]);\n                }\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        return rv;\n    }\n    if (Array.isArray(val)) {\n        return val.map(dropUndefinedKeys);\n    }\n    return val;\n}\n//# sourceMappingURL=object.js.map","import { isString } from './is';\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 */\nexport function htmlTreeAsString(elem) {\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        var currentElem = elem;\n        var MAX_TRAVERSE_HEIGHT = 5;\n        var MAX_OUTPUT_LEN = 80;\n        var out = [];\n        var height = 0;\n        var len = 0;\n        var separator = ' > ';\n        var sepLength = separator.length;\n        var nextStr = void 0;\n        // eslint-disable-next-line no-plusplus\n        while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n            nextStr = _htmlElementAsString(currentElem);\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            out.push(nextStr);\n            len += nextStr.length;\n            currentElem = currentElem.parentNode;\n        }\n        return out.reverse().join(separator);\n    }\n    catch (_oO) {\n        return '<unknown>';\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) {\n    var elem = el;\n    var out = [];\n    var className;\n    var classes;\n    var key;\n    var attr;\n    var i;\n    if (!elem || !elem.tagName) {\n        return '';\n    }\n    out.push(elem.tagName.toLowerCase());\n    if (elem.id) {\n        out.push(\"#\" + elem.id);\n    }\n    // eslint-disable-next-line prefer-const\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    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//# sourceMappingURL=browser.js.map","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/**\n * Memo class used for decycle json objects. Uses WeakSet if available otherwise array.\n */\nvar Memo = /** @class */ (function () {\n    function Memo() {\n        this._hasWeakSet = typeof WeakSet === 'function';\n        this._inner = this._hasWeakSet ? new WeakSet() : [];\n    }\n    /**\n     * Sets obj to remember.\n     * @param obj Object to remember\n     */\n    Memo.prototype.memoize = function (obj) {\n        if (this._hasWeakSet) {\n            if (this._inner.has(obj)) {\n                return true;\n            }\n            this._inner.add(obj);\n            return false;\n        }\n        // eslint-disable-next-line @typescript-eslint/prefer-for-of\n        for (var i = 0; i < this._inner.length; i++) {\n            var value = this._inner[i];\n            if (value === obj) {\n                return true;\n            }\n        }\n        this._inner.push(obj);\n        return false;\n    };\n    /**\n     * Removes object from internal storage.\n     * @param obj Object to forget\n     */\n    Memo.prototype.unmemoize = function (obj) {\n        if (this._hasWeakSet) {\n            this._inner.delete(obj);\n        }\n        else {\n            for (var i = 0; i < this._inner.length; i++) {\n                if (this._inner[i] === obj) {\n                    this._inner.splice(i, 1);\n                    break;\n                }\n            }\n        }\n    };\n    return Memo;\n}());\nexport { Memo };\n//# sourceMappingURL=memo.js.map","import { getGlobalObject } from './misc';\nimport { dynamicRequire, isNodeEnv } from './node';\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: function () { return Date.now() / 1000; },\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    var performance = getGlobalObject().performance;\n    if (!performance || !performance.now) {\n        return undefined;\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    return {\n        now: function () { return performance.now(); },\n        timeOrigin: timeOrigin,\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    }\n    catch (_) {\n        return undefined;\n    }\n}\n/**\n * The Performance API implementation for the current platform, if available.\n */\nvar platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\nvar timestampSource = platformPerformance === undefined\n    ? dateTimestampSource\n    : {\n        nowSeconds: function () { return (platformPerformance.timeOrigin + platformPerformance.now()) / 1000; },\n    };\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nexport var dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\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 */\nexport var timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);\n// Re-exported with an old name for backwards-compatibility.\nexport var timestampWithMs = timestampInSeconds;\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nexport var usingPerformanceAPI = platformPerformance !== undefined;\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n */\nexport var _browserPerformanceTimeOriginMode;\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 */\nexport var browserPerformanceTimeOrigin = (function () {\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    var performance = getGlobalObject().performance;\n    if (!performance) {\n        _browserPerformanceTimeOriginMode = 'none';\n        return undefined;\n    }\n    var threshold = 3600 * 1000;\n    var performanceNow = performance.now();\n    var dateNow = Date.now();\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    // 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    // eslint-disable-next-line deprecation/deprecation\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    if (timeOriginIsReliable || navigationStartIsReliable) {\n        // Use the more reliable time origin\n        if (timeOriginDelta <= navigationStartDelta) {\n            _browserPerformanceTimeOriginMode = 'timeOrigin';\n            return performance.timeOrigin;\n        }\n        else {\n            _browserPerformanceTimeOriginMode = 'navigationStart';\n            return navigationStart;\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//# sourceMappingURL=time.js.map","/** JSDoc */\n// eslint-disable-next-line import/export\nexport var Severity;\n(function (Severity) {\n    /** JSDoc */\n    Severity[\"Fatal\"] = \"fatal\";\n    /** JSDoc */\n    Severity[\"Error\"] = \"error\";\n    /** JSDoc */\n    Severity[\"Warning\"] = \"warning\";\n    /** JSDoc */\n    Severity[\"Log\"] = \"log\";\n    /** JSDoc */\n    Severity[\"Info\"] = \"info\";\n    /** JSDoc */\n    Severity[\"Debug\"] = \"debug\";\n    /** JSDoc */\n    Severity[\"Critical\"] = \"critical\";\n})(Severity || (Severity = {}));\n// eslint-disable-next-line @typescript-eslint/no-namespace, import/export\n(function (Severity) {\n    /**\n     * Converts a string-based level into a {@link Severity}.\n     *\n     * @param level string representation of Severity\n     * @returns Severity\n     */\n    function fromString(level) {\n        switch (level) {\n            case 'debug':\n                return Severity.Debug;\n            case 'info':\n                return Severity.Info;\n            case 'warn':\n            case 'warning':\n                return Severity.Warning;\n            case 'error':\n                return Severity.Error;\n            case 'fatal':\n                return Severity.Fatal;\n            case 'critical':\n                return Severity.Critical;\n            case 'log':\n            default:\n                return Severity.Log;\n        }\n    }\n    Severity.fromString = fromString;\n})(Severity || (Severity = {}));\n//# sourceMappingURL=severity.js.map","/** The status of an event. */\n// eslint-disable-next-line import/export\nexport var Status;\n(function (Status) {\n    /** The status could not be determined. */\n    Status[\"Unknown\"] = \"unknown\";\n    /** The event was skipped due to configuration or callbacks. */\n    Status[\"Skipped\"] = \"skipped\";\n    /** The event was sent to Sentry successfully. */\n    Status[\"Success\"] = \"success\";\n    /** The client is currently rate limited and will try again later. */\n    Status[\"RateLimit\"] = \"rate_limit\";\n    /** The event could not be processed. */\n    Status[\"Invalid\"] = \"invalid\";\n    /** A server-side error ocurred during submission. */\n    Status[\"Failed\"] = \"failed\";\n})(Status || (Status = {}));\n// eslint-disable-next-line @typescript-eslint/no-namespace, import/export\n(function (Status) {\n    /**\n     * Converts a HTTP status code into a {@link Status}.\n     *\n     * @param code The HTTP response status code.\n     * @returns The send status or {@link Status.Unknown}.\n     */\n    function fromHttpCode(code) {\n        if (code >= 200 && code < 300) {\n            return Status.Success;\n        }\n        if (code === 429) {\n            return Status.RateLimit;\n        }\n        if (code >= 400 && code < 500) {\n            return Status.Invalid;\n        }\n        if (code >= 500) {\n            return Status.Failed;\n        }\n        return Status.Unknown;\n    }\n    Status.fromHttpCode = fromHttpCode;\n})(Status || (Status = {}));\n//# sourceMappingURL=status.js.map","/* eslint-disable @typescript-eslint/explicit-function-return-type */\n/* eslint-disable @typescript-eslint/typedef */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { isThenable } from './is';\n/** SyncPromise internal states */\nvar States;\n(function (States) {\n    /** Pending */\n    States[\"PENDING\"] = \"PENDING\";\n    /** Resolved / OK */\n    States[\"RESOLVED\"] = \"RESOLVED\";\n    /** Rejected / Error */\n    States[\"REJECTED\"] = \"REJECTED\";\n})(States || (States = {}));\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nvar SyncPromise = /** @class */ (function () {\n    function SyncPromise(executor) {\n        var _this = this;\n        this._state = States.PENDING;\n        this._handlers = [];\n        /** JSDoc */\n        this._resolve = function (value) {\n            _this._setResult(States.RESOLVED, value);\n        };\n        /** JSDoc */\n        this._reject = function (reason) {\n            _this._setResult(States.REJECTED, reason);\n        };\n        /** JSDoc */\n        this._setResult = function (state, value) {\n            if (_this._state !== States.PENDING) {\n                return;\n            }\n            if (isThenable(value)) {\n                value.then(_this._resolve, _this._reject);\n                return;\n            }\n            _this._state = state;\n            _this._value = value;\n            _this._executeHandlers();\n        };\n        // TODO: FIXME\n        /** JSDoc */\n        this._attachHandler = function (handler) {\n            _this._handlers = _this._handlers.concat(handler);\n            _this._executeHandlers();\n        };\n        /** JSDoc */\n        this._executeHandlers = function () {\n            if (_this._state === States.PENDING) {\n                return;\n            }\n            var cachedHandlers = _this._handlers.slice();\n            _this._handlers = [];\n            cachedHandlers.forEach(function (handler) {\n                if (handler.done) {\n                    return;\n                }\n                if (_this._state === States.RESOLVED) {\n                    if (handler.onfulfilled) {\n                        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n                        handler.onfulfilled(_this._value);\n                    }\n                }\n                if (_this._state === States.REJECTED) {\n                    if (handler.onrejected) {\n                        handler.onrejected(_this._value);\n                    }\n                }\n                handler.done = true;\n            });\n        };\n        try {\n            executor(this._resolve, this._reject);\n        }\n        catch (e) {\n            this._reject(e);\n        }\n    }\n    /** JSDoc */\n    SyncPromise.resolve = function (value) {\n        return new SyncPromise(function (resolve) {\n            resolve(value);\n        });\n    };\n    /** JSDoc */\n    SyncPromise.reject = function (reason) {\n        return new SyncPromise(function (_, reject) {\n            reject(reason);\n        });\n    };\n    /** JSDoc */\n    SyncPromise.all = function (collection) {\n        return new SyncPromise(function (resolve, reject) {\n            if (!Array.isArray(collection)) {\n                reject(new TypeError(\"Promise.all requires an array as input.\"));\n                return;\n            }\n            if (collection.length === 0) {\n                resolve([]);\n                return;\n            }\n            var counter = collection.length;\n            var resolvedCollection = [];\n            collection.forEach(function (item, index) {\n                SyncPromise.resolve(item)\n                    .then(function (value) {\n                    resolvedCollection[index] = value;\n                    counter -= 1;\n                    if (counter !== 0) {\n                        return;\n                    }\n                    resolve(resolvedCollection);\n                })\n                    .then(null, reject);\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.then = function (onfulfilled, onrejected) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            _this._attachHandler({\n                done: false,\n                onfulfilled: function (result) {\n                    if (!onfulfilled) {\n                        // TODO: ¯\\_(ツ)_/¯\n                        // TODO: FIXME\n                        resolve(result);\n                        return;\n                    }\n                    try {\n                        resolve(onfulfilled(result));\n                        return;\n                    }\n                    catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n                onrejected: function (reason) {\n                    if (!onrejected) {\n                        reject(reason);\n                        return;\n                    }\n                    try {\n                        resolve(onrejected(reason));\n                        return;\n                    }\n                    catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.catch = function (onrejected) {\n        return this.then(function (val) { return val; }, onrejected);\n    };\n    /** JSDoc */\n    SyncPromise.prototype.finally = function (onfinally) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            var val;\n            var isRejected;\n            return _this.then(function (value) {\n                isRejected = false;\n                val = value;\n                if (onfinally) {\n                    onfinally();\n                }\n            }, function (reason) {\n                isRejected = true;\n                val = reason;\n                if (onfinally) {\n                    onfinally();\n                }\n            }).then(function () {\n                if (isRejected) {\n                    reject(val);\n                    return;\n                }\n                resolve(val);\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.toString = function () {\n        return '[object SyncPromise]';\n    };\n    return SyncPromise;\n}());\nexport { SyncPromise };\n//# sourceMappingURL=syncpromise.js.map","/**\n * Session Status\n */\nexport var SessionStatus;\n(function (SessionStatus) {\n    /** JSDoc */\n    SessionStatus[\"Ok\"] = \"ok\";\n    /** JSDoc */\n    SessionStatus[\"Exited\"] = \"exited\";\n    /** JSDoc */\n    SessionStatus[\"Crashed\"] = \"crashed\";\n    /** JSDoc */\n    SessionStatus[\"Abnormal\"] = \"abnormal\";\n})(SessionStatus || (SessionStatus = {}));\nexport var RequestSessionStatus;\n(function (RequestSessionStatus) {\n    /** JSDoc */\n    RequestSessionStatus[\"Ok\"] = \"ok\";\n    /** JSDoc */\n    RequestSessionStatus[\"Errored\"] = \"errored\";\n    /** JSDoc */\n    RequestSessionStatus[\"Crashed\"] = \"crashed\";\n})(RequestSessionStatus || (RequestSessionStatus = {}));\n//# sourceMappingURL=session.js.map","import { __assign, __read, __spread } from \"tslib\";\nimport { dateTimestampInSeconds, getGlobalObject, isPlainObject, isThenable, SyncPromise } from '@sentry/utils';\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nvar Scope = /** @class */ (function () {\n    function Scope() {\n        /** Flag if notifiying is happening. */\n        this._notifyingListeners = false;\n        /** Callback for client to receive scope changes. */\n        this._scopeListeners = [];\n        /** Callback list that will be called after {@link applyToEvent}. */\n        this._eventProcessors = [];\n        /** Array of breadcrumbs. */\n        this._breadcrumbs = [];\n        /** User */\n        this._user = {};\n        /** Tags */\n        this._tags = {};\n        /** Extra */\n        this._extra = {};\n        /** Contexts */\n        this._contexts = {};\n    }\n    /**\n     * Inherit values from the parent scope.\n     * @param scope to clone.\n     */\n    Scope.clone = function (scope) {\n        var newScope = new Scope();\n        if (scope) {\n            newScope._breadcrumbs = __spread(scope._breadcrumbs);\n            newScope._tags = __assign({}, scope._tags);\n            newScope._extra = __assign({}, scope._extra);\n            newScope._contexts = __assign({}, 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 = __spread(scope._eventProcessors);\n            newScope._requestSession = scope._requestSession;\n        }\n        return newScope;\n    };\n    /**\n     * Add internal on change listener. Used for sub SDKs that need to store the scope.\n     * @hidden\n     */\n    Scope.prototype.addScopeListener = function (callback) {\n        this._scopeListeners.push(callback);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addEventProcessor = function (callback) {\n        this._eventProcessors.push(callback);\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setUser = function (user) {\n        this._user = user || {};\n        if (this._session) {\n            this._session.update({ user: user });\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getUser = function () {\n        return this._user;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getRequestSession = function () {\n        return this._requestSession;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setRequestSession = function (requestSession) {\n        this._requestSession = requestSession;\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTags = function (tags) {\n        this._tags = __assign(__assign({}, this._tags), tags);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTag = function (key, value) {\n        var _a;\n        this._tags = __assign(__assign({}, this._tags), (_a = {}, _a[key] = value, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtras = function (extras) {\n        this._extra = __assign(__assign({}, this._extra), extras);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtra = function (key, extra) {\n        var _a;\n        this._extra = __assign(__assign({}, this._extra), (_a = {}, _a[key] = extra, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setFingerprint = function (fingerprint) {\n        this._fingerprint = fingerprint;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setLevel = function (level) {\n        this._level = level;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTransactionName = function (name) {\n        this._transactionName = name;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Can be removed in major version.\n     * @deprecated in favor of {@link this.setTransactionName}\n     */\n    Scope.prototype.setTransaction = function (name) {\n        return this.setTransactionName(name);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setContext = function (key, context) {\n        var _a;\n        if (context === null) {\n            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n            delete this._contexts[key];\n        }\n        else {\n            this._contexts = __assign(__assign({}, this._contexts), (_a = {}, _a[key] = context, _a));\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSpan = function (span) {\n        this._span = span;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getSpan = function () {\n        return this._span;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getTransaction = function () {\n        var _a, _b, _c, _d;\n        // often, this span will be a transaction, but it's not guaranteed to be\n        var span = this.getSpan();\n        // try it the new way first\n        if ((_a = span) === null || _a === void 0 ? void 0 : _a.transaction) {\n            return (_b = span) === null || _b === void 0 ? void 0 : _b.transaction;\n        }\n        // fallback to the old way (known bug: this only finds transactions with sampled = true)\n        if ((_d = (_c = span) === null || _c === void 0 ? void 0 : _c.spanRecorder) === null || _d === void 0 ? void 0 : _d.spans[0]) {\n            return span.spanRecorder.spans[0];\n        }\n        // neither way found a transaction\n        return undefined;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSession = function (session) {\n        if (!session) {\n            delete this._session;\n        }\n        else {\n            this._session = session;\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getSession = function () {\n        return this._session;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.update = function (captureContext) {\n        if (!captureContext) {\n            return this;\n        }\n        if (typeof captureContext === 'function') {\n            var updatedScope = captureContext(this);\n            return updatedScope instanceof Scope ? updatedScope : this;\n        }\n        if (captureContext instanceof Scope) {\n            this._tags = __assign(__assign({}, this._tags), captureContext._tags);\n            this._extra = __assign(__assign({}, this._extra), captureContext._extra);\n            this._contexts = __assign(__assign({}, 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        }\n        else if (isPlainObject(captureContext)) {\n            // eslint-disable-next-line no-param-reassign\n            captureContext = captureContext;\n            this._tags = __assign(__assign({}, this._tags), captureContext.tags);\n            this._extra = __assign(__assign({}, this._extra), captureContext.extra);\n            this._contexts = __assign(__assign({}, 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        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clear = function () {\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        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {\n        var mergedBreadcrumb = __assign({ timestamp: dateTimestampInSeconds() }, breadcrumb);\n        this._breadcrumbs =\n            maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0\n                ? __spread(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxBreadcrumbs)\n                : __spread(this._breadcrumbs, [mergedBreadcrumb]);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clearBreadcrumbs = function () {\n        this._breadcrumbs = [];\n        this._notifyScopeListeners();\n        return this;\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 informartion about the original exception.\n     * @hidden\n     */\n    Scope.prototype.applyToEvent = function (event, hint) {\n        var _a;\n        if (this._extra && Object.keys(this._extra).length) {\n            event.extra = __assign(__assign({}, this._extra), event.extra);\n        }\n        if (this._tags && Object.keys(this._tags).length) {\n            event.tags = __assign(__assign({}, this._tags), event.tags);\n        }\n        if (this._user && Object.keys(this._user).length) {\n            event.user = __assign(__assign({}, this._user), event.user);\n        }\n        if (this._contexts && Object.keys(this._contexts).length) {\n            event.contexts = __assign(__assign({}, 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        // 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 relys on that.\n        if (this._span) {\n            event.contexts = __assign({ trace: this._span.getTraceContext() }, event.contexts);\n            var transactionName = (_a = this._span.transaction) === null || _a === void 0 ? void 0 : _a.name;\n            if (transactionName) {\n                event.tags = __assign({ transaction: transactionName }, event.tags);\n            }\n        }\n        this._applyFingerprint(event);\n        event.breadcrumbs = __spread((event.breadcrumbs || []), this._breadcrumbs);\n        event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n        return this._notifyEventProcessors(__spread(getGlobalEventProcessors(), this._eventProcessors), event, hint);\n    };\n    /**\n     * This will be called after {@link applyToEvent} is finished.\n     */\n    Scope.prototype._notifyEventProcessors = function (processors, event, hint, index) {\n        var _this = this;\n        if (index === void 0) { index = 0; }\n        return new SyncPromise(function (resolve, reject) {\n            var processor = processors[index];\n            if (event === null || typeof processor !== 'function') {\n                resolve(event);\n            }\n            else {\n                var result = processor(__assign({}, event), hint);\n                if (isThenable(result)) {\n                    result\n                        .then(function (final) { return _this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve); })\n                        .then(null, reject);\n                }\n                else {\n                    _this._notifyEventProcessors(processors, result, hint, index + 1)\n                        .then(resolve)\n                        .then(null, reject);\n                }\n            }\n        });\n    };\n    /**\n     * This will be called on every set call.\n     */\n    Scope.prototype._notifyScopeListeners = function () {\n        var _this = this;\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(function (callback) {\n                callback(_this);\n            });\n            this._notifyingListeners = false;\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    Scope.prototype._applyFingerprint = function (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        // 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        // 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    return Scope;\n}());\nexport { Scope };\n/**\n * Retruns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n    /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access  */\n    var global = getGlobalObject();\n    global.__SENTRY__ = global.__SENTRY__ || {};\n    global.__SENTRY__.globalEventProcessors = global.__SENTRY__.globalEventProcessors || [];\n    return global.__SENTRY__.globalEventProcessors;\n    /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */\n}\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nexport function addGlobalEventProcessor(callback) {\n    getGlobalEventProcessors().push(callback);\n}\n//# sourceMappingURL=scope.js.map","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { consoleSandbox, getGlobalObject } from './misc';\n// TODO: Implement different loggers for different environments\nvar global = getGlobalObject();\n/** Prefix for logging strings */\nvar PREFIX = 'Sentry Logger ';\n/** JSDoc */\nvar Logger = /** @class */ (function () {\n    /** JSDoc */\n    function Logger() {\n        this._enabled = false;\n    }\n    /** JSDoc */\n    Logger.prototype.disable = function () {\n        this._enabled = false;\n    };\n    /** JSDoc */\n    Logger.prototype.enable = function () {\n        this._enabled = true;\n    };\n    /** JSDoc */\n    Logger.prototype.log = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.log(PREFIX + \"[Log]: \" + args.join(' '));\n        });\n    };\n    /** JSDoc */\n    Logger.prototype.warn = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.warn(PREFIX + \"[Warn]: \" + args.join(' '));\n        });\n    };\n    /** JSDoc */\n    Logger.prototype.error = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.error(PREFIX + \"[Error]: \" + args.join(' '));\n        });\n    };\n    return Logger;\n}());\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nglobal.__SENTRY__ = global.__SENTRY__ || {};\nvar logger = global.__SENTRY__.logger || (global.__SENTRY__.logger = new Logger());\nexport { logger };\n//# sourceMappingURL=logger.js.map","import { RequestSessionStatus, SessionStatus, } from '@sentry/types';\nimport { dropUndefinedKeys, logger, uuid4 } from '@sentry/utils';\nimport { getCurrentHub } from './hub';\n/**\n * @inheritdoc\n */\nvar Session = /** @class */ (function () {\n    function Session(context) {\n        this.errors = 0;\n        this.sid = uuid4();\n        this.timestamp = Date.now();\n        this.started = Date.now();\n        this.duration = 0;\n        this.status = SessionStatus.Ok;\n        this.init = true;\n        if (context) {\n            this.update(context);\n        }\n    }\n    /** JSDoc */\n    // eslint-disable-next-line complexity\n    Session.prototype.update = function (context) {\n        if (context === void 0) { context = {}; }\n        if (context.user) {\n            if (context.user.ip_address) {\n                this.ipAddress = context.user.ip_address;\n            }\n            if (!context.did) {\n                this.did = context.user.id || context.user.email || context.user.username;\n            }\n        }\n        this.timestamp = context.timestamp || Date.now();\n        if (context.sid) {\n            // Good enough uuid validation. — Kamil\n            this.sid = context.sid.length === 32 ? context.sid : uuid4();\n        }\n        if (context.init !== undefined) {\n            this.init = context.init;\n        }\n        if (context.did) {\n            this.did = \"\" + context.did;\n        }\n        if (typeof context.started === 'number') {\n            this.started = context.started;\n        }\n        if (typeof context.duration === 'number') {\n            this.duration = context.duration;\n        }\n        else {\n            this.duration = this.timestamp - this.started;\n        }\n        if (context.release) {\n            this.release = context.release;\n        }\n        if (context.environment) {\n            this.environment = context.environment;\n        }\n        if (context.ipAddress) {\n            this.ipAddress = context.ipAddress;\n        }\n        if (context.userAgent) {\n            this.userAgent = context.userAgent;\n        }\n        if (typeof context.errors === 'number') {\n            this.errors = context.errors;\n        }\n        if (context.status) {\n            this.status = context.status;\n        }\n    };\n    /** JSDoc */\n    Session.prototype.close = function (status) {\n        if (status) {\n            this.update({ status: status });\n        }\n        else if (this.status === SessionStatus.Ok) {\n            this.update({ status: SessionStatus.Exited });\n        }\n        else {\n            this.update();\n        }\n    };\n    /** JSDoc */\n    Session.prototype.toJSON = function () {\n        return dropUndefinedKeys({\n            sid: \"\" + this.sid,\n            init: this.init,\n            started: new Date(this.started).toISOString(),\n            timestamp: new Date(this.timestamp).toISOString(),\n            status: this.status,\n            errors: this.errors,\n            did: typeof this.did === 'number' || typeof this.did === 'string' ? \"\" + this.did : undefined,\n            duration: this.duration,\n            attrs: dropUndefinedKeys({\n                release: this.release,\n                environment: this.environment,\n                ip_address: this.ipAddress,\n                user_agent: this.userAgent,\n            }),\n        });\n    };\n    return Session;\n}());\nexport { Session };\n/**\n * @inheritdoc\n */\nvar SessionFlusher = /** @class */ (function () {\n    function SessionFlusher(transport, attrs) {\n        var _this = this;\n        this.flushTimeout = 60;\n        this._pendingAggregates = {};\n        this._isEnabled = true;\n        this._transport = transport;\n        // Call to setInterval, so that flush is called every 60 seconds\n        this._intervalId = setInterval(function () { return _this.flush(); }, this.flushTimeout * 1000);\n        this._sessionAttrs = attrs;\n    }\n    /** Sends session aggregates to Transport */\n    SessionFlusher.prototype.sendSessionAggregates = function (sessionAggregates) {\n        if (!this._transport.sendSession) {\n            logger.warn(\"Dropping session because custom transport doesn't implement sendSession\");\n            return;\n        }\n        this._transport.sendSession(sessionAggregates).then(null, function (reason) {\n            logger.error(\"Error while sending session: \" + reason);\n        });\n    };\n    /** Checks if `pendingAggregates` has entries, and if it does flushes them by calling `sendSessions` */\n    SessionFlusher.prototype.flush = function () {\n        var sessionAggregates = this.getSessionAggregates();\n        if (sessionAggregates.aggregates.length === 0) {\n            return;\n        }\n        this._pendingAggregates = {};\n        this.sendSessionAggregates(sessionAggregates);\n    };\n    /** Massages the entries in `pendingAggregates` and returns aggregated sessions */\n    SessionFlusher.prototype.getSessionAggregates = function () {\n        var _this = this;\n        var aggregates = Object.keys(this._pendingAggregates).map(function (key) {\n            return _this._pendingAggregates[parseInt(key)];\n        });\n        var sessionAggregates = {\n            attrs: this._sessionAttrs,\n            aggregates: aggregates,\n        };\n        return dropUndefinedKeys(sessionAggregates);\n    };\n    /** JSDoc */\n    SessionFlusher.prototype.close = function () {\n        clearInterval(this._intervalId);\n        this._isEnabled = false;\n        this.flush();\n    };\n    /**\n     * Wrapper function for _incrementSessionStatusCount that checks if the instance of SessionFlusher is enabled then\n     * fetches the session status of the request from `Scope.getRequestSession().status` on the scope and passes them to\n     * `_incrementSessionStatusCount` along with the start date\n     */\n    SessionFlusher.prototype.incrementSessionStatusCount = function () {\n        var _a, _b;\n        if (!this._isEnabled) {\n            return;\n        }\n        var scope = getCurrentHub().getScope();\n        var requestSession = (_a = scope) === null || _a === void 0 ? void 0 : _a.getRequestSession();\n        if (requestSession && requestSession.status) {\n            this._incrementSessionStatusCount(requestSession.status, new Date());\n            // This is not entirely necessarily but is added as a safe guard to indicate the bounds of a request and so in\n            // case captureRequestSession is called more than once to prevent double count\n            (_b = scope) === null || _b === void 0 ? void 0 : _b.setRequestSession(undefined);\n            /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n        }\n    };\n    /**\n     * Increments status bucket in pendingAggregates buffer (internal state) corresponding to status of\n     * the session received\n     */\n    SessionFlusher.prototype._incrementSessionStatusCount = function (status, date) {\n        // Truncate minutes and seconds on Session Started attribute to have one minute bucket keys\n        var sessionStartedTrunc = new Date(date).setSeconds(0, 0);\n        this._pendingAggregates[sessionStartedTrunc] = this._pendingAggregates[sessionStartedTrunc] || {};\n        // corresponds to aggregated sessions in one specific minute bucket\n        // for example, {\"started\":\"2021-03-16T08:00:00.000Z\",\"exited\":4, \"errored\": 1}\n        var aggregationCounts = this._pendingAggregates[sessionStartedTrunc];\n        if (!aggregationCounts.started) {\n            aggregationCounts.started = new Date(sessionStartedTrunc).toISOString();\n        }\n        switch (status) {\n            case RequestSessionStatus.Errored:\n                aggregationCounts.errored = (aggregationCounts.errored || 0) + 1;\n                return aggregationCounts.errored;\n            case RequestSessionStatus.Ok:\n                aggregationCounts.exited = (aggregationCounts.exited || 0) + 1;\n                return aggregationCounts.exited;\n            case RequestSessionStatus.Crashed:\n                aggregationCounts.crashed = (aggregationCounts.crashed || 0) + 1;\n                return aggregationCounts.crashed;\n        }\n    };\n    return SessionFlusher;\n}());\nexport { SessionFlusher };\n//# sourceMappingURL=session.js.map","import { __assign, __read, __spread } from \"tslib\";\n/* eslint-disable max-lines */\nimport { SessionStatus, } from '@sentry/types';\nimport { consoleSandbox, dateTimestampInSeconds, getGlobalObject, isNodeEnv, logger, uuid4 } from '@sentry/utils';\nimport { Scope } from './scope';\nimport { Session } from './session';\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 */\nexport var API_VERSION = 4;\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 * Absolute maximum number of breadcrumbs added to an event. The\n * `maxBreadcrumbs` option cannot be higher than this value.\n */\nvar MAX_BREADCRUMBS = 100;\n/**\n * @inheritDoc\n */\nvar Hub = /** @class */ (function () {\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    function Hub(client, scope, _version) {\n        if (scope === void 0) { scope = new Scope(); }\n        if (_version === void 0) { _version = API_VERSION; }\n        this._version = _version;\n        /** Is a {@link Layer}[] containing the client and scope */\n        this._stack = [{}];\n        this.getStackTop().scope = scope;\n        this.bindClient(client);\n    }\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.isOlderThan = function (version) {\n        return this._version < version;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.bindClient = function (client) {\n        var top = this.getStackTop();\n        top.client = client;\n        if (client && client.setupIntegrations) {\n            client.setupIntegrations();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.pushScope = function () {\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: scope,\n        });\n        return scope;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.popScope = function () {\n        if (this.getStack().length <= 1)\n            return false;\n        return !!this.getStack().pop();\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.withScope = function (callback) {\n        var scope = this.pushScope();\n        try {\n            callback(scope);\n        }\n        finally {\n            this.popScope();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getClient = function () {\n        return this.getStackTop().client;\n    };\n    /** Returns the scope of the top stack. */\n    Hub.prototype.getScope = function () {\n        return this.getStackTop().scope;\n    };\n    /** Returns the scope stack for domains or the process. */\n    Hub.prototype.getStack = function () {\n        return this._stack;\n    };\n    /** Returns the topmost scope layer in the order domain > local > process. */\n    Hub.prototype.getStackTop = function () {\n        return this._stack[this._stack.length - 1];\n    };\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    Hub.prototype.captureException = function (exception, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error('Sentry syntheticException');\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: exception,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureException', exception, __assign(__assign({}, finalHint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureMessage = function (message, level, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error(message);\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: message,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureMessage', message, level, __assign(__assign({}, finalHint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureEvent = function (event, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        this._invokeClient('captureEvent', event, __assign(__assign({}, hint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.lastEventId = function () {\n        return this._lastEventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.addBreadcrumb = function (breadcrumb, hint) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (!scope || !client)\n            return;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var _b = (client.getOptions && client.getOptions()) || {}, _c = _b.beforeBreadcrumb, beforeBreadcrumb = _c === void 0 ? null : _c, _d = _b.maxBreadcrumbs, maxBreadcrumbs = _d === void 0 ? DEFAULT_BREADCRUMBS : _d;\n        if (maxBreadcrumbs <= 0)\n            return;\n        var timestamp = dateTimestampInSeconds();\n        var mergedBreadcrumb = __assign({ timestamp: timestamp }, breadcrumb);\n        var finalBreadcrumb = beforeBreadcrumb\n            ? consoleSandbox(function () { return beforeBreadcrumb(mergedBreadcrumb, hint); })\n            : mergedBreadcrumb;\n        if (finalBreadcrumb === null)\n            return;\n        scope.addBreadcrumb(finalBreadcrumb, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setUser = function (user) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setUser(user);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTags = function (tags) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setTags(tags);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtras = function (extras) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setExtras(extras);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTag = function (key, value) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setTag(key, value);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtra = function (key, extra) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setExtra(key, extra);\n    };\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype.setContext = function (name, context) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setContext(name, context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.configureScope = function (callback) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (scope && client) {\n            callback(scope);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.run = function (callback) {\n        var oldHub = makeMain(this);\n        try {\n            callback(this);\n        }\n        finally {\n            makeMain(oldHub);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getIntegration = function (integration) {\n        var client = this.getClient();\n        if (!client)\n            return null;\n        try {\n            return client.getIntegration(integration);\n        }\n        catch (_oO) {\n            logger.warn(\"Cannot retrieve integration \" + integration.id + \" from the current Hub\");\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSpan = function (context) {\n        return this._callExtensionMethod('startSpan', context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startTransaction = function (context, customSamplingContext) {\n        return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.traceHeaders = function () {\n        return this._callExtensionMethod('traceHeaders');\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureSession = function (endSession) {\n        if (endSession === void 0) { endSession = false; }\n        // both send the update and pull the session from the scope\n        if (endSession) {\n            return this.endSession();\n        }\n        // only send the update\n        this._sendSessionUpdate();\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.endSession = function () {\n        var _a, _b, _c, _d, _e;\n        (_c = (_b = (_a = this.getStackTop()) === null || _a === void 0 ? void 0 : _a.scope) === null || _b === void 0 ? void 0 : _b.getSession()) === null || _c === void 0 ? void 0 : _c.close();\n        this._sendSessionUpdate();\n        // the session is over; take it off of the scope\n        (_e = (_d = this.getStackTop()) === null || _d === void 0 ? void 0 : _d.scope) === null || _e === void 0 ? void 0 : _e.setSession();\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSession = function (context) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        var _b = (client && client.getOptions()) || {}, release = _b.release, environment = _b.environment;\n        var session = new Session(__assign(__assign({ release: release,\n            environment: environment }, (scope && { user: scope.getUser() })), context));\n        if (scope) {\n            // End existing session if there's one\n            var currentSession = scope.getSession && scope.getSession();\n            if (currentSession && currentSession.status === SessionStatus.Ok) {\n                currentSession.update({ status: SessionStatus.Exited });\n            }\n            this.endSession();\n            // Afterwards we set the new session on the scope\n            scope.setSession(session);\n        }\n        return session;\n    };\n    /**\n     * Sends the current Session on the scope\n     */\n    Hub.prototype._sendSessionUpdate = function () {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (!scope)\n            return;\n        var session = scope.getSession && scope.getSession();\n        if (session) {\n            if (client && client.captureSession) {\n                client.captureSession(session);\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    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype._invokeClient = function (method) {\n        var _a;\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var _b = this.getStackTop(), scope = _b.scope, client = _b.client;\n        if (client && client[method]) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any\n            (_a = client)[method].apply(_a, __spread(args, [scope]));\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    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype._callExtensionMethod = function (method) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\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        logger.warn(\"Extension method \" + method + \" couldn't be found, doing nothing.\");\n    };\n    return Hub;\n}());\nexport { Hub };\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 **/\nexport function getMainCarrier() {\n    var carrier = getGlobalObject();\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {\n        extensions: {},\n        hub: undefined,\n    };\n    return carrier;\n}\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nexport function makeMain(hub) {\n    var registry = getMainCarrier();\n    var oldHub = getHubFromCarrier(registry);\n    setHubOnCarrier(registry, hub);\n    return oldHub;\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 */\nexport function getCurrentHub() {\n    // Get main carrier (global for every environment)\n    var registry = getMainCarrier();\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    // 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 * Returns the active domain, if one exists\n * @deprecated No longer used; remove in v7\n * @returns The domain, or undefined if there is no active domain\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function getActiveDomain() {\n    logger.warn('Function `getActiveDomain` is deprecated and will be removed in a future version.');\n    var sentry = getMainCarrier().__SENTRY__;\n    return sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\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    var _a, _b, _c;\n    try {\n        var activeDomain = (_c = (_b = (_a = getMainCarrier().__SENTRY__) === null || _a === void 0 ? void 0 : _a.extensions) === null || _b === void 0 ? void 0 : _b.domain) === null || _c === void 0 ? void 0 : _c.active;\n        // If there's no active domain, just return global hub\n        if (!activeDomain) {\n            return getHubFromCarrier(registry);\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        // Return hub that lives on a domain\n        return getHubFromCarrier(activeDomain);\n    }\n    catch (_Oo) {\n        // Return hub that lives on a global object\n        return getHubFromCarrier(registry);\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 * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nexport function getHubFromCarrier(carrier) {\n    if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub)\n        return carrier.__SENTRY__.hub;\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = new Hub();\n    return carrier.__SENTRY__.hub;\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 */\nexport function setHubOnCarrier(carrier, hub) {\n    if (!carrier)\n        return false;\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = hub;\n    return true;\n}\n//# sourceMappingURL=hub.js.map","import { __assign, __read, __spread } from \"tslib\";\nimport { getCurrentHub } from '@sentry/hub';\n/**\n * This calls a function on the current hub.\n * @param method function to call on hub.\n * @param args to pass to function.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction callOnHub(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    var hub = getCurrentHub();\n    if (hub && hub[method]) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return hub[method].apply(hub, __spread(args));\n    }\n    throw new Error(\"No hub defined or \" + method + \" was not found on the hub, please open a bug report.\");\n}\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @returns The generated eventId.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nexport function captureException(exception, captureContext) {\n    var syntheticException;\n    try {\n        throw new Error('Sentry syntheticException');\n    }\n    catch (exception) {\n        syntheticException = exception;\n    }\n    return callOnHub('captureException', exception, {\n        captureContext: captureContext,\n        originalException: exception,\n        syntheticException: syntheticException,\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 level Define the level of the message.\n * @returns The generated eventId.\n */\nexport function captureMessage(message, captureContext) {\n    var syntheticException;\n    try {\n        throw new Error(message);\n    }\n    catch (exception) {\n        syntheticException = exception;\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: captureContext } : undefined;\n    return callOnHub('captureMessage', message, level, __assign({ originalException: message, syntheticException: syntheticException }, context));\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 */\nexport function captureEvent(event) {\n    return callOnHub('captureEvent', event);\n}\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nexport function configureScope(callback) {\n    callOnHub('configureScope', callback);\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 */\nexport function addBreadcrumb(breadcrumb) {\n    callOnHub('addBreadcrumb', breadcrumb);\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function setContext(name, context) {\n    callOnHub('setContext', name, context);\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 */\nexport function setExtras(extras) {\n    callOnHub('setExtras', extras);\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 */\nexport function setTags(tags) {\n    callOnHub('setTags', tags);\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 */\nexport function setExtra(key, extra) {\n    callOnHub('setExtra', key, extra);\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 */\nexport function setTag(key, value) {\n    callOnHub('setTag', key, value);\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 */\nexport function setUser(user) {\n    callOnHub('setUser', user);\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 */\nexport function withScope(callback) {\n    callOnHub('withScope', callback);\n}\n/**\n * Calls a function on the latest client. Use this with caution, it's meant as\n * in \"internal\" helper so we don't need to expose every possible function in\n * the shim. It is not guaranteed that the client actually implements the\n * function.\n *\n * @param method The method to call on the client/client.\n * @param args Arguments to pass to the client/fontend.\n * @hidden\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function _callOnClient(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    callOnHub.apply(void 0, __spread(['_invokeClient', method], args));\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 * @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 */\nexport function startTransaction(context, customSamplingContext) {\n    return callOnHub('startTransaction', __assign({}, context), customSamplingContext);\n}\n//# sourceMappingURL=index.js.map","export var SDK_VERSION = '6.4.1';\n//# sourceMappingURL=version.js.map","export var setPrototypeOf = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);\n/**\n * setPrototypeOf polyfill using __proto__\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction setProtoOf(obj, proto) {\n    // @ts-ignore __proto__ does not exist on obj\n    obj.__proto__ = proto;\n    return obj;\n}\n/**\n * setPrototypeOf polyfill using mixin\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction mixinProperties(obj, proto) {\n    for (var prop in proto) {\n        // eslint-disable-next-line no-prototype-builtins\n        if (!obj.hasOwnProperty(prop)) {\n            // @ts-ignore typescript complains about indexing so we remove\n            obj[prop] = proto[prop];\n        }\n    }\n    return obj;\n}\n//# sourceMappingURL=polyfill.js.map","import { __extends } from \"tslib\";\nimport { setPrototypeOf } from './polyfill';\n/** An error emitted by Sentry SDKs and related utilities. */\nvar SentryError = /** @class */ (function (_super) {\n    __extends(SentryError, _super);\n    function SentryError(message) {\n        var _newTarget = this.constructor;\n        var _this = _super.call(this, message) || this;\n        _this.message = message;\n        _this.name = _newTarget.prototype.constructor.name;\n        setPrototypeOf(_this, _newTarget.prototype);\n        return _this;\n    }\n    return SentryError;\n}(Error));\nexport { SentryError };\n//# sourceMappingURL=error.js.map","import { __read } from \"tslib\";\nimport { SentryError } from './error';\n/** Regular expression used to parse a Dsn. */\nvar DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+))?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n/** Error message */\nvar ERROR_MESSAGE = 'Invalid Dsn';\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nvar Dsn = /** @class */ (function () {\n    /** Creates a new Dsn component */\n    function Dsn(from) {\n        if (typeof from === 'string') {\n            this._fromString(from);\n        }\n        else {\n            this._fromComponents(from);\n        }\n        this._validate();\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     */\n    Dsn.prototype.toString = function (withPassword) {\n        if (withPassword === void 0) { withPassword = false; }\n        var _a = this, host = _a.host, path = _a.path, pass = _a.pass, port = _a.port, projectId = _a.projectId, protocol = _a.protocol, publicKey = _a.publicKey;\n        return (protocol + \"://\" + publicKey + (withPassword && pass ? \":\" + pass : '') +\n            (\"@\" + host + (port ? \":\" + port : '') + \"/\" + (path ? path + \"/\" : path) + projectId));\n    };\n    /** Parses a string into this Dsn. */\n    Dsn.prototype._fromString = function (str) {\n        var match = DSN_REGEX.exec(str);\n        if (!match) {\n            throw new SentryError(ERROR_MESSAGE);\n        }\n        var _a = __read(match.slice(1), 6), protocol = _a[0], publicKey = _a[1], _b = _a[2], pass = _b === void 0 ? '' : _b, host = _a[3], _c = _a[4], port = _c === void 0 ? '' : _c, lastPath = _a[5];\n        var path = '';\n        var projectId = lastPath;\n        var split = projectId.split('/');\n        if (split.length > 1) {\n            path = split.slice(0, -1).join('/');\n            projectId = split.pop();\n        }\n        if (projectId) {\n            var projectMatch = projectId.match(/^\\d+/);\n            if (projectMatch) {\n                projectId = projectMatch[0];\n            }\n        }\n        this._fromComponents({ host: host, pass: pass, path: path, projectId: projectId, port: port, protocol: protocol, publicKey: publicKey });\n    };\n    /** Maps Dsn components into this instance. */\n    Dsn.prototype._fromComponents = function (components) {\n        // TODO this is for backwards compatibility, and can be removed in a future version\n        if ('user' in components && !('publicKey' in components)) {\n            components.publicKey = components.user;\n        }\n        this.user = components.publicKey || '';\n        this.protocol = components.protocol;\n        this.publicKey = components.publicKey || '';\n        this.pass = components.pass || '';\n        this.host = components.host;\n        this.port = components.port || '';\n        this.path = components.path || '';\n        this.projectId = components.projectId;\n    };\n    /** Validates this Dsn and throws on error. */\n    Dsn.prototype._validate = function () {\n        var _this = this;\n        ['protocol', 'publicKey', 'host', 'projectId'].forEach(function (component) {\n            if (!_this[component]) {\n                throw new SentryError(ERROR_MESSAGE + \": \" + component + \" missing\");\n            }\n        });\n        if (!this.projectId.match(/^\\d+$/)) {\n            throw new SentryError(ERROR_MESSAGE + \": Invalid projectId \" + this.projectId);\n        }\n        if (this.protocol !== 'http' && this.protocol !== 'https') {\n            throw new SentryError(ERROR_MESSAGE + \": Invalid protocol \" + this.protocol);\n        }\n        if (this.port && isNaN(parseInt(this.port, 10))) {\n            throw new SentryError(ERROR_MESSAGE + \": Invalid port \" + this.port);\n        }\n    };\n    return Dsn;\n}());\nexport { Dsn };\n//# sourceMappingURL=dsn.js.map","import { __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\nexport var installedIntegrations = [];\n/**\n * @private\n */\nfunction filterDuplicates(integrations) {\n    return integrations.reduce(function (acc, integrations) {\n        if (acc.every(function (accIntegration) { return integrations.name !== accIntegration.name; })) {\n            acc.push(integrations);\n        }\n        return acc;\n    }, []);\n}\n/** Gets integration to install */\nexport function getIntegrationsToSetup(options) {\n    var defaultIntegrations = (options.defaultIntegrations && __spread(options.defaultIntegrations)) || [];\n    var userIntegrations = options.integrations;\n    var integrations = __spread(filterDuplicates(defaultIntegrations));\n    if (Array.isArray(userIntegrations)) {\n        // Filter out integrations that are also included in user options\n        integrations = __spread(integrations.filter(function (integrations) {\n            return userIntegrations.every(function (userIntegration) { return userIntegration.name !== integrations.name; });\n        }), filterDuplicates(userIntegrations));\n    }\n    else if (typeof userIntegrations === 'function') {\n        integrations = userIntegrations(integrations);\n        integrations = Array.isArray(integrations) ? integrations : [integrations];\n    }\n    // Make sure that if present, `Debug` integration will always run last\n    var integrationsNames = integrations.map(function (i) { return i.name; });\n    var alwaysLastToRun = 'Debug';\n    if (integrationsNames.indexOf(alwaysLastToRun) !== -1) {\n        integrations.push.apply(integrations, __spread(integrations.splice(integrationsNames.indexOf(alwaysLastToRun), 1)));\n    }\n    return integrations;\n}\n/** Setup given integration */\nexport function setupIntegration(integration) {\n    if (installedIntegrations.indexOf(integration.name) !== -1) {\n        return;\n    }\n    integration.setupOnce(addGlobalEventProcessor, getCurrentHub);\n    installedIntegrations.push(integration.name);\n    logger.log(\"Integration installed: \" + integration.name);\n}\n/**\n * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default\n * integrations are added unless they were already provided before.\n * @param integrations array of integration instances\n * @param withDefault should enable default integrations\n */\nexport function setupIntegrations(options) {\n    var integrations = {};\n    getIntegrationsToSetup(options).forEach(function (integration) {\n        integrations[integration.name] = integration;\n        setupIntegration(integration);\n    });\n    return integrations;\n}\n//# sourceMappingURL=integration.js.map","import { __assign, __read, __spread, __values } from \"tslib\";\n/* eslint-disable max-lines */\nimport { Scope } from '@sentry/hub';\nimport { SessionStatus, } from '@sentry/types';\nimport { dateTimestampInSeconds, Dsn, isPrimitive, isThenable, logger, normalize, SentryError, SyncPromise, truncate, uuid4, } from '@sentry/utils';\nimport { setupIntegrations } from './integration';\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding backend constructor and options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}. Also, the Backend instance is available via\n * {@link Client.getBackend}.\n *\n * If a Dsn is specified in the options, it will be parsed and stored. Use\n * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is\n * invalid, the constructor will throw a {@link SentryException}. Note that\n * without a valid Dsn, the SDK will not send any events to Sentry.\n *\n * Before sending an event via the backend, it is passed through\n * {@link BaseClient._prepareEvent} to add SDK information and scope data\n * (breadcrumbs and context). To add more custom information, override this\n * method and extend the resulting prepared event.\n *\n * To issue automatically created events (e.g. via instrumentation), use\n * {@link Client.captureEvent}. It will prepare the event and pass it through\n * the callback lifecycle. To issue auto-breadcrumbs, use\n * {@link Client.addBreadcrumb}.\n *\n * @example\n * class NodeClient extends BaseClient<NodeBackend, NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(NodeBackend, options);\n *   }\n *\n *   // ...\n * }\n */\nvar BaseClient = /** @class */ (function () {\n    /**\n     * Initializes this client instance.\n     *\n     * @param backendClass A constructor function to create the backend.\n     * @param options Options for the client.\n     */\n    function BaseClient(backendClass, options) {\n        /** Array of used integrations. */\n        this._integrations = {};\n        /** Number of call being processed */\n        this._processing = 0;\n        this._backend = new backendClass(options);\n        this._options = options;\n        if (options.dsn) {\n            this._dsn = new Dsn(options.dsn);\n        }\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    BaseClient.prototype.captureException = function (exception, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        this._process(this._getBackend()\n            .eventFromException(exception, hint)\n            .then(function (event) { return _this._captureEvent(event, hint, scope); })\n            .then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureMessage = function (message, level, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        var promisedEvent = isPrimitive(message)\n            ? this._getBackend().eventFromMessage(String(message), level, hint)\n            : this._getBackend().eventFromException(message, hint);\n        this._process(promisedEvent\n            .then(function (event) { return _this._captureEvent(event, hint, scope); })\n            .then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureEvent = function (event, hint, scope) {\n        var eventId = hint && hint.event_id;\n        this._process(this._captureEvent(event, hint, scope).then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureSession = function (session) {\n        if (!(typeof session.release === 'string')) {\n            logger.warn('Discarded session because of missing or non-string release');\n        }\n        else {\n            this._sendSession(session);\n            // After sending, we set init false to indicate it's not the first occurrence\n            session.update({ init: false });\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getDsn = function () {\n        return this._dsn;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getOptions = function () {\n        return this._options;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.flush = function (timeout) {\n        var _this = this;\n        return this._isClientProcessing(timeout).then(function (ready) {\n            return _this._getBackend()\n                .getTransport()\n                .close(timeout)\n                .then(function (transportFlushed) { return ready && transportFlushed; });\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.close = function (timeout) {\n        var _this = this;\n        return this.flush(timeout).then(function (result) {\n            _this.getOptions().enabled = false;\n            return result;\n        });\n    };\n    /**\n     * Sets up the integrations\n     */\n    BaseClient.prototype.setupIntegrations = function () {\n        if (this._isEnabled()) {\n            this._integrations = setupIntegrations(this._options);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getIntegration = function (integration) {\n        try {\n            return this._integrations[integration.id] || null;\n        }\n        catch (_oO) {\n            logger.warn(\"Cannot retrieve integration \" + integration.id + \" from the current Client\");\n            return null;\n        }\n    };\n    /** Updates existing session based on the provided event */\n    BaseClient.prototype._updateSessionFromEvent = function (session, event) {\n        var e_1, _a;\n        var crashed = false;\n        var errored = false;\n        var userAgent;\n        var exceptions = event.exception && event.exception.values;\n        if (exceptions) {\n            errored = true;\n            try {\n                for (var exceptions_1 = __values(exceptions), exceptions_1_1 = exceptions_1.next(); !exceptions_1_1.done; exceptions_1_1 = exceptions_1.next()) {\n                    var ex = exceptions_1_1.value;\n                    var mechanism = ex.mechanism;\n                    if (mechanism && mechanism.handled === false) {\n                        crashed = true;\n                        break;\n                    }\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (exceptions_1_1 && !exceptions_1_1.done && (_a = exceptions_1.return)) _a.call(exceptions_1);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n        }\n        var user = event.user;\n        if (!session.userAgent) {\n            var headers = event.request ? event.request.headers : {};\n            for (var key in headers) {\n                if (key.toLowerCase() === 'user-agent') {\n                    userAgent = headers[key];\n                    break;\n                }\n            }\n        }\n        session.update(__assign(__assign({}, (crashed && { status: SessionStatus.Crashed })), { user: user,\n            userAgent: userAgent, errors: session.errors + Number(errored || crashed) }));\n        this.captureSession(session);\n    };\n    /** Deliver captured session to Sentry */\n    BaseClient.prototype._sendSession = function (session) {\n        this._getBackend().sendSession(session);\n    };\n    /** Waits for the client to be done with processing. */\n    BaseClient.prototype._isClientProcessing = function (timeout) {\n        var _this = this;\n        return new SyncPromise(function (resolve) {\n            var ticked = 0;\n            var tick = 1;\n            var interval = setInterval(function () {\n                if (_this._processing == 0) {\n                    clearInterval(interval);\n                    resolve(true);\n                }\n                else {\n                    ticked += tick;\n                    if (timeout && ticked >= timeout) {\n                        clearInterval(interval);\n                        resolve(false);\n                    }\n                }\n            }, tick);\n        });\n    };\n    /** Returns the current backend. */\n    BaseClient.prototype._getBackend = function () {\n        return this._backend;\n    };\n    /** Determines whether this SDK is enabled and a valid Dsn is present. */\n    BaseClient.prototype._isEnabled = function () {\n        return this.getOptions().enabled !== false && this._dsn !== undefined;\n    };\n    /**\n     * Adds common information to events.\n     *\n     * The information includes release and environment from `options`,\n     * breadcrumbs and context (extra, tags and user) from the scope.\n     *\n     * Information that is already present in the event is never overwritten. For\n     * nested objects, such as the context, keys are merged.\n     *\n     * @param event The original event.\n     * @param hint May contain additional information about the original exception.\n     * @param scope A scope containing event metadata.\n     * @returns A new event with more information.\n     */\n    BaseClient.prototype._prepareEvent = function (event, scope, hint) {\n        var _this = this;\n        var _a = this.getOptions().normalizeDepth, normalizeDepth = _a === void 0 ? 3 : _a;\n        var prepared = __assign(__assign({}, event), { event_id: event.event_id || (hint && hint.event_id ? hint.event_id : uuid4()), timestamp: event.timestamp || dateTimestampInSeconds() });\n        this._applyClientOptions(prepared);\n        this._applyIntegrationsMetadata(prepared);\n        // If we have scope given to us, use it as the base for further modifications.\n        // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.\n        var finalScope = scope;\n        if (hint && hint.captureContext) {\n            finalScope = Scope.clone(finalScope).update(hint.captureContext);\n        }\n        // We prepare the result here with a resolved Event.\n        var result = SyncPromise.resolve(prepared);\n        // This should be the last thing called, since we want that\n        // {@link Hub.addEventProcessor} gets the finished prepared event.\n        if (finalScope) {\n            // In case we have a hub we reassign it.\n            result = finalScope.applyToEvent(prepared, hint);\n        }\n        return result.then(function (evt) {\n            if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n                return _this._normalizeEvent(evt, normalizeDepth);\n            }\n            return evt;\n        });\n    };\n    /**\n     * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.\n     * Normalized keys:\n     * - `breadcrumbs.data`\n     * - `user`\n     * - `contexts`\n     * - `extra`\n     * @param event Event\n     * @returns Normalized event\n     */\n    BaseClient.prototype._normalizeEvent = function (event, depth) {\n        if (!event) {\n            return null;\n        }\n        var normalized = __assign(__assign(__assign(__assign(__assign({}, event), (event.breadcrumbs && {\n            breadcrumbs: event.breadcrumbs.map(function (b) { return (__assign(__assign({}, b), (b.data && {\n                data: normalize(b.data, depth),\n            }))); }),\n        })), (event.user && {\n            user: normalize(event.user, depth),\n        })), (event.contexts && {\n            contexts: normalize(event.contexts, depth),\n        })), (event.extra && {\n            extra: normalize(event.extra, depth),\n        }));\n        // event.contexts.trace stores information about a Transaction. Similarly,\n        // event.spans[] stores information about child Spans. Given that a\n        // Transaction is conceptually a Span, normalization should apply to both\n        // Transactions and Spans consistently.\n        // For now the decision is to skip normalization of Transactions and Spans,\n        // so this block overwrites the normalized event to add back the original\n        // Transaction information prior to normalization.\n        if (event.contexts && event.contexts.trace) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            normalized.contexts.trace = event.contexts.trace;\n        }\n        return normalized;\n    };\n    /**\n     *  Enhances event using the client configuration.\n     *  It takes care of all \"static\" values like environment, release and `dist`,\n     *  as well as truncating overly long values.\n     * @param event event instance to be enhanced\n     */\n    BaseClient.prototype._applyClientOptions = function (event) {\n        var options = this.getOptions();\n        var environment = options.environment, release = options.release, dist = options.dist, _a = options.maxValueLength, maxValueLength = _a === void 0 ? 250 : _a;\n        if (!('environment' in event)) {\n            event.environment = 'environment' in options ? environment : 'production';\n        }\n        if (event.release === undefined && release !== undefined) {\n            event.release = release;\n        }\n        if (event.dist === undefined && dist !== undefined) {\n            event.dist = dist;\n        }\n        if (event.message) {\n            event.message = truncate(event.message, maxValueLength);\n        }\n        var exception = event.exception && event.exception.values && event.exception.values[0];\n        if (exception && exception.value) {\n            exception.value = truncate(exception.value, maxValueLength);\n        }\n        var request = event.request;\n        if (request && request.url) {\n            request.url = truncate(request.url, maxValueLength);\n        }\n    };\n    /**\n     * This function adds all used integrations to the SDK info in the event.\n     * @param event The event that will be filled with all integrations.\n     */\n    BaseClient.prototype._applyIntegrationsMetadata = function (event) {\n        var integrationsArray = Object.keys(this._integrations);\n        if (integrationsArray.length > 0) {\n            event.sdk = event.sdk || {};\n            event.sdk.integrations = __spread((event.sdk.integrations || []), integrationsArray);\n        }\n    };\n    /**\n     * Tells the backend to send this event\n     * @param event The Sentry event to send\n     */\n    BaseClient.prototype._sendEvent = function (event) {\n        this._getBackend().sendEvent(event);\n    };\n    /**\n     * Processes the event and logs an error in case of rejection\n     * @param event\n     * @param hint\n     * @param scope\n     */\n    BaseClient.prototype._captureEvent = function (event, hint, scope) {\n        return this._processEvent(event, hint, scope).then(function (finalEvent) {\n            return finalEvent.event_id;\n        }, function (reason) {\n            logger.error(reason);\n            return undefined;\n        });\n    };\n    /**\n     * Processes an event (either error or message) and sends it to Sentry.\n     *\n     * This also adds breadcrumbs and context information to the event. However,\n     * platform specific meta data (such as the User's IP address) must be added\n     * by the SDK implementor.\n     *\n     *\n     * @param event The event to send to Sentry.\n     * @param hint May contain additional information about the original exception.\n     * @param scope A scope containing event metadata.\n     * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.\n     */\n    BaseClient.prototype._processEvent = function (event, hint, scope) {\n        var _this = this;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var _a = this.getOptions(), beforeSend = _a.beforeSend, sampleRate = _a.sampleRate;\n        if (!this._isEnabled()) {\n            return SyncPromise.reject(new SentryError('SDK not enabled, will not send event.'));\n        }\n        var isTransaction = event.type === 'transaction';\n        // 1.0 === 100% events are sent\n        // 0.0 === 0% events are sent\n        // Sampling for transaction happens somewhere else\n        if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {\n            return SyncPromise.reject(new SentryError(\"Discarding event because it's not included in the random sample (sampling rate = \" + sampleRate + \")\"));\n        }\n        return this._prepareEvent(event, scope, hint)\n            .then(function (prepared) {\n            if (prepared === null) {\n                throw new SentryError('An event processor returned null, will not send event.');\n            }\n            var isInternalException = hint && hint.data && hint.data.__sentry__ === true;\n            if (isInternalException || isTransaction || !beforeSend) {\n                return prepared;\n            }\n            var beforeSendResult = beforeSend(prepared, hint);\n            if (typeof beforeSendResult === 'undefined') {\n                throw new SentryError('`beforeSend` method has to return `null` or a valid event.');\n            }\n            else if (isThenable(beforeSendResult)) {\n                return beforeSendResult.then(function (event) { return event; }, function (e) {\n                    throw new SentryError(\"beforeSend rejected with \" + e);\n                });\n            }\n            return beforeSendResult;\n        })\n            .then(function (processedEvent) {\n            if (processedEvent === null) {\n                throw new SentryError('`beforeSend` returned `null`, will not send event.');\n            }\n            var session = scope && scope.getSession && scope.getSession();\n            if (!isTransaction && session) {\n                _this._updateSessionFromEvent(session, processedEvent);\n            }\n            _this._sendEvent(processedEvent);\n            return processedEvent;\n        })\n            .then(null, function (reason) {\n            if (reason instanceof SentryError) {\n                throw reason;\n            }\n            _this.captureException(reason, {\n                data: {\n                    __sentry__: true,\n                },\n                originalException: reason,\n            });\n            throw new SentryError(\"Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: \" + reason);\n        });\n    };\n    /**\n     * Occupies the client with processing and event\n     */\n    BaseClient.prototype._process = function (promise) {\n        var _this = this;\n        this._processing += 1;\n        promise.then(function (value) {\n            _this._processing -= 1;\n            return value;\n        }, function (reason) {\n            _this._processing -= 1;\n            return reason;\n        });\n    };\n    return BaseClient;\n}());\nexport { BaseClient };\n//# sourceMappingURL=baseclient.js.map","import { Status } from '@sentry/types';\nimport { SyncPromise } from '@sentry/utils';\n/** Noop transport */\nvar NoopTransport = /** @class */ (function () {\n    function NoopTransport() {\n    }\n    /**\n     * @inheritDoc\n     */\n    NoopTransport.prototype.sendEvent = function (_) {\n        return SyncPromise.resolve({\n            reason: \"NoopTransport: Event has been skipped because no Dsn is configured.\",\n            status: Status.Skipped,\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    NoopTransport.prototype.close = function (_) {\n        return SyncPromise.resolve(true);\n    };\n    return NoopTransport;\n}());\nexport { NoopTransport };\n//# sourceMappingURL=noop.js.map","import { logger, SentryError } from '@sentry/utils';\nimport { NoopTransport } from './transports/noop';\n/**\n * This is the base implemention of a Backend.\n * @hidden\n */\nvar BaseBackend = /** @class */ (function () {\n    /** Creates a new backend instance. */\n    function BaseBackend(options) {\n        this._options = options;\n        if (!this._options.dsn) {\n            logger.warn('No DSN provided, backend will not do anything.');\n        }\n        this._transport = this._setupTransport();\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    BaseBackend.prototype.eventFromException = function (_exception, _hint) {\n        throw new SentryError('Backend has to implement `eventFromException` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.eventFromMessage = function (_message, _level, _hint) {\n        throw new SentryError('Backend has to implement `eventFromMessage` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.sendEvent = function (event) {\n        this._transport.sendEvent(event).then(null, function (reason) {\n            logger.error(\"Error while sending event: \" + reason);\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.sendSession = function (session) {\n        if (!this._transport.sendSession) {\n            logger.warn(\"Dropping session because custom transport doesn't implement sendSession\");\n            return;\n        }\n        this._transport.sendSession(session).then(null, function (reason) {\n            logger.error(\"Error while sending session: \" + reason);\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.getTransport = function () {\n        return this._transport;\n    };\n    /**\n     * Sets up the transport so it can be used later to send requests.\n     */\n    BaseBackend.prototype._setupTransport = function () {\n        return new NoopTransport();\n    };\n    return BaseBackend;\n}());\nexport { BaseBackend };\n//# sourceMappingURL=basebackend.js.map","import { logger } from './logger';\nimport { getGlobalObject } from './misc';\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsErrorEvent() {\n    try {\n        new ErrorEvent('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nexport function 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    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMException() {\n    try {\n        new DOMException('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsFetch() {\n    if (!('fetch' in getGlobalObject())) {\n        return false;\n    }\n    try {\n        new Headers();\n        new Request('');\n        new Response();\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function isNativeFetch(func) {\n    return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\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 */\nexport function supportsNativeFetch() {\n    if (!supportsFetch()) {\n        return false;\n    }\n    var global = getGlobalObject();\n    // Fast path to avoid DOM I/O\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    if (isNativeFetch(global.fetch)) {\n        return true;\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    var result = false;\n    var doc = global.document;\n    // eslint-disable-next-line deprecation/deprecation\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                // eslint-disable-next-line @typescript-eslint/unbound-method\n                result = isNativeFetch(sandbox.contentWindow.fetch);\n            }\n            doc.head.removeChild(sandbox);\n        }\n        catch (err) {\n            logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n        }\n    }\n    return result;\n}\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReportingObserver() {\n    return 'ReportingObserver' in getGlobalObject();\n}\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReferrerPolicy() {\n    // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default\n    // https://caniuse.com/#feat=referrer-policy\n    // It doesn't. And it throw exception instead of ignoring this parameter...\n    // REF: https://github.com/getsentry/raven-js/issues/1233\n    if (!supportsFetch()) {\n        return false;\n    }\n    try {\n        new Request('_', {\n            referrerPolicy: 'origin',\n        });\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nexport function 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    /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var chrome = global.chrome;\n    var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n    /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n    var hasHistoryApi = 'history' in global && !!global.history.pushState && !!global.history.replaceState;\n    return !isChromePackagedApp && hasHistoryApi;\n}\n//# sourceMappingURL=supports.js.map","/**\n * This was originally forked from https://github.com/occ/TraceKit, but has since been\n * largely modified and is now maintained as part of Sentry JS SDK.\n */\nimport { __assign } from \"tslib\";\n// global reference to slice\nvar UNKNOWN_FUNCTION = '?';\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nvar chrome = /^\\s*at (?:(.*?) ?\\()?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nvar gecko = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|capacitor).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar winjs = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nvar geckoEval = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nvar chromeEval = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nvar reactMinifiedRegexp = /Minified React error #\\d+;/i;\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nexport function computeStackTrace(ex) {\n    var stack = null;\n    var popSize = 0;\n    if (ex) {\n        if (typeof ex.framesToPop === 'number') {\n            popSize = ex.framesToPop;\n        }\n        else if (reactMinifiedRegexp.test(ex.message)) {\n            popSize = 1;\n        }\n    }\n    try {\n        // This must be tried first because Opera 10 *destroys*\n        // its stacktrace property if you try to access the stack\n        // property first!!\n        stack = computeStackTraceFromStacktraceProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\n        }\n    }\n    catch (e) {\n        // no-empty\n    }\n    try {\n        stack = computeStackTraceFromStackProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\n        }\n    }\n    catch (e) {\n        // no-empty\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex && ex.name,\n        stack: [],\n        failed: true,\n    };\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, complexity\nfunction computeStackTraceFromStackProp(ex) {\n    if (!ex || !ex.stack) {\n        return null;\n    }\n    var stack = [];\n    var lines = ex.stack.split('\\n');\n    var isEval;\n    var submatch;\n    var parts;\n    var element;\n    for (var i = 0; i < lines.length; ++i) {\n        if ((parts = chrome.exec(lines[i]))) {\n            var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n            isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n            if (isEval && (submatch = chromeEval.exec(parts[2]))) {\n                // throw out eval line/column and use top-most line/column number\n                parts[2] = submatch[1]; // url\n                parts[3] = submatch[2]; // line\n                parts[4] = submatch[3]; // column\n            }\n            // Arpad: Working with the regexp above is super painful. it is quite a hack, but just stripping the `address at `\n            // prefix here seems like the quickest solution for now.\n            var url = parts[2] && parts[2].indexOf('address at ') === 0 ? parts[2].substr('address at '.length) : parts[2];\n            // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now\n            // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)\n            var func = parts[1] || UNKNOWN_FUNCTION;\n            var isSafariExtension = func.indexOf('safari-extension') !== -1;\n            var isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;\n            if (isSafariExtension || isSafariWebExtension) {\n                func = func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION;\n                url = isSafariExtension ? \"safari-extension:\" + url : \"safari-web-extension:\" + url;\n            }\n            element = {\n                url: url,\n                func: func,\n                args: isNative ? [parts[2]] : [],\n                line: parts[3] ? +parts[3] : null,\n                column: parts[4] ? +parts[4] : null,\n            };\n        }\n        else if ((parts = winjs.exec(lines[i]))) {\n            element = {\n                url: parts[2],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: [],\n                line: +parts[3],\n                column: parts[4] ? +parts[4] : null,\n            };\n        }\n        else if ((parts = gecko.exec(lines[i]))) {\n            isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n            if (isEval && (submatch = geckoEval.exec(parts[3]))) {\n                // throw out eval line/column and use top-most line number\n                parts[1] = parts[1] || \"eval\";\n                parts[3] = submatch[1];\n                parts[4] = submatch[2];\n                parts[5] = ''; // no column when eval\n            }\n            else if (i === 0 && !parts[5] && ex.columnNumber !== void 0) {\n                // FireFox uses this awesome columnNumber property for its top frame\n                // Also note, Firefox's column number is 0-based and everything else expects 1-based,\n                // so adding 1\n                // NOTE: this hack doesn't work if top-most frame is eval\n                stack[0].column = ex.columnNumber + 1;\n            }\n            element = {\n                url: parts[3],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: parts[2] ? parts[2].split(',') : [],\n                line: parts[4] ? +parts[4] : null,\n                column: parts[5] ? +parts[5] : null,\n            };\n        }\n        else {\n            continue;\n        }\n        if (!element.func && element.line) {\n            element.func = UNKNOWN_FUNCTION;\n        }\n        stack.push(element);\n    }\n    if (!stack.length) {\n        return null;\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex.name,\n        stack: stack,\n    };\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction computeStackTraceFromStacktraceProp(ex) {\n    if (!ex || !ex.stacktrace) {\n        return null;\n    }\n    // Access and store the stacktrace property before doing ANYTHING\n    // else to it because Opera is not very good at providing it\n    // reliably in other circumstances.\n    var stacktrace = ex.stacktrace;\n    var opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n    var opera11Regex = / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\((.*)\\))? in (.*):\\s*$/i;\n    var lines = stacktrace.split('\\n');\n    var stack = [];\n    var parts;\n    for (var line = 0; line < lines.length; line += 2) {\n        var element = null;\n        if ((parts = opera10Regex.exec(lines[line]))) {\n            element = {\n                url: parts[2],\n                func: parts[3],\n                args: [],\n                line: +parts[1],\n                column: null,\n            };\n        }\n        else if ((parts = opera11Regex.exec(lines[line]))) {\n            element = {\n                url: parts[6],\n                func: parts[3] || parts[4],\n                args: parts[5] ? parts[5].split(',') : [],\n                line: +parts[1],\n                column: +parts[2],\n            };\n        }\n        if (element) {\n            if (!element.func && element.line) {\n                element.func = UNKNOWN_FUNCTION;\n            }\n            stack.push(element);\n        }\n    }\n    if (!stack.length) {\n        return null;\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex.name,\n        stack: stack,\n    };\n}\n/** Remove N number of frames from the stack */\nfunction popFrames(stacktrace, popSize) {\n    try {\n        return __assign(__assign({}, stacktrace), { stack: stacktrace.stack.slice(popSize) });\n    }\n    catch (e) {\n        return stacktrace;\n    }\n}\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction extractMessage(ex) {\n    var message = ex && ex.message;\n    if (!message) {\n        return 'No error message';\n    }\n    if (message.error && typeof message.error.message === 'string') {\n        return message.error.message;\n    }\n    return message;\n}\n//# sourceMappingURL=tracekit.js.map","import { extractExceptionKeysForMessage, isEvent, normalizeToSize } from '@sentry/utils';\nimport { computeStackTrace } from './tracekit';\nvar STACKTRACE_LIMIT = 50;\n/**\n * This function creates an exception from an TraceKitStackTrace\n * @param stacktrace TraceKitStackTrace that will be converted to an exception\n * @hidden\n */\nexport function exceptionFromStacktrace(stacktrace) {\n    var frames = prepareFramesForEvent(stacktrace.stack);\n    var exception = {\n        type: stacktrace.name,\n        value: stacktrace.message,\n    };\n    if (frames && frames.length) {\n        exception.stacktrace = { frames: frames };\n    }\n    if (exception.type === undefined && exception.value === '') {\n        exception.value = 'Unrecoverable error caught';\n    }\n    return exception;\n}\n/**\n * @hidden\n */\nexport function eventFromPlainObject(exception, syntheticException, rejection) {\n    var event = {\n        exception: {\n            values: [\n                {\n                    type: isEvent(exception) ? exception.constructor.name : rejection ? 'UnhandledRejection' : 'Error',\n                    value: \"Non-Error \" + (rejection ? 'promise rejection' : 'exception') + \" captured with keys: \" + extractExceptionKeysForMessage(exception),\n                },\n            ],\n        },\n        extra: {\n            __serialized__: normalizeToSize(exception),\n        },\n    };\n    if (syntheticException) {\n        var stacktrace = computeStackTrace(syntheticException);\n        var frames_1 = prepareFramesForEvent(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1,\n        };\n    }\n    return event;\n}\n/**\n * @hidden\n */\nexport function eventFromStacktrace(stacktrace) {\n    var exception = exceptionFromStacktrace(stacktrace);\n    return {\n        exception: {\n            values: [exception],\n        },\n    };\n}\n/**\n * @hidden\n */\nexport function prepareFramesForEvent(stack) {\n    if (!stack || !stack.length) {\n        return [];\n    }\n    var localStack = stack;\n    var firstFrameFunction = localStack[0].func || '';\n    var lastFrameFunction = localStack[localStack.length - 1].func || '';\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    // 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    // The frame where the crash happened, should be the last entry in the array\n    return localStack\n        .slice(0, STACKTRACE_LIMIT)\n        .map(function (frame) { return ({\n        colno: frame.column === null ? undefined : frame.column,\n        filename: frame.url || localStack[0].url,\n        function: frame.func || '?',\n        in_app: true,\n        lineno: frame.line === null ? undefined : frame.line,\n    }); })\n        .reverse();\n}\n//# sourceMappingURL=parsers.js.map","import { __assign } from \"tslib\";\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, addExceptionTypeValue, isDOMError, isDOMException, isError, isErrorEvent, isEvent, isPlainObject, SyncPromise, } from '@sentry/utils';\nimport { eventFromPlainObject, eventFromStacktrace, prepareFramesForEvent } from './parsers';\nimport { computeStackTrace } from './tracekit';\n/**\n * Builds and Event from a Exception\n * @hidden\n */\nexport function eventFromException(options, exception, hint) {\n    var syntheticException = (hint && hint.syntheticException) || undefined;\n    var event = eventFromUnknownInput(exception, syntheticException, {\n        attachStacktrace: options.attachStacktrace,\n    });\n    addExceptionMechanism(event, {\n        handled: true,\n        type: 'generic',\n    });\n    event.level = Severity.Error;\n    if (hint && hint.event_id) {\n        event.event_id = hint.event_id;\n    }\n    return SyncPromise.resolve(event);\n}\n/**\n * Builds and Event from a Message\n * @hidden\n */\nexport function eventFromMessage(options, message, level, hint) {\n    if (level === void 0) { level = Severity.Info; }\n    var syntheticException = (hint && hint.syntheticException) || undefined;\n    var event = eventFromString(message, syntheticException, {\n        attachStacktrace: options.attachStacktrace,\n    });\n    event.level = level;\n    if (hint && hint.event_id) {\n        event.event_id = hint.event_id;\n    }\n    return SyncPromise.resolve(event);\n}\n/**\n * @hidden\n */\nexport function eventFromUnknownInput(exception, syntheticException, options) {\n    if (options === void 0) { options = {}; }\n    var event;\n    if (isErrorEvent(exception) && exception.error) {\n        // If it is an ErrorEvent with `error` property, extract it to get actual Error\n        var errorEvent = exception;\n        // eslint-disable-next-line no-param-reassign\n        exception = errorEvent.error;\n        event = eventFromStacktrace(computeStackTrace(exception));\n        return event;\n    }\n    if (isDOMError(exception) || isDOMException(exception)) {\n        // If it is a DOMError or DOMException (which are legacy APIs, but still supported in some browsers)\n        // then we just extract the name, code, and message, as they don't provide anything else\n        // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n        // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n        var domException = exception;\n        var name_1 = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n        var message = domException.message ? name_1 + \": \" + domException.message : name_1;\n        event = eventFromString(message, syntheticException, options);\n        addExceptionTypeValue(event, message);\n        if ('code' in domException) {\n            event.tags = __assign(__assign({}, event.tags), { 'DOMException.code': \"\" + domException.code });\n        }\n        return event;\n    }\n    if (isError(exception)) {\n        // we have a real Error object, do nothing\n        event = eventFromStacktrace(computeStackTrace(exception));\n        return event;\n    }\n    if (isPlainObject(exception) || isEvent(exception)) {\n        // If it is plain Object or Event, serialize it manually and extract options\n        // This will allow us to group events based on top-level keys\n        // which is much better than creating new group when any key/value change\n        var objectException = exception;\n        event = eventFromPlainObject(objectException, syntheticException, options.rejection);\n        addExceptionMechanism(event, {\n            synthetic: true,\n        });\n        return event;\n    }\n    // If none of previous checks were valid, then it means that it's not:\n    // - an instance of DOMError\n    // - an instance of DOMException\n    // - an instance of Event\n    // - an instance of Error\n    // - a valid ErrorEvent (one with an error property)\n    // - a plain Object\n    //\n    // So bail out and capture it as a simple message:\n    event = eventFromString(exception, syntheticException, options);\n    addExceptionTypeValue(event, \"\" + exception, undefined);\n    addExceptionMechanism(event, {\n        synthetic: true,\n    });\n    return event;\n}\n/**\n * @hidden\n */\nexport function eventFromString(input, syntheticException, options) {\n    if (options === void 0) { options = {}; }\n    var event = {\n        message: input,\n    };\n    if (options.attachStacktrace && syntheticException) {\n        var stacktrace = computeStackTrace(syntheticException);\n        var frames_1 = prepareFramesForEvent(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1,\n        };\n    }\n    return event;\n}\n//# sourceMappingURL=eventbuilder.js.map","import { __assign, __read, __rest, __spread } from \"tslib\";\n/** Extract sdk info from from the API metadata */\nfunction getSdkMetadataForEnvelopeHeader(api) {\n    if (!api.metadata || !api.metadata.sdk) {\n        return;\n    }\n    var _a = api.metadata.sdk, name = _a.name, version = _a.version;\n    return { name: name, version: version };\n}\n/**\n * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.\n * Merge with existing data if any.\n **/\nfunction enhanceEventWithSdkInfo(event, sdkInfo) {\n    if (!sdkInfo) {\n        return event;\n    }\n    event.sdk = event.sdk || {};\n    event.sdk.name = event.sdk.name || sdkInfo.name;\n    event.sdk.version = event.sdk.version || sdkInfo.version;\n    event.sdk.integrations = __spread((event.sdk.integrations || []), (sdkInfo.integrations || []));\n    event.sdk.packages = __spread((event.sdk.packages || []), (sdkInfo.packages || []));\n    return event;\n}\n/** Creates a SentryRequest from a Session. */\nexport function sessionToSentryRequest(session, api) {\n    var sdkInfo = getSdkMetadataForEnvelopeHeader(api);\n    var envelopeHeaders = JSON.stringify(__assign({ sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })));\n    // I know this is hacky but we don't want to add `session` to request type since it's never rate limited\n    var type = 'aggregates' in session ? 'sessions' : 'session';\n    var itemHeaders = JSON.stringify({\n        type: type,\n    });\n    return {\n        body: envelopeHeaders + \"\\n\" + itemHeaders + \"\\n\" + JSON.stringify(session),\n        type: type,\n        url: api.getEnvelopeEndpointWithUrlEncodedAuth(),\n    };\n}\n/** Creates a SentryRequest from an event. */\nexport function eventToSentryRequest(event, api) {\n    var sdkInfo = getSdkMetadataForEnvelopeHeader(api);\n    var eventType = event.type || 'event';\n    var useEnvelope = eventType === 'transaction';\n    var _a = event.debug_meta || {}, transactionSampling = _a.transactionSampling, metadata = __rest(_a, [\"transactionSampling\"]);\n    var _b = transactionSampling || {}, samplingMethod = _b.method, sampleRate = _b.rate;\n    if (Object.keys(metadata).length === 0) {\n        delete event.debug_meta;\n    }\n    else {\n        event.debug_meta = metadata;\n    }\n    var req = {\n        body: JSON.stringify(sdkInfo ? enhanceEventWithSdkInfo(event, api.metadata.sdk) : event),\n        type: eventType,\n        url: useEnvelope ? api.getEnvelopeEndpointWithUrlEncodedAuth() : api.getStoreEndpointWithUrlEncodedAuth(),\n    };\n    // https://develop.sentry.dev/sdk/envelopes/\n    // Since we don't need to manipulate envelopes nor store them, there is no\n    // exported concept of an Envelope with operations including serialization and\n    // deserialization. Instead, we only implement a minimal subset of the spec to\n    // serialize events inline here.\n    if (useEnvelope) {\n        var envelopeHeaders = JSON.stringify(__assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })));\n        var itemHeaders = JSON.stringify({\n            type: event.type,\n            // TODO: Right now, sampleRate may or may not be defined (it won't be in the cases of inheritance and\n            // explicitly-set sampling decisions). Are we good with that?\n            sample_rates: [{ id: samplingMethod, rate: sampleRate }],\n        });\n        // The trailing newline is optional. We intentionally don't send it to avoid\n        // sending unnecessary bytes.\n        //\n        // const envelope = `${envelopeHeaders}\\n${itemHeaders}\\n${req.body}\\n`;\n        var envelope = envelopeHeaders + \"\\n\" + itemHeaders + \"\\n\" + req.body;\n        req.body = envelope;\n    }\n    return req;\n}\n//# sourceMappingURL=request.js.map","import { Dsn, urlEncode } from '@sentry/utils';\nvar SENTRY_API_VERSION = '7';\n/**\n * Helper class to provide urls, headers and metadata that can be used to form\n * different types of requests to Sentry endpoints.\n * Supports both envelopes and regular event requests.\n **/\nvar API = /** @class */ (function () {\n    /** Create a new instance of API */\n    function API(dsn, metadata) {\n        if (metadata === void 0) { metadata = {}; }\n        this.dsn = dsn;\n        this._dsnObject = new Dsn(dsn);\n        this.metadata = metadata;\n    }\n    /** Returns the Dsn object. */\n    API.prototype.getDsn = function () {\n        return this._dsnObject;\n    };\n    /** Returns the prefix to construct Sentry ingestion API endpoints. */\n    API.prototype.getBaseApiEndpoint = function () {\n        var dsn = this._dsnObject;\n        var protocol = dsn.protocol ? dsn.protocol + \":\" : '';\n        var port = dsn.port ? \":\" + dsn.port : '';\n        return protocol + \"//\" + dsn.host + port + (dsn.path ? \"/\" + dsn.path : '') + \"/api/\";\n    };\n    /** Returns the store endpoint URL. */\n    API.prototype.getStoreEndpoint = function () {\n        return this._getIngestEndpoint('store');\n    };\n    /**\n     * Returns the store endpoint URL with auth in the query string.\n     *\n     * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n     */\n    API.prototype.getStoreEndpointWithUrlEncodedAuth = function () {\n        return this.getStoreEndpoint() + \"?\" + this._encodedAuth();\n    };\n    /**\n     * Returns the envelope endpoint URL with auth in the query string.\n     *\n     * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n     */\n    API.prototype.getEnvelopeEndpointWithUrlEncodedAuth = function () {\n        return this._getEnvelopeEndpoint() + \"?\" + this._encodedAuth();\n    };\n    /** Returns only the path component for the store endpoint. */\n    API.prototype.getStoreEndpointPath = function () {\n        var dsn = this._dsnObject;\n        return (dsn.path ? \"/\" + dsn.path : '') + \"/api/\" + dsn.projectId + \"/store/\";\n    };\n    /**\n     * Returns an object that can be used in request headers.\n     * This is needed for node and the old /store endpoint in sentry\n     */\n    API.prototype.getRequestHeaders = function (clientName, clientVersion) {\n        // CHANGE THIS to use metadata but keep clientName and clientVersion compatible\n        var dsn = this._dsnObject;\n        var header = [\"Sentry sentry_version=\" + SENTRY_API_VERSION];\n        header.push(\"sentry_client=\" + clientName + \"/\" + clientVersion);\n        header.push(\"sentry_key=\" + dsn.publicKey);\n        if (dsn.pass) {\n            header.push(\"sentry_secret=\" + dsn.pass);\n        }\n        return {\n            'Content-Type': 'application/json',\n            'X-Sentry-Auth': header.join(', '),\n        };\n    };\n    /** Returns the url to the report dialog endpoint. */\n    API.prototype.getReportDialogEndpoint = function (dialogOptions) {\n        if (dialogOptions === void 0) { dialogOptions = {}; }\n        var dsn = this._dsnObject;\n        var endpoint = this.getBaseApiEndpoint() + \"embed/error-page/\";\n        var encodedOptions = [];\n        encodedOptions.push(\"dsn=\" + dsn.toString());\n        for (var key in dialogOptions) {\n            if (key === 'dsn') {\n                continue;\n            }\n            if (key === 'user') {\n                if (!dialogOptions.user) {\n                    continue;\n                }\n                if (dialogOptions.user.name) {\n                    encodedOptions.push(\"name=\" + encodeURIComponent(dialogOptions.user.name));\n                }\n                if (dialogOptions.user.email) {\n                    encodedOptions.push(\"email=\" + encodeURIComponent(dialogOptions.user.email));\n                }\n            }\n            else {\n                encodedOptions.push(encodeURIComponent(key) + \"=\" + encodeURIComponent(dialogOptions[key]));\n            }\n        }\n        if (encodedOptions.length) {\n            return endpoint + \"?\" + encodedOptions.join('&');\n        }\n        return endpoint;\n    };\n    /** Returns the envelope endpoint URL. */\n    API.prototype._getEnvelopeEndpoint = function () {\n        return this._getIngestEndpoint('envelope');\n    };\n    /** Returns the ingest API endpoint for target. */\n    API.prototype._getIngestEndpoint = function (target) {\n        var base = this.getBaseApiEndpoint();\n        var dsn = this._dsnObject;\n        return \"\" + base + dsn.projectId + \"/\" + target + \"/\";\n    };\n    /** Returns a URL-encoded string with auth config suitable for a query string. */\n    API.prototype._encodedAuth = function () {\n        var dsn = this._dsnObject;\n        var auth = {\n            // We send only the minimum set of required information. See\n            // https://github.com/getsentry/sentry-javascript/issues/2572.\n            sentry_key: dsn.publicKey,\n            sentry_version: SENTRY_API_VERSION,\n        };\n        return urlEncode(auth);\n    };\n    return API;\n}());\nexport { API };\n//# sourceMappingURL=api.js.map","import { SentryError } from './error';\nimport { SyncPromise } from './syncpromise';\n/** A simple queue that holds promises. */\nvar PromiseBuffer = /** @class */ (function () {\n    function PromiseBuffer(_limit) {\n        this._limit = _limit;\n        /** Internal set of queued Promises */\n        this._buffer = [];\n    }\n    /**\n     * Says if the buffer is ready to take more requests\n     */\n    PromiseBuffer.prototype.isReady = function () {\n        return this._limit === undefined || this.length() < this._limit;\n    };\n    /**\n     * Add a promise to the queue.\n     *\n     * @param task Can be any PromiseLike<T>\n     * @returns The original promise.\n     */\n    PromiseBuffer.prototype.add = function (task) {\n        var _this = this;\n        if (!this.isReady()) {\n            return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));\n        }\n        if (this._buffer.indexOf(task) === -1) {\n            this._buffer.push(task);\n        }\n        task\n            .then(function () { return _this.remove(task); })\n            .then(null, function () {\n            return _this.remove(task).then(null, function () {\n                // We have to add this catch here otherwise we have an unhandledPromiseRejection\n                // because it's a new Promise chain.\n            });\n        });\n        return task;\n    };\n    /**\n     * Remove a promise to the queue.\n     *\n     * @param task Can be any PromiseLike<T>\n     * @returns Removed promise.\n     */\n    PromiseBuffer.prototype.remove = function (task) {\n        var removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];\n        return removedTask;\n    };\n    /**\n     * This function returns the number of unresolved promises in the queue.\n     */\n    PromiseBuffer.prototype.length = function () {\n        return this._buffer.length;\n    };\n    /**\n     * This will drain the whole queue, returns true if queue is empty or drained.\n     * If timeout is provided and the queue takes longer to drain, the promise still resolves but with false.\n     *\n     * @param timeout Number in ms to wait until it resolves with false.\n     */\n    PromiseBuffer.prototype.drain = function (timeout) {\n        var _this = this;\n        return new SyncPromise(function (resolve) {\n            var capturedSetTimeout = setTimeout(function () {\n                if (timeout && timeout > 0) {\n                    resolve(false);\n                }\n            }, timeout);\n            SyncPromise.all(_this._buffer)\n                .then(function () {\n                clearTimeout(capturedSetTimeout);\n                resolve(true);\n            })\n                .then(null, function () {\n                resolve(true);\n            });\n        });\n    };\n    return PromiseBuffer;\n}());\nexport { PromiseBuffer };\n//# sourceMappingURL=promisebuffer.js.map","import { __values } from \"tslib\";\nimport { API } from '@sentry/core';\nimport { Status, } from '@sentry/types';\nimport { logger, parseRetryAfterHeader, PromiseBuffer, SentryError } from '@sentry/utils';\nvar CATEGORY_MAPPING = {\n    event: 'error',\n    transaction: 'transaction',\n    session: 'session',\n    attachment: 'attachment',\n};\n/** Base Transport class implementation */\nvar BaseTransport = /** @class */ (function () {\n    function BaseTransport(options) {\n        this.options = options;\n        /** A simple buffer holding all requests. */\n        this._buffer = new PromiseBuffer(30);\n        /** Locks transport after receiving rate limits in a response */\n        this._rateLimits = {};\n        this._api = new API(options.dsn, options._metadata);\n        // eslint-disable-next-line deprecation/deprecation\n        this.url = this._api.getStoreEndpointWithUrlEncodedAuth();\n    }\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.sendEvent = function (_) {\n        throw new SentryError('Transport Class has to implement `sendEvent` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.close = function (timeout) {\n        return this._buffer.drain(timeout);\n    };\n    /**\n     * Handle Sentry repsonse for promise-based transports.\n     */\n    BaseTransport.prototype._handleResponse = function (_a) {\n        var requestType = _a.requestType, response = _a.response, headers = _a.headers, resolve = _a.resolve, reject = _a.reject;\n        var status = Status.fromHttpCode(response.status);\n        /**\n         * \"The name is case-insensitive.\"\n         * https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n         */\n        var limited = this._handleRateLimit(headers);\n        if (limited)\n            logger.warn(\"Too many requests, backing off until: \" + this._disabledUntil(requestType));\n        if (status === Status.Success) {\n            resolve({ status: status });\n            return;\n        }\n        reject(response);\n    };\n    /**\n     * Gets the time that given category is disabled until for rate limiting\n     */\n    BaseTransport.prototype._disabledUntil = function (requestType) {\n        var category = CATEGORY_MAPPING[requestType];\n        return this._rateLimits[category] || this._rateLimits.all;\n    };\n    /**\n     * Checks if a category is rate limited\n     */\n    BaseTransport.prototype._isRateLimited = function (requestType) {\n        return this._disabledUntil(requestType) > new Date(Date.now());\n    };\n    /**\n     * Sets internal _rateLimits from incoming headers. Returns true if headers contains a non-empty rate limiting header.\n     */\n    BaseTransport.prototype._handleRateLimit = function (headers) {\n        var e_1, _a, e_2, _b;\n        var now = Date.now();\n        var rlHeader = headers['x-sentry-rate-limits'];\n        var raHeader = headers['retry-after'];\n        if (rlHeader) {\n            try {\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 ms\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                for (var _c = __values(rlHeader.trim().split(',')), _d = _c.next(); !_d.done; _d = _c.next()) {\n                    var limit = _d.value;\n                    var parameters = limit.split(':', 2);\n                    var headerDelay = parseInt(parameters[0], 10);\n                    var delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n                    try {\n                        for (var _e = (e_2 = void 0, __values(parameters[1].split(';'))), _f = _e.next(); !_f.done; _f = _e.next()) {\n                            var category = _f.value;\n                            this._rateLimits[category || 'all'] = new Date(now + delay);\n                        }\n                    }\n                    catch (e_2_1) { e_2 = { error: e_2_1 }; }\n                    finally {\n                        try {\n                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);\n                        }\n                        finally { if (e_2) throw e_2.error; }\n                    }\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n            return true;\n        }\n        else if (raHeader) {\n            this._rateLimits.all = new Date(now + parseRetryAfterHeader(now, raHeader));\n            return true;\n        }\n        return false;\n    };\n    return BaseTransport;\n}());\nexport { BaseTransport };\n//# sourceMappingURL=base.js.map","import { __extends } from \"tslib\";\nimport { eventToSentryRequest, sessionToSentryRequest } from '@sentry/core';\nimport { getGlobalObject, isNativeFetch, logger, supportsReferrerPolicy, SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\n/**\n * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.\n * Whenever someone wraps the Fetch API and returns the wrong promise chain,\n * this chain becomes orphaned and there is no possible way to capture it's rejections\n * other than allowing it bubble up to this very handler. eg.\n *\n * const f = window.fetch;\n * window.fetch = function () {\n *   const p = f.apply(this, arguments);\n *\n *   p.then(function() {\n *     console.log('hi.');\n *   });\n *\n *   return p;\n * }\n *\n * `p.then(function () { ... })` is producing a completely separate promise chain,\n * however, what's returned is `p` - the result of original `fetch` call.\n *\n * This mean, that whenever we use the Fetch API to send our own requests, _and_\n * some ad-blocker blocks it, this orphaned chain will _always_ reject,\n * effectively causing another event to be captured.\n * This makes a whole process become an infinite loop, which we need to somehow\n * deal with, and break it in one way or another.\n *\n * To deal with this issue, we are making sure that we _always_ use the real\n * browser Fetch API, instead of relying on what `window.fetch` exposes.\n * The only downside to this would be missing our own requests as breadcrumbs,\n * but because we are already not doing this, it should be just fine.\n *\n * Possible failed fetch error messages per-browser:\n *\n * Chrome:  Failed to fetch\n * Edge:    Failed to Fetch\n * Firefox: NetworkError when attempting to fetch resource\n * Safari:  resource blocked by content blocker\n */\nfunction getNativeFetchImplementation() {\n    /* eslint-disable @typescript-eslint/unbound-method */\n    var _a, _b;\n    // Fast path to avoid DOM I/O\n    var global = getGlobalObject();\n    if (isNativeFetch(global.fetch)) {\n        return global.fetch.bind(global);\n    }\n    var document = global.document;\n    var fetchImpl = global.fetch;\n    // eslint-disable-next-line deprecation/deprecation\n    if (typeof ((_a = document) === null || _a === void 0 ? void 0 : _a.createElement) === \"function\") {\n        try {\n            var sandbox = document.createElement('iframe');\n            sandbox.hidden = true;\n            document.head.appendChild(sandbox);\n            if ((_b = sandbox.contentWindow) === null || _b === void 0 ? void 0 : _b.fetch) {\n                fetchImpl = sandbox.contentWindow.fetch;\n            }\n            document.head.removeChild(sandbox);\n        }\n        catch (e) {\n            logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);\n        }\n    }\n    return fetchImpl.bind(global);\n    /* eslint-enable @typescript-eslint/unbound-method */\n}\n/** `fetch` based transport */\nvar FetchTransport = /** @class */ (function (_super) {\n    __extends(FetchTransport, _super);\n    function FetchTransport(options, fetchImpl) {\n        if (fetchImpl === void 0) { fetchImpl = getNativeFetchImplementation(); }\n        var _this = _super.call(this, options) || this;\n        _this._fetch = fetchImpl;\n        return _this;\n    }\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendEvent = function (event) {\n        return this._sendRequest(eventToSentryRequest(event, this._api), event);\n    };\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendSession = function (session) {\n        return this._sendRequest(sessionToSentryRequest(session, this._api), session);\n    };\n    /**\n     * @param sentryRequest Prepared SentryRequest to be delivered\n     * @param originalPayload Original payload used to create SentryRequest\n     */\n    FetchTransport.prototype._sendRequest = function (sentryRequest, originalPayload) {\n        var _this = this;\n        if (this._isRateLimited(sentryRequest.type)) {\n            return Promise.reject({\n                event: originalPayload,\n                type: sentryRequest.type,\n                reason: \"Transport locked till \" + this._disabledUntil(sentryRequest.type) + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        var options = {\n            body: sentryRequest.body,\n            method: 'POST',\n            // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default\n            // https://caniuse.com/#feat=referrer-policy\n            // It doesn't. And it throw exception instead of ignoring this parameter...\n            // REF: https://github.com/getsentry/raven-js/issues/1233\n            referrerPolicy: (supportsReferrerPolicy() ? 'origin' : ''),\n        };\n        if (this.options.fetchParameters !== undefined) {\n            Object.assign(options, this.options.fetchParameters);\n        }\n        if (this.options.headers !== undefined) {\n            options.headers = this.options.headers;\n        }\n        return this._buffer.add(new SyncPromise(function (resolve, reject) {\n            _this._fetch(sentryRequest.url, options)\n                .then(function (response) {\n                var headers = {\n                    'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n                    'retry-after': response.headers.get('Retry-After'),\n                };\n                _this._handleResponse({\n                    requestType: sentryRequest.type,\n                    response: response,\n                    headers: headers,\n                    resolve: resolve,\n                    reject: reject,\n                });\n            })\n                .catch(reject);\n        }));\n    };\n    return FetchTransport;\n}(BaseTransport));\nexport { FetchTransport };\n//# sourceMappingURL=fetch.js.map","import { __extends } from \"tslib\";\nimport { eventToSentryRequest, sessionToSentryRequest } from '@sentry/core';\nimport { SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\n/** `XHR` based transport */\nvar XHRTransport = /** @class */ (function (_super) {\n    __extends(XHRTransport, _super);\n    function XHRTransport() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendEvent = function (event) {\n        return this._sendRequest(eventToSentryRequest(event, this._api), event);\n    };\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendSession = function (session) {\n        return this._sendRequest(sessionToSentryRequest(session, this._api), session);\n    };\n    /**\n     * @param sentryRequest Prepared SentryRequest to be delivered\n     * @param originalPayload Original payload used to create SentryRequest\n     */\n    XHRTransport.prototype._sendRequest = function (sentryRequest, originalPayload) {\n        var _this = this;\n        if (this._isRateLimited(sentryRequest.type)) {\n            return Promise.reject({\n                event: originalPayload,\n                type: sentryRequest.type,\n                reason: \"Transport locked till \" + this._disabledUntil(sentryRequest.type) + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        return this._buffer.add(new SyncPromise(function (resolve, reject) {\n            var request = new XMLHttpRequest();\n            request.onreadystatechange = function () {\n                if (request.readyState === 4) {\n                    var headers = {\n                        'x-sentry-rate-limits': request.getResponseHeader('X-Sentry-Rate-Limits'),\n                        'retry-after': request.getResponseHeader('Retry-After'),\n                    };\n                    _this._handleResponse({ requestType: sentryRequest.type, response: request, headers: headers, resolve: resolve, reject: reject });\n                }\n            };\n            request.open('POST', sentryRequest.url);\n            for (var header in _this.options.headers) {\n                if (_this.options.headers.hasOwnProperty(header)) {\n                    request.setRequestHeader(header, _this.options.headers[header]);\n                }\n            }\n            request.send(sentryRequest.body);\n        }));\n    };\n    return XHRTransport;\n}(BaseTransport));\nexport { XHRTransport };\n//# sourceMappingURL=xhr.js.map","import { __assign, __extends } from \"tslib\";\nimport { BaseBackend } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { supportsFetch } from '@sentry/utils';\nimport { eventFromException, eventFromMessage } from './eventbuilder';\nimport { FetchTransport, XHRTransport } from './transports';\n/**\n * The Sentry Browser SDK Backend.\n * @hidden\n */\nvar BrowserBackend = /** @class */ (function (_super) {\n    __extends(BrowserBackend, _super);\n    function BrowserBackend() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromException = function (exception, hint) {\n        return eventFromException(this._options, exception, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromMessage = function (message, level, hint) {\n        if (level === void 0) { level = Severity.Info; }\n        return eventFromMessage(this._options, message, level, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype._setupTransport = function () {\n        if (!this._options.dsn) {\n            // We return the noop transport here in case there is no Dsn.\n            return _super.prototype._setupTransport.call(this);\n        }\n        var transportOptions = __assign(__assign({}, this._options.transportOptions), { dsn: this._options.dsn, _metadata: this._options._metadata });\n        if (this._options.transport) {\n            return new this._options.transport(transportOptions);\n        }\n        if (supportsFetch()) {\n            return new FetchTransport(transportOptions);\n        }\n        return new XHRTransport(transportOptions);\n    };\n    return BrowserBackend;\n}(BaseBackend));\nexport { BrowserBackend };\n//# sourceMappingURL=backend.js.map","import { __assign } from \"tslib\";\nimport { API, captureException, withScope } from '@sentry/core';\nimport { addExceptionMechanism, addExceptionTypeValue, logger } from '@sentry/utils';\nvar ignoreOnError = 0;\n/**\n * @hidden\n */\nexport function shouldIgnoreOnError() {\n    return ignoreOnError > 0;\n}\n/**\n * @hidden\n */\nexport function ignoreNextOnError() {\n    // onerror should trigger before setTimeout\n    ignoreOnError += 1;\n    setTimeout(function () {\n        ignoreOnError -= 1;\n    });\n}\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap.\n * @returns The wrapped function.\n * @hidden\n */\nexport function wrap(fn, options, before) {\n    if (options === void 0) { options = {}; }\n    if (typeof fn !== 'function') {\n        return fn;\n    }\n    try {\n        // We don't wanna wrap it twice\n        if (fn.__sentry__) {\n            return fn;\n        }\n        // If this has already been wrapped in the past, return that wrapped function\n        if (fn.__sentry_wrapped__) {\n            return fn.__sentry_wrapped__;\n        }\n    }\n    catch (e) {\n        // Just accessing custom props in some Selenium environments\n        // can cause a \"Permission denied\" exception (see raven-js#495).\n        // Bail on wrapping and return the function as-is (defers to window.onerror).\n        return fn;\n    }\n    /* eslint-disable prefer-rest-params */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var sentryWrapped = function () {\n        var args = Array.prototype.slice.call(arguments);\n        try {\n            if (before && typeof before === 'function') {\n                before.apply(this, arguments);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n            var wrappedArguments = args.map(function (arg) { return wrap(arg, options); });\n            if (fn.handleEvent) {\n                // Attempt to invoke user-land function\n                // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n                //       means the sentry.javascript SDK caught an error invoking your application code. This\n                //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                return fn.handleEvent.apply(this, wrappedArguments);\n            }\n            // Attempt to invoke user-land function\n            // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n            //       means the sentry.javascript SDK caught an error invoking your application code. This\n            //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n            return fn.apply(this, wrappedArguments);\n        }\n        catch (ex) {\n            ignoreNextOnError();\n            withScope(function (scope) {\n                scope.addEventProcessor(function (event) {\n                    var processedEvent = __assign({}, event);\n                    if (options.mechanism) {\n                        addExceptionTypeValue(processedEvent, undefined, undefined);\n                        addExceptionMechanism(processedEvent, options.mechanism);\n                    }\n                    processedEvent.extra = __assign(__assign({}, processedEvent.extra), { arguments: args });\n                    return processedEvent;\n                });\n                captureException(ex);\n            });\n            throw ex;\n        }\n    };\n    /* eslint-enable prefer-rest-params */\n    // Accessing some objects may throw\n    // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n    try {\n        for (var property in fn) {\n            if (Object.prototype.hasOwnProperty.call(fn, property)) {\n                sentryWrapped[property] = fn[property];\n            }\n        }\n    }\n    catch (_oO) { } // eslint-disable-line no-empty\n    fn.prototype = fn.prototype || {};\n    sentryWrapped.prototype = fn.prototype;\n    Object.defineProperty(fn, '__sentry_wrapped__', {\n        enumerable: false,\n        value: sentryWrapped,\n    });\n    // Signal that this function has been wrapped/filled already\n    // for both debugging and to prevent it to being wrapped/filled twice\n    Object.defineProperties(sentryWrapped, {\n        __sentry__: {\n            enumerable: false,\n            value: true,\n        },\n        __sentry_original__: {\n            enumerable: false,\n            value: fn,\n        },\n    });\n    // Restore original function name (not all browsers allow that)\n    try {\n        var descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name');\n        if (descriptor.configurable) {\n            Object.defineProperty(sentryWrapped, 'name', {\n                get: function () {\n                    return fn.name;\n                },\n            });\n        }\n        // eslint-disable-next-line no-empty\n    }\n    catch (_oO) { }\n    return sentryWrapped;\n}\n/**\n * Injects the Report Dialog script\n * @hidden\n */\nexport function injectReportDialog(options) {\n    if (options === void 0) { options = {}; }\n    if (!options.eventId) {\n        logger.error(\"Missing eventId option in showReportDialog call\");\n        return;\n    }\n    if (!options.dsn) {\n        logger.error(\"Missing dsn option in showReportDialog call\");\n        return;\n    }\n    var script = document.createElement('script');\n    script.async = true;\n    script.src = new API(options.dsn).getReportDialogEndpoint(options);\n    if (options.onLoad) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        script.onload = options.onLoad;\n    }\n    (document.head || document.body).appendChild(script);\n}\n//# sourceMappingURL=helpers.js.map","import { __assign, __values } from \"tslib\";\nimport { isInstanceOf, isString } from './is';\nimport { logger } from './logger';\nimport { getGlobalObject } from './misc';\nimport { fill } from './object';\nimport { getFunctionName } from './stacktrace';\nimport { supportsHistory, supportsNativeFetch } from './supports';\nvar global = getGlobalObject();\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 */\nvar handlers = {};\nvar instrumented = {};\n/** Instruments given API */\nfunction instrument(type) {\n    if (instrumented[type]) {\n        return;\n    }\n    instrumented[type] = true;\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            logger.warn('unknown instrumentation type:', type);\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 */\nexport function addInstrumentationHandler(handler) {\n    if (!handler || typeof handler.type !== 'string' || typeof handler.callback !== 'function') {\n        return;\n    }\n    handlers[handler.type] = handlers[handler.type] || [];\n    handlers[handler.type].push(handler.callback);\n    instrument(handler.type);\n}\n/** JSDoc */\nfunction triggerHandlers(type, data) {\n    var e_1, _a;\n    if (!type || !handlers[type]) {\n        return;\n    }\n    try {\n        for (var _b = __values(handlers[type] || []), _c = _b.next(); !_c.done; _c = _b.next()) {\n            var handler = _c.value;\n            try {\n                handler(data);\n            }\n            catch (e) {\n                logger.error(\"Error while triggering instrumentation handler.\\nType: \" + type + \"\\nName: \" + getFunctionName(handler) + \"\\nError: \" + e);\n            }\n        }\n    }\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n    finally {\n        try {\n            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n        }\n        finally { if (e_1) throw e_1.error; }\n    }\n}\n/** JSDoc */\nfunction instrumentConsole() {\n    if (!('console' in global)) {\n        return;\n    }\n    ['debug', 'info', 'warn', 'error', 'log', 'assert'].forEach(function (level) {\n        if (!(level in global.console)) {\n            return;\n        }\n        fill(global.console, level, function (originalConsoleLevel) {\n            return function () {\n                var args = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    args[_i] = arguments[_i];\n                }\n                triggerHandlers('console', { args: args, level: level });\n                // this fails for some browsers. :(\n                if (originalConsoleLevel) {\n                    Function.prototype.apply.call(originalConsoleLevel, global.console, args);\n                }\n            };\n        });\n    });\n}\n/** JSDoc */\nfunction instrumentFetch() {\n    if (!supportsNativeFetch()) {\n        return;\n    }\n    fill(global, 'fetch', function (originalFetch) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var handlerData = {\n                args: args,\n                fetchData: {\n                    method: getFetchMethod(args),\n                    url: getFetchUrl(args),\n                },\n                startTimestamp: Date.now(),\n            };\n            triggerHandlers('fetch', __assign({}, handlerData));\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            return originalFetch.apply(global, args).then(function (response) {\n                triggerHandlers('fetch', __assign(__assign({}, handlerData), { endTimestamp: Date.now(), response: response }));\n                return response;\n            }, function (error) {\n                triggerHandlers('fetch', __assign(__assign({}, handlerData), { endTimestamp: Date.now(), error: error }));\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/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs) {\n    if (fetchArgs === void 0) { 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/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs) {\n    if (fetchArgs === void 0) { 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/* eslint-enable @typescript-eslint/no-unsafe-member-access */\n/** JSDoc */\nfunction instrumentXHR() {\n    if (!('XMLHttpRequest' in global)) {\n        return;\n    }\n    // Poor man's implementation of ES6 `Map`, tracking and keeping in sync key and value separately.\n    var requestKeys = [];\n    var requestValues = [];\n    var xhrproto = XMLHttpRequest.prototype;\n    fill(xhrproto, 'open', function (originalOpen) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            // eslint-disable-next-line @typescript-eslint/no-this-alias\n            var xhr = this;\n            var url = args[1];\n            xhr.__sentry_xhr__ = {\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n                url: args[1],\n            };\n            // if Sentry key appears in URL, don't capture it as a request\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            if (isString(url) && xhr.__sentry_xhr__.method === 'POST' && url.match(/sentry_key/)) {\n                xhr.__sentry_own_request__ = true;\n            }\n            var onreadystatechangeHandler = function () {\n                if (xhr.readyState === 4) {\n                    try {\n                        // touching statusCode in some platforms throws\n                        // an exception\n                        if (xhr.__sentry_xhr__) {\n                            xhr.__sentry_xhr__.status_code = xhr.status;\n                        }\n                    }\n                    catch (e) {\n                        /* do nothing */\n                    }\n                    try {\n                        var requestPos = requestKeys.indexOf(xhr);\n                        if (requestPos !== -1) {\n                            // Make sure to pop both key and value to keep it in sync.\n                            requestKeys.splice(requestPos);\n                            var args_1 = requestValues.splice(requestPos)[0];\n                            if (xhr.__sentry_xhr__ && args_1[0] !== undefined) {\n                                xhr.__sentry_xhr__.body = args_1[0];\n                            }\n                        }\n                    }\n                    catch (e) {\n                        /* do nothing */\n                    }\n                    triggerHandlers('xhr', {\n                        args: args,\n                        endTimestamp: Date.now(),\n                        startTimestamp: Date.now(),\n                        xhr: xhr,\n                    });\n                }\n            };\n            if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n                fill(xhr, 'onreadystatechange', function (original) {\n                    return function () {\n                        var readyStateArgs = [];\n                        for (var _i = 0; _i < arguments.length; _i++) {\n                            readyStateArgs[_i] = arguments[_i];\n                        }\n                        onreadystatechangeHandler();\n                        return original.apply(xhr, readyStateArgs);\n                    };\n                });\n            }\n            else {\n                xhr.addEventListener('readystatechange', onreadystatechangeHandler);\n            }\n            return originalOpen.apply(xhr, args);\n        };\n    });\n    fill(xhrproto, 'send', function (originalSend) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            requestKeys.push(this);\n            requestValues.push(args);\n            triggerHandlers('xhr', {\n                args: args,\n                startTimestamp: Date.now(),\n                xhr: this,\n            });\n            return originalSend.apply(this, args);\n        };\n    });\n}\nvar lastHref;\n/** JSDoc */\nfunction instrumentHistory() {\n    if (!supportsHistory()) {\n        return;\n    }\n    var oldOnPopState = global.onpopstate;\n    global.onpopstate = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\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: from,\n            to: 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            }\n            catch (_oO) {\n                // no-empty\n            }\n        }\n    };\n    /** @hidden */\n    function historyReplacementFunction(originalHistoryFunction) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\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: from,\n                    to: to,\n                });\n            }\n            return originalHistoryFunction.apply(this, args);\n        };\n    }\n    fill(global.history, 'pushState', historyReplacementFunction);\n    fill(global.history, 'replaceState', historyReplacementFunction);\n}\nvar debounceDuration = 1000;\nvar debounceTimerID;\nvar lastCapturedEvent;\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    // 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    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    }\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    // 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 * 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    try {\n        var target = event.target;\n        if (!target || !target.tagName) {\n            return true;\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    }\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    return true;\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) {\n    if (globalListener === void 0) { globalListener = false; }\n    return function (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        // We always want to skip _some_ events.\n        if (shouldSkipDOMEvent(event)) {\n            return;\n        }\n        var name = event.type === 'keypress' ? 'input' : event.type;\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: 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: name,\n                global: globalListener,\n            });\n            lastCapturedEvent = event;\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(function () {\n            debounceTimerID = undefined;\n        }, debounceDuration);\n    };\n}\n/** JSDoc */\nfunction instrumentDOM() {\n    if (!('document' in global)) {\n        return;\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    // 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(function (target) {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        var proto = global[target] && global[target].prototype;\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\n        fill(proto, 'addEventListener', function (originalAddEventListener) {\n            return function (type, listener, options) {\n                if (type === 'click' || type == 'keypress') {\n                    try {\n                        var el = this;\n                        var handlers_1 = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});\n                        var handlerForType = (handlers_1[type] = handlers_1[type] || { refCount: 0 });\n                        if (!handlerForType.handler) {\n                            var handler = makeDOMEventHandler(triggerDOMHandler);\n                            handlerForType.handler = handler;\n                            originalAddEventListener.call(this, type, handler, options);\n                        }\n                        handlerForType.refCount += 1;\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                return originalAddEventListener.call(this, type, listener, options);\n            };\n        });\n        fill(proto, 'removeEventListener', function (originalRemoveEventListener) {\n            return function (type, listener, options) {\n                if (type === 'click' || type == 'keypress') {\n                    try {\n                        var el = this;\n                        var handlers_2 = el.__sentry_instrumentation_handlers__ || {};\n                        var handlerForType = handlers_2[type];\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_2[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete\n                            }\n                            // If there are no longer any custom handlers of any type on this element, cleanup everything.\n                            if (Object.keys(handlers_2).length === 0) {\n                                delete el.__sentry_instrumentation_handlers__;\n                            }\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                return originalRemoveEventListener.call(this, type, listener, options);\n            };\n        });\n    });\n}\nvar _oldOnErrorHandler = null;\n/** JSDoc */\nfunction instrumentError() {\n    _oldOnErrorHandler = global.onerror;\n    global.onerror = function (msg, url, line, column, error) {\n        triggerHandlers('error', {\n            column: column,\n            error: error,\n            line: line,\n            msg: msg,\n            url: url,\n        });\n        if (_oldOnErrorHandler) {\n            // eslint-disable-next-line prefer-rest-params\n            return _oldOnErrorHandler.apply(this, arguments);\n        }\n        return false;\n    };\n}\nvar _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection() {\n    _oldOnUnhandledRejectionHandler = global.onunhandledrejection;\n    global.onunhandledrejection = function (e) {\n        triggerHandlers('unhandledrejection', e);\n        if (_oldOnUnhandledRejectionHandler) {\n            // eslint-disable-next-line prefer-rest-params\n            return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n        }\n        return true;\n    };\n}\n//# sourceMappingURL=instrument.js.map","var originalFunctionToString;\n/** Patch toString calls to return proper name for wrapped functions */\nvar FunctionToString = /** @class */ (function () {\n    function FunctionToString() {\n        /**\n         * @inheritDoc\n         */\n        this.name = FunctionToString.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    FunctionToString.prototype.setupOnce = function () {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        originalFunctionToString = Function.prototype.toString;\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        Function.prototype.toString = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var context = this.__sentry_original__ || this;\n            return originalFunctionToString.apply(context, args);\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    FunctionToString.id = 'FunctionToString';\n    return FunctionToString;\n}());\nexport { FunctionToString };\n//# sourceMappingURL=functiontostring.js.map","import { __assign, __read, __spread } from \"tslib\";\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable max-lines */\nimport { getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addInstrumentationHandler, getEventDescription, getGlobalObject, htmlTreeAsString, parseUrl, safeJoin, } from '@sentry/utils';\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nvar Breadcrumbs = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function Breadcrumbs(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = Breadcrumbs.id;\n        this._options = __assign({ console: true, dom: true, fetch: true, history: true, sentry: true, xhr: true }, options);\n    }\n    /**\n     * Create a breadcrumb of `sentry` from the events themselves\n     */\n    Breadcrumbs.prototype.addSentryBreadcrumb = function (event) {\n        if (!this._options.sentry) {\n            return;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: \"sentry.\" + (event.type === 'transaction' ? 'transaction' : 'event'),\n            event_id: event.event_id,\n            level: event.level,\n            message: getEventDescription(event),\n        }, {\n            event: event,\n        });\n    };\n    /**\n     * Instrument browser built-ins w/ breadcrumb capturing\n     *  - Console API\n     *  - DOM API (click/typing)\n     *  - XMLHttpRequest API\n     *  - Fetch API\n     *  - History API\n     */\n    Breadcrumbs.prototype.setupOnce = function () {\n        var _this = this;\n        if (this._options.console) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._consoleBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'console',\n            });\n        }\n        if (this._options.dom) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._domBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'dom',\n            });\n        }\n        if (this._options.xhr) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._xhrBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'xhr',\n            });\n        }\n        if (this._options.fetch) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._fetchBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'fetch',\n            });\n        }\n        if (this._options.history) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._historyBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'history',\n            });\n        }\n    };\n    /**\n     * Creates breadcrumbs from console API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._consoleBreadcrumb = function (handlerData) {\n        var breadcrumb = {\n            category: 'console',\n            data: {\n                arguments: handlerData.args,\n                logger: 'console',\n            },\n            level: Severity.fromString(handlerData.level),\n            message: safeJoin(handlerData.args, ' '),\n        };\n        if (handlerData.level === 'assert') {\n            if (handlerData.args[0] === false) {\n                breadcrumb.message = \"Assertion failed: \" + (safeJoin(handlerData.args.slice(1), ' ') || 'console.assert');\n                breadcrumb.data.arguments = handlerData.args.slice(1);\n            }\n            else {\n                // Don't capture a breadcrumb for passed assertions\n                return;\n            }\n        }\n        getCurrentHub().addBreadcrumb(breadcrumb, {\n            input: handlerData.args,\n            level: handlerData.level,\n        });\n    };\n    /**\n     * Creates breadcrumbs from DOM API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._domBreadcrumb = function (handlerData) {\n        var target;\n        // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n        try {\n            target = handlerData.event.target\n                ? htmlTreeAsString(handlerData.event.target)\n                : htmlTreeAsString(handlerData.event);\n        }\n        catch (e) {\n            target = '<unknown>';\n        }\n        if (target.length === 0) {\n            return;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: \"ui.\" + handlerData.name,\n            message: target,\n        }, {\n            event: handlerData.event,\n            name: handlerData.name,\n            global: handlerData.global,\n        });\n    };\n    /**\n     * Creates breadcrumbs from XHR API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._xhrBreadcrumb = function (handlerData) {\n        if (handlerData.endTimestamp) {\n            // We only capture complete, non-sentry requests\n            if (handlerData.xhr.__sentry_own_request__) {\n                return;\n            }\n            var _a = handlerData.xhr.__sentry_xhr__ || {}, method = _a.method, url = _a.url, status_code = _a.status_code, body = _a.body;\n            getCurrentHub().addBreadcrumb({\n                category: 'xhr',\n                data: {\n                    method: method,\n                    url: url,\n                    status_code: status_code,\n                },\n                type: 'http',\n            }, {\n                xhr: handlerData.xhr,\n                input: body,\n            });\n            return;\n        }\n    };\n    /**\n     * Creates breadcrumbs from fetch API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._fetchBreadcrumb = function (handlerData) {\n        // We only capture complete fetch requests\n        if (!handlerData.endTimestamp) {\n            return;\n        }\n        if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {\n            // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)\n            return;\n        }\n        if (handlerData.error) {\n            getCurrentHub().addBreadcrumb({\n                category: 'fetch',\n                data: handlerData.fetchData,\n                level: Severity.Error,\n                type: 'http',\n            }, {\n                data: handlerData.error,\n                input: handlerData.args,\n            });\n        }\n        else {\n            getCurrentHub().addBreadcrumb({\n                category: 'fetch',\n                data: __assign(__assign({}, handlerData.fetchData), { status_code: handlerData.response.status }),\n                type: 'http',\n            }, {\n                input: handlerData.args,\n                response: handlerData.response,\n            });\n        }\n    };\n    /**\n     * Creates breadcrumbs from history API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._historyBreadcrumb = function (handlerData) {\n        var global = getGlobalObject();\n        var from = handlerData.from;\n        var to = handlerData.to;\n        var parsedLoc = parseUrl(global.location.href);\n        var parsedFrom = parseUrl(from);\n        var parsedTo = parseUrl(to);\n        // Initial pushState doesn't provide `from` information\n        if (!parsedFrom.path) {\n            parsedFrom = parsedLoc;\n        }\n        // Use only the path component of the URL if the URL matches the current\n        // document (almost all the time when using pushState)\n        if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n            to = parsedTo.relative;\n        }\n        if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n            from = parsedFrom.relative;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: 'navigation',\n            data: {\n                from: from,\n                to: to,\n            },\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    Breadcrumbs.id = 'Breadcrumbs';\n    return Breadcrumbs;\n}());\nexport { Breadcrumbs };\n//# sourceMappingURL=breadcrumbs.js.map","import { __assign, __extends } from \"tslib\";\nimport { BaseClient, SDK_VERSION } from '@sentry/core';\nimport { getGlobalObject, logger } from '@sentry/utils';\nimport { BrowserBackend } from './backend';\nimport { injectReportDialog } from './helpers';\nimport { Breadcrumbs } from './integrations';\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nvar BrowserClient = /** @class */ (function (_super) {\n    __extends(BrowserClient, _super);\n    /**\n     * Creates a new Browser SDK instance.\n     *\n     * @param options Configuration options for this SDK.\n     */\n    function BrowserClient(options) {\n        if (options === void 0) { options = {}; }\n        var _this = this;\n        options._metadata = options._metadata || {};\n        options._metadata.sdk = options._metadata.sdk || {\n            name: 'sentry.javascript.browser',\n            packages: [\n                {\n                    name: 'npm:@sentry/browser',\n                    version: SDK_VERSION,\n                },\n            ],\n            version: SDK_VERSION,\n        };\n        _this = _super.call(this, BrowserBackend, options) || this;\n        return _this;\n    }\n    /**\n     * Show a report dialog to the user to send feedback to a specific event.\n     *\n     * @param options Set individual options for the dialog\n     */\n    BrowserClient.prototype.showReportDialog = function (options) {\n        if (options === void 0) { options = {}; }\n        // doesn't work without a document (React Native)\n        var document = getGlobalObject().document;\n        if (!document) {\n            return;\n        }\n        if (!this._isEnabled()) {\n            logger.error('Trying to call showReportDialog with Sentry Client disabled');\n            return;\n        }\n        injectReportDialog(__assign(__assign({}, options), { dsn: options.dsn || this.getDsn() }));\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._prepareEvent = function (event, scope, hint) {\n        event.platform = event.platform || 'javascript';\n        return _super.prototype._prepareEvent.call(this, event, scope, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._sendEvent = function (event) {\n        var integration = this.getIntegration(Breadcrumbs);\n        if (integration) {\n            integration.addSentryBreadcrumb(event);\n        }\n        _super.prototype._sendEvent.call(this, event);\n    };\n    return BrowserClient;\n}(BaseClient));\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map","import { __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { getEventDescription, isMatchingPattern, logger } from '@sentry/utils';\n// \"Script error.\" is hard coded into browsers for errors that it can't read.\n// this is the result of a script being pulled in from an external domain and CORS.\nvar DEFAULT_IGNORE_ERRORS = [/^Script error\\.?$/, /^Javascript error: Script error\\.? on line 0$/];\n/** Inbound filters configurable by the user */\nvar InboundFilters = /** @class */ (function () {\n    function InboundFilters(_options) {\n        if (_options === void 0) { _options = {}; }\n        this._options = _options;\n        /**\n         * @inheritDoc\n         */\n        this.name = InboundFilters.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    InboundFilters.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event) {\n            var hub = getCurrentHub();\n            if (!hub) {\n                return event;\n            }\n            var self = hub.getIntegration(InboundFilters);\n            if (self) {\n                var client = hub.getClient();\n                var clientOptions = client ? client.getOptions() : {};\n                // This checks prevents most of the occurrences of the bug linked below:\n                // https://github.com/getsentry/sentry-javascript/issues/2622\n                // The bug is caused by multiple SDK instances, where one is minified and one is using non-mangled code.\n                // Unfortunatelly we cannot fix it reliably (thus reserved property in rollup's terser config),\n                // as we cannot force people using multiple instances in their apps to sync SDK versions.\n                var options = typeof self._mergeOptions === 'function' ? self._mergeOptions(clientOptions) : {};\n                if (typeof self._shouldDropEvent !== 'function') {\n                    return event;\n                }\n                return self._shouldDropEvent(event, options) ? null : event;\n            }\n            return event;\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._shouldDropEvent = function (event, options) {\n        if (this._isSentryError(event, options)) {\n            logger.warn(\"Event dropped due to being internal Sentry Error.\\nEvent: \" + getEventDescription(event));\n            return true;\n        }\n        if (this._isIgnoredError(event, options)) {\n            logger.warn(\"Event dropped due to being matched by `ignoreErrors` option.\\nEvent: \" + getEventDescription(event));\n            return true;\n        }\n        if (this._isDeniedUrl(event, options)) {\n            logger.warn(\"Event dropped due to being matched by `denyUrls` option.\\nEvent: \" + getEventDescription(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        if (!this._isAllowedUrl(event, options)) {\n            logger.warn(\"Event dropped due to not being matched by `allowUrls` option.\\nEvent: \" + getEventDescription(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        return false;\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isSentryError = function (event, options) {\n        if (!options.ignoreInternal) {\n            return false;\n        }\n        try {\n            return ((event &&\n                event.exception &&\n                event.exception.values &&\n                event.exception.values[0] &&\n                event.exception.values[0].type === 'SentryError') ||\n                false);\n        }\n        catch (_oO) {\n            return false;\n        }\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isIgnoredError = function (event, options) {\n        if (!options.ignoreErrors || !options.ignoreErrors.length) {\n            return false;\n        }\n        return this._getPossibleEventMessages(event).some(function (message) {\n            // Not sure why TypeScript complains here...\n            return options.ignoreErrors.some(function (pattern) { return isMatchingPattern(message, pattern); });\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isDeniedUrl = function (event, options) {\n        // TODO: Use Glob instead?\n        if (!options.denyUrls || !options.denyUrls.length) {\n            return false;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? false : options.denyUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isAllowedUrl = function (event, options) {\n        // TODO: Use Glob instead?\n        if (!options.allowUrls || !options.allowUrls.length) {\n            return true;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? true : options.allowUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._mergeOptions = function (clientOptions) {\n        if (clientOptions === void 0) { clientOptions = {}; }\n        return {\n            allowUrls: __spread((this._options.whitelistUrls || []), (this._options.allowUrls || []), (clientOptions.whitelistUrls || []), (clientOptions.allowUrls || [])),\n            denyUrls: __spread((this._options.blacklistUrls || []), (this._options.denyUrls || []), (clientOptions.blacklistUrls || []), (clientOptions.denyUrls || [])),\n            ignoreErrors: __spread((this._options.ignoreErrors || []), (clientOptions.ignoreErrors || []), DEFAULT_IGNORE_ERRORS),\n            ignoreInternal: typeof this._options.ignoreInternal !== 'undefined' ? this._options.ignoreInternal : true,\n        };\n    };\n    /** JSDoc */\n    InboundFilters.prototype._getPossibleEventMessages = function (event) {\n        if (event.message) {\n            return [event.message];\n        }\n        if (event.exception) {\n            try {\n                var _a = (event.exception.values && event.exception.values[0]) || {}, _b = _a.type, type = _b === void 0 ? '' : _b, _c = _a.value, value = _c === void 0 ? '' : _c;\n                return [\"\" + value, type + \": \" + value];\n            }\n            catch (oO) {\n                logger.error(\"Cannot extract message for event \" + getEventDescription(event));\n                return [];\n            }\n        }\n        return [];\n    };\n    /** JSDoc */\n    InboundFilters.prototype._getEventFilterUrl = function (event) {\n        try {\n            if (event.stacktrace) {\n                var frames_1 = event.stacktrace.frames;\n                return (frames_1 && frames_1[frames_1.length - 1].filename) || null;\n            }\n            if (event.exception) {\n                var frames_2 = event.exception.values && event.exception.values[0].stacktrace && event.exception.values[0].stacktrace.frames;\n                return (frames_2 && frames_2[frames_2.length - 1].filename) || null;\n            }\n            return null;\n        }\n        catch (oO) {\n            logger.error(\"Cannot extract url for event \" + getEventDescription(event));\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    InboundFilters.id = 'InboundFilters';\n    return InboundFilters;\n}());\nexport { InboundFilters };\n//# sourceMappingURL=inboundfilters.js.map","import { __assign } from \"tslib\";\nimport { fill, getFunctionName, getGlobalObject } from '@sentry/utils';\nimport { wrap } from '../helpers';\nvar DEFAULT_EVENT_TARGET = [\n    'EventTarget',\n    'Window',\n    'Node',\n    'ApplicationCache',\n    'AudioTrackList',\n    'ChannelMergerNode',\n    'CryptoOperation',\n    'EventSource',\n    'FileReader',\n    'HTMLUnknownElement',\n    'IDBDatabase',\n    'IDBRequest',\n    'IDBTransaction',\n    'KeyOperation',\n    'MediaController',\n    'MessagePort',\n    'ModalWindow',\n    'Notification',\n    'SVGElementInstance',\n    'Screen',\n    'TextTrack',\n    'TextTrackCue',\n    'TextTrackList',\n    'WebSocket',\n    'WebSocketWorker',\n    'Worker',\n    'XMLHttpRequest',\n    'XMLHttpRequestEventTarget',\n    'XMLHttpRequestUpload',\n];\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\nvar TryCatch = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function TryCatch(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = TryCatch.id;\n        this._options = __assign({ XMLHttpRequest: true, eventTarget: true, requestAnimationFrame: true, setInterval: true, setTimeout: true }, options);\n    }\n    /**\n     * Wrap timer functions and event targets to catch errors\n     * and provide better metadata.\n     */\n    TryCatch.prototype.setupOnce = function () {\n        var global = getGlobalObject();\n        if (this._options.setTimeout) {\n            fill(global, 'setTimeout', this._wrapTimeFunction.bind(this));\n        }\n        if (this._options.setInterval) {\n            fill(global, 'setInterval', this._wrapTimeFunction.bind(this));\n        }\n        if (this._options.requestAnimationFrame) {\n            fill(global, 'requestAnimationFrame', this._wrapRAF.bind(this));\n        }\n        if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {\n            fill(XMLHttpRequest.prototype, 'send', this._wrapXHR.bind(this));\n        }\n        if (this._options.eventTarget) {\n            var eventTarget = Array.isArray(this._options.eventTarget) ? this._options.eventTarget : DEFAULT_EVENT_TARGET;\n            eventTarget.forEach(this._wrapEventTarget.bind(this));\n        }\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapTimeFunction = function (original) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var originalCallback = args[0];\n            args[0] = wrap(originalCallback, {\n                mechanism: {\n                    data: { function: getFunctionName(original) },\n                    handled: true,\n                    type: 'instrument',\n                },\n            });\n            return original.apply(this, args);\n        };\n    };\n    /** JSDoc */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    TryCatch.prototype._wrapRAF = function (original) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function (callback) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            return original.call(this, wrap(callback, {\n                mechanism: {\n                    data: {\n                        function: 'requestAnimationFrame',\n                        handler: getFunctionName(original),\n                    },\n                    handled: true,\n                    type: 'instrument',\n                },\n            }));\n        };\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapEventTarget = function (target) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        var global = getGlobalObject();\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        var proto = global[target] && global[target].prototype;\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\n        fill(proto, 'addEventListener', function (original) {\n            return function (eventName, fn, options) {\n                try {\n                    if (typeof fn.handleEvent === 'function') {\n                        fn.handleEvent = wrap(fn.handleEvent.bind(fn), {\n                            mechanism: {\n                                data: {\n                                    function: 'handleEvent',\n                                    handler: getFunctionName(fn),\n                                    target: target,\n                                },\n                                handled: true,\n                                type: 'instrument',\n                            },\n                        });\n                    }\n                }\n                catch (err) {\n                    // can sometimes get 'Permission denied to access property \"handle Event'\n                }\n                return original.call(this, eventName, \n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                wrap(fn, {\n                    mechanism: {\n                        data: {\n                            function: 'addEventListener',\n                            handler: getFunctionName(fn),\n                            target: target,\n                        },\n                        handled: true,\n                        type: 'instrument',\n                    },\n                }), options);\n            };\n        });\n        fill(proto, 'removeEventListener', function (originalRemoveEventListener) {\n            return function (eventName, fn, options) {\n                var _a;\n                /**\n                 * There are 2 possible scenarios here:\n                 *\n                 * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified\n                 * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function\n                 * as a pass-through, and call original `removeEventListener` with it.\n                 *\n                 * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using\n                 * our wrapped version of `addEventListener`, which internally calls `wrap` helper.\n                 * This helper \"wraps\" whole callback inside a try/catch statement, and attached appropriate metadata to it,\n                 * in order for us to make a distinction between wrapped/non-wrapped functions possible.\n                 * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.\n                 *\n                 * When someone adds a handler prior to initialization, and then do it again, but after,\n                 * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible\n                 * to get rid of the initial handler and it'd stick there forever.\n                 */\n                var wrappedEventHandler = fn;\n                try {\n                    var originalEventHandler = (_a = wrappedEventHandler) === null || _a === void 0 ? void 0 : _a.__sentry_wrapped__;\n                    if (originalEventHandler) {\n                        originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n                    }\n                }\n                catch (e) {\n                    // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n                }\n                return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);\n            };\n        });\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapXHR = function (originalSend) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            // eslint-disable-next-line @typescript-eslint/no-this-alias\n            var xhr = this;\n            var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n            xmlHttpRequestProps.forEach(function (prop) {\n                if (prop in xhr && typeof xhr[prop] === 'function') {\n                    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                    fill(xhr, prop, function (original) {\n                        var wrapOptions = {\n                            mechanism: {\n                                data: {\n                                    function: prop,\n                                    handler: getFunctionName(original),\n                                },\n                                handled: true,\n                                type: 'instrument',\n                            },\n                        };\n                        // If Instrument integration has been called before TryCatch, get the name of original function\n                        if (original.__sentry_original__) {\n                            wrapOptions.mechanism.data.handler = getFunctionName(original.__sentry_original__);\n                        }\n                        // Otherwise wrap directly\n                        return wrap(original, wrapOptions);\n                    });\n                }\n            });\n            return originalSend.apply(this, args);\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    TryCatch.id = 'TryCatch';\n    return TryCatch;\n}());\nexport { TryCatch };\n//# sourceMappingURL=trycatch.js.map","import { __assign } from \"tslib\";\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\nimport { getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, addInstrumentationHandler, getLocationHref, isErrorEvent, isPrimitive, isString, logger, } from '@sentry/utils';\nimport { eventFromUnknownInput } from '../eventbuilder';\nimport { shouldIgnoreOnError } from '../helpers';\n/** Global handlers */\nvar GlobalHandlers = /** @class */ (function () {\n    /** JSDoc */\n    function GlobalHandlers(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = GlobalHandlers.id;\n        /** JSDoc */\n        this._onErrorHandlerInstalled = false;\n        /** JSDoc */\n        this._onUnhandledRejectionHandlerInstalled = false;\n        this._options = __assign({ onerror: true, onunhandledrejection: true }, options);\n    }\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.prototype.setupOnce = function () {\n        Error.stackTraceLimit = 50;\n        if (this._options.onerror) {\n            logger.log('Global Handler attached: onerror');\n            this._installGlobalOnErrorHandler();\n        }\n        if (this._options.onunhandledrejection) {\n            logger.log('Global Handler attached: onunhandledrejection');\n            this._installGlobalOnUnhandledRejectionHandler();\n        }\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnErrorHandler = function () {\n        var _this = this;\n        if (this._onErrorHandlerInstalled) {\n            return;\n        }\n        addInstrumentationHandler({\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            callback: function (data) {\n                var error = data.error;\n                var currentHub = getCurrentHub();\n                var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n                var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n                if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {\n                    return;\n                }\n                var client = currentHub.getClient();\n                var event = isPrimitive(error)\n                    ? _this._eventFromIncompleteOnError(data.msg, data.url, data.line, data.column)\n                    : _this._enhanceEventWithInitialFrame(eventFromUnknownInput(error, undefined, {\n                        attachStacktrace: client && client.getOptions().attachStacktrace,\n                        rejection: false,\n                    }), data.url, data.line, data.column);\n                addExceptionMechanism(event, {\n                    handled: false,\n                    type: 'onerror',\n                });\n                currentHub.captureEvent(event, {\n                    originalException: error,\n                });\n            },\n            type: 'error',\n        });\n        this._onErrorHandlerInstalled = true;\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnUnhandledRejectionHandler = function () {\n        var _this = this;\n        if (this._onUnhandledRejectionHandlerInstalled) {\n            return;\n        }\n        addInstrumentationHandler({\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            callback: function (e) {\n                var error = e;\n                // dig the object of the rejection out of known event types\n                try {\n                    // PromiseRejectionEvents store the object of the rejection under 'reason'\n                    // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent\n                    if ('reason' in e) {\n                        error = e.reason;\n                    }\n                    // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n                    // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n                    // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n                    // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n                    // https://github.com/getsentry/sentry-javascript/issues/2380\n                    else if ('detail' in e && 'reason' in e.detail) {\n                        error = e.detail.reason;\n                    }\n                }\n                catch (_oO) {\n                    // no-empty\n                }\n                var currentHub = getCurrentHub();\n                var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n                var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n                if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {\n                    return true;\n                }\n                var client = currentHub.getClient();\n                var event = isPrimitive(error)\n                    ? _this._eventFromRejectionWithPrimitive(error)\n                    : eventFromUnknownInput(error, undefined, {\n                        attachStacktrace: client && client.getOptions().attachStacktrace,\n                        rejection: true,\n                    });\n                event.level = Severity.Error;\n                addExceptionMechanism(event, {\n                    handled: false,\n                    type: 'onunhandledrejection',\n                });\n                currentHub.captureEvent(event, {\n                    originalException: error,\n                });\n                return;\n            },\n            type: 'unhandledrejection',\n        });\n        this._onUnhandledRejectionHandlerInstalled = true;\n    };\n    /**\n     * This function creates a stack from an old, error-less onerror handler.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    GlobalHandlers.prototype._eventFromIncompleteOnError = function (msg, url, line, column) {\n        var ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n        // If 'message' is ErrorEvent, get real message from inside\n        var message = isErrorEvent(msg) ? msg.message : msg;\n        var name;\n        if (isString(message)) {\n            var groups = message.match(ERROR_TYPES_RE);\n            if (groups) {\n                name = groups[1];\n                message = groups[2];\n            }\n        }\n        var event = {\n            exception: {\n                values: [\n                    {\n                        type: name || 'Error',\n                        value: message,\n                    },\n                ],\n            },\n        };\n        return this._enhanceEventWithInitialFrame(event, url, line, column);\n    };\n    /**\n     * Create an event from a promise rejection where the `reason` is a primitive.\n     *\n     * @param reason: The `reason` property of the promise rejection\n     * @returns An Event object with an appropriate `exception` value\n     */\n    GlobalHandlers.prototype._eventFromRejectionWithPrimitive = function (reason) {\n        return {\n            exception: {\n                values: [\n                    {\n                        type: 'UnhandledRejection',\n                        // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n                        value: \"Non-Error promise rejection captured with value: \" + String(reason),\n                    },\n                ],\n            },\n        };\n    };\n    /** JSDoc */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    GlobalHandlers.prototype._enhanceEventWithInitialFrame = function (event, url, line, column) {\n        event.exception = event.exception || {};\n        event.exception.values = event.exception.values || [];\n        event.exception.values[0] = event.exception.values[0] || {};\n        event.exception.values[0].stacktrace = event.exception.values[0].stacktrace || {};\n        event.exception.values[0].stacktrace.frames = event.exception.values[0].stacktrace.frames || [];\n        var colno = isNaN(parseInt(column, 10)) ? undefined : column;\n        var lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n        var filename = isString(url) && url.length > 0 ? url : getLocationHref();\n        if (event.exception.values[0].stacktrace.frames.length === 0) {\n            event.exception.values[0].stacktrace.frames.push({\n                colno: colno,\n                filename: filename,\n                function: '?',\n                in_app: true,\n                lineno: lineno,\n            });\n        }\n        return event;\n    };\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.id = 'GlobalHandlers';\n    return GlobalHandlers;\n}());\nexport { GlobalHandlers };\n//# sourceMappingURL=globalhandlers.js.map","import { __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { isInstanceOf } from '@sentry/utils';\nimport { exceptionFromStacktrace } from '../parsers';\nimport { computeStackTrace } from '../tracekit';\nvar DEFAULT_KEY = 'cause';\nvar DEFAULT_LIMIT = 5;\n/** Adds SDK info to an event. */\nvar LinkedErrors = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function LinkedErrors(options) {\n        if (options === void 0) { options = {}; }\n        /**\n         * @inheritDoc\n         */\n        this.name = LinkedErrors.id;\n        this._key = options.key || DEFAULT_KEY;\n        this._limit = options.limit || DEFAULT_LIMIT;\n    }\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event, hint) {\n            var self = getCurrentHub().getIntegration(LinkedErrors);\n            if (self) {\n                return self._handler(event, hint);\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype._handler = function (event, hint) {\n        if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n            return event;\n        }\n        var linkedErrors = this._walkErrorTree(hint.originalException, this._key);\n        event.exception.values = __spread(linkedErrors, event.exception.values);\n        return event;\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype._walkErrorTree = function (error, key, stack) {\n        if (stack === void 0) { stack = []; }\n        if (!isInstanceOf(error[key], Error) || stack.length + 1 >= this._limit) {\n            return stack;\n        }\n        var stacktrace = computeStackTrace(error[key]);\n        var exception = exceptionFromStacktrace(stacktrace);\n        return this._walkErrorTree(error[key], key, __spread([exception], stack));\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.id = 'LinkedErrors';\n    return LinkedErrors;\n}());\nexport { LinkedErrors };\n//# sourceMappingURL=linkederrors.js.map","import { __assign } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\nvar global = getGlobalObject();\n/** UserAgent */\nvar UserAgent = /** @class */ (function () {\n    function UserAgent() {\n        /**\n         * @inheritDoc\n         */\n        this.name = UserAgent.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    UserAgent.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event) {\n            var _a, _b, _c;\n            if (getCurrentHub().getIntegration(UserAgent)) {\n                // if none of the information we want exists, don't bother\n                if (!global.navigator && !global.location && !global.document) {\n                    return event;\n                }\n                // grab as much info as exists and add it to the event\n                var url = ((_a = event.request) === null || _a === void 0 ? void 0 : _a.url) || ((_b = global.location) === null || _b === void 0 ? void 0 : _b.href);\n                var referrer = (global.document || {}).referrer;\n                var userAgent = (global.navigator || {}).userAgent;\n                var headers = __assign(__assign(__assign({}, (_c = event.request) === null || _c === void 0 ? void 0 : _c.headers), (referrer && { Referer: referrer })), (userAgent && { 'User-Agent': userAgent }));\n                var request = __assign(__assign({}, (url && { url: url })), { headers: headers });\n                return __assign(__assign({}, event), { request: request });\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    UserAgent.id = 'UserAgent';\n    return UserAgent;\n}());\nexport { UserAgent };\n//# sourceMappingURL=useragent.js.map","import { getCurrentHub, initAndBind, Integrations as CoreIntegrations } from '@sentry/core';\nimport { addInstrumentationHandler, getGlobalObject, logger, SyncPromise } from '@sentry/utils';\nimport { BrowserClient } from './client';\nimport { wrap as internalWrap } from './helpers';\nimport { Breadcrumbs, GlobalHandlers, LinkedErrors, TryCatch, UserAgent } from './integrations';\nexport var defaultIntegrations = [\n    new CoreIntegrations.InboundFilters(),\n    new CoreIntegrations.FunctionToString(),\n    new TryCatch(),\n    new Breadcrumbs(),\n    new GlobalHandlers(),\n    new LinkedErrors(),\n    new UserAgent(),\n];\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { configureScope } from '@sentry/browser';\n * configureScope((scope: Scope) => {\n *   scope.setExtra({ battery: 0.7 });\n *   scope.setTag({ user_mode: 'admin' });\n *   scope.setUser({ id: '4711' });\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n *   message: 'My Breadcrumb',\n *   // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n *   message: 'Manual',\n *   stacktrace: [\n *     // ...\n *   ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nexport function init(options) {\n    if (options === void 0) { options = {}; }\n    if (options.defaultIntegrations === undefined) {\n        options.defaultIntegrations = defaultIntegrations;\n    }\n    if (options.release === undefined) {\n        var window_1 = getGlobalObject();\n        // This supports the variable that sentry-webpack-plugin injects\n        if (window_1.SENTRY_RELEASE && window_1.SENTRY_RELEASE.id) {\n            options.release = window_1.SENTRY_RELEASE.id;\n        }\n    }\n    if (options.autoSessionTracking === undefined) {\n        options.autoSessionTracking = true;\n    }\n    initAndBind(BrowserClient, options);\n    if (options.autoSessionTracking) {\n        startSessionTracking();\n    }\n}\n/**\n * Present the user with a report dialog.\n *\n * @param options Everything is optional, we try to fetch all info need from the global scope.\n */\nexport function showReportDialog(options) {\n    if (options === void 0) { options = {}; }\n    if (!options.eventId) {\n        options.eventId = getCurrentHub().lastEventId();\n    }\n    var client = getCurrentHub().getClient();\n    if (client) {\n        client.showReportDialog(options);\n    }\n}\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nexport function lastEventId() {\n    return getCurrentHub().lastEventId();\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function forceLoad() {\n    // Noop\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function onLoad(callback) {\n    callback();\n}\n/**\n * A promise that resolves when all current events have been sent.\n * If you provide a timeout and the queue takes longer to drain the promise returns false.\n *\n * @param timeout Maximum time in ms the client should wait.\n */\nexport function flush(timeout) {\n    var client = getCurrentHub().getClient();\n    if (client) {\n        return client.flush(timeout);\n    }\n    return SyncPromise.reject(false);\n}\n/**\n * A promise that resolves when all current events have been sent.\n * If you provide a timeout and the queue takes longer to drain the promise returns false.\n *\n * @param timeout Maximum time in ms the client should wait.\n */\nexport function close(timeout) {\n    var client = getCurrentHub().getClient();\n    if (client) {\n        return client.close(timeout);\n    }\n    return SyncPromise.reject(false);\n}\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function wrap(fn) {\n    return internalWrap(fn)();\n}\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking() {\n    var window = getGlobalObject();\n    var document = window.document;\n    if (typeof document === 'undefined') {\n        logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\n        return;\n    }\n    var hub = getCurrentHub();\n    // The only way for this to be false is for there to be a version mismatch between @sentry/browser (>= 6.0.0) and\n    // @sentry/hub (< 5.27.0). In the simple case, there won't ever be such a mismatch, because the two packages are\n    // pinned at the same version in package.json, but there are edge cases where it's possible. See\n    // https://github.com/getsentry/sentry-javascript/issues/3207 and\n    // https://github.com/getsentry/sentry-javascript/issues/3234 and\n    // https://github.com/getsentry/sentry-javascript/issues/3278.\n    if (typeof hub.startSession !== 'function' || typeof hub.captureSession !== 'function') {\n        return;\n    }\n    hub.startSession();\n    hub.captureSession();\n    // We want to create a session for every navigation as well\n    addInstrumentationHandler({\n        callback: function () {\n            hub.startSession();\n            hub.captureSession();\n        },\n        type: 'history',\n    });\n}\n//# sourceMappingURL=sdk.js.map","import { getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\n/**\n * Internal function to create a new SDK client instance. The client is\n * installed and then bound to the current scope.\n *\n * @param clientClass The client class to instantiate.\n * @param options Options to pass to the client.\n */\nexport function initAndBind(clientClass, options) {\n    var _a;\n    if (options.debug === true) {\n        logger.enable();\n    }\n    var hub = getCurrentHub();\n    (_a = hub.getScope()) === null || _a === void 0 ? void 0 : _a.update(options.initialScope);\n    var client = new clientClass(options);\n    hub.bindClient(client);\n}\n//# sourceMappingURL=sdk.js.map","// TODO: Remove in the next major release and rely only on @sentry/core SDK_VERSION and SdkInfo metadata\nexport var SDK_NAME = 'sentry.javascript.browser';\n//# sourceMappingURL=version.js.map","import { __assign } from \"tslib\";\nexport * from './exports';\nimport { Integrations as CoreIntegrations } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\nimport * as BrowserIntegrations from './integrations';\nimport * as Transports from './transports';\nvar windowIntegrations = {};\n// This block is needed to add compatibility with the integrations packages when used with a CDN\nvar _window = getGlobalObject();\nif (_window.Sentry && _window.Sentry.Integrations) {\n    windowIntegrations = _window.Sentry.Integrations;\n}\nvar INTEGRATIONS = __assign(__assign(__assign({}, windowIntegrations), CoreIntegrations), BrowserIntegrations);\nexport { INTEGRATIONS as Integrations, Transports };\n//# sourceMappingURL=index.js.map"],"sourceRoot":""}