{"version":3,"sources":["webpack:///./node_modules/@sentry/utils/esm/object.js","webpack:///./node_modules/@sentry/utils/esm/polyfill.js","webpack:///./node_modules/@sentry/utils/esm/error.js","webpack:///./node_modules/@sentry/utils/esm/string.js","webpack:///./node_modules/@sentry/utils/esm/logger.js","webpack:///./node_modules/@vue/composition-api/dist/vue-composition-api.esm.js","webpack:///./node_modules/@sentry/utils/esm/syncpromise.js","webpack:///./node_modules/@sentry/utils/esm/supports.js","webpack:///./node_modules/@sentry/utils/esm/memo.js","webpack:///./node_modules/@sentry/utils/esm/misc.js","webpack:///./node_modules/@sentry/utils/esm/is.js","webpack:///./node_modules/@sentry/webpack-plugin/src/sentry-webpack.module.js","webpack:///./node_modules/@sentry/types/esm/severity.js","webpack:///./node_modules/@sentry/utils/esm/instrument.js","webpack:///./node_modules/@sentry/types/esm/status.js","webpack:///./node_modules/@sentry/utils/esm/promisebuffer.js","webpack:///./node_modules/@sentry/utils/esm/dsn.js"],"names":["fill","source","name","replacement","original","wrapped","prototype","Object","defineProperties","__sentry_original__","enumerable","value","_Oo","urlEncode","object","keys","map","key","encodeURIComponent","join","getWalkSource","error","err","message","stack","i","hasOwnProperty","call","event_1","type","target","toString","_oO","currentTarget","CustomEvent","detail","jsonSize","encodeURI","split","length","utf8Length","JSON","stringify","normalizeToSize","depth","maxSize","serialized","normalize","normalizeValue","_events","global","window","document","walk","memo","Infinity","normalized","serializeValue","toJSON","acc","Array","isArray","memoize","innerKey","unmemoize","input","parse","extractExceptionKeysForMessage","exception","maxLength","sort","includedKeys","slice","setPrototypeOf","__proto__","obj","proto","prop","_super","SentryError","_newTarget","this","constructor","_this","Error","truncate","str","max","substr","snipLine","line","colno","newLine","ll","start","Math","end","min","safeJoin","delimiter","output","push","String","e","isMatchingPattern","pattern","test","indexOf","PREFIX","Logger","_enabled","disable","enable","log","args","_i","arguments","console","warn","__SENTRY__","logger","x","isNative","Ctor","hasSymbol","Symbol","Reflect","ownKeys","noopFn","_","proxy","_a","get","set","defineProperty","configurable","def","val","writable","hasOwn","objectToString","toTypeString","isMap","isSet","isObject","isPlainObject","isFunction","warn$1","msg","vm","util","vueDependency","undefined","requiredVue","isVue","default","vueConstructor","currentInstance","PluginInstalledFlag","getVueConstructor","setCurrentInstance","getCurrentInstance","toVue3ComponentInstance","vue2Instance","instanceMapCache","has","instance","update","$forceUpdate","uid","_uid","emit","$emit","bind","parent","root","forEach","_isMounted","_isDestroyed","_inactive","$parent","$root","vueInternalClasses","WeakMap","currentVMInFn","hook","defineComponentInstance","options","silent","config","createSlotProxy","slotName","$scopedSlots","apply","getVueInternalClasses","computed","Watcher","_computedWatchers","Dep","_data","__ob__","dep","$destroy","__assign","assign","t","s","n","p","__values","o","iterator","m","next","done","TypeError","__read","r","ar","__spreadArray","to","from","il","j","createSymbol","for","WatcherPreFlushQueueKey","WatcherPostFlushQueueKey","RefKey","accessModifiedSet","readonlySet","RefImpl","createRef","readonly","sealed","seal","ref","raw","isRef","reactive","v","unref","toRefs","ret","toRef","shallowRef","e_1","isRaw","isExtensible","observed","observe","setupAccessControl","ob","_loop_1","getter","setter","property","getOwnPropertyDescriptor","depend","newVal","notify","_b","_c","e_1_1","return","shallowReactive","Boolean","__raw__","isReactive","Vue","defineAccessControl","observable","data","$$state","addSub","removeSub","mockObserver","createObserver","genName","toUpperCase","createLifeCycle","lifeCyclehook","callback","$options","mergeFn","optionMergeStrategies","fn","preVm","wrapHookCall","injectHookOption","fallbackVM","onMounted","onUnmounted","flushPreQueue","flushQueue","flushPostQueue","getWatcherVM","hasWatchEnv","$on","installWatchEnv","queue","index","queueFlushJob","mode","fallbackFlush","$nextTick","condition","assert","patchWatcherTeardown","watcher","runCleanup","_teardown","teardown","createWatcher","cb","cleanup","flushMode","flush","isSync","registerCleanup","info","logError","createScheduler","running_1","watcher_1","_watchers","$watch","immediate","immediateInvokeCallback","deep","lazy","noRun","sync","before","createVueWatcher","originGet","traverse","seen","Set","add","applyCb","originalCallback_1","shiftCallback_1","stop","run","watchEffect","effect","opts","getWatchEffectOption","watch","getWatcherOption","getterOrOptions","computedSetter","computedGetter","$isServer","Watcher_1","Dep_1","dirty","evaluate","computedHost_1","NOT_FOUND","inject","defaultValue","treatDefaultAsFactory","provideKey","_provided","resolveInject","fallbackCreateElement","nextTick","createElement","$createElement","vmStateManager","__composition_api_state__","updateTemplateRef","rawBindings","refs","$refs","oldRefKeys","setupValue","newKeys","validNewKeys","resolveScopedSlots","slotsProxy","parentVNode","_parentVnode","prevSlots","curSlots","slots","normalSlots","res","_normalized","resolveSlots","scopedSlots","$slots","slotNames","activateCurrentInstance","onError","mixin","beforeCreate","setup","render","props","binding","ctx","srcKey","attr","createSetupContext","bindingFunc_1","bindingObj_1","bindingValue","hasReactiveArrayChild","visited","Map","some","customReactive","defineReactive","k","propName","propValue","asVmProperty","initSetup","$props","mounted","updated","install","isVueRegistered","child","context","mergeData","toVal","fromVal","setVueConstructor","Plugin","defineComponent","use","States","SyncPromise","executor","_state","PENDING","_handlers","_resolve","_setResult","RESOLVED","_reject","reason","REJECTED","state","then","_value","_executeHandlers","_attachHandler","handler","concat","cachedHandlers","onfulfilled","onrejected","resolve","reject","all","collection","counter","resolvedCollection","item","result","catch","finally","onfinally","isRejected","supportsFetch","Headers","Request","Response","isNativeFetch","func","supportsNativeFetch","fetch","doc","sandbox","hidden","head","appendChild","contentWindow","removeChild","supportsReferrerPolicy","referrerPolicy","supportsHistory","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","Memo","_hasWeakSet","WeakSet","_inner","delete","splice","isNodeEnv","process","fallbackGlobalObject","getGlobalObject","self","uuid4","crypto","msCrypto","getRandomValues","arr","Uint16Array","pad","num","replace","c","random","parseUrl","url","match","query","fragment","host","path","protocol","relative","getEventDescription","event","values","event_id","consoleSandbox","originalConsole","wrappedLevels","level","addExceptionTypeValue","addExceptionMechanism","mechanism","getLocationHref","location","href","oO","htmlTreeAsString","elem","currentElem","out","height","len","sepLength","nextStr","_htmlElementAsString","parentNode","reverse","el","className","classes","tagName","toLowerCase","id","attrWhitelist","getAttribute","INITIAL_TIME","Date","now","prevNow","performanceFallback","timeOrigin","crossPlatformPerformance","request","module","require","performance","timing","navigationStart","timestampWithMs","defaultRetryAfter","parseRetryAfterHeader","header","headerDelay","parseInt","isNaN","headerDate","defaultFunctionName","getFunctionName","isError","wat","isInstanceOf","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isEvent","Event","isElement","Element","isRegExp","isThenable","isSyntheticEvent","base","_e","SENTRY_RELEASE","Severity","fromString","Debug","Info","Warning","Fatal","Critical","Log","lastHref","handlers","instrumented","instrument","originalConsoleLevel","triggerHandlers","Function","instrumentConsole","addEventListener","domEventHandler","keypressEventHandler","eventName","handleEvent","innerOriginal","__sentry_wrapped__","instrumentDOM","xhrproto","XMLHttpRequest","originalOpen","xhr","__sentry_xhr__","method","__sentry_own_request__","onreadystatechangeHandler","readyState","status_code","status","endTimestamp","startTimestamp","onreadystatechange","readyStateArgs","originalSend","instrumentXHR","originalFetch","commonHandlerData","fetchData","getFetchMethod","getFetchUrl","response","instrumentFetch","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","instrumentHistory","_oldOnErrorHandler","onerror","column","_oldOnUnhandledRejectionHandler","onunhandledrejection","addInstrumentationHandler","fetchArgs","keypressTimeout","lastCapturedEvent","debounceDuration","debounceTimer","debounce","clearTimeout","setTimeout","isContentEditable","Status","fromHttpCode","code","Success","RateLimit","Invalid","Failed","Unknown","PromiseBuffer","_limit","_buffer","isReady","task","remove","drain","timeout","capturedSetTimeout","DSN_REGEX","Dsn","_fromString","_fromComponents","_validate","withPassword","pass","port","projectId","user","exec","pop","projectMatch","components","component","ERROR_MESSAGE"],"mappings":"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","file":"vendors~app~f4520c04.js","sourcesContent":["import * as tslib_1 from \"tslib\";\nimport { isElement, isError, isEvent, isInstanceOf, isPlainObject, isPrimitive, isSyntheticEvent } from './is';\nimport { Memo } from './memo';\nimport { getFunctionName, htmlTreeAsString } from './misc';\nimport { truncate } from './string';\n/**\n * Wrap a given object method with a higher-order function\n *\n * @param source An object that contains a method to be wrapped.\n * @param name A name of method to be wrapped.\n * @param replacement A function that should be used to wrap a given method.\n * @returns void\n */\nexport function fill(source, name, replacement) {\n    if (!(name in source)) {\n        return;\n    }\n    var original = source[name];\n    var wrapped = replacement(original);\n    // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n    // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n    // tslint:disable-next-line:strict-type-predicates\n    if (typeof wrapped === 'function') {\n        try {\n            wrapped.prototype = wrapped.prototype || {};\n            Object.defineProperties(wrapped, {\n                __sentry_original__: {\n                    enumerable: false,\n                    value: original,\n                },\n            });\n        }\n        catch (_Oo) {\n            // This can throw if multiple fill happens on a global object like XMLHttpRequest\n            // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n        }\n    }\n    source[name] = wrapped;\n}\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nexport function urlEncode(object) {\n    return Object.keys(object)\n        .map(\n    // tslint:disable-next-line:no-unsafe-any\n    function (key) { return encodeURIComponent(key) + \"=\" + encodeURIComponent(object[key]); })\n        .join('&');\n}\n/**\n * Transforms any object into an object literal with all it's attributes\n * attached to it.\n *\n * @param value Initial source that we have to transform in order to be usable by the serializer\n */\nfunction getWalkSource(value) {\n    if (isError(value)) {\n        var error = value;\n        var err = {\n            message: error.message,\n            name: error.name,\n            stack: error.stack,\n        };\n        for (var i in error) {\n            if (Object.prototype.hasOwnProperty.call(error, i)) {\n                err[i] = error[i];\n            }\n        }\n        return err;\n    }\n    if (isEvent(value)) {\n        var event_1 = value;\n        var source = {};\n        source.type = event_1.type;\n        // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n        try {\n            source.target = isElement(event_1.target)\n                ? htmlTreeAsString(event_1.target)\n                : Object.prototype.toString.call(event_1.target);\n        }\n        catch (_oO) {\n            source.target = '<unknown>';\n        }\n        try {\n            source.currentTarget = isElement(event_1.currentTarget)\n                ? htmlTreeAsString(event_1.currentTarget)\n                : Object.prototype.toString.call(event_1.currentTarget);\n        }\n        catch (_oO) {\n            source.currentTarget = '<unknown>';\n        }\n        // tslint:disable-next-line:strict-type-predicates\n        if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n            source.detail = event_1.detail;\n        }\n        for (var i in event_1) {\n            if (Object.prototype.hasOwnProperty.call(event_1, i)) {\n                source[i] = event_1;\n            }\n        }\n        return source;\n    }\n    return value;\n}\n/** Calculates bytes size of input string */\nfunction utf8Length(value) {\n    // tslint:disable-next-line:no-bitwise\n    return ~-encodeURI(value).split(/%..|./).length;\n}\n/** Calculates bytes size of input object */\nfunction jsonSize(value) {\n    return utf8Length(JSON.stringify(value));\n}\n/** JSDoc */\nexport function normalizeToSize(object, \n// Default Node.js REPL depth\ndepth, \n// 100kB, as 200kB is max payload size, so half sounds reasonable\nmaxSize) {\n    if (depth === void 0) { depth = 3; }\n    if (maxSize === void 0) { maxSize = 100 * 1024; }\n    var serialized = normalize(object, depth);\n    if (jsonSize(serialized) > maxSize) {\n        return normalizeToSize(object, depth - 1, maxSize);\n    }\n    return serialized;\n}\n/** Transforms any input value into a string form, either primitive value or a type of the input */\nfunction serializeValue(value) {\n    var type = Object.prototype.toString.call(value);\n    // Node.js REPL notation\n    if (typeof value === 'string') {\n        return value;\n    }\n    if (type === '[object Object]') {\n        return '[Object]';\n    }\n    if (type === '[object Array]') {\n        return '[Array]';\n    }\n    var normalized = normalizeValue(value);\n    return isPrimitive(normalized) ? normalized : type;\n}\n/**\n * normalizeValue()\n *\n * Takes unserializable input and make it serializable friendly\n *\n * - translates undefined/NaN values to \"[undefined]\"/\"[NaN]\" respectively,\n * - serializes Error objects\n * - filter global objects\n */\n// tslint:disable-next-line:cyclomatic-complexity\nfunction normalizeValue(value, key) {\n    if (key === 'domain' && value && typeof value === 'object' && value._events) {\n        return '[Domain]';\n    }\n    if (key === 'domainEmitter') {\n        return '[DomainEmitter]';\n    }\n    if (typeof global !== 'undefined' && value === global) {\n        return '[Global]';\n    }\n    if (typeof window !== 'undefined' && value === window) {\n        return '[Window]';\n    }\n    if (typeof document !== 'undefined' && value === document) {\n        return '[Document]';\n    }\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n        return '[SyntheticEvent]';\n    }\n    // tslint:disable-next-line:no-tautology-expression\n    if (typeof value === 'number' && value !== value) {\n        return '[NaN]';\n    }\n    if (value === void 0) {\n        return '[undefined]';\n    }\n    if (typeof value === 'function') {\n        return \"[Function: \" + getFunctionName(value) + \"]\";\n    }\n    return value;\n}\n/**\n * Walks an object to perform a normalization on it\n *\n * @param key of object that's walked in current iteration\n * @param value object to be walked\n * @param depth Optional number indicating how deep should walking be performed\n * @param memo Optional Memo class handling decycling\n */\nexport function walk(key, value, depth, memo) {\n    if (depth === void 0) { depth = +Infinity; }\n    if (memo === void 0) { memo = new Memo(); }\n    // If we reach the maximum depth, serialize whatever has left\n    if (depth === 0) {\n        return serializeValue(value);\n    }\n    // If value implements `toJSON` method, call it and return early\n    // tslint:disable:no-unsafe-any\n    if (value !== null && value !== undefined && typeof value.toJSON === 'function') {\n        return value.toJSON();\n    }\n    // tslint:enable:no-unsafe-any\n    // If normalized value is a primitive, there are no branches left to walk, so we can just bail out, as theres no point in going down that branch any further\n    var normalized = normalizeValue(value, key);\n    if (isPrimitive(normalized)) {\n        return normalized;\n    }\n    // Create source that we will use for next itterations, either objectified error object (Error type with extracted keys:value pairs) or the input itself\n    var source = getWalkSource(value);\n    // Create an accumulator that will act as a parent for all future itterations of that branch\n    var acc = Array.isArray(value) ? [] : {};\n    // If we already walked that branch, bail out, as it's circular reference\n    if (memo.memoize(value)) {\n        return '[Circular ~]';\n    }\n    // Walk all keys of the source\n    for (var innerKey in source) {\n        // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n        if (!Object.prototype.hasOwnProperty.call(source, innerKey)) {\n            continue;\n        }\n        // Recursively walk through all the child nodes\n        acc[innerKey] = walk(innerKey, source[innerKey], depth - 1, memo);\n    }\n    // Once walked through all the branches, remove the parent from memo storage\n    memo.unmemoize(value);\n    // Return accumulated values\n    return acc;\n}\n/**\n * normalize()\n *\n * - Creates a copy to prevent original input mutation\n * - Skip non-enumerablers\n * - Calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializeable values (undefined/NaN/Functions) to serializable format\n * - Translates known global objects/Classes to a string representations\n * - Takes care of Error objects serialization\n * - Optionally limit depth of final output\n */\nexport function normalize(input, depth) {\n    try {\n        // tslint:disable-next-line:no-unsafe-any\n        return JSON.parse(JSON.stringify(input, function (key, value) { return walk(key, value, depth); }));\n    }\n    catch (_oO) {\n        return '**non-serializable**';\n    }\n}\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\nexport function extractExceptionKeysForMessage(exception, maxLength) {\n    if (maxLength === void 0) { maxLength = 40; }\n    // tslint:disable:strict-type-predicates\n    var keys = Object.keys(getWalkSource(exception));\n    keys.sort();\n    if (!keys.length) {\n        return '[object has no keys]';\n    }\n    if (keys[0].length >= maxLength) {\n        return truncate(keys[0], maxLength);\n    }\n    for (var includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n        var serialized = keys.slice(0, includedKeys).join(', ');\n        if (serialized.length > maxLength) {\n            continue;\n        }\n        if (includedKeys === keys.length) {\n            return serialized;\n        }\n        return truncate(serialized, maxLength);\n    }\n    return '';\n}\n/**\n * Given any object, return the new object with removed keys that value was `undefined`.\n * Works recursively on objects and arrays.\n */\nexport function dropUndefinedKeys(val) {\n    var e_1, _a;\n    if (isPlainObject(val)) {\n        var obj = val;\n        var rv = {};\n        try {\n            for (var _b = tslib_1.__values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {\n                var key = _c.value;\n                if (typeof obj[key] !== 'undefined') {\n                    rv[key] = dropUndefinedKeys(obj[key]);\n                }\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        return rv;\n    }\n    if (Array.isArray(val)) {\n        return val.map(dropUndefinedKeys);\n    }\n    return val;\n}\n//# sourceMappingURL=object.js.map","export var setPrototypeOf = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties); // tslint:disable-line:no-unbound-method\n/**\n * setPrototypeOf polyfill using __proto__\n */\nfunction setProtoOf(obj, proto) {\n    // @ts-ignore\n    obj.__proto__ = proto;\n    return obj;\n}\n/**\n * setPrototypeOf polyfill using mixin\n */\nfunction mixinProperties(obj, proto) {\n    for (var prop in proto) {\n        if (!obj.hasOwnProperty(prop)) {\n            // @ts-ignore\n            obj[prop] = proto[prop];\n        }\n    }\n    return obj;\n}\n//# sourceMappingURL=polyfill.js.map","import * as tslib_1 from \"tslib\";\nimport { setPrototypeOf } from './polyfill';\n/** An error emitted by Sentry SDKs and related utilities. */\nvar SentryError = /** @class */ (function (_super) {\n    tslib_1.__extends(SentryError, _super);\n    function SentryError(message) {\n        var _newTarget = this.constructor;\n        var _this = _super.call(this, message) || this;\n        _this.message = message;\n        // tslint:disable:no-unsafe-any\n        _this.name = _newTarget.prototype.constructor.name;\n        setPrototypeOf(_this, _newTarget.prototype);\n        return _this;\n    }\n    return SentryError;\n}(Error));\nexport { SentryError };\n//# sourceMappingURL=error.js.map","import { 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 { 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","import Vue from 'vue';\n\nvar toString = function (x) { return Object.prototype.toString.call(x); };\r\nfunction isNative(Ctor) {\r\n    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());\r\n}\r\nvar hasSymbol = typeof Symbol !== 'undefined' &&\r\n    isNative(Symbol) &&\r\n    typeof Reflect !== 'undefined' &&\r\n    isNative(Reflect.ownKeys);\r\nvar noopFn = function (_) { return _; };\r\nfunction proxy(target, key, _a) {\r\n    var get = _a.get, set = _a.set;\r\n    Object.defineProperty(target, key, {\r\n        enumerable: true,\r\n        configurable: true,\r\n        get: get || noopFn,\r\n        set: set || noopFn,\r\n    });\r\n}\r\nfunction def(obj, key, val, enumerable) {\r\n    Object.defineProperty(obj, key, {\r\n        value: val,\r\n        enumerable: !!enumerable,\r\n        writable: true,\r\n        configurable: true,\r\n    });\r\n}\r\nfunction hasOwn(obj, key) {\r\n    return Object.hasOwnProperty.call(obj, key);\r\n}\r\nfunction assert(condition, msg) {\r\n    if (!condition) {\r\n        throw new Error(\"[vue-composition-api] \" + msg);\r\n    }\r\n}\r\nfunction isPrimitive(value) {\r\n    return (typeof value === 'string' ||\r\n        typeof value === 'number' ||\r\n        // $flow-disable-line\r\n        typeof value === 'symbol' ||\r\n        typeof value === 'boolean');\r\n}\r\nfunction isArray(x) {\r\n    return Array.isArray(x);\r\n}\r\nvar objectToString = Object.prototype.toString;\r\nvar toTypeString = function (value) {\r\n    return objectToString.call(value);\r\n};\r\nvar isMap = function (val) {\r\n    return toTypeString(val) === '[object Map]';\r\n};\r\nvar isSet = function (val) {\r\n    return toTypeString(val) === '[object Set]';\r\n};\r\nfunction isValidArrayIndex(val) {\r\n    var n = parseFloat(String(val));\r\n    return n >= 0 && Math.floor(n) === n && isFinite(val);\r\n}\r\nfunction isObject(val) {\r\n    return val !== null && typeof val === 'object';\r\n}\r\nfunction isPlainObject(x) {\r\n    return toString(x) === '[object Object]';\r\n}\r\nfunction isFunction(x) {\r\n    return typeof x === 'function';\r\n}\r\nfunction isUndef(v) {\r\n    return v === undefined || v === null;\r\n}\r\nfunction warn$1(msg, vm) {\r\n    Vue.util.warn(msg, vm);\r\n}\r\nfunction logError(err, vm, info) {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        warn$1(\"Error in \" + info + \": \\\"\" + err.toString() + \"\\\"\", vm);\r\n    }\r\n    if (typeof window !== 'undefined' && typeof console !== 'undefined') {\r\n        console.error(err);\r\n    }\r\n    else {\r\n        throw err;\r\n    }\r\n}\n\nvar vueDependency = undefined;\r\ntry {\r\n    var requiredVue = require('vue');\r\n    if (requiredVue && isVue(requiredVue)) {\r\n        vueDependency = requiredVue;\r\n    }\r\n    else if (requiredVue &&\r\n        'default' in requiredVue &&\r\n        isVue(requiredVue.default)) {\r\n        vueDependency = requiredVue.default;\r\n    }\r\n}\r\ncatch (_a) {\r\n    // not available\r\n}\r\nvar vueConstructor = null;\r\nvar currentInstance = null;\r\nvar PluginInstalledFlag = '__composition_api_installed__';\r\nfunction isVue(obj) {\r\n    return obj && typeof obj === 'function' && obj.name === 'Vue';\r\n}\r\nfunction isVueRegistered(Vue) {\r\n    return hasOwn(Vue, PluginInstalledFlag);\r\n}\r\nfunction getVueConstructor() {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        assert(vueConstructor, \"must call Vue.use(VueCompositionAPI) before using any function.\");\r\n    }\r\n    return vueConstructor;\r\n}\r\n// returns registered vue or `vue` dependency\r\nfunction getRegisteredVueOrDefault() {\r\n    var constructor = vueConstructor || vueDependency;\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        assert(constructor, \"No vue dependency found.\");\r\n    }\r\n    return constructor;\r\n}\r\nfunction setVueConstructor(Vue) {\r\n    // @ts-ignore\r\n    if ((process.env.NODE_ENV !== 'production') && vueConstructor && Vue.__proto__ !== vueConstructor.__proto__) {\r\n        warn$1('[vue-composition-api] another instance of Vue installed');\r\n    }\r\n    vueConstructor = Vue;\r\n    Object.defineProperty(Vue, PluginInstalledFlag, {\r\n        configurable: true,\r\n        writable: true,\r\n        value: true,\r\n    });\r\n}\r\nfunction setCurrentInstance(vm) {\r\n    // currentInstance?.$scopedSlots\r\n    currentInstance = vm;\r\n}\r\nfunction getCurrentVue2Instance() {\r\n    return currentInstance;\r\n}\r\nfunction getCurrentInstance() {\r\n    if (currentInstance) {\r\n        return toVue3ComponentInstance(currentInstance);\r\n    }\r\n    return null;\r\n}\r\nvar instanceMapCache = new WeakMap();\r\nfunction toVue3ComponentInstance(vue2Instance) {\r\n    if (instanceMapCache.has(vue2Instance)) {\r\n        return instanceMapCache.get(vue2Instance);\r\n    }\r\n    var instance = {\r\n        proxy: vue2Instance,\r\n        update: vue2Instance.$forceUpdate,\r\n        uid: vue2Instance._uid,\r\n        // $emit is defined on prototype and it expected to be bound\r\n        emit: vue2Instance.$emit.bind(vue2Instance),\r\n        parent: null,\r\n        root: null,\r\n    };\r\n    // map vm.$props =\r\n    var instanceProps = [\r\n        'data',\r\n        'props',\r\n        'attrs',\r\n        'refs',\r\n        'vnode',\r\n        'slots',\r\n    ];\r\n    instanceProps.forEach(function (prop) {\r\n        proxy(instance, prop, {\r\n            get: function () {\r\n                return vue2Instance[\"$\" + prop];\r\n            },\r\n        });\r\n    });\r\n    proxy(instance, 'isMounted', {\r\n        get: function () {\r\n            // @ts-expect-error private api\r\n            return vue2Instance._isMounted;\r\n        },\r\n    });\r\n    proxy(instance, 'isUnmounted', {\r\n        get: function () {\r\n            // @ts-expect-error private api\r\n            return vue2Instance._isDestroyed;\r\n        },\r\n    });\r\n    proxy(instance, 'isDeactivated', {\r\n        get: function () {\r\n            // @ts-expect-error private api\r\n            return vue2Instance._inactive;\r\n        },\r\n    });\r\n    proxy(instance, 'emitted', {\r\n        get: function () {\r\n            // @ts-expect-error private api\r\n            return vue2Instance._events;\r\n        },\r\n    });\r\n    instanceMapCache.set(vue2Instance, instance);\r\n    if (vue2Instance.$parent) {\r\n        instance.parent = toVue3ComponentInstance(vue2Instance.$parent);\r\n    }\r\n    if (vue2Instance.$root) {\r\n        instance.root = toVue3ComponentInstance(vue2Instance.$root);\r\n    }\r\n    return instance;\r\n}\n\nfunction currentVMInFn(hook) {\r\n    var vm = getCurrentInstance();\r\n    if ((process.env.NODE_ENV !== 'production') && !vm) {\r\n        warn$1(hook + \" is called when there is no active component instance to be \" +\r\n            \"associated with. \" +\r\n            \"Lifecycle injection APIs can only be used during execution of setup().\");\r\n    }\r\n    return vm === null || vm === void 0 ? void 0 : vm.proxy;\r\n}\r\nfunction defineComponentInstance(Ctor, options) {\r\n    if (options === void 0) { options = {}; }\r\n    var silent = Ctor.config.silent;\r\n    Ctor.config.silent = true;\r\n    var vm = new Ctor(options);\r\n    Ctor.config.silent = silent;\r\n    return vm;\r\n}\r\nfunction isComponentInstance(obj) {\r\n    var Vue = getVueConstructor();\r\n    return Vue && obj instanceof Vue;\r\n}\r\nfunction createSlotProxy(vm, slotName) {\r\n    return function () {\r\n        var args = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            args[_i] = arguments[_i];\r\n        }\r\n        if (!vm.$scopedSlots[slotName]) {\r\n            return warn$1(\"slots.\" + slotName + \"() got called outside of the \\\"render()\\\" scope\", vm);\r\n        }\r\n        return vm.$scopedSlots[slotName].apply(vm, args);\r\n    };\r\n}\r\nfunction resolveSlots(slots, normalSlots) {\r\n    var res;\r\n    if (!slots) {\r\n        res = {};\r\n    }\r\n    else if (slots._normalized) {\r\n        // fast path 1: child component re-render only, parent did not change\r\n        return slots._normalized;\r\n    }\r\n    else {\r\n        res = {};\r\n        for (var key in slots) {\r\n            if (slots[key] && key[0] !== '$') {\r\n                res[key] = true;\r\n            }\r\n        }\r\n    }\r\n    // expose normal slots on scopedSlots\r\n    for (var key in normalSlots) {\r\n        if (!(key in res)) {\r\n            res[key] = true;\r\n        }\r\n    }\r\n    return res;\r\n}\r\nvar vueInternalClasses;\r\nvar getVueInternalClasses = function () {\r\n    if (!vueInternalClasses) {\r\n        var vm = defineComponentInstance(getVueConstructor(), {\r\n            computed: {\r\n                value: function () {\r\n                    return 0;\r\n                },\r\n            },\r\n        });\r\n        // to get Watcher class\r\n        var Watcher = vm._computedWatchers.value.constructor;\r\n        // to get Dep class\r\n        var Dep = vm._data.__ob__.dep.constructor;\r\n        vueInternalClasses = {\r\n            Watcher: Watcher,\r\n            Dep: Dep,\r\n        };\r\n        vm.$destroy();\r\n    }\r\n    return vueInternalClasses;\r\n};\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n\r\nvar __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\r\n\r\nfunction __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nfunction __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nfunction __spreadArray(to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n}\n\nfunction createSymbol(name) {\r\n    return hasSymbol ? Symbol.for(name) : name;\r\n}\r\nvar WatcherPreFlushQueueKey = createSymbol('composition-api.preFlushQueue');\r\nvar WatcherPostFlushQueueKey = createSymbol('composition-api.postFlushQueue');\r\n// must be a string, symbol key is ignored in reactive\r\nvar RefKey = 'composition-api.refKey';\n\nvar accessModifiedSet = new WeakMap();\r\nvar rawSet = new WeakMap();\r\nvar readonlySet = new WeakMap();\n\nvar RefImpl = /** @class */ (function () {\r\n    function RefImpl(_a) {\r\n        var get = _a.get, set = _a.set;\r\n        proxy(this, 'value', {\r\n            get: get,\r\n            set: set,\r\n        });\r\n    }\r\n    return RefImpl;\r\n}());\r\nfunction createRef(options, readonly) {\r\n    var r = new RefImpl(options);\r\n    // seal the ref, this could prevent ref from being observed\r\n    // It's safe to seal the ref, since we really shouldn't extend it.\r\n    // related issues: #79\r\n    var sealed = Object.seal(r);\r\n    readonlySet.set(sealed, true);\r\n    return sealed;\r\n}\r\nfunction ref(raw) {\r\n    var _a;\r\n    if (isRef(raw)) {\r\n        return raw;\r\n    }\r\n    var value = reactive((_a = {}, _a[RefKey] = raw, _a));\r\n    return createRef({\r\n        get: function () { return value[RefKey]; },\r\n        set: function (v) { return (value[RefKey] = v); },\r\n    });\r\n}\r\nfunction isRef(value) {\r\n    return value instanceof RefImpl;\r\n}\r\nfunction unref(ref) {\r\n    return isRef(ref) ? ref.value : ref;\r\n}\r\nfunction toRefs(obj) {\r\n    if ((process.env.NODE_ENV !== 'production') && !isReactive(obj)) {\r\n        warn$1(\"toRefs() expects a reactive object but received a plain one.\");\r\n    }\r\n    if (!isPlainObject(obj))\r\n        return obj;\r\n    var ret = {};\r\n    for (var key in obj) {\r\n        ret[key] = toRef(obj, key);\r\n    }\r\n    return ret;\r\n}\r\nfunction customRef(factory) {\r\n    var version = ref(0);\r\n    return createRef(factory(function () { return void version.value; }, function () {\r\n        ++version.value;\r\n    }));\r\n}\r\nfunction toRef(object, key) {\r\n    var v = object[key];\r\n    if (isRef(v))\r\n        return v;\r\n    return createRef({\r\n        get: function () { return object[key]; },\r\n        set: function (v) { return (object[key] = v); },\r\n    });\r\n}\r\nfunction shallowRef(raw) {\r\n    var _a;\r\n    if (isRef(raw)) {\r\n        return raw;\r\n    }\r\n    var value = shallowReactive((_a = {}, _a[RefKey] = raw, _a));\r\n    return createRef({\r\n        get: function () { return value[RefKey]; },\r\n        set: function (v) { return (value[RefKey] = v); },\r\n    });\r\n}\r\nfunction triggerRef(value) {\r\n    if (!isRef(value))\r\n        return;\r\n    value.value = value.value;\r\n}\r\nfunction proxyRefs(objectWithRefs) {\r\n    var _a, e_1, _b;\r\n    if (isReactive(objectWithRefs)) {\r\n        return objectWithRefs;\r\n    }\r\n    var value = reactive((_a = {}, _a[RefKey] = objectWithRefs, _a));\r\n    var _loop_1 = function (key) {\r\n        proxy(value, key, {\r\n            get: function () {\r\n                if (isRef(value[key])) {\r\n                    return value[key].value;\r\n                }\r\n                return value[key];\r\n            },\r\n            set: function (v) {\r\n                if (isRef(value[key])) {\r\n                    return (value[key].value = unref(v));\r\n                }\r\n                value[key] = unref(v);\r\n            },\r\n        });\r\n    };\r\n    try {\r\n        for (var _c = __values(Object.keys(objectWithRefs)), _d = _c.next(); !_d.done; _d = _c.next()) {\r\n            var key = _d.value;\r\n            _loop_1(key);\r\n        }\r\n    }\r\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\r\n    finally {\r\n        try {\r\n            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);\r\n        }\r\n        finally { if (e_1) throw e_1.error; }\r\n    }\r\n    return value;\r\n}\n\nfunction isRaw(obj) {\r\n    var _a;\r\n    return Boolean((obj === null || obj === void 0 ? void 0 : obj.__ob__) && ((_a = obj.__ob__) === null || _a === void 0 ? void 0 : _a.__raw__));\r\n}\r\nfunction isReactive(obj) {\r\n    var _a;\r\n    return Boolean((obj === null || obj === void 0 ? void 0 : obj.__ob__) && !((_a = obj.__ob__) === null || _a === void 0 ? void 0 : _a.__raw__));\r\n}\r\n/**\r\n * Proxing property access of target.\r\n * We can do unwrapping and other things here.\r\n */\r\nfunction setupAccessControl(target) {\r\n    if (!isPlainObject(target) ||\r\n        isRaw(target) ||\r\n        Array.isArray(target) ||\r\n        isRef(target) ||\r\n        isComponentInstance(target) ||\r\n        accessModifiedSet.has(target))\r\n        return;\r\n    accessModifiedSet.set(target, true);\r\n    var keys = Object.keys(target);\r\n    for (var i = 0; i < keys.length; i++) {\r\n        defineAccessControl(target, keys[i]);\r\n    }\r\n}\r\n/**\r\n * Auto unwrapping when access property\r\n */\r\nfunction defineAccessControl(target, key, val) {\r\n    if (key === '__ob__')\r\n        return;\r\n    if (isRaw(target[key]))\r\n        return;\r\n    var getter;\r\n    var setter;\r\n    var property = Object.getOwnPropertyDescriptor(target, key);\r\n    if (property) {\r\n        if (property.configurable === false) {\r\n            return;\r\n        }\r\n        getter = property.get;\r\n        setter = property.set;\r\n        if ((!getter || setter) /* not only have getter */ &&\r\n            arguments.length === 2) {\r\n            val = target[key];\r\n        }\r\n    }\r\n    setupAccessControl(val);\r\n    Object.defineProperty(target, key, {\r\n        enumerable: true,\r\n        configurable: true,\r\n        get: function getterHandler() {\r\n            var value = getter ? getter.call(target) : val;\r\n            // if the key is equal to RefKey, skip the unwrap logic\r\n            if (key !== RefKey && isRef(value)) {\r\n                return value.value;\r\n            }\r\n            else {\r\n                return value;\r\n            }\r\n        },\r\n        set: function setterHandler(newVal) {\r\n            if (getter && !setter)\r\n                return;\r\n            var value = getter ? getter.call(target) : val;\r\n            // If the key is equal to RefKey, skip the unwrap logic\r\n            // If and only if \"value\" is ref and \"newVal\" is not a ref,\r\n            // the assignment should be proxied to \"value\" ref.\r\n            if (key !== RefKey && isRef(value) && !isRef(newVal)) {\r\n                value.value = newVal;\r\n            }\r\n            else if (setter) {\r\n                setter.call(target, newVal);\r\n            }\r\n            else {\r\n                val = newVal;\r\n            }\r\n            setupAccessControl(newVal);\r\n        },\r\n    });\r\n}\r\nfunction observe(obj) {\r\n    var Vue = getRegisteredVueOrDefault();\r\n    var observed;\r\n    if (Vue.observable) {\r\n        observed = Vue.observable(obj);\r\n    }\r\n    else {\r\n        var vm = defineComponentInstance(Vue, {\r\n            data: {\r\n                $$state: obj,\r\n            },\r\n        });\r\n        observed = vm._data.$$state;\r\n    }\r\n    // in SSR, there is no __ob__. Mock for reactivity check\r\n    if (!hasOwn(observed, '__ob__')) {\r\n        def(observed, '__ob__', mockObserver(observed));\r\n    }\r\n    return observed;\r\n}\r\nfunction createObserver() {\r\n    return observe({}).__ob__;\r\n}\r\nfunction mockObserver(value) {\r\n    if (value === void 0) { value = {}; }\r\n    return {\r\n        value: value,\r\n        dep: {\r\n            notify: noopFn,\r\n            depend: noopFn,\r\n            addSub: noopFn,\r\n            removeSub: noopFn,\r\n        },\r\n    };\r\n}\r\nfunction shallowReactive(obj) {\r\n    var e_1, _a;\r\n    if (!isObject(obj)) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            warn$1('\"shallowReactive()\" is called without provide an \"object\".');\r\n        }\r\n        return obj;\r\n    }\r\n    if (!(isPlainObject(obj) || isArray(obj)) ||\r\n        isRaw(obj) ||\r\n        !Object.isExtensible(obj)) {\r\n        return obj;\r\n    }\r\n    var observed = observe({});\r\n    setupAccessControl(observed);\r\n    var ob = observed.__ob__;\r\n    var _loop_1 = function (key) {\r\n        var val = obj[key];\r\n        var getter;\r\n        var setter;\r\n        var property = Object.getOwnPropertyDescriptor(obj, key);\r\n        if (property) {\r\n            if (property.configurable === false) {\r\n                return \"continue\";\r\n            }\r\n            getter = property.get;\r\n            setter = property.set;\r\n        }\r\n        Object.defineProperty(observed, key, {\r\n            enumerable: true,\r\n            configurable: true,\r\n            get: function getterHandler() {\r\n                var _a;\r\n                var value = getter ? getter.call(obj) : val;\r\n                (_a = ob.dep) === null || _a === void 0 ? void 0 : _a.depend();\r\n                return value;\r\n            },\r\n            set: function setterHandler(newVal) {\r\n                var _a;\r\n                if (getter && !setter)\r\n                    return;\r\n                if (setter) {\r\n                    setter.call(obj, newVal);\r\n                }\r\n                else {\r\n                    val = newVal;\r\n                }\r\n                (_a = ob.dep) === null || _a === void 0 ? void 0 : _a.notify();\r\n            },\r\n        });\r\n    };\r\n    try {\r\n        for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {\r\n            var key = _c.value;\r\n            _loop_1(key);\r\n        }\r\n    }\r\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\r\n    finally {\r\n        try {\r\n            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\r\n        }\r\n        finally { if (e_1) throw e_1.error; }\r\n    }\r\n    return observed;\r\n}\r\n/**\r\n * Make obj reactivity\r\n */\r\nfunction reactive(obj) {\r\n    if (!isObject(obj)) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            warn$1('\"reactive()\" is called without provide an \"object\".');\r\n        }\r\n        return obj;\r\n    }\r\n    if (!(isPlainObject(obj) || isArray(obj)) ||\r\n        isRaw(obj) ||\r\n        !Object.isExtensible(obj)) {\r\n        return obj;\r\n    }\r\n    var observed = observe(obj);\r\n    setupAccessControl(observed);\r\n    return observed;\r\n}\r\n/**\r\n * Make sure obj can't be a reactive\r\n */\r\nfunction markRaw(obj) {\r\n    if (!(isPlainObject(obj) || isArray(obj)) || !Object.isExtensible(obj)) {\r\n        return obj;\r\n    }\r\n    // set the vue observable flag at obj\r\n    var ob = createObserver();\r\n    ob.__raw__ = true;\r\n    def(obj, '__ob__', ob);\r\n    // mark as Raw\r\n    rawSet.set(obj, true);\r\n    return obj;\r\n}\r\nfunction toRaw(observed) {\r\n    var _a, _b;\r\n    if (isRaw(observed) || !Object.isExtensible(observed)) {\r\n        return observed;\r\n    }\r\n    return ((_b = (_a = observed) === null || _a === void 0 ? void 0 : _a.__ob__) === null || _b === void 0 ? void 0 : _b.value) || observed;\r\n}\n\nfunction isReadonly(obj) {\r\n    return readonlySet.has(obj);\r\n}\r\n/**\r\n * **In @vue/composition-api, `reactive` only provides type-level readonly check**\r\n *\r\n * Creates a readonly copy of the original object. Note the returned copy is not\r\n * made reactive, but `readonly` can be called on an already reactive object.\r\n */\r\nfunction readonly(target) {\r\n    return target;\r\n}\r\nfunction shallowReadonly(obj) {\r\n    var e_1, _a;\r\n    if (!(isPlainObject(obj) || isArray(obj)) ||\r\n        (!Object.isExtensible(obj) && !isRef(obj))) {\r\n        return obj;\r\n    }\r\n    var readonlyObj = {};\r\n    var source = reactive({});\r\n    var ob = source.__ob__;\r\n    var _loop_1 = function (key) {\r\n        var val = obj[key];\r\n        var getter;\r\n        var property = Object.getOwnPropertyDescriptor(obj, key);\r\n        if (property && !isRef(obj)) {\r\n            if (property.configurable === false) {\r\n                return \"continue\";\r\n            }\r\n            getter = property.get;\r\n        }\r\n        Object.defineProperty(readonlyObj, key, {\r\n            enumerable: true,\r\n            configurable: true,\r\n            get: function getterHandler() {\r\n                var value = getter ? getter.call(obj) : val;\r\n                ob.dep.depend();\r\n                return value;\r\n            },\r\n            set: function (v) {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn$1(\"Set operation on key \\\"\" + key + \"\\\" failed: target is readonly.\");\r\n                }\r\n            },\r\n        });\r\n    };\r\n    try {\r\n        for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {\r\n            var key = _c.value;\r\n            _loop_1(key);\r\n        }\r\n    }\r\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\r\n    finally {\r\n        try {\r\n            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\r\n        }\r\n        finally { if (e_1) throw e_1.error; }\r\n    }\r\n    readonlySet.set(readonlyObj, true);\r\n    return readonlyObj;\r\n}\n\n/**\r\n * Set a property on an object. Adds the new property, triggers change\r\n * notification and intercept it's subsequent access if the property doesn't\r\n * already exist.\r\n */\r\nfunction set$1(target, key, val) {\r\n    var Vue = getVueConstructor();\r\n    var _a = Vue.util, warn = _a.warn, defineReactive = _a.defineReactive;\r\n    if ((process.env.NODE_ENV !== 'production') && (isUndef(target) || isPrimitive(target))) {\r\n        warn(\"Cannot set reactive property on undefined, null, or primitive value: \" + target);\r\n    }\r\n    if (isArray(target) && isValidArrayIndex(key)) {\r\n        target.length = Math.max(target.length, key);\r\n        target.splice(key, 1, val);\r\n        return val;\r\n    }\r\n    if (key in target && !(key in Object.prototype)) {\r\n        target[key] = val;\r\n        return val;\r\n    }\r\n    var ob = target.__ob__;\r\n    if (target._isVue || (ob && ob.vmCount)) {\r\n        (process.env.NODE_ENV !== 'production') &&\r\n            warn('Avoid adding reactive properties to a Vue instance or its root $data ' +\r\n                'at runtime - declare it upfront in the data option.');\r\n        return val;\r\n    }\r\n    if (!ob) {\r\n        target[key] = val;\r\n        return val;\r\n    }\r\n    defineReactive(ob.value, key, val);\r\n    // IMPORTANT: define access control before trigger watcher\r\n    defineAccessControl(target, key, val);\r\n    ob.dep.notify();\r\n    return val;\r\n}\n\n/**\r\n * Delete a property and trigger change if necessary.\r\n */\r\nfunction del(target, key) {\r\n    var Vue = getVueConstructor();\r\n    var warn = Vue.util.warn;\r\n    if ((process.env.NODE_ENV !== 'production') && (isUndef(target) || isPrimitive(target))) {\r\n        warn(\"Cannot delete reactive property on undefined, null, or primitive value: \" + target);\r\n    }\r\n    if (Array.isArray(target) && isValidArrayIndex(key)) {\r\n        target.splice(key, 1);\r\n        return;\r\n    }\r\n    var ob = target.__ob__;\r\n    if (target._isVue || (ob && ob.vmCount)) {\r\n        (process.env.NODE_ENV !== 'production') &&\r\n            warn('Avoid deleting properties on a Vue instance or its root $data ' +\r\n                '- just set it to null.');\r\n        return;\r\n    }\r\n    if (!hasOwn(target, key)) {\r\n        return;\r\n    }\r\n    delete target[key];\r\n    if (!ob) {\r\n        return;\r\n    }\r\n    ob.dep.notify();\r\n}\n\nvar genName = function (name) { return \"on\" + (name[0].toUpperCase() + name.slice(1)); };\r\nfunction createLifeCycle(lifeCyclehook) {\r\n    return function (callback) {\r\n        var vm = currentVMInFn(genName(lifeCyclehook));\r\n        if (vm) {\r\n            injectHookOption(getVueConstructor(), vm, lifeCyclehook, callback);\r\n        }\r\n    };\r\n}\r\nfunction injectHookOption(Vue, vm, hook, val) {\r\n    var options = vm.$options;\r\n    var mergeFn = Vue.config.optionMergeStrategies[hook];\r\n    options[hook] = mergeFn(options[hook], wrapHookCall(vm, val));\r\n}\r\nfunction wrapHookCall(vm, fn) {\r\n    return function () {\r\n        var _a;\r\n        var args = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            args[_i] = arguments[_i];\r\n        }\r\n        var preVm = (_a = getCurrentInstance()) === null || _a === void 0 ? void 0 : _a.proxy;\r\n        setCurrentInstance(vm);\r\n        try {\r\n            return fn.apply(void 0, __spreadArray([], __read(args)));\r\n        }\r\n        finally {\r\n            setCurrentInstance(preVm);\r\n        }\r\n    };\r\n}\r\n// export const onCreated = createLifeCycle('created');\r\nvar onBeforeMount = createLifeCycle('beforeMount');\r\nvar onMounted = createLifeCycle('mounted');\r\nvar onBeforeUpdate = createLifeCycle('beforeUpdate');\r\nvar onUpdated = createLifeCycle('updated');\r\nvar onBeforeUnmount = createLifeCycle('beforeDestroy');\r\nvar onUnmounted = createLifeCycle('destroyed');\r\nvar onErrorCaptured = createLifeCycle('errorCaptured');\r\nvar onActivated = createLifeCycle('activated');\r\nvar onDeactivated = createLifeCycle('deactivated');\r\nvar onServerPrefetch = createLifeCycle('serverPrefetch');\n\nvar fallbackVM;\r\nfunction flushPreQueue() {\r\n    flushQueue(this, WatcherPreFlushQueueKey);\r\n}\r\nfunction flushPostQueue() {\r\n    flushQueue(this, WatcherPostFlushQueueKey);\r\n}\r\nfunction hasWatchEnv(vm) {\r\n    return vm[WatcherPreFlushQueueKey] !== undefined;\r\n}\r\nfunction installWatchEnv(vm) {\r\n    vm[WatcherPreFlushQueueKey] = [];\r\n    vm[WatcherPostFlushQueueKey] = [];\r\n    vm.$on('hook:beforeUpdate', flushPreQueue);\r\n    vm.$on('hook:updated', flushPostQueue);\r\n}\r\nfunction getWatcherOption(options) {\r\n    return __assign({\r\n        immediate: false,\r\n        deep: false,\r\n        flush: 'pre',\r\n    }, options);\r\n}\r\nfunction getWatchEffectOption(options) {\r\n    return __assign({\r\n        immediate: true,\r\n        deep: false,\r\n        flush: 'pre',\r\n    }, options);\r\n}\r\nfunction getWatcherVM() {\r\n    var _a;\r\n    var vm = (_a = getCurrentInstance()) === null || _a === void 0 ? void 0 : _a.proxy;\r\n    if (!vm) {\r\n        if (!fallbackVM) {\r\n            fallbackVM = defineComponentInstance(getVueConstructor());\r\n        }\r\n        vm = fallbackVM;\r\n    }\r\n    else if (!hasWatchEnv(vm)) {\r\n        installWatchEnv(vm);\r\n    }\r\n    return vm;\r\n}\r\nfunction flushQueue(vm, key) {\r\n    var queue = vm[key];\r\n    for (var index = 0; index < queue.length; index++) {\r\n        queue[index]();\r\n    }\r\n    queue.length = 0;\r\n}\r\nfunction queueFlushJob(vm, fn, mode) {\r\n    // flush all when beforeUpdate and updated are not fired\r\n    var fallbackFlush = function () {\r\n        vm.$nextTick(function () {\r\n            if (vm[WatcherPreFlushQueueKey].length) {\r\n                flushQueue(vm, WatcherPreFlushQueueKey);\r\n            }\r\n            if (vm[WatcherPostFlushQueueKey].length) {\r\n                flushQueue(vm, WatcherPostFlushQueueKey);\r\n            }\r\n        });\r\n    };\r\n    switch (mode) {\r\n        case 'pre':\r\n            fallbackFlush();\r\n            vm[WatcherPreFlushQueueKey].push(fn);\r\n            break;\r\n        case 'post':\r\n            fallbackFlush();\r\n            vm[WatcherPostFlushQueueKey].push(fn);\r\n            break;\r\n        default:\r\n            assert(false, \"flush must be one of [\\\"post\\\", \\\"pre\\\", \\\"sync\\\"], but got \" + mode);\r\n            break;\r\n    }\r\n}\r\nfunction createVueWatcher(vm, getter, callback, options) {\r\n    var index = vm._watchers.length;\r\n    // @ts-ignore: use undocumented options\r\n    vm.$watch(getter, callback, {\r\n        immediate: options.immediateInvokeCallback,\r\n        deep: options.deep,\r\n        lazy: options.noRun,\r\n        sync: options.sync,\r\n        before: options.before,\r\n    });\r\n    return vm._watchers[index];\r\n}\r\n// We have to monkeypatch the teardown function so Vue will run\r\n// runCleanup() when it tears down the watcher on unmounted.\r\nfunction patchWatcherTeardown(watcher, runCleanup) {\r\n    var _teardown = watcher.teardown;\r\n    watcher.teardown = function () {\r\n        var args = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            args[_i] = arguments[_i];\r\n        }\r\n        _teardown.apply(watcher, args);\r\n        runCleanup();\r\n    };\r\n}\r\nfunction createWatcher(vm, source, cb, options) {\r\n    var _a;\r\n    var flushMode = options.flush;\r\n    var isSync = flushMode === 'sync';\r\n    var cleanup;\r\n    var registerCleanup = function (fn) {\r\n        cleanup = function () {\r\n            try {\r\n                fn();\r\n            }\r\n            catch (error) {\r\n                logError(error, vm, 'onCleanup()');\r\n            }\r\n        };\r\n    };\r\n    // cleanup before running getter again\r\n    var runCleanup = function () {\r\n        if (cleanup) {\r\n            cleanup();\r\n            cleanup = null;\r\n        }\r\n    };\r\n    var createScheduler = function (fn) {\r\n        if (isSync ||\r\n            /* without a current active instance, ignore pre|post mode */ vm ===\r\n                fallbackVM) {\r\n            return fn;\r\n        }\r\n        return (function () {\r\n            var args = [];\r\n            for (var _i = 0; _i < arguments.length; _i++) {\r\n                args[_i] = arguments[_i];\r\n            }\r\n            return queueFlushJob(vm, function () {\r\n                fn.apply(void 0, __spreadArray([], __read(args)));\r\n            }, flushMode);\r\n        });\r\n    };\r\n    // effect watch\r\n    if (cb === null) {\r\n        var running_1 = false;\r\n        var getter_1 = function () {\r\n            // preventing the watch callback being call in the same execution\r\n            if (running_1) {\r\n                return;\r\n            }\r\n            try {\r\n                running_1 = true;\r\n                source(registerCleanup);\r\n            }\r\n            finally {\r\n                running_1 = false;\r\n            }\r\n        };\r\n        var watcher_1 = createVueWatcher(vm, getter_1, noopFn, {\r\n            deep: options.deep || false,\r\n            sync: isSync,\r\n            before: runCleanup,\r\n        });\r\n        patchWatcherTeardown(watcher_1, runCleanup);\r\n        // enable the watcher update\r\n        watcher_1.lazy = false;\r\n        var originGet = watcher_1.get.bind(watcher_1);\r\n        // always run watchEffect\r\n        watcher_1.get = createScheduler(originGet);\r\n        return function () {\r\n            watcher_1.teardown();\r\n        };\r\n    }\r\n    var deep = options.deep;\r\n    var getter;\r\n    if (isRef(source)) {\r\n        getter = function () { return source.value; };\r\n    }\r\n    else if (isReactive(source)) {\r\n        getter = function () { return source; };\r\n        deep = true;\r\n    }\r\n    else if (isArray(source)) {\r\n        getter = function () {\r\n            return source.map(function (s) {\r\n                if (isRef(s)) {\r\n                    return s.value;\r\n                }\r\n                else if (isReactive(s)) {\r\n                    return traverse(s);\r\n                }\r\n                else if (isFunction(s)) {\r\n                    return s();\r\n                }\r\n                else {\r\n                    warn$1(\"Invalid watch source: \" + JSON.stringify(s) + \".\\n          A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.\", vm);\r\n                    return noopFn;\r\n                }\r\n            });\r\n        };\r\n    }\r\n    else if (isFunction(source)) {\r\n        getter = source;\r\n    }\r\n    else {\r\n        getter = noopFn;\r\n        warn$1(\"Invalid watch source: \" + JSON.stringify(source) + \".\\n      A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.\", vm);\r\n    }\r\n    var applyCb = function (n, o) {\r\n        // cleanup before running cb again\r\n        runCleanup();\r\n        cb(n, o, registerCleanup);\r\n    };\r\n    var callback = createScheduler(applyCb);\r\n    if (options.immediate) {\r\n        var originalCallback_1 = callback;\r\n        // `shiftCallback` is used to handle the first sync effect run.\r\n        // The subsequent callbacks will redirect to `callback`.\r\n        var shiftCallback_1 = function (n, o) {\r\n            shiftCallback_1 = originalCallback_1;\r\n            applyCb(n, o);\r\n        };\r\n        callback = function (n, o) {\r\n            shiftCallback_1(n, o);\r\n        };\r\n    }\r\n    // @ts-ignore: use undocumented option \"sync\"\r\n    var stop = vm.$watch(getter, callback, {\r\n        immediate: options.immediate,\r\n        deep: deep,\r\n        sync: isSync,\r\n    });\r\n    // Once again, we have to hack the watcher for proper teardown\r\n    var watcher = vm._watchers[vm._watchers.length - 1];\r\n    // if the return value is reactive and deep:true\r\n    // watch for changes, this might happen when new key is added\r\n    if (isReactive(watcher.value) && ((_a = watcher.value.__ob__) === null || _a === void 0 ? void 0 : _a.dep) && deep) {\r\n        watcher.value.__ob__.dep.addSub({\r\n            update: function () {\r\n                // this will force the source to be revaluated and the callback\r\n                // executed if needed\r\n                watcher.run();\r\n            },\r\n        });\r\n    }\r\n    patchWatcherTeardown(watcher, runCleanup);\r\n    return function () {\r\n        stop();\r\n    };\r\n}\r\nfunction watchEffect(effect, options) {\r\n    var opts = getWatchEffectOption(options);\r\n    var vm = getWatcherVM();\r\n    return createWatcher(vm, effect, null, opts);\r\n}\r\n// implementation\r\nfunction watch(source, cb, options) {\r\n    var callback = null;\r\n    if (typeof cb === 'function') {\r\n        // source watch\r\n        callback = cb;\r\n    }\r\n    else {\r\n        // effect watch\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            warn$1(\"`watch(fn, options?)` signature has been moved to a separate API. \" +\r\n                \"Use `watchEffect(fn, options?)` instead. `watch` now only \" +\r\n                \"supports `watch(source, cb, options?) signature.\");\r\n        }\r\n        options = cb;\r\n        callback = null;\r\n    }\r\n    var opts = getWatcherOption(options);\r\n    var vm = getWatcherVM();\r\n    return createWatcher(vm, source, callback, opts);\r\n}\r\nfunction traverse(value, seen) {\r\n    if (seen === void 0) { seen = new Set(); }\r\n    if (!isObject(value) || seen.has(value)) {\r\n        return value;\r\n    }\r\n    seen.add(value);\r\n    if (isRef(value)) {\r\n        traverse(value.value, seen);\r\n    }\r\n    else if (isArray(value)) {\r\n        for (var i = 0; i < value.length; i++) {\r\n            traverse(value[i], seen);\r\n        }\r\n    }\r\n    else if (isSet(value) || isMap(value)) {\r\n        value.forEach(function (v) {\r\n            traverse(v, seen);\r\n        });\r\n    }\r\n    else if (isPlainObject(value)) {\r\n        for (var key in value) {\r\n            traverse(value[key], seen);\r\n        }\r\n    }\r\n    return value;\r\n}\n\n// implement\r\nfunction computed(getterOrOptions) {\r\n    var _a;\r\n    var vm = (_a = getCurrentInstance()) === null || _a === void 0 ? void 0 : _a.proxy;\r\n    var getter;\r\n    var setter;\r\n    if (typeof getterOrOptions === 'function') {\r\n        getter = getterOrOptions;\r\n    }\r\n    else {\r\n        getter = getterOrOptions.get;\r\n        setter = getterOrOptions.set;\r\n    }\r\n    var computedSetter;\r\n    var computedGetter;\r\n    if (vm && !vm.$isServer) {\r\n        var _b = getVueInternalClasses(), Watcher_1 = _b.Watcher, Dep_1 = _b.Dep;\r\n        var watcher_1;\r\n        computedGetter = function () {\r\n            if (!watcher_1) {\r\n                watcher_1 = new Watcher_1(vm, getter, noopFn, { lazy: true });\r\n            }\r\n            if (watcher_1.dirty) {\r\n                watcher_1.evaluate();\r\n            }\r\n            if (Dep_1.target) {\r\n                watcher_1.depend();\r\n            }\r\n            return watcher_1.value;\r\n        };\r\n        computedSetter = function (v) {\r\n            if ((process.env.NODE_ENV !== 'production') && !setter) {\r\n                warn$1('Write operation failed: computed value is readonly.', vm);\r\n                return;\r\n            }\r\n            if (setter) {\r\n                setter(v);\r\n            }\r\n        };\r\n    }\r\n    else {\r\n        // fallback\r\n        var computedHost_1 = defineComponentInstance(getVueConstructor(), {\r\n            computed: {\r\n                $$state: {\r\n                    get: getter,\r\n                    set: setter,\r\n                },\r\n            },\r\n        });\r\n        vm && vm.$on('hook:destroyed', function () { return computedHost_1.$destroy(); });\r\n        computedGetter = function () { return computedHost_1.$$state; };\r\n        computedSetter = function (v) {\r\n            if ((process.env.NODE_ENV !== 'production') && !setter) {\r\n                warn$1('Write operation failed: computed value is readonly.', vm);\r\n                return;\r\n            }\r\n            computedHost_1.$$state = v;\r\n        };\r\n    }\r\n    return createRef({\r\n        get: computedGetter,\r\n        set: computedSetter,\r\n    });\r\n}\n\nvar NOT_FOUND = {};\r\nfunction resolveInject(provideKey, vm) {\r\n    var source = vm;\r\n    while (source) {\r\n        // @ts-ignore\r\n        if (source._provided && hasOwn(source._provided, provideKey)) {\r\n            //@ts-ignore\r\n            return source._provided[provideKey];\r\n        }\r\n        source = source.$parent;\r\n    }\r\n    return NOT_FOUND;\r\n}\r\nfunction provide(key, value) {\r\n    var vm = currentVMInFn('provide');\r\n    if (!vm)\r\n        return;\r\n    if (!vm._provided) {\r\n        var provideCache_1 = {};\r\n        Object.defineProperty(vm, '_provided', {\r\n            get: function () { return provideCache_1; },\r\n            set: function (v) { return Object.assign(provideCache_1, v); },\r\n        });\r\n    }\r\n    vm._provided[key] = value;\r\n}\r\nfunction inject(key, defaultValue, treatDefaultAsFactory) {\r\n    var _a;\r\n    if (treatDefaultAsFactory === void 0) { treatDefaultAsFactory = false; }\r\n    if (!key) {\r\n        return defaultValue;\r\n    }\r\n    var vm = (_a = getCurrentInstance()) === null || _a === void 0 ? void 0 : _a.proxy;\r\n    if (!vm) {\r\n        warn$1(\"inject() can only be used inside setup() or functional components.\");\r\n        return;\r\n    }\r\n    var val = resolveInject(key, vm);\r\n    if (val !== NOT_FOUND) {\r\n        return val;\r\n    }\r\n    if (defaultValue === undefined && (process.env.NODE_ENV !== 'production')) {\r\n        warn$1(\"Injection \\\"\" + String(key) + \"\\\" not found\", vm);\r\n    }\r\n    return treatDefaultAsFactory && isFunction(defaultValue)\r\n        ? defaultValue()\r\n        : defaultValue;\r\n}\n\nvar EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n    ? Object.freeze({})\r\n    : {};\r\nvar useCssModule = function (name) {\r\n    var _a;\r\n    if (name === void 0) { name = '$style'; }\r\n    var instance = getCurrentInstance();\r\n    if (!instance) {\r\n        (process.env.NODE_ENV !== 'production') && warn$1(\"useCssModule must be called inside setup()\");\r\n        return EMPTY_OBJ;\r\n    }\r\n    var mod = (_a = instance.proxy) === null || _a === void 0 ? void 0 : _a[name];\r\n    if (!mod) {\r\n        (process.env.NODE_ENV !== 'production') &&\r\n            warn$1(\"Current instance does not have CSS module named \\\"\" + name + \"\\\".\");\r\n        return EMPTY_OBJ;\r\n    }\r\n    return mod;\r\n};\r\n/**\r\n * @deprecated use `useCssModule` instead.\r\n */\r\nvar useCSSModule = useCssModule;\n\nfunction createApp(rootComponent, rootProps) {\r\n    if (rootProps === void 0) { rootProps = undefined; }\r\n    var V = getVueConstructor();\r\n    var mountedVM = undefined;\r\n    return {\r\n        config: V.config,\r\n        use: V.use.bind(V),\r\n        mixin: V.mixin.bind(V),\r\n        component: V.component.bind(V),\r\n        directive: V.directive.bind(V),\r\n        mount: function (el, hydrating) {\r\n            if (!mountedVM) {\r\n                mountedVM = new V(__assign({ propsData: rootProps }, rootComponent));\r\n                mountedVM.$mount(el, hydrating);\r\n                return mountedVM;\r\n            }\r\n            else {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn$1(\"App has already been mounted.\\n\" +\r\n                        \"If you want to remount the same app, move your app creation logic \" +\r\n                        \"into a factory function and create fresh app instances for each \" +\r\n                        \"mount - e.g. `const createMyApp = () => createApp(App)`\");\r\n                }\r\n                return mountedVM;\r\n            }\r\n        },\r\n        unmount: function () {\r\n            if (mountedVM) {\r\n                mountedVM.$destroy();\r\n                mountedVM = undefined;\r\n            }\r\n            else if ((process.env.NODE_ENV !== 'production')) {\r\n                warn$1(\"Cannot unmount an app that is not mounted.\");\r\n            }\r\n        },\r\n    };\r\n}\n\nvar nextTick = function nextTick() {\r\n    var _a;\r\n    var args = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        args[_i] = arguments[_i];\r\n    }\r\n    return (_a = getVueConstructor()) === null || _a === void 0 ? void 0 : _a.nextTick.apply(this, args);\r\n};\n\nvar fallbackCreateElement;\r\nvar createElement = function createElement() {\r\n    var _a;\r\n    var args = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        args[_i] = arguments[_i];\r\n    }\r\n    var instance = (_a = getCurrentInstance()) === null || _a === void 0 ? void 0 : _a.proxy;\r\n    if (!instance) {\r\n        warn$1('`createElement()` has been called outside of render function.');\r\n        if (!fallbackCreateElement) {\r\n            fallbackCreateElement = defineComponentInstance(getVueConstructor())\r\n                .$createElement;\r\n        }\r\n        return fallbackCreateElement.apply(fallbackCreateElement, args);\r\n    }\r\n    return instance.$createElement.apply(instance, args);\r\n};\n\n/**\r\n * Displays a warning message (using console.error) with a stack trace if the\r\n * function is called inside of active component.\r\n *\r\n * @param message warning message to be displayed\r\n */\r\nfunction warn(message) {\r\n    var _a;\r\n    warn$1(message, (_a = getCurrentInstance()) === null || _a === void 0 ? void 0 : _a.proxy);\r\n}\n\nfunction set(vm, key, value) {\r\n    var state = (vm.__composition_api_state__ =\r\n        vm.__composition_api_state__ || {});\r\n    state[key] = value;\r\n}\r\nfunction get(vm, key) {\r\n    return (vm.__composition_api_state__ || {})[key];\r\n}\r\nvar vmStateManager = {\r\n    set: set,\r\n    get: get,\r\n};\n\nfunction asVmProperty(vm, propName, propValue) {\r\n    var props = vm.$options.props;\r\n    if (!(propName in vm) && !(props && hasOwn(props, propName))) {\r\n        if (isRef(propValue)) {\r\n            proxy(vm, propName, {\r\n                get: function () { return propValue.value; },\r\n                set: function (val) {\r\n                    propValue.value = val;\r\n                },\r\n            });\r\n        }\r\n        else {\r\n            Object.defineProperty(vm, propName, {\r\n                enumerable: true,\r\n                configurable: true,\r\n                get: function () {\r\n                    if (isReactive(propValue)) {\r\n                        propValue.__ob__.dep.depend();\r\n                    }\r\n                    return propValue;\r\n                },\r\n                set: function (val) {\r\n                    propValue = val;\r\n                },\r\n            });\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            // expose binding to Vue Devtool as a data property\r\n            // delay this until state has been resolved to prevent repeated works\r\n            vm.$nextTick(function () {\r\n                if (Object.keys(vm._data).indexOf(propName) !== -1) {\r\n                    return;\r\n                }\r\n                if (isRef(propValue)) {\r\n                    proxy(vm._data, propName, {\r\n                        get: function () { return propValue.value; },\r\n                        set: function (val) {\r\n                            propValue.value = val;\r\n                        },\r\n                    });\r\n                }\r\n                else {\r\n                    proxy(vm._data, propName, {\r\n                        get: function () { return propValue; },\r\n                        set: function (val) {\r\n                            propValue = val;\r\n                        },\r\n                    });\r\n                }\r\n            });\r\n        }\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        if (props && hasOwn(props, propName)) {\r\n            warn$1(\"The setup binding property \\\"\" + propName + \"\\\" is already declared as a prop.\", vm);\r\n        }\r\n        else {\r\n            warn$1(\"The setup binding property \\\"\" + propName + \"\\\" is already declared.\", vm);\r\n        }\r\n    }\r\n}\r\nfunction updateTemplateRef(vm) {\r\n    var rawBindings = vmStateManager.get(vm, 'rawBindings') || {};\r\n    if (!rawBindings || !Object.keys(rawBindings).length)\r\n        return;\r\n    var refs = vm.$refs;\r\n    var oldRefKeys = vmStateManager.get(vm, 'refs') || [];\r\n    for (var index = 0; index < oldRefKeys.length; index++) {\r\n        var key = oldRefKeys[index];\r\n        var setupValue = rawBindings[key];\r\n        if (!refs[key] && setupValue && isRef(setupValue)) {\r\n            setupValue.value = null;\r\n        }\r\n    }\r\n    var newKeys = Object.keys(refs);\r\n    var validNewKeys = [];\r\n    for (var index = 0; index < newKeys.length; index++) {\r\n        var key = newKeys[index];\r\n        var setupValue = rawBindings[key];\r\n        if (refs[key] && setupValue && isRef(setupValue)) {\r\n            setupValue.value = refs[key];\r\n            validNewKeys.push(key);\r\n        }\r\n    }\r\n    vmStateManager.set(vm, 'refs', validNewKeys);\r\n}\r\nfunction resolveScopedSlots(vm, slotsProxy) {\r\n    var parentVNode = vm.$options._parentVnode;\r\n    if (!parentVNode)\r\n        return;\r\n    var prevSlots = vmStateManager.get(vm, 'slots') || [];\r\n    var curSlots = resolveSlots(parentVNode.data.scopedSlots, vm.$slots);\r\n    // remove staled slots\r\n    for (var index = 0; index < prevSlots.length; index++) {\r\n        var key = prevSlots[index];\r\n        if (!curSlots[key]) {\r\n            delete slotsProxy[key];\r\n        }\r\n    }\r\n    // proxy fresh slots\r\n    var slotNames = Object.keys(curSlots);\r\n    for (var index = 0; index < slotNames.length; index++) {\r\n        var key = slotNames[index];\r\n        if (!slotsProxy[key]) {\r\n            slotsProxy[key] = createSlotProxy(vm, key);\r\n        }\r\n    }\r\n    vmStateManager.set(vm, 'slots', slotNames);\r\n}\r\nfunction activateCurrentInstance(vm, fn, onError) {\r\n    var preVm = getCurrentVue2Instance();\r\n    setCurrentInstance(vm);\r\n    try {\r\n        return fn(vm);\r\n    }\r\n    catch (err) {\r\n        if (onError) {\r\n            onError(err);\r\n        }\r\n        else {\r\n            throw err;\r\n        }\r\n    }\r\n    finally {\r\n        setCurrentInstance(preVm);\r\n    }\r\n}\n\nfunction mixin(Vue) {\r\n    Vue.mixin({\r\n        beforeCreate: functionApiInit,\r\n        mounted: function () {\r\n            updateTemplateRef(this);\r\n        },\r\n        updated: function () {\r\n            updateTemplateRef(this);\r\n        },\r\n    });\r\n    /**\r\n     * Vuex init hook, injected into each instances init hooks list.\r\n     */\r\n    function functionApiInit() {\r\n        var vm = this;\r\n        var $options = vm.$options;\r\n        var setup = $options.setup, render = $options.render;\r\n        if (render) {\r\n            // keep currentInstance accessible for createElement\r\n            $options.render = function () {\r\n                var _this = this;\r\n                var args = [];\r\n                for (var _i = 0; _i < arguments.length; _i++) {\r\n                    args[_i] = arguments[_i];\r\n                }\r\n                return activateCurrentInstance(vm, function () { return render.apply(_this, args); });\r\n            };\r\n        }\r\n        if (!setup) {\r\n            return;\r\n        }\r\n        if (typeof setup !== 'function') {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                warn$1('The \"setup\" option should be a function that returns a object in component definitions.', vm);\r\n            }\r\n            return;\r\n        }\r\n        var data = $options.data;\r\n        // wrapper the data option, so we can invoke setup before data get resolved\r\n        $options.data = function wrappedData() {\r\n            initSetup(vm, vm.$props);\r\n            return typeof data === 'function'\r\n                ? data.call(vm, vm)\r\n                : data || {};\r\n        };\r\n    }\r\n    function initSetup(vm, props) {\r\n        if (props === void 0) { props = {}; }\r\n        var setup = vm.$options.setup;\r\n        var ctx = createSetupContext(vm);\r\n        // fake reactive for `toRefs(props)`\r\n        def(props, '__ob__', createObserver());\r\n        // resolve scopedSlots and slots to functions\r\n        // @ts-expect-error\r\n        resolveScopedSlots(vm, ctx.slots);\r\n        var binding;\r\n        activateCurrentInstance(vm, function () {\r\n            // make props to be fake reactive, this is for `toRefs(props)`\r\n            binding = setup(props, ctx);\r\n        });\r\n        if (!binding)\r\n            return;\r\n        if (isFunction(binding)) {\r\n            // keep typescript happy with the binding type.\r\n            var bindingFunc_1 = binding;\r\n            // keep currentInstance accessible for createElement\r\n            vm.$options.render = function () {\r\n                // @ts-expect-error\r\n                resolveScopedSlots(vm, ctx.slots);\r\n                return activateCurrentInstance(vm, function () { return bindingFunc_1(); });\r\n            };\r\n            return;\r\n        }\r\n        else if (isPlainObject(binding)) {\r\n            if (isReactive(binding)) {\r\n                binding = toRefs(binding);\r\n            }\r\n            vmStateManager.set(vm, 'rawBindings', binding);\r\n            var bindingObj_1 = binding;\r\n            Object.keys(bindingObj_1).forEach(function (name) {\r\n                var bindingValue = bindingObj_1[name];\r\n                if (!isRef(bindingValue)) {\r\n                    if (!isReactive(bindingValue)) {\r\n                        if (isFunction(bindingValue)) {\r\n                            bindingValue = bindingValue.bind(vm);\r\n                        }\r\n                        else if (!isObject(bindingValue)) {\r\n                            bindingValue = ref(bindingValue);\r\n                        }\r\n                        else if (hasReactiveArrayChild(bindingValue)) {\r\n                            // creates a custom reactive properties without make the object explicitly reactive\r\n                            // NOTE we should try to avoid this, better implementation needed\r\n                            customReactive(bindingValue);\r\n                        }\r\n                    }\r\n                    else if (isArray(bindingValue)) {\r\n                        bindingValue = ref(bindingValue);\r\n                    }\r\n                }\r\n                asVmProperty(vm, name, bindingValue);\r\n            });\r\n            return;\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            assert(false, \"\\\"setup\\\" must return a \\\"Object\\\" or a \\\"Function\\\", got \\\"\" + Object.prototype.toString\r\n                .call(binding)\r\n                .slice(8, -1) + \"\\\"\");\r\n        }\r\n    }\r\n    function customReactive(target) {\r\n        if (!isPlainObject(target) ||\r\n            isRef(target) ||\r\n            isReactive(target) ||\r\n            isRaw(target))\r\n            return;\r\n        var Vue = getVueConstructor();\r\n        var defineReactive = Vue.util.defineReactive;\r\n        Object.keys(target).forEach(function (k) {\r\n            var val = target[k];\r\n            defineReactive(target, k, val);\r\n            if (val) {\r\n                customReactive(val);\r\n            }\r\n            return;\r\n        });\r\n    }\r\n    function hasReactiveArrayChild(target, visited) {\r\n        if (visited === void 0) { visited = new Map(); }\r\n        if (visited.has(target)) {\r\n            return visited.get(target);\r\n        }\r\n        visited.set(target, false);\r\n        if (Array.isArray(target) && isReactive(target)) {\r\n            visited.set(target, true);\r\n            return true;\r\n        }\r\n        if (!isPlainObject(target) || isRaw(target)) {\r\n            return false;\r\n        }\r\n        return Object.keys(target).some(function (x) {\r\n            return hasReactiveArrayChild(target[x], visited);\r\n        });\r\n    }\r\n    function createSetupContext(vm) {\r\n        var ctx = { slots: {} };\r\n        var propsPlain = [\r\n            'root',\r\n            'parent',\r\n            'refs',\r\n            'listeners',\r\n            'isServer',\r\n            'ssrContext',\r\n        ];\r\n        var propsReactiveProxy = ['attrs'];\r\n        var methodReturnVoid = ['emit'];\r\n        propsPlain.forEach(function (key) {\r\n            var srcKey = \"$\" + key;\r\n            proxy(ctx, key, {\r\n                get: function () { return vm[srcKey]; },\r\n                set: function () {\r\n                    warn$1(\"Cannot assign to '\" + key + \"' because it is a read-only property\", vm);\r\n                },\r\n            });\r\n        });\r\n        propsReactiveProxy.forEach(function (key) {\r\n            var srcKey = \"$\" + key;\r\n            proxy(ctx, key, {\r\n                get: function () {\r\n                    var e_1, _a;\r\n                    var data = reactive({});\r\n                    var source = vm[srcKey];\r\n                    var _loop_1 = function (attr) {\r\n                        proxy(data, attr, {\r\n                            get: function () {\r\n                                // to ensure it always return the latest value\r\n                                return vm[srcKey][attr];\r\n                            },\r\n                        });\r\n                    };\r\n                    try {\r\n                        for (var _b = __values(Object.keys(source)), _c = _b.next(); !_c.done; _c = _b.next()) {\r\n                            var attr = _c.value;\r\n                            _loop_1(attr);\r\n                        }\r\n                    }\r\n                    catch (e_1_1) { e_1 = { error: e_1_1 }; }\r\n                    finally {\r\n                        try {\r\n                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\r\n                        }\r\n                        finally { if (e_1) throw e_1.error; }\r\n                    }\r\n                    return data;\r\n                },\r\n                set: function () {\r\n                    warn$1(\"Cannot assign to '\" + key + \"' because it is a read-only property\", vm);\r\n                },\r\n            });\r\n        });\r\n        methodReturnVoid.forEach(function (key) {\r\n            var srcKey = \"$\" + key;\r\n            proxy(ctx, key, {\r\n                get: function () {\r\n                    return function () {\r\n                        var args = [];\r\n                        for (var _i = 0; _i < arguments.length; _i++) {\r\n                            args[_i] = arguments[_i];\r\n                        }\r\n                        var fn = vm[srcKey];\r\n                        fn.apply(vm, args);\r\n                    };\r\n                },\r\n            });\r\n        });\r\n        if (process.env.NODE_ENV === 'test') {\r\n            ctx._vm = vm;\r\n        }\r\n        return ctx;\r\n    }\r\n}\n\n/**\r\n * Helper that recursively merges two data objects together.\r\n */\r\nfunction mergeData(from, to) {\r\n    if (!from)\r\n        return to;\r\n    if (!to)\r\n        return from;\r\n    var key;\r\n    var toVal;\r\n    var fromVal;\r\n    var keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from);\r\n    for (var i = 0; i < keys.length; i++) {\r\n        key = keys[i];\r\n        // in case the object is already observed...\r\n        if (key === '__ob__')\r\n            continue;\r\n        toVal = to[key];\r\n        fromVal = from[key];\r\n        if (!hasOwn(to, key)) {\r\n            to[key] = fromVal;\r\n        }\r\n        else if (toVal !== fromVal &&\r\n            isPlainObject(toVal) &&\r\n            !isRef(toVal) &&\r\n            isPlainObject(fromVal) &&\r\n            !isRef(fromVal)) {\r\n            mergeData(fromVal, toVal);\r\n        }\r\n    }\r\n    return to;\r\n}\r\nfunction install(Vue) {\r\n    if (isVueRegistered(Vue)) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            warn$1('[vue-composition-api] already installed. Vue.use(VueCompositionAPI) should be called only once.');\r\n        }\r\n        return;\r\n    }\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        if (Vue.version) {\r\n            if (Vue.version[0] !== '2' || Vue.version[1] !== '.') {\r\n                warn$1(\"[vue-composition-api] only works with Vue 2, v\" + Vue.version + \" found.\");\r\n            }\r\n        }\r\n        else {\r\n            warn$1('[vue-composition-api] no Vue version found');\r\n        }\r\n    }\r\n    Vue.config.optionMergeStrategies.setup = function (parent, child) {\r\n        return function mergedSetupFn(props, context) {\r\n            return mergeData(typeof parent === 'function' ? parent(props, context) || {} : undefined, typeof child === 'function' ? child(props, context) || {} : undefined);\r\n        };\r\n    };\r\n    setVueConstructor(Vue);\r\n    mixin(Vue);\r\n}\r\nvar Plugin = {\r\n    install: function (Vue) { return install(Vue); },\r\n};\n\n// implementation, close to no-op\r\nfunction defineComponent(options) {\r\n    return options;\r\n}\n\nfunction defineAsyncComponent(source) {\r\n    if (isFunction(source)) {\r\n        source = { loader: source };\r\n    }\r\n    var loader = source.loader, loadingComponent = source.loadingComponent, errorComponent = source.errorComponent, _a = source.delay, delay = _a === void 0 ? 200 : _a, timeout = source.timeout, // undefined = never times out\r\n    _b = source.suspensible, // undefined = never times out\r\n    suspensible = _b === void 0 ? false : _b, // in Vue 3 default is true\r\n    userOnError = source.onError;\r\n    if ((process.env.NODE_ENV !== 'production') && suspensible) {\r\n        warn$1(\"The suspensiblbe option for async components is not supported in Vue2. It is ignored.\");\r\n    }\r\n    var pendingRequest = null;\r\n    var retries = 0;\r\n    var retry = function () {\r\n        retries++;\r\n        pendingRequest = null;\r\n        return load();\r\n    };\r\n    var load = function () {\r\n        var thisRequest;\r\n        return (pendingRequest ||\r\n            (thisRequest = pendingRequest = loader()\r\n                .catch(function (err) {\r\n                err = err instanceof Error ? err : new Error(String(err));\r\n                if (userOnError) {\r\n                    return new Promise(function (resolve, reject) {\r\n                        var userRetry = function () { return resolve(retry()); };\r\n                        var userFail = function () { return reject(err); };\r\n                        userOnError(err, userRetry, userFail, retries + 1);\r\n                    });\r\n                }\r\n                else {\r\n                    throw err;\r\n                }\r\n            })\r\n                .then(function (comp) {\r\n                if (thisRequest !== pendingRequest && pendingRequest) {\r\n                    return pendingRequest;\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production') && !comp) {\r\n                    warn$1(\"Async component loader resolved to undefined. \" +\r\n                        \"If you are using retry(), make sure to return its return value.\");\r\n                }\r\n                // interop module default\r\n                if (comp &&\r\n                    (comp.__esModule || comp[Symbol.toStringTag] === 'Module')) {\r\n                    comp = comp.default;\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production') && comp && !isObject(comp) && !isFunction(comp)) {\r\n                    throw new Error(\"Invalid async component load result: \" + comp);\r\n                }\r\n                return comp;\r\n            })));\r\n    };\r\n    return function () {\r\n        var component = load();\r\n        return {\r\n            component: component,\r\n            delay: delay,\r\n            timeout: timeout,\r\n            error: errorComponent,\r\n            loading: loadingComponent,\r\n        };\r\n    };\r\n}\n\nvar version = \"1.0.0-rc.10\";\r\n// auto install when using CDN\r\nif (typeof window !== 'undefined' && window.Vue) {\r\n    window.Vue.use(Plugin);\r\n}\n\nexport default Plugin;\nexport { computed, createApp, createRef, customRef, defineAsyncComponent, defineComponent, del, getCurrentInstance, createElement as h, inject, isRaw, isReactive, isReadonly, isRef, markRaw, nextTick, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onServerPrefetch, onUnmounted, onUpdated, provide, proxyRefs, reactive, readonly, ref, set$1 as set, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toRefs, triggerRef, unref, useCSSModule, useCssModule, version, warn, watch, watchEffect };\n","import { isThenable } from './is';\n/** SyncPromise internal states */\nvar States;\n(function (States) {\n    /** Pending */\n    States[\"PENDING\"] = \"PENDING\";\n    /** Resolved / OK */\n    States[\"RESOLVED\"] = \"RESOLVED\";\n    /** Rejected / Error */\n    States[\"REJECTED\"] = \"REJECTED\";\n})(States || (States = {}));\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nvar SyncPromise = /** @class */ (function () {\n    function SyncPromise(executor) {\n        var _this = this;\n        this._state = States.PENDING;\n        this._handlers = [];\n        /** JSDoc */\n        this._resolve = function (value) {\n            _this._setResult(States.RESOLVED, value);\n        };\n        /** JSDoc */\n        this._reject = function (reason) {\n            _this._setResult(States.REJECTED, reason);\n        };\n        /** JSDoc */\n        this._setResult = function (state, value) {\n            if (_this._state !== States.PENDING) {\n                return;\n            }\n            if (isThenable(value)) {\n                value.then(_this._resolve, _this._reject);\n                return;\n            }\n            _this._state = state;\n            _this._value = value;\n            _this._executeHandlers();\n        };\n        // TODO: FIXME\n        /** JSDoc */\n        this._attachHandler = function (handler) {\n            _this._handlers = _this._handlers.concat(handler);\n            _this._executeHandlers();\n        };\n        /** JSDoc */\n        this._executeHandlers = function () {\n            if (_this._state === States.PENDING) {\n                return;\n            }\n            var cachedHandlers = _this._handlers.slice();\n            _this._handlers = [];\n            cachedHandlers.forEach(function (handler) {\n                if (handler.done) {\n                    return;\n                }\n                if (_this._state === States.RESOLVED) {\n                    if (handler.onfulfilled) {\n                        handler.onfulfilled(_this._value);\n                    }\n                }\n                if (_this._state === States.REJECTED) {\n                    if (handler.onrejected) {\n                        handler.onrejected(_this._value);\n                    }\n                }\n                handler.done = true;\n            });\n        };\n        try {\n            executor(this._resolve, this._reject);\n        }\n        catch (e) {\n            this._reject(e);\n        }\n    }\n    /** JSDoc */\n    SyncPromise.prototype.toString = function () {\n        return '[object SyncPromise]';\n    };\n    /** JSDoc */\n    SyncPromise.resolve = function (value) {\n        return new SyncPromise(function (resolve) {\n            resolve(value);\n        });\n    };\n    /** JSDoc */\n    SyncPromise.reject = function (reason) {\n        return new SyncPromise(function (_, reject) {\n            reject(reason);\n        });\n    };\n    /** JSDoc */\n    SyncPromise.all = function (collection) {\n        return new SyncPromise(function (resolve, reject) {\n            if (!Array.isArray(collection)) {\n                reject(new TypeError(\"Promise.all requires an array as input.\"));\n                return;\n            }\n            if (collection.length === 0) {\n                resolve([]);\n                return;\n            }\n            var counter = collection.length;\n            var resolvedCollection = [];\n            collection.forEach(function (item, index) {\n                SyncPromise.resolve(item)\n                    .then(function (value) {\n                    resolvedCollection[index] = value;\n                    counter -= 1;\n                    if (counter !== 0) {\n                        return;\n                    }\n                    resolve(resolvedCollection);\n                })\n                    .then(null, reject);\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.then = function (onfulfilled, onrejected) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            _this._attachHandler({\n                done: false,\n                onfulfilled: function (result) {\n                    if (!onfulfilled) {\n                        // TODO: ¯\\_(ツ)_/¯\n                        // TODO: FIXME\n                        resolve(result);\n                        return;\n                    }\n                    try {\n                        resolve(onfulfilled(result));\n                        return;\n                    }\n                    catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n                onrejected: function (reason) {\n                    if (!onrejected) {\n                        reject(reason);\n                        return;\n                    }\n                    try {\n                        resolve(onrejected(reason));\n                        return;\n                    }\n                    catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.catch = function (onrejected) {\n        return this.then(function (val) { return val; }, onrejected);\n    };\n    /** JSDoc */\n    SyncPromise.prototype.finally = function (onfinally) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            var val;\n            var isRejected;\n            return _this.then(function (value) {\n                isRejected = false;\n                val = value;\n                if (onfinally) {\n                    onfinally();\n                }\n            }, function (reason) {\n                isRejected = true;\n                val = reason;\n                if (onfinally) {\n                    onfinally();\n                }\n            }).then(function () {\n                if (isRejected) {\n                    reject(val);\n                    return;\n                }\n                resolve(val);\n            });\n        });\n    };\n    return SyncPromise;\n}());\nexport { SyncPromise };\n//# sourceMappingURL=syncpromise.js.map","import { logger } from './logger';\nimport { getGlobalObject } from './misc';\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsErrorEvent() {\n    try {\n        // tslint:disable:no-unused-expression\n        new ErrorEvent('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMError() {\n    try {\n        // It really needs 1 argument, not 0.\n        // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n        // 1 argument required, but only 0 present.\n        // @ts-ignore\n        // tslint:disable:no-unused-expression\n        new DOMError('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMException() {\n    try {\n        // tslint:disable:no-unused-expression\n        new DOMException('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsFetch() {\n    if (!('fetch' in getGlobalObject())) {\n        return false;\n    }\n    try {\n        // tslint:disable-next-line:no-unused-expression\n        new Headers();\n        // tslint:disable-next-line:no-unused-expression\n        new Request('');\n        // tslint:disable-next-line:no-unused-expression\n        new Response();\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\nfunction isNativeFetch(func) {\n    return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nexport function supportsNativeFetch() {\n    if (!supportsFetch()) {\n        return false;\n    }\n    var global = getGlobalObject();\n    // Fast path to avoid DOM I/O\n    // tslint:disable-next-line:no-unbound-method\n    if (isNativeFetch(global.fetch)) {\n        return true;\n    }\n    // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n    // so create a \"pure\" iframe to see if that has native fetch\n    var result = false;\n    var doc = global.document;\n    // tslint:disable-next-line:no-unbound-method deprecation\n    if (doc && typeof doc.createElement === \"function\") {\n        try {\n            var sandbox = doc.createElement('iframe');\n            sandbox.hidden = true;\n            doc.head.appendChild(sandbox);\n            if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n                // tslint:disable-next-line:no-unbound-method\n                result = isNativeFetch(sandbox.contentWindow.fetch);\n            }\n            doc.head.removeChild(sandbox);\n        }\n        catch (err) {\n            logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n        }\n    }\n    return result;\n}\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReportingObserver() {\n    // tslint:disable-next-line: no-unsafe-any\n    return 'ReportingObserver' in getGlobalObject();\n}\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReferrerPolicy() {\n    // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default\n    // https://caniuse.com/#feat=referrer-policy\n    // It doesn't. And it throw exception instead of ignoring this parameter...\n    // REF: https://github.com/getsentry/raven-js/issues/1233\n    if (!supportsFetch()) {\n        return false;\n    }\n    try {\n        // tslint:disable:no-unused-expression\n        new Request('_', {\n            referrerPolicy: 'origin',\n        });\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsHistory() {\n    // NOTE: in Chrome App environment, touching history.pushState, *even inside\n    //       a try/catch block*, will cause Chrome to output an error to console.error\n    // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n    var global = getGlobalObject();\n    var chrome = global.chrome;\n    // tslint:disable-next-line:no-unsafe-any\n    var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n    var hasHistoryApi = 'history' in global && !!global.history.pushState && !!global.history.replaceState;\n    return !isChromePackagedApp && hasHistoryApi;\n}\n//# sourceMappingURL=supports.js.map","// tslint:disable:no-unsafe-any\n/**\n * Memo class used for decycle json objects. Uses WeakSet if available otherwise array.\n */\nvar Memo = /** @class */ (function () {\n    function Memo() {\n        // tslint:disable-next-line\n        this._hasWeakSet = typeof WeakSet === 'function';\n        this._inner = this._hasWeakSet ? new WeakSet() : [];\n    }\n    /**\n     * Sets obj to remember.\n     * @param obj Object to remember\n     */\n    Memo.prototype.memoize = function (obj) {\n        if (this._hasWeakSet) {\n            if (this._inner.has(obj)) {\n                return true;\n            }\n            this._inner.add(obj);\n            return false;\n        }\n        // tslint:disable-next-line:prefer-for-of\n        for (var i = 0; i < this._inner.length; i++) {\n            var value = this._inner[i];\n            if (value === obj) {\n                return true;\n            }\n        }\n        this._inner.push(obj);\n        return false;\n    };\n    /**\n     * Removes object from internal storage.\n     * @param obj Object to forget\n     */\n    Memo.prototype.unmemoize = function (obj) {\n        if (this._hasWeakSet) {\n            this._inner.delete(obj);\n        }\n        else {\n            for (var i = 0; i < this._inner.length; i++) {\n                if (this._inner[i] === obj) {\n                    this._inner.splice(i, 1);\n                    break;\n                }\n            }\n        }\n    };\n    return Memo;\n}());\nexport { Memo };\n//# sourceMappingURL=memo.js.map","import { 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 attrWhitelist = ['type', 'name', 'title', 'alt'];\n    for (i = 0; i < attrWhitelist.length; i++) {\n        key = attrWhitelist[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    if (getGlobalObject().performance) {\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    }\n    return getGlobalObject().performance || performanceFallback;\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","/**\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","(typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}).SENTRY_RELEASE={id:\"f07b17ad090e30e22cea182082bcf1d1d26c9138\"};","/** JSDoc */\nexport var Severity;\n(function (Severity) {\n    /** JSDoc */\n    Severity[\"Fatal\"] = \"fatal\";\n    /** JSDoc */\n    Severity[\"Error\"] = \"error\";\n    /** JSDoc */\n    Severity[\"Warning\"] = \"warning\";\n    /** JSDoc */\n    Severity[\"Log\"] = \"log\";\n    /** JSDoc */\n    Severity[\"Info\"] = \"info\";\n    /** JSDoc */\n    Severity[\"Debug\"] = \"debug\";\n    /** JSDoc */\n    Severity[\"Critical\"] = \"critical\";\n})(Severity || (Severity = {}));\n// tslint:disable:completed-docs\n// tslint:disable:no-unnecessary-qualifier no-namespace\n(function (Severity) {\n    /**\n     * Converts a string-based level into a {@link Severity}.\n     *\n     * @param level string representation of Severity\n     * @returns Severity\n     */\n    function fromString(level) {\n        switch (level) {\n            case 'debug':\n                return Severity.Debug;\n            case 'info':\n                return Severity.Info;\n            case 'warn':\n            case 'warning':\n                return Severity.Warning;\n            case 'error':\n                return Severity.Error;\n            case 'fatal':\n                return Severity.Fatal;\n            case 'critical':\n                return Severity.Critical;\n            case 'log':\n            default:\n                return Severity.Log;\n        }\n    }\n    Severity.fromString = fromString;\n})(Severity || (Severity = {}));\n//# sourceMappingURL=severity.js.map","/* tslint:disable:only-arrow-functions no-unsafe-any */\nimport * as tslib_1 from \"tslib\";\nimport { isInstanceOf, isString } from './is';\nimport { logger } from './logger';\nimport { getFunctionName, getGlobalObject } from './misc';\nimport { fill } from './object';\nimport { supportsHistory, supportsNativeFetch } from './supports';\nvar global = getGlobalObject();\n/**\n * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.\n *  - Console API\n *  - Fetch API\n *  - XHR API\n *  - History API\n *  - DOM API (click/typing)\n *  - Error API\n *  - UnhandledRejection API\n */\nvar handlers = {};\nvar instrumented = {};\n/** Instruments given API */\nfunction instrument(type) {\n    if (instrumented[type]) {\n        return;\n    }\n    instrumented[type] = true;\n    switch (type) {\n        case 'console':\n            instrumentConsole();\n            break;\n        case 'dom':\n            instrumentDOM();\n            break;\n        case 'xhr':\n            instrumentXHR();\n            break;\n        case 'fetch':\n            instrumentFetch();\n            break;\n        case 'history':\n            instrumentHistory();\n            break;\n        case 'error':\n            instrumentError();\n            break;\n        case 'unhandledrejection':\n            instrumentUnhandledRejection();\n            break;\n        default:\n            logger.warn('unknown instrumentation type:', type);\n    }\n}\n/**\n * Add handler that will be called when given type of instrumentation triggers.\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addInstrumentationHandler(handler) {\n    // tslint:disable-next-line:strict-type-predicates\n    if (!handler || typeof handler.type !== 'string' || typeof handler.callback !== 'function') {\n        return;\n    }\n    handlers[handler.type] = handlers[handler.type] || [];\n    handlers[handler.type].push(handler.callback);\n    instrument(handler.type);\n}\n/** JSDoc */\nfunction triggerHandlers(type, data) {\n    var e_1, _a;\n    if (!type || !handlers[type]) {\n        return;\n    }\n    try {\n        for (var _b = tslib_1.__values(handlers[type] || []), _c = _b.next(); !_c.done; _c = _b.next()) {\n            var handler = _c.value;\n            try {\n                handler(data);\n            }\n            catch (e) {\n                logger.error(\"Error while triggering instrumentation handler.\\nType: \" + type + \"\\nName: \" + getFunctionName(handler) + \"\\nError: \" + e);\n            }\n        }\n    }\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n    finally {\n        try {\n            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n        }\n        finally { if (e_1) throw e_1.error; }\n    }\n}\n/** JSDoc */\nfunction instrumentConsole() {\n    if (!('console' in global)) {\n        return;\n    }\n    ['debug', 'info', 'warn', 'error', 'log', 'assert'].forEach(function (level) {\n        if (!(level in global.console)) {\n            return;\n        }\n        fill(global.console, level, function (originalConsoleLevel) {\n            return function () {\n                var args = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    args[_i] = arguments[_i];\n                }\n                triggerHandlers('console', { args: args, level: level });\n                // this fails for some browsers. :(\n                if (originalConsoleLevel) {\n                    Function.prototype.apply.call(originalConsoleLevel, global.console, args);\n                }\n            };\n        });\n    });\n}\n/** JSDoc */\nfunction instrumentFetch() {\n    if (!supportsNativeFetch()) {\n        return;\n    }\n    fill(global, 'fetch', function (originalFetch) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var commonHandlerData = {\n                args: args,\n                fetchData: {\n                    method: getFetchMethod(args),\n                    url: getFetchUrl(args),\n                },\n                startTimestamp: Date.now(),\n            };\n            triggerHandlers('fetch', tslib_1.__assign({}, commonHandlerData));\n            return originalFetch.apply(global, args).then(function (response) {\n                triggerHandlers('fetch', tslib_1.__assign({}, commonHandlerData, { endTimestamp: Date.now(), response: response }));\n                return response;\n            }, function (error) {\n                triggerHandlers('fetch', tslib_1.__assign({}, commonHandlerData, { endTimestamp: Date.now(), error: error }));\n                throw error;\n            });\n        };\n    });\n}\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs) {\n    if (fetchArgs === void 0) { fetchArgs = []; }\n    if ('Request' in global && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {\n        return String(fetchArgs[0].method).toUpperCase();\n    }\n    if (fetchArgs[1] && fetchArgs[1].method) {\n        return String(fetchArgs[1].method).toUpperCase();\n    }\n    return 'GET';\n}\n/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs) {\n    if (fetchArgs === void 0) { fetchArgs = []; }\n    if (typeof fetchArgs[0] === 'string') {\n        return fetchArgs[0];\n    }\n    if ('Request' in global && isInstanceOf(fetchArgs[0], Request)) {\n        return fetchArgs[0].url;\n    }\n    return String(fetchArgs[0]);\n}\n/** JSDoc */\nfunction instrumentXHR() {\n    if (!('XMLHttpRequest' in global)) {\n        return;\n    }\n    var xhrproto = XMLHttpRequest.prototype;\n    fill(xhrproto, 'open', function (originalOpen) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var xhr = this; // tslint:disable-line:no-this-assignment\n            var url = args[1];\n            xhr.__sentry_xhr__ = {\n                method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n                url: args[1],\n            };\n            // if Sentry key appears in URL, don't capture it as a request\n            if (isString(url) && xhr.__sentry_xhr__.method === 'POST' && url.match(/sentry_key/)) {\n                xhr.__sentry_own_request__ = true;\n            }\n            var onreadystatechangeHandler = function () {\n                if (xhr.readyState === 4) {\n                    try {\n                        // touching statusCode in some platforms throws\n                        // an exception\n                        if (xhr.__sentry_xhr__) {\n                            xhr.__sentry_xhr__.status_code = xhr.status;\n                        }\n                    }\n                    catch (e) {\n                        /* do nothing */\n                    }\n                    triggerHandlers('xhr', {\n                        args: args,\n                        endTimestamp: Date.now(),\n                        startTimestamp: Date.now(),\n                        xhr: xhr,\n                    });\n                }\n            };\n            if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n                fill(xhr, 'onreadystatechange', function (original) {\n                    return function () {\n                        var readyStateArgs = [];\n                        for (var _i = 0; _i < arguments.length; _i++) {\n                            readyStateArgs[_i] = arguments[_i];\n                        }\n                        onreadystatechangeHandler();\n                        return original.apply(xhr, readyStateArgs);\n                    };\n                });\n            }\n            else {\n                xhr.addEventListener('readystatechange', onreadystatechangeHandler);\n            }\n            return originalOpen.apply(xhr, args);\n        };\n    });\n    fill(xhrproto, 'send', function (originalSend) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            triggerHandlers('xhr', {\n                args: args,\n                startTimestamp: Date.now(),\n                xhr: this,\n            });\n            return originalSend.apply(this, args);\n        };\n    });\n}\nvar lastHref;\n/** JSDoc */\nfunction instrumentHistory() {\n    if (!supportsHistory()) {\n        return;\n    }\n    var oldOnPopState = global.onpopstate;\n    global.onpopstate = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var to = global.location.href;\n        // keep track of the current URL state, as we always receive only the updated state\n        var from = lastHref;\n        lastHref = to;\n        triggerHandlers('history', {\n            from: from,\n            to: to,\n        });\n        if (oldOnPopState) {\n            return oldOnPopState.apply(this, args);\n        }\n    };\n    /** @hidden */\n    function historyReplacementFunction(originalHistoryFunction) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var url = args.length > 2 ? args[2] : undefined;\n            if (url) {\n                // coerce to string (this is what pushState does)\n                var from = lastHref;\n                var to = String(url);\n                // keep track of the current URL state, as we always receive only the updated state\n                lastHref = to;\n                triggerHandlers('history', {\n                    from: from,\n                    to: to,\n                });\n            }\n            return originalHistoryFunction.apply(this, args);\n        };\n    }\n    fill(global.history, 'pushState', historyReplacementFunction);\n    fill(global.history, 'replaceState', historyReplacementFunction);\n}\n/** JSDoc */\nfunction instrumentDOM() {\n    if (!('document' in global)) {\n        return;\n    }\n    // Capture breadcrumbs from any click that is unhandled / bubbled up all the way\n    // to the document. Do this before we instrument addEventListener.\n    global.document.addEventListener('click', domEventHandler('click', triggerHandlers.bind(null, 'dom')), false);\n    global.document.addEventListener('keypress', keypressEventHandler(triggerHandlers.bind(null, 'dom')), false);\n    // After hooking into document bubbled up click and keypresses events, we also hook into user handled click & keypresses.\n    ['EventTarget', 'Node'].forEach(function (target) {\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                if (fn && fn.handleEvent) {\n                    if (eventName === 'click') {\n                        fill(fn, 'handleEvent', function (innerOriginal) {\n                            return function (event) {\n                                domEventHandler('click', triggerHandlers.bind(null, 'dom'))(event);\n                                return innerOriginal.call(this, event);\n                            };\n                        });\n                    }\n                    if (eventName === 'keypress') {\n                        fill(fn, 'handleEvent', function (innerOriginal) {\n                            return function (event) {\n                                keypressEventHandler(triggerHandlers.bind(null, 'dom'))(event);\n                                return innerOriginal.call(this, event);\n                            };\n                        });\n                    }\n                }\n                else {\n                    if (eventName === 'click') {\n                        domEventHandler('click', triggerHandlers.bind(null, 'dom'), true)(this);\n                    }\n                    if (eventName === 'keypress') {\n                        keypressEventHandler(triggerHandlers.bind(null, 'dom'))(this);\n                    }\n                }\n                return original.call(this, eventName, fn, 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}\nvar debounceDuration = 1000;\nvar debounceTimer = 0;\nvar keypressTimeout;\nvar lastCapturedEvent;\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param name the event name (e.g. \"click\")\n * @param handler function that will be triggered\n * @param debounce decides whether it should wait till another event loop\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\nfunction domEventHandler(name, handler, debounce) {\n    if (debounce === void 0) { debounce = false; }\n    return function (event) {\n        // reset keypress timeout; e.g. triggering a 'click' after\n        // a 'keypress' will reset the keypress debounce so that a new\n        // set of keypresses can be recorded\n        keypressTimeout = undefined;\n        // It's possible this handler might trigger multiple times for the same\n        // event (e.g. event propagation through node ancestors). Ignore if we've\n        // already captured the event.\n        if (!event || lastCapturedEvent === event) {\n            return;\n        }\n        lastCapturedEvent = event;\n        if (debounceTimer) {\n            clearTimeout(debounceTimer);\n        }\n        if (debounce) {\n            debounceTimer = setTimeout(function () {\n                handler({ event: event, name: name });\n            });\n        }\n        else {\n            handler({ event: event, name: name });\n        }\n    };\n}\n/**\n * Wraps addEventListener to capture keypress UI events\n * @param handler function that will be triggered\n * @returns wrapped keypress events handler\n * @hidden\n */\nfunction keypressEventHandler(handler) {\n    // TODO: if somehow user switches keypress target before\n    //       debounce timeout is triggered, we will only capture\n    //       a single breadcrumb from the FIRST target (acceptable?)\n    return function (event) {\n        var target;\n        try {\n            target = event.target;\n        }\n        catch (e) {\n            // just accessing event properties can throw an exception in some rare circumstances\n            // see: https://github.com/getsentry/raven-js/issues/838\n            return;\n        }\n        var tagName = target && target.tagName;\n        // only consider keypress events on actual input elements\n        // this will disregard keypresses targeting body (e.g. tabbing\n        // through elements, hotkeys, etc)\n        if (!tagName || (tagName !== 'INPUT' && tagName !== 'TEXTAREA' && !target.isContentEditable)) {\n            return;\n        }\n        // record first keypress in a series, but ignore subsequent\n        // keypresses until debounce clears\n        if (!keypressTimeout) {\n            domEventHandler('input', handler)(event);\n        }\n        clearTimeout(keypressTimeout);\n        keypressTimeout = setTimeout(function () {\n            keypressTimeout = undefined;\n        }, debounceDuration);\n    };\n}\nvar _oldOnErrorHandler = null;\n/** JSDoc */\nfunction instrumentError() {\n    _oldOnErrorHandler = global.onerror;\n    global.onerror = function (msg, url, line, column, error) {\n        triggerHandlers('error', {\n            column: column,\n            error: error,\n            line: line,\n            msg: msg,\n            url: url,\n        });\n        if (_oldOnErrorHandler) {\n            return _oldOnErrorHandler.apply(this, arguments);\n        }\n        return false;\n    };\n}\nvar _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection() {\n    _oldOnUnhandledRejectionHandler = global.onunhandledrejection;\n    global.onunhandledrejection = function (e) {\n        triggerHandlers('unhandledrejection', e);\n        if (_oldOnUnhandledRejectionHandler) {\n            return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n        }\n        return true;\n    };\n}\n//# sourceMappingURL=instrument.js.map","/** The status of an event. */\nexport var Status;\n(function (Status) {\n    /** The status could not be determined. */\n    Status[\"Unknown\"] = \"unknown\";\n    /** The event was skipped due to configuration or callbacks. */\n    Status[\"Skipped\"] = \"skipped\";\n    /** The event was sent to Sentry successfully. */\n    Status[\"Success\"] = \"success\";\n    /** The client is currently rate limited and will try again later. */\n    Status[\"RateLimit\"] = \"rate_limit\";\n    /** The event could not be processed. */\n    Status[\"Invalid\"] = \"invalid\";\n    /** A server-side error ocurred during submission. */\n    Status[\"Failed\"] = \"failed\";\n})(Status || (Status = {}));\n// tslint:disable:completed-docs\n// tslint:disable:no-unnecessary-qualifier no-namespace\n(function (Status) {\n    /**\n     * Converts a HTTP status code into a {@link Status}.\n     *\n     * @param code The HTTP response status code.\n     * @returns The send status or {@link Status.Unknown}.\n     */\n    function fromHttpCode(code) {\n        if (code >= 200 && code < 300) {\n            return Status.Success;\n        }\n        if (code === 429) {\n            return Status.RateLimit;\n        }\n        if (code >= 400 && code < 500) {\n            return Status.Invalid;\n        }\n        if (code >= 500) {\n            return Status.Failed;\n        }\n        return Status.Unknown;\n    }\n    Status.fromHttpCode = fromHttpCode;\n})(Status || (Status = {}));\n//# sourceMappingURL=status.js.map","import { SentryError } from './error';\nimport { SyncPromise } from './syncpromise';\n/** A simple queue that holds promises. */\nvar PromiseBuffer = /** @class */ (function () {\n    function PromiseBuffer(_limit) {\n        this._limit = _limit;\n        /** Internal set of queued Promises */\n        this._buffer = [];\n    }\n    /**\n     * Says if the buffer is ready to take more requests\n     */\n    PromiseBuffer.prototype.isReady = function () {\n        return this._limit === undefined || this.length() < this._limit;\n    };\n    /**\n     * Add a promise to the queue.\n     *\n     * @param task Can be any PromiseLike<T>\n     * @returns The original promise.\n     */\n    PromiseBuffer.prototype.add = function (task) {\n        var _this = this;\n        if (!this.isReady()) {\n            return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));\n        }\n        if (this._buffer.indexOf(task) === -1) {\n            this._buffer.push(task);\n        }\n        task\n            .then(function () { return _this.remove(task); })\n            .then(null, function () {\n            return _this.remove(task).then(null, function () {\n                // We have to add this catch here otherwise we have an unhandledPromiseRejection\n                // because it's a new Promise chain.\n            });\n        });\n        return task;\n    };\n    /**\n     * Remove a promise to the queue.\n     *\n     * @param task Can be any PromiseLike<T>\n     * @returns Removed promise.\n     */\n    PromiseBuffer.prototype.remove = function (task) {\n        var removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];\n        return removedTask;\n    };\n    /**\n     * This function returns the number of unresolved promises in the queue.\n     */\n    PromiseBuffer.prototype.length = function () {\n        return this._buffer.length;\n    };\n    /**\n     * This will drain the whole queue, returns true if queue is empty or drained.\n     * If timeout is provided and the queue takes longer to drain, the promise still resolves but with false.\n     *\n     * @param timeout Number in ms to wait until it resolves with false.\n     */\n    PromiseBuffer.prototype.drain = function (timeout) {\n        var _this = this;\n        return new SyncPromise(function (resolve) {\n            var capturedSetTimeout = setTimeout(function () {\n                if (timeout && timeout > 0) {\n                    resolve(false);\n                }\n            }, timeout);\n            SyncPromise.all(_this._buffer)\n                .then(function () {\n                clearTimeout(capturedSetTimeout);\n                resolve(true);\n            })\n                .then(null, function () {\n                resolve(true);\n            });\n        });\n    };\n    return PromiseBuffer;\n}());\nexport { PromiseBuffer };\n//# sourceMappingURL=promisebuffer.js.map","import * as tslib_1 from \"tslib\";\nimport { SentryError } from './error';\n/** Regular expression used to parse a Dsn. */\nvar DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+))?@)([\\w\\.-]+)(?::(\\d+))?\\/(.+)/;\n/** Error message */\nvar ERROR_MESSAGE = 'Invalid Dsn';\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nvar Dsn = /** @class */ (function () {\n    /** Creates a new Dsn component */\n    function Dsn(from) {\n        if (typeof from === 'string') {\n            this._fromString(from);\n        }\n        else {\n            this._fromComponents(from);\n        }\n        this._validate();\n    }\n    /**\n     * Renders the string representation of this Dsn.\n     *\n     * By default, this will render the public representation without the password\n     * component. To get the deprecated private representation, set `withPassword`\n     * to true.\n     *\n     * @param withPassword When set to true, the password will be included.\n     */\n    Dsn.prototype.toString = function (withPassword) {\n        if (withPassword === void 0) { withPassword = false; }\n        // tslint:disable-next-line:no-this-assignment\n        var _a = this, host = _a.host, path = _a.path, pass = _a.pass, port = _a.port, projectId = _a.projectId, protocol = _a.protocol, user = _a.user;\n        return (protocol + \"://\" + user + (withPassword && pass ? \":\" + pass : '') +\n            (\"@\" + host + (port ? \":\" + port : '') + \"/\" + (path ? path + \"/\" : path) + projectId));\n    };\n    /** Parses a string into this Dsn. */\n    Dsn.prototype._fromString = function (str) {\n        var match = DSN_REGEX.exec(str);\n        if (!match) {\n            throw new SentryError(ERROR_MESSAGE);\n        }\n        var _a = tslib_1.__read(match.slice(1), 6), protocol = _a[0], user = _a[1], _b = _a[2], pass = _b === void 0 ? '' : _b, host = _a[3], _c = _a[4], port = _c === void 0 ? '' : _c, lastPath = _a[5];\n        var path = '';\n        var projectId = lastPath;\n        var split = projectId.split('/');\n        if (split.length > 1) {\n            path = split.slice(0, -1).join('/');\n            projectId = split.pop();\n        }\n        if (projectId) {\n            var projectMatch = projectId.match(/^\\d+/);\n            if (projectMatch) {\n                projectId = projectMatch[0];\n            }\n        }\n        this._fromComponents({ host: host, pass: pass, path: path, projectId: projectId, port: port, protocol: protocol, user: user });\n    };\n    /** Maps Dsn components into this instance. */\n    Dsn.prototype._fromComponents = function (components) {\n        this.protocol = components.protocol;\n        this.user = components.user;\n        this.pass = components.pass || '';\n        this.host = components.host;\n        this.port = components.port || '';\n        this.path = components.path || '';\n        this.projectId = components.projectId;\n    };\n    /** Validates this Dsn and throws on error. */\n    Dsn.prototype._validate = function () {\n        var _this = this;\n        ['protocol', 'user', 'host', 'projectId'].forEach(function (component) {\n            if (!_this[component]) {\n                throw new SentryError(ERROR_MESSAGE + \": \" + component + \" missing\");\n            }\n        });\n        if (!this.projectId.match(/^\\d+$/)) {\n            throw new SentryError(ERROR_MESSAGE + \": Invalid projectId \" + this.projectId);\n        }\n        if (this.protocol !== 'http' && this.protocol !== 'https') {\n            throw new SentryError(ERROR_MESSAGE + \": Invalid protocol \" + this.protocol);\n        }\n        if (this.port && isNaN(parseInt(this.port, 10))) {\n            throw new SentryError(ERROR_MESSAGE + \": Invalid port \" + this.port);\n        }\n    };\n    return Dsn;\n}());\nexport { Dsn };\n//# sourceMappingURL=dsn.js.map"],"sourceRoot":""}