{"version":3,"sources":["webpack:///./node_modules/@sentry/integrations/node_modules/@sentry/utils/esm/is.js","webpack:///./node_modules/@sentry/integrations/node_modules/@sentry/utils/esm/misc.js","webpack:///./node_modules/@sentry/hub/esm/scope.js","webpack:///./node_modules/@sentry/integrations/node_modules/@sentry/utils/esm/string.js","webpack:///./node_modules/@sentry/minimal/esm/index.js","webpack:///./node_modules/@sentry/hub/esm/hub.js","webpack:///./node_modules/@sentry/integrations/node_modules/@sentry/utils/esm/logger.js","webpack:///./node_modules/@sentry/integrations/node_modules/@sentry/utils/esm/path.js","webpack:///./node_modules/@sentry/integrations/esm/vue.js"],"names":["isString","wat","Object","prototype","toString","call","isRegExp","isNodeEnv","process","fallbackGlobalObject","getGlobalObject","global","window","self","consoleSandbox","callback","originalConsole","console","wrappedLevels","forEach","level","__sentry_original__","result","keys","INITIAL_TIME","Date","now","prevNow","performanceFallback","timeOrigin","crossPlatformPerformance","request","module","require","performance","_","undefined","timing","navigationStart","timestampWithMs","Scope","this","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_user","_tags","_extra","_contexts","addScopeListener","push","addEventProcessor","_notifyScopeListeners","_this","setTimeout","_notifyEventProcessors","processors","event","hint","index","resolve","reject","processor","then","final","setUser","user","setTags","tags","setTag","key","value","_a","setExtras","extras","setExtra","extra","setFingerprint","fingerprint","_fingerprint","setLevel","_level","setTransaction","transaction","_transaction","setContext","context","setSpan","span","_span","getSpan","clone","scope","newScope","update","captureContext","updatedScope","contexts","clear","addBreadcrumb","breadcrumb","maxBreadcrumbs","mergedBreadcrumb","timestamp","slice","clearBreadcrumbs","_applyFingerprint","Array","isArray","concat","length","applyToEvent","trace","getTraceContext","breadcrumbs","getGlobalEventProcessors","__SENTRY__","globalEventProcessors","addGlobalEventProcessor","snipLine","line","colno","newLine","ll","start","Math","max","end","min","callOnHub","method","args","_i","arguments","hub","apply","Error","captureException","exception","syntheticException","originalException","withScope","API_VERSION","Hub","client","_version","_stack","_invokeClient","top","getStackTop","isOlderThan","version","bindClient","setupIntegrations","pushScope","stack","getStack","parentScope","getClient","popScope","pop","getScope","eventId","_lastEventId","finalHint","event_id","captureMessage","message","captureEvent","lastEventId","getOptions","_b","beforeBreadcrumb","_c","finalBreadcrumb","name","configureScope","run","oldHub","makeMain","getIntegration","integration","_oO","warn","id","startSpan","_callExtensionMethod","startTransaction","traceHeaders","carrier","getMainCarrier","sentry","extensions","registry","getHubFromCarrier","setHubOnCarrier","getCurrentHub","hasHubOnCarrier","activeDomain","active","registryHubTopStack","_Oo","getHubFromActiveDomain","PREFIX","Logger","_enabled","disable","enable","log","join","error","logger","splitPathRe","splitPath","filename","parts","exec","TRACING_GETTER","HOOKS","activate","create","destroy","mount","COMPONENT_NAME_REGEXP","ROOT_COMPONENT_NAME","Vue","options","_componentsCache","_applyTracingHooks","vm","$options","$_sentryPerfHook","_getComponentName","rootMount","spans","rootHandler","hook","_rootSpan","_finishRootSpan","$once","tracingIntegration","_tracingActivity","constructor","pushActivity","getTransaction","startChild","description","op","childHandler","operation","shouldTrack","_options","tracingOptions","trackComponents","indexOf","finish","hooks","internalHooks","internalHook","handler","bind","currentValue","attachProps","logErrors","tracing","timeout","$root","_componentTag","__file","unifiedFile","replace","ext","f","substr","c","toUpperCase","_rootSpanTimer","clearTimeout","popActivity","_startTracing","applyTracingHooks","mixin","beforeCreate","_attachErrorHandler","currentErrorHandler","config","errorHandler","info","metadata","componentName","propsData","lifecycleHook","util","setupOnce"],"mappings":"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","file":"vendors~app~a05af556.js","sourcesContent":["/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isError(wat) {\n    switch (Object.prototype.toString.call(wat)) {\n        case '[object Error]':\n            return true;\n        case '[object Exception]':\n            return true;\n        case '[object DOMException]':\n            return true;\n        default:\n            return isInstanceOf(wat, Error);\n    }\n}\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isErrorEvent(wat) {\n    return Object.prototype.toString.call(wat) === '[object ErrorEvent]';\n}\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMError(wat) {\n    return Object.prototype.toString.call(wat) === '[object DOMError]';\n}\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMException(wat) {\n    return Object.prototype.toString.call(wat) === '[object DOMException]';\n}\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isString(wat) {\n    return Object.prototype.toString.call(wat) === '[object String]';\n}\n/**\n * Checks whether given value's is a primitive (undefined, null, number, boolean, string)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPrimitive(wat) {\n    return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPlainObject(wat) {\n    return Object.prototype.toString.call(wat) === '[object Object]';\n}\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isEvent(wat) {\n    // tslint:disable-next-line:strict-type-predicates\n    return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isElement(wat) {\n    // tslint:disable-next-line:strict-type-predicates\n    return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isRegExp(wat) {\n    return Object.prototype.toString.call(wat) === '[object RegExp]';\n}\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nexport function isThenable(wat) {\n    // tslint:disable:no-unsafe-any\n    return Boolean(wat && wat.then && typeof wat.then === 'function');\n    // tslint:enable:no-unsafe-any\n}\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isSyntheticEvent(wat) {\n    // tslint:disable-next-line:no-unsafe-any\n    return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nexport function isInstanceOf(wat, base) {\n    try {\n        // tslint:disable-next-line:no-unsafe-any\n        return wat instanceof base;\n    }\n    catch (_e) {\n        return false;\n    }\n}\n//# sourceMappingURL=is.js.map","import { isString } from './is';\nimport { snipLine } from './string';\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\nexport function dynamicRequire(mod, request) {\n    // tslint:disable-next-line: no-unsafe-any\n    return mod.require(request);\n}\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nexport function isNodeEnv() {\n    // tslint:disable:strict-type-predicates\n    return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';\n}\nvar fallbackGlobalObject = {};\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nexport function getGlobalObject() {\n    return (isNodeEnv()\n        ? global\n        : typeof window !== 'undefined'\n            ? window\n            : typeof self !== 'undefined'\n                ? self\n                : fallbackGlobalObject);\n}\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nexport function uuid4() {\n    var global = getGlobalObject();\n    var crypto = global.crypto || global.msCrypto;\n    if (!(crypto === void 0) && crypto.getRandomValues) {\n        // Use window.crypto API if available\n        var arr = new Uint16Array(8);\n        crypto.getRandomValues(arr);\n        // set 4 in byte 7\n        // tslint:disable-next-line:no-bitwise\n        arr[3] = (arr[3] & 0xfff) | 0x4000;\n        // set 2 most significant bits of byte 9 to '10'\n        // tslint:disable-next-line:no-bitwise\n        arr[4] = (arr[4] & 0x3fff) | 0x8000;\n        var pad = function (num) {\n            var v = num.toString(16);\n            while (v.length < 4) {\n                v = \"0\" + v;\n            }\n            return v;\n        };\n        return (pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) + pad(arr[5]) + pad(arr[6]) + pad(arr[7]));\n    }\n    // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n    return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n        // tslint:disable-next-line:no-bitwise\n        var r = (Math.random() * 16) | 0;\n        // tslint:disable-next-line:no-bitwise\n        var v = c === 'x' ? r : (r & 0x3) | 0x8;\n        return v.toString(16);\n    });\n}\n/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nexport function parseUrl(url) {\n    if (!url) {\n        return {};\n    }\n    var match = url.match(/^(([^:\\/?#]+):)?(\\/\\/([^\\/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n    if (!match) {\n        return {};\n    }\n    // coerce to undefined values to empty string so we don't get 'undefined'\n    var query = match[6] || '';\n    var fragment = match[8] || '';\n    return {\n        host: match[4],\n        path: match[5],\n        protocol: match[2],\n        relative: match[5] + query + fragment,\n    };\n}\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nexport function getEventDescription(event) {\n    if (event.message) {\n        return event.message;\n    }\n    if (event.exception && event.exception.values && event.exception.values[0]) {\n        var exception = event.exception.values[0];\n        if (exception.type && exception.value) {\n            return exception.type + \": \" + exception.value;\n        }\n        return exception.type || exception.value || event.event_id || '<unknown>';\n    }\n    return event.event_id || '<unknown>';\n}\n/** JSDoc */\nexport function consoleSandbox(callback) {\n    var global = getGlobalObject();\n    var levels = ['debug', 'info', 'warn', 'error', 'log', 'assert'];\n    if (!('console' in global)) {\n        return callback();\n    }\n    var originalConsole = global.console;\n    var wrappedLevels = {};\n    // Restore all wrapped console methods\n    levels.forEach(function (level) {\n        if (level in global.console && originalConsole[level].__sentry_original__) {\n            wrappedLevels[level] = originalConsole[level];\n            originalConsole[level] = originalConsole[level].__sentry_original__;\n        }\n    });\n    // Perform callback manipulations\n    var result = callback();\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(function (level) {\n        originalConsole[level] = wrappedLevels[level];\n    });\n    return result;\n}\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nexport function addExceptionTypeValue(event, value, type) {\n    event.exception = event.exception || {};\n    event.exception.values = event.exception.values || [];\n    event.exception.values[0] = event.exception.values[0] || {};\n    event.exception.values[0].value = event.exception.values[0].value || value || '';\n    event.exception.values[0].type = event.exception.values[0].type || type || 'Error';\n}\n/**\n * Adds exception mechanism to a given event.\n * @param event The event to modify.\n * @param mechanism Mechanism of the mechanism.\n * @hidden\n */\nexport function addExceptionMechanism(event, mechanism) {\n    if (mechanism === void 0) { mechanism = {}; }\n    // TODO: Use real type with `keyof Mechanism` thingy and maybe make it better?\n    try {\n        // @ts-ignore\n        // tslint:disable:no-non-null-assertion\n        event.exception.values[0].mechanism = event.exception.values[0].mechanism || {};\n        Object.keys(mechanism).forEach(function (key) {\n            // @ts-ignore\n            event.exception.values[0].mechanism[key] = mechanism[key];\n        });\n    }\n    catch (_oO) {\n        // no-empty\n    }\n}\n/**\n * A safe form of location.href\n */\nexport function getLocationHref() {\n    try {\n        return document.location.href;\n    }\n    catch (oO) {\n        return '';\n    }\n}\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nexport function htmlTreeAsString(elem) {\n    // try/catch both:\n    // - accessing event.target (see getsentry/raven-js#838, #768)\n    // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n    // - can throw an exception in some circumstances.\n    try {\n        var currentElem = elem;\n        var MAX_TRAVERSE_HEIGHT = 5;\n        var MAX_OUTPUT_LEN = 80;\n        var out = [];\n        var height = 0;\n        var len = 0;\n        var separator = ' > ';\n        var sepLength = separator.length;\n        var nextStr = void 0;\n        while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n            nextStr = _htmlElementAsString(currentElem);\n            // bail out if\n            // - nextStr is the 'html' element\n            // - the length of the string that would be created exceeds MAX_OUTPUT_LEN\n            //   (ignore this limit if we are on the first iteration)\n            if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {\n                break;\n            }\n            out.push(nextStr);\n            len += nextStr.length;\n            currentElem = currentElem.parentNode;\n        }\n        return out.reverse().join(separator);\n    }\n    catch (_oO) {\n        return '<unknown>';\n    }\n}\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el) {\n    var elem = el;\n    var out = [];\n    var className;\n    var classes;\n    var key;\n    var attr;\n    var i;\n    if (!elem || !elem.tagName) {\n        return '';\n    }\n    out.push(elem.tagName.toLowerCase());\n    if (elem.id) {\n        out.push(\"#\" + elem.id);\n    }\n    className = elem.className;\n    if (className && isString(className)) {\n        classes = className.split(/\\s+/);\n        for (i = 0; i < classes.length; i++) {\n            out.push(\".\" + classes[i]);\n        }\n    }\n    var allowedAttrs = ['type', 'name', 'title', 'alt'];\n    for (i = 0; i < allowedAttrs.length; i++) {\n        key = allowedAttrs[i];\n        attr = elem.getAttribute(key);\n        if (attr) {\n            out.push(\"[\" + key + \"=\\\"\" + attr + \"\\\"]\");\n        }\n    }\n    return out.join('');\n}\nvar INITIAL_TIME = Date.now();\nvar prevNow = 0;\nvar performanceFallback = {\n    now: function () {\n        var now = Date.now() - INITIAL_TIME;\n        if (now < prevNow) {\n            now = prevNow;\n        }\n        prevNow = now;\n        return now;\n    },\n    timeOrigin: INITIAL_TIME,\n};\nexport var crossPlatformPerformance = (function () {\n    if (isNodeEnv()) {\n        try {\n            var perfHooks = dynamicRequire(module, 'perf_hooks');\n            return perfHooks.performance;\n        }\n        catch (_) {\n            return performanceFallback;\n        }\n    }\n    var performance = getGlobalObject().performance;\n    if (!performance || !performance.now) {\n        return performanceFallback;\n    }\n    // Polyfill for performance.timeOrigin.\n    //\n    // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n    // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n    // tslint:disable-next-line:strict-type-predicates\n    if (performance.timeOrigin === undefined) {\n        // As of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always a\n        // valid fallback. In the absence of a initial time provided by the browser, fallback to INITIAL_TIME.\n        // @ts-ignore\n        // tslint:disable-next-line:deprecation\n        performance.timeOrigin = (performance.timing && performance.timing.navigationStart) || INITIAL_TIME;\n    }\n    return performance;\n})();\n/**\n * Returns a timestamp in seconds with milliseconds precision since the UNIX epoch calculated with the monotonic clock.\n */\nexport function timestampWithMs() {\n    return (crossPlatformPerformance.timeOrigin + crossPlatformPerformance.now()) / 1000;\n}\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nvar SEMVER_REGEXP = /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nexport function parseSemver(input) {\n    var match = input.match(SEMVER_REGEXP) || [];\n    var major = parseInt(match[1], 10);\n    var minor = parseInt(match[2], 10);\n    var patch = parseInt(match[3], 10);\n    return {\n        buildmetadata: match[5],\n        major: isNaN(major) ? undefined : major,\n        minor: isNaN(minor) ? undefined : minor,\n        patch: isNaN(patch) ? undefined : patch,\n        prerelease: match[4],\n    };\n}\nvar defaultRetryAfter = 60 * 1000; // 60 seconds\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param now current unix timestamp\n * @param header string representation of 'Retry-After' header\n */\nexport function parseRetryAfterHeader(now, header) {\n    if (!header) {\n        return defaultRetryAfter;\n    }\n    var headerDelay = parseInt(\"\" + header, 10);\n    if (!isNaN(headerDelay)) {\n        return headerDelay * 1000;\n    }\n    var headerDate = Date.parse(\"\" + header);\n    if (!isNaN(headerDate)) {\n        return headerDate - now;\n    }\n    return defaultRetryAfter;\n}\nvar defaultFunctionName = '<anonymous>';\n/**\n * Safely extract function name from itself\n */\nexport function getFunctionName(fn) {\n    try {\n        if (!fn || typeof fn !== 'function') {\n            return defaultFunctionName;\n        }\n        return fn.name || defaultFunctionName;\n    }\n    catch (e) {\n        // Just accessing custom props in some Selenium environments\n        // can cause a \"Permission denied\" exception (see raven-js#495).\n        return defaultFunctionName;\n    }\n}\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nexport function addContextToFrame(lines, frame, linesOfContext) {\n    if (linesOfContext === void 0) { linesOfContext = 5; }\n    var lineno = frame.lineno || 0;\n    var maxLines = lines.length;\n    var sourceLine = Math.max(Math.min(maxLines, lineno - 1), 0);\n    frame.pre_context = lines\n        .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n        .map(function (line) { return snipLine(line, 0); });\n    frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n    frame.post_context = lines\n        .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n        .map(function (line) { return snipLine(line, 0); });\n}\n//# sourceMappingURL=misc.js.map","import * as tslib_1 from \"tslib\";\nimport { getGlobalObject, isPlainObject, isThenable, SyncPromise, timestampWithMs } from '@sentry/utils';\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nvar Scope = /** @class */ (function () {\n    function Scope() {\n        /** Flag if notifiying is happening. */\n        this._notifyingListeners = false;\n        /** Callback for client to receive scope changes. */\n        this._scopeListeners = [];\n        /** Callback list that will be called after {@link applyToEvent}. */\n        this._eventProcessors = [];\n        /** Array of breadcrumbs. */\n        this._breadcrumbs = [];\n        /** User */\n        this._user = {};\n        /** Tags */\n        this._tags = {};\n        /** Extra */\n        this._extra = {};\n        /** Contexts */\n        this._contexts = {};\n    }\n    /**\n     * Add internal on change listener. Used for sub SDKs that need to store the scope.\n     * @hidden\n     */\n    Scope.prototype.addScopeListener = function (callback) {\n        this._scopeListeners.push(callback);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addEventProcessor = function (callback) {\n        this._eventProcessors.push(callback);\n        return this;\n    };\n    /**\n     * This will be called on every set call.\n     */\n    Scope.prototype._notifyScopeListeners = function () {\n        var _this = this;\n        if (!this._notifyingListeners) {\n            this._notifyingListeners = true;\n            setTimeout(function () {\n                _this._scopeListeners.forEach(function (callback) {\n                    callback(_this);\n                });\n                _this._notifyingListeners = false;\n            });\n        }\n    };\n    /**\n     * This will be called after {@link applyToEvent} is finished.\n     */\n    Scope.prototype._notifyEventProcessors = function (processors, event, hint, index) {\n        var _this = this;\n        if (index === void 0) { index = 0; }\n        return new SyncPromise(function (resolve, reject) {\n            var processor = processors[index];\n            // tslint:disable-next-line:strict-type-predicates\n            if (event === null || typeof processor !== 'function') {\n                resolve(event);\n            }\n            else {\n                var result = processor(tslib_1.__assign({}, event), hint);\n                if (isThenable(result)) {\n                    result\n                        .then(function (final) { return _this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve); })\n                        .then(null, reject);\n                }\n                else {\n                    _this._notifyEventProcessors(processors, result, hint, index + 1)\n                        .then(resolve)\n                        .then(null, reject);\n                }\n            }\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setUser = function (user) {\n        this._user = user || {};\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTags = function (tags) {\n        this._tags = tslib_1.__assign({}, this._tags, tags);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTag = function (key, value) {\n        var _a;\n        this._tags = tslib_1.__assign({}, this._tags, (_a = {}, _a[key] = value, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtras = function (extras) {\n        this._extra = tslib_1.__assign({}, this._extra, extras);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtra = function (key, extra) {\n        var _a;\n        this._extra = tslib_1.__assign({}, this._extra, (_a = {}, _a[key] = extra, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setFingerprint = function (fingerprint) {\n        this._fingerprint = fingerprint;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setLevel = function (level) {\n        this._level = level;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTransaction = function (transaction) {\n        this._transaction = transaction;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setContext = function (key, context) {\n        var _a;\n        this._contexts = tslib_1.__assign({}, this._contexts, (_a = {}, _a[key] = context, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSpan = function (span) {\n        this._span = span;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Internal getter for Span, used in Hub.\n     * @hidden\n     */\n    Scope.prototype.getSpan = function () {\n        return this._span;\n    };\n    /**\n     * Inherit values from the parent scope.\n     * @param scope to clone.\n     */\n    Scope.clone = function (scope) {\n        var newScope = new Scope();\n        if (scope) {\n            newScope._breadcrumbs = tslib_1.__spread(scope._breadcrumbs);\n            newScope._tags = tslib_1.__assign({}, scope._tags);\n            newScope._extra = tslib_1.__assign({}, scope._extra);\n            newScope._contexts = tslib_1.__assign({}, scope._contexts);\n            newScope._user = scope._user;\n            newScope._level = scope._level;\n            newScope._span = scope._span;\n            newScope._transaction = scope._transaction;\n            newScope._fingerprint = scope._fingerprint;\n            newScope._eventProcessors = tslib_1.__spread(scope._eventProcessors);\n        }\n        return newScope;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.update = function (captureContext) {\n        if (!captureContext) {\n            return this;\n        }\n        if (typeof captureContext === 'function') {\n            var updatedScope = captureContext(this);\n            return updatedScope instanceof Scope ? updatedScope : this;\n        }\n        if (captureContext instanceof Scope) {\n            this._tags = tslib_1.__assign({}, this._tags, captureContext._tags);\n            this._extra = tslib_1.__assign({}, this._extra, captureContext._extra);\n            this._contexts = tslib_1.__assign({}, this._contexts, captureContext._contexts);\n            if (captureContext._user) {\n                this._user = captureContext._user;\n            }\n            if (captureContext._level) {\n                this._level = captureContext._level;\n            }\n            if (captureContext._fingerprint) {\n                this._fingerprint = captureContext._fingerprint;\n            }\n        }\n        else if (isPlainObject(captureContext)) {\n            // tslint:disable-next-line:no-parameter-reassignment\n            captureContext = captureContext;\n            this._tags = tslib_1.__assign({}, this._tags, captureContext.tags);\n            this._extra = tslib_1.__assign({}, this._extra, captureContext.extra);\n            this._contexts = tslib_1.__assign({}, this._contexts, captureContext.contexts);\n            if (captureContext.user) {\n                this._user = captureContext.user;\n            }\n            if (captureContext.level) {\n                this._level = captureContext.level;\n            }\n            if (captureContext.fingerprint) {\n                this._fingerprint = captureContext.fingerprint;\n            }\n        }\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clear = function () {\n        this._breadcrumbs = [];\n        this._tags = {};\n        this._extra = {};\n        this._user = {};\n        this._contexts = {};\n        this._level = undefined;\n        this._transaction = undefined;\n        this._fingerprint = undefined;\n        this._span = undefined;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {\n        var mergedBreadcrumb = tslib_1.__assign({ timestamp: timestampWithMs() }, breadcrumb);\n        this._breadcrumbs =\n            maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0\n                ? tslib_1.__spread(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxBreadcrumbs)\n                : tslib_1.__spread(this._breadcrumbs, [mergedBreadcrumb]);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clearBreadcrumbs = function () {\n        this._breadcrumbs = [];\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Applies fingerprint from the scope to the event if there's one,\n     * uses message if there's one instead or get rid of empty fingerprint\n     */\n    Scope.prototype._applyFingerprint = function (event) {\n        // Make sure it's an array first and we actually have something in place\n        event.fingerprint = event.fingerprint\n            ? Array.isArray(event.fingerprint)\n                ? event.fingerprint\n                : [event.fingerprint]\n            : [];\n        // If we have something on the scope, then merge it with event\n        if (this._fingerprint) {\n            event.fingerprint = event.fingerprint.concat(this._fingerprint);\n        }\n        // If we have no data at all, remove empty array default\n        if (event.fingerprint && !event.fingerprint.length) {\n            delete event.fingerprint;\n        }\n    };\n    /**\n     * Applies the current context and fingerprint to the event.\n     * Note that breadcrumbs will be added by the client.\n     * Also if the event has already breadcrumbs on it, we do not merge them.\n     * @param event Event\n     * @param hint May contain additional informartion about the original exception.\n     * @hidden\n     */\n    Scope.prototype.applyToEvent = function (event, hint) {\n        if (this._extra && Object.keys(this._extra).length) {\n            event.extra = tslib_1.__assign({}, this._extra, event.extra);\n        }\n        if (this._tags && Object.keys(this._tags).length) {\n            event.tags = tslib_1.__assign({}, this._tags, event.tags);\n        }\n        if (this._user && Object.keys(this._user).length) {\n            event.user = tslib_1.__assign({}, this._user, event.user);\n        }\n        if (this._contexts && Object.keys(this._contexts).length) {\n            event.contexts = tslib_1.__assign({}, this._contexts, event.contexts);\n        }\n        if (this._level) {\n            event.level = this._level;\n        }\n        if (this._transaction) {\n            event.transaction = this._transaction;\n        }\n        // We want to set the trace context for normal events only if there isn't already\n        // a trace context on the event. There is a product feature in place where we link\n        // errors with transaction and it relys on that.\n        if (this._span) {\n            event.contexts = tslib_1.__assign({ trace: this._span.getTraceContext() }, event.contexts);\n        }\n        this._applyFingerprint(event);\n        event.breadcrumbs = tslib_1.__spread((event.breadcrumbs || []), this._breadcrumbs);\n        event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n        return this._notifyEventProcessors(tslib_1.__spread(getGlobalEventProcessors(), this._eventProcessors), event, hint);\n    };\n    return Scope;\n}());\nexport { Scope };\n/**\n * Retruns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n    var global = getGlobalObject();\n    global.__SENTRY__ = global.__SENTRY__ || {};\n    global.__SENTRY__.globalEventProcessors = global.__SENTRY__.globalEventProcessors || [];\n    return global.__SENTRY__.globalEventProcessors;\n}\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nexport function addGlobalEventProcessor(callback) {\n    getGlobalEventProcessors().push(callback);\n}\n//# sourceMappingURL=scope.js.map","import { isRegExp, isString } from './is';\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nexport function truncate(str, max) {\n    if (max === void 0) { max = 0; }\n    // tslint:disable-next-line:strict-type-predicates\n    if (typeof str !== 'string' || max === 0) {\n        return str;\n    }\n    return str.length <= max ? str : str.substr(0, max) + \"...\";\n}\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nexport function snipLine(line, colno) {\n    var newLine = line;\n    var ll = newLine.length;\n    if (ll <= 150) {\n        return newLine;\n    }\n    if (colno > ll) {\n        colno = ll; // tslint:disable-line:no-parameter-reassignment\n    }\n    var start = Math.max(colno - 60, 0);\n    if (start < 5) {\n        start = 0;\n    }\n    var end = Math.min(start + 140, ll);\n    if (end > ll - 5) {\n        end = ll;\n    }\n    if (end === ll) {\n        start = Math.max(end - 140, 0);\n    }\n    newLine = newLine.slice(start, end);\n    if (start > 0) {\n        newLine = \"'{snip} \" + newLine;\n    }\n    if (end < ll) {\n        newLine += ' {snip}';\n    }\n    return newLine;\n}\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\nexport function safeJoin(input, delimiter) {\n    if (!Array.isArray(input)) {\n        return '';\n    }\n    var output = [];\n    // tslint:disable-next-line:prefer-for-of\n    for (var i = 0; i < input.length; i++) {\n        var value = input[i];\n        try {\n            output.push(String(value));\n        }\n        catch (e) {\n            output.push('[value cannot be serialized]');\n        }\n    }\n    return output.join(delimiter);\n}\n/**\n * Checks if the value matches a regex or includes the string\n * @param value The string value to be checked against\n * @param pattern Either a regex or a string that must be contained in value\n */\nexport function isMatchingPattern(value, pattern) {\n    if (!isString(value)) {\n        return false;\n    }\n    if (isRegExp(pattern)) {\n        return pattern.test(value);\n    }\n    if (typeof pattern === 'string') {\n        return value.indexOf(pattern) !== -1;\n    }\n    return false;\n}\n//# sourceMappingURL=string.js.map","import * as tslib_1 from \"tslib\";\nimport { getCurrentHub } from '@sentry/hub';\n/**\n * This calls a function on the current hub.\n * @param method function to call on hub.\n * @param args to pass to function.\n */\nfunction callOnHub(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    var hub = getCurrentHub();\n    if (hub && hub[method]) {\n        // tslint:disable-next-line:no-unsafe-any\n        return hub[method].apply(hub, tslib_1.__spread(args));\n    }\n    throw new Error(\"No hub defined or \" + method + \" was not found on the hub, please open a bug report.\");\n}\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @returns The generated eventId.\n */\nexport function captureException(exception, captureContext) {\n    var syntheticException;\n    try {\n        throw new Error('Sentry syntheticException');\n    }\n    catch (exception) {\n        syntheticException = exception;\n    }\n    return callOnHub('captureException', exception, {\n        captureContext: captureContext,\n        originalException: exception,\n        syntheticException: syntheticException,\n    });\n}\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param level Define the level of the message.\n * @returns The generated eventId.\n */\nexport function captureMessage(message, captureContext) {\n    var syntheticException;\n    try {\n        throw new Error(message);\n    }\n    catch (exception) {\n        syntheticException = exception;\n    }\n    // This is necessary to provide explicit scopes upgrade, without changing the original\n    // arrity of the `captureMessage(message, level)` method.\n    var level = typeof captureContext === 'string' ? captureContext : undefined;\n    var context = typeof captureContext !== 'string' ? { captureContext: captureContext } : undefined;\n    return callOnHub('captureMessage', message, level, tslib_1.__assign({ originalException: message, syntheticException: syntheticException }, context));\n}\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nexport function captureEvent(event) {\n    return callOnHub('captureEvent', event);\n}\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nexport function configureScope(callback) {\n    callOnHub('configureScope', callback);\n}\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nexport function addBreadcrumb(breadcrumb) {\n    callOnHub('addBreadcrumb', breadcrumb);\n}\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\nexport function setContext(name, context) {\n    callOnHub('setContext', name, context);\n}\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nexport function setExtras(extras) {\n    callOnHub('setExtras', extras);\n}\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nexport function setTags(tags) {\n    callOnHub('setTags', tags);\n}\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nexport function setExtra(key, extra) {\n    callOnHub('setExtra', key, extra);\n}\n/**\n * Set key:value that will be sent as tags data with the event.\n * @param key String key of tag\n * @param value String value of tag\n */\nexport function setTag(key, value) {\n    callOnHub('setTag', key, value);\n}\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nexport function setUser(user) {\n    callOnHub('setUser', user);\n}\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nexport function withScope(callback) {\n    callOnHub('withScope', callback);\n}\n/**\n * Calls a function on the latest client. Use this with caution, it's meant as\n * in \"internal\" helper so we don't need to expose every possible function in\n * the shim. It is not guaranteed that the client actually implements the\n * function.\n *\n * @param method The method to call on the client/client.\n * @param args Arguments to pass to the client/fontend.\n * @hidden\n */\nexport function _callOnClient(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    callOnHub.apply(void 0, tslib_1.__spread(['_invokeClient', method], args));\n}\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual\n * tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and\n * child spans to other spans. To start a new child span within the transaction\n * or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished,\n * otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at\n * which point the transaction with all its finished child spans will be sent to\n * Sentry.\n *\n * @param context Properties of the new `Transaction`.\n */\nexport function startTransaction(context) {\n    return callOnHub('startTransaction', tslib_1.__assign({}, context));\n}\n//# sourceMappingURL=index.js.map","import * as tslib_1 from \"tslib\";\nimport { consoleSandbox, getGlobalObject, isNodeEnv, logger, timestampWithMs, uuid4 } from '@sentry/utils';\nimport { Scope } from './scope';\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be incresed when the global interface\n * changes a and new methods are introduced.\n *\n * @hidden\n */\nexport var API_VERSION = 3;\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nvar DEFAULT_BREADCRUMBS = 100;\n/**\n * Absolute maximum number of breadcrumbs added to an event. The\n * `maxBreadcrumbs` option cannot be higher than this value.\n */\nvar MAX_BREADCRUMBS = 100;\n/**\n * @inheritDoc\n */\nvar Hub = /** @class */ (function () {\n    /**\n     * Creates a new instance of the hub, will push one {@link Layer} into the\n     * internal stack on creation.\n     *\n     * @param client bound to the hub.\n     * @param scope bound to the hub.\n     * @param version number, higher number means higher priority.\n     */\n    function Hub(client, scope, _version) {\n        if (scope === void 0) { scope = new Scope(); }\n        if (_version === void 0) { _version = API_VERSION; }\n        this._version = _version;\n        /** Is a {@link Layer}[] containing the client and scope */\n        this._stack = [];\n        this._stack.push({ client: client, scope: scope });\n    }\n    /**\n     * Internal helper function to call a method on the top client if it exists.\n     *\n     * @param method The method to call on the client.\n     * @param args Arguments to pass to the client function.\n     */\n    Hub.prototype._invokeClient = function (method) {\n        var _a;\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var top = this.getStackTop();\n        if (top && top.client && top.client[method]) {\n            (_a = top.client)[method].apply(_a, tslib_1.__spread(args, [top.scope]));\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.isOlderThan = function (version) {\n        return this._version < version;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.bindClient = function (client) {\n        var top = this.getStackTop();\n        top.client = client;\n        if (client && client.setupIntegrations) {\n            client.setupIntegrations();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.pushScope = function () {\n        // We want to clone the content of prev scope\n        var stack = this.getStack();\n        var parentScope = stack.length > 0 ? stack[stack.length - 1].scope : undefined;\n        var scope = Scope.clone(parentScope);\n        this.getStack().push({\n            client: this.getClient(),\n            scope: scope,\n        });\n        return scope;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.popScope = function () {\n        return this.getStack().pop() !== undefined;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.withScope = function (callback) {\n        var scope = this.pushScope();\n        try {\n            callback(scope);\n        }\n        finally {\n            this.popScope();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getClient = function () {\n        return this.getStackTop().client;\n    };\n    /** Returns the scope of the top stack. */\n    Hub.prototype.getScope = function () {\n        return this.getStackTop().scope;\n    };\n    /** Returns the scope stack for domains or the process. */\n    Hub.prototype.getStack = function () {\n        return this._stack;\n    };\n    /** Returns the topmost scope layer in the order domain > local > process. */\n    Hub.prototype.getStackTop = function () {\n        return this._stack[this._stack.length - 1];\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureException = function (exception, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error('Sentry syntheticException');\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: exception,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureException', exception, tslib_1.__assign({}, finalHint, { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureMessage = function (message, level, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error(message);\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: message,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureMessage', message, level, tslib_1.__assign({}, finalHint, { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureEvent = function (event, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        this._invokeClient('captureEvent', event, tslib_1.__assign({}, hint, { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.lastEventId = function () {\n        return this._lastEventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.addBreadcrumb = function (breadcrumb, hint) {\n        var top = this.getStackTop();\n        if (!top.scope || !top.client) {\n            return;\n        }\n        var _a = (top.client.getOptions && top.client.getOptions()) || {}, _b = _a.beforeBreadcrumb, beforeBreadcrumb = _b === void 0 ? null : _b, _c = _a.maxBreadcrumbs, maxBreadcrumbs = _c === void 0 ? DEFAULT_BREADCRUMBS : _c;\n        if (maxBreadcrumbs <= 0) {\n            return;\n        }\n        var timestamp = timestampWithMs();\n        var mergedBreadcrumb = tslib_1.__assign({ timestamp: timestamp }, breadcrumb);\n        var finalBreadcrumb = beforeBreadcrumb\n            ? consoleSandbox(function () { return beforeBreadcrumb(mergedBreadcrumb, hint); })\n            : mergedBreadcrumb;\n        if (finalBreadcrumb === null) {\n            return;\n        }\n        top.scope.addBreadcrumb(finalBreadcrumb, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setUser = function (user) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setUser(user);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTags = function (tags) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setTags(tags);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtras = function (extras) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setExtras(extras);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTag = function (key, value) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setTag(key, value);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtra = function (key, extra) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setExtra(key, extra);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setContext = function (name, context) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setContext(name, context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.configureScope = function (callback) {\n        var top = this.getStackTop();\n        if (top.scope && top.client) {\n            callback(top.scope);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.run = function (callback) {\n        var oldHub = makeMain(this);\n        try {\n            callback(this);\n        }\n        finally {\n            makeMain(oldHub);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getIntegration = function (integration) {\n        var client = this.getClient();\n        if (!client) {\n            return null;\n        }\n        try {\n            return client.getIntegration(integration);\n        }\n        catch (_oO) {\n            logger.warn(\"Cannot retrieve integration \" + integration.id + \" from the current Hub\");\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSpan = function (context) {\n        return this._callExtensionMethod('startSpan', context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startTransaction = function (context) {\n        return this._callExtensionMethod('startTransaction', context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.traceHeaders = function () {\n        return this._callExtensionMethod('traceHeaders');\n    };\n    /**\n     * Calls global extension method and binding current instance to the function call\n     */\n    // @ts-ignore\n    Hub.prototype._callExtensionMethod = function (method) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var carrier = getMainCarrier();\n        var sentry = carrier.__SENTRY__;\n        // tslint:disable-next-line: strict-type-predicates\n        if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n            return sentry.extensions[method].apply(this, args);\n        }\n        logger.warn(\"Extension method \" + method + \" couldn't be found, doing nothing.\");\n    };\n    return Hub;\n}());\nexport { Hub };\n/** Returns the global shim registry. */\nexport function getMainCarrier() {\n    var carrier = getGlobalObject();\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {\n        extensions: {},\n        hub: undefined,\n    };\n    return carrier;\n}\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nexport function makeMain(hub) {\n    var registry = getMainCarrier();\n    var oldHub = getHubFromCarrier(registry);\n    setHubOnCarrier(registry, hub);\n    return oldHub;\n}\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nexport function getCurrentHub() {\n    // Get main carrier (global for every environment)\n    var registry = getMainCarrier();\n    // If there's no hub, or its an old API, assign a new one\n    if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n        setHubOnCarrier(registry, new Hub());\n    }\n    // Prefer domains over global if they are there (applicable only to Node environment)\n    if (isNodeEnv()) {\n        return getHubFromActiveDomain(registry);\n    }\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n}\n/**\n * Try to read the hub from an active domain, fallback to the registry if one doesnt exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n    try {\n        var property = 'domain';\n        var carrier = getMainCarrier();\n        var sentry = carrier.__SENTRY__;\n        // tslint:disable-next-line: strict-type-predicates\n        if (!sentry || !sentry.extensions || !sentry.extensions[property]) {\n            return getHubFromCarrier(registry);\n        }\n        var domain = sentry.extensions[property];\n        var activeDomain = domain.active;\n        // If there no active domain, just return global hub\n        if (!activeDomain) {\n            return getHubFromCarrier(registry);\n        }\n        // If there's no hub on current domain, or its an old API, assign a new one\n        if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n            var registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n            setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n        }\n        // Return hub that lives on a domain\n        return getHubFromCarrier(activeDomain);\n    }\n    catch (_Oo) {\n        // Return hub that lives on a global object\n        return getHubFromCarrier(registry);\n    }\n}\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier) {\n    if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub) {\n        return true;\n    }\n    return false;\n}\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nexport function getHubFromCarrier(carrier) {\n    if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub) {\n        return carrier.__SENTRY__.hub;\n    }\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = new Hub();\n    return carrier.__SENTRY__.hub;\n}\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n */\nexport function setHubOnCarrier(carrier, hub) {\n    if (!carrier) {\n        return false;\n    }\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = hub;\n    return true;\n}\n//# sourceMappingURL=hub.js.map","import { consoleSandbox, getGlobalObject } from './misc';\n// TODO: Implement different loggers for different environments\nvar global = getGlobalObject();\n/** Prefix for logging strings */\nvar PREFIX = 'Sentry Logger ';\n/** JSDoc */\nvar Logger = /** @class */ (function () {\n    /** JSDoc */\n    function Logger() {\n        this._enabled = false;\n    }\n    /** JSDoc */\n    Logger.prototype.disable = function () {\n        this._enabled = false;\n    };\n    /** JSDoc */\n    Logger.prototype.enable = function () {\n        this._enabled = true;\n    };\n    /** JSDoc */\n    Logger.prototype.log = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.log(PREFIX + \"[Log]: \" + args.join(' ')); // tslint:disable-line:no-console\n        });\n    };\n    /** JSDoc */\n    Logger.prototype.warn = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.warn(PREFIX + \"[Warn]: \" + args.join(' ')); // tslint:disable-line:no-console\n        });\n    };\n    /** JSDoc */\n    Logger.prototype.error = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.error(PREFIX + \"[Error]: \" + args.join(' ')); // tslint:disable-line:no-console\n        });\n    };\n    return Logger;\n}());\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nglobal.__SENTRY__ = global.__SENTRY__ || {};\nvar logger = global.__SENTRY__.logger || (global.__SENTRY__.logger = new Logger());\nexport { logger };\n//# sourceMappingURL=logger.js.map","// Slightly modified (no IE8 support, ES6) and transcribed to TypeScript\n// https://raw.githubusercontent.com/calvinmetcalf/rollup-plugin-node-builtins/master/src/es6/path.js\n/** JSDoc */\nfunction normalizeArray(parts, allowAboveRoot) {\n    // if the path tries to go above the root, `up` ends up > 0\n    var up = 0;\n    for (var i = parts.length - 1; i >= 0; i--) {\n        var last = parts[i];\n        if (last === '.') {\n            parts.splice(i, 1);\n        }\n        else if (last === '..') {\n            parts.splice(i, 1);\n            up++;\n        }\n        else if (up) {\n            parts.splice(i, 1);\n            up--;\n        }\n    }\n    // if the path is allowed to go above the root, restore leading ..s\n    if (allowAboveRoot) {\n        for (; up--; up) {\n            parts.unshift('..');\n        }\n    }\n    return parts;\n}\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nvar splitPathRe = /^(\\/?|)([\\s\\S]*?)((?:\\.{1,2}|[^\\/]+?|)(\\.[^.\\/]*|))(?:[\\/]*)$/;\n/** JSDoc */\nfunction splitPath(filename) {\n    var parts = splitPathRe.exec(filename);\n    return parts ? parts.slice(1) : [];\n}\n// path.resolve([from ...], to)\n// posix version\n/** JSDoc */\nexport function resolve() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    var resolvedPath = '';\n    var resolvedAbsolute = false;\n    for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n        var path = i >= 0 ? args[i] : '/';\n        // Skip empty entries\n        if (!path) {\n            continue;\n        }\n        resolvedPath = path + \"/\" + resolvedPath;\n        resolvedAbsolute = path.charAt(0) === '/';\n    }\n    // At this point the path should be resolved to a full absolute path, but\n    // handle relative paths to be safe (might happen when process.cwd() fails)\n    // Normalize the path\n    resolvedPath = normalizeArray(resolvedPath.split('/').filter(function (p) { return !!p; }), !resolvedAbsolute).join('/');\n    return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';\n}\n/** JSDoc */\nfunction trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n        if (arr[start] !== '') {\n            break;\n        }\n    }\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n        if (arr[end] !== '') {\n            break;\n        }\n    }\n    if (start > end) {\n        return [];\n    }\n    return arr.slice(start, end - start + 1);\n}\n// path.relative(from, to)\n// posix version\n/** JSDoc */\nexport function relative(from, to) {\n    // tslint:disable:no-parameter-reassignment\n    from = resolve(from).substr(1);\n    to = resolve(to).substr(1);\n    var fromParts = trim(from.split('/'));\n    var toParts = trim(to.split('/'));\n    var length = Math.min(fromParts.length, toParts.length);\n    var samePartsLength = length;\n    for (var i = 0; i < length; i++) {\n        if (fromParts[i] !== toParts[i]) {\n            samePartsLength = i;\n            break;\n        }\n    }\n    var outputParts = [];\n    for (var i = samePartsLength; i < fromParts.length; i++) {\n        outputParts.push('..');\n    }\n    outputParts = outputParts.concat(toParts.slice(samePartsLength));\n    return outputParts.join('/');\n}\n// path.normalize(path)\n// posix version\n/** JSDoc */\nexport function normalizePath(path) {\n    var isPathAbsolute = isAbsolute(path);\n    var trailingSlash = path.substr(-1) === '/';\n    // Normalize the path\n    var normalizedPath = normalizeArray(path.split('/').filter(function (p) { return !!p; }), !isPathAbsolute).join('/');\n    if (!normalizedPath && !isPathAbsolute) {\n        normalizedPath = '.';\n    }\n    if (normalizedPath && trailingSlash) {\n        normalizedPath += '/';\n    }\n    return (isPathAbsolute ? '/' : '') + normalizedPath;\n}\n// posix version\n/** JSDoc */\nexport function isAbsolute(path) {\n    return path.charAt(0) === '/';\n}\n// posix version\n/** JSDoc */\nexport function join() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    return normalizePath(args.join('/'));\n}\n/** JSDoc */\nexport function dirname(path) {\n    var result = splitPath(path);\n    var root = result[0];\n    var dir = result[1];\n    if (!root && !dir) {\n        // No dirname whatsoever\n        return '.';\n    }\n    if (dir) {\n        // It has a dirname, strip trailing slash\n        dir = dir.substr(0, dir.length - 1);\n    }\n    return root + dir;\n}\n/** JSDoc */\nexport function basename(path, ext) {\n    var f = splitPath(path)[2];\n    if (ext && f.substr(ext.length * -1) === ext) {\n        f = f.substr(0, f.length - ext.length);\n    }\n    return f;\n}\n//# sourceMappingURL=path.js.map","import * as tslib_1 from \"tslib\";\nimport { basename, getGlobalObject, logger, timestampWithMs } from '@sentry/utils';\n/**\n * Used to extract Tracing integration from the current client,\n * without the need to import `Tracing` itself from the @sentry/apm package.\n */\nvar TRACING_GETTER = {\n    id: 'Tracing',\n};\n// Mappings from operation to corresponding lifecycle hook.\nvar HOOKS = {\n    activate: ['activated', 'deactivated'],\n    create: ['beforeCreate', 'created'],\n    destroy: ['beforeDestroy', 'destroyed'],\n    mount: ['beforeMount', 'mounted'],\n    update: ['beforeUpdate', 'updated'],\n};\nvar COMPONENT_NAME_REGEXP = /(?:^|[-_/])(\\w)/g;\nvar ROOT_COMPONENT_NAME = 'root';\nvar ANONYMOUS_COMPONENT_NAME = 'anonymous component';\n/** JSDoc */\nvar Vue = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function Vue(options) {\n        var _this = this;\n        /**\n         * @inheritDoc\n         */\n        this.name = Vue.id;\n        /**\n         * Cache holding already processed component names\n         */\n        this._componentsCache = {};\n        /** Keep it as attribute function, to keep correct `this` binding inside the hooks callbacks  */\n        this._applyTracingHooks = function (vm, getCurrentHub) {\n            // Don't attach twice, just in case\n            if (vm.$options.$_sentryPerfHook) {\n                return;\n            }\n            vm.$options.$_sentryPerfHook = true;\n            var name = _this._getComponentName(vm);\n            var rootMount = name === ROOT_COMPONENT_NAME;\n            var spans = {};\n            // Render hook starts after once event is emitted,\n            // but it ends before the second event of the same type.\n            //\n            // Because of this, we start measuring inside the first event,\n            // but finish it before it triggers, to skip the event emitter timing itself.\n            var rootHandler = function (hook) {\n                var now = timestampWithMs();\n                // On the first handler call (before), it'll be undefined, as `$once` will add it in the future.\n                // However, on the second call (after), it'll be already in place.\n                if (_this._rootSpan) {\n                    _this._finishRootSpan(now, getCurrentHub);\n                }\n                else {\n                    vm.$once(\"hook:\" + hook, function () {\n                        // Create an activity on the first event call. There'll be no second call, as rootSpan will be in place,\n                        // thus new event handler won't be attached.\n                        // We do this whole dance with `TRACING_GETTER` to prevent `@sentry/apm` from becoming a peerDependency.\n                        // We also need to ask for the `.constructor`, as `pushActivity` and `popActivity` are static, not instance methods.\n                        var tracingIntegration = getCurrentHub().getIntegration(TRACING_GETTER);\n                        if (tracingIntegration) {\n                            // tslint:disable-next-line:no-unsafe-any\n                            _this._tracingActivity = tracingIntegration.constructor.pushActivity('Vue Application Render');\n                            // tslint:disable-next-line:no-unsafe-any\n                            var transaction = tracingIntegration.constructor.getTransaction();\n                            if (transaction) {\n                                // tslint:disable-next-line:no-unsafe-any\n                                _this._rootSpan = transaction.startChild({\n                                    description: 'Application Render',\n                                    op: 'Vue',\n                                });\n                            }\n                        }\n                    });\n                }\n            };\n            var childHandler = function (hook, operation) {\n                // Skip components that we don't want to track to minimize the noise and give a more granular control to the user\n                var shouldTrack = Array.isArray(_this._options.tracingOptions.trackComponents)\n                    ? _this._options.tracingOptions.trackComponents.indexOf(name) > -1\n                    : _this._options.tracingOptions.trackComponents;\n                if (!_this._rootSpan || !shouldTrack) {\n                    return;\n                }\n                var now = timestampWithMs();\n                var span = spans[operation];\n                // On the first handler call (before), it'll be undefined, as `$once` will add it in the future.\n                // However, on the second call (after), it'll be already in place.\n                if (span) {\n                    span.finish();\n                    _this._finishRootSpan(now, getCurrentHub);\n                }\n                else {\n                    vm.$once(\"hook:\" + hook, function () {\n                        if (_this._rootSpan) {\n                            spans[operation] = _this._rootSpan.startChild({\n                                description: \"Vue <\" + name + \">\",\n                                op: operation,\n                            });\n                        }\n                    });\n                }\n            };\n            // Each compomnent has it's own scope, so all activities are only related to one of them\n            _this._options.tracingOptions.hooks.forEach(function (operation) {\n                // Retrieve corresponding hooks from Vue lifecycle.\n                // eg. mount => ['beforeMount', 'mounted']\n                var internalHooks = HOOKS[operation];\n                if (!internalHooks) {\n                    logger.warn(\"Unknown hook: \" + operation);\n                    return;\n                }\n                internalHooks.forEach(function (internalHook) {\n                    var handler = rootMount\n                        ? rootHandler.bind(_this, internalHook)\n                        : childHandler.bind(_this, internalHook, operation);\n                    var currentValue = vm.$options[internalHook];\n                    if (Array.isArray(currentValue)) {\n                        vm.$options[internalHook] = tslib_1.__spread([handler], currentValue);\n                    }\n                    else if (typeof currentValue === 'function') {\n                        vm.$options[internalHook] = [handler, currentValue];\n                    }\n                    else {\n                        vm.$options[internalHook] = [handler];\n                    }\n                });\n            });\n        };\n        this._options = tslib_1.__assign({ Vue: getGlobalObject().Vue, attachProps: true, logErrors: false, tracing: false }, options, { tracingOptions: tslib_1.__assign({ hooks: ['mount', 'update'], timeout: 2000, trackComponents: false }, options.tracingOptions) });\n    }\n    /**\n     * Extract component name from the ViewModel\n     */\n    Vue.prototype._getComponentName = function (vm) {\n        // Such level of granularity is most likely not necessary, but better safe than sorry. — Kamil\n        if (!vm) {\n            return ANONYMOUS_COMPONENT_NAME;\n        }\n        if (vm.$root === vm) {\n            return ROOT_COMPONENT_NAME;\n        }\n        if (!vm.$options) {\n            return ANONYMOUS_COMPONENT_NAME;\n        }\n        if (vm.$options.name) {\n            return vm.$options.name;\n        }\n        if (vm.$options._componentTag) {\n            return vm.$options._componentTag;\n        }\n        // injected by vue-loader\n        if (vm.$options.__file) {\n            var unifiedFile = vm.$options.__file.replace(/^[a-zA-Z]:/, '').replace(/\\\\/g, '/');\n            var filename = basename(unifiedFile, '.vue');\n            return (this._componentsCache[filename] ||\n                (this._componentsCache[filename] = filename.replace(COMPONENT_NAME_REGEXP, function (_, c) {\n                    return c ? c.toUpperCase() : '';\n                })));\n        }\n        return ANONYMOUS_COMPONENT_NAME;\n    };\n    /** Finish top-level span and activity with a debounce configured using `timeout` option */\n    Vue.prototype._finishRootSpan = function (timestamp, getCurrentHub) {\n        var _this = this;\n        if (this._rootSpanTimer) {\n            clearTimeout(this._rootSpanTimer);\n        }\n        this._rootSpanTimer = setTimeout(function () {\n            if (_this._tracingActivity) {\n                // We do this whole dance with `TRACING_GETTER` to prevent `@sentry/apm` from becoming a peerDependency.\n                // We also need to ask for the `.constructor`, as `pushActivity` and `popActivity` are static, not instance methods.\n                var tracingIntegration = getCurrentHub().getIntegration(TRACING_GETTER);\n                if (tracingIntegration) {\n                    // tslint:disable-next-line:no-unsafe-any\n                    tracingIntegration.constructor.popActivity(_this._tracingActivity);\n                    if (_this._rootSpan) {\n                        _this._rootSpan.finish(timestamp);\n                    }\n                }\n            }\n        }, this._options.tracingOptions.timeout);\n    };\n    /** Inject configured tracing hooks into Vue's component lifecycles */\n    Vue.prototype._startTracing = function (getCurrentHub) {\n        var applyTracingHooks = this._applyTracingHooks;\n        this._options.Vue.mixin({\n            beforeCreate: function () {\n                if (getCurrentHub().getIntegration(TRACING_GETTER)) {\n                    // `this` points to currently rendered component\n                    applyTracingHooks(this, getCurrentHub);\n                }\n                else {\n                    logger.error('Vue integration has tracing enabled, but Tracing integration is not configured');\n                }\n            },\n        });\n    };\n    /** Inject Sentry's handler into owns Vue's error handler  */\n    Vue.prototype._attachErrorHandler = function (getCurrentHub) {\n        var _this = this;\n        var currentErrorHandler = this._options.Vue.config.errorHandler; // tslint:disable-line:no-unbound-method\n        this._options.Vue.config.errorHandler = function (error, vm, info) {\n            var metadata = {};\n            if (vm) {\n                try {\n                    metadata.componentName = _this._getComponentName(vm);\n                    if (_this._options.attachProps) {\n                        metadata.propsData = vm.$options.propsData;\n                    }\n                }\n                catch (_oO) {\n                    logger.warn('Unable to extract metadata from Vue component.');\n                }\n            }\n            if (info) {\n                metadata.lifecycleHook = info;\n            }\n            if (getCurrentHub().getIntegration(Vue)) {\n                // Capture exception in the next event loop, to make sure that all breadcrumbs are recorded in time.\n                setTimeout(function () {\n                    getCurrentHub().withScope(function (scope) {\n                        scope.setContext('vue', metadata);\n                        getCurrentHub().captureException(error);\n                    });\n                });\n            }\n            if (typeof currentErrorHandler === 'function') {\n                currentErrorHandler.call(_this._options.Vue, error, vm, info);\n            }\n            if (_this._options.logErrors) {\n                if (_this._options.Vue.util) {\n                    _this._options.Vue.util.warn(\"Error in \" + info + \": \\\"\" + error.toString() + \"\\\"\", vm);\n                }\n                console.error(error); // tslint:disable-line:no-console\n            }\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    Vue.prototype.setupOnce = function (_, getCurrentHub) {\n        if (!this._options.Vue) {\n            logger.error('Vue integration is missing a Vue instance');\n            return;\n        }\n        this._attachErrorHandler(getCurrentHub);\n        if (this._options.tracing) {\n            this._startTracing(getCurrentHub);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Vue.id = 'Vue';\n    return Vue;\n}());\nexport { Vue };\n//# sourceMappingURL=vue.js.map"],"sourceRoot":""}