{"version":3,"sources":["webpack:///./node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack:///./node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack:///./node_modules/@sentry/core/esm/api.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/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/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/integrations/breadcrumbs.js","webpack:///./node_modules/@sentry/browser/esm/client.js","webpack:///./node_modules/@sentry/browser/esm/version.js","webpack:///./node_modules/@sentry/browser/esm/helpers.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"],"names":["originalFunctionToString","FunctionToString","this","name","id","prototype","setupOnce","Function","toString","args","_i","arguments","length","context","__sentry_original__","apply","DEFAULT_IGNORE_ERRORS","InboundFilters","_options","event","hub","self","getIntegration","client","getClient","clientOptions","getOptions","options","_mergeOptions","_shouldDropEvent","_isSentryError","logger","warn","_isIgnoredError","_isBlacklistedUrl","_getEventFilterUrl","_isWhitelistedUrl","ignoreInternal","exception","values","type","_oO","ignoreErrors","_getPossibleEventMessages","some","message","pattern","blacklistUrls","url","whitelistUrls","_a","_b","_c","value","oO","error","stacktrace","frames_1","frames","filename","frames_2","API","dsn","_dsnObject","getDsn","getBaseApiEndpoint","protocol","port","host","path","getStoreEndpoint","_getIngestEndpoint","_getEnvelopeEndpoint","target","projectId","getStoreEndpointWithUrlEncodedAuth","_encodedAuth","getEnvelopeEndpointWithUrlEncodedAuth","auth","sentry_key","user","sentry_version","getStoreEndpointPath","getRequestHeaders","clientName","clientVersion","header","push","pass","join","getReportDialogEndpoint","dialogOptions","endpoint","encodedOptions","key","encodeURIComponent","email","installedIntegrations","setupIntegrations","integrations","defaultIntegrations","userIntegrations","Array","isArray","userIntegrationsNames_1","map","i","pickedIntegrationsNames_1","forEach","defaultIntegration","indexOf","userIntegration","integrationsNames","splice","getIntegrationsToSetup","integration","log","setupIntegration","BaseClient","backendClass","_integrations","_processing","_backend","_dsn","captureException","hint","scope","_this","eventId","event_id","_getBackend","eventFromException","then","captureEvent","captureMessage","level","is","eventFromMessage","_processEvent","finalEvent","reason","flush","timeout","_isClientProcessing","status","clearInterval","interval","getTransport","close","transportFlushed","ready","result","enabled","_isEnabled","resolve","ticked","setInterval","undefined","_prepareEvent","normalizeDepth","prepared","timestamp","_applyClientOptions","_applyIntegrationsMetadata","finalScope","captureContext","clone","update","applyToEvent","evt","_normalizeEvent","depth","normalized","breadcrumbs","b","data","contexts","extra","trace","environment","release","dist","maxValueLength","request","sdkInfo","sdk","integrationsArray","Object","keys","_sendEvent","sendEvent","beforeSend","sampleRate","reject","isTransaction","Math","random","__sentry__","beforeSendResult","_handleAsyncBeforeSend","originalException","processedEvent","e","NoopTransport","_","Skipped","BaseBackend","_transport","_setupTransport","_exception","_hint","_message","_level","UNKNOWN_FUNCTION","chrome","gecko","winjs","geckoEval","chromeEval","computeStackTrace","ex","stack","popSize","framesToPop","parts","opera10Regex","opera11Regex","lines","split","line","element","exec","func","column","extractMessage","computeStackTraceFromStacktraceProp","popFrames","submatch","isNative","substr","columnNumber","computeStackTraceFromStackProp","failed","slice","STACKTRACE_LIMIT","exceptionFromStacktrace","prepareFramesForEvent","eventFromStacktrace","localStack","firstFrameFunction","lastFrameFunction","frame","colno","function","in_app","lineno","reverse","eventFromUnknownInput","syntheticException","domException","name_1","eventFromString","rejection","constructor","__serialized__","eventFromPlainObject","synthetic","input","attachStacktrace","eventToSentryRequest","api","useEnvelope","req","body","JSON","stringify","envelope","sent_at","Date","toISOString","BaseTransport","_buffer","_api","drain","_super","FetchTransport","_disabledUntil","now","Promise","sentryReq","method","referrerPolicy","supports","fetchParameters","assign","headers","add","fetch","response","fromHttpCode","Success","RateLimit","get","catch","XHRTransport","XMLHttpRequest","onreadystatechange","readyState","getResponseHeader","open","hasOwnProperty","setRequestHeader","send","BrowserBackend","call","transportOptions","transport","handled","Error","Info","Breadcrumbs","console","dom","history","sentry","xhr","addSentryBreadcrumb","addBreadcrumb","category","_consoleBreadcrumb","handlerData","breadcrumb","fromString","_domBreadcrumb","_xhrBreadcrumb","endTimestamp","__sentry_own_request__","__sentry_xhr__","_fetchBreadcrumb","fetchData","match","status_code","_historyBreadcrumb","global","from","to","parsedLoc","location","href","parsedFrom","parsedTo","relative","callback","BrowserClient","platform","packages","version","showReportDialog","document","script","createElement","async","src","onLoad","onload","head","appendChild","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","setTimeout","wrap","fn","before","__sentry_wrapped__","sentryWrapped","wrappedArguments","arg","handleEvent","addEventProcessor","mechanism","property","defineProperty","enumerable","defineProperties","getOwnPropertyDescriptor","configurable","DEFAULT_EVENT_TARGET","TryCatch","eventTarget","requestAnimationFrame","_wrapTimeFunction","original","originalCallback","_wrapRAF","handler","_wrapEventTarget","proto","eventName","bind","err","_wrapXHR","originalSend","xmlHttpRequestProps","prop","wrapOptions","GlobalHandlers","_onErrorHandlerInstalled","_onUnhandledRejectionHandlerInstalled","onerror","onunhandledrejection","stackTraceLimit","_installGlobalOnErrorHandler","_installGlobalOnUnhandledRejectionHandler","currentHub","hasIntegration","isFailedOwnDelivery","_eventFromIncompleteOnError","msg","_enhanceEventWithInitialFrame","detail","_eventFromIncompleteRejection","groups","isNaN","parseInt","DEFAULT_KEY","DEFAULT_LIMIT","LinkedErrors","_key","_limit","limit","_handler","linkedErrors","_walkErrorTree","UserAgent","navigator","userAgent","init","window_1","SENTRY_RELEASE","clientClass","debug","enable","bindClient","initAndBind"],"mappings":"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","file":"vendors~app~cd1be390.js","sourcesContent":["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        originalFunctionToString = Function.prototype.toString;\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            // tslint:disable-next-line:no-unsafe-any\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 * as tslib_1 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                var options = self._mergeOptions(clientOptions);\n                if (self._shouldDropEvent(event, options)) {\n                    return null;\n                }\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._isBlacklistedUrl(event, options)) {\n            logger.warn(\"Event dropped due to being matched by `blacklistUrls` option.\\nEvent: \" + getEventDescription(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        if (!this._isWhitelistedUrl(event, options)) {\n            logger.warn(\"Event dropped due to not being matched by `whitelistUrls` 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 === void 0) { 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 === void 0) { 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._isBlacklistedUrl = function (event, options) {\n        if (options === void 0) { options = {}; }\n        // TODO: Use Glob instead?\n        if (!options.blacklistUrls || !options.blacklistUrls.length) {\n            return false;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? false : options.blacklistUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isWhitelistedUrl = function (event, options) {\n        if (options === void 0) { options = {}; }\n        // TODO: Use Glob instead?\n        if (!options.whitelistUrls || !options.whitelistUrls.length) {\n            return true;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? true : options.whitelistUrls.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            blacklistUrls: tslib_1.__spread((this._options.blacklistUrls || []), (clientOptions.blacklistUrls || [])),\n            ignoreErrors: tslib_1.__spread((this._options.ignoreErrors || []), (clientOptions.ignoreErrors || []), DEFAULT_IGNORE_ERRORS),\n            ignoreInternal: typeof this._options.ignoreInternal !== 'undefined' ? this._options.ignoreInternal : true,\n            whitelistUrls: tslib_1.__spread((this._options.whitelistUrls || []), (clientOptions.whitelistUrls || [])),\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 { Dsn, urlEncode } from '@sentry/utils';\nvar SENTRY_API_VERSION = '7';\n/** Helper class to provide urls to different Sentry endpoints. */\nvar API = /** @class */ (function () {\n    /** Create a new instance of API */\n    function API(dsn) {\n        this.dsn = dsn;\n        this._dsnObject = new Dsn(dsn);\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    /** 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    /**\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 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.user,\n            sentry_version: SENTRY_API_VERSION,\n        };\n        return urlEncode(auth);\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        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.user);\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 === '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    return API;\n}());\nexport { API };\n//# sourceMappingURL=api.js.map","import * as tslib_1 from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\nexport var installedIntegrations = [];\n/** Gets integration to install */\nexport function getIntegrationsToSetup(options) {\n    var defaultIntegrations = (options.defaultIntegrations && tslib_1.__spread(options.defaultIntegrations)) || [];\n    var userIntegrations = options.integrations;\n    var integrations = [];\n    if (Array.isArray(userIntegrations)) {\n        var userIntegrationsNames_1 = userIntegrations.map(function (i) { return i.name; });\n        var pickedIntegrationsNames_1 = [];\n        // Leave only unique default integrations, that were not overridden with provided user integrations\n        defaultIntegrations.forEach(function (defaultIntegration) {\n            if (userIntegrationsNames_1.indexOf(defaultIntegration.name) === -1 &&\n                pickedIntegrationsNames_1.indexOf(defaultIntegration.name) === -1) {\n                integrations.push(defaultIntegration);\n                pickedIntegrationsNames_1.push(defaultIntegration.name);\n            }\n        });\n        // Don't add same user integration twice\n        userIntegrations.forEach(function (userIntegration) {\n            if (pickedIntegrationsNames_1.indexOf(userIntegration.name) === -1) {\n                integrations.push(userIntegration);\n                pickedIntegrationsNames_1.push(userIntegration.name);\n            }\n        });\n    }\n    else if (typeof userIntegrations === 'function') {\n        integrations = userIntegrations(defaultIntegrations);\n        integrations = Array.isArray(integrations) ? integrations : [integrations];\n    }\n    else {\n        integrations = tslib_1.__spread(defaultIntegrations);\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, tslib_1.__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 * as tslib_1 from \"tslib\";\nimport { Scope } from '@sentry/hub';\nimport { Dsn, isPrimitive, isThenable, logger, normalize, SyncPromise, timestampWithMs, 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        /** Is the client still processing a call? */\n        this._processing = false;\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    BaseClient.prototype.captureException = function (exception, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        this._processing = true;\n        this._getBackend()\n            .eventFromException(exception, hint)\n            .then(function (event) {\n            eventId = _this.captureEvent(event, hint, scope);\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        this._processing = true;\n        var promisedEvent = isPrimitive(message)\n            ? this._getBackend().eventFromMessage(\"\" + message, level, hint)\n            : this._getBackend().eventFromException(message, hint);\n        promisedEvent.then(function (event) {\n            eventId = _this.captureEvent(event, hint, scope);\n        });\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureEvent = function (event, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        this._processing = true;\n        this._processEvent(event, hint, scope)\n            .then(function (finalEvent) {\n            // We need to check for finalEvent in case beforeSend returned null\n            eventId = finalEvent && finalEvent.event_id;\n            _this._processing = false;\n        })\n            .then(null, function (reason) {\n            logger.error(reason);\n            _this._processing = false;\n        });\n        return eventId;\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 (status) {\n            clearInterval(status.interval);\n            return _this._getBackend()\n                .getTransport()\n                .close(timeout)\n                .then(function (transportFlushed) { return status.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    /** 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 = 0;\n            clearInterval(interval);\n            interval = setInterval(function () {\n                if (!_this._processing) {\n                    resolve({\n                        interval: interval,\n                        ready: true,\n                    });\n                }\n                else {\n                    ticked += tick;\n                    if (timeout && ticked >= timeout) {\n                        resolve({\n                            interval: interval,\n                            ready: false,\n                        });\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 = tslib_1.__assign({}, event, { event_id: event.event_id || (hint && hint.event_id ? hint.event_id : uuid4()), timestamp: event.timestamp || timestampWithMs() });\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            // tslint:disable-next-line:strict-type-predicates\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        // tslint:disable:no-unsafe-any\n        var normalized = tslib_1.__assign({}, event, (event.breadcrumbs && {\n            breadcrumbs: event.breadcrumbs.map(function (b) { return (tslib_1.__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            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 _a = this.getOptions(), environment = _a.environment, release = _a.release, dist = _a.dist, _b = _a.maxValueLength, maxValueLength = _b === void 0 ? 250 : _b;\n        if (event.environment === undefined && environment !== undefined) {\n            event.environment = environment;\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 sdkInfo The sdkInfo of the event that will be filled with all integrations.\n     */\n    BaseClient.prototype._applyIntegrationsMetadata = function (event) {\n        var sdkInfo = event.sdk;\n        var integrationsArray = Object.keys(this._integrations);\n        if (sdkInfo && integrationsArray.length > 0) {\n            sdkInfo.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 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        var _a = this.getOptions(), beforeSend = _a.beforeSend, sampleRate = _a.sampleRate;\n        if (!this._isEnabled()) {\n            return SyncPromise.reject('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('This event has been sampled, will not send event.');\n        }\n        return new SyncPromise(function (resolve, reject) {\n            _this._prepareEvent(event, scope, hint)\n                .then(function (prepared) {\n                if (prepared === null) {\n                    reject('An event processor returned null, will not send event.');\n                    return;\n                }\n                var finalEvent = prepared;\n                var isInternalException = hint && hint.data && hint.data.__sentry__ === true;\n                // We skip beforeSend in case of transactions\n                if (isInternalException || !beforeSend || isTransaction) {\n                    _this._sendEvent(finalEvent);\n                    resolve(finalEvent);\n                    return;\n                }\n                var beforeSendResult = beforeSend(prepared, hint);\n                // tslint:disable-next-line:strict-type-predicates\n                if (typeof beforeSendResult === 'undefined') {\n                    logger.error('`beforeSend` method has to return `null` or a valid event.');\n                }\n                else if (isThenable(beforeSendResult)) {\n                    _this._handleAsyncBeforeSend(beforeSendResult, resolve, reject);\n                }\n                else {\n                    finalEvent = beforeSendResult;\n                    if (finalEvent === null) {\n                        logger.log('`beforeSend` returned `null`, will not send event.');\n                        resolve(null);\n                        return;\n                    }\n                    // From here on we are really async\n                    _this._sendEvent(finalEvent);\n                    resolve(finalEvent);\n                }\n            })\n                .then(null, function (reason) {\n                _this.captureException(reason, {\n                    data: {\n                        __sentry__: true,\n                    },\n                    originalException: reason,\n                });\n                reject(\"Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: \" + reason);\n            });\n        });\n    };\n    /**\n     * Resolves before send Promise and calls resolve/reject on parent SyncPromise.\n     */\n    BaseClient.prototype._handleAsyncBeforeSend = function (beforeSend, resolve, reject) {\n        var _this = this;\n        beforeSend\n            .then(function (processedEvent) {\n            if (processedEvent === null) {\n                reject('`beforeSend` returned `null`, will not send event.');\n                return;\n            }\n            // From here on we are really async\n            _this._sendEvent(processedEvent);\n            resolve(processedEvent);\n        })\n            .then(null, function (e) {\n            reject(\"beforeSend rejected with \" + e);\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     * 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    /**\n     * @inheritDoc\n     */\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.getTransport = function () {\n        return this._transport;\n    };\n    return BaseBackend;\n}());\nexport { BaseBackend };\n//# sourceMappingURL=basebackend.js.map","// tslint:disable:object-literal-sort-keys\nimport * as tslib_1 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).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js))(?::(\\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/** JSDoc */\nexport function computeStackTrace(ex) {\n    // tslint:disable:no-unsafe-any\n    var stack = null;\n    var popSize = ex && ex.framesToPop;\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// tslint:disable-next-line:cyclomatic-complexity\nfunction computeStackTraceFromStackProp(ex) {\n    // tslint:disable:no-conditional-assignment\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            element = {\n                // 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                url: parts[2] && parts[2].indexOf('address at ') === 0 ? parts[2].substr('address at '.length) : parts[2],\n                func: parts[1] || UNKNOWN_FUNCTION,\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 */\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        // tslint:disable:no-conditional-assignment\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 tslib_1.__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 */\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    // tslint:disable-next-line:strict-type-predicates\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 { addExceptionMechanism, addExceptionTypeValue, isDOMError, isDOMException, isError, isErrorEvent, isEvent, isPlainObject, } from '@sentry/utils';\nimport { eventFromPlainObject, eventFromStacktrace, prepareFramesForEvent } from './parsers';\nimport { computeStackTrace } from './tracekit';\n/** JSDoc */\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        exception = errorEvent.error; // tslint:disable-line:no-parameter-reassignment\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 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        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// this._options.attachStacktrace\n/** JSDoc */\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 { timestampWithMs } from '@sentry/utils';\n/** Creates a SentryRequest from an event. */\nexport function eventToSentryRequest(event, api) {\n    var useEnvelope = event.type === 'transaction';\n    var req = {\n        body: JSON.stringify(event),\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({\n            event_id: event.event_id,\n            // We need to add * 1000 since we divide it by 1000 by default but JS works with ms precision\n            // The reason we use timestampWithMs here is that all clocks across the SDK use the same clock\n            sent_at: new Date(timestampWithMs() * 1000).toISOString(),\n        });\n        var itemHeaders = JSON.stringify({\n            type: event.type,\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 { API } from '@sentry/core';\nimport { PromiseBuffer, SentryError } from '@sentry/utils';\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        this._api = new API(this.options.dsn);\n        // tslint:disable-next-line: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    return BaseTransport;\n}());\nexport { BaseTransport };\n//# sourceMappingURL=base.js.map","import * as tslib_1 from \"tslib\";\nimport { eventToSentryRequest } from '@sentry/core';\nimport { Status } from '@sentry/types';\nimport { getGlobalObject, logger, parseRetryAfterHeader, supportsReferrerPolicy, SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\nvar global = getGlobalObject();\n/** `fetch` based transport */\nvar FetchTransport = /** @class */ (function (_super) {\n    tslib_1.__extends(FetchTransport, _super);\n    function FetchTransport() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        /** Locks transport after receiving 429 response */\n        _this._disabledUntil = new Date(Date.now());\n        return _this;\n    }\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendEvent = function (event) {\n        var _this = this;\n        if (new Date(Date.now()) < this._disabledUntil) {\n            return Promise.reject({\n                event: event,\n                reason: \"Transport locked till \" + this._disabledUntil + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        var sentryReq = eventToSentryRequest(event, this._api);\n        var options = {\n            body: sentryReq.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            global\n                .fetch(sentryReq.url, options)\n                .then(function (response) {\n                var status = Status.fromHttpCode(response.status);\n                if (status === Status.Success) {\n                    resolve({ status: status });\n                    return;\n                }\n                if (status === Status.RateLimit) {\n                    var now = Date.now();\n                    _this._disabledUntil = new Date(now + parseRetryAfterHeader(now, response.headers.get('Retry-After')));\n                    logger.warn(\"Too many requests, backing off till: \" + _this._disabledUntil);\n                }\n                reject(response);\n            })\n                .catch(reject);\n        }));\n    };\n    return FetchTransport;\n}(BaseTransport));\nexport { FetchTransport };\n//# sourceMappingURL=fetch.js.map","import * as tslib_1 from \"tslib\";\nimport { eventToSentryRequest } from '@sentry/core';\nimport { Status } from '@sentry/types';\nimport { logger, parseRetryAfterHeader, SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\n/** `XHR` based transport */\nvar XHRTransport = /** @class */ (function (_super) {\n    tslib_1.__extends(XHRTransport, _super);\n    function XHRTransport() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        /** Locks transport after receiving 429 response */\n        _this._disabledUntil = new Date(Date.now());\n        return _this;\n    }\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendEvent = function (event) {\n        var _this = this;\n        if (new Date(Date.now()) < this._disabledUntil) {\n            return Promise.reject({\n                event: event,\n                reason: \"Transport locked till \" + this._disabledUntil + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        var sentryReq = eventToSentryRequest(event, this._api);\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                    return;\n                }\n                var status = Status.fromHttpCode(request.status);\n                if (status === Status.Success) {\n                    resolve({ status: status });\n                    return;\n                }\n                if (status === Status.RateLimit) {\n                    var now = Date.now();\n                    _this._disabledUntil = new Date(now + parseRetryAfterHeader(now, request.getResponseHeader('Retry-After')));\n                    logger.warn(\"Too many requests, backing off till: \" + _this._disabledUntil);\n                }\n                reject(request);\n            };\n            request.open('POST', sentryReq.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(sentryReq.body);\n        }));\n    };\n    return XHRTransport;\n}(BaseTransport));\nexport { XHRTransport };\n//# sourceMappingURL=xhr.js.map","import * as tslib_1 from \"tslib\";\nimport { BaseBackend } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, supportsFetch, SyncPromise } from '@sentry/utils';\nimport { eventFromString, eventFromUnknownInput } from './eventbuilder';\nimport { FetchTransport, XHRTransport } from './transports';\n/**\n * The Sentry Browser SDK Backend.\n * @hidden\n */\nvar BrowserBackend = /** @class */ (function (_super) {\n    tslib_1.__extends(BrowserBackend, _super);\n    function BrowserBackend() {\n        return _super !== null && _super.apply(this, arguments) || this;\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 = tslib_1.__assign({}, this._options.transportOptions, { dsn: this._options.dsn });\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    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromException = function (exception, hint) {\n        var syntheticException = (hint && hint.syntheticException) || undefined;\n        var event = eventFromUnknownInput(exception, syntheticException, {\n            attachStacktrace: this._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     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromMessage = function (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: this._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    return BrowserBackend;\n}(BaseBackend));\nexport { BrowserBackend };\n//# sourceMappingURL=backend.js.map","import * as tslib_1 from \"tslib\";\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 = tslib_1.__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     * Creates breadcrumbs from console API calls\n     */\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    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        });\n    };\n    /**\n     * Creates breadcrumbs from XHR API calls\n     */\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            getCurrentHub().addBreadcrumb({\n                category: 'xhr',\n                data: handlerData.xhr.__sentry_xhr__,\n                type: 'http',\n            }, {\n                xhr: handlerData.xhr,\n            });\n            return;\n        }\n    };\n    /**\n     * Creates breadcrumbs from fetch API calls\n     */\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: tslib_1.__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    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            // tslint:disable-next-line:no-parameter-reassignment\n            to = parsedTo.relative;\n        }\n        if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n            // tslint:disable-next-line:no-parameter-reassignment\n            from = parsedFrom.relative;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: 'navigation',\n            data: {\n                from: from,\n                to: to,\n            },\n        });\n    };\n    /**\n     * Instrument browser built-ins w/ breadcrumb capturing\n     *  - Console API\n     *  - DOM API (click/typing)\n     *  - XMLHttpRequest API\n     *  - Fetch API\n     *  - History API\n     */\n    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, tslib_1.__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, tslib_1.__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, tslib_1.__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, tslib_1.__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, tslib_1.__spread(args));\n                },\n                type: 'history',\n            });\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Breadcrumbs.id = 'Breadcrumbs';\n    return Breadcrumbs;\n}());\nexport { Breadcrumbs };\n//# sourceMappingURL=breadcrumbs.js.map","import * as tslib_1 from \"tslib\";\nimport { API, BaseClient } from '@sentry/core';\nimport { getGlobalObject, logger } from '@sentry/utils';\nimport { BrowserBackend } from './backend';\nimport { Breadcrumbs } from './integrations';\nimport { SDK_NAME, SDK_VERSION } from './version';\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    tslib_1.__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        return _super.call(this, BrowserBackend, options) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._prepareEvent = function (event, scope, hint) {\n        event.platform = event.platform || 'javascript';\n        event.sdk = tslib_1.__assign({}, event.sdk, { name: SDK_NAME, packages: tslib_1.__spread(((event.sdk && event.sdk.packages) || []), [\n                {\n                    name: 'npm:@sentry/browser',\n                    version: SDK_VERSION,\n                },\n            ]), version: SDK_VERSION });\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    /**\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 is disabled');\n            return;\n        }\n        var dsn = options.dsn || this.getDsn();\n        if (!options.eventId) {\n            logger.error('Missing `eventId` option in showReportDialog call');\n            return;\n        }\n        if (!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(dsn).getReportDialogEndpoint(options);\n        if (options.onLoad) {\n            script.onload = options.onLoad;\n        }\n        (document.head || document.body).appendChild(script);\n    };\n    return BrowserClient;\n}(BaseClient));\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map","export var SDK_NAME = 'sentry.javascript.browser';\nexport var SDK_VERSION = '5.17.0';\n//# sourceMappingURL=version.js.map","import * as tslib_1 from \"tslib\";\nimport { captureException, withScope } from '@sentry/core';\nimport { addExceptionMechanism, addExceptionTypeValue } 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    // tslint:disable-next-line:strict-type-predicates\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    var sentryWrapped = function () {\n        var args = Array.prototype.slice.call(arguments);\n        // tslint:disable:no-unsafe-any\n        try {\n            // tslint:disable-next-line:strict-type-predicates\n            if (before && typeof before === 'function') {\n                before.apply(this, arguments);\n            }\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                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            // tslint:enable:no-unsafe-any\n        }\n        catch (ex) {\n            ignoreNextOnError();\n            withScope(function (scope) {\n                scope.addEventProcessor(function (event) {\n                    var processedEvent = tslib_1.__assign({}, event);\n                    if (options.mechanism) {\n                        addExceptionTypeValue(processedEvent, undefined, undefined);\n                        addExceptionMechanism(processedEvent, options.mechanism);\n                    }\n                    processedEvent.extra = tslib_1.__assign({}, processedEvent.extra, { arguments: args });\n                    return processedEvent;\n                });\n                captureException(ex);\n            });\n            throw ex;\n        }\n    };\n    // Accessing some objects may throw\n    // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n    try {\n        for (var property in fn) {\n            if (Object.prototype.hasOwnProperty.call(fn, property)) {\n                sentryWrapped[property] = fn[property];\n            }\n        }\n    }\n    catch (_oO) { } // tslint: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    }\n    catch (_oO) {\n        /*no-empty*/\n    }\n    return sentryWrapped;\n}\n//# sourceMappingURL=helpers.js.map","import * as tslib_1 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 = tslib_1.__assign({ XMLHttpRequest: true, eventTarget: true, requestAnimationFrame: true, setInterval: true, setTimeout: true }, options);\n    }\n    /** JSDoc */\n    TryCatch.prototype._wrapTimeFunction = function (original) {\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    TryCatch.prototype._wrapRAF = function (original) {\n        return function (callback) {\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        var global = getGlobalObject();\n        var proto = global[target] && global[target].prototype;\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                    // tslint:disable-next-line:no-unbound-method strict-type-predicates\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, 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 (original) {\n            return function (eventName, fn, options) {\n                var callback = fn;\n                try {\n                    callback = callback && (callback.__sentry_wrapped__ || callback);\n                }\n                catch (e) {\n                    // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n                }\n                return original.call(this, eventName, callback, options);\n            };\n        });\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapXHR = function (originalSend) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var xhr = this; // tslint:disable-line:no-this-assignment\n            var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n            xmlHttpRequestProps.forEach(function (prop) {\n                if (prop in xhr && typeof xhr[prop] === 'function') {\n                    fill(xhr, prop, function (original) {\n                        var wrapOptions = {\n                            mechanism: {\n                                data: {\n                                    function: prop,\n                                    handler: getFunctionName(original),\n                                },\n                                handled: true,\n                                type: 'instrument',\n                            },\n                        };\n                        // 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     * 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    /**\n     * @inheritDoc\n     */\n    TryCatch.id = 'TryCatch';\n    return TryCatch;\n}());\nexport { TryCatch };\n//# sourceMappingURL=trycatch.js.map","import * as tslib_1 from \"tslib\";\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 = tslib_1.__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            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            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._eventFromIncompleteRejection(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    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     * This function creates an Event from an TraceKitStackTrace that has part of it missing.\n     */\n    GlobalHandlers.prototype._eventFromIncompleteRejection = function (error) {\n        return {\n            exception: {\n                values: [\n                    {\n                        type: 'UnhandledRejection',\n                        value: \"Non-Error promise rejection captured with value: \" + error,\n                    },\n                ],\n            },\n        };\n    };\n    /** JSDoc */\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 * as tslib_1 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 = tslib_1.__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, tslib_1.__spread([exception], stack));\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.id = 'LinkedErrors';\n    return LinkedErrors;\n}());\nexport { LinkedErrors };\n//# sourceMappingURL=linkederrors.js.map","import * as tslib_1 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            if (getCurrentHub().getIntegration(UserAgent)) {\n                if (!global.navigator || !global.location) {\n                    return event;\n                }\n                var request = event.request || {};\n                request.url = request.url || global.location.href;\n                request.headers = request.headers || {};\n                request.headers['User-Agent'] = global.navigator.userAgent;\n                return tslib_1.__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 { getGlobalObject, 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    initAndBind(BrowserClient, options);\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 */\nexport function wrap(fn) {\n    return internalWrap(fn)(); // tslint:disable-line:no-unsafe-any\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 instanciate.\n * @param options Options to pass to the client.\n */\nexport function initAndBind(clientClass, options) {\n    if (options.debug === true) {\n        logger.enable();\n    }\n    var hub = getCurrentHub();\n    var client = new clientClass(options);\n    hub.bindClient(client);\n}\n//# sourceMappingURL=sdk.js.map"],"sourceRoot":""}