{"version":3,"file":"js/34-b301f40b1998bef96a9b.js","mappings":"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","sources":["webpack://ventures_nest/./node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack://ventures_nest/./node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/polyfill.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/error.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/dsn.js","webpack://ventures_nest/./node_modules/@sentry/core/esm/integration.js","webpack://ventures_nest/./node_modules/@sentry/core/esm/baseclient.js","webpack://ventures_nest/./node_modules/@sentry/types/esm/status.js","webpack://ventures_nest/./node_modules/@sentry/core/esm/transports/noop.js","webpack://ventures_nest/./node_modules/@sentry/types/esm/severity.js","webpack://ventures_nest/./node_modules/@sentry/core/esm/basebackend.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/supports.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/tracekit.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/parsers.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/eventbuilder.js","webpack://ventures_nest/./node_modules/@sentry/core/esm/request.js","webpack://ventures_nest/./node_modules/@sentry/core/esm/api.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/promisebuffer.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/transports/base.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/transports/fetch.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/transports/xhr.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/backend.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/helpers.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/instrument.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/version.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/client.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/integrations/useragent.js","webpack://ventures_nest/./node_modules/@sentry/browser/esm/sdk.js","webpack://ventures_nest/./node_modules/@sentry/core/esm/sdk.js","webpack://ventures_nest/./node_modules/@sentry/hub/esm/session.js","webpack://ventures_nest/./node_modules/@sentry/hub/esm/hub.js","webpack://ventures_nest/./node_modules/@sentry/hub/esm/scope.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/path.js","webpack://ventures_nest/./node_modules/@sentry/integrations/esm/vue.js","webpack://ventures_nest/./node_modules/@sentry/minimal/esm/index.js","webpack://ventures_nest/./node_modules/@sentry/types/esm/session.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/browser.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/is.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/logger.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/misc.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/node.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/memo.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/object.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/stacktrace.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/string.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/syncpromise.js","webpack://ventures_nest/./node_modules/@sentry/utils/esm/time.js","webpack://ventures_nest/./node_modules/@vee-validate/i18n/dist/vee-validate-i18n.esm.js","webpack://ventures_nest/./node_modules/@vee-validate/rules/dist/vee-validate-rules.esm.js","webpack://ventures_nest/./node_modules/tslib/tslib.es6.js","webpack://ventures_nest/./node_modules/validator/src/lib/isMobilePhone.js","webpack://ventures_nest/./node_modules/validator/src/lib/util/assertString.js","webpack://ventures_nest/./node_modules/vee-validate/dist/vee-validate.esm.js","webpack://ventures_nest/./node_modules/@intlify/shared/dist/shared.esm-bundler.js","webpack://ventures_nest/./node_modules/@intlify/message-compiler/dist/message-compiler.esm-bundler.js","webpack://ventures_nest/./node_modules/@intlify/devtools-if/dist/devtools-if.esm-bundler.js","webpack://ventures_nest/./node_modules/@intlify/core-base/dist/core-base.esm-bundler.js","webpack://ventures_nest/./node_modules/vue-i18n/dist/vue-i18n.esm-bundler.js","webpack://ventures_nest/./node_modules/vue-demi/lib/index.mjs","webpack://ventures_nest/./node_modules/vue-inline-svg/src/index.js"],"sourcesContent":["var originalFunctionToString;\n/** Patch toString calls to return proper name for wrapped functions */\nvar FunctionToString = /** @class */ (function () {\n    function FunctionToString() {\n        /**\n         * @inheritDoc\n         */\n        this.name = FunctionToString.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    FunctionToString.prototype.setupOnce = function () {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        originalFunctionToString = Function.prototype.toString;\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        Function.prototype.toString = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var context = this.__sentry_original__ || this;\n            return originalFunctionToString.apply(context, args);\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    FunctionToString.id = 'FunctionToString';\n    return FunctionToString;\n}());\nexport { FunctionToString };\n//# sourceMappingURL=functiontostring.js.map","import { __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { getEventDescription, isMatchingPattern, logger } from '@sentry/utils';\n// \"Script error.\" is hard coded into browsers for errors that it can't read.\n// this is the result of a script being pulled in from an external domain and CORS.\nvar DEFAULT_IGNORE_ERRORS = [/^Script error\\.?$/, /^Javascript error: Script error\\.? on line 0$/];\n/** Inbound filters configurable by the user */\nvar InboundFilters = /** @class */ (function () {\n    function InboundFilters(_options) {\n        if (_options === void 0) { _options = {}; }\n        this._options = _options;\n        /**\n         * @inheritDoc\n         */\n        this.name = InboundFilters.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    InboundFilters.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event) {\n            var hub = getCurrentHub();\n            if (!hub) {\n                return event;\n            }\n            var self = hub.getIntegration(InboundFilters);\n            if (self) {\n                var client = hub.getClient();\n                var clientOptions = client ? client.getOptions() : {};\n                var options = self._mergeOptions(clientOptions);\n                if (self._shouldDropEvent(event, options)) {\n                    return null;\n                }\n            }\n            return event;\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._shouldDropEvent = function (event, options) {\n        if (this._isSentryError(event, options)) {\n            logger.warn(\"Event dropped due to being internal Sentry Error.\\nEvent: \" + getEventDescription(event));\n            return true;\n        }\n        if (this._isIgnoredError(event, options)) {\n            logger.warn(\"Event dropped due to being matched by `ignoreErrors` option.\\nEvent: \" + getEventDescription(event));\n            return true;\n        }\n        if (this._isDeniedUrl(event, options)) {\n            logger.warn(\"Event dropped due to being matched by `denyUrls` option.\\nEvent: \" + getEventDescription(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        if (!this._isAllowedUrl(event, options)) {\n            logger.warn(\"Event dropped due to not being matched by `allowUrls` option.\\nEvent: \" + getEventDescription(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        return false;\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isSentryError = function (event, options) {\n        if (!options.ignoreInternal) {\n            return false;\n        }\n        try {\n            return ((event &&\n                event.exception &&\n                event.exception.values &&\n                event.exception.values[0] &&\n                event.exception.values[0].type === 'SentryError') ||\n                false);\n        }\n        catch (_oO) {\n            return false;\n        }\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isIgnoredError = function (event, options) {\n        if (!options.ignoreErrors || !options.ignoreErrors.length) {\n            return false;\n        }\n        return this._getPossibleEventMessages(event).some(function (message) {\n            // Not sure why TypeScript complains here...\n            return options.ignoreErrors.some(function (pattern) { return isMatchingPattern(message, pattern); });\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isDeniedUrl = function (event, options) {\n        // TODO: Use Glob instead?\n        if (!options.denyUrls || !options.denyUrls.length) {\n            return false;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? false : options.denyUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isAllowedUrl = function (event, options) {\n        // TODO: Use Glob instead?\n        if (!options.allowUrls || !options.allowUrls.length) {\n            return true;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? true : options.allowUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._mergeOptions = function (clientOptions) {\n        if (clientOptions === void 0) { clientOptions = {}; }\n        return {\n            allowUrls: __spread((this._options.whitelistUrls || []), (this._options.allowUrls || []), (clientOptions.whitelistUrls || []), (clientOptions.allowUrls || [])),\n            denyUrls: __spread((this._options.blacklistUrls || []), (this._options.denyUrls || []), (clientOptions.blacklistUrls || []), (clientOptions.denyUrls || [])),\n            ignoreErrors: __spread((this._options.ignoreErrors || []), (clientOptions.ignoreErrors || []), DEFAULT_IGNORE_ERRORS),\n            ignoreInternal: typeof this._options.ignoreInternal !== 'undefined' ? this._options.ignoreInternal : true,\n        };\n    };\n    /** JSDoc */\n    InboundFilters.prototype._getPossibleEventMessages = function (event) {\n        if (event.message) {\n            return [event.message];\n        }\n        if (event.exception) {\n            try {\n                var _a = (event.exception.values && event.exception.values[0]) || {}, _b = _a.type, type = _b === void 0 ? '' : _b, _c = _a.value, value = _c === void 0 ? '' : _c;\n                return [\"\" + value, type + \": \" + value];\n            }\n            catch (oO) {\n                logger.error(\"Cannot extract message for event \" + getEventDescription(event));\n                return [];\n            }\n        }\n        return [];\n    };\n    /** JSDoc */\n    InboundFilters.prototype._getEventFilterUrl = function (event) {\n        try {\n            if (event.stacktrace) {\n                var frames_1 = event.stacktrace.frames;\n                return (frames_1 && frames_1[frames_1.length - 1].filename) || null;\n            }\n            if (event.exception) {\n                var frames_2 = event.exception.values && event.exception.values[0].stacktrace && event.exception.values[0].stacktrace.frames;\n                return (frames_2 && frames_2[frames_2.length - 1].filename) || null;\n            }\n            return null;\n        }\n        catch (oO) {\n            logger.error(\"Cannot extract url for event \" + getEventDescription(event));\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    InboundFilters.id = 'InboundFilters';\n    return InboundFilters;\n}());\nexport { InboundFilters };\n//# sourceMappingURL=inboundfilters.js.map","export var setPrototypeOf = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);\n/**\n * setPrototypeOf polyfill using __proto__\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction setProtoOf(obj, proto) {\n    // @ts-ignore __proto__ does not exist on obj\n    obj.__proto__ = proto;\n    return obj;\n}\n/**\n * setPrototypeOf polyfill using mixin\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction mixinProperties(obj, proto) {\n    for (var prop in proto) {\n        // eslint-disable-next-line no-prototype-builtins\n        if (!obj.hasOwnProperty(prop)) {\n            // @ts-ignore typescript complains about indexing so we remove\n            obj[prop] = proto[prop];\n        }\n    }\n    return obj;\n}\n//# sourceMappingURL=polyfill.js.map","import { __extends } from \"tslib\";\nimport { setPrototypeOf } from './polyfill';\n/** An error emitted by Sentry SDKs and related utilities. */\nvar SentryError = /** @class */ (function (_super) {\n    __extends(SentryError, _super);\n    function SentryError(message) {\n        var _newTarget = this.constructor;\n        var _this = _super.call(this, message) || this;\n        _this.message = message;\n        _this.name = _newTarget.prototype.constructor.name;\n        setPrototypeOf(_this, _newTarget.prototype);\n        return _this;\n    }\n    return SentryError;\n}(Error));\nexport { SentryError };\n//# sourceMappingURL=error.js.map","import { __read } from \"tslib\";\nimport { SentryError } from './error';\n/** Regular expression used to parse a Dsn. */\nvar DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+))?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n/** Error message */\nvar ERROR_MESSAGE = 'Invalid Dsn';\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nvar Dsn = /** @class */ (function () {\n    /** Creates a new Dsn component */\n    function Dsn(from) {\n        if (typeof from === 'string') {\n            this._fromString(from);\n        }\n        else {\n            this._fromComponents(from);\n        }\n        this._validate();\n    }\n    /**\n     * Renders the string representation of this Dsn.\n     *\n     * By default, this will render the public representation without the password\n     * component. To get the deprecated private representation, set `withPassword`\n     * to true.\n     *\n     * @param withPassword When set to true, the password will be included.\n     */\n    Dsn.prototype.toString = function (withPassword) {\n        if (withPassword === void 0) { withPassword = false; }\n        var _a = this, host = _a.host, path = _a.path, pass = _a.pass, port = _a.port, projectId = _a.projectId, protocol = _a.protocol, 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 = __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","import { __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\nexport var installedIntegrations = [];\n/** Gets integration to install */\nexport function getIntegrationsToSetup(options) {\n    var defaultIntegrations = (options.defaultIntegrations && __spread(options.defaultIntegrations)) || [];\n    var userIntegrations = options.integrations;\n    var integrations = [];\n    if (Array.isArray(userIntegrations)) {\n        var userIntegrationsNames_1 = userIntegrations.map(function (i) { return i.name; });\n        var pickedIntegrationsNames_1 = [];\n        // Leave only unique default integrations, that were not overridden with provided user integrations\n        defaultIntegrations.forEach(function (defaultIntegration) {\n            if (userIntegrationsNames_1.indexOf(defaultIntegration.name) === -1 &&\n                pickedIntegrationsNames_1.indexOf(defaultIntegration.name) === -1) {\n                integrations.push(defaultIntegration);\n                pickedIntegrationsNames_1.push(defaultIntegration.name);\n            }\n        });\n        // Don't add same user integration twice\n        userIntegrations.forEach(function (userIntegration) {\n            if (pickedIntegrationsNames_1.indexOf(userIntegration.name) === -1) {\n                integrations.push(userIntegration);\n                pickedIntegrationsNames_1.push(userIntegration.name);\n            }\n        });\n    }\n    else if (typeof userIntegrations === 'function') {\n        integrations = userIntegrations(defaultIntegrations);\n        integrations = Array.isArray(integrations) ? integrations : [integrations];\n    }\n    else {\n        integrations = __spread(defaultIntegrations);\n    }\n    // Make sure that if present, `Debug` integration will always run last\n    var integrationsNames = integrations.map(function (i) { return i.name; });\n    var alwaysLastToRun = 'Debug';\n    if (integrationsNames.indexOf(alwaysLastToRun) !== -1) {\n        integrations.push.apply(integrations, __spread(integrations.splice(integrationsNames.indexOf(alwaysLastToRun), 1)));\n    }\n    return integrations;\n}\n/** Setup given integration */\nexport function setupIntegration(integration) {\n    if (installedIntegrations.indexOf(integration.name) !== -1) {\n        return;\n    }\n    integration.setupOnce(addGlobalEventProcessor, getCurrentHub);\n    installedIntegrations.push(integration.name);\n    logger.log(\"Integration installed: \" + integration.name);\n}\n/**\n * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default\n * integrations are added unless they were already provided before.\n * @param integrations array of integration instances\n * @param withDefault should enable default integrations\n */\nexport function setupIntegrations(options) {\n    var integrations = {};\n    getIntegrationsToSetup(options).forEach(function (integration) {\n        integrations[integration.name] = integration;\n        setupIntegration(integration);\n    });\n    return integrations;\n}\n//# sourceMappingURL=integration.js.map","import { __assign, __values } from \"tslib\";\n/* eslint-disable max-lines */\nimport { Scope } from '@sentry/hub';\nimport { SessionStatus, } from '@sentry/types';\nimport { dateTimestampInSeconds, Dsn, isPrimitive, isThenable, logger, normalize, SentryError, SyncPromise, truncate, uuid4, } from '@sentry/utils';\nimport { setupIntegrations } from './integration';\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding backend constructor and options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}. Also, the Backend instance is available via\n * {@link Client.getBackend}.\n *\n * If a Dsn is specified in the options, it will be parsed and stored. Use\n * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is\n * invalid, the constructor will throw a {@link SentryException}. Note that\n * without a valid Dsn, the SDK will not send any events to Sentry.\n *\n * Before sending an event via the backend, it is passed through\n * {@link BaseClient.prepareEvent} to add SDK information and scope data\n * (breadcrumbs and context). To add more custom information, override this\n * method and extend the resulting prepared event.\n *\n * To issue automatically created events (e.g. via instrumentation), use\n * {@link Client.captureEvent}. It will prepare the event and pass it through\n * the callback lifecycle. To issue auto-breadcrumbs, use\n * {@link Client.addBreadcrumb}.\n *\n * @example\n * class NodeClient extends BaseClient<NodeBackend, NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(NodeBackend, options);\n *   }\n *\n *   // ...\n * }\n */\nvar BaseClient = /** @class */ (function () {\n    /**\n     * Initializes this client instance.\n     *\n     * @param backendClass A constructor function to create the backend.\n     * @param options Options for the client.\n     */\n    function BaseClient(backendClass, options) {\n        /** Array of used integrations. */\n        this._integrations = {};\n        /** Number of call being processed */\n        this._processing = 0;\n        this._backend = new backendClass(options);\n        this._options = options;\n        if (options.dsn) {\n            this._dsn = new Dsn(options.dsn);\n        }\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    BaseClient.prototype.captureException = function (exception, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        this._process(this._getBackend()\n            .eventFromException(exception, hint)\n            .then(function (event) { return _this._captureEvent(event, hint, scope); })\n            .then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureMessage = function (message, level, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        var promisedEvent = isPrimitive(message)\n            ? this._getBackend().eventFromMessage(String(message), level, hint)\n            : this._getBackend().eventFromException(message, hint);\n        this._process(promisedEvent\n            .then(function (event) { return _this._captureEvent(event, hint, scope); })\n            .then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureEvent = function (event, hint, scope) {\n        var eventId = hint && hint.event_id;\n        this._process(this._captureEvent(event, hint, scope).then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureSession = function (session) {\n        if (!session.release) {\n            logger.warn('Discarded session because of missing release');\n        }\n        else {\n            this._sendSession(session);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getDsn = function () {\n        return this._dsn;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getOptions = function () {\n        return this._options;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.flush = function (timeout) {\n        var _this = this;\n        return this._isClientProcessing(timeout).then(function (ready) {\n            return _this._getBackend()\n                .getTransport()\n                .close(timeout)\n                .then(function (transportFlushed) { return ready && transportFlushed; });\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.close = function (timeout) {\n        var _this = this;\n        return this.flush(timeout).then(function (result) {\n            _this.getOptions().enabled = false;\n            return result;\n        });\n    };\n    /**\n     * Sets up the integrations\n     */\n    BaseClient.prototype.setupIntegrations = function () {\n        if (this._isEnabled()) {\n            this._integrations = setupIntegrations(this._options);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getIntegration = function (integration) {\n        try {\n            return this._integrations[integration.id] || null;\n        }\n        catch (_oO) {\n            logger.warn(\"Cannot retrieve integration \" + integration.id + \" from the current Client\");\n            return null;\n        }\n    };\n    /** Updates existing session based on the provided event */\n    BaseClient.prototype._updateSessionFromEvent = function (session, event) {\n        var e_1, _a;\n        var crashed = false;\n        var errored = false;\n        var userAgent;\n        var exceptions = event.exception && event.exception.values;\n        if (exceptions) {\n            errored = true;\n            try {\n                for (var exceptions_1 = __values(exceptions), exceptions_1_1 = exceptions_1.next(); !exceptions_1_1.done; exceptions_1_1 = exceptions_1.next()) {\n                    var ex = exceptions_1_1.value;\n                    var mechanism = ex.mechanism;\n                    if (mechanism && mechanism.handled === false) {\n                        crashed = true;\n                        break;\n                    }\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (exceptions_1_1 && !exceptions_1_1.done && (_a = exceptions_1.return)) _a.call(exceptions_1);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n        }\n        var user = event.user;\n        if (!session.userAgent) {\n            var headers = event.request ? event.request.headers : {};\n            for (var key in headers) {\n                if (key.toLowerCase() === 'user-agent') {\n                    userAgent = headers[key];\n                    break;\n                }\n            }\n        }\n        session.update(__assign(__assign({}, (crashed && { status: SessionStatus.Crashed })), { user: user,\n            userAgent: userAgent, errors: session.errors + Number(errored || crashed) }));\n    };\n    /** Deliver captured session to Sentry */\n    BaseClient.prototype._sendSession = function (session) {\n        this._getBackend().sendSession(session);\n    };\n    /** Waits for the client to be done with processing. */\n    BaseClient.prototype._isClientProcessing = function (timeout) {\n        var _this = this;\n        return new SyncPromise(function (resolve) {\n            var ticked = 0;\n            var tick = 1;\n            var interval = setInterval(function () {\n                if (_this._processing == 0) {\n                    clearInterval(interval);\n                    resolve(true);\n                }\n                else {\n                    ticked += tick;\n                    if (timeout && ticked >= timeout) {\n                        clearInterval(interval);\n                        resolve(false);\n                    }\n                }\n            }, tick);\n        });\n    };\n    /** Returns the current backend. */\n    BaseClient.prototype._getBackend = function () {\n        return this._backend;\n    };\n    /** Determines whether this SDK is enabled and a valid Dsn is present. */\n    BaseClient.prototype._isEnabled = function () {\n        return this.getOptions().enabled !== false && this._dsn !== undefined;\n    };\n    /**\n     * Adds common information to events.\n     *\n     * The information includes release and environment from `options`,\n     * breadcrumbs and context (extra, tags and user) from the scope.\n     *\n     * Information that is already present in the event is never overwritten. For\n     * nested objects, such as the context, keys are merged.\n     *\n     * @param event The original event.\n     * @param hint May contain additional information about the original exception.\n     * @param scope A scope containing event metadata.\n     * @returns A new event with more information.\n     */\n    BaseClient.prototype._prepareEvent = function (event, scope, hint) {\n        var _this = this;\n        var _a = this.getOptions().normalizeDepth, normalizeDepth = _a === void 0 ? 3 : _a;\n        var prepared = __assign(__assign({}, event), { event_id: event.event_id || (hint && hint.event_id ? hint.event_id : uuid4()), timestamp: event.timestamp || dateTimestampInSeconds() });\n        this._applyClientOptions(prepared);\n        this._applyIntegrationsMetadata(prepared);\n        // If we have scope given to us, use it as the base for further modifications.\n        // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.\n        var finalScope = scope;\n        if (hint && hint.captureContext) {\n            finalScope = Scope.clone(finalScope).update(hint.captureContext);\n        }\n        // We prepare the result here with a resolved Event.\n        var result = SyncPromise.resolve(prepared);\n        // This should be the last thing called, since we want that\n        // {@link Hub.addEventProcessor} gets the finished prepared event.\n        if (finalScope) {\n            // In case we have a hub we reassign it.\n            result = finalScope.applyToEvent(prepared, hint);\n        }\n        return result.then(function (evt) {\n            if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n                return _this._normalizeEvent(evt, normalizeDepth);\n            }\n            return evt;\n        });\n    };\n    /**\n     * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.\n     * Normalized keys:\n     * - `breadcrumbs.data`\n     * - `user`\n     * - `contexts`\n     * - `extra`\n     * @param event Event\n     * @returns Normalized event\n     */\n    BaseClient.prototype._normalizeEvent = function (event, depth) {\n        if (!event) {\n            return null;\n        }\n        var normalized = __assign(__assign(__assign(__assign(__assign({}, event), (event.breadcrumbs && {\n            breadcrumbs: event.breadcrumbs.map(function (b) { return (__assign(__assign({}, b), (b.data && {\n                data: normalize(b.data, depth),\n            }))); }),\n        })), (event.user && {\n            user: normalize(event.user, depth),\n        })), (event.contexts && {\n            contexts: normalize(event.contexts, depth),\n        })), (event.extra && {\n            extra: normalize(event.extra, depth),\n        }));\n        // event.contexts.trace stores information about a Transaction. Similarly,\n        // event.spans[] stores information about child Spans. Given that a\n        // Transaction is conceptually a Span, normalization should apply to both\n        // Transactions and Spans consistently.\n        // For now the decision is to skip normalization of Transactions and Spans,\n        // so this block overwrites the normalized event to add back the original\n        // Transaction information prior to normalization.\n        if (event.contexts && event.contexts.trace) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            normalized.contexts.trace = event.contexts.trace;\n        }\n        return normalized;\n    };\n    /**\n     *  Enhances event using the client configuration.\n     *  It takes care of all \"static\" values like environment, release and `dist`,\n     *  as well as truncating overly long values.\n     * @param event event instance to be enhanced\n     */\n    BaseClient.prototype._applyClientOptions = function (event) {\n        var options = this.getOptions();\n        var environment = options.environment, release = options.release, dist = options.dist, _a = options.maxValueLength, maxValueLength = _a === void 0 ? 250 : _a;\n        if (!('environment' in event)) {\n            event.environment = 'environment' in options ? environment : 'production';\n        }\n        if (event.release === undefined && release !== undefined) {\n            event.release = release;\n        }\n        if (event.dist === undefined && dist !== undefined) {\n            event.dist = dist;\n        }\n        if (event.message) {\n            event.message = truncate(event.message, maxValueLength);\n        }\n        var exception = event.exception && event.exception.values && event.exception.values[0];\n        if (exception && exception.value) {\n            exception.value = truncate(exception.value, maxValueLength);\n        }\n        var request = event.request;\n        if (request && request.url) {\n            request.url = truncate(request.url, maxValueLength);\n        }\n    };\n    /**\n     * This function adds all used integrations to the SDK info in the event.\n     * @param sdkInfo The sdkInfo of the event that will be filled with all integrations.\n     */\n    BaseClient.prototype._applyIntegrationsMetadata = function (event) {\n        var sdkInfo = event.sdk;\n        var integrationsArray = Object.keys(this._integrations);\n        if (sdkInfo && integrationsArray.length > 0) {\n            sdkInfo.integrations = integrationsArray;\n        }\n    };\n    /**\n     * Tells the backend to send this event\n     * @param event The Sentry event to send\n     */\n    BaseClient.prototype._sendEvent = function (event) {\n        this._getBackend().sendEvent(event);\n    };\n    /**\n     * Processes the event and logs an error in case of rejection\n     * @param event\n     * @param hint\n     * @param scope\n     */\n    BaseClient.prototype._captureEvent = function (event, hint, scope) {\n        return this._processEvent(event, hint, scope).then(function (finalEvent) {\n            return finalEvent.event_id;\n        }, function (reason) {\n            logger.error(reason);\n            return undefined;\n        });\n    };\n    /**\n     * Processes an event (either error or message) and sends it to Sentry.\n     *\n     * This also adds breadcrumbs and context information to the event. However,\n     * platform specific meta data (such as the User's IP address) must be added\n     * by the SDK implementor.\n     *\n     *\n     * @param event The event to send to Sentry.\n     * @param hint May contain additional information about the original exception.\n     * @param scope A scope containing event metadata.\n     * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.\n     */\n    BaseClient.prototype._processEvent = function (event, hint, scope) {\n        var _this = this;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var _a = this.getOptions(), beforeSend = _a.beforeSend, sampleRate = _a.sampleRate;\n        if (!this._isEnabled()) {\n            return SyncPromise.reject(new SentryError('SDK not enabled, will not send event.'));\n        }\n        var isTransaction = event.type === 'transaction';\n        // 1.0 === 100% events are sent\n        // 0.0 === 0% events are sent\n        // Sampling for transaction happens somewhere else\n        if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {\n            return SyncPromise.reject(new SentryError(\"Discarding event because it's not included in the random sample (sampling rate = \" + sampleRate + \")\"));\n        }\n        return this._prepareEvent(event, scope, hint)\n            .then(function (prepared) {\n            if (prepared === null) {\n                throw new SentryError('An event processor returned null, will not send event.');\n            }\n            var isInternalException = hint && hint.data && hint.data.__sentry__ === true;\n            if (isInternalException || isTransaction || !beforeSend) {\n                return prepared;\n            }\n            var beforeSendResult = beforeSend(prepared, hint);\n            if (typeof beforeSendResult === 'undefined') {\n                throw new SentryError('`beforeSend` method has to return `null` or a valid event.');\n            }\n            else if (isThenable(beforeSendResult)) {\n                return beforeSendResult.then(function (event) { return event; }, function (e) {\n                    throw new SentryError(\"beforeSend rejected with \" + e);\n                });\n            }\n            return beforeSendResult;\n        })\n            .then(function (processedEvent) {\n            if (processedEvent === null) {\n                throw new SentryError('`beforeSend` returned `null`, will not send event.');\n            }\n            var session = scope && scope.getSession && scope.getSession();\n            if (!isTransaction && session) {\n                _this._updateSessionFromEvent(session, processedEvent);\n            }\n            _this._sendEvent(processedEvent);\n            return processedEvent;\n        })\n            .then(null, function (reason) {\n            if (reason instanceof SentryError) {\n                throw reason;\n            }\n            _this.captureException(reason, {\n                data: {\n                    __sentry__: true,\n                },\n                originalException: reason,\n            });\n            throw new SentryError(\"Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: \" + reason);\n        });\n    };\n    /**\n     * Occupies the client with processing and event\n     */\n    BaseClient.prototype._process = function (promise) {\n        var _this = this;\n        this._processing += 1;\n        promise.then(function (value) {\n            _this._processing -= 1;\n            return value;\n        }, function (reason) {\n            _this._processing -= 1;\n            return reason;\n        });\n    };\n    return BaseClient;\n}());\nexport { BaseClient };\n//# sourceMappingURL=baseclient.js.map","/** The status of an event. */\n// eslint-disable-next-line import/export\nexport var Status;\n(function (Status) {\n    /** The status could not be determined. */\n    Status[\"Unknown\"] = \"unknown\";\n    /** The event was skipped due to configuration or callbacks. */\n    Status[\"Skipped\"] = \"skipped\";\n    /** The event was sent to Sentry successfully. */\n    Status[\"Success\"] = \"success\";\n    /** The client is currently rate limited and will try again later. */\n    Status[\"RateLimit\"] = \"rate_limit\";\n    /** The event could not be processed. */\n    Status[\"Invalid\"] = \"invalid\";\n    /** A server-side error ocurred during submission. */\n    Status[\"Failed\"] = \"failed\";\n})(Status || (Status = {}));\n// eslint-disable-next-line @typescript-eslint/no-namespace, import/export\n(function (Status) {\n    /**\n     * Converts a HTTP status code into a {@link Status}.\n     *\n     * @param code The HTTP response status code.\n     * @returns The send status or {@link Status.Unknown}.\n     */\n    function fromHttpCode(code) {\n        if (code >= 200 && code < 300) {\n            return Status.Success;\n        }\n        if (code === 429) {\n            return Status.RateLimit;\n        }\n        if (code >= 400 && code < 500) {\n            return Status.Invalid;\n        }\n        if (code >= 500) {\n            return Status.Failed;\n        }\n        return Status.Unknown;\n    }\n    Status.fromHttpCode = fromHttpCode;\n})(Status || (Status = {}));\n//# sourceMappingURL=status.js.map","import { Status } from '@sentry/types';\nimport { SyncPromise } from '@sentry/utils';\n/** Noop transport */\nvar NoopTransport = /** @class */ (function () {\n    function NoopTransport() {\n    }\n    /**\n     * @inheritDoc\n     */\n    NoopTransport.prototype.sendEvent = function (_) {\n        return SyncPromise.resolve({\n            reason: \"NoopTransport: Event has been skipped because no Dsn is configured.\",\n            status: Status.Skipped,\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    NoopTransport.prototype.close = function (_) {\n        return SyncPromise.resolve(true);\n    };\n    return NoopTransport;\n}());\nexport { NoopTransport };\n//# sourceMappingURL=noop.js.map","/** JSDoc */\n// eslint-disable-next-line import/export\nexport var Severity;\n(function (Severity) {\n    /** JSDoc */\n    Severity[\"Fatal\"] = \"fatal\";\n    /** JSDoc */\n    Severity[\"Error\"] = \"error\";\n    /** JSDoc */\n    Severity[\"Warning\"] = \"warning\";\n    /** JSDoc */\n    Severity[\"Log\"] = \"log\";\n    /** JSDoc */\n    Severity[\"Info\"] = \"info\";\n    /** JSDoc */\n    Severity[\"Debug\"] = \"debug\";\n    /** JSDoc */\n    Severity[\"Critical\"] = \"critical\";\n})(Severity || (Severity = {}));\n// eslint-disable-next-line @typescript-eslint/no-namespace, import/export\n(function (Severity) {\n    /**\n     * Converts a string-based level into a {@link Severity}.\n     *\n     * @param level string representation of Severity\n     * @returns Severity\n     */\n    function fromString(level) {\n        switch (level) {\n            case 'debug':\n                return Severity.Debug;\n            case 'info':\n                return Severity.Info;\n            case 'warn':\n            case 'warning':\n                return Severity.Warning;\n            case 'error':\n                return Severity.Error;\n            case 'fatal':\n                return Severity.Fatal;\n            case 'critical':\n                return Severity.Critical;\n            case 'log':\n            default:\n                return Severity.Log;\n        }\n    }\n    Severity.fromString = fromString;\n})(Severity || (Severity = {}));\n//# sourceMappingURL=severity.js.map","import { logger, SentryError } from '@sentry/utils';\nimport { NoopTransport } from './transports/noop';\n/**\n * This is the base implemention of a Backend.\n * @hidden\n */\nvar BaseBackend = /** @class */ (function () {\n    /** Creates a new backend instance. */\n    function BaseBackend(options) {\n        this._options = options;\n        if (!this._options.dsn) {\n            logger.warn('No DSN provided, backend will not do anything.');\n        }\n        this._transport = this._setupTransport();\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    BaseBackend.prototype.eventFromException = function (_exception, _hint) {\n        throw new SentryError('Backend has to implement `eventFromException` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.eventFromMessage = function (_message, _level, _hint) {\n        throw new SentryError('Backend has to implement `eventFromMessage` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.sendEvent = function (event) {\n        this._transport.sendEvent(event).then(null, function (reason) {\n            logger.error(\"Error while sending event: \" + reason);\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.sendSession = function (session) {\n        if (!this._transport.sendSession) {\n            logger.warn(\"Dropping session because custom transport doesn't implement sendSession\");\n            return;\n        }\n        this._transport.sendSession(session).then(null, function (reason) {\n            logger.error(\"Error while sending session: \" + reason);\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.getTransport = function () {\n        return this._transport;\n    };\n    /**\n     * Sets up the transport so it can be used later to send requests.\n     */\n    BaseBackend.prototype._setupTransport = function () {\n        return new NoopTransport();\n    };\n    return BaseBackend;\n}());\nexport { BaseBackend };\n//# sourceMappingURL=basebackend.js.map","import { logger } from './logger';\nimport { getGlobalObject } from './misc';\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsErrorEvent() {\n    try {\n        new ErrorEvent('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMError() {\n    try {\n        // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n        // 1 argument required, but only 0 present.\n        // @ts-ignore It really needs 1 argument, not 0.\n        new DOMError('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMException() {\n    try {\n        new DOMException('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsFetch() {\n    if (!('fetch' in getGlobalObject())) {\n        return false;\n    }\n    try {\n        new Headers();\n        new Request('');\n        new Response();\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\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    // eslint-disable-next-line @typescript-eslint/unbound-method\n    if (isNativeFetch(global.fetch)) {\n        return true;\n    }\n    // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n    // so create a \"pure\" iframe to see if that has native fetch\n    var result = false;\n    var doc = global.document;\n    // eslint-disable-next-line deprecation/deprecation\n    if (doc && typeof doc.createElement === \"function\") {\n        try {\n            var sandbox = doc.createElement('iframe');\n            sandbox.hidden = true;\n            doc.head.appendChild(sandbox);\n            if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n                // eslint-disable-next-line @typescript-eslint/unbound-method\n                result = isNativeFetch(sandbox.contentWindow.fetch);\n            }\n            doc.head.removeChild(sandbox);\n        }\n        catch (err) {\n            logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n        }\n    }\n    return result;\n}\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReportingObserver() {\n    return 'ReportingObserver' in getGlobalObject();\n}\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReferrerPolicy() {\n    // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default\n    // https://caniuse.com/#feat=referrer-policy\n    // It doesn't. And it throw exception instead of ignoring this parameter...\n    // REF: https://github.com/getsentry/raven-js/issues/1233\n    if (!supportsFetch()) {\n        return false;\n    }\n    try {\n        new Request('_', {\n            referrerPolicy: 'origin',\n        });\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsHistory() {\n    // NOTE: in Chrome App environment, touching history.pushState, *even inside\n    //       a try/catch block*, will cause Chrome to output an error to console.error\n    // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n    var global = getGlobalObject();\n    /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var chrome = global.chrome;\n    var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n    /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n    var hasHistoryApi = 'history' in global && !!global.history.pushState && !!global.history.replaceState;\n    return !isChromePackagedApp && hasHistoryApi;\n}\n//# sourceMappingURL=supports.js.map","/**\n * This was originally forked from https://github.com/occ/TraceKit, but has since been\n * largely modified and is now maintained as part of Sentry JS SDK.\n */\nimport { __assign } from \"tslib\";\n// global reference to slice\nvar UNKNOWN_FUNCTION = '?';\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nvar chrome = /^\\s*at (?:(.*?) ?\\()?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nvar gecko = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|capacitor).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar winjs = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nvar geckoEval = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nvar chromeEval = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nvar reactMinifiedRegexp = /Minified React error #\\d+;/i;\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nexport function computeStackTrace(ex) {\n    var stack = null;\n    var popSize = 0;\n    if (ex) {\n        if (typeof ex.framesToPop === 'number') {\n            popSize = ex.framesToPop;\n        }\n        else if (reactMinifiedRegexp.test(ex.message)) {\n            popSize = 1;\n        }\n    }\n    try {\n        // This must be tried first because Opera 10 *destroys*\n        // its stacktrace property if you try to access the stack\n        // property first!!\n        stack = computeStackTraceFromStacktraceProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\n        }\n    }\n    catch (e) {\n        // no-empty\n    }\n    try {\n        stack = computeStackTraceFromStackProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\n        }\n    }\n    catch (e) {\n        // no-empty\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex && ex.name,\n        stack: [],\n        failed: true,\n    };\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, complexity\nfunction computeStackTraceFromStackProp(ex) {\n    if (!ex || !ex.stack) {\n        return null;\n    }\n    var stack = [];\n    var lines = ex.stack.split('\\n');\n    var isEval;\n    var submatch;\n    var parts;\n    var element;\n    for (var i = 0; i < lines.length; ++i) {\n        if ((parts = chrome.exec(lines[i]))) {\n            var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n            isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n            if (isEval && (submatch = chromeEval.exec(parts[2]))) {\n                // throw out eval line/column and use top-most line/column number\n                parts[2] = submatch[1]; // url\n                parts[3] = submatch[2]; // line\n                parts[4] = submatch[3]; // column\n            }\n            element = {\n                // working with the regexp above is super painful. it is quite a hack, but just stripping the `address at `\n                // prefix here seems like the quickest solution for now.\n                url: parts[2] && parts[2].indexOf('address at ') === 0 ? parts[2].substr('address at '.length) : parts[2],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: isNative ? [parts[2]] : [],\n                line: parts[3] ? +parts[3] : null,\n                column: parts[4] ? +parts[4] : null,\n            };\n        }\n        else if ((parts = winjs.exec(lines[i]))) {\n            element = {\n                url: parts[2],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: [],\n                line: +parts[3],\n                column: parts[4] ? +parts[4] : null,\n            };\n        }\n        else if ((parts = gecko.exec(lines[i]))) {\n            isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n            if (isEval && (submatch = geckoEval.exec(parts[3]))) {\n                // throw out eval line/column and use top-most line number\n                parts[1] = parts[1] || \"eval\";\n                parts[3] = submatch[1];\n                parts[4] = submatch[2];\n                parts[5] = ''; // no column when eval\n            }\n            else if (i === 0 && !parts[5] && ex.columnNumber !== void 0) {\n                // FireFox uses this awesome columnNumber property for its top frame\n                // Also note, Firefox's column number is 0-based and everything else expects 1-based,\n                // so adding 1\n                // NOTE: this hack doesn't work if top-most frame is eval\n                stack[0].column = ex.columnNumber + 1;\n            }\n            element = {\n                url: parts[3],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: parts[2] ? parts[2].split(',') : [],\n                line: parts[4] ? +parts[4] : null,\n                column: parts[5] ? +parts[5] : null,\n            };\n        }\n        else {\n            continue;\n        }\n        if (!element.func && element.line) {\n            element.func = UNKNOWN_FUNCTION;\n        }\n        stack.push(element);\n    }\n    if (!stack.length) {\n        return null;\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex.name,\n        stack: stack,\n    };\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction computeStackTraceFromStacktraceProp(ex) {\n    if (!ex || !ex.stacktrace) {\n        return null;\n    }\n    // Access and store the stacktrace property before doing ANYTHING\n    // else to it because Opera is not very good at providing it\n    // reliably in other circumstances.\n    var stacktrace = ex.stacktrace;\n    var opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n    var opera11Regex = / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\((.*)\\))? in (.*):\\s*$/i;\n    var lines = stacktrace.split('\\n');\n    var stack = [];\n    var parts;\n    for (var line = 0; line < lines.length; line += 2) {\n        var element = null;\n        if ((parts = opera10Regex.exec(lines[line]))) {\n            element = {\n                url: parts[2],\n                func: parts[3],\n                args: [],\n                line: +parts[1],\n                column: null,\n            };\n        }\n        else if ((parts = opera11Regex.exec(lines[line]))) {\n            element = {\n                url: parts[6],\n                func: parts[3] || parts[4],\n                args: parts[5] ? parts[5].split(',') : [],\n                line: +parts[1],\n                column: +parts[2],\n            };\n        }\n        if (element) {\n            if (!element.func && element.line) {\n                element.func = UNKNOWN_FUNCTION;\n            }\n            stack.push(element);\n        }\n    }\n    if (!stack.length) {\n        return null;\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex.name,\n        stack: stack,\n    };\n}\n/** Remove N number of frames from the stack */\nfunction popFrames(stacktrace, popSize) {\n    try {\n        return __assign(__assign({}, stacktrace), { stack: stacktrace.stack.slice(popSize) });\n    }\n    catch (e) {\n        return stacktrace;\n    }\n}\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction extractMessage(ex) {\n    var message = ex && ex.message;\n    if (!message) {\n        return 'No error message';\n    }\n    if (message.error && typeof message.error.message === 'string') {\n        return message.error.message;\n    }\n    return message;\n}\n//# sourceMappingURL=tracekit.js.map","import { extractExceptionKeysForMessage, isEvent, normalizeToSize } from '@sentry/utils';\nimport { computeStackTrace } from './tracekit';\nvar STACKTRACE_LIMIT = 50;\n/**\n * This function creates an exception from an TraceKitStackTrace\n * @param stacktrace TraceKitStackTrace that will be converted to an exception\n * @hidden\n */\nexport function exceptionFromStacktrace(stacktrace) {\n    var frames = prepareFramesForEvent(stacktrace.stack);\n    var exception = {\n        type: stacktrace.name,\n        value: stacktrace.message,\n    };\n    if (frames && frames.length) {\n        exception.stacktrace = { frames: frames };\n    }\n    if (exception.type === undefined && exception.value === '') {\n        exception.value = 'Unrecoverable error caught';\n    }\n    return exception;\n}\n/**\n * @hidden\n */\nexport function eventFromPlainObject(exception, syntheticException, rejection) {\n    var event = {\n        exception: {\n            values: [\n                {\n                    type: isEvent(exception) ? exception.constructor.name : rejection ? 'UnhandledRejection' : 'Error',\n                    value: \"Non-Error \" + (rejection ? 'promise rejection' : 'exception') + \" captured with keys: \" + extractExceptionKeysForMessage(exception),\n                },\n            ],\n        },\n        extra: {\n            __serialized__: normalizeToSize(exception),\n        },\n    };\n    if (syntheticException) {\n        var stacktrace = computeStackTrace(syntheticException);\n        var frames_1 = prepareFramesForEvent(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1,\n        };\n    }\n    return event;\n}\n/**\n * @hidden\n */\nexport function eventFromStacktrace(stacktrace) {\n    var exception = exceptionFromStacktrace(stacktrace);\n    return {\n        exception: {\n            values: [exception],\n        },\n    };\n}\n/**\n * @hidden\n */\nexport function prepareFramesForEvent(stack) {\n    if (!stack || !stack.length) {\n        return [];\n    }\n    var localStack = stack;\n    var firstFrameFunction = localStack[0].func || '';\n    var lastFrameFunction = localStack[localStack.length - 1].func || '';\n    // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n    if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {\n        localStack = localStack.slice(1);\n    }\n    // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n    if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {\n        localStack = localStack.slice(0, -1);\n    }\n    // The frame where the crash happened, should be the last entry in the array\n    return localStack\n        .slice(0, STACKTRACE_LIMIT)\n        .map(function (frame) { return ({\n        colno: frame.column === null ? undefined : frame.column,\n        filename: frame.url || localStack[0].url,\n        function: frame.func || '?',\n        in_app: true,\n        lineno: frame.line === null ? undefined : frame.line,\n    }); })\n        .reverse();\n}\n//# sourceMappingURL=parsers.js.map","import { __assign } from \"tslib\";\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, addExceptionTypeValue, isDOMError, isDOMException, isError, isErrorEvent, isEvent, isPlainObject, SyncPromise, } from '@sentry/utils';\nimport { eventFromPlainObject, eventFromStacktrace, prepareFramesForEvent } from './parsers';\nimport { computeStackTrace } from './tracekit';\n/**\n * Builds and Event from a Exception\n * @hidden\n */\nexport function eventFromException(options, exception, hint) {\n    var syntheticException = (hint && hint.syntheticException) || undefined;\n    var event = eventFromUnknownInput(exception, syntheticException, {\n        attachStacktrace: options.attachStacktrace,\n    });\n    addExceptionMechanism(event, {\n        handled: true,\n        type: 'generic',\n    });\n    event.level = Severity.Error;\n    if (hint && hint.event_id) {\n        event.event_id = hint.event_id;\n    }\n    return SyncPromise.resolve(event);\n}\n/**\n * Builds and Event from a Message\n * @hidden\n */\nexport function eventFromMessage(options, message, level, hint) {\n    if (level === void 0) { level = Severity.Info; }\n    var syntheticException = (hint && hint.syntheticException) || undefined;\n    var event = eventFromString(message, syntheticException, {\n        attachStacktrace: options.attachStacktrace,\n    });\n    event.level = level;\n    if (hint && hint.event_id) {\n        event.event_id = hint.event_id;\n    }\n    return SyncPromise.resolve(event);\n}\n/**\n * @hidden\n */\nexport function eventFromUnknownInput(exception, syntheticException, options) {\n    if (options === void 0) { options = {}; }\n    var event;\n    if (isErrorEvent(exception) && exception.error) {\n        // If it is an ErrorEvent with `error` property, extract it to get actual Error\n        var errorEvent = exception;\n        // eslint-disable-next-line no-param-reassign\n        exception = errorEvent.error;\n        event = eventFromStacktrace(computeStackTrace(exception));\n        return event;\n    }\n    if (isDOMError(exception) || isDOMException(exception)) {\n        // If it is a DOMError or DOMException (which are legacy APIs, but still supported in some browsers)\n        // then we just extract the name, code, and message, as they don't provide anything else\n        // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n        // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n        var domException = exception;\n        var name_1 = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n        var message = domException.message ? name_1 + \": \" + domException.message : name_1;\n        event = eventFromString(message, syntheticException, options);\n        addExceptionTypeValue(event, message);\n        if ('code' in domException) {\n            event.tags = __assign(__assign({}, event.tags), { 'DOMException.code': \"\" + domException.code });\n        }\n        return event;\n    }\n    if (isError(exception)) {\n        // we have a real Error object, do nothing\n        event = eventFromStacktrace(computeStackTrace(exception));\n        return event;\n    }\n    if (isPlainObject(exception) || isEvent(exception)) {\n        // If it is plain Object or Event, serialize it manually and extract options\n        // This will allow us to group events based on top-level keys\n        // which is much better than creating new group when any key/value change\n        var objectException = exception;\n        event = eventFromPlainObject(objectException, syntheticException, options.rejection);\n        addExceptionMechanism(event, {\n            synthetic: true,\n        });\n        return event;\n    }\n    // If none of previous checks were valid, then it means that it's not:\n    // - an instance of DOMError\n    // - an instance of DOMException\n    // - an instance of Event\n    // - an instance of Error\n    // - a valid ErrorEvent (one with an error property)\n    // - a plain Object\n    //\n    // So bail out and capture it as a simple message:\n    event = eventFromString(exception, syntheticException, options);\n    addExceptionTypeValue(event, \"\" + exception, undefined);\n    addExceptionMechanism(event, {\n        synthetic: true,\n    });\n    return event;\n}\n/**\n * @hidden\n */\nexport function eventFromString(input, syntheticException, options) {\n    if (options === void 0) { options = {}; }\n    var event = {\n        message: input,\n    };\n    if (options.attachStacktrace && syntheticException) {\n        var stacktrace = computeStackTrace(syntheticException);\n        var frames_1 = prepareFramesForEvent(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1,\n        };\n    }\n    return event;\n}\n//# sourceMappingURL=eventbuilder.js.map","import { __rest } from \"tslib\";\n/** Creates a SentryRequest from an event. */\nexport function sessionToSentryRequest(session, api) {\n    var envelopeHeaders = JSON.stringify({\n        sent_at: new Date().toISOString(),\n    });\n    var itemHeaders = JSON.stringify({\n        type: 'session',\n    });\n    return {\n        body: envelopeHeaders + \"\\n\" + itemHeaders + \"\\n\" + JSON.stringify(session),\n        type: 'session',\n        url: api.getEnvelopeEndpointWithUrlEncodedAuth(),\n    };\n}\n/** Creates a SentryRequest from an event. */\nexport function eventToSentryRequest(event, api) {\n    // since JS has no Object.prototype.pop()\n    var _a = event.tags || {}, samplingMethod = _a.__sentry_samplingMethod, sampleRate = _a.__sentry_sampleRate, otherTags = __rest(_a, [\"__sentry_samplingMethod\", \"__sentry_sampleRate\"]);\n    event.tags = otherTags;\n    var useEnvelope = event.type === 'transaction';\n    var req = {\n        body: JSON.stringify(event),\n        type: event.type || 'event',\n        url: useEnvelope ? api.getEnvelopeEndpointWithUrlEncodedAuth() : api.getStoreEndpointWithUrlEncodedAuth(),\n    };\n    // https://develop.sentry.dev/sdk/envelopes/\n    // Since we don't need to manipulate envelopes nor store them, there is no\n    // exported concept of an Envelope with operations including serialization and\n    // deserialization. Instead, we only implement a minimal subset of the spec to\n    // serialize events inline here.\n    if (useEnvelope) {\n        var envelopeHeaders = JSON.stringify({\n            event_id: event.event_id,\n            sent_at: new Date().toISOString(),\n        });\n        var itemHeaders = JSON.stringify({\n            type: event.type,\n            // TODO: Right now, sampleRate may or may not be defined (it won't be in the cases of inheritance and\n            // explicitly-set sampling decisions). Are we good with that?\n            sample_rates: [{ id: samplingMethod, rate: sampleRate }],\n        });\n        // The trailing newline is optional. We intentionally don't send it to avoid\n        // sending unnecessary bytes.\n        //\n        // const envelope = `${envelopeHeaders}\\n${itemHeaders}\\n${req.body}\\n`;\n        var envelope = envelopeHeaders + \"\\n\" + itemHeaders + \"\\n\" + req.body;\n        req.body = envelope;\n    }\n    return req;\n}\n//# sourceMappingURL=request.js.map","import { Dsn, urlEncode } from '@sentry/utils';\nvar SENTRY_API_VERSION = '7';\n/** Helper class to provide urls to different Sentry endpoints. */\nvar API = /** @class */ (function () {\n    /** Create a new instance of API */\n    function API(dsn) {\n        this.dsn = dsn;\n        this._dsnObject = new Dsn(dsn);\n    }\n    /** Returns the Dsn object. */\n    API.prototype.getDsn = function () {\n        return this._dsnObject;\n    };\n    /** Returns the prefix to construct Sentry ingestion API endpoints. */\n    API.prototype.getBaseApiEndpoint = function () {\n        var dsn = this._dsnObject;\n        var protocol = dsn.protocol ? dsn.protocol + \":\" : '';\n        var port = dsn.port ? \":\" + dsn.port : '';\n        return protocol + \"//\" + dsn.host + port + (dsn.path ? \"/\" + dsn.path : '') + \"/api/\";\n    };\n    /** Returns the store endpoint URL. */\n    API.prototype.getStoreEndpoint = function () {\n        return this._getIngestEndpoint('store');\n    };\n    /**\n     * Returns the store endpoint URL with auth in the query string.\n     *\n     * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n     */\n    API.prototype.getStoreEndpointWithUrlEncodedAuth = function () {\n        return this.getStoreEndpoint() + \"?\" + this._encodedAuth();\n    };\n    /**\n     * Returns the envelope endpoint URL with auth in the query string.\n     *\n     * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n     */\n    API.prototype.getEnvelopeEndpointWithUrlEncodedAuth = function () {\n        return this._getEnvelopeEndpoint() + \"?\" + this._encodedAuth();\n    };\n    /** Returns only the path component for the store endpoint. */\n    API.prototype.getStoreEndpointPath = function () {\n        var dsn = this._dsnObject;\n        return (dsn.path ? \"/\" + dsn.path : '') + \"/api/\" + dsn.projectId + \"/store/\";\n    };\n    /**\n     * Returns an object that can be used in request headers.\n     * This is needed for node and the old /store endpoint in sentry\n     */\n    API.prototype.getRequestHeaders = function (clientName, clientVersion) {\n        var dsn = this._dsnObject;\n        var header = [\"Sentry sentry_version=\" + SENTRY_API_VERSION];\n        header.push(\"sentry_client=\" + clientName + \"/\" + clientVersion);\n        header.push(\"sentry_key=\" + dsn.user);\n        if (dsn.pass) {\n            header.push(\"sentry_secret=\" + dsn.pass);\n        }\n        return {\n            'Content-Type': 'application/json',\n            'X-Sentry-Auth': header.join(', '),\n        };\n    };\n    /** Returns the url to the report dialog endpoint. */\n    API.prototype.getReportDialogEndpoint = function (dialogOptions) {\n        if (dialogOptions === void 0) { dialogOptions = {}; }\n        var dsn = this._dsnObject;\n        var endpoint = this.getBaseApiEndpoint() + \"embed/error-page/\";\n        var encodedOptions = [];\n        encodedOptions.push(\"dsn=\" + dsn.toString());\n        for (var key in dialogOptions) {\n            if (key === 'dsn') {\n                continue;\n            }\n            if (key === 'user') {\n                if (!dialogOptions.user) {\n                    continue;\n                }\n                if (dialogOptions.user.name) {\n                    encodedOptions.push(\"name=\" + encodeURIComponent(dialogOptions.user.name));\n                }\n                if (dialogOptions.user.email) {\n                    encodedOptions.push(\"email=\" + encodeURIComponent(dialogOptions.user.email));\n                }\n            }\n            else {\n                encodedOptions.push(encodeURIComponent(key) + \"=\" + encodeURIComponent(dialogOptions[key]));\n            }\n        }\n        if (encodedOptions.length) {\n            return endpoint + \"?\" + encodedOptions.join('&');\n        }\n        return endpoint;\n    };\n    /** Returns the envelope endpoint URL. */\n    API.prototype._getEnvelopeEndpoint = function () {\n        return this._getIngestEndpoint('envelope');\n    };\n    /** Returns the ingest API endpoint for target. */\n    API.prototype._getIngestEndpoint = function (target) {\n        var base = this.getBaseApiEndpoint();\n        var dsn = this._dsnObject;\n        return \"\" + base + dsn.projectId + \"/\" + target + \"/\";\n    };\n    /** Returns a URL-encoded string with auth config suitable for a query string. */\n    API.prototype._encodedAuth = function () {\n        var dsn = this._dsnObject;\n        var auth = {\n            // We send only the minimum set of required information. See\n            // https://github.com/getsentry/sentry-javascript/issues/2572.\n            sentry_key: dsn.user,\n            sentry_version: SENTRY_API_VERSION,\n        };\n        return urlEncode(auth);\n    };\n    return API;\n}());\nexport { API };\n//# sourceMappingURL=api.js.map","import { SentryError } from './error';\nimport { SyncPromise } from './syncpromise';\n/** A simple queue that holds promises. */\nvar PromiseBuffer = /** @class */ (function () {\n    function PromiseBuffer(_limit) {\n        this._limit = _limit;\n        /** Internal set of queued Promises */\n        this._buffer = [];\n    }\n    /**\n     * Says if the buffer is ready to take more requests\n     */\n    PromiseBuffer.prototype.isReady = function () {\n        return this._limit === undefined || this.length() < this._limit;\n    };\n    /**\n     * Add a promise to the queue.\n     *\n     * @param task Can be any PromiseLike<T>\n     * @returns The original promise.\n     */\n    PromiseBuffer.prototype.add = function (task) {\n        var _this = this;\n        if (!this.isReady()) {\n            return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));\n        }\n        if (this._buffer.indexOf(task) === -1) {\n            this._buffer.push(task);\n        }\n        task\n            .then(function () { return _this.remove(task); })\n            .then(null, function () {\n            return _this.remove(task).then(null, function () {\n                // We have to add this catch here otherwise we have an unhandledPromiseRejection\n                // because it's a new Promise chain.\n            });\n        });\n        return task;\n    };\n    /**\n     * Remove a promise to the queue.\n     *\n     * @param task Can be any PromiseLike<T>\n     * @returns Removed promise.\n     */\n    PromiseBuffer.prototype.remove = function (task) {\n        var removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];\n        return removedTask;\n    };\n    /**\n     * This function returns the number of unresolved promises in the queue.\n     */\n    PromiseBuffer.prototype.length = function () {\n        return this._buffer.length;\n    };\n    /**\n     * This will drain the whole queue, returns true if queue is empty or drained.\n     * If timeout is provided and the queue takes longer to drain, the promise still resolves but with false.\n     *\n     * @param timeout Number in ms to wait until it resolves with false.\n     */\n    PromiseBuffer.prototype.drain = function (timeout) {\n        var _this = this;\n        return new SyncPromise(function (resolve) {\n            var capturedSetTimeout = setTimeout(function () {\n                if (timeout && timeout > 0) {\n                    resolve(false);\n                }\n            }, timeout);\n            SyncPromise.all(_this._buffer)\n                .then(function () {\n                clearTimeout(capturedSetTimeout);\n                resolve(true);\n            })\n                .then(null, function () {\n                resolve(true);\n            });\n        });\n    };\n    return PromiseBuffer;\n}());\nexport { PromiseBuffer };\n//# sourceMappingURL=promisebuffer.js.map","import { __values } from \"tslib\";\nimport { API } from '@sentry/core';\nimport { Status, } from '@sentry/types';\nimport { logger, parseRetryAfterHeader, PromiseBuffer, SentryError } from '@sentry/utils';\n/** Base Transport class implementation */\nvar BaseTransport = /** @class */ (function () {\n    function BaseTransport(options) {\n        this.options = options;\n        /** A simple buffer holding all requests. */\n        this._buffer = new PromiseBuffer(30);\n        /** Locks transport after receiving rate limits in a response */\n        this._rateLimits = {};\n        this._api = new API(this.options.dsn);\n        // eslint-disable-next-line deprecation/deprecation\n        this.url = this._api.getStoreEndpointWithUrlEncodedAuth();\n    }\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.sendEvent = function (_) {\n        throw new SentryError('Transport Class has to implement `sendEvent` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.close = function (timeout) {\n        return this._buffer.drain(timeout);\n    };\n    /**\n     * Handle Sentry repsonse for promise-based transports.\n     */\n    BaseTransport.prototype._handleResponse = function (_a) {\n        var requestType = _a.requestType, response = _a.response, headers = _a.headers, resolve = _a.resolve, reject = _a.reject;\n        var status = Status.fromHttpCode(response.status);\n        /**\n         * \"The name is case-insensitive.\"\n         * https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n         */\n        var limited = this._handleRateLimit(headers);\n        if (limited)\n            logger.warn(\"Too many requests, backing off until: \" + this._disabledUntil(requestType));\n        if (status === Status.Success) {\n            resolve({ status: status });\n            return;\n        }\n        reject(response);\n    };\n    /**\n     * Gets the time that given category is disabled until for rate limiting\n     */\n    BaseTransport.prototype._disabledUntil = function (category) {\n        return this._rateLimits[category] || this._rateLimits.all;\n    };\n    /**\n     * Checks if a category is rate limited\n     */\n    BaseTransport.prototype._isRateLimited = function (category) {\n        return this._disabledUntil(category) > new Date(Date.now());\n    };\n    /**\n     * Sets internal _rateLimits from incoming headers. Returns true if headers contains a non-empty rate limiting header.\n     */\n    BaseTransport.prototype._handleRateLimit = function (headers) {\n        var e_1, _a, e_2, _b;\n        var now = Date.now();\n        var rlHeader = headers['x-sentry-rate-limits'];\n        var raHeader = headers['retry-after'];\n        if (rlHeader) {\n            try {\n                // rate limit headers are of the form\n                //     <header>,<header>,..\n                // where each <header> is of the form\n                //     <retry_after>: <categories>: <scope>: <reason_code>\n                // where\n                //     <retry_after> is a delay in ms\n                //     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form\n                //         <category>;<category>;...\n                //     <scope> is what's being limited (org, project, or key) - ignored by SDK\n                //     <reason_code> is an arbitrary string like \"org_quota\" - ignored by SDK\n                for (var _c = __values(rlHeader.trim().split(',')), _d = _c.next(); !_d.done; _d = _c.next()) {\n                    var limit = _d.value;\n                    var parameters = limit.split(':', 2);\n                    var headerDelay = parseInt(parameters[0], 10);\n                    var delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n                    try {\n                        for (var _e = (e_2 = void 0, __values(parameters[1].split(';'))), _f = _e.next(); !_f.done; _f = _e.next()) {\n                            var category = _f.value;\n                            this._rateLimits[category || 'all'] = new Date(now + delay);\n                        }\n                    }\n                    catch (e_2_1) { e_2 = { error: e_2_1 }; }\n                    finally {\n                        try {\n                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);\n                        }\n                        finally { if (e_2) throw e_2.error; }\n                    }\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n            return true;\n        }\n        else if (raHeader) {\n            this._rateLimits.all = new Date(now + parseRetryAfterHeader(now, raHeader));\n            return true;\n        }\n        return false;\n    };\n    return BaseTransport;\n}());\nexport { BaseTransport };\n//# sourceMappingURL=base.js.map","import { __extends } from \"tslib\";\nimport { eventToSentryRequest, sessionToSentryRequest } from '@sentry/core';\nimport { getGlobalObject, supportsReferrerPolicy, SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\nvar global = getGlobalObject();\n/** `fetch` based transport */\nvar FetchTransport = /** @class */ (function (_super) {\n    __extends(FetchTransport, _super);\n    function FetchTransport() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendEvent = function (event) {\n        return this._sendRequest(eventToSentryRequest(event, this._api), event);\n    };\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendSession = function (session) {\n        return this._sendRequest(sessionToSentryRequest(session, this._api), session);\n    };\n    /**\n     * @param sentryRequest Prepared SentryRequest to be delivered\n     * @param originalPayload Original payload used to create SentryRequest\n     */\n    FetchTransport.prototype._sendRequest = function (sentryRequest, originalPayload) {\n        var _this = this;\n        if (this._isRateLimited(sentryRequest.type)) {\n            return Promise.reject({\n                event: originalPayload,\n                type: sentryRequest.type,\n                reason: \"Transport locked till \" + this._disabledUntil(sentryRequest.type) + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        var options = {\n            body: sentryRequest.body,\n            method: 'POST',\n            // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default\n            // https://caniuse.com/#feat=referrer-policy\n            // It doesn't. And it throw exception instead of ignoring this parameter...\n            // REF: https://github.com/getsentry/raven-js/issues/1233\n            referrerPolicy: (supportsReferrerPolicy() ? 'origin' : ''),\n        };\n        if (this.options.fetchParameters !== undefined) {\n            Object.assign(options, this.options.fetchParameters);\n        }\n        if (this.options.headers !== undefined) {\n            options.headers = this.options.headers;\n        }\n        return this._buffer.add(new SyncPromise(function (resolve, reject) {\n            global\n                .fetch(sentryRequest.url, options)\n                .then(function (response) {\n                var headers = {\n                    'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n                    'retry-after': response.headers.get('Retry-After'),\n                };\n                _this._handleResponse({\n                    requestType: sentryRequest.type,\n                    response: response,\n                    headers: headers,\n                    resolve: resolve,\n                    reject: reject,\n                });\n            })\n                .catch(reject);\n        }));\n    };\n    return FetchTransport;\n}(BaseTransport));\nexport { FetchTransport };\n//# sourceMappingURL=fetch.js.map","import { __extends } from \"tslib\";\nimport { eventToSentryRequest, sessionToSentryRequest } from '@sentry/core';\nimport { SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\n/** `XHR` based transport */\nvar XHRTransport = /** @class */ (function (_super) {\n    __extends(XHRTransport, _super);\n    function XHRTransport() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendEvent = function (event) {\n        return this._sendRequest(eventToSentryRequest(event, this._api), event);\n    };\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendSession = function (session) {\n        return this._sendRequest(sessionToSentryRequest(session, this._api), session);\n    };\n    /**\n     * @param sentryRequest Prepared SentryRequest to be delivered\n     * @param originalPayload Original payload used to create SentryRequest\n     */\n    XHRTransport.prototype._sendRequest = function (sentryRequest, originalPayload) {\n        var _this = this;\n        if (this._isRateLimited(sentryRequest.type)) {\n            return Promise.reject({\n                event: originalPayload,\n                type: sentryRequest.type,\n                reason: \"Transport locked till \" + this._disabledUntil(sentryRequest.type) + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        return this._buffer.add(new SyncPromise(function (resolve, reject) {\n            var request = new XMLHttpRequest();\n            request.onreadystatechange = function () {\n                if (request.readyState === 4) {\n                    var headers = {\n                        'x-sentry-rate-limits': request.getResponseHeader('X-Sentry-Rate-Limits'),\n                        'retry-after': request.getResponseHeader('Retry-After'),\n                    };\n                    _this._handleResponse({ requestType: sentryRequest.type, response: request, headers: headers, resolve: resolve, reject: reject });\n                }\n            };\n            request.open('POST', sentryRequest.url);\n            for (var header in _this.options.headers) {\n                if (_this.options.headers.hasOwnProperty(header)) {\n                    request.setRequestHeader(header, _this.options.headers[header]);\n                }\n            }\n            request.send(sentryRequest.body);\n        }));\n    };\n    return XHRTransport;\n}(BaseTransport));\nexport { XHRTransport };\n//# sourceMappingURL=xhr.js.map","import { __assign, __extends } from \"tslib\";\nimport { BaseBackend } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { supportsFetch } from '@sentry/utils';\nimport { eventFromException, eventFromMessage } from './eventbuilder';\nimport { FetchTransport, XHRTransport } from './transports';\n/**\n * The Sentry Browser SDK Backend.\n * @hidden\n */\nvar BrowserBackend = /** @class */ (function (_super) {\n    __extends(BrowserBackend, _super);\n    function BrowserBackend() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromException = function (exception, hint) {\n        return eventFromException(this._options, exception, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromMessage = function (message, level, hint) {\n        if (level === void 0) { level = Severity.Info; }\n        return eventFromMessage(this._options, message, level, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype._setupTransport = function () {\n        if (!this._options.dsn) {\n            // We return the noop transport here in case there is no Dsn.\n            return _super.prototype._setupTransport.call(this);\n        }\n        var transportOptions = __assign(__assign({}, this._options.transportOptions), { dsn: this._options.dsn });\n        if (this._options.transport) {\n            return new this._options.transport(transportOptions);\n        }\n        if (supportsFetch()) {\n            return new FetchTransport(transportOptions);\n        }\n        return new XHRTransport(transportOptions);\n    };\n    return BrowserBackend;\n}(BaseBackend));\nexport { BrowserBackend };\n//# sourceMappingURL=backend.js.map","import { __assign } from \"tslib\";\nimport { API, captureException, withScope } from '@sentry/core';\nimport { addExceptionMechanism, addExceptionTypeValue, logger } from '@sentry/utils';\nvar ignoreOnError = 0;\n/**\n * @hidden\n */\nexport function shouldIgnoreOnError() {\n    return ignoreOnError > 0;\n}\n/**\n * @hidden\n */\nexport function ignoreNextOnError() {\n    // onerror should trigger before setTimeout\n    ignoreOnError += 1;\n    setTimeout(function () {\n        ignoreOnError -= 1;\n    });\n}\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap.\n * @returns The wrapped function.\n * @hidden\n */\nexport function wrap(fn, options, before) {\n    if (options === void 0) { options = {}; }\n    if (typeof fn !== 'function') {\n        return fn;\n    }\n    try {\n        // We don't wanna wrap it twice\n        if (fn.__sentry__) {\n            return fn;\n        }\n        // If this has already been wrapped in the past, return that wrapped function\n        if (fn.__sentry_wrapped__) {\n            return fn.__sentry_wrapped__;\n        }\n    }\n    catch (e) {\n        // Just accessing custom props in some Selenium environments\n        // can cause a \"Permission denied\" exception (see raven-js#495).\n        // Bail on wrapping and return the function as-is (defers to window.onerror).\n        return fn;\n    }\n    /* eslint-disable prefer-rest-params */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var sentryWrapped = function () {\n        var args = Array.prototype.slice.call(arguments);\n        try {\n            if (before && typeof before === 'function') {\n                before.apply(this, arguments);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n            var wrappedArguments = args.map(function (arg) { return wrap(arg, options); });\n            if (fn.handleEvent) {\n                // Attempt to invoke user-land function\n                // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n                //       means the sentry.javascript SDK caught an error invoking your application code. This\n                //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                return fn.handleEvent.apply(this, wrappedArguments);\n            }\n            // Attempt to invoke user-land function\n            // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n            //       means the sentry.javascript SDK caught an error invoking your application code. This\n            //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n            return fn.apply(this, wrappedArguments);\n        }\n        catch (ex) {\n            ignoreNextOnError();\n            withScope(function (scope) {\n                scope.addEventProcessor(function (event) {\n                    var processedEvent = __assign({}, event);\n                    if (options.mechanism) {\n                        addExceptionTypeValue(processedEvent, undefined, undefined);\n                        addExceptionMechanism(processedEvent, options.mechanism);\n                    }\n                    processedEvent.extra = __assign(__assign({}, processedEvent.extra), { arguments: args });\n                    return processedEvent;\n                });\n                captureException(ex);\n            });\n            throw ex;\n        }\n    };\n    /* eslint-enable prefer-rest-params */\n    // Accessing some objects may throw\n    // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n    try {\n        for (var property in fn) {\n            if (Object.prototype.hasOwnProperty.call(fn, property)) {\n                sentryWrapped[property] = fn[property];\n            }\n        }\n    }\n    catch (_oO) { } // eslint-disable-line no-empty\n    fn.prototype = fn.prototype || {};\n    sentryWrapped.prototype = fn.prototype;\n    Object.defineProperty(fn, '__sentry_wrapped__', {\n        enumerable: false,\n        value: sentryWrapped,\n    });\n    // Signal that this function has been wrapped/filled already\n    // for both debugging and to prevent it to being wrapped/filled twice\n    Object.defineProperties(sentryWrapped, {\n        __sentry__: {\n            enumerable: false,\n            value: true,\n        },\n        __sentry_original__: {\n            enumerable: false,\n            value: fn,\n        },\n    });\n    // Restore original function name (not all browsers allow that)\n    try {\n        var descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name');\n        if (descriptor.configurable) {\n            Object.defineProperty(sentryWrapped, 'name', {\n                get: function () {\n                    return fn.name;\n                },\n            });\n        }\n        // eslint-disable-next-line no-empty\n    }\n    catch (_oO) { }\n    return sentryWrapped;\n}\n/**\n * Injects the Report Dialog script\n * @hidden\n */\nexport function injectReportDialog(options) {\n    if (options === void 0) { options = {}; }\n    if (!options.eventId) {\n        logger.error(\"Missing eventId option in showReportDialog call\");\n        return;\n    }\n    if (!options.dsn) {\n        logger.error(\"Missing dsn option in showReportDialog call\");\n        return;\n    }\n    var script = document.createElement('script');\n    script.async = true;\n    script.src = new API(options.dsn).getReportDialogEndpoint(options);\n    if (options.onLoad) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        script.onload = options.onLoad;\n    }\n    (document.head || document.body).appendChild(script);\n}\n//# sourceMappingURL=helpers.js.map","import { __assign, __values } from \"tslib\";\nimport { isInstanceOf, isString } from './is';\nimport { logger } from './logger';\nimport { getGlobalObject } from './misc';\nimport { fill } from './object';\nimport { getFunctionName } from './stacktrace';\nimport { supportsHistory, supportsNativeFetch } from './supports';\nvar global = getGlobalObject();\n/**\n * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.\n *  - Console API\n *  - Fetch API\n *  - XHR API\n *  - History API\n *  - DOM API (click/typing)\n *  - Error API\n *  - UnhandledRejection API\n */\nvar handlers = {};\nvar instrumented = {};\n/** Instruments given API */\nfunction instrument(type) {\n    if (instrumented[type]) {\n        return;\n    }\n    instrumented[type] = true;\n    switch (type) {\n        case 'console':\n            instrumentConsole();\n            break;\n        case 'dom':\n            instrumentDOM();\n            break;\n        case 'xhr':\n            instrumentXHR();\n            break;\n        case 'fetch':\n            instrumentFetch();\n            break;\n        case 'history':\n            instrumentHistory();\n            break;\n        case 'error':\n            instrumentError();\n            break;\n        case 'unhandledrejection':\n            instrumentUnhandledRejection();\n            break;\n        default:\n            logger.warn('unknown instrumentation type:', type);\n    }\n}\n/**\n * Add handler that will be called when given type of instrumentation triggers.\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addInstrumentationHandler(handler) {\n    if (!handler || typeof handler.type !== 'string' || typeof handler.callback !== 'function') {\n        return;\n    }\n    handlers[handler.type] = handlers[handler.type] || [];\n    handlers[handler.type].push(handler.callback);\n    instrument(handler.type);\n}\n/** JSDoc */\nfunction triggerHandlers(type, data) {\n    var e_1, _a;\n    if (!type || !handlers[type]) {\n        return;\n    }\n    try {\n        for (var _b = __values(handlers[type] || []), _c = _b.next(); !_c.done; _c = _b.next()) {\n            var handler = _c.value;\n            try {\n                handler(data);\n            }\n            catch (e) {\n                logger.error(\"Error while triggering instrumentation handler.\\nType: \" + type + \"\\nName: \" + getFunctionName(handler) + \"\\nError: \" + e);\n            }\n        }\n    }\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n    finally {\n        try {\n            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n        }\n        finally { if (e_1) throw e_1.error; }\n    }\n}\n/** JSDoc */\nfunction instrumentConsole() {\n    if (!('console' in global)) {\n        return;\n    }\n    ['debug', 'info', 'warn', 'error', 'log', 'assert'].forEach(function (level) {\n        if (!(level in global.console)) {\n            return;\n        }\n        fill(global.console, level, function (originalConsoleLevel) {\n            return function () {\n                var args = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    args[_i] = arguments[_i];\n                }\n                triggerHandlers('console', { args: args, level: level });\n                // this fails for some browsers. :(\n                if (originalConsoleLevel) {\n                    Function.prototype.apply.call(originalConsoleLevel, global.console, args);\n                }\n            };\n        });\n    });\n}\n/** JSDoc */\nfunction instrumentFetch() {\n    if (!supportsNativeFetch()) {\n        return;\n    }\n    fill(global, 'fetch', function (originalFetch) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var handlerData = {\n                args: args,\n                fetchData: {\n                    method: getFetchMethod(args),\n                    url: getFetchUrl(args),\n                },\n                startTimestamp: Date.now(),\n            };\n            triggerHandlers('fetch', __assign({}, handlerData));\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            return originalFetch.apply(global, args).then(function (response) {\n                triggerHandlers('fetch', __assign(__assign({}, handlerData), { endTimestamp: Date.now(), response: response }));\n                return response;\n            }, function (error) {\n                triggerHandlers('fetch', __assign(__assign({}, handlerData), { endTimestamp: Date.now(), error: error }));\n                // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n                //       it means the sentry.javascript SDK caught an error invoking your application code.\n                //       This is expected behavior and NOT indicative of a bug with sentry.javascript.\n                throw error;\n            });\n        };\n    });\n}\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs) {\n    if (fetchArgs === void 0) { fetchArgs = []; }\n    if ('Request' in global && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {\n        return String(fetchArgs[0].method).toUpperCase();\n    }\n    if (fetchArgs[1] && fetchArgs[1].method) {\n        return String(fetchArgs[1].method).toUpperCase();\n    }\n    return 'GET';\n}\n/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs) {\n    if (fetchArgs === void 0) { fetchArgs = []; }\n    if (typeof fetchArgs[0] === 'string') {\n        return fetchArgs[0];\n    }\n    if ('Request' in global && isInstanceOf(fetchArgs[0], Request)) {\n        return fetchArgs[0].url;\n    }\n    return String(fetchArgs[0]);\n}\n/* eslint-enable @typescript-eslint/no-unsafe-member-access */\n/** JSDoc */\nfunction instrumentXHR() {\n    if (!('XMLHttpRequest' in global)) {\n        return;\n    }\n    // Poor man's implementation of ES6 `Map`, tracking and keeping in sync key and value separately.\n    var requestKeys = [];\n    var requestValues = [];\n    var xhrproto = XMLHttpRequest.prototype;\n    fill(xhrproto, 'open', function (originalOpen) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            // eslint-disable-next-line @typescript-eslint/no-this-alias\n            var xhr = this;\n            var url = args[1];\n            xhr.__sentry_xhr__ = {\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n                url: args[1],\n            };\n            // if Sentry key appears in URL, don't capture it as a request\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            if (isString(url) && xhr.__sentry_xhr__.method === 'POST' && url.match(/sentry_key/)) {\n                xhr.__sentry_own_request__ = true;\n            }\n            var onreadystatechangeHandler = function () {\n                if (xhr.readyState === 4) {\n                    try {\n                        // touching statusCode in some platforms throws\n                        // an exception\n                        if (xhr.__sentry_xhr__) {\n                            xhr.__sentry_xhr__.status_code = xhr.status;\n                        }\n                    }\n                    catch (e) {\n                        /* do nothing */\n                    }\n                    try {\n                        var requestPos = requestKeys.indexOf(xhr);\n                        if (requestPos !== -1) {\n                            // Make sure to pop both key and value to keep it in sync.\n                            requestKeys.splice(requestPos);\n                            var args_1 = requestValues.splice(requestPos)[0];\n                            if (xhr.__sentry_xhr__ && args_1[0] !== undefined) {\n                                xhr.__sentry_xhr__.body = args_1[0];\n                            }\n                        }\n                    }\n                    catch (e) {\n                        /* do nothing */\n                    }\n                    triggerHandlers('xhr', {\n                        args: args,\n                        endTimestamp: Date.now(),\n                        startTimestamp: Date.now(),\n                        xhr: xhr,\n                    });\n                }\n            };\n            if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n                fill(xhr, 'onreadystatechange', function (original) {\n                    return function () {\n                        var readyStateArgs = [];\n                        for (var _i = 0; _i < arguments.length; _i++) {\n                            readyStateArgs[_i] = arguments[_i];\n                        }\n                        onreadystatechangeHandler();\n                        return original.apply(xhr, readyStateArgs);\n                    };\n                });\n            }\n            else {\n                xhr.addEventListener('readystatechange', onreadystatechangeHandler);\n            }\n            return originalOpen.apply(xhr, args);\n        };\n    });\n    fill(xhrproto, 'send', function (originalSend) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            requestKeys.push(this);\n            requestValues.push(args);\n            triggerHandlers('xhr', {\n                args: args,\n                startTimestamp: Date.now(),\n                xhr: this,\n            });\n            return originalSend.apply(this, args);\n        };\n    });\n}\nvar lastHref;\n/** JSDoc */\nfunction instrumentHistory() {\n    if (!supportsHistory()) {\n        return;\n    }\n    var oldOnPopState = global.onpopstate;\n    global.onpopstate = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var to = global.location.href;\n        // keep track of the current URL state, as we always receive only the updated state\n        var from = lastHref;\n        lastHref = to;\n        triggerHandlers('history', {\n            from: from,\n            to: to,\n        });\n        if (oldOnPopState) {\n            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        /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n        var proto = global[target] && global[target].prototype;\n        // eslint-disable-next-line no-prototype-builtins\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\n        /* eslint-enable @typescript-eslint/no-unsafe-member-access */\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                try {\n                    original.call(this, eventName, fn.__sentry_wrapped__, options);\n                }\n                catch (e) {\n                    // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n                }\n                return original.call(this, eventName, fn, 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            // eslint-disable-next-line prefer-rest-params\n            return _oldOnErrorHandler.apply(this, arguments);\n        }\n        return false;\n    };\n}\nvar _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection() {\n    _oldOnUnhandledRejectionHandler = global.onunhandledrejection;\n    global.onunhandledrejection = function (e) {\n        triggerHandlers('unhandledrejection', e);\n        if (_oldOnUnhandledRejectionHandler) {\n            // eslint-disable-next-line prefer-rest-params\n            return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n        }\n        return true;\n    };\n}\n//# sourceMappingURL=instrument.js.map","import { __assign, __read, __spread } from \"tslib\";\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable max-lines */\nimport { getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addInstrumentationHandler, getEventDescription, getGlobalObject, htmlTreeAsString, parseUrl, safeJoin, } from '@sentry/utils';\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nvar Breadcrumbs = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function Breadcrumbs(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = Breadcrumbs.id;\n        this._options = __assign({ console: true, dom: true, fetch: true, history: true, sentry: true, xhr: true }, options);\n    }\n    /**\n     * Create a breadcrumb of `sentry` from the events themselves\n     */\n    Breadcrumbs.prototype.addSentryBreadcrumb = function (event) {\n        if (!this._options.sentry) {\n            return;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: \"sentry.\" + (event.type === 'transaction' ? 'transaction' : 'event'),\n            event_id: event.event_id,\n            level: event.level,\n            message: getEventDescription(event),\n        }, {\n            event: event,\n        });\n    };\n    /**\n     * Instrument browser built-ins w/ breadcrumb capturing\n     *  - Console API\n     *  - DOM API (click/typing)\n     *  - XMLHttpRequest API\n     *  - Fetch API\n     *  - History API\n     */\n    Breadcrumbs.prototype.setupOnce = function () {\n        var _this = this;\n        if (this._options.console) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._consoleBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'console',\n            });\n        }\n        if (this._options.dom) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._domBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'dom',\n            });\n        }\n        if (this._options.xhr) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._xhrBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'xhr',\n            });\n        }\n        if (this._options.fetch) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._fetchBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'fetch',\n            });\n        }\n        if (this._options.history) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._historyBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'history',\n            });\n        }\n    };\n    /**\n     * Creates breadcrumbs from console API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._consoleBreadcrumb = function (handlerData) {\n        var breadcrumb = {\n            category: 'console',\n            data: {\n                arguments: handlerData.args,\n                logger: 'console',\n            },\n            level: Severity.fromString(handlerData.level),\n            message: safeJoin(handlerData.args, ' '),\n        };\n        if (handlerData.level === 'assert') {\n            if (handlerData.args[0] === false) {\n                breadcrumb.message = \"Assertion failed: \" + (safeJoin(handlerData.args.slice(1), ' ') || 'console.assert');\n                breadcrumb.data.arguments = handlerData.args.slice(1);\n            }\n            else {\n                // Don't capture a breadcrumb for passed assertions\n                return;\n            }\n        }\n        getCurrentHub().addBreadcrumb(breadcrumb, {\n            input: handlerData.args,\n            level: handlerData.level,\n        });\n    };\n    /**\n     * Creates breadcrumbs from DOM API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._domBreadcrumb = function (handlerData) {\n        var target;\n        // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n        try {\n            target = handlerData.event.target\n                ? htmlTreeAsString(handlerData.event.target)\n                : htmlTreeAsString(handlerData.event);\n        }\n        catch (e) {\n            target = '<unknown>';\n        }\n        if (target.length === 0) {\n            return;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: \"ui.\" + handlerData.name,\n            message: target,\n        }, {\n            event: handlerData.event,\n            name: handlerData.name,\n        });\n    };\n    /**\n     * Creates breadcrumbs from XHR API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._xhrBreadcrumb = function (handlerData) {\n        if (handlerData.endTimestamp) {\n            // We only capture complete, non-sentry requests\n            if (handlerData.xhr.__sentry_own_request__) {\n                return;\n            }\n            var _a = handlerData.xhr.__sentry_xhr__ || {}, method = _a.method, url = _a.url, status_code = _a.status_code, body = _a.body;\n            getCurrentHub().addBreadcrumb({\n                category: 'xhr',\n                data: {\n                    method: method,\n                    url: url,\n                    status_code: status_code,\n                },\n                type: 'http',\n            }, {\n                xhr: handlerData.xhr,\n                input: body,\n            });\n            return;\n        }\n    };\n    /**\n     * Creates breadcrumbs from fetch API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._fetchBreadcrumb = function (handlerData) {\n        // We only capture complete fetch requests\n        if (!handlerData.endTimestamp) {\n            return;\n        }\n        if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {\n            // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)\n            return;\n        }\n        if (handlerData.error) {\n            getCurrentHub().addBreadcrumb({\n                category: 'fetch',\n                data: handlerData.fetchData,\n                level: Severity.Error,\n                type: 'http',\n            }, {\n                data: handlerData.error,\n                input: handlerData.args,\n            });\n        }\n        else {\n            getCurrentHub().addBreadcrumb({\n                category: 'fetch',\n                data: __assign(__assign({}, handlerData.fetchData), { status_code: handlerData.response.status }),\n                type: 'http',\n            }, {\n                input: handlerData.args,\n                response: handlerData.response,\n            });\n        }\n    };\n    /**\n     * Creates breadcrumbs from history API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._historyBreadcrumb = function (handlerData) {\n        var global = getGlobalObject();\n        var from = handlerData.from;\n        var to = handlerData.to;\n        var parsedLoc = parseUrl(global.location.href);\n        var parsedFrom = parseUrl(from);\n        var parsedTo = parseUrl(to);\n        // Initial pushState doesn't provide `from` information\n        if (!parsedFrom.path) {\n            parsedFrom = parsedLoc;\n        }\n        // Use only the path component of the URL if the URL matches the current\n        // document (almost all the time when using pushState)\n        if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n            to = parsedTo.relative;\n        }\n        if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n            from = parsedFrom.relative;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: 'navigation',\n            data: {\n                from: from,\n                to: to,\n            },\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    Breadcrumbs.id = 'Breadcrumbs';\n    return Breadcrumbs;\n}());\nexport { Breadcrumbs };\n//# sourceMappingURL=breadcrumbs.js.map","export var SDK_NAME = 'sentry.javascript.browser';\nexport var SDK_VERSION = '5.30.0';\n//# sourceMappingURL=version.js.map","import { __assign, __extends, __read, __spread } from \"tslib\";\nimport { BaseClient } from '@sentry/core';\nimport { getGlobalObject, logger } from '@sentry/utils';\nimport { BrowserBackend } from './backend';\nimport { injectReportDialog } from './helpers';\nimport { Breadcrumbs } from './integrations';\nimport { SDK_NAME, SDK_VERSION } from './version';\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nvar BrowserClient = /** @class */ (function (_super) {\n    __extends(BrowserClient, _super);\n    /**\n     * Creates a new Browser SDK instance.\n     *\n     * @param options Configuration options for this SDK.\n     */\n    function BrowserClient(options) {\n        if (options === void 0) { options = {}; }\n        return _super.call(this, BrowserBackend, options) || this;\n    }\n    /**\n     * Show a report dialog to the user to send feedback to a specific event.\n     *\n     * @param options Set individual options for the dialog\n     */\n    BrowserClient.prototype.showReportDialog = function (options) {\n        if (options === void 0) { options = {}; }\n        // doesn't work without a document (React Native)\n        var document = getGlobalObject().document;\n        if (!document) {\n            return;\n        }\n        if (!this._isEnabled()) {\n            logger.error('Trying to call showReportDialog with Sentry Client disabled');\n            return;\n        }\n        injectReportDialog(__assign(__assign({}, options), { dsn: options.dsn || this.getDsn() }));\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._prepareEvent = function (event, scope, hint) {\n        event.platform = event.platform || 'javascript';\n        event.sdk = __assign(__assign({}, event.sdk), { name: SDK_NAME, packages: __spread(((event.sdk && event.sdk.packages) || []), [\n                {\n                    name: 'npm:@sentry/browser',\n                    version: SDK_VERSION,\n                },\n            ]), version: SDK_VERSION });\n        return _super.prototype._prepareEvent.call(this, event, scope, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._sendEvent = function (event) {\n        var integration = this.getIntegration(Breadcrumbs);\n        if (integration) {\n            integration.addSentryBreadcrumb(event);\n        }\n        _super.prototype._sendEvent.call(this, event);\n    };\n    return BrowserClient;\n}(BaseClient));\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map","import { __assign } from \"tslib\";\nimport { fill, getFunctionName, getGlobalObject } from '@sentry/utils';\nimport { wrap } from '../helpers';\nvar DEFAULT_EVENT_TARGET = [\n    'EventTarget',\n    'Window',\n    'Node',\n    'ApplicationCache',\n    'AudioTrackList',\n    'ChannelMergerNode',\n    'CryptoOperation',\n    'EventSource',\n    'FileReader',\n    'HTMLUnknownElement',\n    'IDBDatabase',\n    'IDBRequest',\n    'IDBTransaction',\n    'KeyOperation',\n    'MediaController',\n    'MessagePort',\n    'ModalWindow',\n    'Notification',\n    'SVGElementInstance',\n    'Screen',\n    'TextTrack',\n    'TextTrackCue',\n    'TextTrackList',\n    'WebSocket',\n    'WebSocketWorker',\n    'Worker',\n    'XMLHttpRequest',\n    'XMLHttpRequestEventTarget',\n    'XMLHttpRequestUpload',\n];\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\nvar TryCatch = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function TryCatch(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = TryCatch.id;\n        this._options = __assign({ XMLHttpRequest: true, eventTarget: true, requestAnimationFrame: true, setInterval: true, setTimeout: true }, options);\n    }\n    /**\n     * Wrap timer functions and event targets to catch errors\n     * and provide better metadata.\n     */\n    TryCatch.prototype.setupOnce = function () {\n        var global = getGlobalObject();\n        if (this._options.setTimeout) {\n            fill(global, 'setTimeout', this._wrapTimeFunction.bind(this));\n        }\n        if (this._options.setInterval) {\n            fill(global, 'setInterval', this._wrapTimeFunction.bind(this));\n        }\n        if (this._options.requestAnimationFrame) {\n            fill(global, 'requestAnimationFrame', this._wrapRAF.bind(this));\n        }\n        if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {\n            fill(XMLHttpRequest.prototype, 'send', this._wrapXHR.bind(this));\n        }\n        if (this._options.eventTarget) {\n            var eventTarget = Array.isArray(this._options.eventTarget) ? this._options.eventTarget : DEFAULT_EVENT_TARGET;\n            eventTarget.forEach(this._wrapEventTarget.bind(this));\n        }\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapTimeFunction = function (original) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var originalCallback = args[0];\n            args[0] = wrap(originalCallback, {\n                mechanism: {\n                    data: { function: getFunctionName(original) },\n                    handled: true,\n                    type: 'instrument',\n                },\n            });\n            return original.apply(this, args);\n        };\n    };\n    /** JSDoc */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    TryCatch.prototype._wrapRAF = function (original) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function (callback) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            return original.call(this, wrap(callback, {\n                mechanism: {\n                    data: {\n                        function: 'requestAnimationFrame',\n                        handler: getFunctionName(original),\n                    },\n                    handled: true,\n                    type: 'instrument',\n                },\n            }));\n        };\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapEventTarget = function (target) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        var global = getGlobalObject();\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        var proto = global[target] && global[target].prototype;\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\n        fill(proto, 'addEventListener', function (original) {\n            return function (eventName, fn, options) {\n                try {\n                    if (typeof fn.handleEvent === 'function') {\n                        fn.handleEvent = wrap(fn.handleEvent.bind(fn), {\n                            mechanism: {\n                                data: {\n                                    function: 'handleEvent',\n                                    handler: getFunctionName(fn),\n                                    target: target,\n                                },\n                                handled: true,\n                                type: 'instrument',\n                            },\n                        });\n                    }\n                }\n                catch (err) {\n                    // can sometimes get 'Permission denied to access property \"handle Event'\n                }\n                return original.call(this, eventName, \n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                wrap(fn, {\n                    mechanism: {\n                        data: {\n                            function: 'addEventListener',\n                            handler: getFunctionName(fn),\n                            target: target,\n                        },\n                        handled: true,\n                        type: 'instrument',\n                    },\n                }), options);\n            };\n        });\n        fill(proto, 'removeEventListener', function (originalRemoveEventListener) {\n            return function (eventName, fn, options) {\n                var _a;\n                /**\n                 * There are 2 possible scenarios here:\n                 *\n                 * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified\n                 * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function\n                 * as a pass-through, and call original `removeEventListener` with it.\n                 *\n                 * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using\n                 * our wrapped version of `addEventListener`, which internally calls `wrap` helper.\n                 * This helper \"wraps\" whole callback inside a try/catch statement, and attached appropriate metadata to it,\n                 * in order for us to make a distinction between wrapped/non-wrapped functions possible.\n                 * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.\n                 *\n                 * When someone adds a handler prior to initialization, and then do it again, but after,\n                 * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible\n                 * to get rid of the initial handler and it'd stick there forever.\n                 */\n                var wrappedEventHandler = fn;\n                try {\n                    var originalEventHandler = (_a = wrappedEventHandler) === null || _a === void 0 ? void 0 : _a.__sentry_wrapped__;\n                    if (originalEventHandler) {\n                        originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n                    }\n                }\n                catch (e) {\n                    // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n                }\n                return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);\n            };\n        });\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapXHR = function (originalSend) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            // eslint-disable-next-line @typescript-eslint/no-this-alias\n            var xhr = this;\n            var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n            xmlHttpRequestProps.forEach(function (prop) {\n                if (prop in xhr && typeof xhr[prop] === 'function') {\n                    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                    fill(xhr, prop, function (original) {\n                        var wrapOptions = {\n                            mechanism: {\n                                data: {\n                                    function: prop,\n                                    handler: getFunctionName(original),\n                                },\n                                handled: true,\n                                type: 'instrument',\n                            },\n                        };\n                        // If Instrument integration has been called before TryCatch, get the name of original function\n                        if (original.__sentry_original__) {\n                            wrapOptions.mechanism.data.handler = getFunctionName(original.__sentry_original__);\n                        }\n                        // Otherwise wrap directly\n                        return wrap(original, wrapOptions);\n                    });\n                }\n            });\n            return originalSend.apply(this, args);\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    TryCatch.id = 'TryCatch';\n    return TryCatch;\n}());\nexport { TryCatch };\n//# sourceMappingURL=trycatch.js.map","import { __assign } from \"tslib\";\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\nimport { getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, addInstrumentationHandler, getLocationHref, isErrorEvent, isPrimitive, isString, logger, } from '@sentry/utils';\nimport { eventFromUnknownInput } from '../eventbuilder';\nimport { shouldIgnoreOnError } from '../helpers';\n/** Global handlers */\nvar GlobalHandlers = /** @class */ (function () {\n    /** JSDoc */\n    function GlobalHandlers(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = GlobalHandlers.id;\n        /** JSDoc */\n        this._onErrorHandlerInstalled = false;\n        /** JSDoc */\n        this._onUnhandledRejectionHandlerInstalled = false;\n        this._options = __assign({ onerror: true, onunhandledrejection: true }, options);\n    }\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.prototype.setupOnce = function () {\n        Error.stackTraceLimit = 50;\n        if (this._options.onerror) {\n            logger.log('Global Handler attached: onerror');\n            this._installGlobalOnErrorHandler();\n        }\n        if (this._options.onunhandledrejection) {\n            logger.log('Global Handler attached: onunhandledrejection');\n            this._installGlobalOnUnhandledRejectionHandler();\n        }\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnErrorHandler = function () {\n        var _this = this;\n        if (this._onErrorHandlerInstalled) {\n            return;\n        }\n        addInstrumentationHandler({\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            callback: function (data) {\n                var error = data.error;\n                var currentHub = getCurrentHub();\n                var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n                var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n                if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {\n                    return;\n                }\n                var client = currentHub.getClient();\n                var event = isPrimitive(error)\n                    ? _this._eventFromIncompleteOnError(data.msg, data.url, data.line, data.column)\n                    : _this._enhanceEventWithInitialFrame(eventFromUnknownInput(error, undefined, {\n                        attachStacktrace: client && client.getOptions().attachStacktrace,\n                        rejection: false,\n                    }), data.url, data.line, data.column);\n                addExceptionMechanism(event, {\n                    handled: false,\n                    type: 'onerror',\n                });\n                currentHub.captureEvent(event, {\n                    originalException: error,\n                });\n            },\n            type: 'error',\n        });\n        this._onErrorHandlerInstalled = true;\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnUnhandledRejectionHandler = function () {\n        var _this = this;\n        if (this._onUnhandledRejectionHandlerInstalled) {\n            return;\n        }\n        addInstrumentationHandler({\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            callback: function (e) {\n                var error = e;\n                // dig the object of the rejection out of known event types\n                try {\n                    // PromiseRejectionEvents store the object of the rejection under 'reason'\n                    // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent\n                    if ('reason' in e) {\n                        error = e.reason;\n                    }\n                    // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n                    // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n                    // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n                    // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n                    // https://github.com/getsentry/sentry-javascript/issues/2380\n                    else if ('detail' in e && 'reason' in e.detail) {\n                        error = e.detail.reason;\n                    }\n                }\n                catch (_oO) {\n                    // no-empty\n                }\n                var currentHub = getCurrentHub();\n                var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n                var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n                if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {\n                    return true;\n                }\n                var client = currentHub.getClient();\n                var event = isPrimitive(error)\n                    ? _this._eventFromRejectionWithPrimitive(error)\n                    : eventFromUnknownInput(error, undefined, {\n                        attachStacktrace: client && client.getOptions().attachStacktrace,\n                        rejection: true,\n                    });\n                event.level = Severity.Error;\n                addExceptionMechanism(event, {\n                    handled: false,\n                    type: 'onunhandledrejection',\n                });\n                currentHub.captureEvent(event, {\n                    originalException: error,\n                });\n                return;\n            },\n            type: 'unhandledrejection',\n        });\n        this._onUnhandledRejectionHandlerInstalled = true;\n    };\n    /**\n     * This function creates a stack from an old, error-less onerror handler.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    GlobalHandlers.prototype._eventFromIncompleteOnError = function (msg, url, line, column) {\n        var ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n        // If 'message' is ErrorEvent, get real message from inside\n        var message = isErrorEvent(msg) ? msg.message : msg;\n        var name;\n        if (isString(message)) {\n            var groups = message.match(ERROR_TYPES_RE);\n            if (groups) {\n                name = groups[1];\n                message = groups[2];\n            }\n        }\n        var event = {\n            exception: {\n                values: [\n                    {\n                        type: name || 'Error',\n                        value: message,\n                    },\n                ],\n            },\n        };\n        return this._enhanceEventWithInitialFrame(event, url, line, column);\n    };\n    /**\n     * Create an event from a promise rejection where the `reason` is a primitive.\n     *\n     * @param reason: The `reason` property of the promise rejection\n     * @returns An Event object with an appropriate `exception` value\n     */\n    GlobalHandlers.prototype._eventFromRejectionWithPrimitive = function (reason) {\n        return {\n            exception: {\n                values: [\n                    {\n                        type: 'UnhandledRejection',\n                        // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n                        value: \"Non-Error promise rejection captured with value: \" + String(reason),\n                    },\n                ],\n            },\n        };\n    };\n    /** JSDoc */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    GlobalHandlers.prototype._enhanceEventWithInitialFrame = function (event, url, line, column) {\n        event.exception = event.exception || {};\n        event.exception.values = event.exception.values || [];\n        event.exception.values[0] = event.exception.values[0] || {};\n        event.exception.values[0].stacktrace = event.exception.values[0].stacktrace || {};\n        event.exception.values[0].stacktrace.frames = event.exception.values[0].stacktrace.frames || [];\n        var colno = isNaN(parseInt(column, 10)) ? undefined : column;\n        var lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n        var filename = isString(url) && url.length > 0 ? url : getLocationHref();\n        if (event.exception.values[0].stacktrace.frames.length === 0) {\n            event.exception.values[0].stacktrace.frames.push({\n                colno: colno,\n                filename: filename,\n                function: '?',\n                in_app: true,\n                lineno: lineno,\n            });\n        }\n        return event;\n    };\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.id = 'GlobalHandlers';\n    return GlobalHandlers;\n}());\nexport { GlobalHandlers };\n//# sourceMappingURL=globalhandlers.js.map","import { __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { isInstanceOf } from '@sentry/utils';\nimport { exceptionFromStacktrace } from '../parsers';\nimport { computeStackTrace } from '../tracekit';\nvar DEFAULT_KEY = 'cause';\nvar DEFAULT_LIMIT = 5;\n/** Adds SDK info to an event. */\nvar LinkedErrors = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function LinkedErrors(options) {\n        if (options === void 0) { options = {}; }\n        /**\n         * @inheritDoc\n         */\n        this.name = LinkedErrors.id;\n        this._key = options.key || DEFAULT_KEY;\n        this._limit = options.limit || DEFAULT_LIMIT;\n    }\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event, hint) {\n            var self = getCurrentHub().getIntegration(LinkedErrors);\n            if (self) {\n                return self._handler(event, hint);\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype._handler = function (event, hint) {\n        if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n            return event;\n        }\n        var linkedErrors = this._walkErrorTree(hint.originalException, this._key);\n        event.exception.values = __spread(linkedErrors, event.exception.values);\n        return event;\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype._walkErrorTree = function (error, key, stack) {\n        if (stack === void 0) { stack = []; }\n        if (!isInstanceOf(error[key], Error) || stack.length + 1 >= this._limit) {\n            return stack;\n        }\n        var stacktrace = computeStackTrace(error[key]);\n        var exception = exceptionFromStacktrace(stacktrace);\n        return this._walkErrorTree(error[key], key, __spread([exception], stack));\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.id = 'LinkedErrors';\n    return LinkedErrors;\n}());\nexport { LinkedErrors };\n//# sourceMappingURL=linkederrors.js.map","import { __assign } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\nvar global = getGlobalObject();\n/** UserAgent */\nvar UserAgent = /** @class */ (function () {\n    function UserAgent() {\n        /**\n         * @inheritDoc\n         */\n        this.name = UserAgent.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    UserAgent.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event) {\n            var _a, _b, _c;\n            if (getCurrentHub().getIntegration(UserAgent)) {\n                // if none of the information we want exists, don't bother\n                if (!global.navigator && !global.location && !global.document) {\n                    return event;\n                }\n                // grab as much info as exists and add it to the event\n                var url = ((_a = event.request) === null || _a === void 0 ? void 0 : _a.url) || ((_b = global.location) === null || _b === void 0 ? void 0 : _b.href);\n                var referrer = (global.document || {}).referrer;\n                var userAgent = (global.navigator || {}).userAgent;\n                var headers = __assign(__assign(__assign({}, (_c = event.request) === null || _c === void 0 ? void 0 : _c.headers), (referrer && { Referer: referrer })), (userAgent && { 'User-Agent': userAgent }));\n                var request = __assign(__assign({}, (url && { url: url })), { headers: headers });\n                return __assign(__assign({}, event), { request: request });\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    UserAgent.id = 'UserAgent';\n    return UserAgent;\n}());\nexport { UserAgent };\n//# sourceMappingURL=useragent.js.map","import { getCurrentHub, initAndBind, Integrations as CoreIntegrations } from '@sentry/core';\nimport { getGlobalObject, SyncPromise } from '@sentry/utils';\nimport { BrowserClient } from './client';\nimport { wrap as internalWrap } from './helpers';\nimport { Breadcrumbs, GlobalHandlers, LinkedErrors, TryCatch, UserAgent } from './integrations';\nexport var defaultIntegrations = [\n    new CoreIntegrations.InboundFilters(),\n    new CoreIntegrations.FunctionToString(),\n    new TryCatch(),\n    new Breadcrumbs(),\n    new GlobalHandlers(),\n    new LinkedErrors(),\n    new UserAgent(),\n];\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { configureScope } from '@sentry/browser';\n * configureScope((scope: Scope) => {\n *   scope.setExtra({ battery: 0.7 });\n *   scope.setTag({ user_mode: 'admin' });\n *   scope.setUser({ id: '4711' });\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n *   message: 'My Breadcrumb',\n *   // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n *   message: 'Manual',\n *   stacktrace: [\n *     // ...\n *   ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nexport function init(options) {\n    if (options === void 0) { options = {}; }\n    if (options.defaultIntegrations === undefined) {\n        options.defaultIntegrations = defaultIntegrations;\n    }\n    if (options.release === undefined) {\n        var window_1 = getGlobalObject();\n        // This supports the variable that sentry-webpack-plugin injects\n        if (window_1.SENTRY_RELEASE && window_1.SENTRY_RELEASE.id) {\n            options.release = window_1.SENTRY_RELEASE.id;\n        }\n    }\n    if (options.autoSessionTracking === undefined) {\n        options.autoSessionTracking = false;\n    }\n    initAndBind(BrowserClient, options);\n    if (options.autoSessionTracking) {\n        startSessionTracking();\n    }\n}\n/**\n * Present the user with a report dialog.\n *\n * @param options Everything is optional, we try to fetch all info need from the global scope.\n */\nexport function showReportDialog(options) {\n    if (options === void 0) { options = {}; }\n    if (!options.eventId) {\n        options.eventId = getCurrentHub().lastEventId();\n    }\n    var client = getCurrentHub().getClient();\n    if (client) {\n        client.showReportDialog(options);\n    }\n}\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nexport function lastEventId() {\n    return getCurrentHub().lastEventId();\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function forceLoad() {\n    // Noop\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function onLoad(callback) {\n    callback();\n}\n/**\n * A promise that resolves when all current events have been sent.\n * If you provide a timeout and the queue takes longer to drain the promise returns false.\n *\n * @param timeout Maximum time in ms the client should wait.\n */\nexport function flush(timeout) {\n    var client = getCurrentHub().getClient();\n    if (client) {\n        return client.flush(timeout);\n    }\n    return SyncPromise.reject(false);\n}\n/**\n * A promise that resolves when all current events have been sent.\n * If you provide a timeout and the queue takes longer to drain the promise returns false.\n *\n * @param timeout Maximum time in ms the client should wait.\n */\nexport function close(timeout) {\n    var client = getCurrentHub().getClient();\n    if (client) {\n        return client.close(timeout);\n    }\n    return SyncPromise.reject(false);\n}\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function wrap(fn) {\n    return internalWrap(fn)();\n}\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking() {\n    var window = getGlobalObject();\n    var hub = getCurrentHub();\n    /**\n     * We should be using `Promise.all([windowLoaded, firstContentfulPaint])` here,\n     * but, as always, it's not available in the IE10-11. Thanks IE.\n     */\n    var loadResolved = document.readyState === 'complete';\n    var fcpResolved = false;\n    var possiblyEndSession = function () {\n        if (fcpResolved && loadResolved) {\n            hub.endSession();\n        }\n    };\n    var resolveWindowLoaded = function () {\n        loadResolved = true;\n        possiblyEndSession();\n        window.removeEventListener('load', resolveWindowLoaded);\n    };\n    hub.startSession();\n    if (!loadResolved) {\n        // IE doesn't support `{ once: true }` for event listeners, so we have to manually\n        // attach and then detach it once completed.\n        window.addEventListener('load', resolveWindowLoaded);\n    }\n    try {\n        var po = new PerformanceObserver(function (entryList, po) {\n            entryList.getEntries().forEach(function (entry) {\n                if (entry.name === 'first-contentful-paint' && entry.startTime < firstHiddenTime_1) {\n                    po.disconnect();\n                    fcpResolved = true;\n                    possiblyEndSession();\n                }\n            });\n        });\n        // There's no need to even attach this listener if `PerformanceObserver` constructor will fail,\n        // so we do it below here.\n        var firstHiddenTime_1 = document.visibilityState === 'hidden' ? 0 : Infinity;\n        document.addEventListener('visibilitychange', function (event) {\n            firstHiddenTime_1 = Math.min(firstHiddenTime_1, event.timeStamp);\n        }, { once: true });\n        po.observe({\n            type: 'paint',\n            buffered: true,\n        });\n    }\n    catch (e) {\n        fcpResolved = true;\n        possiblyEndSession();\n    }\n}\n//# sourceMappingURL=sdk.js.map","import { getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\n/**\n * Internal function to create a new SDK client instance. The client is\n * installed and then bound to the current scope.\n *\n * @param clientClass The client class to instantiate.\n * @param options Options to pass to the client.\n */\nexport function initAndBind(clientClass, options) {\n    if (options.debug === true) {\n        logger.enable();\n    }\n    var hub = getCurrentHub();\n    var client = new clientClass(options);\n    hub.bindClient(client);\n}\n//# sourceMappingURL=sdk.js.map","import { SessionStatus } from '@sentry/types';\nimport { dropUndefinedKeys, uuid4 } from '@sentry/utils';\n/**\n * @inheritdoc\n */\nvar Session = /** @class */ (function () {\n    function Session(context) {\n        this.errors = 0;\n        this.sid = uuid4();\n        this.timestamp = Date.now();\n        this.started = Date.now();\n        this.duration = 0;\n        this.status = SessionStatus.Ok;\n        if (context) {\n            this.update(context);\n        }\n    }\n    /** JSDoc */\n    // eslint-disable-next-line complexity\n    Session.prototype.update = function (context) {\n        if (context === void 0) { context = {}; }\n        if (context.user) {\n            if (context.user.ip_address) {\n                this.ipAddress = context.user.ip_address;\n            }\n            if (!context.did) {\n                this.did = context.user.id || context.user.email || context.user.username;\n            }\n        }\n        this.timestamp = context.timestamp || Date.now();\n        if (context.sid) {\n            // Good enough uuid validation. — Kamil\n            this.sid = context.sid.length === 32 ? context.sid : uuid4();\n        }\n        if (context.did) {\n            this.did = \"\" + context.did;\n        }\n        if (typeof context.started === 'number') {\n            this.started = context.started;\n        }\n        if (typeof context.duration === 'number') {\n            this.duration = context.duration;\n        }\n        else {\n            this.duration = this.timestamp - this.started;\n        }\n        if (context.release) {\n            this.release = context.release;\n        }\n        if (context.environment) {\n            this.environment = context.environment;\n        }\n        if (context.ipAddress) {\n            this.ipAddress = context.ipAddress;\n        }\n        if (context.userAgent) {\n            this.userAgent = context.userAgent;\n        }\n        if (typeof context.errors === 'number') {\n            this.errors = context.errors;\n        }\n        if (context.status) {\n            this.status = context.status;\n        }\n    };\n    /** JSDoc */\n    Session.prototype.close = function (status) {\n        if (status) {\n            this.update({ status: status });\n        }\n        else if (this.status === SessionStatus.Ok) {\n            this.update({ status: SessionStatus.Exited });\n        }\n        else {\n            this.update();\n        }\n    };\n    /** JSDoc */\n    Session.prototype.toJSON = function () {\n        return dropUndefinedKeys({\n            sid: \"\" + this.sid,\n            init: true,\n            started: new Date(this.started).toISOString(),\n            timestamp: new Date(this.timestamp).toISOString(),\n            status: this.status,\n            errors: this.errors,\n            did: typeof this.did === 'number' || typeof this.did === 'string' ? \"\" + this.did : undefined,\n            duration: this.duration,\n            attrs: dropUndefinedKeys({\n                release: this.release,\n                environment: this.environment,\n                ip_address: this.ipAddress,\n                user_agent: this.userAgent,\n            }),\n        });\n    };\n    return Session;\n}());\nexport { Session };\n//# sourceMappingURL=session.js.map","import { __assign, __read, __spread } from \"tslib\";\nimport { consoleSandbox, dateTimestampInSeconds, getGlobalObject, isNodeEnv, logger, uuid4 } from '@sentry/utils';\nimport { Scope } from './scope';\nimport { Session } from './session';\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nexport var API_VERSION = 3;\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nvar DEFAULT_BREADCRUMBS = 100;\n/**\n * Absolute maximum number of breadcrumbs added to an event. The\n * `maxBreadcrumbs` option cannot be higher than this value.\n */\nvar MAX_BREADCRUMBS = 100;\n/**\n * @inheritDoc\n */\nvar Hub = /** @class */ (function () {\n    /**\n     * Creates a new instance of the hub, will push one {@link Layer} into the\n     * internal stack on creation.\n     *\n     * @param client bound to the hub.\n     * @param scope bound to the hub.\n     * @param version number, higher number means higher priority.\n     */\n    function Hub(client, scope, _version) {\n        if (scope === void 0) { scope = new Scope(); }\n        if (_version === void 0) { _version = API_VERSION; }\n        this._version = _version;\n        /** Is a {@link Layer}[] containing the client and scope */\n        this._stack = [{}];\n        this.getStackTop().scope = scope;\n        this.bindClient(client);\n    }\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.isOlderThan = function (version) {\n        return this._version < version;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.bindClient = function (client) {\n        var top = this.getStackTop();\n        top.client = client;\n        if (client && client.setupIntegrations) {\n            client.setupIntegrations();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.pushScope = function () {\n        // We want to clone the content of prev scope\n        var scope = Scope.clone(this.getScope());\n        this.getStack().push({\n            client: this.getClient(),\n            scope: scope,\n        });\n        return scope;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.popScope = function () {\n        if (this.getStack().length <= 1)\n            return false;\n        return !!this.getStack().pop();\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.withScope = function (callback) {\n        var scope = this.pushScope();\n        try {\n            callback(scope);\n        }\n        finally {\n            this.popScope();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getClient = function () {\n        return this.getStackTop().client;\n    };\n    /** Returns the scope of the top stack. */\n    Hub.prototype.getScope = function () {\n        return this.getStackTop().scope;\n    };\n    /** Returns the scope stack for domains or the process. */\n    Hub.prototype.getStack = function () {\n        return this._stack;\n    };\n    /** Returns the topmost scope layer in the order domain > local > process. */\n    Hub.prototype.getStackTop = function () {\n        return this._stack[this._stack.length - 1];\n    };\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    Hub.prototype.captureException = function (exception, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error('Sentry syntheticException');\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: exception,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureException', exception, __assign(__assign({}, finalHint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureMessage = function (message, level, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error(message);\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: message,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureMessage', message, level, __assign(__assign({}, finalHint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureEvent = function (event, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        this._invokeClient('captureEvent', event, __assign(__assign({}, hint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.lastEventId = function () {\n        return this._lastEventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.addBreadcrumb = function (breadcrumb, hint) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (!scope || !client)\n            return;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var _b = (client.getOptions && client.getOptions()) || {}, _c = _b.beforeBreadcrumb, beforeBreadcrumb = _c === void 0 ? null : _c, _d = _b.maxBreadcrumbs, maxBreadcrumbs = _d === void 0 ? DEFAULT_BREADCRUMBS : _d;\n        if (maxBreadcrumbs <= 0)\n            return;\n        var timestamp = dateTimestampInSeconds();\n        var mergedBreadcrumb = __assign({ timestamp: timestamp }, breadcrumb);\n        var finalBreadcrumb = beforeBreadcrumb\n            ? consoleSandbox(function () { return beforeBreadcrumb(mergedBreadcrumb, hint); })\n            : mergedBreadcrumb;\n        if (finalBreadcrumb === null)\n            return;\n        scope.addBreadcrumb(finalBreadcrumb, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setUser = function (user) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setUser(user);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTags = function (tags) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setTags(tags);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtras = function (extras) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setExtras(extras);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTag = function (key, value) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setTag(key, value);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtra = function (key, extra) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setExtra(key, extra);\n    };\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype.setContext = function (name, context) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setContext(name, context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.configureScope = function (callback) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (scope && client) {\n            callback(scope);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.run = function (callback) {\n        var oldHub = makeMain(this);\n        try {\n            callback(this);\n        }\n        finally {\n            makeMain(oldHub);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getIntegration = function (integration) {\n        var client = this.getClient();\n        if (!client)\n            return null;\n        try {\n            return client.getIntegration(integration);\n        }\n        catch (_oO) {\n            logger.warn(\"Cannot retrieve integration \" + integration.id + \" from the current Hub\");\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSpan = function (context) {\n        return this._callExtensionMethod('startSpan', context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startTransaction = function (context, customSamplingContext) {\n        return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.traceHeaders = function () {\n        return this._callExtensionMethod('traceHeaders');\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSession = function (context) {\n        // End existing session if there's one\n        this.endSession();\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        var _b = (client && client.getOptions()) || {}, release = _b.release, environment = _b.environment;\n        var session = new Session(__assign(__assign({ release: release,\n            environment: environment }, (scope && { user: scope.getUser() })), context));\n        if (scope) {\n            scope.setSession(session);\n        }\n        return session;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.endSession = function () {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (!scope)\n            return;\n        var session = scope.getSession && scope.getSession();\n        if (session) {\n            session.close();\n            if (client && client.captureSession) {\n                client.captureSession(session);\n            }\n            scope.setSession();\n        }\n    };\n    /**\n     * Internal helper function to call a method on the top client if it exists.\n     *\n     * @param method The method to call on the client.\n     * @param args Arguments to pass to the client function.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype._invokeClient = function (method) {\n        var _a;\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var _b = this.getStackTop(), scope = _b.scope, client = _b.client;\n        if (client && client[method]) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any\n            (_a = client)[method].apply(_a, __spread(args, [scope]));\n        }\n    };\n    /**\n     * Calls global extension method and binding current instance to the function call\n     */\n    // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype._callExtensionMethod = function (method) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var carrier = getMainCarrier();\n        var sentry = carrier.__SENTRY__;\n        if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n            return sentry.extensions[method].apply(this, args);\n        }\n        logger.warn(\"Extension method \" + method + \" couldn't be found, doing nothing.\");\n    };\n    return Hub;\n}());\nexport { Hub };\n/** Returns the global shim registry. */\nexport function getMainCarrier() {\n    var carrier = getGlobalObject();\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {\n        extensions: {},\n        hub: undefined,\n    };\n    return carrier;\n}\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nexport function makeMain(hub) {\n    var registry = getMainCarrier();\n    var oldHub = getHubFromCarrier(registry);\n    setHubOnCarrier(registry, hub);\n    return oldHub;\n}\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nexport function getCurrentHub() {\n    // Get main carrier (global for every environment)\n    var registry = getMainCarrier();\n    // If there's no hub, or its an old API, assign a new one\n    if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n        setHubOnCarrier(registry, new Hub());\n    }\n    // Prefer domains over global if they are there (applicable only to Node environment)\n    if (isNodeEnv()) {\n        return getHubFromActiveDomain(registry);\n    }\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n}\n/**\n * Returns the active domain, if one exists\n *\n * @returns The domain, or undefined if there is no active domain\n */\nexport function getActiveDomain() {\n    var sentry = getMainCarrier().__SENTRY__;\n    return sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n}\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n    try {\n        var activeDomain = getActiveDomain();\n        // If there's no active domain, just return global hub\n        if (!activeDomain) {\n            return getHubFromCarrier(registry);\n        }\n        // If there's no hub on current domain, or it's an old API, assign a new one\n        if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n            var registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n            setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n        }\n        // Return hub that lives on a domain\n        return getHubFromCarrier(activeDomain);\n    }\n    catch (_Oo) {\n        // Return hub that lives on a global object\n        return getHubFromCarrier(registry);\n    }\n}\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier) {\n    return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nexport function getHubFromCarrier(carrier) {\n    if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub)\n        return carrier.__SENTRY__.hub;\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = new Hub();\n    return carrier.__SENTRY__.hub;\n}\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n */\nexport function setHubOnCarrier(carrier, hub) {\n    if (!carrier)\n        return false;\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = hub;\n    return true;\n}\n//# sourceMappingURL=hub.js.map","import { __assign, __read, __spread } from \"tslib\";\nimport { dateTimestampInSeconds, getGlobalObject, isPlainObject, isThenable, SyncPromise } from '@sentry/utils';\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nvar Scope = /** @class */ (function () {\n    function Scope() {\n        /** Flag if notifiying is happening. */\n        this._notifyingListeners = false;\n        /** Callback for client to receive scope changes. */\n        this._scopeListeners = [];\n        /** Callback list that will be called after {@link applyToEvent}. */\n        this._eventProcessors = [];\n        /** Array of breadcrumbs. */\n        this._breadcrumbs = [];\n        /** User */\n        this._user = {};\n        /** Tags */\n        this._tags = {};\n        /** Extra */\n        this._extra = {};\n        /** Contexts */\n        this._contexts = {};\n    }\n    /**\n     * Inherit values from the parent scope.\n     * @param scope to clone.\n     */\n    Scope.clone = function (scope) {\n        var newScope = new Scope();\n        if (scope) {\n            newScope._breadcrumbs = __spread(scope._breadcrumbs);\n            newScope._tags = __assign({}, scope._tags);\n            newScope._extra = __assign({}, scope._extra);\n            newScope._contexts = __assign({}, scope._contexts);\n            newScope._user = scope._user;\n            newScope._level = scope._level;\n            newScope._span = scope._span;\n            newScope._session = scope._session;\n            newScope._transactionName = scope._transactionName;\n            newScope._fingerprint = scope._fingerprint;\n            newScope._eventProcessors = __spread(scope._eventProcessors);\n        }\n        return newScope;\n    };\n    /**\n     * Add internal on change listener. Used for sub SDKs that need to store the scope.\n     * @hidden\n     */\n    Scope.prototype.addScopeListener = function (callback) {\n        this._scopeListeners.push(callback);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addEventProcessor = function (callback) {\n        this._eventProcessors.push(callback);\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setUser = function (user) {\n        this._user = user || {};\n        if (this._session) {\n            this._session.update({ user: user });\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getUser = function () {\n        return this._user;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTags = function (tags) {\n        this._tags = __assign(__assign({}, this._tags), tags);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTag = function (key, value) {\n        var _a;\n        this._tags = __assign(__assign({}, this._tags), (_a = {}, _a[key] = value, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtras = function (extras) {\n        this._extra = __assign(__assign({}, this._extra), extras);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtra = function (key, extra) {\n        var _a;\n        this._extra = __assign(__assign({}, this._extra), (_a = {}, _a[key] = extra, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setFingerprint = function (fingerprint) {\n        this._fingerprint = fingerprint;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setLevel = function (level) {\n        this._level = level;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTransactionName = function (name) {\n        this._transactionName = name;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Can be removed in major version.\n     * @deprecated in favor of {@link this.setTransactionName}\n     */\n    Scope.prototype.setTransaction = function (name) {\n        return this.setTransactionName(name);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setContext = function (key, context) {\n        var _a;\n        if (context === null) {\n            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n            delete this._contexts[key];\n        }\n        else {\n            this._contexts = __assign(__assign({}, this._contexts), (_a = {}, _a[key] = context, _a));\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSpan = function (span) {\n        this._span = span;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getSpan = function () {\n        return this._span;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getTransaction = function () {\n        var _a, _b, _c, _d;\n        // often, this span will be a transaction, but it's not guaranteed to be\n        var span = this.getSpan();\n        // try it the new way first\n        if ((_a = span) === null || _a === void 0 ? void 0 : _a.transaction) {\n            return (_b = span) === null || _b === void 0 ? void 0 : _b.transaction;\n        }\n        // fallback to the old way (known bug: this only finds transactions with sampled = true)\n        if ((_d = (_c = span) === null || _c === void 0 ? void 0 : _c.spanRecorder) === null || _d === void 0 ? void 0 : _d.spans[0]) {\n            return span.spanRecorder.spans[0];\n        }\n        // neither way found a transaction\n        return undefined;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSession = function (session) {\n        if (!session) {\n            delete this._session;\n        }\n        else {\n            this._session = session;\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getSession = function () {\n        return this._session;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.update = function (captureContext) {\n        if (!captureContext) {\n            return this;\n        }\n        if (typeof captureContext === 'function') {\n            var updatedScope = captureContext(this);\n            return updatedScope instanceof Scope ? updatedScope : this;\n        }\n        if (captureContext instanceof Scope) {\n            this._tags = __assign(__assign({}, this._tags), captureContext._tags);\n            this._extra = __assign(__assign({}, this._extra), captureContext._extra);\n            this._contexts = __assign(__assign({}, this._contexts), captureContext._contexts);\n            if (captureContext._user && Object.keys(captureContext._user).length) {\n                this._user = captureContext._user;\n            }\n            if (captureContext._level) {\n                this._level = captureContext._level;\n            }\n            if (captureContext._fingerprint) {\n                this._fingerprint = captureContext._fingerprint;\n            }\n        }\n        else if (isPlainObject(captureContext)) {\n            // eslint-disable-next-line no-param-reassign\n            captureContext = captureContext;\n            this._tags = __assign(__assign({}, this._tags), captureContext.tags);\n            this._extra = __assign(__assign({}, this._extra), captureContext.extra);\n            this._contexts = __assign(__assign({}, this._contexts), captureContext.contexts);\n            if (captureContext.user) {\n                this._user = captureContext.user;\n            }\n            if (captureContext.level) {\n                this._level = captureContext.level;\n            }\n            if (captureContext.fingerprint) {\n                this._fingerprint = captureContext.fingerprint;\n            }\n        }\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clear = function () {\n        this._breadcrumbs = [];\n        this._tags = {};\n        this._extra = {};\n        this._user = {};\n        this._contexts = {};\n        this._level = undefined;\n        this._transactionName = undefined;\n        this._fingerprint = undefined;\n        this._span = undefined;\n        this._session = undefined;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {\n        var mergedBreadcrumb = __assign({ timestamp: dateTimestampInSeconds() }, breadcrumb);\n        this._breadcrumbs =\n            maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0\n                ? __spread(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxBreadcrumbs)\n                : __spread(this._breadcrumbs, [mergedBreadcrumb]);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clearBreadcrumbs = function () {\n        this._breadcrumbs = [];\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Applies the current context and fingerprint to the event.\n     * Note that breadcrumbs will be added by the client.\n     * Also if the event has already breadcrumbs on it, we do not merge them.\n     * @param event Event\n     * @param hint May contain additional informartion about the original exception.\n     * @hidden\n     */\n    Scope.prototype.applyToEvent = function (event, hint) {\n        var _a;\n        if (this._extra && Object.keys(this._extra).length) {\n            event.extra = __assign(__assign({}, this._extra), event.extra);\n        }\n        if (this._tags && Object.keys(this._tags).length) {\n            event.tags = __assign(__assign({}, this._tags), event.tags);\n        }\n        if (this._user && Object.keys(this._user).length) {\n            event.user = __assign(__assign({}, this._user), event.user);\n        }\n        if (this._contexts && Object.keys(this._contexts).length) {\n            event.contexts = __assign(__assign({}, this._contexts), event.contexts);\n        }\n        if (this._level) {\n            event.level = this._level;\n        }\n        if (this._transactionName) {\n            event.transaction = this._transactionName;\n        }\n        // We want to set the trace context for normal events only if there isn't already\n        // a trace context on the event. There is a product feature in place where we link\n        // errors with transaction and it relys on that.\n        if (this._span) {\n            event.contexts = __assign({ trace: this._span.getTraceContext() }, event.contexts);\n            var transactionName = (_a = this._span.transaction) === null || _a === void 0 ? void 0 : _a.name;\n            if (transactionName) {\n                event.tags = __assign({ transaction: transactionName }, event.tags);\n            }\n        }\n        this._applyFingerprint(event);\n        event.breadcrumbs = __spread((event.breadcrumbs || []), this._breadcrumbs);\n        event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n        return this._notifyEventProcessors(__spread(getGlobalEventProcessors(), this._eventProcessors), event, hint);\n    };\n    /**\n     * This will be called after {@link applyToEvent} is finished.\n     */\n    Scope.prototype._notifyEventProcessors = function (processors, event, hint, index) {\n        var _this = this;\n        if (index === void 0) { index = 0; }\n        return new SyncPromise(function (resolve, reject) {\n            var processor = processors[index];\n            if (event === null || typeof processor !== 'function') {\n                resolve(event);\n            }\n            else {\n                var result = processor(__assign({}, event), hint);\n                if (isThenable(result)) {\n                    result\n                        .then(function (final) { return _this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve); })\n                        .then(null, reject);\n                }\n                else {\n                    _this._notifyEventProcessors(processors, result, hint, index + 1)\n                        .then(resolve)\n                        .then(null, reject);\n                }\n            }\n        });\n    };\n    /**\n     * This will be called on every set call.\n     */\n    Scope.prototype._notifyScopeListeners = function () {\n        var _this = this;\n        // We need this check for this._notifyingListeners to be able to work on scope during updates\n        // If this check is not here we'll produce endless recursion when something is done with the scope\n        // during the callback.\n        if (!this._notifyingListeners) {\n            this._notifyingListeners = true;\n            this._scopeListeners.forEach(function (callback) {\n                callback(_this);\n            });\n            this._notifyingListeners = false;\n        }\n    };\n    /**\n     * Applies fingerprint from the scope to the event if there's one,\n     * uses message if there's one instead or get rid of empty fingerprint\n     */\n    Scope.prototype._applyFingerprint = function (event) {\n        // Make sure it's an array first and we actually have something in place\n        event.fingerprint = event.fingerprint\n            ? Array.isArray(event.fingerprint)\n                ? event.fingerprint\n                : [event.fingerprint]\n            : [];\n        // If we have something on the scope, then merge it with event\n        if (this._fingerprint) {\n            event.fingerprint = event.fingerprint.concat(this._fingerprint);\n        }\n        // If we have no data at all, remove empty array default\n        if (event.fingerprint && !event.fingerprint.length) {\n            delete event.fingerprint;\n        }\n    };\n    return Scope;\n}());\nexport { Scope };\n/**\n * Retruns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n    /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access  */\n    var global = getGlobalObject();\n    global.__SENTRY__ = global.__SENTRY__ || {};\n    global.__SENTRY__.globalEventProcessors = global.__SENTRY__.globalEventProcessors || [];\n    return global.__SENTRY__.globalEventProcessors;\n    /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */\n}\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nexport function addGlobalEventProcessor(callback) {\n    getGlobalEventProcessors().push(callback);\n}\n//# sourceMappingURL=scope.js.map","// Slightly modified (no IE8 support, ES6) and transcribed to TypeScript\n// https://raw.githubusercontent.com/calvinmetcalf/rollup-plugin-node-builtins/master/src/es6/path.js\n/** JSDoc */\nfunction normalizeArray(parts, allowAboveRoot) {\n    // if the path tries to go above the root, `up` ends up > 0\n    var up = 0;\n    for (var i = parts.length - 1; i >= 0; i--) {\n        var last = parts[i];\n        if (last === '.') {\n            parts.splice(i, 1);\n        }\n        else if (last === '..') {\n            parts.splice(i, 1);\n            // eslint-disable-next-line no-plusplus\n            up++;\n        }\n        else if (up) {\n            parts.splice(i, 1);\n            // eslint-disable-next-line no-plusplus\n            up--;\n        }\n    }\n    // if the path is allowed to go above the root, restore leading ..s\n    if (allowAboveRoot) {\n        // eslint-disable-next-line no-plusplus\n        for (; up--; up) {\n            parts.unshift('..');\n        }\n    }\n    return parts;\n}\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nvar splitPathRe = /^(\\/?|)([\\s\\S]*?)((?:\\.{1,2}|[^/]+?|)(\\.[^./]*|))(?:[/]*)$/;\n/** JSDoc */\nfunction splitPath(filename) {\n    var parts = splitPathRe.exec(filename);\n    return parts ? parts.slice(1) : [];\n}\n// path.resolve([from ...], to)\n// posix version\n/** JSDoc */\nexport function resolve() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    var resolvedPath = '';\n    var resolvedAbsolute = false;\n    for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n        var path = i >= 0 ? args[i] : '/';\n        // Skip empty entries\n        if (!path) {\n            continue;\n        }\n        resolvedPath = path + \"/\" + resolvedPath;\n        resolvedAbsolute = path.charAt(0) === '/';\n    }\n    // At this point the path should be resolved to a full absolute path, but\n    // handle relative paths to be safe (might happen when process.cwd() fails)\n    // Normalize the path\n    resolvedPath = normalizeArray(resolvedPath.split('/').filter(function (p) { return !!p; }), !resolvedAbsolute).join('/');\n    return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';\n}\n/** JSDoc */\nfunction trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n        if (arr[start] !== '') {\n            break;\n        }\n    }\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n        if (arr[end] !== '') {\n            break;\n        }\n    }\n    if (start > end) {\n        return [];\n    }\n    return arr.slice(start, end - start + 1);\n}\n// path.relative(from, to)\n// posix version\n/** JSDoc */\nexport function relative(from, to) {\n    /* eslint-disable no-param-reassign */\n    from = resolve(from).substr(1);\n    to = resolve(to).substr(1);\n    /* eslint-enable no-param-reassign */\n    var fromParts = trim(from.split('/'));\n    var toParts = trim(to.split('/'));\n    var length = Math.min(fromParts.length, toParts.length);\n    var samePartsLength = length;\n    for (var i = 0; i < length; i++) {\n        if (fromParts[i] !== toParts[i]) {\n            samePartsLength = i;\n            break;\n        }\n    }\n    var outputParts = [];\n    for (var i = samePartsLength; i < fromParts.length; i++) {\n        outputParts.push('..');\n    }\n    outputParts = outputParts.concat(toParts.slice(samePartsLength));\n    return outputParts.join('/');\n}\n// path.normalize(path)\n// posix version\n/** JSDoc */\nexport function normalizePath(path) {\n    var isPathAbsolute = isAbsolute(path);\n    var trailingSlash = path.substr(-1) === '/';\n    // Normalize the path\n    var normalizedPath = normalizeArray(path.split('/').filter(function (p) { return !!p; }), !isPathAbsolute).join('/');\n    if (!normalizedPath && !isPathAbsolute) {\n        normalizedPath = '.';\n    }\n    if (normalizedPath && trailingSlash) {\n        normalizedPath += '/';\n    }\n    return (isPathAbsolute ? '/' : '') + normalizedPath;\n}\n// posix version\n/** JSDoc */\nexport function isAbsolute(path) {\n    return path.charAt(0) === '/';\n}\n// posix version\n/** JSDoc */\nexport function join() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    return normalizePath(args.join('/'));\n}\n/** JSDoc */\nexport function dirname(path) {\n    var result = splitPath(path);\n    var root = result[0];\n    var dir = result[1];\n    if (!root && !dir) {\n        // No dirname whatsoever\n        return '.';\n    }\n    if (dir) {\n        // It has a dirname, strip trailing slash\n        dir = dir.substr(0, dir.length - 1);\n    }\n    return root + dir;\n}\n/** JSDoc */\nexport function basename(path, ext) {\n    var f = splitPath(path)[2];\n    if (ext && f.substr(ext.length * -1) === ext) {\n        f = f.substr(0, f.length - ext.length);\n    }\n    return f;\n}\n//# sourceMappingURL=path.js.map","import { __assign, __read, __spread } from \"tslib\";\nimport { basename, getGlobalObject, logger, timestampWithMs } from '@sentry/utils';\n/**\n * Used to extract Tracing integration from the current client,\n * without the need to import `Tracing` itself from the @sentry/apm package.\n * @deprecated as @sentry/tracing should be used over @sentry/apm.\n */\nvar TRACING_GETTER = {\n    id: 'Tracing',\n};\n/**\n * Used to extract BrowserTracing integration from @sentry/tracing\n */\nvar BROWSER_TRACING_GETTER = {\n    id: 'BrowserTracing',\n};\n// Mappings from operation to corresponding lifecycle hook.\nvar HOOKS = {\n    activate: ['activated', 'deactivated'],\n    create: ['beforeCreate', 'created'],\n    destroy: ['beforeDestroy', 'destroyed'],\n    mount: ['beforeMount', 'mounted'],\n    update: ['beforeUpdate', 'updated'],\n};\nvar COMPONENT_NAME_REGEXP = /(?:^|[-_/])(\\w)/g;\nvar ROOT_COMPONENT_NAME = 'root';\nvar ANONYMOUS_COMPONENT_NAME = 'anonymous component';\n/** JSDoc */\nvar Vue = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function Vue(options) {\n        var _this = this;\n        /**\n         * @inheritDoc\n         */\n        this.name = Vue.id;\n        /**\n         * Cache holding already processed component names\n         */\n        this._componentsCache = {};\n        /** Keep it as attribute function, to keep correct `this` binding inside the hooks callbacks  */\n        // eslint-disable-next-line @typescript-eslint/typedef\n        this._applyTracingHooks = function (vm, getCurrentHub) {\n            // Don't attach twice, just in case\n            if (vm.$options.$_sentryPerfHook) {\n                return;\n            }\n            vm.$options.$_sentryPerfHook = true;\n            var name = _this._getComponentName(vm);\n            var rootMount = name === ROOT_COMPONENT_NAME;\n            var spans = {};\n            // Render hook starts after once event is emitted,\n            // but it ends before the second event of the same type.\n            //\n            // Because of this, we start measuring inside the first event,\n            // but finish it before it triggers, to skip the event emitter timing itself.\n            var rootHandler = function (hook) {\n                var now = timestampWithMs();\n                // On the first handler call (before), it'll be undefined, as `$once` will add it in the future.\n                // However, on the second call (after), it'll be already in place.\n                if (_this._rootSpan) {\n                    _this._finishRootSpan(now, getCurrentHub);\n                }\n                else {\n                    vm.$once(\"hook:\" + hook, function () {\n                        // Create an activity on the first event call. There'll be no second call, as rootSpan will be in place,\n                        // thus new event handler won't be attached.\n                        // We do this whole dance with `TRACING_GETTER` to prevent `@sentry/apm` from becoming a peerDependency.\n                        // We also need to ask for the `.constructor`, as `pushActivity` and `popActivity` are static, not instance methods.\n                        /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n                        // eslint-disable-next-line deprecation/deprecation\n                        var tracingIntegration = getCurrentHub().getIntegration(TRACING_GETTER);\n                        if (tracingIntegration) {\n                            _this._tracingActivity = tracingIntegration.constructor.pushActivity('Vue Application Render');\n                            var transaction = tracingIntegration.constructor.getTransaction();\n                            if (transaction) {\n                                _this._rootSpan = transaction.startChild({\n                                    description: 'Application Render',\n                                    op: 'Vue',\n                                });\n                            }\n                            // Use functionality from @sentry/tracing\n                        }\n                        else {\n                            var activeTransaction = getActiveTransaction(getCurrentHub());\n                            if (activeTransaction) {\n                                _this._rootSpan = activeTransaction.startChild({\n                                    description: 'Application Render',\n                                    op: 'Vue',\n                                });\n                            }\n                        }\n                        /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n                    });\n                }\n            };\n            var childHandler = function (hook, operation) {\n                // Skip components that we don't want to track to minimize the noise and give a more granular control to the user\n                var shouldTrack = Array.isArray(_this._options.tracingOptions.trackComponents)\n                    ? _this._options.tracingOptions.trackComponents.indexOf(name) > -1\n                    : _this._options.tracingOptions.trackComponents;\n                if (!_this._rootSpan || !shouldTrack) {\n                    return;\n                }\n                var now = timestampWithMs();\n                var span = spans[operation];\n                // On the first handler call (before), it'll be undefined, as `$once` will add it in the future.\n                // However, on the second call (after), it'll be already in place.\n                if (span) {\n                    span.finish();\n                    _this._finishRootSpan(now, getCurrentHub);\n                }\n                else {\n                    vm.$once(\"hook:\" + hook, function () {\n                        if (_this._rootSpan) {\n                            spans[operation] = _this._rootSpan.startChild({\n                                description: \"Vue <\" + name + \">\",\n                                op: operation,\n                            });\n                        }\n                    });\n                }\n            };\n            // Each component has it's own scope, so all activities are only related to one of them\n            _this._options.tracingOptions.hooks.forEach(function (operation) {\n                // Retrieve corresponding hooks from Vue lifecycle.\n                // eg. mount => ['beforeMount', 'mounted']\n                var internalHooks = HOOKS[operation];\n                if (!internalHooks) {\n                    logger.warn(\"Unknown hook: \" + operation);\n                    return;\n                }\n                internalHooks.forEach(function (internalHook) {\n                    var handler = rootMount\n                        ? rootHandler.bind(_this, internalHook)\n                        : childHandler.bind(_this, internalHook, operation);\n                    var currentValue = vm.$options[internalHook];\n                    if (Array.isArray(currentValue)) {\n                        vm.$options[internalHook] = __spread([handler], currentValue);\n                    }\n                    else if (typeof currentValue === 'function') {\n                        vm.$options[internalHook] = [handler, currentValue];\n                    }\n                    else {\n                        vm.$options[internalHook] = [handler];\n                    }\n                });\n            });\n        };\n        logger.log('You are still using the Vue.js integration, consider moving to @sentry/vue');\n        this._options = __assign(__assign({ \n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            Vue: getGlobalObject().Vue, attachProps: true, logErrors: false, tracing: false }, options), { tracingOptions: __assign({ hooks: ['mount', 'update'], timeout: 2000, trackComponents: false }, options.tracingOptions) });\n    }\n    /**\n     * @inheritDoc\n     */\n    Vue.prototype.setupOnce = function (_, getCurrentHub) {\n        if (!this._options.Vue) {\n            logger.error('Vue integration is missing a Vue instance');\n            return;\n        }\n        this._attachErrorHandler(getCurrentHub);\n        if (this._options.tracing) {\n            this._startTracing(getCurrentHub);\n        }\n    };\n    /**\n     * Extract component name from the ViewModel\n     */\n    Vue.prototype._getComponentName = function (vm) {\n        // Such level of granularity is most likely not necessary, but better safe than sorry. — Kamil\n        if (!vm) {\n            return ANONYMOUS_COMPONENT_NAME;\n        }\n        if (vm.$root === vm) {\n            return ROOT_COMPONENT_NAME;\n        }\n        if (!vm.$options) {\n            return ANONYMOUS_COMPONENT_NAME;\n        }\n        if (vm.$options.name) {\n            return vm.$options.name;\n        }\n        if (vm.$options._componentTag) {\n            return vm.$options._componentTag;\n        }\n        // injected by vue-loader\n        if (vm.$options.__file) {\n            var unifiedFile = vm.$options.__file.replace(/^[a-zA-Z]:/, '').replace(/\\\\/g, '/');\n            var filename = basename(unifiedFile, '.vue');\n            return (this._componentsCache[filename] ||\n                (this._componentsCache[filename] = filename.replace(COMPONENT_NAME_REGEXP, function (_, c) {\n                    return c ? c.toUpperCase() : '';\n                })));\n        }\n        return ANONYMOUS_COMPONENT_NAME;\n    };\n    /** Finish top-level span and activity with a debounce configured using `timeout` option */\n    Vue.prototype._finishRootSpan = function (timestamp, getCurrentHub) {\n        var _this = this;\n        if (this._rootSpanTimer) {\n            clearTimeout(this._rootSpanTimer);\n        }\n        this._rootSpanTimer = setTimeout(function () {\n            if (_this._tracingActivity) {\n                // We do this whole dance with `TRACING_GETTER` to prevent `@sentry/apm` from becoming a peerDependency.\n                // We also need to ask for the `.constructor`, as `pushActivity` and `popActivity` are static, not instance methods.\n                // eslint-disable-next-line deprecation/deprecation\n                var tracingIntegration = getCurrentHub().getIntegration(TRACING_GETTER);\n                if (tracingIntegration) {\n                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                    tracingIntegration.constructor.popActivity(_this._tracingActivity);\n                }\n            }\n            // We should always finish the span, only should pop activity if using @sentry/apm\n            if (_this._rootSpan) {\n                _this._rootSpan.finish(timestamp);\n            }\n        }, this._options.tracingOptions.timeout);\n    };\n    /** Inject configured tracing hooks into Vue's component lifecycles */\n    Vue.prototype._startTracing = function (getCurrentHub) {\n        var applyTracingHooks = this._applyTracingHooks;\n        this._options.Vue.mixin({\n            beforeCreate: function () {\n                // eslint-disable-next-line deprecation/deprecation\n                if (getCurrentHub().getIntegration(TRACING_GETTER) || getCurrentHub().getIntegration(BROWSER_TRACING_GETTER)) {\n                    // `this` points to currently rendered component\n                    applyTracingHooks(this, getCurrentHub);\n                }\n                else {\n                    logger.error('Vue integration has tracing enabled, but Tracing integration is not configured');\n                }\n            },\n        });\n    };\n    /** Inject Sentry's handler into owns Vue's error handler  */\n    Vue.prototype._attachErrorHandler = function (getCurrentHub) {\n        var _this = this;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var currentErrorHandler = this._options.Vue.config.errorHandler;\n        this._options.Vue.config.errorHandler = function (error, vm, info) {\n            var metadata = {};\n            if (vm) {\n                try {\n                    metadata.componentName = _this._getComponentName(vm);\n                    if (_this._options.attachProps) {\n                        metadata.propsData = vm.$options.propsData;\n                    }\n                }\n                catch (_oO) {\n                    logger.warn('Unable to extract metadata from Vue component.');\n                }\n            }\n            if (info) {\n                metadata.lifecycleHook = info;\n            }\n            if (getCurrentHub().getIntegration(Vue)) {\n                // Capture exception in the next event loop, to make sure that all breadcrumbs are recorded in time.\n                setTimeout(function () {\n                    getCurrentHub().withScope(function (scope) {\n                        scope.setContext('vue', metadata);\n                        getCurrentHub().captureException(error);\n                    });\n                });\n            }\n            if (typeof currentErrorHandler === 'function') {\n                currentErrorHandler.call(_this._options.Vue, error, vm, info);\n            }\n            if (_this._options.logErrors) {\n                if (_this._options.Vue.util) {\n                    _this._options.Vue.util.warn(\"Error in \" + info + \": \\\"\" + error.toString() + \"\\\"\", vm);\n                }\n                // eslint-disable-next-line no-console\n                console.error(error);\n            }\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    Vue.id = 'Vue';\n    return Vue;\n}());\nexport { Vue };\n/** Grabs active transaction off scope */\nexport function getActiveTransaction(hub) {\n    if (hub && hub.getScope) {\n        var scope = hub.getScope();\n        if (scope) {\n            return scope.getTransaction();\n        }\n    }\n    return undefined;\n}\n//# sourceMappingURL=vue.js.map","import { __assign, __read, __spread } from \"tslib\";\nimport { getCurrentHub } from '@sentry/hub';\n/**\n * This calls a function on the current hub.\n * @param method function to call on hub.\n * @param args to pass to function.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction callOnHub(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    var hub = getCurrentHub();\n    if (hub && hub[method]) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return hub[method].apply(hub, __spread(args));\n    }\n    throw new Error(\"No hub defined or \" + method + \" was not found on the hub, please open a bug report.\");\n}\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @returns The generated eventId.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nexport function captureException(exception, captureContext) {\n    var syntheticException;\n    try {\n        throw new Error('Sentry syntheticException');\n    }\n    catch (exception) {\n        syntheticException = exception;\n    }\n    return callOnHub('captureException', exception, {\n        captureContext: captureContext,\n        originalException: exception,\n        syntheticException: syntheticException,\n    });\n}\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param level Define the level of the message.\n * @returns The generated eventId.\n */\nexport function captureMessage(message, captureContext) {\n    var syntheticException;\n    try {\n        throw new Error(message);\n    }\n    catch (exception) {\n        syntheticException = exception;\n    }\n    // This is necessary to provide explicit scopes upgrade, without changing the original\n    // arity of the `captureMessage(message, level)` method.\n    var level = typeof captureContext === 'string' ? captureContext : undefined;\n    var context = typeof captureContext !== 'string' ? { captureContext: captureContext } : undefined;\n    return callOnHub('captureMessage', message, level, __assign({ originalException: message, syntheticException: syntheticException }, context));\n}\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nexport function captureEvent(event) {\n    return callOnHub('captureEvent', event);\n}\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nexport function configureScope(callback) {\n    callOnHub('configureScope', callback);\n}\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nexport function addBreadcrumb(breadcrumb) {\n    callOnHub('addBreadcrumb', breadcrumb);\n}\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function setContext(name, context) {\n    callOnHub('setContext', name, context);\n}\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nexport function setExtras(extras) {\n    callOnHub('setExtras', extras);\n}\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nexport function setTags(tags) {\n    callOnHub('setTags', tags);\n}\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nexport function setExtra(key, extra) {\n    callOnHub('setExtra', key, extra);\n}\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nexport function setTag(key, value) {\n    callOnHub('setTag', key, value);\n}\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nexport function setUser(user) {\n    callOnHub('setUser', user);\n}\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nexport function withScope(callback) {\n    callOnHub('withScope', callback);\n}\n/**\n * Calls a function on the latest client. Use this with caution, it's meant as\n * in \"internal\" helper so we don't need to expose every possible function in\n * the shim. It is not guaranteed that the client actually implements the\n * function.\n *\n * @param method The method to call on the client/client.\n * @param args Arguments to pass to the client/fontend.\n * @hidden\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function _callOnClient(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    callOnHub.apply(void 0, __spread(['_invokeClient', method], args));\n}\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n */\nexport function startTransaction(context, customSamplingContext) {\n    return callOnHub('startTransaction', __assign({}, context), customSamplingContext);\n}\n//# sourceMappingURL=index.js.map","/**\n * Session Status\n */\nexport var SessionStatus;\n(function (SessionStatus) {\n    /** JSDoc */\n    SessionStatus[\"Ok\"] = \"ok\";\n    /** JSDoc */\n    SessionStatus[\"Exited\"] = \"exited\";\n    /** JSDoc */\n    SessionStatus[\"Crashed\"] = \"crashed\";\n    /** JSDoc */\n    SessionStatus[\"Abnormal\"] = \"abnormal\";\n})(SessionStatus || (SessionStatus = {}));\n//# sourceMappingURL=session.js.map","import { isString } from './is';\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nexport function htmlTreeAsString(elem) {\n    // try/catch both:\n    // - accessing event.target (see getsentry/raven-js#838, #768)\n    // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n    // - can throw an exception in some circumstances.\n    try {\n        var currentElem = elem;\n        var MAX_TRAVERSE_HEIGHT = 5;\n        var MAX_OUTPUT_LEN = 80;\n        var out = [];\n        var height = 0;\n        var len = 0;\n        var separator = ' > ';\n        var sepLength = separator.length;\n        var nextStr = void 0;\n        // eslint-disable-next-line no-plusplus\n        while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n            nextStr = _htmlElementAsString(currentElem);\n            // bail out if\n            // - nextStr is the 'html' element\n            // - the length of the string that would be created exceeds MAX_OUTPUT_LEN\n            //   (ignore this limit if we are on the first iteration)\n            if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {\n                break;\n            }\n            out.push(nextStr);\n            len += nextStr.length;\n            currentElem = currentElem.parentNode;\n        }\n        return out.reverse().join(separator);\n    }\n    catch (_oO) {\n        return '<unknown>';\n    }\n}\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el) {\n    var elem = el;\n    var out = [];\n    var className;\n    var classes;\n    var key;\n    var attr;\n    var i;\n    if (!elem || !elem.tagName) {\n        return '';\n    }\n    out.push(elem.tagName.toLowerCase());\n    if (elem.id) {\n        out.push(\"#\" + elem.id);\n    }\n    // eslint-disable-next-line prefer-const\n    className = elem.className;\n    if (className && isString(className)) {\n        classes = className.split(/\\s+/);\n        for (i = 0; i < classes.length; i++) {\n            out.push(\".\" + classes[i]);\n        }\n    }\n    var allowedAttrs = ['type', 'name', 'title', 'alt'];\n    for (i = 0; i < allowedAttrs.length; i++) {\n        key = allowedAttrs[i];\n        attr = elem.getAttribute(key);\n        if (attr) {\n            out.push(\"[\" + key + \"=\\\"\" + attr + \"\\\"]\");\n        }\n    }\n    return out.join('');\n}\n//# sourceMappingURL=browser.js.map","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isError(wat) {\n    switch (Object.prototype.toString.call(wat)) {\n        case '[object Error]':\n            return true;\n        case '[object Exception]':\n            return true;\n        case '[object DOMException]':\n            return true;\n        default:\n            return isInstanceOf(wat, Error);\n    }\n}\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isErrorEvent(wat) {\n    return Object.prototype.toString.call(wat) === '[object ErrorEvent]';\n}\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMError(wat) {\n    return Object.prototype.toString.call(wat) === '[object DOMError]';\n}\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMException(wat) {\n    return Object.prototype.toString.call(wat) === '[object DOMException]';\n}\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isString(wat) {\n    return Object.prototype.toString.call(wat) === '[object String]';\n}\n/**\n * Checks whether given value's is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPrimitive(wat) {\n    return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPlainObject(wat) {\n    return Object.prototype.toString.call(wat) === '[object Object]';\n}\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isEvent(wat) {\n    return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isElement(wat) {\n    return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isRegExp(wat) {\n    return Object.prototype.toString.call(wat) === '[object RegExp]';\n}\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nexport function isThenable(wat) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isSyntheticEvent(wat) {\n    return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nexport function isInstanceOf(wat, base) {\n    try {\n        return wat instanceof base;\n    }\n    catch (_e) {\n        return false;\n    }\n}\n//# sourceMappingURL=is.js.map","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { consoleSandbox, getGlobalObject } from './misc';\n// TODO: Implement different loggers for different environments\nvar global = getGlobalObject();\n/** Prefix for logging strings */\nvar PREFIX = 'Sentry Logger ';\n/** JSDoc */\nvar Logger = /** @class */ (function () {\n    /** JSDoc */\n    function Logger() {\n        this._enabled = false;\n    }\n    /** JSDoc */\n    Logger.prototype.disable = function () {\n        this._enabled = false;\n    };\n    /** JSDoc */\n    Logger.prototype.enable = function () {\n        this._enabled = true;\n    };\n    /** JSDoc */\n    Logger.prototype.log = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.log(PREFIX + \"[Log]: \" + args.join(' '));\n        });\n    };\n    /** JSDoc */\n    Logger.prototype.warn = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.warn(PREFIX + \"[Warn]: \" + args.join(' '));\n        });\n    };\n    /** JSDoc */\n    Logger.prototype.error = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.error(PREFIX + \"[Error]: \" + args.join(' '));\n        });\n    };\n    return Logger;\n}());\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nglobal.__SENTRY__ = global.__SENTRY__ || {};\nvar logger = global.__SENTRY__.logger || (global.__SENTRY__.logger = new Logger());\nexport { logger };\n//# sourceMappingURL=logger.js.map","import { isNodeEnv } from './node';\nimport { snipLine } from './string';\nvar fallbackGlobalObject = {};\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nexport function getGlobalObject() {\n    return (isNodeEnv()\n        ? global\n        : typeof window !== 'undefined'\n            ? window\n            : typeof self !== 'undefined'\n                ? self\n                : fallbackGlobalObject);\n}\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nexport function uuid4() {\n    var global = getGlobalObject();\n    var crypto = global.crypto || global.msCrypto;\n    if (!(crypto === void 0) && crypto.getRandomValues) {\n        // Use window.crypto API if available\n        var arr = new Uint16Array(8);\n        crypto.getRandomValues(arr);\n        // set 4 in byte 7\n        // eslint-disable-next-line no-bitwise\n        arr[3] = (arr[3] & 0xfff) | 0x4000;\n        // set 2 most significant bits of byte 9 to '10'\n        // eslint-disable-next-line no-bitwise\n        arr[4] = (arr[4] & 0x3fff) | 0x8000;\n        var pad = function (num) {\n            var v = num.toString(16);\n            while (v.length < 4) {\n                v = \"0\" + v;\n            }\n            return v;\n        };\n        return (pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) + pad(arr[5]) + pad(arr[6]) + pad(arr[7]));\n    }\n    // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n    return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n        // eslint-disable-next-line no-bitwise\n        var r = (Math.random() * 16) | 0;\n        // eslint-disable-next-line no-bitwise\n        var v = c === 'x' ? r : (r & 0x3) | 0x8;\n        return v.toString(16);\n    });\n}\n/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nexport function parseUrl(url) {\n    if (!url) {\n        return {};\n    }\n    var match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n    if (!match) {\n        return {};\n    }\n    // coerce to undefined values to empty string so we don't get 'undefined'\n    var query = match[6] || '';\n    var fragment = match[8] || '';\n    return {\n        host: match[4],\n        path: match[5],\n        protocol: match[2],\n        relative: match[5] + query + fragment,\n    };\n}\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nexport function getEventDescription(event) {\n    if (event.message) {\n        return event.message;\n    }\n    if (event.exception && event.exception.values && event.exception.values[0]) {\n        var exception = event.exception.values[0];\n        if (exception.type && exception.value) {\n            return exception.type + \": \" + exception.value;\n        }\n        return exception.type || exception.value || event.event_id || '<unknown>';\n    }\n    return event.event_id || '<unknown>';\n}\n/** JSDoc */\nexport function consoleSandbox(callback) {\n    var global = getGlobalObject();\n    var levels = ['debug', 'info', 'warn', 'error', 'log', 'assert'];\n    if (!('console' in global)) {\n        return callback();\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    var originalConsole = global.console;\n    var wrappedLevels = {};\n    // Restore all wrapped console methods\n    levels.forEach(function (level) {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        if (level in global.console && originalConsole[level].__sentry_original__) {\n            wrappedLevels[level] = originalConsole[level];\n            originalConsole[level] = originalConsole[level].__sentry_original__;\n        }\n    });\n    // Perform callback manipulations\n    var result = callback();\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(function (level) {\n        originalConsole[level] = wrappedLevels[level];\n    });\n    return result;\n}\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nexport function addExceptionTypeValue(event, value, type) {\n    event.exception = event.exception || {};\n    event.exception.values = event.exception.values || [];\n    event.exception.values[0] = event.exception.values[0] || {};\n    event.exception.values[0].value = event.exception.values[0].value || value || '';\n    event.exception.values[0].type = event.exception.values[0].type || type || 'Error';\n}\n/**\n * Adds exception mechanism to a given event.\n * @param event The event to modify.\n * @param mechanism Mechanism of the mechanism.\n * @hidden\n */\nexport function addExceptionMechanism(event, mechanism) {\n    if (mechanism === void 0) { mechanism = {}; }\n    // TODO: Use real type with `keyof Mechanism` thingy and maybe make it better?\n    try {\n        // @ts-ignore Type 'Mechanism | {}' is not assignable to type 'Mechanism | undefined'\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        event.exception.values[0].mechanism = event.exception.values[0].mechanism || {};\n        Object.keys(mechanism).forEach(function (key) {\n            // @ts-ignore Mechanism has no index signature\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            event.exception.values[0].mechanism[key] = mechanism[key];\n        });\n    }\n    catch (_oO) {\n        // no-empty\n    }\n}\n/**\n * A safe form of location.href\n */\nexport function getLocationHref() {\n    try {\n        return document.location.href;\n    }\n    catch (oO) {\n        return '';\n    }\n}\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nvar SEMVER_REGEXP = /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nexport function parseSemver(input) {\n    var match = input.match(SEMVER_REGEXP) || [];\n    var major = parseInt(match[1], 10);\n    var minor = parseInt(match[2], 10);\n    var patch = parseInt(match[3], 10);\n    return {\n        buildmetadata: match[5],\n        major: isNaN(major) ? undefined : major,\n        minor: isNaN(minor) ? undefined : minor,\n        patch: isNaN(patch) ? undefined : patch,\n        prerelease: match[4],\n    };\n}\nvar defaultRetryAfter = 60 * 1000; // 60 seconds\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param now current unix timestamp\n * @param header string representation of 'Retry-After' header\n */\nexport function parseRetryAfterHeader(now, header) {\n    if (!header) {\n        return defaultRetryAfter;\n    }\n    var headerDelay = parseInt(\"\" + header, 10);\n    if (!isNaN(headerDelay)) {\n        return headerDelay * 1000;\n    }\n    var headerDate = Date.parse(\"\" + header);\n    if (!isNaN(headerDate)) {\n        return headerDate - now;\n    }\n    return defaultRetryAfter;\n}\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nexport function addContextToFrame(lines, frame, linesOfContext) {\n    if (linesOfContext === void 0) { linesOfContext = 5; }\n    var lineno = frame.lineno || 0;\n    var maxLines = lines.length;\n    var sourceLine = Math.max(Math.min(maxLines, lineno - 1), 0);\n    frame.pre_context = lines\n        .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n        .map(function (line) { return snipLine(line, 0); });\n    frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n    frame.post_context = lines\n        .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n        .map(function (line) { return snipLine(line, 0); });\n}\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nexport function stripUrlQueryAndFragment(urlPath) {\n    // eslint-disable-next-line no-useless-escape\n    return urlPath.split(/[\\?#]/, 1)[0];\n}\n//# sourceMappingURL=misc.js.map","import { isString } from './is';\nimport { normalize } from './object';\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nexport function isNodeEnv() {\n    return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';\n}\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function dynamicRequire(mod, request) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return mod.require(request);\n}\n/** Default request keys that'll be used to extract data from the request */\nvar DEFAULT_REQUEST_KEYS = ['cookies', 'data', 'headers', 'method', 'query_string', 'url'];\n/**\n * Normalizes data from the request object, accounting for framework differences.\n *\n * @param req The request object from which to extract data\n * @param keys An optional array of keys to include in the normalized data. Defaults to DEFAULT_REQUEST_KEYS if not\n * provided.\n * @returns An object containing normalized request data\n */\nexport function extractNodeRequestData(req, keys) {\n    if (keys === void 0) { keys = DEFAULT_REQUEST_KEYS; }\n    // make sure we can safely use dynamicRequire below\n    if (!isNodeEnv()) {\n        throw new Error(\"Can't get node request data outside of a node environment\");\n    }\n    var requestData = {};\n    // headers:\n    //   node, express: req.headers\n    //   koa: req.header\n    var headers = (req.headers || req.header || {});\n    // method:\n    //   node, express, koa: req.method\n    var method = req.method;\n    // host:\n    //   express: req.hostname in > 4 and req.host in < 4\n    //   koa: req.host\n    //   node: req.headers.host\n    var host = req.hostname || req.host || headers.host || '<no host>';\n    // protocol:\n    //   node: <n/a>\n    //   express, koa: req.protocol\n    var protocol = req.protocol === 'https' || req.secure || (req.socket || {}).encrypted\n        ? 'https'\n        : 'http';\n    // url (including path and query string):\n    //   node, express: req.originalUrl\n    //   koa: req.url\n    var originalUrl = (req.originalUrl || req.url || '');\n    // absolute url\n    var absoluteUrl = protocol + \"://\" + host + originalUrl;\n    keys.forEach(function (key) {\n        switch (key) {\n            case 'headers':\n                requestData.headers = headers;\n                break;\n            case 'method':\n                requestData.method = method;\n                break;\n            case 'url':\n                requestData.url = absoluteUrl;\n                break;\n            case 'cookies':\n                // cookies:\n                //   node, express, koa: req.headers.cookie\n                //   vercel, sails.js, express (w/ cookie middleware): req.cookies\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                requestData.cookies = req.cookies || dynamicRequire(module, 'cookie').parse(headers.cookie || '');\n                break;\n            case 'query_string':\n                // query string:\n                //   node: req.url (raw)\n                //   express, koa: req.query\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                requestData.query_string = dynamicRequire(module, 'url').parse(originalUrl || '', false).query;\n                break;\n            case 'data':\n                if (method === 'GET' || method === 'HEAD') {\n                    break;\n                }\n                // body data:\n                //   node, express, koa: req.body\n                if (req.body !== undefined) {\n                    requestData.data = isString(req.body) ? req.body : JSON.stringify(normalize(req.body));\n                }\n                break;\n            default:\n                if ({}.hasOwnProperty.call(req, key)) {\n                    requestData[key] = req[key];\n                }\n        }\n    });\n    return requestData;\n}\n//# sourceMappingURL=node.js.map","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/**\n * Memo class used for decycle json objects. Uses WeakSet if available otherwise array.\n */\nvar Memo = /** @class */ (function () {\n    function Memo() {\n        this._hasWeakSet = typeof WeakSet === 'function';\n        this._inner = this._hasWeakSet ? new WeakSet() : [];\n    }\n    /**\n     * Sets obj to remember.\n     * @param obj Object to remember\n     */\n    Memo.prototype.memoize = function (obj) {\n        if (this._hasWeakSet) {\n            if (this._inner.has(obj)) {\n                return true;\n            }\n            this._inner.add(obj);\n            return false;\n        }\n        // eslint-disable-next-line @typescript-eslint/prefer-for-of\n        for (var i = 0; i < this._inner.length; i++) {\n            var value = this._inner[i];\n            if (value === obj) {\n                return true;\n            }\n        }\n        this._inner.push(obj);\n        return false;\n    };\n    /**\n     * Removes object from internal storage.\n     * @param obj Object to forget\n     */\n    Memo.prototype.unmemoize = function (obj) {\n        if (this._hasWeakSet) {\n            this._inner.delete(obj);\n        }\n        else {\n            for (var i = 0; i < this._inner.length; i++) {\n                if (this._inner[i] === obj) {\n                    this._inner.splice(i, 1);\n                    break;\n                }\n            }\n        }\n    };\n    return Memo;\n}());\nexport { Memo };\n//# sourceMappingURL=memo.js.map","import { __values } from \"tslib\";\nimport { htmlTreeAsString } from './browser';\nimport { isElement, isError, isEvent, isInstanceOf, isPlainObject, isPrimitive, isSyntheticEvent } from './is';\nimport { Memo } from './memo';\nimport { getFunctionName } from './stacktrace';\nimport { truncate } from './string';\n/**\n * 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 replacementFactory A function that should be used to wrap a given method, returning the wrapped method which\n * will be substituted in for `source[name]`.\n * @returns void\n */\nexport function fill(source, name, replacementFactory) {\n    if (!(name in source)) {\n        return;\n    }\n    var original = source[name];\n    var wrapped = replacementFactory(original);\n    // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n    // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n    if (typeof wrapped === 'function') {\n        try {\n            wrapped.prototype = wrapped.prototype || {};\n            Object.defineProperties(wrapped, {\n                __sentry_original__: {\n                    enumerable: false,\n                    value: original,\n                },\n            });\n        }\n        catch (_Oo) {\n            // This can throw if multiple fill happens on a global object like XMLHttpRequest\n            // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n        }\n    }\n    source[name] = wrapped;\n}\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nexport function urlEncode(object) {\n    return Object.keys(object)\n        .map(function (key) { return encodeURIComponent(key) + \"=\" + encodeURIComponent(object[key]); })\n        .join('&');\n}\n/**\n * Transforms any object into an object literal with all its attributes\n * attached to it.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n */\nfunction getWalkSource(value) {\n    if (isError(value)) {\n        var error = value;\n        var err = {\n            message: error.message,\n            name: error.name,\n            stack: error.stack,\n        };\n        for (var i in error) {\n            if (Object.prototype.hasOwnProperty.call(error, i)) {\n                err[i] = error[i];\n            }\n        }\n        return err;\n    }\n    if (isEvent(value)) {\n        var event_1 = value;\n        var source = {};\n        source.type = event_1.type;\n        // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n        try {\n            source.target = isElement(event_1.target)\n                ? htmlTreeAsString(event_1.target)\n                : Object.prototype.toString.call(event_1.target);\n        }\n        catch (_oO) {\n            source.target = '<unknown>';\n        }\n        try {\n            source.currentTarget = isElement(event_1.currentTarget)\n                ? htmlTreeAsString(event_1.currentTarget)\n                : Object.prototype.toString.call(event_1.currentTarget);\n        }\n        catch (_oO) {\n            source.currentTarget = '<unknown>';\n        }\n        if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n            source.detail = event_1.detail;\n        }\n        for (var i in event_1) {\n            if (Object.prototype.hasOwnProperty.call(event_1, i)) {\n                source[i] = event_1;\n            }\n        }\n        return source;\n    }\n    return value;\n}\n/** Calculates bytes size of input string */\nfunction utf8Length(value) {\n    // eslint-disable-next-line no-bitwise\n    return ~-encodeURI(value).split(/%..|./).length;\n}\n/** Calculates bytes size of input object */\nfunction jsonSize(value) {\n    return utf8Length(JSON.stringify(value));\n}\n/** JSDoc */\nexport function normalizeToSize(object, \n// Default Node.js REPL depth\ndepth, \n// 100kB, as 200kB is max payload size, so half sounds reasonable\nmaxSize) {\n    if (depth === void 0) { depth = 3; }\n    if (maxSize === void 0) { maxSize = 100 * 1024; }\n    var serialized = normalize(object, depth);\n    if (jsonSize(serialized) > maxSize) {\n        return normalizeToSize(object, depth - 1, maxSize);\n    }\n    return serialized;\n}\n/**\n * Transform any non-primitive, BigInt, or Symbol-type value into a string. Acts as a no-op on strings, numbers,\n * booleans, null, and undefined.\n *\n * @param value The value to stringify\n * @returns For non-primitive, BigInt, and Symbol-type values, a string denoting the value's type, type and value, or\n *  type and `description` property, respectively. For non-BigInt, non-Symbol primitives, returns the original value,\n *  unchanged.\n */\nfunction serializeValue(value) {\n    var type = Object.prototype.toString.call(value);\n    // Node.js REPL notation\n    if (typeof value === 'string') {\n        return value;\n    }\n    if (type === '[object Object]') {\n        return '[Object]';\n    }\n    if (type === '[object Array]') {\n        return '[Array]';\n    }\n    var normalized = normalizeValue(value);\n    return isPrimitive(normalized) ? normalized : type;\n}\n/**\n * normalizeValue()\n *\n * Takes unserializable input and make it serializable friendly\n *\n * - translates undefined/NaN values to \"[undefined]\"/\"[NaN]\" respectively,\n * - serializes Error objects\n * - filter global objects\n */\nfunction normalizeValue(value, key) {\n    if (key === 'domain' && value && typeof value === 'object' && value._events) {\n        return '[Domain]';\n    }\n    if (key === 'domainEmitter') {\n        return '[DomainEmitter]';\n    }\n    if (typeof global !== 'undefined' && value === global) {\n        return '[Global]';\n    }\n    if (typeof window !== 'undefined' && value === window) {\n        return '[Window]';\n    }\n    if (typeof document !== 'undefined' && value === document) {\n        return '[Document]';\n    }\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n        return '[SyntheticEvent]';\n    }\n    if (typeof value === 'number' && value !== value) {\n        return '[NaN]';\n    }\n    if (value === void 0) {\n        return '[undefined]';\n    }\n    if (typeof value === 'function') {\n        return \"[Function: \" + getFunctionName(value) + \"]\";\n    }\n    // symbols and bigints are considered primitives by TS, but aren't natively JSON-serilaizable\n    if (typeof value === 'symbol') {\n        return \"[\" + String(value) + \"]\";\n    }\n    if (typeof value === 'bigint') {\n        return \"[BigInt: \" + String(value) + \"]\";\n    }\n    return value;\n}\n/**\n * Walks an object to perform a normalization on it\n *\n * @param key of object that's walked in current iteration\n * @param value object to be walked\n * @param depth Optional number indicating how deep should walking be performed\n * @param memo Optional Memo class handling decycling\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function walk(key, value, depth, memo) {\n    if (depth === void 0) { depth = +Infinity; }\n    if (memo === void 0) { memo = new Memo(); }\n    // If we reach the maximum depth, serialize whatever has left\n    if (depth === 0) {\n        return serializeValue(value);\n    }\n    /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n    // If value implements `toJSON` method, call it and return early\n    if (value !== null && value !== undefined && typeof value.toJSON === 'function') {\n        return value.toJSON();\n    }\n    /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n    // If normalized value is a primitive, there are no branches left to walk, so we can just bail out, as theres no point in going down that branch any further\n    var normalized = normalizeValue(value, key);\n    if (isPrimitive(normalized)) {\n        return normalized;\n    }\n    // Create source that we will use for next itterations, either objectified error object (Error type with extracted keys:value pairs) or the input itself\n    var source = getWalkSource(value);\n    // Create an accumulator that will act as a parent for all future itterations of that branch\n    var acc = Array.isArray(value) ? [] : {};\n    // If we already walked that branch, bail out, as it's circular reference\n    if (memo.memoize(value)) {\n        return '[Circular ~]';\n    }\n    // Walk all keys of the source\n    for (var innerKey in source) {\n        // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n        if (!Object.prototype.hasOwnProperty.call(source, innerKey)) {\n            continue;\n        }\n        // Recursively walk through all the child nodes\n        acc[innerKey] = walk(innerKey, source[innerKey], depth - 1, memo);\n    }\n    // Once walked through all the branches, remove the parent from memo storage\n    memo.unmemoize(value);\n    // Return accumulated values\n    return acc;\n}\n/**\n * normalize()\n *\n * - Creates a copy to prevent original input mutation\n * - Skip non-enumerablers\n * - Calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializeable values (undefined/NaN/Functions) to serializable format\n * - Translates known global objects/Classes to a string representations\n * - Takes care of Error objects serialization\n * - Optionally limit depth of final output\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function normalize(input, depth) {\n    try {\n        return JSON.parse(JSON.stringify(input, function (key, value) { return walk(key, value, depth); }));\n    }\n    catch (_oO) {\n        return '**non-serializable**';\n    }\n}\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function extractExceptionKeysForMessage(exception, maxLength) {\n    if (maxLength === void 0) { maxLength = 40; }\n    var keys = Object.keys(getWalkSource(exception));\n    keys.sort();\n    if (!keys.length) {\n        return '[object has no keys]';\n    }\n    if (keys[0].length >= maxLength) {\n        return truncate(keys[0], maxLength);\n    }\n    for (var includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n        var serialized = keys.slice(0, includedKeys).join(', ');\n        if (serialized.length > maxLength) {\n            continue;\n        }\n        if (includedKeys === keys.length) {\n            return serialized;\n        }\n        return truncate(serialized, maxLength);\n    }\n    return '';\n}\n/**\n * Given any object, return the new object with removed keys that value was `undefined`.\n * Works recursively on objects and arrays.\n */\nexport function dropUndefinedKeys(val) {\n    var e_1, _a;\n    if (isPlainObject(val)) {\n        var obj = val;\n        var rv = {};\n        try {\n            for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {\n                var key = _c.value;\n                if (typeof obj[key] !== 'undefined') {\n                    rv[key] = dropUndefinedKeys(obj[key]);\n                }\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        return rv;\n    }\n    if (Array.isArray(val)) {\n        return val.map(dropUndefinedKeys);\n    }\n    return val;\n}\n//# sourceMappingURL=object.js.map","var defaultFunctionName = '<anonymous>';\n/**\n * Safely extract function name from itself\n */\nexport function getFunctionName(fn) {\n    try {\n        if (!fn || typeof fn !== 'function') {\n            return defaultFunctionName;\n        }\n        return fn.name || defaultFunctionName;\n    }\n    catch (e) {\n        // Just accessing custom props in some Selenium environments\n        // can cause a \"Permission denied\" exception (see raven-js#495).\n        return defaultFunctionName;\n    }\n}\n//# sourceMappingURL=stacktrace.js.map","import { isRegExp, isString } from './is';\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nexport function truncate(str, max) {\n    if (max === void 0) { max = 0; }\n    if (typeof str !== 'string' || max === 0) {\n        return str;\n    }\n    return str.length <= max ? str : str.substr(0, max) + \"...\";\n}\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nexport function snipLine(line, colno) {\n    var newLine = line;\n    var ll = newLine.length;\n    if (ll <= 150) {\n        return newLine;\n    }\n    if (colno > ll) {\n        // eslint-disable-next-line no-param-reassign\n        colno = ll;\n    }\n    var start = Math.max(colno - 60, 0);\n    if (start < 5) {\n        start = 0;\n    }\n    var end = Math.min(start + 140, ll);\n    if (end > ll - 5) {\n        end = ll;\n    }\n    if (end === ll) {\n        start = Math.max(end - 140, 0);\n    }\n    newLine = newLine.slice(start, end);\n    if (start > 0) {\n        newLine = \"'{snip} \" + newLine;\n    }\n    if (end < ll) {\n        newLine += ' {snip}';\n    }\n    return newLine;\n}\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function safeJoin(input, delimiter) {\n    if (!Array.isArray(input)) {\n        return '';\n    }\n    var output = [];\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (var i = 0; i < input.length; i++) {\n        var value = input[i];\n        try {\n            output.push(String(value));\n        }\n        catch (e) {\n            output.push('[value cannot be serialized]');\n        }\n    }\n    return output.join(delimiter);\n}\n/**\n * Checks if the value matches a regex or includes the string\n * @param value The string value to be checked against\n * @param pattern Either a regex or a string that must be contained in value\n */\nexport function isMatchingPattern(value, pattern) {\n    if (!isString(value)) {\n        return false;\n    }\n    if (isRegExp(pattern)) {\n        return pattern.test(value);\n    }\n    if (typeof pattern === 'string') {\n        return value.indexOf(pattern) !== -1;\n    }\n    return false;\n}\n//# sourceMappingURL=string.js.map","/* eslint-disable @typescript-eslint/explicit-function-return-type */\n/* eslint-disable @typescript-eslint/typedef */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { isThenable } from './is';\n/** SyncPromise internal states */\nvar States;\n(function (States) {\n    /** Pending */\n    States[\"PENDING\"] = \"PENDING\";\n    /** Resolved / OK */\n    States[\"RESOLVED\"] = \"RESOLVED\";\n    /** Rejected / Error */\n    States[\"REJECTED\"] = \"REJECTED\";\n})(States || (States = {}));\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nvar SyncPromise = /** @class */ (function () {\n    function SyncPromise(executor) {\n        var _this = this;\n        this._state = States.PENDING;\n        this._handlers = [];\n        /** JSDoc */\n        this._resolve = function (value) {\n            _this._setResult(States.RESOLVED, value);\n        };\n        /** JSDoc */\n        this._reject = function (reason) {\n            _this._setResult(States.REJECTED, reason);\n        };\n        /** JSDoc */\n        this._setResult = function (state, value) {\n            if (_this._state !== States.PENDING) {\n                return;\n            }\n            if (isThenable(value)) {\n                value.then(_this._resolve, _this._reject);\n                return;\n            }\n            _this._state = state;\n            _this._value = value;\n            _this._executeHandlers();\n        };\n        // TODO: FIXME\n        /** JSDoc */\n        this._attachHandler = function (handler) {\n            _this._handlers = _this._handlers.concat(handler);\n            _this._executeHandlers();\n        };\n        /** JSDoc */\n        this._executeHandlers = function () {\n            if (_this._state === States.PENDING) {\n                return;\n            }\n            var cachedHandlers = _this._handlers.slice();\n            _this._handlers = [];\n            cachedHandlers.forEach(function (handler) {\n                if (handler.done) {\n                    return;\n                }\n                if (_this._state === States.RESOLVED) {\n                    if (handler.onfulfilled) {\n                        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n                        handler.onfulfilled(_this._value);\n                    }\n                }\n                if (_this._state === States.REJECTED) {\n                    if (handler.onrejected) {\n                        handler.onrejected(_this._value);\n                    }\n                }\n                handler.done = true;\n            });\n        };\n        try {\n            executor(this._resolve, this._reject);\n        }\n        catch (e) {\n            this._reject(e);\n        }\n    }\n    /** JSDoc */\n    SyncPromise.resolve = function (value) {\n        return new SyncPromise(function (resolve) {\n            resolve(value);\n        });\n    };\n    /** JSDoc */\n    SyncPromise.reject = function (reason) {\n        return new SyncPromise(function (_, reject) {\n            reject(reason);\n        });\n    };\n    /** JSDoc */\n    SyncPromise.all = function (collection) {\n        return new SyncPromise(function (resolve, reject) {\n            if (!Array.isArray(collection)) {\n                reject(new TypeError(\"Promise.all requires an array as input.\"));\n                return;\n            }\n            if (collection.length === 0) {\n                resolve([]);\n                return;\n            }\n            var counter = collection.length;\n            var resolvedCollection = [];\n            collection.forEach(function (item, index) {\n                SyncPromise.resolve(item)\n                    .then(function (value) {\n                    resolvedCollection[index] = value;\n                    counter -= 1;\n                    if (counter !== 0) {\n                        return;\n                    }\n                    resolve(resolvedCollection);\n                })\n                    .then(null, reject);\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.then = function (onfulfilled, onrejected) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            _this._attachHandler({\n                done: false,\n                onfulfilled: function (result) {\n                    if (!onfulfilled) {\n                        // TODO: ¯\\_(ツ)_/¯\n                        // TODO: FIXME\n                        resolve(result);\n                        return;\n                    }\n                    try {\n                        resolve(onfulfilled(result));\n                        return;\n                    }\n                    catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n                onrejected: function (reason) {\n                    if (!onrejected) {\n                        reject(reason);\n                        return;\n                    }\n                    try {\n                        resolve(onrejected(reason));\n                        return;\n                    }\n                    catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.catch = function (onrejected) {\n        return this.then(function (val) { return val; }, onrejected);\n    };\n    /** JSDoc */\n    SyncPromise.prototype.finally = function (onfinally) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            var val;\n            var isRejected;\n            return _this.then(function (value) {\n                isRejected = false;\n                val = value;\n                if (onfinally) {\n                    onfinally();\n                }\n            }, function (reason) {\n                isRejected = true;\n                val = reason;\n                if (onfinally) {\n                    onfinally();\n                }\n            }).then(function () {\n                if (isRejected) {\n                    reject(val);\n                    return;\n                }\n                resolve(val);\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.toString = function () {\n        return '[object SyncPromise]';\n    };\n    return SyncPromise;\n}());\nexport { SyncPromise };\n//# sourceMappingURL=syncpromise.js.map","import { getGlobalObject } from './misc';\nimport { dynamicRequire, isNodeEnv } from './node';\n/**\n * A TimestampSource implementation for environments that do not support the Performance Web API natively.\n *\n * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier\n * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It\n * is more obvious to explain \"why does my span have negative duration\" than \"why my spans have zero duration\".\n */\nvar dateTimestampSource = {\n    nowSeconds: function () { return Date.now() / 1000; },\n};\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction getBrowserPerformance() {\n    var performance = getGlobalObject().performance;\n    if (!performance || !performance.now) {\n        return undefined;\n    }\n    // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n    //\n    // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n    // performance.now() gives a date arbitrarily in the past.\n    //\n    // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n    // undefined.\n    //\n    // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n    // interact with data coming out of performance entries.\n    //\n    // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n    // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n    // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n    // observed skews that can be as long as days, weeks or months.\n    //\n    // See https://github.com/getsentry/sentry-javascript/issues/2590.\n    //\n    // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n    // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n    // transactions of long-lived web pages.\n    var timeOrigin = Date.now() - performance.now();\n    return {\n        now: function () { return performance.now(); },\n        timeOrigin: timeOrigin,\n    };\n}\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\nfunction getNodePerformance() {\n    try {\n        var perfHooks = dynamicRequire(module, 'perf_hooks');\n        return perfHooks.performance;\n    }\n    catch (_) {\n        return undefined;\n    }\n}\n/**\n * The Performance API implementation for the current platform, if available.\n */\nvar platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\nvar timestampSource = platformPerformance === undefined\n    ? dateTimestampSource\n    : {\n        nowSeconds: function () { return (platformPerformance.timeOrigin + platformPerformance.now()) / 1000; },\n    };\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nexport var dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * See `usingPerformanceAPI` to test whether the Performance API is used.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nexport var timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);\n// Re-exported with an old name for backwards-compatibility.\nexport var timestampWithMs = timestampInSeconds;\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nexport var usingPerformanceAPI = platformPerformance !== undefined;\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nexport var browserPerformanceTimeOrigin = (function () {\n    var performance = getGlobalObject().performance;\n    if (!performance) {\n        return undefined;\n    }\n    if (performance.timeOrigin) {\n        return 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    // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n    // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n    // Date API.\n    // eslint-disable-next-line deprecation/deprecation\n    return (performance.timing && performance.timing.navigationStart) || Date.now();\n})();\n//# sourceMappingURL=time.js.map","/**\n  * vee-validate v4.6.6\n  * (c) 2022 Abdelrahman Awad\n  * @license MIT\n  */\nfunction isCallable(fn) {\r\n    return typeof fn === 'function';\r\n}\r\nconst isObject = (obj) => obj !== null && !!obj && typeof obj === 'object' && !Array.isArray(obj);\n\n/**\r\n * Replaces placeholder values in a string with their actual values\r\n */\r\nfunction interpolate(template, values) {\r\n    return template.replace(/(\\d:)?{([^}]+)}/g, function (_, param, placeholder) {\r\n        if (!param || !values.params) {\r\n            return placeholder in values\r\n                ? values[placeholder]\r\n                : values.params && placeholder in values.params\r\n                    ? values.params[placeholder]\r\n                    : `{${placeholder}}`;\r\n        }\r\n        // Handles extended object params format\r\n        if (!Array.isArray(values.params)) {\r\n            return placeholder in values.params ? values.params[placeholder] : `{${placeholder}}`;\r\n        }\r\n        // Extended Params exit in the format of `paramIndex:{paramName}` where the index is optional\r\n        const paramIndex = Number(param.replace(':', ''));\r\n        return paramIndex in values.params ? values.params[paramIndex] : `${param}{${placeholder}}`;\r\n    });\r\n}\r\nfunction merge(target, source) {\r\n    Object.keys(source).forEach(key => {\r\n        if (isObject(source[key])) {\r\n            if (!target[key]) {\r\n                target[key] = {};\r\n            }\r\n            merge(target[key], source[key]);\r\n            return;\r\n        }\r\n        target[key] = source[key];\r\n    });\r\n    return target;\r\n}\n\nclass Dictionary {\r\n    constructor(locale, dictionary) {\r\n        this.container = {};\r\n        this.locale = locale;\r\n        this.merge(dictionary);\r\n    }\r\n    resolve(ctx) {\r\n        return this.format(this.locale, ctx);\r\n    }\r\n    getLocaleDefault(locale, field) {\r\n        var _a, _b, _c, _d, _e;\r\n        return ((_c = (_b = (_a = this.container[locale]) === null || _a === void 0 ? void 0 : _a.fields) === null || _b === void 0 ? void 0 : _b[field]) === null || _c === void 0 ? void 0 : _c._default) || ((_e = (_d = this.container[locale]) === null || _d === void 0 ? void 0 : _d.messages) === null || _e === void 0 ? void 0 : _e._default);\r\n    }\r\n    format(locale, ctx) {\r\n        var _a, _b, _c, _d, _e, _f, _g, _h;\r\n        let message;\r\n        const { field, rule, form } = ctx;\r\n        const fieldName = (_c = (_b = (_a = this.container[locale]) === null || _a === void 0 ? void 0 : _a.names) === null || _b === void 0 ? void 0 : _b[field]) !== null && _c !== void 0 ? _c : field;\r\n        if (!rule) {\r\n            message = this.getLocaleDefault(locale, field) || `${fieldName} is not valid`;\r\n            return isCallable(message) ? message(ctx) : interpolate(message, Object.assign(Object.assign({}, form), { field: fieldName }));\r\n        }\r\n        // find if specific message for that field was specified.\r\n        message = ((_f = (_e = (_d = this.container[locale]) === null || _d === void 0 ? void 0 : _d.fields) === null || _e === void 0 ? void 0 : _e[field]) === null || _f === void 0 ? void 0 : _f[rule.name]) || ((_h = (_g = this.container[locale]) === null || _g === void 0 ? void 0 : _g.messages) === null || _h === void 0 ? void 0 : _h[rule.name]);\r\n        if (!message) {\r\n            message = this.getLocaleDefault(locale, field) || `${fieldName} is not valid`;\r\n        }\r\n        return isCallable(message)\r\n            ? message(ctx)\r\n            : interpolate(message, Object.assign(Object.assign({}, form), { field: fieldName, params: rule.params }));\r\n    }\r\n    merge(dictionary) {\r\n        merge(this.container, dictionary);\r\n    }\r\n}\r\nlet DICTIONARY;\r\nfunction localize(locale, dictionary) {\r\n    if (!DICTIONARY) {\r\n        DICTIONARY = new Dictionary('en', {});\r\n    }\r\n    const generateMessage = ctx => {\r\n        return DICTIONARY.resolve(ctx);\r\n    };\r\n    if (typeof locale === 'string') {\r\n        DICTIONARY.locale = locale;\r\n        if (dictionary) {\r\n            DICTIONARY.merge({ [locale]: dictionary });\r\n        }\r\n        return generateMessage;\r\n    }\r\n    DICTIONARY.merge(locale);\r\n    return generateMessage;\r\n}\r\n/**\r\n * Sets the locale\r\n */\r\nfunction setLocale(locale) {\r\n    DICTIONARY.locale = locale;\r\n}\r\n/**\r\n * Loads a locale file from URL and merges it with the current dictionary\r\n */\r\nasync function loadLocaleFromURL(url) {\r\n    try {\r\n        const locale = await fetch(url, {\r\n            headers: {\r\n                'content-type': 'application/json',\r\n            },\r\n        }).then(res => res.json());\r\n        if (!locale.code) {\r\n            console.error('Could not identify locale, ensure the locale file contains `code` field');\r\n            return;\r\n        }\r\n        localize({ [locale.code]: locale });\r\n    }\r\n    catch (err) {\r\n        console.error(`Failed to load locale `);\r\n    }\r\n}\n\nexport { loadLocaleFromURL, localize, setLocale };\n","/**\n  * vee-validate v4.6.6\n  * (c) 2022 Abdelrahman Awad\n  * @license MIT\n  */\n/* eslint-disable no-misleading-character-class */\r\n/**\r\n * Some Alpha Regex helpers.\r\n * https://github.com/chriso/validator.js/blob/master/src/lib/alpha.js\r\n */\r\nconst alpha = {\r\n    en: /^[A-Z]*$/i,\r\n    cs: /^[A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ]*$/i,\r\n    da: /^[A-ZÆØÅ]*$/i,\r\n    de: /^[A-ZÄÖÜß]*$/i,\r\n    es: /^[A-ZÁÉÍÑÓÚÜ]*$/i,\r\n    fr: /^[A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ]*$/i,\r\n    it: /^[A-Z\\xC0-\\xFF]*$/i,\r\n    lt: /^[A-ZĄČĘĖĮŠŲŪŽ]*$/i,\r\n    nl: /^[A-ZÉËÏÓÖÜ]*$/i,\r\n    hu: /^[A-ZÁÉÍÓÖŐÚÜŰ]*$/i,\r\n    pl: /^[A-ZĄĆĘŚŁŃÓŻŹ]*$/i,\r\n    pt: /^[A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ]*$/i,\r\n    ru: /^[А-ЯЁ]*$/i,\r\n    sk: /^[A-ZÁÄČĎÉÍĹĽŇÓŔŠŤÚÝŽ]*$/i,\r\n    sr: /^[A-ZČĆŽŠĐ]*$/i,\r\n    sv: /^[A-ZÅÄÖ]*$/i,\r\n    tr: /^[A-ZÇĞİıÖŞÜ]*$/i,\r\n    uk: /^[А-ЩЬЮЯЄІЇҐ]*$/i,\r\n    ar: /^[ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰ]*$/,\r\n    az: /^[A-ZÇƏĞİıÖŞÜ]*$/i,\r\n    ug: /^[A-Zچۋېرتيۇڭوپھسداەىقكلزشغۈبنمژفگخجۆئ]*$/i,\r\n};\r\nconst alphaSpaces = {\r\n    en: /^[A-Z\\s]*$/i,\r\n    cs: /^[A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ\\s]*$/i,\r\n    da: /^[A-ZÆØÅ\\s]*$/i,\r\n    de: /^[A-ZÄÖÜß\\s]*$/i,\r\n    es: /^[A-ZÁÉÍÑÓÚÜ\\s]*$/i,\r\n    fr: /^[A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ\\s]*$/i,\r\n    it: /^[A-Z\\xC0-\\xFF\\s]*$/i,\r\n    lt: /^[A-ZĄČĘĖĮŠŲŪŽ\\s]*$/i,\r\n    nl: /^[A-ZÉËÏÓÖÜ\\s]*$/i,\r\n    hu: /^[A-ZÁÉÍÓÖŐÚÜŰ\\s]*$/i,\r\n    pl: /^[A-ZĄĆĘŚŁŃÓŻŹ\\s]*$/i,\r\n    pt: /^[A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ\\s]*$/i,\r\n    ru: /^[А-ЯЁ\\s]*$/i,\r\n    sk: /^[A-ZÁÄČĎÉÍĹĽŇÓŔŠŤÚÝŽ\\s]*$/i,\r\n    sr: /^[A-ZČĆŽŠĐ\\s]*$/i,\r\n    sv: /^[A-ZÅÄÖ\\s]*$/i,\r\n    tr: /^[A-ZÇĞİıÖŞÜ\\s]*$/i,\r\n    uk: /^[А-ЩЬЮЯЄІЇҐ\\s]*$/i,\r\n    ar: /^[ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰ\\s]*$/,\r\n    az: /^[A-ZÇƏĞİıÖŞÜ\\s]*$/i,\r\n    ug: /^[A-Zچۋېرتيۇڭوپھسداەىقكلزشغۈبنمژفگخجۆئ\\s]*$/i,\r\n};\r\nconst alphanumeric = {\r\n    en: /^[0-9A-Z]*$/i,\r\n    cs: /^[0-9A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ]*$/i,\r\n    da: /^[0-9A-ZÆØÅ]$/i,\r\n    de: /^[0-9A-ZÄÖÜß]*$/i,\r\n    es: /^[0-9A-ZÁÉÍÑÓÚÜ]*$/i,\r\n    fr: /^[0-9A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ]*$/i,\r\n    it: /^[0-9A-Z\\xC0-\\xFF]*$/i,\r\n    lt: /^[0-9A-ZĄČĘĖĮŠŲŪŽ]*$/i,\r\n    hu: /^[0-9A-ZÁÉÍÓÖŐÚÜŰ]*$/i,\r\n    nl: /^[0-9A-ZÉËÏÓÖÜ]*$/i,\r\n    pl: /^[0-9A-ZĄĆĘŚŁŃÓŻŹ]*$/i,\r\n    pt: /^[0-9A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ]*$/i,\r\n    ru: /^[0-9А-ЯЁ]*$/i,\r\n    sk: /^[0-9A-ZÁÄČĎÉÍĹĽŇÓŔŠŤÚÝŽ]*$/i,\r\n    sr: /^[0-9A-ZČĆŽŠĐ]*$/i,\r\n    sv: /^[0-9A-ZÅÄÖ]*$/i,\r\n    tr: /^[0-9A-ZÇĞİıÖŞÜ]*$/i,\r\n    uk: /^[0-9А-ЩЬЮЯЄІЇҐ]*$/i,\r\n    ar: /^[٠١٢٣٤٥٦٧٨٩0-9ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰ]*$/,\r\n    az: /^[0-9A-ZÇƏĞİıÖŞÜ]*$/i,\r\n    ug: /^[0-9A-Zچۋېرتيۇڭوپھسداەىقكلزشغۈبنمژفگخجۆئ]*$/i,\r\n};\r\nconst alphaDash = {\r\n    en: /^[0-9A-Z_-]*$/i,\r\n    cs: /^[0-9A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ_-]*$/i,\r\n    da: /^[0-9A-ZÆØÅ_-]*$/i,\r\n    de: /^[0-9A-ZÄÖÜß_-]*$/i,\r\n    es: /^[0-9A-ZÁÉÍÑÓÚÜ_-]*$/i,\r\n    fr: /^[0-9A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ_-]*$/i,\r\n    it: /^[0-9A-Z\\xC0-\\xFF_-]*$/i,\r\n    lt: /^[0-9A-ZĄČĘĖĮŠŲŪŽ_-]*$/i,\r\n    nl: /^[0-9A-ZÉËÏÓÖÜ_-]*$/i,\r\n    hu: /^[0-9A-ZÁÉÍÓÖŐÚÜŰ_-]*$/i,\r\n    pl: /^[0-9A-ZĄĆĘŚŁŃÓŻŹ_-]*$/i,\r\n    pt: /^[0-9A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ_-]*$/i,\r\n    ru: /^[0-9А-ЯЁ_-]*$/i,\r\n    sk: /^[0-9A-ZÁÄČĎÉÍĹĽŇÓŔŠŤÚÝŽ_-]*$/i,\r\n    sr: /^[0-9A-ZČĆŽŠĐ_-]*$/i,\r\n    sv: /^[0-9A-ZÅÄÖ_-]*$/i,\r\n    tr: /^[0-9A-ZÇĞİıÖŞÜ_-]*$/i,\r\n    uk: /^[0-9А-ЩЬЮЯЄІЇҐ_-]*$/i,\r\n    ar: /^[٠١٢٣٤٥٦٧٨٩0-9ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰ_-]*$/,\r\n    az: /^[0-9A-ZÇƏĞİıÖŞÜ_-]*$/i,\r\n    ug: /^[0-9A-Zچۋېرتيۇڭوپھسداەىقكلزشغۈبنمژفگخجۆئ_-]*$/i,\r\n};\r\nconst getLocale = (params) => {\r\n    if (!params) {\r\n        return undefined;\r\n    }\r\n    return Array.isArray(params) ? params[0] : params.locale;\r\n};\n\nfunction getSingleParam(params, paramName) {\r\n    return Array.isArray(params) ? params[0] : params[paramName];\r\n}\r\nfunction isEmpty(value) {\r\n    if (value === null || value === undefined || value === '') {\r\n        return true;\r\n    }\r\n    if (Array.isArray(value) && value.length === 0) {\r\n        return true;\r\n    }\r\n    return false;\r\n}\n\nconst alphaValidator = (value, params) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    const locale = getLocale(params);\r\n    if (Array.isArray(value)) {\r\n        return value.every(val => alphaValidator(val, { locale }));\r\n    }\r\n    const valueAsString = String(value);\r\n    // Match at least one locale.\r\n    if (!locale) {\r\n        return Object.keys(alpha).some(loc => alpha[loc].test(valueAsString));\r\n    }\r\n    return (alpha[locale] || alpha.en).test(valueAsString);\r\n};\n\nconst alphaDashValidator = (value, params) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    const locale = getLocale(params);\r\n    if (Array.isArray(value)) {\r\n        return value.every(val => alphaDashValidator(val, { locale }));\r\n    }\r\n    const valueAsString = String(value);\r\n    // Match at least one locale.\r\n    if (!locale) {\r\n        return Object.keys(alphaDash).some(loc => alphaDash[loc].test(valueAsString));\r\n    }\r\n    return (alphaDash[locale] || alphaDash.en).test(valueAsString);\r\n};\n\nconst alphaNumValidator = (value, params) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    const locale = getLocale(params);\r\n    if (Array.isArray(value)) {\r\n        return value.every(val => alphaNumValidator(val, { locale }));\r\n    }\r\n    const valueAsString = String(value);\r\n    // Match at least one locale.\r\n    if (!locale) {\r\n        return Object.keys(alphanumeric).some(loc => alphanumeric[loc].test(valueAsString));\r\n    }\r\n    return (alphanumeric[locale] || alphanumeric.en).test(valueAsString);\r\n};\n\nconst alphaSpacesValidator = (value, params) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    const locale = getLocale(params);\r\n    if (Array.isArray(value)) {\r\n        return value.every(val => alphaSpacesValidator(val, { locale }));\r\n    }\r\n    const valueAsString = String(value);\r\n    // Match at least one locale.\r\n    if (!locale) {\r\n        return Object.keys(alphaSpaces).some(loc => alphaSpaces[loc].test(valueAsString));\r\n    }\r\n    return (alphaSpaces[locale] || alphaSpaces.en).test(valueAsString);\r\n};\n\nfunction getParams$1(params) {\r\n    if (!params) {\r\n        return {\r\n            min: 0,\r\n            max: 0,\r\n        };\r\n    }\r\n    if (Array.isArray(params)) {\r\n        return { min: params[0], max: params[1] };\r\n    }\r\n    return params;\r\n}\r\nconst betweenValidator = (value, params) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    const { min, max } = getParams$1(params);\r\n    if (Array.isArray(value)) {\r\n        return value.every(val => !!betweenValidator(val, { min, max }));\r\n    }\r\n    const valueAsNumber = Number(value);\r\n    return Number(min) <= valueAsNumber && Number(max) >= valueAsNumber;\r\n};\n\nconst confirmedValidator = (value, params) => {\r\n    const target = getSingleParam(params, 'target');\r\n    return String(value) === String(target);\r\n};\n\nconst digitsValidator = (value, params) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    const length = getSingleParam(params, 'length');\r\n    if (Array.isArray(value)) {\r\n        return value.every(val => digitsValidator(val, { length }));\r\n    }\r\n    const strVal = String(value);\r\n    return /^[0-9]*$/.test(strVal) && strVal.length === Number(length);\r\n};\n\nconst validateImage = (file, width, height) => {\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    const URL = window.URL || window.webkitURL;\r\n    return new Promise(resolve => {\r\n        const image = new Image();\r\n        image.onerror = () => resolve(false);\r\n        image.onload = () => resolve(image.width === width && image.height === height);\r\n        image.src = URL.createObjectURL(file);\r\n    });\r\n};\r\nfunction getParams(params) {\r\n    if (!params) {\r\n        return { width: 0, height: 0 };\r\n    }\r\n    if (Array.isArray(params)) {\r\n        return { width: Number(params[0]), height: Number(params[1]) };\r\n    }\r\n    return {\r\n        width: Number(params.width),\r\n        height: Number(params.height),\r\n    };\r\n}\r\nconst dimensionsValidator = (files, params) => {\r\n    if (isEmpty(files)) {\r\n        return true;\r\n    }\r\n    const { width, height } = getParams(params);\r\n    const list = [];\r\n    const fileList = Array.isArray(files) ? files : [files];\r\n    for (let i = 0; i < fileList.length; i++) {\r\n        // if file is not an image, reject.\r\n        if (!/\\.(jpg|svg|jpeg|png|bmp|gif)$/i.test(fileList[i].name)) {\r\n            return Promise.resolve(false);\r\n        }\r\n        list.push(fileList[i]);\r\n    }\r\n    return Promise.all(list.map(file => validateImage(file, width, height))).then(values => {\r\n        return values.every(v => v);\r\n    });\r\n};\n\n/* eslint-disable no-useless-escape */\r\nconst emailValidator = (value) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    const re = /^(([^<>()\\[\\]\\\\.,;:\\s@\"]+(\\.[^<>()\\[\\]\\\\.,;:\\s@\"]+)*)|(\".+\"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$/;\r\n    if (Array.isArray(value)) {\r\n        return value.every(val => re.test(String(val)));\r\n    }\r\n    return re.test(String(value));\r\n};\n\nconst extValidator = (files, extensions) => {\r\n    if (isEmpty(files)) {\r\n        return true;\r\n    }\r\n    if (!extensions) {\r\n        extensions = [];\r\n    }\r\n    const regex = new RegExp(`.(${extensions.join('|')})$`, 'i');\r\n    if (Array.isArray(files)) {\r\n        return files.every(file => regex.test(file.name));\r\n    }\r\n    return regex.test(files.name);\r\n};\n\nconst imageValidator = (files) => {\r\n    if (isEmpty(files)) {\r\n        return true;\r\n    }\r\n    const regex = /\\.(jpg|svg|jpeg|png|bmp|gif|webp)$/i;\r\n    if (Array.isArray(files)) {\r\n        return files.every(file => regex.test(file.name));\r\n    }\r\n    return regex.test(files.name);\r\n};\n\nconst integerValidator = (value) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    if (Array.isArray(value)) {\r\n        return value.every(val => /^-?[0-9]+$/.test(String(val)));\r\n    }\r\n    return /^-?[0-9]+$/.test(String(value));\r\n};\n\nconst isValidator = (value, params) => {\r\n    const other = getSingleParam(params, 'other');\r\n    return value === other;\r\n};\n\nconst isNotValidator = (value, params) => {\r\n    const other = getSingleParam(params, 'other');\r\n    return value !== other;\r\n};\n\nfunction isNullOrUndefined(value) {\r\n    return value === null || value === undefined;\r\n}\r\nfunction isEmptyArray(arr) {\r\n    return Array.isArray(arr) && arr.length === 0;\r\n}\n\nconst lengthValidator = (value, params) => {\r\n    // Normalize the length value\r\n    const length = getSingleParam(params, 'length');\r\n    if (isNullOrUndefined(value)) {\r\n        return false;\r\n    }\r\n    if (typeof value === 'number') {\r\n        value = String(value);\r\n    }\r\n    if (!value.length) {\r\n        value = Array.from(value);\r\n    }\r\n    return value.length === Number(length);\r\n};\n\nconst maxLengthValidator = (value, params) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    const length = getSingleParam(params, 'length');\r\n    if (Array.isArray(value)) {\r\n        return value.every(val => maxLengthValidator(val, { length }));\r\n    }\r\n    return String(value).length <= Number(length);\r\n};\n\nconst maxValueValidator = (value, params) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    const max = getSingleParam(params, 'max');\r\n    if (Array.isArray(value)) {\r\n        return value.length > 0 && value.every(val => maxValueValidator(val, { max }));\r\n    }\r\n    return Number(value) <= Number(max);\r\n};\n\nconst mimesValidator = (files, mimes) => {\r\n    if (isEmpty(files)) {\r\n        return true;\r\n    }\r\n    if (!mimes) {\r\n        mimes = [];\r\n    }\r\n    const regex = new RegExp(`${mimes.join('|').replace('*', '.+')}$`, 'i');\r\n    if (Array.isArray(files)) {\r\n        return files.every(file => regex.test(file.type));\r\n    }\r\n    return regex.test(files.type);\r\n};\n\nconst minValidator = (value, params) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    const length = getSingleParam(params, 'length');\r\n    if (Array.isArray(value)) {\r\n        return value.every(val => minValidator(val, { length }));\r\n    }\r\n    return String(value).length >= Number(length);\r\n};\n\nconst minValueValidator = (value, params) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    const min = getSingleParam(params, 'min');\r\n    if (Array.isArray(value)) {\r\n        return value.length > 0 && value.every(val => minValueValidator(val, { min }));\r\n    }\r\n    return Number(value) >= Number(min);\r\n};\n\nconst oneOfValidator = (value, list) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    if (Array.isArray(value)) {\r\n        return value.every(val => oneOfValidator(val, list));\r\n    }\r\n    return Array.from(list).some(item => {\r\n        // eslint-disable-next-line\r\n        return item == value;\r\n    });\r\n};\n\nconst excludedValidator = (value, list) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    return !oneOfValidator(value, list);\r\n};\n\nconst ar = /^[٠١٢٣٤٥٦٧٨٩]+$/;\r\nconst en = /^[0-9]+$/;\r\nconst numericValidator = (value) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    const testValue = (val) => {\r\n        const strValue = String(val);\r\n        return en.test(strValue) || ar.test(strValue);\r\n    };\r\n    if (Array.isArray(value)) {\r\n        return value.every(testValue);\r\n    }\r\n    return testValue(value);\r\n};\n\nconst regexValidator = (value, params) => {\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    let regex = getSingleParam(params, 'regex');\r\n    if (typeof regex === 'string') {\r\n        regex = new RegExp(regex);\r\n    }\r\n    if (Array.isArray(value)) {\r\n        return value.every(val => regexValidator(val, { regex }));\r\n    }\r\n    return regex.test(String(value));\r\n};\n\nconst requiredValidator = (value) => {\r\n    if (isNullOrUndefined(value) || isEmptyArray(value) || value === false) {\r\n        return false;\r\n    }\r\n    return !!String(value).trim().length;\r\n};\n\nconst sizeValidator = (files, params) => {\r\n    if (isEmpty(files)) {\r\n        return true;\r\n    }\r\n    let size = getSingleParam(params, 'size');\r\n    size = Number(size);\r\n    if (isNaN(size)) {\r\n        return false;\r\n    }\r\n    const nSize = size * 1024;\r\n    if (!Array.isArray(files)) {\r\n        return files.size <= nSize;\r\n    }\r\n    for (let i = 0; i < files.length; i++) {\r\n        if (files[i].size > nSize) {\r\n            return false;\r\n        }\r\n    }\r\n    return true;\r\n};\n\nconst urlValidator = (value, params) => {\r\n    var _a;\r\n    if (isEmpty(value)) {\r\n        return true;\r\n    }\r\n    let pattern = getSingleParam(params, 'pattern');\r\n    if (typeof pattern === 'string') {\r\n        pattern = new RegExp(pattern);\r\n    }\r\n    try {\r\n        // eslint-disable-next-line no-new\r\n        new URL(value);\r\n    }\r\n    catch (_b) {\r\n        return false;\r\n    }\r\n    return (_a = pattern === null || pattern === void 0 ? void 0 : pattern.test(value)) !== null && _a !== void 0 ? _a : true;\r\n};\n\n/* eslint-disable camelcase */\r\nconst all = {\r\n    alpha_dash: alphaDashValidator,\r\n    alpha_num: alphaNumValidator,\r\n    alpha_spaces: alphaSpacesValidator,\r\n    alpha: alphaValidator,\r\n    between: betweenValidator,\r\n    confirmed: confirmedValidator,\r\n    digits: digitsValidator,\r\n    dimensions: dimensionsValidator,\r\n    email: emailValidator,\r\n    ext: extValidator,\r\n    image: imageValidator,\r\n    integer: integerValidator,\r\n    is_not: isNotValidator,\r\n    is: isValidator,\r\n    length: lengthValidator,\r\n    max_value: maxValueValidator,\r\n    max: maxLengthValidator,\r\n    mimes: mimesValidator,\r\n    min_value: minValueValidator,\r\n    min: minValidator,\r\n    not_one_of: excludedValidator,\r\n    numeric: numericValidator,\r\n    one_of: oneOfValidator,\r\n    regex: regexValidator,\r\n    required: requiredValidator,\r\n    size: sizeValidator,\r\n    url: urlValidator,\r\n};\n\nexport { alphaValidator as alpha, alphaDashValidator as alpha_dash, alphaNumValidator as alpha_num, alphaSpacesValidator as alpha_spaces, betweenValidator as between, confirmedValidator as confirmed, all as default, digitsValidator as digits, dimensionsValidator as dimensions, emailValidator as email, extValidator as ext, imageValidator as image, integerValidator as integer, isValidator as is, isNotValidator as is_not, lengthValidator as length, maxLengthValidator as max, maxValueValidator as max_value, mimesValidator as mimes, minValidator as min, minValueValidator as min_value, excludedValidator as not_one_of, numericValidator as numeric, oneOfValidator as one_of, regexValidator as regex, requiredValidator as required, sizeValidator as size, urlValidator as url };\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/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __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\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import assertString from './util/assertString';\n\n/* eslint-disable max-len */\nconst phones = {\n  'am-AM': /^(\\+?374|0)((10|[9|7][0-9])\\d{6}$|[2-4]\\d{7}$)/,\n  'ar-AE': /^((\\+?971)|0)?5[024568]\\d{7}$/,\n  'ar-BH': /^(\\+?973)?(3|6)\\d{7}$/,\n  'ar-DZ': /^(\\+?213|0)(5|6|7)\\d{8}$/,\n  'ar-LB': /^(\\+?961)?((3|81)\\d{6}|7\\d{7})$/,\n  'ar-EG': /^((\\+?20)|0)?1[0125]\\d{8}$/,\n  'ar-IQ': /^(\\+?964|0)?7[0-9]\\d{8}$/,\n  'ar-JO': /^(\\+?962|0)?7[789]\\d{7}$/,\n  'ar-KW': /^(\\+?965)[569]\\d{7}$/,\n  'ar-LY': /^((\\+?218)|0)?(9[1-6]\\d{7}|[1-8]\\d{7,9})$/,\n  'ar-MA': /^(?:(?:\\+|00)212|0)[5-7]\\d{8}$/,\n  'ar-OM': /^((\\+|00)968)?(9[1-9])\\d{6}$/,\n  'ar-PS': /^(\\+?970|0)5[6|9](\\d{7})$/,\n  'ar-SA': /^(!?(\\+?966)|0)?5\\d{8}$/,\n  'ar-SY': /^(!?(\\+?963)|0)?9\\d{8}$/,\n  'ar-TN': /^(\\+?216)?[2459]\\d{7}$/,\n  'az-AZ': /^(\\+994|0)(10|5[015]|7[07]|99)\\d{7}$/,\n  'bs-BA': /^((((\\+|00)3876)|06))((([0-3]|[5-6])\\d{6})|(4\\d{7}))$/,\n  'be-BY': /^(\\+?375)?(24|25|29|33|44)\\d{7}$/,\n  'bg-BG': /^(\\+?359|0)?8[789]\\d{7}$/,\n  'bn-BD': /^(\\+?880|0)1[13456789][0-9]{8}$/,\n  'ca-AD': /^(\\+376)?[346]\\d{5}$/,\n  'cs-CZ': /^(\\+?420)? ?[1-9][0-9]{2} ?[0-9]{3} ?[0-9]{3}$/,\n  'da-DK': /^(\\+?45)?\\s?\\d{2}\\s?\\d{2}\\s?\\d{2}\\s?\\d{2}$/,\n  'de-DE': /^((\\+49|0)1)(5[0-25-9]\\d|6([23]|0\\d?)|7([0-57-9]|6\\d))\\d{7,9}$/,\n  'de-AT': /^(\\+43|0)\\d{1,4}\\d{3,12}$/,\n  'de-CH': /^(\\+41|0)([1-9])\\d{1,9}$/,\n  'de-LU': /^(\\+352)?((6\\d1)\\d{6})$/,\n  'dv-MV': /^(\\+?960)?(7[2-9]|91|9[3-9])\\d{7}$/,\n  'el-GR': /^(\\+?30|0)?(69\\d{8})$/,\n  'el-CY': /^(\\+?357?)?(9(9|6)\\d{6})$/,\n  'en-AI': /^(\\+?1|0)264(?:2(35|92)|4(?:6[1-2]|76|97)|5(?:3[6-9]|8[1-4])|7(?:2(4|9)|72))\\d{4}$/,\n  'en-AU': /^(\\+?61|0)4\\d{8}$/,\n  'en-AG': /^(?:\\+1|1)268(?:464|7(?:1[3-9]|[28]\\d|3[0246]|64|7[0-689]))\\d{4}$/,\n  'en-BM': /^(\\+?1)?441(((3|7)\\d{6}$)|(5[0-3][0-9]\\d{4}$)|(59\\d{5}))/,\n  'en-BS': /^(\\+?1[-\\s]?|0)?\\(?242\\)?[-\\s]?\\d{3}[-\\s]?\\d{4}$/,\n  'en-GB': /^(\\+?44|0)7\\d{9}$/,\n  'en-GG': /^(\\+?44|0)1481\\d{6}$/,\n  'en-GH': /^(\\+233|0)(20|50|24|54|27|57|26|56|23|28|55|59)\\d{7}$/,\n  'en-GY': /^(\\+592|0)6\\d{6}$/,\n  'en-HK': /^(\\+?852[-\\s]?)?[456789]\\d{3}[-\\s]?\\d{4}$/,\n  'en-MO': /^(\\+?853[-\\s]?)?[6]\\d{3}[-\\s]?\\d{4}$/,\n  'en-IE': /^(\\+?353|0)8[356789]\\d{7}$/,\n  'en-IN': /^(\\+?91|0)?[6789]\\d{9}$/,\n  'en-JM': /^(\\+?876)?\\d{7}$/,\n  'en-KE': /^(\\+?254|0)(7|1)\\d{8}$/,\n  'en-KI': /^((\\+686|686)?)?( )?((6|7)(2|3|8)[0-9]{6})$/,\n  'en-KN': /^(?:\\+1|1)869(?:46\\d|48[89]|55[6-8]|66\\d|76[02-7])\\d{4}$/,\n  'en-LS': /^(\\+?266)(22|28|57|58|59|27|52)\\d{6}$/,\n  'en-MT': /^(\\+?356|0)?(99|79|77|21|27|22|25)[0-9]{6}$/,\n  'en-MU': /^(\\+?230|0)?\\d{8}$/,\n  'en-NA': /^(\\+?264|0)(6|8)\\d{7}$/,\n  'en-NG': /^(\\+?234|0)?[789]\\d{9}$/,\n  'en-NZ': /^(\\+?64|0)[28]\\d{7,9}$/,\n  'en-PG': /^(\\+?675|0)?(7\\d|8[18])\\d{6}$/,\n  'en-PK': /^((00|\\+)?92|0)3[0-6]\\d{8}$/,\n  'en-PH': /^(09|\\+639)\\d{9}$/,\n  'en-PR': /^\\+1( |-)?(\\((787|939)\\)|787|939)( |-)?([2-9][0-9]{2}( |-)?[0-9]{4})$/,\n  'en-RW': /^(\\+?250|0)?[7]\\d{8}$/,\n  'en-SG': /^(\\+65)?[3689]\\d{7}$/,\n  'en-SL': /^(\\+?232|0)\\d{8}$/,\n  'en-TZ': /^(\\+?255|0)?[67]\\d{8}$/,\n  'en-UG': /^(\\+?256|0)?[7]\\d{8}$/,\n  'en-US': /^((\\+1|1)?( |-)?)?(\\([2-9][0-9]{2}\\)|[2-9][0-9]{2})( |-)?([2-9][0-9]{2}( |-)?[0-9]{4})$/,\n  'en-ZA': /^(\\+?27|0)\\d{9}$/,\n  'en-ZM': /^(\\+?26)?09[567]\\d{7}$/,\n  'en-ZW': /^(\\+263)[0-9]{9}$/,\n  'en-BW': /^(\\+?267)?(7[1-8]{1})\\d{6}$/,\n  'es-AR': /^\\+?549?(11|[2368]\\d)\\d{8}$/,\n  'es-BO': /^(\\+?591)?(6|7)\\d{7}$/,\n  'es-CO': /^(\\+?57)?3(0(0|1|2|4|5)|1\\d|2[0-4]|5(0|1))\\d{7}$/,\n  'es-CL': /^(\\+?56|0)[2-9]\\d{1}\\d{7}$/,\n  'es-CR': /^(\\+506)?[2-8]\\d{7}$/,\n  'es-CU': /^(\\+53|0053)?5\\d{7}/,\n  'es-DO': /^(\\+?1)?8[024]9\\d{7}$/,\n  'es-HN': /^(\\+?504)?[2|3|7|8|9]\\d{7}$/,\n  'es-EC': /^(\\+?593|0)([2-7]|9[2-9])\\d{7}$/,\n  'es-ES': /^(\\+?34)?[6|7]\\d{8}$/,\n  'es-PE': /^(\\+?51)?9\\d{8}$/,\n  'es-MX': /^(\\+?52)?(1|01)?\\d{10,11}$/,\n  'es-NI': /^(\\+?505)\\d{7,8}$/,\n  'es-PA': /^(\\+?507)\\d{7,8}$/,\n  'es-PY': /^(\\+?595|0)9[9876]\\d{7}$/,\n  'es-SV': /^(\\+?503)?[67]\\d{7}$/,\n  'es-UY': /^(\\+598|0)9[1-9][\\d]{6}$/,\n  'es-VE': /^(\\+?58)?(2|4)\\d{9}$/,\n  'es-GT': /^(\\+?502)?(2|3|4|5|7)\\d{7}$/,\n  'et-EE': /^(\\+?372)?\\s?(5|8[1-4])\\s?([0-9]\\s?){6,7}$/,\n  'fa-IR': /^(\\+?98[\\-\\s]?|0)9[0-39]\\d[\\-\\s]?\\d{3}[\\-\\s]?\\d{4}$/,\n  'fi-FI': /^(\\+?358|0)\\s?(4[0-6]|50)\\s?(\\d\\s?){4,8}$/,\n  'fj-FJ': /^(\\+?679)?\\s?\\d{3}\\s?\\d{4}$/,\n  'fo-FO': /^(\\+?298)?\\s?\\d{2}\\s?\\d{2}\\s?\\d{2}$/,\n  'fr-BF': /^(\\+226|0)[67]\\d{7}$/,\n  'fr-BJ': /^(\\+229)\\d{8}$/,\n  'fr-CM': /^(\\+?237)6[0-9]{8}$/,\n  'fr-FR': /^(\\+?33|0)[67]\\d{8}$/,\n  'fr-GF': /^(\\+?594|0|00594)[67]\\d{8}$/,\n  'fr-GP': /^(\\+?590|0|00590)[67]\\d{8}$/,\n  'fr-MQ': /^(\\+?596|0|00596)[67]\\d{8}$/,\n  'fr-PF': /^(\\+?689)?8[789]\\d{6}$/,\n  'fr-RE': /^(\\+?262|0|00262)[67]\\d{8}$/,\n  'he-IL': /^(\\+972|0)([23489]|5[012345689]|77)[1-9]\\d{6}$/,\n  'hu-HU': /^(\\+?36|06)(20|30|31|50|70)\\d{7}$/,\n  'id-ID': /^(\\+?62|0)8(1[123456789]|2[1238]|3[1238]|5[12356789]|7[78]|9[56789]|8[123456789])([\\s?|\\d]{5,11})$/,\n  'ir-IR': /^(\\+98|0)?9\\d{9}$/,\n  'it-IT': /^(\\+?39)?\\s?3\\d{2} ?\\d{6,7}$/,\n  'it-SM': /^((\\+378)|(0549)|(\\+390549)|(\\+3780549))?6\\d{5,9}$/,\n  'ja-JP': /^(\\+81[ \\-]?(\\(0\\))?|0)[6789]0[ \\-]?\\d{4}[ \\-]?\\d{4}$/,\n  'ka-GE': /^(\\+?995)?(79\\d{7}|5\\d{8})$/,\n  'kk-KZ': /^(\\+?7|8)?7\\d{9}$/,\n  'kl-GL': /^(\\+?299)?\\s?\\d{2}\\s?\\d{2}\\s?\\d{2}$/,\n  'ko-KR': /^((\\+?82)[ \\-]?)?0?1([0|1|6|7|8|9]{1})[ \\-]?\\d{3,4}[ \\-]?\\d{4}$/,\n  'ky-KG': /^(\\+?7\\s?\\+?7|0)\\s?\\d{2}\\s?\\d{3}\\s?\\d{4}$/,\n  'lt-LT': /^(\\+370|8)\\d{8}$/,\n  'lv-LV': /^(\\+?371)2\\d{7}$/,\n  'mg-MG': /^((\\+?261|0)(2|3)\\d)?\\d{7}$/,\n  'mn-MN': /^(\\+|00|011)?976(77|81|88|91|94|95|96|99)\\d{6}$/,\n  'my-MM': /^(\\+?959|09|9)(2[5-7]|3[1-2]|4[0-5]|6[6-9]|7[5-9]|9[6-9])[0-9]{7}$/,\n  'ms-MY': /^(\\+?6?01){1}(([0145]{1}(\\-|\\s)?\\d{7,8})|([236789]{1}(\\s|\\-)?\\d{7}))$/,\n  'mz-MZ': /^(\\+?258)?8[234567]\\d{7}$/,\n  'nb-NO': /^(\\+?47)?[49]\\d{7}$/,\n  'ne-NP': /^(\\+?977)?9[78]\\d{8}$/,\n  'nl-BE': /^(\\+?32|0)4\\d{8}$/,\n  'nl-NL': /^(((\\+|00)?31\\(0\\))|((\\+|00)?31)|0)6{1}\\d{8}$/,\n  'nl-AW': /^(\\+)?297(56|59|64|73|74|99)\\d{5}$/,\n  'nn-NO': /^(\\+?47)?[49]\\d{7}$/,\n  'pl-PL': /^(\\+?48)? ?[5-8]\\d ?\\d{3} ?\\d{2} ?\\d{2}$/,\n  'pt-BR': /^((\\+?55\\ ?[1-9]{2}\\ ?)|(\\+?55\\ ?\\([1-9]{2}\\)\\ ?)|(0[1-9]{2}\\ ?)|(\\([1-9]{2}\\)\\ ?)|([1-9]{2}\\ ?))((\\d{4}\\-?\\d{4})|(9[1-9]{1}\\d{3}\\-?\\d{4}))$/,\n  'pt-PT': /^(\\+?351)?9[1236]\\d{7}$/,\n  'pt-AO': /^(\\+244)\\d{9}$/,\n  'ro-RO': /^(\\+?4?0)\\s?7\\d{2}(\\/|\\s|\\.|\\-)?\\d{3}(\\s|\\.|\\-)?\\d{3}$/,\n  'ru-RU': /^(\\+?7|8)?9\\d{9}$/,\n  'si-LK': /^(?:0|94|\\+94)?(7(0|1|2|4|5|6|7|8)( |-)?)\\d{7}$/,\n  'sl-SI': /^(\\+386\\s?|0)(\\d{1}\\s?\\d{3}\\s?\\d{2}\\s?\\d{2}|\\d{2}\\s?\\d{3}\\s?\\d{3})$/,\n  'sk-SK': /^(\\+?421)? ?[1-9][0-9]{2} ?[0-9]{3} ?[0-9]{3}$/,\n  'sq-AL': /^(\\+355|0)6[789]\\d{6}$/,\n  'sr-RS': /^(\\+3816|06)[- \\d]{5,9}$/,\n  'sv-SE': /^(\\+?46|0)[\\s\\-]?7[\\s\\-]?[02369]([\\s\\-]?\\d){7}$/,\n  'tg-TJ': /^(\\+?992)?[5][5]\\d{7}$/,\n  'th-TH': /^(\\+66|66|0)\\d{9}$/,\n  'tr-TR': /^(\\+?90|0)?5\\d{9}$/,\n  'tk-TM': /^(\\+993|993|8)\\d{8}$/,\n  'uk-UA': /^(\\+?38|8)?0\\d{9}$/,\n  'uz-UZ': /^(\\+?998)?(6[125-79]|7[1-69]|88|9\\d)\\d{7}$/,\n  'vi-VN': /^((\\+?84)|0)((3([2-9]))|(5([25689]))|(7([0|6-9]))|(8([1-9]))|(9([0-9])))([0-9]{7})$/,\n  'zh-CN': /^((\\+|00)86)?(1[3-9]|9[28])\\d{9}$/,\n  'zh-TW': /^(\\+?886\\-?|0)?9\\d{8}$/,\n  'dz-BT': /^(\\+?975|0)?(17|16|77|02)\\d{6}$/,\n  'ar-YE': /^(((\\+|00)9677|0?7)[0137]\\d{7}|((\\+|00)967|0)[1-7]\\d{6})$/,\n  'ar-EH': /^(\\+?212|0)[\\s\\-]?(5288|5289)[\\s\\-]?\\d{5}$/,\n  'fa-AF': /^(\\+93|0)?(2{1}[0-8]{1}|[3-5]{1}[0-4]{1})(\\d{7})$/,\n};\n/* eslint-enable max-len */\n\n// aliases\nphones['en-CA'] = phones['en-US'];\nphones['fr-CA'] = phones['en-CA'];\nphones['fr-BE'] = phones['nl-BE'];\nphones['zh-HK'] = phones['en-HK'];\nphones['zh-MO'] = phones['en-MO'];\nphones['ga-IE'] = phones['en-IE'];\nphones['fr-CH'] = phones['de-CH'];\nphones['it-CH'] = phones['fr-CH'];\n\nexport default function isMobilePhone(str, locale, options) {\n  assertString(str);\n  if (options && options.strictMode && !str.startsWith('+')) {\n    return false;\n  }\n  if (Array.isArray(locale)) {\n    return locale.some((key) => {\n      // https://github.com/gotwarlost/istanbul/blob/master/ignoring-code-for-coverage.md#ignoring-code-for-coverage-purposes\n      // istanbul ignore else\n      if (phones.hasOwnProperty(key)) {\n        const phone = phones[key];\n        if (phone.test(str)) {\n          return true;\n        }\n      }\n      return false;\n    });\n  } else if (locale in phones) {\n    return phones[locale].test(str);\n    // alias falsey locale as 'any'\n  } else if (!locale || locale === 'any') {\n    for (const key in phones) {\n      // istanbul ignore else\n      if (phones.hasOwnProperty(key)) {\n        const phone = phones[key];\n        if (phone.test(str)) {\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n  throw new Error(`Invalid locale '${locale}'`);\n}\n\nexport const locales = Object.keys(phones);\n","export default function assertString(input) {\n  const isString = typeof input === 'string' || input instanceof String;\n\n  if (!isString) {\n    let invalidType = typeof input;\n    if (input === null) invalidType = 'null';\n    else if (invalidType === 'object') invalidType = input.constructor.name;\n\n    throw new TypeError(`Expected a string but received a ${invalidType}`);\n  }\n}\n","/**\n  * vee-validate v4.6.6\n  * (c) 2022 Abdelrahman Awad\n  * @license MIT\n  */\nimport { inject, getCurrentInstance, warn as warn$1, ref, unref, computed, reactive, watch, onUnmounted, nextTick, onMounted, provide, isRef, onBeforeUnmount, defineComponent, toRef, resolveDynamicComponent, h, watchEffect, markRaw } from 'vue';\nimport { setupDevtoolsPlugin } from '@vue/devtools-api';\n\nfunction isCallable(fn) {\r\n    return typeof fn === 'function';\r\n}\r\nfunction isNullOrUndefined(value) {\r\n    return value === null || value === undefined;\r\n}\r\nconst isObject = (obj) => obj !== null && !!obj && typeof obj === 'object' && !Array.isArray(obj);\r\nfunction isIndex(value) {\r\n    return Number(value) >= 0;\r\n}\r\nfunction toNumber(value) {\r\n    const n = parseFloat(value);\r\n    return isNaN(n) ? value : n;\r\n}\n\nconst RULES = {};\r\n/**\r\n * Adds a custom validator to the list of validation rules.\r\n */\r\nfunction defineRule(id, validator) {\r\n    // makes sure new rules are properly formatted.\r\n    guardExtend(id, validator);\r\n    RULES[id] = validator;\r\n}\r\n/**\r\n * Gets an already defined rule\r\n */\r\nfunction resolveRule(id) {\r\n    return RULES[id];\r\n}\r\n/**\r\n * Guards from extension violations.\r\n */\r\nfunction guardExtend(id, validator) {\r\n    if (isCallable(validator)) {\r\n        return;\r\n    }\r\n    throw new Error(`Extension Error: The validator '${id}' must be a function.`);\r\n}\n\nconst FormContextKey = Symbol('vee-validate-form');\r\nconst FieldContextKey = Symbol('vee-validate-field-instance');\r\nconst IS_ABSENT = Symbol('Default empty value');\n\nfunction isLocator(value) {\r\n    return isCallable(value) && !!value.__locatorRef;\r\n}\r\nfunction isYupValidator(value) {\r\n    return !!value && isCallable(value.validate);\r\n}\r\nfunction hasCheckedAttr(type) {\r\n    return type === 'checkbox' || type === 'radio';\r\n}\r\nfunction isContainerValue(value) {\r\n    return isObject(value) || Array.isArray(value);\r\n}\r\n/**\r\n * True if the value is an empty object or array\r\n */\r\nfunction isEmptyContainer(value) {\r\n    if (Array.isArray(value)) {\r\n        return value.length === 0;\r\n    }\r\n    return isObject(value) && Object.keys(value).length === 0;\r\n}\r\n/**\r\n * Checks if the path opted out of nested fields using `[fieldName]` syntax\r\n */\r\nfunction isNotNestedPath(path) {\r\n    return /^\\[.+\\]$/i.test(path);\r\n}\r\n/**\r\n * Checks if an element is a native HTML5 multi-select input element\r\n */\r\nfunction isNativeMultiSelect(el) {\r\n    return isNativeSelect(el) && el.multiple;\r\n}\r\n/**\r\n * Checks if an element is a native HTML5 select input element\r\n */\r\nfunction isNativeSelect(el) {\r\n    return el.tagName === 'SELECT';\r\n}\r\n/**\r\n * Checks if a tag name with attrs object will render a native multi-select element\r\n */\r\nfunction isNativeMultiSelectNode(tag, attrs) {\r\n    // The falsy value array is the values that Vue won't add the `multiple` prop if it has one of these values\r\n    const hasTruthyBindingValue = ![false, null, undefined, 0].includes(attrs.multiple) && !Number.isNaN(attrs.multiple);\r\n    return tag === 'select' && 'multiple' in attrs && hasTruthyBindingValue;\r\n}\r\n/**\r\n * Checks if a node should have a `:value` binding or not\r\n *\r\n * These nodes should not have a value binding\r\n * For files, because they are not reactive\r\n * For multi-selects because the value binding will reset the value\r\n */\r\nfunction shouldHaveValueBinding(tag, attrs) {\r\n    return !isNativeMultiSelectNode(tag, attrs) && attrs.type !== 'file' && !hasCheckedAttr(attrs.type);\r\n}\r\nfunction isFormSubmitEvent(evt) {\r\n    return isEvent(evt) && evt.target && 'submit' in evt.target;\r\n}\r\nfunction isEvent(evt) {\r\n    if (!evt) {\r\n        return false;\r\n    }\r\n    if (typeof Event !== 'undefined' && isCallable(Event) && evt instanceof Event) {\r\n        return true;\r\n    }\r\n    // this is for IE and Cypress #3161\r\n    /* istanbul ignore next */\r\n    if (evt && evt.srcElement) {\r\n        return true;\r\n    }\r\n    return false;\r\n}\r\nfunction isPropPresent(obj, prop) {\r\n    return prop in obj && obj[prop] !== IS_ABSENT;\r\n}\n\n// do not edit .js files directly - edit src/index.jst\n\n\n\nvar fastDeepEqual = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n\nfunction cleanupNonNestedPath(path) {\r\n    if (isNotNestedPath(path)) {\r\n        return path.replace(/\\[|\\]/gi, '');\r\n    }\r\n    return path;\r\n}\r\nfunction getFromPath(object, path, fallback) {\r\n    if (!object) {\r\n        return fallback;\r\n    }\r\n    if (isNotNestedPath(path)) {\r\n        return object[cleanupNonNestedPath(path)];\r\n    }\r\n    const resolvedValue = (path || '')\r\n        .split(/\\.|\\[(\\d+)\\]/)\r\n        .filter(Boolean)\r\n        .reduce((acc, propKey) => {\r\n        if (isContainerValue(acc) && propKey in acc) {\r\n            return acc[propKey];\r\n        }\r\n        return fallback;\r\n    }, object);\r\n    return resolvedValue;\r\n}\r\n/**\r\n * Sets a nested property value in a path, creates the path properties if it doesn't exist\r\n */\r\nfunction setInPath(object, path, value) {\r\n    if (isNotNestedPath(path)) {\r\n        object[cleanupNonNestedPath(path)] = value;\r\n        return;\r\n    }\r\n    const keys = path.split(/\\.|\\[(\\d+)\\]/).filter(Boolean);\r\n    let acc = object;\r\n    for (let i = 0; i < keys.length; i++) {\r\n        // Last key, set it\r\n        if (i === keys.length - 1) {\r\n            acc[keys[i]] = value;\r\n            return;\r\n        }\r\n        // Key does not exist, create a container for it\r\n        if (!(keys[i] in acc) || isNullOrUndefined(acc[keys[i]])) {\r\n            // container can be either an object or an array depending on the next key if it exists\r\n            acc[keys[i]] = isIndex(keys[i + 1]) ? [] : {};\r\n        }\r\n        acc = acc[keys[i]];\r\n    }\r\n}\r\nfunction unset(object, key) {\r\n    if (Array.isArray(object) && isIndex(key)) {\r\n        object.splice(Number(key), 1);\r\n        return;\r\n    }\r\n    if (isObject(object)) {\r\n        delete object[key];\r\n    }\r\n}\r\n/**\r\n * Removes a nested property from object\r\n */\r\nfunction unsetPath(object, path) {\r\n    if (isNotNestedPath(path)) {\r\n        delete object[cleanupNonNestedPath(path)];\r\n        return;\r\n    }\r\n    const keys = path.split(/\\.|\\[(\\d+)\\]/).filter(Boolean);\r\n    let acc = object;\r\n    for (let i = 0; i < keys.length; i++) {\r\n        // Last key, unset it\r\n        if (i === keys.length - 1) {\r\n            unset(acc, keys[i]);\r\n            break;\r\n        }\r\n        // Key does not exist, exit\r\n        if (!(keys[i] in acc) || isNullOrUndefined(acc[keys[i]])) {\r\n            break;\r\n        }\r\n        acc = acc[keys[i]];\r\n    }\r\n    const pathValues = keys.map((_, idx) => {\r\n        return getFromPath(object, keys.slice(0, idx).join('.'));\r\n    });\r\n    for (let i = pathValues.length - 1; i >= 0; i--) {\r\n        if (!isEmptyContainer(pathValues[i])) {\r\n            continue;\r\n        }\r\n        if (i === 0) {\r\n            unset(object, keys[0]);\r\n            continue;\r\n        }\r\n        unset(pathValues[i - 1], keys[i - 1]);\r\n    }\r\n}\r\n/**\r\n * A typed version of Object.keys\r\n */\r\nfunction keysOf(record) {\r\n    return Object.keys(record);\r\n}\r\n// Uses same component provide as its own injections\r\n// Due to changes in https://github.com/vuejs/vue-next/pull/2424\r\nfunction injectWithSelf(symbol, def = undefined) {\r\n    const vm = getCurrentInstance();\r\n    return (vm === null || vm === void 0 ? void 0 : vm.provides[symbol]) || inject(symbol, def);\r\n}\r\nfunction warn(message) {\r\n    warn$1(`[vee-validate]: ${message}`);\r\n}\r\n/**\r\n * Ensures we deal with a singular field value\r\n */\r\nfunction normalizeField(field) {\r\n    if (Array.isArray(field)) {\r\n        return field[0];\r\n    }\r\n    return field;\r\n}\r\nfunction resolveNextCheckboxValue(currentValue, checkedValue, uncheckedValue) {\r\n    if (Array.isArray(currentValue)) {\r\n        const newVal = [...currentValue];\r\n        // Use isEqual since checked object values can possibly fail the equality check #3883\r\n        const idx = newVal.findIndex(v => fastDeepEqual(v, checkedValue));\r\n        idx >= 0 ? newVal.splice(idx, 1) : newVal.push(checkedValue);\r\n        return newVal;\r\n    }\r\n    return fastDeepEqual(currentValue, checkedValue) ? uncheckedValue : checkedValue;\r\n}\r\n/**\r\n * Creates a throttled function that only invokes the provided function (`func`) at most once per within a given number of milliseconds\r\n * (`limit`)\r\n */\r\nfunction throttle(func, limit) {\r\n    let inThrottle;\r\n    let lastResult;\r\n    return function (...args) {\r\n        // eslint-disable-next-line @typescript-eslint/no-this-alias\r\n        const context = this;\r\n        if (!inThrottle) {\r\n            inThrottle = true;\r\n            setTimeout(() => (inThrottle = false), limit);\r\n            lastResult = func.apply(context, args);\r\n        }\r\n        return lastResult;\r\n    };\r\n}\r\nfunction debounceAsync(inner, ms = 0) {\r\n    let timer = null;\r\n    let resolves = [];\r\n    return function (...args) {\r\n        // Run the function after a certain amount of time\r\n        if (timer) {\r\n            window.clearTimeout(timer);\r\n        }\r\n        timer = window.setTimeout(() => {\r\n            // Get the result of the inner function, then apply it to the resolve function of\r\n            // each promise that has been created since the last time the inner function was run\r\n            const result = inner(...args);\r\n            resolves.forEach(r => r(result));\r\n            resolves = [];\r\n        }, ms);\r\n        return new Promise(resolve => resolves.push(resolve));\r\n    };\r\n}\r\nfunction applyModelModifiers(value, modifiers) {\r\n    if (!isObject(modifiers)) {\r\n        return value;\r\n    }\r\n    if (modifiers.number) {\r\n        return toNumber(value);\r\n    }\r\n    return value;\r\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nconst normalizeChildren = (tag, context, slotProps) => {\r\n    if (!context.slots.default) {\r\n        return context.slots.default;\r\n    }\r\n    if (typeof tag === 'string' || !tag) {\r\n        return context.slots.default(slotProps());\r\n    }\r\n    return {\r\n        default: () => { var _a, _b; return (_b = (_a = context.slots).default) === null || _b === void 0 ? void 0 : _b.call(_a, slotProps()); },\r\n    };\r\n};\r\n/**\r\n * Vue adds a `_value` prop at the moment on the input elements to store the REAL value on them, real values are different than the `value` attribute\r\n * as they do not get casted to strings unlike `el.value` which preserves user-code behavior\r\n */\r\nfunction getBoundValue(el) {\r\n    if (hasValueBinding(el)) {\r\n        return el._value;\r\n    }\r\n    return undefined;\r\n}\r\n/**\r\n * Vue adds a `_value` prop at the moment on the input elements to store the REAL value on them, real values are different than the `value` attribute\r\n * as they do not get casted to strings unlike `el.value` which preserves user-code behavior\r\n */\r\nfunction hasValueBinding(el) {\r\n    return '_value' in el;\r\n}\n\nfunction normalizeEventValue(value) {\r\n    if (!isEvent(value)) {\r\n        return value;\r\n    }\r\n    const input = value.target;\r\n    // Vue sets the current bound value on `_value` prop\r\n    // for checkboxes it it should fetch the value binding type as is (boolean instead of string)\r\n    if (hasCheckedAttr(input.type) && hasValueBinding(input)) {\r\n        return getBoundValue(input);\r\n    }\r\n    if (input.type === 'file' && input.files) {\r\n        const files = Array.from(input.files);\r\n        return input.multiple ? files : files[0];\r\n    }\r\n    if (isNativeMultiSelect(input)) {\r\n        return Array.from(input.options)\r\n            .filter(opt => opt.selected && !opt.disabled)\r\n            .map(getBoundValue);\r\n    }\r\n    // makes sure we get the actual `option` bound value\r\n    // #3440\r\n    if (isNativeSelect(input)) {\r\n        const selectedOption = Array.from(input.options).find(opt => opt.selected);\r\n        return selectedOption ? getBoundValue(selectedOption) : input.value;\r\n    }\r\n    return input.value;\r\n}\n\n/**\r\n * Normalizes the given rules expression.\r\n */\r\nfunction normalizeRules(rules) {\r\n    const acc = {};\r\n    Object.defineProperty(acc, '_$$isNormalized', {\r\n        value: true,\r\n        writable: false,\r\n        enumerable: false,\r\n        configurable: false,\r\n    });\r\n    if (!rules) {\r\n        return acc;\r\n    }\r\n    // Object is already normalized, skip.\r\n    if (isObject(rules) && rules._$$isNormalized) {\r\n        return rules;\r\n    }\r\n    if (isObject(rules)) {\r\n        return Object.keys(rules).reduce((prev, curr) => {\r\n            const params = normalizeParams(rules[curr]);\r\n            if (rules[curr] !== false) {\r\n                prev[curr] = buildParams(params);\r\n            }\r\n            return prev;\r\n        }, acc);\r\n    }\r\n    /* istanbul ignore if */\r\n    if (typeof rules !== 'string') {\r\n        return acc;\r\n    }\r\n    return rules.split('|').reduce((prev, rule) => {\r\n        const parsedRule = parseRule(rule);\r\n        if (!parsedRule.name) {\r\n            return prev;\r\n        }\r\n        prev[parsedRule.name] = buildParams(parsedRule.params);\r\n        return prev;\r\n    }, acc);\r\n}\r\n/**\r\n * Normalizes a rule param.\r\n */\r\nfunction normalizeParams(params) {\r\n    if (params === true) {\r\n        return [];\r\n    }\r\n    if (Array.isArray(params)) {\r\n        return params;\r\n    }\r\n    if (isObject(params)) {\r\n        return params;\r\n    }\r\n    return [params];\r\n}\r\nfunction buildParams(provided) {\r\n    const mapValueToLocator = (value) => {\r\n        // A target param using interpolation\r\n        if (typeof value === 'string' && value[0] === '@') {\r\n            return createLocator(value.slice(1));\r\n        }\r\n        return value;\r\n    };\r\n    if (Array.isArray(provided)) {\r\n        return provided.map(mapValueToLocator);\r\n    }\r\n    // #3073\r\n    if (provided instanceof RegExp) {\r\n        return [provided];\r\n    }\r\n    return Object.keys(provided).reduce((prev, key) => {\r\n        prev[key] = mapValueToLocator(provided[key]);\r\n        return prev;\r\n    }, {});\r\n}\r\n/**\r\n * Parses a rule string expression.\r\n */\r\nconst parseRule = (rule) => {\r\n    let params = [];\r\n    const name = rule.split(':')[0];\r\n    if (rule.includes(':')) {\r\n        params = rule.split(':').slice(1).join(':').split(',');\r\n    }\r\n    return { name, params };\r\n};\r\nfunction createLocator(value) {\r\n    const locator = (crossTable) => {\r\n        const val = getFromPath(crossTable, value) || crossTable[value];\r\n        return val;\r\n    };\r\n    locator.__locatorRef = value;\r\n    return locator;\r\n}\r\nfunction extractLocators(params) {\r\n    if (Array.isArray(params)) {\r\n        return params.filter(isLocator);\r\n    }\r\n    return keysOf(params)\r\n        .filter(key => isLocator(params[key]))\r\n        .map(key => params[key]);\r\n}\n\nconst DEFAULT_CONFIG = {\r\n    generateMessage: ({ field }) => `${field} is not valid.`,\r\n    bails: true,\r\n    validateOnBlur: true,\r\n    validateOnChange: true,\r\n    validateOnInput: false,\r\n    validateOnModelUpdate: true,\r\n};\r\nlet currentConfig = Object.assign({}, DEFAULT_CONFIG);\r\nconst getConfig = () => currentConfig;\r\nconst setConfig = (newConf) => {\r\n    currentConfig = Object.assign(Object.assign({}, currentConfig), newConf);\r\n};\r\nconst configure = setConfig;\n\n/**\r\n * Validates a value against the rules.\r\n */\r\nasync function validate(value, rules, options = {}) {\r\n    const shouldBail = options === null || options === void 0 ? void 0 : options.bails;\r\n    const field = {\r\n        name: (options === null || options === void 0 ? void 0 : options.name) || '{field}',\r\n        rules,\r\n        bails: shouldBail !== null && shouldBail !== void 0 ? shouldBail : true,\r\n        formData: (options === null || options === void 0 ? void 0 : options.values) || {},\r\n    };\r\n    const result = await _validate(field, value);\r\n    const errors = result.errors;\r\n    return {\r\n        errors,\r\n        valid: !errors.length,\r\n    };\r\n}\r\n/**\r\n * Starts the validation process.\r\n */\r\nasync function _validate(field, value) {\r\n    if (isYupValidator(field.rules)) {\r\n        return validateFieldWithYup(value, field.rules, { bails: field.bails });\r\n    }\r\n    // if a generic function or chain of generic functions\r\n    if (isCallable(field.rules) || Array.isArray(field.rules)) {\r\n        const ctx = {\r\n            field: field.name,\r\n            form: field.formData,\r\n            value: value,\r\n        };\r\n        // Normalize the pipeline\r\n        const pipeline = Array.isArray(field.rules) ? field.rules : [field.rules];\r\n        const length = pipeline.length;\r\n        const errors = [];\r\n        for (let i = 0; i < length; i++) {\r\n            const rule = pipeline[i];\r\n            const result = await rule(value, ctx);\r\n            const isValid = typeof result !== 'string' && result;\r\n            if (isValid) {\r\n                continue;\r\n            }\r\n            const message = typeof result === 'string' ? result : _generateFieldError(ctx);\r\n            errors.push(message);\r\n            if (field.bails) {\r\n                return {\r\n                    errors,\r\n                };\r\n            }\r\n        }\r\n        return {\r\n            errors,\r\n        };\r\n    }\r\n    const normalizedContext = Object.assign(Object.assign({}, field), { rules: normalizeRules(field.rules) });\r\n    const errors = [];\r\n    const rulesKeys = Object.keys(normalizedContext.rules);\r\n    const length = rulesKeys.length;\r\n    for (let i = 0; i < length; i++) {\r\n        const rule = rulesKeys[i];\r\n        const result = await _test(normalizedContext, value, {\r\n            name: rule,\r\n            params: normalizedContext.rules[rule],\r\n        });\r\n        if (result.error) {\r\n            errors.push(result.error);\r\n            if (field.bails) {\r\n                return {\r\n                    errors,\r\n                };\r\n            }\r\n        }\r\n    }\r\n    return {\r\n        errors,\r\n    };\r\n}\r\n/**\r\n * Handles yup validation\r\n */\r\nasync function validateFieldWithYup(value, validator, opts) {\r\n    var _a;\r\n    const errors = await validator\r\n        .validate(value, {\r\n        abortEarly: (_a = opts.bails) !== null && _a !== void 0 ? _a : true,\r\n    })\r\n        .then(() => [])\r\n        .catch((err) => {\r\n        // Yup errors have a name prop one them.\r\n        // https://github.com/jquense/yup#validationerrorerrors-string--arraystring-value-any-path-string\r\n        if (err.name === 'ValidationError') {\r\n            return err.errors;\r\n        }\r\n        // re-throw the error so we don't hide it\r\n        throw err;\r\n    });\r\n    return {\r\n        errors,\r\n    };\r\n}\r\n/**\r\n * Tests a single input value against a rule.\r\n */\r\nasync function _test(field, value, rule) {\r\n    const validator = resolveRule(rule.name);\r\n    if (!validator) {\r\n        throw new Error(`No such validator '${rule.name}' exists.`);\r\n    }\r\n    const params = fillTargetValues(rule.params, field.formData);\r\n    const ctx = {\r\n        field: field.name,\r\n        value,\r\n        form: field.formData,\r\n        rule: Object.assign(Object.assign({}, rule), { params }),\r\n    };\r\n    const result = await validator(value, params, ctx);\r\n    if (typeof result === 'string') {\r\n        return {\r\n            error: result,\r\n        };\r\n    }\r\n    return {\r\n        error: result ? undefined : _generateFieldError(ctx),\r\n    };\r\n}\r\n/**\r\n * Generates error messages.\r\n */\r\nfunction _generateFieldError(fieldCtx) {\r\n    const message = getConfig().generateMessage;\r\n    if (!message) {\r\n        return 'Field is invalid';\r\n    }\r\n    return message(fieldCtx);\r\n}\r\nfunction fillTargetValues(params, crossTable) {\r\n    const normalize = (value) => {\r\n        if (isLocator(value)) {\r\n            return value(crossTable);\r\n        }\r\n        return value;\r\n    };\r\n    if (Array.isArray(params)) {\r\n        return params.map(normalize);\r\n    }\r\n    return Object.keys(params).reduce((acc, param) => {\r\n        acc[param] = normalize(params[param]);\r\n        return acc;\r\n    }, {});\r\n}\r\nasync function validateYupSchema(schema, values) {\r\n    const errorObjects = await schema\r\n        .validate(values, { abortEarly: false })\r\n        .then(() => [])\r\n        .catch((err) => {\r\n        // Yup errors have a name prop one them.\r\n        // https://github.com/jquense/yup#validationerrorerrors-string--arraystring-value-any-path-string\r\n        if (err.name !== 'ValidationError') {\r\n            throw err;\r\n        }\r\n        // list of aggregated errors\r\n        return err.inner || [];\r\n    });\r\n    const results = {};\r\n    const errors = {};\r\n    for (const error of errorObjects) {\r\n        const messages = error.errors;\r\n        results[error.path] = { valid: !messages.length, errors: messages };\r\n        if (messages.length) {\r\n            errors[error.path] = messages[0];\r\n        }\r\n    }\r\n    return {\r\n        valid: !errorObjects.length,\r\n        results,\r\n        errors,\r\n    };\r\n}\r\nasync function validateObjectSchema(schema, values, opts) {\r\n    const paths = keysOf(schema);\r\n    const validations = paths.map(async (path) => {\r\n        var _a, _b, _c;\r\n        const fieldResult = await validate(getFromPath(values, path), schema[path], {\r\n            name: ((_a = opts === null || opts === void 0 ? void 0 : opts.names) === null || _a === void 0 ? void 0 : _a[path]) || path,\r\n            values: values,\r\n            bails: (_c = (_b = opts === null || opts === void 0 ? void 0 : opts.bailsMap) === null || _b === void 0 ? void 0 : _b[path]) !== null && _c !== void 0 ? _c : true,\r\n        });\r\n        return Object.assign(Object.assign({}, fieldResult), { path });\r\n    });\r\n    let isAllValid = true;\r\n    const validationResults = await Promise.all(validations);\r\n    const results = {};\r\n    const errors = {};\r\n    for (const result of validationResults) {\r\n        results[result.path] = {\r\n            valid: result.valid,\r\n            errors: result.errors,\r\n        };\r\n        if (!result.valid) {\r\n            isAllValid = false;\r\n            errors[result.path] = result.errors[0];\r\n        }\r\n    }\r\n    return {\r\n        valid: isAllValid,\r\n        results,\r\n        errors,\r\n    };\r\n}\n\nfunction set(obj, key, val) {\n\tif (typeof val.value === 'object') val.value = klona(val.value);\n\tif (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === '__proto__') {\n\t\tObject.defineProperty(obj, key, val);\n\t} else obj[key] = val.value;\n}\n\nfunction klona(x) {\n\tif (typeof x !== 'object') return x;\n\n\tvar i=0, k, list, tmp, str=Object.prototype.toString.call(x);\n\n\tif (str === '[object Object]') {\n\t\ttmp = Object.create(x.__proto__ || null);\n\t} else if (str === '[object Array]') {\n\t\ttmp = Array(x.length);\n\t} else if (str === '[object Set]') {\n\t\ttmp = new Set;\n\t\tx.forEach(function (val) {\n\t\t\ttmp.add(klona(val));\n\t\t});\n\t} else if (str === '[object Map]') {\n\t\ttmp = new Map;\n\t\tx.forEach(function (val, key) {\n\t\t\ttmp.set(klona(key), klona(val));\n\t\t});\n\t} else if (str === '[object Date]') {\n\t\ttmp = new Date(+x);\n\t} else if (str === '[object RegExp]') {\n\t\ttmp = new RegExp(x.source, x.flags);\n\t} else if (str === '[object DataView]') {\n\t\ttmp = new x.constructor( klona(x.buffer) );\n\t} else if (str === '[object ArrayBuffer]') {\n\t\ttmp = x.slice(0);\n\t} else if (str.slice(-6) === 'Array]') {\n\t\t// ArrayBuffer.isView(x)\n\t\t// ~> `new` bcuz `Buffer.slice` => ref\n\t\ttmp = new x.constructor(x);\n\t}\n\n\tif (tmp) {\n\t\tfor (list=Object.getOwnPropertySymbols(x); i < list.length; i++) {\n\t\t\tset(tmp, list[i], Object.getOwnPropertyDescriptor(x, list[i]));\n\t\t}\n\n\t\tfor (i=0, list=Object.getOwnPropertyNames(x); i < list.length; i++) {\n\t\t\tif (Object.hasOwnProperty.call(tmp, k=list[i]) && tmp[k] === x[k]) continue;\n\t\t\tset(tmp, k, Object.getOwnPropertyDescriptor(x, k));\n\t\t}\n\t}\n\n\treturn tmp || x;\n}\n\nvar es6 = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n    if ((a instanceof Map) && (b instanceof Map)) {\n      if (a.size !== b.size) return false;\n      for (i of a.entries())\n        if (!b.has(i[0])) return false;\n      for (i of a.entries())\n        if (!equal(i[1], b.get(i[0]))) return false;\n      return true;\n    }\n\n    if ((a instanceof Set) && (b instanceof Set)) {\n      if (a.size !== b.size) return false;\n      for (i of a.entries())\n        if (!b.has(i[0])) return false;\n      return true;\n    }\n\n    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (a[i] !== b[i]) return false;\n      return true;\n    }\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n\nlet ID_COUNTER = 0;\r\nfunction useFieldState(path, init) {\r\n    const { value, initialValue, setInitialValue } = _useFieldValue(path, init.modelValue, !init.standalone);\r\n    const { errorMessage, errors, setErrors } = _useFieldErrors(path, !init.standalone);\r\n    const meta = _useFieldMeta(value, initialValue, errors);\r\n    const id = ID_COUNTER >= Number.MAX_SAFE_INTEGER ? 0 : ++ID_COUNTER;\r\n    function setState(state) {\r\n        var _a;\r\n        if ('value' in state) {\r\n            value.value = state.value;\r\n        }\r\n        if ('errors' in state) {\r\n            setErrors(state.errors);\r\n        }\r\n        if ('touched' in state) {\r\n            meta.touched = (_a = state.touched) !== null && _a !== void 0 ? _a : meta.touched;\r\n        }\r\n        if ('initialValue' in state) {\r\n            setInitialValue(state.initialValue);\r\n        }\r\n    }\r\n    return {\r\n        id,\r\n        path,\r\n        value,\r\n        initialValue,\r\n        meta,\r\n        errors,\r\n        errorMessage,\r\n        setState,\r\n    };\r\n}\r\n/**\r\n * Creates the field value and resolves the initial value\r\n */\r\nfunction _useFieldValue(path, modelValue, shouldInjectForm = true) {\r\n    const form = shouldInjectForm === true ? injectWithSelf(FormContextKey, undefined) : undefined;\r\n    const modelRef = ref(unref(modelValue));\r\n    function resolveInitialValue() {\r\n        if (!form) {\r\n            return unref(modelRef);\r\n        }\r\n        return getFromPath(form.meta.value.initialValues, unref(path), unref(modelRef));\r\n    }\r\n    function setInitialValue(value) {\r\n        if (!form) {\r\n            modelRef.value = value;\r\n            return;\r\n        }\r\n        form.stageInitialValue(unref(path), value, true);\r\n    }\r\n    const initialValue = computed(resolveInitialValue);\r\n    // if no form is associated, use a regular ref.\r\n    if (!form) {\r\n        const value = ref(resolveInitialValue());\r\n        return {\r\n            value,\r\n            initialValue,\r\n            setInitialValue,\r\n        };\r\n    }\r\n    // to set the initial value, first check if there is a current value, if there is then use it.\r\n    // otherwise use the configured initial value if it exists.\r\n    // prioritize model value over form values\r\n    // #3429\r\n    const currentValue = modelValue ? unref(modelValue) : getFromPath(form.values, unref(path), unref(initialValue));\r\n    form.stageInitialValue(unref(path), currentValue, true);\r\n    // otherwise use a computed setter that triggers the `setFieldValue`\r\n    const value = computed({\r\n        get() {\r\n            return getFromPath(form.values, unref(path));\r\n        },\r\n        set(newVal) {\r\n            form.setFieldValue(unref(path), newVal);\r\n        },\r\n    });\r\n    return {\r\n        value,\r\n        initialValue,\r\n        setInitialValue,\r\n    };\r\n}\r\n/**\r\n * Creates meta flags state and some associated effects with them\r\n */\r\nfunction _useFieldMeta(currentValue, initialValue, errors) {\r\n    const meta = reactive({\r\n        touched: false,\r\n        pending: false,\r\n        valid: true,\r\n        validated: !!unref(errors).length,\r\n        initialValue: computed(() => unref(initialValue)),\r\n        dirty: computed(() => {\r\n            return !es6(unref(currentValue), unref(initialValue));\r\n        }),\r\n    });\r\n    watch(errors, value => {\r\n        meta.valid = !value.length;\r\n    }, {\r\n        immediate: true,\r\n        flush: 'sync',\r\n    });\r\n    return meta;\r\n}\r\n/**\r\n * Creates the error message state for the field state\r\n */\r\nfunction _useFieldErrors(path, shouldInjectForm) {\r\n    const form = shouldInjectForm ? injectWithSelf(FormContextKey, undefined) : undefined;\r\n    function normalizeErrors(messages) {\r\n        if (!messages) {\r\n            return [];\r\n        }\r\n        return Array.isArray(messages) ? messages : [messages];\r\n    }\r\n    if (!form) {\r\n        const errors = ref([]);\r\n        return {\r\n            errors,\r\n            errorMessage: computed(() => errors.value[0]),\r\n            setErrors: (messages) => {\r\n                errors.value = normalizeErrors(messages);\r\n            },\r\n        };\r\n    }\r\n    const errors = computed(() => form.errorBag.value[unref(path)] || []);\r\n    return {\r\n        errors,\r\n        errorMessage: computed(() => errors.value[0]),\r\n        setErrors: (messages) => {\r\n            form.setFieldErrorBag(unref(path), normalizeErrors(messages));\r\n        },\r\n    };\r\n}\n\nfunction installDevtoolsPlugin(app) {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        setupDevtoolsPlugin({\r\n            id: 'vee-validate-devtools-plugin',\r\n            label: 'VeeValidate Plugin',\r\n            packageName: 'vee-validate',\r\n            homepage: 'https://vee-validate.logaretm.com/v4',\r\n            app,\r\n            logo: 'https://vee-validate.logaretm.com/v4/logo.png',\r\n        }, setupApiHooks);\r\n    }\r\n}\r\nconst DEVTOOLS_FORMS = {};\r\nconst DEVTOOLS_FIELDS = {};\r\nlet API;\r\nconst refreshInspector = throttle(() => {\r\n    setTimeout(async () => {\r\n        await nextTick();\r\n        API === null || API === void 0 ? void 0 : API.sendInspectorState(INSPECTOR_ID);\r\n        API === null || API === void 0 ? void 0 : API.sendInspectorTree(INSPECTOR_ID);\r\n    }, 100);\r\n}, 100);\r\nfunction registerFormWithDevTools(form) {\r\n    const vm = getCurrentInstance();\r\n    if (!API) {\r\n        const app = vm === null || vm === void 0 ? void 0 : vm.appContext.app;\r\n        if (!app) {\r\n            return;\r\n        }\r\n        installDevtoolsPlugin(app);\r\n    }\r\n    DEVTOOLS_FORMS[form.formId] = Object.assign({}, form);\r\n    DEVTOOLS_FORMS[form.formId]._vm = vm;\r\n    onUnmounted(() => {\r\n        delete DEVTOOLS_FORMS[form.formId];\r\n        refreshInspector();\r\n    });\r\n    refreshInspector();\r\n}\r\nfunction registerSingleFieldWithDevtools(field) {\r\n    const vm = getCurrentInstance();\r\n    if (!API) {\r\n        const app = vm === null || vm === void 0 ? void 0 : vm.appContext.app;\r\n        if (!app) {\r\n            return;\r\n        }\r\n        installDevtoolsPlugin(app);\r\n    }\r\n    DEVTOOLS_FIELDS[field.id] = Object.assign({}, field);\r\n    DEVTOOLS_FIELDS[field.id]._vm = vm;\r\n    onUnmounted(() => {\r\n        delete DEVTOOLS_FIELDS[field.id];\r\n        refreshInspector();\r\n    });\r\n    refreshInspector();\r\n}\r\nconst INSPECTOR_ID = 'vee-validate-inspector';\r\nconst COLORS = {\r\n    error: 0xbd4b4b,\r\n    success: 0x06d77b,\r\n    unknown: 0x54436b,\r\n    white: 0xffffff,\r\n    black: 0x000000,\r\n    blue: 0x035397,\r\n    purple: 0xb980f0,\r\n    orange: 0xf5a962,\r\n    gray: 0xbbbfca,\r\n};\r\nlet SELECTED_NODE = null;\r\nfunction setupApiHooks(api) {\r\n    API = api;\r\n    api.addInspector({\r\n        id: INSPECTOR_ID,\r\n        icon: 'rule',\r\n        label: 'vee-validate',\r\n        noSelectionText: 'Select a vee-validate node to inspect',\r\n        actions: [\r\n            {\r\n                icon: 'done_outline',\r\n                tooltip: 'Validate selected item',\r\n                action: async () => {\r\n                    if (!SELECTED_NODE) {\r\n                        console.error('There is not a valid selected vee-validate node or component');\r\n                        return;\r\n                    }\r\n                    const result = await SELECTED_NODE.validate();\r\n                    console.log(result);\r\n                },\r\n            },\r\n            {\r\n                icon: 'delete_sweep',\r\n                tooltip: 'Clear validation state of the selected item',\r\n                action: () => {\r\n                    if (!SELECTED_NODE) {\r\n                        console.error('There is not a valid selected vee-validate node or component');\r\n                        return;\r\n                    }\r\n                    if ('id' in SELECTED_NODE) {\r\n                        SELECTED_NODE.resetField();\r\n                        return;\r\n                    }\r\n                    SELECTED_NODE.resetForm();\r\n                },\r\n            },\r\n        ],\r\n    });\r\n    api.on.getInspectorTree(payload => {\r\n        if (payload.inspectorId !== INSPECTOR_ID) {\r\n            return;\r\n        }\r\n        const forms = Object.values(DEVTOOLS_FORMS);\r\n        const fields = Object.values(DEVTOOLS_FIELDS);\r\n        payload.rootNodes = [\r\n            ...forms.map(mapFormForDevtoolsInspector),\r\n            ...fields.map(field => mapFieldForDevtoolsInspector(field)),\r\n        ];\r\n    });\r\n    api.on.getInspectorState((payload, ctx) => {\r\n        if (payload.inspectorId !== INSPECTOR_ID || ctx.currentTab !== `custom-inspector:${INSPECTOR_ID}`) {\r\n            return;\r\n        }\r\n        const { form, field, type } = decodeNodeId(payload.nodeId);\r\n        if (form && type === 'form') {\r\n            payload.state = buildFormState(form);\r\n            SELECTED_NODE = form;\r\n            return;\r\n        }\r\n        if (field && type === 'field') {\r\n            payload.state = buildFieldState(field);\r\n            SELECTED_NODE = field;\r\n            return;\r\n        }\r\n        SELECTED_NODE = null;\r\n    });\r\n}\r\nfunction mapFormForDevtoolsInspector(form) {\r\n    const { textColor, bgColor } = getTagTheme(form);\r\n    const formTreeNodes = {};\r\n    Object.values(form.fieldsByPath.value).forEach(field => {\r\n        const fieldInstance = Array.isArray(field) ? field[0] : field;\r\n        if (!fieldInstance) {\r\n            return;\r\n        }\r\n        setInPath(formTreeNodes, unref(fieldInstance.name), mapFieldForDevtoolsInspector(fieldInstance, form));\r\n    });\r\n    function buildFormTree(tree, path = []) {\r\n        const key = [...path].pop();\r\n        if ('id' in tree) {\r\n            return Object.assign(Object.assign({}, tree), { label: key || tree.label });\r\n        }\r\n        if (isObject(tree)) {\r\n            return {\r\n                id: `${path.join('.')}`,\r\n                label: key || '',\r\n                children: Object.keys(tree).map(key => buildFormTree(tree[key], [...path, key])),\r\n            };\r\n        }\r\n        if (Array.isArray(tree)) {\r\n            return {\r\n                id: `${path.join('.')}`,\r\n                label: `${key}[]`,\r\n                children: tree.map((c, idx) => buildFormTree(c, [...path, String(idx)])),\r\n            };\r\n        }\r\n        return { id: '', label: '', children: [] };\r\n    }\r\n    const { children } = buildFormTree(formTreeNodes);\r\n    return {\r\n        id: encodeNodeId(form),\r\n        label: 'Form',\r\n        children,\r\n        tags: [\r\n            {\r\n                label: 'Form',\r\n                textColor,\r\n                backgroundColor: bgColor,\r\n            },\r\n            {\r\n                label: `${Object.keys(form.fieldsByPath.value).length} fields`,\r\n                textColor: COLORS.white,\r\n                backgroundColor: COLORS.unknown,\r\n            },\r\n        ],\r\n    };\r\n}\r\nfunction mapFieldForDevtoolsInspector(field, form) {\r\n    const fieldInstance = normalizeField(field);\r\n    const { textColor, bgColor } = getTagTheme(fieldInstance);\r\n    const isGroup = Array.isArray(field) && field.length > 1;\r\n    return {\r\n        id: encodeNodeId(form, fieldInstance, !isGroup),\r\n        label: unref(fieldInstance.name),\r\n        children: Array.isArray(field) ? field.map(fieldItem => mapFieldForDevtoolsInspector(fieldItem, form)) : undefined,\r\n        tags: [\r\n            isGroup\r\n                ? undefined\r\n                : {\r\n                    label: 'Field',\r\n                    textColor,\r\n                    backgroundColor: bgColor,\r\n                },\r\n            !form\r\n                ? {\r\n                    label: 'Standalone',\r\n                    textColor: COLORS.black,\r\n                    backgroundColor: COLORS.gray,\r\n                }\r\n                : undefined,\r\n            !isGroup && fieldInstance.type === 'checkbox'\r\n                ? {\r\n                    label: 'Checkbox',\r\n                    textColor: COLORS.white,\r\n                    backgroundColor: COLORS.blue,\r\n                }\r\n                : undefined,\r\n            !isGroup && fieldInstance.type === 'radio'\r\n                ? {\r\n                    label: 'Radio',\r\n                    textColor: COLORS.white,\r\n                    backgroundColor: COLORS.purple,\r\n                }\r\n                : undefined,\r\n            isGroup\r\n                ? {\r\n                    label: 'Group',\r\n                    textColor: COLORS.black,\r\n                    backgroundColor: COLORS.orange,\r\n                }\r\n                : undefined,\r\n        ].filter(Boolean),\r\n    };\r\n}\r\nfunction encodeNodeId(form, field, encodeIndex = true) {\r\n    const fieldPath = form ? unref(field === null || field === void 0 ? void 0 : field.name) : field === null || field === void 0 ? void 0 : field.id;\r\n    const fieldGroup = fieldPath ? form === null || form === void 0 ? void 0 : form.fieldsByPath.value[fieldPath] : undefined;\r\n    let idx;\r\n    if (encodeIndex && field && Array.isArray(fieldGroup)) {\r\n        idx = fieldGroup.indexOf(field);\r\n    }\r\n    const idObject = { f: form === null || form === void 0 ? void 0 : form.formId, ff: fieldPath, idx, type: field ? 'field' : 'form' };\r\n    return btoa(JSON.stringify(idObject));\r\n}\r\nfunction decodeNodeId(nodeId) {\r\n    try {\r\n        const idObject = JSON.parse(atob(nodeId));\r\n        const form = DEVTOOLS_FORMS[idObject.f];\r\n        if (!form && idObject.ff) {\r\n            const field = DEVTOOLS_FIELDS[idObject.ff];\r\n            if (!field) {\r\n                return {};\r\n            }\r\n            return {\r\n                type: idObject.type,\r\n                field,\r\n            };\r\n        }\r\n        if (!form) {\r\n            return {};\r\n        }\r\n        const fieldGroup = form.fieldsByPath.value[idObject.ff];\r\n        return {\r\n            type: idObject.type,\r\n            form,\r\n            field: Array.isArray(fieldGroup) ? fieldGroup[idObject.idx || 0] : fieldGroup,\r\n        };\r\n    }\r\n    catch (err) {\r\n        // console.error(`Devtools: [vee-validate] Failed to parse node id ${nodeId}`);\r\n    }\r\n    return {};\r\n}\r\nfunction buildFieldState(field) {\r\n    const { errors, meta, value } = field;\r\n    return {\r\n        'Field state': [\r\n            { key: 'errors', value: errors.value },\r\n            {\r\n                key: 'initialValue',\r\n                value: meta.initialValue,\r\n            },\r\n            {\r\n                key: 'currentValue',\r\n                value: value.value,\r\n            },\r\n            {\r\n                key: 'touched',\r\n                value: meta.touched,\r\n            },\r\n            {\r\n                key: 'dirty',\r\n                value: meta.dirty,\r\n            },\r\n            {\r\n                key: 'valid',\r\n                value: meta.valid,\r\n            },\r\n        ],\r\n    };\r\n}\r\nfunction buildFormState(form) {\r\n    const { errorBag, meta, values, isSubmitting, submitCount } = form;\r\n    return {\r\n        'Form state': [\r\n            {\r\n                key: 'submitCount',\r\n                value: submitCount.value,\r\n            },\r\n            {\r\n                key: 'isSubmitting',\r\n                value: isSubmitting.value,\r\n            },\r\n            {\r\n                key: 'touched',\r\n                value: meta.value.touched,\r\n            },\r\n            {\r\n                key: 'dirty',\r\n                value: meta.value.dirty,\r\n            },\r\n            {\r\n                key: 'valid',\r\n                value: meta.value.valid,\r\n            },\r\n            {\r\n                key: 'initialValues',\r\n                value: meta.value.initialValues,\r\n            },\r\n            {\r\n                key: 'currentValues',\r\n                value: values,\r\n            },\r\n            {\r\n                key: 'errors',\r\n                value: keysOf(errorBag.value).reduce((acc, key) => {\r\n                    var _a;\r\n                    const message = (_a = errorBag.value[key]) === null || _a === void 0 ? void 0 : _a[0];\r\n                    if (message) {\r\n                        acc[key] = message;\r\n                    }\r\n                    return acc;\r\n                }, {}),\r\n            },\r\n        ],\r\n    };\r\n}\r\n/**\r\n * Resolves the tag color based on the form state\r\n */\r\nfunction getTagTheme(fieldOrForm) {\r\n    // const fallbackColors = {\r\n    //   bgColor: COLORS.unknown,\r\n    //   textColor: COLORS.white,\r\n    // };\r\n    const isValid = 'id' in fieldOrForm ? fieldOrForm.meta.valid : fieldOrForm.meta.value.valid;\r\n    return {\r\n        bgColor: isValid ? COLORS.success : COLORS.error,\r\n        textColor: isValid ? COLORS.black : COLORS.white,\r\n    };\r\n}\n\n/**\r\n * Creates a field composite.\r\n */\r\nfunction useField(name, rules, opts) {\r\n    if (hasCheckedAttr(opts === null || opts === void 0 ? void 0 : opts.type)) {\r\n        return useCheckboxField(name, rules, opts);\r\n    }\r\n    return _useField(name, rules, opts);\r\n}\r\nfunction _useField(name, rules, opts) {\r\n    const { initialValue: modelValue, validateOnMount, bails, type, checkedValue, label, validateOnValueUpdate, uncheckedValue, standalone, keepValueOnUnmount, modelPropName, syncVModel, } = normalizeOptions(unref(name), opts);\r\n    const form = !standalone ? injectWithSelf(FormContextKey) : undefined;\r\n    // a flag indicating if the field is about to be removed/unmounted.\r\n    let markedForRemoval = false;\r\n    const { id, value, initialValue, meta, setState, errors, errorMessage } = useFieldState(name, {\r\n        modelValue,\r\n        standalone,\r\n    });\r\n    if (syncVModel) {\r\n        useVModel({ value, prop: modelPropName, handleChange });\r\n    }\r\n    /**\r\n     * Handles common onBlur meta update\r\n     */\r\n    const handleBlur = () => {\r\n        meta.touched = true;\r\n    };\r\n    const normalizedRules = computed(() => {\r\n        let rulesValue = unref(rules);\r\n        const schema = unref(form === null || form === void 0 ? void 0 : form.schema);\r\n        if (schema && !isYupValidator(schema)) {\r\n            rulesValue = extractRuleFromSchema(schema, unref(name)) || rulesValue;\r\n        }\r\n        if (isYupValidator(rulesValue) || isCallable(rulesValue) || Array.isArray(rulesValue)) {\r\n            return rulesValue;\r\n        }\r\n        return normalizeRules(rulesValue);\r\n    });\r\n    async function validateCurrentValue(mode) {\r\n        var _a, _b;\r\n        if (form === null || form === void 0 ? void 0 : form.validateSchema) {\r\n            return (_a = (await form.validateSchema(mode)).results[unref(name)]) !== null && _a !== void 0 ? _a : { valid: true, errors: [] };\r\n        }\r\n        return validate(value.value, normalizedRules.value, {\r\n            name: unref(label) || unref(name),\r\n            values: (_b = form === null || form === void 0 ? void 0 : form.values) !== null && _b !== void 0 ? _b : {},\r\n            bails,\r\n        });\r\n    }\r\n    async function validateWithStateMutation() {\r\n        meta.pending = true;\r\n        meta.validated = true;\r\n        const result = await validateCurrentValue('validated-only');\r\n        if (markedForRemoval) {\r\n            result.valid = true;\r\n            result.errors = [];\r\n        }\r\n        setState({ errors: result.errors });\r\n        meta.pending = false;\r\n        return result;\r\n    }\r\n    async function validateValidStateOnly() {\r\n        const result = await validateCurrentValue('silent');\r\n        if (markedForRemoval) {\r\n            result.valid = true;\r\n        }\r\n        meta.valid = result.valid;\r\n        return result;\r\n    }\r\n    function validate$1(opts) {\r\n        if (!(opts === null || opts === void 0 ? void 0 : opts.mode) || (opts === null || opts === void 0 ? void 0 : opts.mode) === 'force') {\r\n            return validateWithStateMutation();\r\n        }\r\n        if ((opts === null || opts === void 0 ? void 0 : opts.mode) === 'validated-only') {\r\n            return validateWithStateMutation();\r\n        }\r\n        return validateValidStateOnly();\r\n    }\r\n    // Common input/change event handler\r\n    function handleChange(e, shouldValidate = true) {\r\n        const newValue = normalizeEventValue(e);\r\n        value.value = newValue;\r\n        if (!validateOnValueUpdate && shouldValidate) {\r\n            validateWithStateMutation();\r\n        }\r\n    }\r\n    // Runs the initial validation\r\n    onMounted(() => {\r\n        if (validateOnMount) {\r\n            return validateWithStateMutation();\r\n        }\r\n        // validate self initially if no form was handling this\r\n        // forms should have their own initial silent validation run to make things more efficient\r\n        if (!form || !form.validateSchema) {\r\n            validateValidStateOnly();\r\n        }\r\n    });\r\n    function setTouched(isTouched) {\r\n        meta.touched = isTouched;\r\n    }\r\n    let unwatchValue;\r\n    function watchValue() {\r\n        unwatchValue = watch(value, (val, oldVal) => {\r\n            if (es6(val, oldVal)) {\r\n                return;\r\n            }\r\n            const validateFn = validateOnValueUpdate ? validateWithStateMutation : validateValidStateOnly;\r\n            validateFn();\r\n        }, {\r\n            deep: true,\r\n        });\r\n    }\r\n    watchValue();\r\n    function resetField(state) {\r\n        var _a;\r\n        unwatchValue === null || unwatchValue === void 0 ? void 0 : unwatchValue();\r\n        const newValue = state && 'value' in state ? state.value : initialValue.value;\r\n        setState({\r\n            value: klona(newValue),\r\n            initialValue: klona(newValue),\r\n            touched: (_a = state === null || state === void 0 ? void 0 : state.touched) !== null && _a !== void 0 ? _a : false,\r\n            errors: (state === null || state === void 0 ? void 0 : state.errors) || [],\r\n        });\r\n        meta.pending = false;\r\n        meta.validated = false;\r\n        validateValidStateOnly();\r\n        // need to watch at next tick to avoid triggering the value watcher\r\n        nextTick(() => {\r\n            watchValue();\r\n        });\r\n    }\r\n    function setValue(newValue) {\r\n        value.value = newValue;\r\n    }\r\n    function setErrors(errors) {\r\n        setState({ errors: Array.isArray(errors) ? errors : [errors] });\r\n    }\r\n    const field = {\r\n        id,\r\n        name,\r\n        label,\r\n        value,\r\n        meta,\r\n        errors,\r\n        errorMessage,\r\n        type,\r\n        checkedValue,\r\n        uncheckedValue,\r\n        bails,\r\n        keepValueOnUnmount,\r\n        resetField,\r\n        handleReset: () => resetField(),\r\n        validate: validate$1,\r\n        handleChange,\r\n        handleBlur,\r\n        setState,\r\n        setTouched,\r\n        setErrors,\r\n        setValue,\r\n    };\r\n    provide(FieldContextKey, field);\r\n    if (isRef(rules) && typeof unref(rules) !== 'function') {\r\n        watch(rules, (value, oldValue) => {\r\n            if (es6(value, oldValue)) {\r\n                return;\r\n            }\r\n            meta.validated ? validateWithStateMutation() : validateValidStateOnly();\r\n        }, {\r\n            deep: true,\r\n        });\r\n    }\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        field._vm = getCurrentInstance();\r\n        watch(() => (Object.assign(Object.assign({ errors: errors.value }, meta), { value: value.value })), refreshInspector, {\r\n            deep: true,\r\n        });\r\n        if (!form) {\r\n            registerSingleFieldWithDevtools(field);\r\n        }\r\n    }\r\n    // if no associated form return the field API immediately\r\n    if (!form) {\r\n        return field;\r\n    }\r\n    // associate the field with the given form\r\n    form.register(field);\r\n    onBeforeUnmount(() => {\r\n        markedForRemoval = true;\r\n        form.unregister(field);\r\n    });\r\n    // extract cross-field dependencies in a computed prop\r\n    const dependencies = computed(() => {\r\n        const rulesVal = normalizedRules.value;\r\n        // is falsy, a function schema or a yup schema\r\n        if (!rulesVal || isCallable(rulesVal) || isYupValidator(rulesVal) || Array.isArray(rulesVal)) {\r\n            return {};\r\n        }\r\n        return Object.keys(rulesVal).reduce((acc, rule) => {\r\n            const deps = extractLocators(rulesVal[rule])\r\n                .map((dep) => dep.__locatorRef)\r\n                .reduce((depAcc, depName) => {\r\n                const depValue = getFromPath(form.values, depName) || form.values[depName];\r\n                if (depValue !== undefined) {\r\n                    depAcc[depName] = depValue;\r\n                }\r\n                return depAcc;\r\n            }, {});\r\n            Object.assign(acc, deps);\r\n            return acc;\r\n        }, {});\r\n    });\r\n    // Adds a watcher that runs the validation whenever field dependencies change\r\n    watch(dependencies, (deps, oldDeps) => {\r\n        // Skip if no dependencies or if the field wasn't manipulated\r\n        if (!Object.keys(deps).length) {\r\n            return;\r\n        }\r\n        const shouldValidate = !es6(deps, oldDeps);\r\n        if (shouldValidate) {\r\n            meta.validated ? validateWithStateMutation() : validateValidStateOnly();\r\n        }\r\n    });\r\n    return field;\r\n}\r\n/**\r\n * Normalizes partial field options to include the full options\r\n */\r\nfunction normalizeOptions(name, opts) {\r\n    const defaults = () => ({\r\n        initialValue: undefined,\r\n        validateOnMount: false,\r\n        bails: true,\r\n        rules: '',\r\n        label: name,\r\n        validateOnValueUpdate: true,\r\n        standalone: false,\r\n        keepValueOnUnmount: undefined,\r\n        modelPropName: 'modelValue',\r\n        syncVModel: true,\r\n    });\r\n    if (!opts) {\r\n        return defaults();\r\n    }\r\n    // TODO: Deprecate this in next major release\r\n    const checkedValue = 'valueProp' in opts ? opts.valueProp : opts.checkedValue;\r\n    return Object.assign(Object.assign(Object.assign({}, defaults()), (opts || {})), { checkedValue });\r\n}\r\n/**\r\n * Extracts the validation rules from a schema\r\n */\r\nfunction extractRuleFromSchema(schema, fieldName) {\r\n    // no schema at all\r\n    if (!schema) {\r\n        return undefined;\r\n    }\r\n    // there is a key on the schema object for this field\r\n    return schema[fieldName];\r\n}\r\nfunction useCheckboxField(name, rules, opts) {\r\n    const form = !(opts === null || opts === void 0 ? void 0 : opts.standalone) ? injectWithSelf(FormContextKey) : undefined;\r\n    const checkedValue = opts === null || opts === void 0 ? void 0 : opts.checkedValue;\r\n    const uncheckedValue = opts === null || opts === void 0 ? void 0 : opts.uncheckedValue;\r\n    function patchCheckboxApi(field) {\r\n        const handleChange = field.handleChange;\r\n        const checked = computed(() => {\r\n            const currentValue = unref(field.value);\r\n            const checkedVal = unref(checkedValue);\r\n            return Array.isArray(currentValue)\r\n                ? currentValue.findIndex(v => es6(v, checkedVal)) >= 0\r\n                : es6(checkedVal, currentValue);\r\n        });\r\n        function handleCheckboxChange(e, shouldValidate = true) {\r\n            var _a;\r\n            if (checked.value === ((_a = e === null || e === void 0 ? void 0 : e.target) === null || _a === void 0 ? void 0 : _a.checked)) {\r\n                return;\r\n            }\r\n            let newValue = normalizeEventValue(e);\r\n            // Single checkbox field without a form to toggle it's value\r\n            if (!form) {\r\n                newValue = resolveNextCheckboxValue(unref(field.value), unref(checkedValue), unref(uncheckedValue));\r\n            }\r\n            handleChange(newValue, shouldValidate);\r\n        }\r\n        return Object.assign(Object.assign({}, field), { checked,\r\n            checkedValue,\r\n            uncheckedValue, handleChange: handleCheckboxChange });\r\n    }\r\n    return patchCheckboxApi(_useField(name, rules, opts));\r\n}\r\nfunction useVModel({ prop, value, handleChange }) {\r\n    const vm = getCurrentInstance();\r\n    /* istanbul ignore next */\r\n    if (!vm) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            console.warn('Failed to setup model events because `useField` was not called in setup.');\r\n        }\r\n        return;\r\n    }\r\n    const propName = prop || 'modelValue';\r\n    const emitName = `update:${propName}`;\r\n    // Component doesn't have a model prop setup (must be defined on the props)\r\n    if (!(propName in vm.props)) {\r\n        return;\r\n    }\r\n    watch(value, newValue => {\r\n        if (es6(newValue, getCurrentModelValue(vm, propName))) {\r\n            return;\r\n        }\r\n        vm.emit(emitName, newValue);\r\n    });\r\n    watch(() => getCurrentModelValue(vm, propName), propValue => {\r\n        if (propValue === IS_ABSENT && value.value === undefined) {\r\n            return;\r\n        }\r\n        const newValue = propValue === IS_ABSENT ? undefined : propValue;\r\n        if (es6(newValue, applyModelModifiers(value.value, vm.props.modelModifiers))) {\r\n            return;\r\n        }\r\n        handleChange(newValue);\r\n    });\r\n}\r\nfunction getCurrentModelValue(vm, propName) {\r\n    return vm.props[propName];\r\n}\n\nconst FieldImpl = defineComponent({\r\n    name: 'Field',\r\n    inheritAttrs: false,\r\n    props: {\r\n        as: {\r\n            type: [String, Object],\r\n            default: undefined,\r\n        },\r\n        name: {\r\n            type: String,\r\n            required: true,\r\n        },\r\n        rules: {\r\n            type: [Object, String, Function],\r\n            default: undefined,\r\n        },\r\n        validateOnMount: {\r\n            type: Boolean,\r\n            default: false,\r\n        },\r\n        validateOnBlur: {\r\n            type: Boolean,\r\n            default: undefined,\r\n        },\r\n        validateOnChange: {\r\n            type: Boolean,\r\n            default: undefined,\r\n        },\r\n        validateOnInput: {\r\n            type: Boolean,\r\n            default: undefined,\r\n        },\r\n        validateOnModelUpdate: {\r\n            type: Boolean,\r\n            default: undefined,\r\n        },\r\n        bails: {\r\n            type: Boolean,\r\n            default: () => getConfig().bails,\r\n        },\r\n        label: {\r\n            type: String,\r\n            default: undefined,\r\n        },\r\n        uncheckedValue: {\r\n            type: null,\r\n            default: undefined,\r\n        },\r\n        modelValue: {\r\n            type: null,\r\n            default: IS_ABSENT,\r\n        },\r\n        modelModifiers: {\r\n            type: null,\r\n            default: () => ({}),\r\n        },\r\n        'onUpdate:modelValue': {\r\n            type: null,\r\n            default: undefined,\r\n        },\r\n        standalone: {\r\n            type: Boolean,\r\n            default: false,\r\n        },\r\n        keepValue: {\r\n            type: Boolean,\r\n            default: undefined,\r\n        },\r\n    },\r\n    setup(props, ctx) {\r\n        const rules = toRef(props, 'rules');\r\n        const name = toRef(props, 'name');\r\n        const label = toRef(props, 'label');\r\n        const uncheckedValue = toRef(props, 'uncheckedValue');\r\n        const keepValue = toRef(props, 'keepValue');\r\n        const { errors, value, errorMessage, validate: validateField, handleChange, handleBlur, setTouched, resetField, handleReset, meta, checked, setErrors, } = useField(name, rules, {\r\n            validateOnMount: props.validateOnMount,\r\n            bails: props.bails,\r\n            standalone: props.standalone,\r\n            type: ctx.attrs.type,\r\n            initialValue: resolveInitialValue(props, ctx),\r\n            // Only for checkboxes and radio buttons\r\n            checkedValue: ctx.attrs.value,\r\n            uncheckedValue,\r\n            label,\r\n            validateOnValueUpdate: false,\r\n            keepValueOnUnmount: keepValue,\r\n        });\r\n        // If there is a v-model applied on the component we need to emit the `update:modelValue` whenever the value binding changes\r\n        const onChangeHandler = function handleChangeWithModel(e, shouldValidate = true) {\r\n            handleChange(e, shouldValidate);\r\n            ctx.emit('update:modelValue', value.value);\r\n        };\r\n        const handleInput = (e) => {\r\n            if (!hasCheckedAttr(ctx.attrs.type)) {\r\n                value.value = normalizeEventValue(e);\r\n            }\r\n        };\r\n        const onInputHandler = function handleInputWithModel(e) {\r\n            handleInput(e);\r\n            ctx.emit('update:modelValue', value.value);\r\n        };\r\n        const fieldProps = computed(() => {\r\n            const { validateOnInput, validateOnChange, validateOnBlur, validateOnModelUpdate } = resolveValidationTriggers(props);\r\n            const baseOnBlur = [handleBlur, ctx.attrs.onBlur, validateOnBlur ? validateField : undefined].filter(Boolean);\r\n            const baseOnInput = [(e) => onChangeHandler(e, validateOnInput), ctx.attrs.onInput].filter(Boolean);\r\n            const baseOnChange = [(e) => onChangeHandler(e, validateOnChange), ctx.attrs.onChange].filter(Boolean);\r\n            const attrs = {\r\n                name: props.name,\r\n                onBlur: baseOnBlur,\r\n                onInput: baseOnInput,\r\n                onChange: baseOnChange,\r\n            };\r\n            attrs['onUpdate:modelValue'] = e => onChangeHandler(e, validateOnModelUpdate);\r\n            if (hasCheckedAttr(ctx.attrs.type) && checked) {\r\n                attrs.checked = checked.value;\r\n            }\r\n            const tag = resolveTag(props, ctx);\r\n            if (shouldHaveValueBinding(tag, ctx.attrs)) {\r\n                attrs.value = value.value;\r\n            }\r\n            return attrs;\r\n        });\r\n        function slotProps() {\r\n            return {\r\n                field: fieldProps.value,\r\n                value: value.value,\r\n                meta,\r\n                errors: errors.value,\r\n                errorMessage: errorMessage.value,\r\n                validate: validateField,\r\n                resetField,\r\n                handleChange: onChangeHandler,\r\n                handleInput: onInputHandler,\r\n                handleReset,\r\n                handleBlur,\r\n                setTouched,\r\n                setErrors,\r\n            };\r\n        }\r\n        ctx.expose({\r\n            setErrors,\r\n            setTouched,\r\n            reset: resetField,\r\n            validate: validateField,\r\n            handleChange,\r\n        });\r\n        return () => {\r\n            const tag = resolveDynamicComponent(resolveTag(props, ctx));\r\n            const children = normalizeChildren(tag, ctx, slotProps);\r\n            if (tag) {\r\n                return h(tag, Object.assign(Object.assign({}, ctx.attrs), fieldProps.value), children);\r\n            }\r\n            return children;\r\n        };\r\n    },\r\n});\r\nfunction resolveTag(props, ctx) {\r\n    let tag = props.as || '';\r\n    if (!props.as && !ctx.slots.default) {\r\n        tag = 'input';\r\n    }\r\n    return tag;\r\n}\r\nfunction resolveValidationTriggers(props) {\r\n    var _a, _b, _c, _d;\r\n    const { validateOnInput, validateOnChange, validateOnBlur, validateOnModelUpdate } = getConfig();\r\n    return {\r\n        validateOnInput: (_a = props.validateOnInput) !== null && _a !== void 0 ? _a : validateOnInput,\r\n        validateOnChange: (_b = props.validateOnChange) !== null && _b !== void 0 ? _b : validateOnChange,\r\n        validateOnBlur: (_c = props.validateOnBlur) !== null && _c !== void 0 ? _c : validateOnBlur,\r\n        validateOnModelUpdate: (_d = props.validateOnModelUpdate) !== null && _d !== void 0 ? _d : validateOnModelUpdate,\r\n    };\r\n}\r\nfunction resolveInitialValue(props, ctx) {\r\n    // Gets the initial value either from `value` prop/attr or `v-model` binding (modelValue)\r\n    // For checkboxes and radio buttons it will always be the model value not the `value` attribute\r\n    if (!hasCheckedAttr(ctx.attrs.type)) {\r\n        return isPropPresent(props, 'modelValue') ? props.modelValue : ctx.attrs.value;\r\n    }\r\n    return isPropPresent(props, 'modelValue') ? props.modelValue : undefined;\r\n}\r\nconst Field = FieldImpl;\n\nlet FORM_COUNTER = 0;\r\nfunction useForm(opts) {\r\n    var _a;\r\n    const formId = FORM_COUNTER++;\r\n    // Prevents fields from double resetting their values, which causes checkboxes to toggle their initial value\r\n    // TODO: This won't be needed if we centralize all the state inside the `form` for form inputs\r\n    let RESET_LOCK = false;\r\n    // A lookup containing fields or field groups\r\n    const fieldsByPath = ref({});\r\n    // If the form is currently submitting\r\n    const isSubmitting = ref(false);\r\n    // The number of times the user tried to submit the form\r\n    const submitCount = ref(0);\r\n    // field arrays managed by this form\r\n    const fieldArrays = [];\r\n    // a private ref for all form values\r\n    const formValues = reactive(klona(unref(opts === null || opts === void 0 ? void 0 : opts.initialValues) || {}));\r\n    // the source of errors for the form fields\r\n    const { errorBag, setErrorBag, setFieldErrorBag } = useErrorBag(opts === null || opts === void 0 ? void 0 : opts.initialErrors);\r\n    // Gets the first error of each field\r\n    const errors = computed(() => {\r\n        return keysOf(errorBag.value).reduce((acc, key) => {\r\n            const bag = errorBag.value[key];\r\n            if (bag && bag.length) {\r\n                acc[key] = bag[0];\r\n            }\r\n            return acc;\r\n        }, {});\r\n    });\r\n    function getFirstFieldAtPath(path) {\r\n        const fieldOrGroup = fieldsByPath.value[path];\r\n        return Array.isArray(fieldOrGroup) ? fieldOrGroup[0] : fieldOrGroup;\r\n    }\r\n    function fieldExists(path) {\r\n        return !!fieldsByPath.value[path];\r\n    }\r\n    /**\r\n     * Holds a computed reference to all fields names and labels\r\n     */\r\n    const fieldNames = computed(() => {\r\n        return keysOf(fieldsByPath.value).reduce((names, path) => {\r\n            const field = getFirstFieldAtPath(path);\r\n            if (field) {\r\n                names[path] = unref(field.label || field.name) || '';\r\n            }\r\n            return names;\r\n        }, {});\r\n    });\r\n    const fieldBailsMap = computed(() => {\r\n        return keysOf(fieldsByPath.value).reduce((map, path) => {\r\n            var _a;\r\n            const field = getFirstFieldAtPath(path);\r\n            if (field) {\r\n                map[path] = (_a = field.bails) !== null && _a !== void 0 ? _a : true;\r\n            }\r\n            return map;\r\n        }, {});\r\n    });\r\n    // mutable non-reactive reference to initial errors\r\n    // we need this to process initial errors then unset them\r\n    const initialErrors = Object.assign({}, ((opts === null || opts === void 0 ? void 0 : opts.initialErrors) || {}));\r\n    const keepValuesOnUnmount = (_a = opts === null || opts === void 0 ? void 0 : opts.keepValuesOnUnmount) !== null && _a !== void 0 ? _a : false;\r\n    // initial form values\r\n    const { initialValues, originalInitialValues, setInitialValues } = useFormInitialValues(fieldsByPath, formValues, opts === null || opts === void 0 ? void 0 : opts.initialValues);\r\n    // form meta aggregations\r\n    const meta = useFormMeta(fieldsByPath, formValues, originalInitialValues, errors);\r\n    const schema = opts === null || opts === void 0 ? void 0 : opts.validationSchema;\r\n    const formCtx = {\r\n        formId,\r\n        fieldsByPath,\r\n        values: formValues,\r\n        errorBag,\r\n        errors,\r\n        schema,\r\n        submitCount,\r\n        meta,\r\n        isSubmitting,\r\n        fieldArrays,\r\n        keepValuesOnUnmount,\r\n        validateSchema: unref(schema) ? validateSchema : undefined,\r\n        validate,\r\n        register: registerField,\r\n        unregister: unregisterField,\r\n        setFieldErrorBag,\r\n        validateField,\r\n        setFieldValue,\r\n        setValues,\r\n        setErrors,\r\n        setFieldError,\r\n        setFieldTouched,\r\n        setTouched,\r\n        resetForm,\r\n        handleSubmit,\r\n        stageInitialValue,\r\n        unsetInitialValue,\r\n        setFieldInitialValue,\r\n        useFieldModel,\r\n    };\r\n    function isFieldGroup(fieldOrGroup) {\r\n        return Array.isArray(fieldOrGroup);\r\n    }\r\n    function applyFieldMutation(fieldOrGroup, mutation) {\r\n        if (Array.isArray(fieldOrGroup)) {\r\n            return fieldOrGroup.forEach(mutation);\r\n        }\r\n        return mutation(fieldOrGroup);\r\n    }\r\n    function mutateAllFields(mutation) {\r\n        Object.values(fieldsByPath.value).forEach(field => {\r\n            if (!field) {\r\n                return;\r\n            }\r\n            // avoid resetting the field values, because they should've been reset already.\r\n            applyFieldMutation(field, mutation);\r\n        });\r\n    }\r\n    /**\r\n     * Manually sets an error message on a specific field\r\n     */\r\n    function setFieldError(field, message) {\r\n        setFieldErrorBag(field, message);\r\n    }\r\n    /**\r\n     * Sets errors for the fields specified in the object\r\n     */\r\n    function setErrors(fields) {\r\n        setErrorBag(fields);\r\n    }\r\n    /**\r\n     * Sets a single field value\r\n     */\r\n    function setFieldValue(field, value, { force } = { force: false }) {\r\n        var _a;\r\n        const fieldInstance = fieldsByPath.value[field];\r\n        const clonedValue = klona(value);\r\n        // field wasn't found, create a virtual field as a placeholder\r\n        if (!fieldInstance) {\r\n            setInPath(formValues, field, clonedValue);\r\n            return;\r\n        }\r\n        if (isFieldGroup(fieldInstance) && ((_a = fieldInstance[0]) === null || _a === void 0 ? void 0 : _a.type) === 'checkbox' && !Array.isArray(value)) {\r\n            // Multiple checkboxes, and only one of them got updated\r\n            const newValue = klona(resolveNextCheckboxValue(getFromPath(formValues, field) || [], value, undefined));\r\n            setInPath(formValues, field, newValue);\r\n            return;\r\n        }\r\n        let newValue = value;\r\n        // Single Checkbox: toggles the field value unless the field is being reset then force it\r\n        if (!isFieldGroup(fieldInstance) && fieldInstance.type === 'checkbox' && !force && !RESET_LOCK) {\r\n            newValue = klona(resolveNextCheckboxValue(getFromPath(formValues, field), value, unref(fieldInstance.uncheckedValue)));\r\n        }\r\n        setInPath(formValues, field, newValue);\r\n    }\r\n    /**\r\n     * Sets multiple fields values\r\n     */\r\n    function setValues(fields) {\r\n        // clean up old values\r\n        keysOf(formValues).forEach(key => {\r\n            delete formValues[key];\r\n        });\r\n        // set up new values\r\n        keysOf(fields).forEach(path => {\r\n            setFieldValue(path, fields[path]);\r\n        });\r\n        // regenerate the arrays when the form values change\r\n        fieldArrays.forEach(f => f && f.reset());\r\n    }\r\n    function createModel(path) {\r\n        const { value } = _useFieldValue(path);\r\n        watch(value, () => {\r\n            if (!fieldExists(unref(path))) {\r\n                validate({ mode: 'validated-only' });\r\n            }\r\n        }, {\r\n            deep: true,\r\n        });\r\n        return value;\r\n    }\r\n    function useFieldModel(path) {\r\n        if (!Array.isArray(path)) {\r\n            return createModel(path);\r\n        }\r\n        return path.map(createModel);\r\n    }\r\n    /**\r\n     * Sets the touched meta state on a field\r\n     */\r\n    function setFieldTouched(field, isTouched) {\r\n        const fieldInstance = fieldsByPath.value[field];\r\n        if (fieldInstance) {\r\n            applyFieldMutation(fieldInstance, f => f.setTouched(isTouched));\r\n        }\r\n    }\r\n    /**\r\n     * Sets the touched meta state on multiple fields\r\n     */\r\n    function setTouched(fields) {\r\n        keysOf(fields).forEach(field => {\r\n            setFieldTouched(field, !!fields[field]);\r\n        });\r\n    }\r\n    /**\r\n     * Resets all fields\r\n     */\r\n    function resetForm(state) {\r\n        RESET_LOCK = true;\r\n        // set initial values if provided\r\n        if (state === null || state === void 0 ? void 0 : state.values) {\r\n            setInitialValues(state.values);\r\n            setValues(state === null || state === void 0 ? void 0 : state.values);\r\n        }\r\n        else {\r\n            // clean up the initial values back to the original\r\n            setInitialValues(originalInitialValues.value);\r\n            // otherwise clean the current values\r\n            setValues(originalInitialValues.value);\r\n        }\r\n        // avoid resetting the field values, because they should've been reset already.\r\n        mutateAllFields(f => f.resetField());\r\n        if (state === null || state === void 0 ? void 0 : state.touched) {\r\n            setTouched(state.touched);\r\n        }\r\n        setErrors((state === null || state === void 0 ? void 0 : state.errors) || {});\r\n        submitCount.value = (state === null || state === void 0 ? void 0 : state.submitCount) || 0;\r\n        nextTick(() => {\r\n            RESET_LOCK = false;\r\n        });\r\n    }\r\n    function insertFieldAtPath(field, path) {\r\n        const rawField = markRaw(field);\r\n        const fieldPath = path;\r\n        // first field at that path\r\n        if (!fieldsByPath.value[fieldPath]) {\r\n            fieldsByPath.value[fieldPath] = rawField;\r\n            return;\r\n        }\r\n        const fieldAtPath = fieldsByPath.value[fieldPath];\r\n        if (fieldAtPath && !Array.isArray(fieldAtPath)) {\r\n            fieldsByPath.value[fieldPath] = [fieldAtPath];\r\n        }\r\n        // add the new array to that path\r\n        fieldsByPath.value[fieldPath] = [...fieldsByPath.value[fieldPath], rawField];\r\n    }\r\n    function removeFieldFromPath(field, path) {\r\n        const fieldPath = path;\r\n        const fieldAtPath = fieldsByPath.value[fieldPath];\r\n        if (!fieldAtPath) {\r\n            return;\r\n        }\r\n        // same field at path\r\n        if (!isFieldGroup(fieldAtPath) && field.id === fieldAtPath.id) {\r\n            delete fieldsByPath.value[fieldPath];\r\n            return;\r\n        }\r\n        if (isFieldGroup(fieldAtPath)) {\r\n            const idx = fieldAtPath.findIndex(f => f.id === field.id);\r\n            if (idx === -1) {\r\n                return;\r\n            }\r\n            fieldAtPath.splice(idx, 1);\r\n            if (!fieldAtPath.length) {\r\n                delete fieldsByPath.value[fieldPath];\r\n            }\r\n        }\r\n    }\r\n    function registerField(field) {\r\n        const fieldPath = unref(field.name);\r\n        insertFieldAtPath(field, fieldPath);\r\n        if (isRef(field.name)) {\r\n            // ensures when a field's name was already taken that it preserves its same value\r\n            // necessary for fields generated by loops\r\n            watch(field.name, async (newPath, oldPath) => {\r\n                // cache the value\r\n                await nextTick();\r\n                removeFieldFromPath(field, oldPath);\r\n                insertFieldAtPath(field, newPath);\r\n                // re-validate if either path had errors before\r\n                if (errors.value[oldPath] || errors.value[newPath]) {\r\n                    // clear up both paths errors\r\n                    setFieldError(oldPath, undefined);\r\n                    validateField(newPath);\r\n                }\r\n                // clean up the old path if no other field is sharing that name\r\n                // #3325\r\n                await nextTick();\r\n                if (!fieldExists(oldPath)) {\r\n                    unsetPath(formValues, oldPath);\r\n                }\r\n            });\r\n        }\r\n        // if field already had errors (initial errors) that's not user-set, validate it again to ensure state is correct\r\n        // the difference being that `initialErrors` will contain the error message while other errors (pre-validated schema) won't have them as initial errors\r\n        // #3342\r\n        const initialErrorMessage = unref(field.errorMessage);\r\n        if (initialErrorMessage && (initialErrors === null || initialErrors === void 0 ? void 0 : initialErrors[fieldPath]) !== initialErrorMessage) {\r\n            validateField(fieldPath);\r\n        }\r\n        // marks the initial error as \"consumed\" so it won't be matched later with same non-initial error\r\n        delete initialErrors[fieldPath];\r\n    }\r\n    function unregisterField(field) {\r\n        const fieldName = unref(field.name);\r\n        const fieldInstance = fieldsByPath.value[fieldName];\r\n        const isGroup = !!fieldInstance && isFieldGroup(fieldInstance);\r\n        removeFieldFromPath(field, fieldName);\r\n        // clears a field error on unmounted\r\n        // we wait till next tick to make sure if the field is completely removed and doesn't have any siblings like checkboxes\r\n        nextTick(() => {\r\n            var _a;\r\n            const shouldKeepValue = (_a = unref(field.keepValueOnUnmount)) !== null && _a !== void 0 ? _a : unref(keepValuesOnUnmount);\r\n            const currentGroupValue = getFromPath(formValues, fieldName);\r\n            // The boolean here is we check if the field still belongs to the same control group with that name\r\n            // if another group claimed the name, we should avoid handling it since it is no longer the same group\r\n            // this happens with `v-for` over some checkboxes and field arrays.\r\n            // also if the group no longer exist we can assume this group was the last one that controlled it\r\n            const isSameGroup = isGroup && (fieldInstance === fieldsByPath.value[fieldName] || !fieldsByPath.value[fieldName]);\r\n            // group field that still has a dangling value, the field may exist or not after it was removed.\r\n            // This used to be handled in the useField composable but the form has better context on when it should/not happen.\r\n            // if it does belong to it that means the group still exists\r\n            // #3844\r\n            if (isSameGroup && Array.isArray(currentGroupValue) && !shouldKeepValue) {\r\n                const valueIdx = currentGroupValue.findIndex(i => es6(i, unref(field.checkedValue)));\r\n                if (valueIdx > -1) {\r\n                    const newVal = [...currentGroupValue];\r\n                    newVal.splice(valueIdx, 1);\r\n                    setFieldValue(fieldName, newVal, { force: true });\r\n                }\r\n            }\r\n            // Field was removed entirely, we should unset its path\r\n            // #3384\r\n            if (!fieldExists(fieldName)) {\r\n                setFieldError(fieldName, undefined);\r\n                // Checks if the field was configured to be unset during unmount or not\r\n                // Checks both the form-level config and field-level one\r\n                // Field has the priority if it is set, otherwise it goes to the form settings\r\n                if (shouldKeepValue) {\r\n                    return;\r\n                }\r\n                if (isGroup && !isEmptyContainer(getFromPath(formValues, fieldName))) {\r\n                    return;\r\n                }\r\n                unsetPath(formValues, fieldName);\r\n            }\r\n        });\r\n    }\r\n    async function validate(opts) {\r\n        mutateAllFields(f => (f.meta.validated = true));\r\n        if (formCtx.validateSchema) {\r\n            return formCtx.validateSchema((opts === null || opts === void 0 ? void 0 : opts.mode) || 'force');\r\n        }\r\n        // No schema, each field is responsible to validate itself\r\n        const validations = await Promise.all(Object.values(fieldsByPath.value).map(field => {\r\n            const fieldInstance = Array.isArray(field) ? field[0] : field;\r\n            if (!fieldInstance) {\r\n                return Promise.resolve({ key: '', valid: true, errors: [] });\r\n            }\r\n            return fieldInstance.validate(opts).then((result) => {\r\n                return {\r\n                    key: unref(fieldInstance.name),\r\n                    valid: result.valid,\r\n                    errors: result.errors,\r\n                };\r\n            });\r\n        }));\r\n        const results = {};\r\n        const errors = {};\r\n        for (const validation of validations) {\r\n            results[validation.key] = {\r\n                valid: validation.valid,\r\n                errors: validation.errors,\r\n            };\r\n            if (validation.errors.length) {\r\n                errors[validation.key] = validation.errors[0];\r\n            }\r\n        }\r\n        return {\r\n            valid: validations.every(r => r.valid),\r\n            results,\r\n            errors,\r\n        };\r\n    }\r\n    async function validateField(field) {\r\n        const fieldInstance = fieldsByPath.value[field];\r\n        if (!fieldInstance) {\r\n            warn$1(`field with name ${field} was not found`);\r\n            return Promise.resolve({ errors: [], valid: true });\r\n        }\r\n        if (Array.isArray(fieldInstance)) {\r\n            return fieldInstance.map(f => f.validate())[0];\r\n        }\r\n        return fieldInstance.validate();\r\n    }\r\n    function handleSubmit(fn, onValidationError) {\r\n        return function submissionHandler(e) {\r\n            if (e instanceof Event) {\r\n                e.preventDefault();\r\n                e.stopPropagation();\r\n            }\r\n            // Touch all fields\r\n            setTouched(keysOf(fieldsByPath.value).reduce((acc, field) => {\r\n                acc[field] = true;\r\n                return acc;\r\n            }, {}));\r\n            isSubmitting.value = true;\r\n            submitCount.value++;\r\n            return validate()\r\n                .then(result => {\r\n                if (result.valid && typeof fn === 'function') {\r\n                    return fn(klona(formValues), {\r\n                        evt: e,\r\n                        setErrors,\r\n                        setFieldError,\r\n                        setTouched,\r\n                        setFieldTouched,\r\n                        setValues,\r\n                        setFieldValue,\r\n                        resetForm,\r\n                    });\r\n                }\r\n                if (!result.valid && typeof onValidationError === 'function') {\r\n                    onValidationError({\r\n                        values: klona(formValues),\r\n                        evt: e,\r\n                        errors: result.errors,\r\n                        results: result.results,\r\n                    });\r\n                }\r\n            })\r\n                .then(returnVal => {\r\n                isSubmitting.value = false;\r\n                return returnVal;\r\n            }, err => {\r\n                isSubmitting.value = false;\r\n                // re-throw the err so it doesn't go silent\r\n                throw err;\r\n            });\r\n        };\r\n    }\r\n    function setFieldInitialValue(path, value) {\r\n        setInPath(initialValues.value, path, klona(value));\r\n    }\r\n    function unsetInitialValue(path) {\r\n        unsetPath(initialValues.value, path);\r\n    }\r\n    /**\r\n     * Sneaky function to set initial field values\r\n     */\r\n    function stageInitialValue(path, value, updateOriginal = false) {\r\n        setInPath(formValues, path, value);\r\n        setFieldInitialValue(path, value);\r\n        if (updateOriginal && !(opts === null || opts === void 0 ? void 0 : opts.initialValues)) {\r\n            setInPath(originalInitialValues.value, path, klona(value));\r\n        }\r\n    }\r\n    async function _validateSchema() {\r\n        const schemaValue = unref(schema);\r\n        if (!schemaValue) {\r\n            return { valid: true, results: {}, errors: {} };\r\n        }\r\n        const formResult = isYupValidator(schemaValue)\r\n            ? await validateYupSchema(schemaValue, formValues)\r\n            : await validateObjectSchema(schemaValue, formValues, {\r\n                names: fieldNames.value,\r\n                bailsMap: fieldBailsMap.value,\r\n            });\r\n        return formResult;\r\n    }\r\n    /**\r\n     * Batches validation runs in 5ms batches\r\n     * Must have two distinct batch queues to make sure they don't override each other settings #3783\r\n     */\r\n    const debouncedSilentValidation = debounceAsync(_validateSchema, 5);\r\n    const debouncedValidation = debounceAsync(_validateSchema, 5);\r\n    async function validateSchema(mode) {\r\n        const formResult = await (mode === 'silent' ? debouncedSilentValidation() : debouncedValidation());\r\n        // fields by id lookup\r\n        const fieldsById = formCtx.fieldsByPath.value || {};\r\n        // errors fields names, we need it to also check if custom errors are updated\r\n        const currentErrorsPaths = keysOf(formCtx.errorBag.value);\r\n        // collect all the keys from the schema and all fields\r\n        // this ensures we have a complete keymap of all the fields\r\n        const paths = [\r\n            ...new Set([...keysOf(formResult.results), ...keysOf(fieldsById), ...currentErrorsPaths]),\r\n        ];\r\n        // aggregates the paths into a single result object while applying the results on the fields\r\n        return paths.reduce((validation, path) => {\r\n            const field = fieldsById[path];\r\n            const messages = (formResult.results[path] || { errors: [] }).errors;\r\n            const fieldResult = {\r\n                errors: messages,\r\n                valid: !messages.length,\r\n            };\r\n            validation.results[path] = fieldResult;\r\n            if (!fieldResult.valid) {\r\n                validation.errors[path] = fieldResult.errors[0];\r\n            }\r\n            // field not rendered\r\n            if (!field) {\r\n                setFieldError(path, messages);\r\n                return validation;\r\n            }\r\n            // always update the valid flag regardless of the mode\r\n            applyFieldMutation(field, f => (f.meta.valid = fieldResult.valid));\r\n            if (mode === 'silent') {\r\n                return validation;\r\n            }\r\n            const wasValidated = Array.isArray(field) ? field.some(f => f.meta.validated) : field.meta.validated;\r\n            if (mode === 'validated-only' && !wasValidated) {\r\n                return validation;\r\n            }\r\n            applyFieldMutation(field, f => f.setState({ errors: fieldResult.errors }));\r\n            return validation;\r\n        }, { valid: formResult.valid, results: {}, errors: {} });\r\n    }\r\n    const submitForm = handleSubmit((_, { evt }) => {\r\n        if (isFormSubmitEvent(evt)) {\r\n            evt.target.submit();\r\n        }\r\n    });\r\n    // Trigger initial validation\r\n    onMounted(() => {\r\n        if (opts === null || opts === void 0 ? void 0 : opts.initialErrors) {\r\n            setErrors(opts.initialErrors);\r\n        }\r\n        if (opts === null || opts === void 0 ? void 0 : opts.initialTouched) {\r\n            setTouched(opts.initialTouched);\r\n        }\r\n        // if validate on mount was enabled\r\n        if (opts === null || opts === void 0 ? void 0 : opts.validateOnMount) {\r\n            validate();\r\n            return;\r\n        }\r\n        // otherwise run initial silent validation through schema if available\r\n        // the useField should skip their own silent validation if a yup schema is present\r\n        if (formCtx.validateSchema) {\r\n            formCtx.validateSchema('silent');\r\n        }\r\n    });\r\n    if (isRef(schema)) {\r\n        watch(schema, () => {\r\n            var _a;\r\n            (_a = formCtx.validateSchema) === null || _a === void 0 ? void 0 : _a.call(formCtx, 'validated-only');\r\n        });\r\n    }\r\n    // Provide injections\r\n    provide(FormContextKey, formCtx);\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        registerFormWithDevTools(formCtx);\r\n        watch(() => (Object.assign(Object.assign({ errors: errorBag.value }, meta.value), { values: formValues, isSubmitting: isSubmitting.value, submitCount: submitCount.value })), refreshInspector, {\r\n            deep: true,\r\n        });\r\n    }\r\n    return {\r\n        errors,\r\n        meta,\r\n        values: formValues,\r\n        isSubmitting,\r\n        submitCount,\r\n        validate,\r\n        validateField,\r\n        handleReset: () => resetForm(),\r\n        resetForm,\r\n        handleSubmit,\r\n        submitForm,\r\n        setFieldError,\r\n        setErrors,\r\n        setFieldValue,\r\n        setValues,\r\n        setFieldTouched,\r\n        setTouched,\r\n        useFieldModel,\r\n    };\r\n}\r\n/**\r\n * Manages form meta aggregation\r\n */\r\nfunction useFormMeta(fieldsByPath, currentValues, initialValues, errors) {\r\n    const MERGE_STRATEGIES = {\r\n        touched: 'some',\r\n        pending: 'some',\r\n        valid: 'every',\r\n    };\r\n    const isDirty = computed(() => {\r\n        return !es6(currentValues, unref(initialValues));\r\n    });\r\n    function calculateFlags() {\r\n        const fields = Object.values(fieldsByPath.value).flat(1).filter(Boolean);\r\n        return keysOf(MERGE_STRATEGIES).reduce((acc, flag) => {\r\n            const mergeMethod = MERGE_STRATEGIES[flag];\r\n            acc[flag] = fields[mergeMethod](field => field.meta[flag]);\r\n            return acc;\r\n        }, {});\r\n    }\r\n    const flags = reactive(calculateFlags());\r\n    watchEffect(() => {\r\n        const value = calculateFlags();\r\n        flags.touched = value.touched;\r\n        flags.valid = value.valid;\r\n        flags.pending = value.pending;\r\n    });\r\n    return computed(() => {\r\n        return Object.assign(Object.assign({ initialValues: unref(initialValues) }, flags), { valid: flags.valid && !keysOf(errors.value).length, dirty: isDirty.value });\r\n    });\r\n}\r\n/**\r\n * Manages the initial values prop\r\n */\r\nfunction useFormInitialValues(fields, formValues, providedValues) {\r\n    // these are the mutable initial values as the fields are mounted/unmounted\r\n    const initialValues = ref(klona(unref(providedValues)) || {});\r\n    // these are the original initial value as provided by the user initially, they don't keep track of conditional fields\r\n    // this is important because some conditional fields will overwrite the initial values for other fields who had the same name\r\n    // like array fields, any push/insert operation will overwrite the initial values because they \"create new fields\"\r\n    // so these are the values that the reset function should use\r\n    // these only change when the user explicitly chanegs the initial values or when the user resets them with new values.\r\n    const originalInitialValues = ref(klona(unref(providedValues)) || {});\r\n    function setInitialValues(values, updateFields = false) {\r\n        initialValues.value = klona(values);\r\n        originalInitialValues.value = klona(values);\r\n        if (!updateFields) {\r\n            return;\r\n        }\r\n        // update the pristine non-touched fields\r\n        // those are excluded because it's unlikely you want to change the form values using initial values\r\n        // we mostly watch them for API population or newly inserted fields\r\n        // if the user API is taking too much time before user interaction they should consider disabling or hiding their inputs until the values are ready\r\n        keysOf(fields.value).forEach(fieldPath => {\r\n            const field = fields.value[fieldPath];\r\n            const wasTouched = Array.isArray(field) ? field.some(f => f.meta.touched) : field === null || field === void 0 ? void 0 : field.meta.touched;\r\n            if (!field || wasTouched) {\r\n                return;\r\n            }\r\n            const newValue = getFromPath(initialValues.value, fieldPath);\r\n            setInPath(formValues, fieldPath, klona(newValue));\r\n        });\r\n    }\r\n    if (isRef(providedValues)) {\r\n        watch(providedValues, value => {\r\n            setInitialValues(value, true);\r\n        }, {\r\n            deep: true,\r\n        });\r\n    }\r\n    return {\r\n        initialValues,\r\n        originalInitialValues,\r\n        setInitialValues,\r\n    };\r\n}\r\nfunction useErrorBag(initialErrors) {\r\n    const errorBag = ref({});\r\n    function normalizeErrorItem(message) {\r\n        return Array.isArray(message) ? message : message ? [message] : [];\r\n    }\r\n    /**\r\n     * Manually sets an error message on a specific field\r\n     */\r\n    function setFieldErrorBag(field, message) {\r\n        if (!message) {\r\n            delete errorBag.value[field];\r\n            return;\r\n        }\r\n        errorBag.value[field] = normalizeErrorItem(message);\r\n    }\r\n    /**\r\n     * Sets errors for the fields specified in the object\r\n     */\r\n    function setErrorBag(fields) {\r\n        errorBag.value = keysOf(fields).reduce((acc, key) => {\r\n            const message = fields[key];\r\n            if (message) {\r\n                acc[key] = normalizeErrorItem(message);\r\n            }\r\n            return acc;\r\n        }, {});\r\n    }\r\n    if (initialErrors) {\r\n        setErrorBag(initialErrors);\r\n    }\r\n    return {\r\n        errorBag,\r\n        setErrorBag,\r\n        setFieldErrorBag,\r\n    };\r\n}\n\nconst FormImpl = defineComponent({\r\n    name: 'Form',\r\n    inheritAttrs: false,\r\n    props: {\r\n        as: {\r\n            type: String,\r\n            default: 'form',\r\n        },\r\n        validationSchema: {\r\n            type: Object,\r\n            default: undefined,\r\n        },\r\n        initialValues: {\r\n            type: Object,\r\n            default: undefined,\r\n        },\r\n        initialErrors: {\r\n            type: Object,\r\n            default: undefined,\r\n        },\r\n        initialTouched: {\r\n            type: Object,\r\n            default: undefined,\r\n        },\r\n        validateOnMount: {\r\n            type: Boolean,\r\n            default: false,\r\n        },\r\n        onSubmit: {\r\n            type: Function,\r\n            default: undefined,\r\n        },\r\n        onInvalidSubmit: {\r\n            type: Function,\r\n            default: undefined,\r\n        },\r\n        keepValues: {\r\n            type: Boolean,\r\n            default: false,\r\n        },\r\n    },\r\n    setup(props, ctx) {\r\n        const initialValues = toRef(props, 'initialValues');\r\n        const validationSchema = toRef(props, 'validationSchema');\r\n        const keepValues = toRef(props, 'keepValues');\r\n        const { errors, values, meta, isSubmitting, submitCount, validate, validateField, handleReset, resetForm, handleSubmit, setErrors, setFieldError, setFieldValue, setValues, setFieldTouched, setTouched, } = useForm({\r\n            validationSchema: validationSchema.value ? validationSchema : undefined,\r\n            initialValues,\r\n            initialErrors: props.initialErrors,\r\n            initialTouched: props.initialTouched,\r\n            validateOnMount: props.validateOnMount,\r\n            keepValuesOnUnmount: keepValues,\r\n        });\r\n        const submitForm = handleSubmit((_, { evt }) => {\r\n            if (isFormSubmitEvent(evt)) {\r\n                evt.target.submit();\r\n            }\r\n        }, props.onInvalidSubmit);\r\n        const onSubmit = props.onSubmit ? handleSubmit(props.onSubmit, props.onInvalidSubmit) : submitForm;\r\n        function handleFormReset(e) {\r\n            if (isEvent(e)) {\r\n                // Prevent default form reset behavior\r\n                e.preventDefault();\r\n            }\r\n            handleReset();\r\n            if (typeof ctx.attrs.onReset === 'function') {\r\n                ctx.attrs.onReset();\r\n            }\r\n        }\r\n        function handleScopedSlotSubmit(evt, onSubmit) {\r\n            const onSuccess = typeof evt === 'function' && !onSubmit ? evt : onSubmit;\r\n            return handleSubmit(onSuccess, props.onInvalidSubmit)(evt);\r\n        }\r\n        function slotProps() {\r\n            return {\r\n                meta: meta.value,\r\n                errors: errors.value,\r\n                values: values,\r\n                isSubmitting: isSubmitting.value,\r\n                submitCount: submitCount.value,\r\n                validate,\r\n                validateField,\r\n                handleSubmit: handleScopedSlotSubmit,\r\n                handleReset,\r\n                submitForm,\r\n                setErrors,\r\n                setFieldError,\r\n                setFieldValue,\r\n                setValues,\r\n                setFieldTouched,\r\n                setTouched,\r\n                resetForm,\r\n            };\r\n        }\r\n        // expose these functions and methods as part of public API\r\n        ctx.expose({\r\n            setFieldError,\r\n            setErrors,\r\n            setFieldValue,\r\n            setValues,\r\n            setFieldTouched,\r\n            setTouched,\r\n            resetForm,\r\n            validate,\r\n            validateField,\r\n        });\r\n        return function renderForm() {\r\n            // avoid resolving the form component as itself\r\n            const tag = props.as === 'form' ? props.as : resolveDynamicComponent(props.as);\r\n            const children = normalizeChildren(tag, ctx, slotProps);\r\n            if (!props.as) {\r\n                return children;\r\n            }\r\n            // Attributes to add on a native `form` tag\r\n            const formAttrs = props.as === 'form'\r\n                ? {\r\n                    // Disables native validation as vee-validate will handle it.\r\n                    novalidate: true,\r\n                }\r\n                : {};\r\n            return h(tag, Object.assign(Object.assign(Object.assign({}, formAttrs), ctx.attrs), { onSubmit, onReset: handleFormReset }), children);\r\n        };\r\n    },\r\n});\r\nconst Form = FormImpl;\n\nfunction useFieldArray(arrayPath) {\r\n    const form = injectWithSelf(FormContextKey, undefined);\r\n    const fields = ref([]);\r\n    // eslint-disable-next-line @typescript-eslint/no-empty-function\r\n    const noOp = () => { };\r\n    const noOpApi = {\r\n        fields,\r\n        remove: noOp,\r\n        push: noOp,\r\n        swap: noOp,\r\n        insert: noOp,\r\n        update: noOp,\r\n        replace: noOp,\r\n        prepend: noOp,\r\n        move: noOp,\r\n    };\r\n    if (!form) {\r\n        warn('FieldArray requires being a child of `<Form/>` or `useForm` being called before it. Array fields may not work correctly');\r\n        return noOpApi;\r\n    }\r\n    if (!unref(arrayPath)) {\r\n        warn('FieldArray requires a field path to be provided, did you forget to pass the `name` prop?');\r\n        return noOpApi;\r\n    }\r\n    const alreadyExists = form.fieldArrays.find(a => unref(a.path) === unref(arrayPath));\r\n    if (alreadyExists) {\r\n        return alreadyExists;\r\n    }\r\n    let entryCounter = 0;\r\n    function initFields() {\r\n        const currentValues = getFromPath(form === null || form === void 0 ? void 0 : form.values, unref(arrayPath), []) || [];\r\n        fields.value = currentValues.map(createEntry);\r\n        updateEntryFlags();\r\n    }\r\n    initFields();\r\n    function updateEntryFlags() {\r\n        const fieldsLength = fields.value.length;\r\n        for (let i = 0; i < fieldsLength; i++) {\r\n            const entry = fields.value[i];\r\n            entry.isFirst = i === 0;\r\n            entry.isLast = i === fieldsLength - 1;\r\n        }\r\n    }\r\n    function createEntry(value) {\r\n        const key = entryCounter++;\r\n        const entry = {\r\n            key,\r\n            value: computed({\r\n                get() {\r\n                    const currentValues = getFromPath(form === null || form === void 0 ? void 0 : form.values, unref(arrayPath), []) || [];\r\n                    const idx = fields.value.findIndex(e => e.key === key);\r\n                    return idx === -1 ? value : currentValues[idx];\r\n                },\r\n                set(value) {\r\n                    const idx = fields.value.findIndex(e => e.key === key);\r\n                    if (idx === -1) {\r\n                        warn(`Attempting to update a non-existent array item`);\r\n                        return;\r\n                    }\r\n                    update(idx, value);\r\n                },\r\n            }),\r\n            isFirst: false,\r\n            isLast: false,\r\n        };\r\n        return entry;\r\n    }\r\n    function remove(idx) {\r\n        const pathName = unref(arrayPath);\r\n        const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);\r\n        if (!pathValue || !Array.isArray(pathValue)) {\r\n            return;\r\n        }\r\n        const newValue = [...pathValue];\r\n        newValue.splice(idx, 1);\r\n        form === null || form === void 0 ? void 0 : form.unsetInitialValue(pathName + `[${idx}]`);\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);\r\n        fields.value.splice(idx, 1);\r\n        updateEntryFlags();\r\n    }\r\n    function push(value) {\r\n        const pathName = unref(arrayPath);\r\n        const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);\r\n        const normalizedPathValue = isNullOrUndefined(pathValue) ? [] : pathValue;\r\n        if (!Array.isArray(normalizedPathValue)) {\r\n            return;\r\n        }\r\n        const newValue = [...normalizedPathValue];\r\n        newValue.push(value);\r\n        form === null || form === void 0 ? void 0 : form.stageInitialValue(pathName + `[${newValue.length - 1}]`, value);\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);\r\n        fields.value.push(createEntry(value));\r\n        updateEntryFlags();\r\n    }\r\n    function swap(indexA, indexB) {\r\n        const pathName = unref(arrayPath);\r\n        const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);\r\n        if (!Array.isArray(pathValue) || !(indexA in pathValue) || !(indexB in pathValue)) {\r\n            return;\r\n        }\r\n        const newValue = [...pathValue];\r\n        const newFields = [...fields.value];\r\n        // the old switcheroo\r\n        const temp = newValue[indexA];\r\n        newValue[indexA] = newValue[indexB];\r\n        newValue[indexB] = temp;\r\n        const tempEntry = newFields[indexA];\r\n        newFields[indexA] = newFields[indexB];\r\n        newFields[indexB] = tempEntry;\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);\r\n        fields.value = newFields;\r\n        updateEntryFlags();\r\n    }\r\n    function insert(idx, value) {\r\n        const pathName = unref(arrayPath);\r\n        const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);\r\n        if (!Array.isArray(pathValue) || pathValue.length < idx) {\r\n            return;\r\n        }\r\n        const newValue = [...pathValue];\r\n        const newFields = [...fields.value];\r\n        newValue.splice(idx, 0, value);\r\n        newFields.splice(idx, 0, createEntry(value));\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);\r\n        fields.value = newFields;\r\n        updateEntryFlags();\r\n    }\r\n    function replace(arr) {\r\n        const pathName = unref(arrayPath);\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, arr);\r\n        initFields();\r\n    }\r\n    function update(idx, value) {\r\n        const pathName = unref(arrayPath);\r\n        const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);\r\n        if (!Array.isArray(pathValue) || pathValue.length - 1 < idx) {\r\n            return;\r\n        }\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(`${pathName}[${idx}]`, value);\r\n    }\r\n    function prepend(value) {\r\n        const pathName = unref(arrayPath);\r\n        const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);\r\n        const normalizedPathValue = isNullOrUndefined(pathValue) ? [] : pathValue;\r\n        if (!Array.isArray(normalizedPathValue)) {\r\n            return;\r\n        }\r\n        const newValue = [value, ...normalizedPathValue];\r\n        form === null || form === void 0 ? void 0 : form.stageInitialValue(pathName + `[${newValue.length - 1}]`, value);\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);\r\n        fields.value.unshift(createEntry(value));\r\n        updateEntryFlags();\r\n    }\r\n    function move(oldIdx, newIdx) {\r\n        const pathName = unref(arrayPath);\r\n        const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);\r\n        const newValue = isNullOrUndefined(pathValue) ? [] : [...pathValue];\r\n        if (!Array.isArray(pathValue) || !(oldIdx in pathValue) || !(newIdx in pathValue)) {\r\n            return;\r\n        }\r\n        const newFields = [...fields.value];\r\n        const movedItem = newFields[oldIdx];\r\n        newFields.splice(oldIdx, 1);\r\n        newFields.splice(newIdx, 0, movedItem);\r\n        const movedValue = newValue[oldIdx];\r\n        newValue.splice(oldIdx, 1);\r\n        newValue.splice(newIdx, 0, movedValue);\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);\r\n        fields.value = newFields;\r\n        updateEntryFlags();\r\n    }\r\n    const fieldArrayCtx = {\r\n        fields,\r\n        remove,\r\n        push,\r\n        swap,\r\n        insert,\r\n        update,\r\n        replace,\r\n        prepend,\r\n        move,\r\n    };\r\n    form.fieldArrays.push(Object.assign({ path: arrayPath, reset: initFields }, fieldArrayCtx));\r\n    onBeforeUnmount(() => {\r\n        const idx = form.fieldArrays.findIndex(i => unref(i.path) === unref(arrayPath));\r\n        if (idx >= 0) {\r\n            form.fieldArrays.splice(idx, 1);\r\n        }\r\n    });\r\n    return fieldArrayCtx;\r\n}\n\nconst FieldArrayImpl = defineComponent({\r\n    name: 'FieldArray',\r\n    inheritAttrs: false,\r\n    props: {\r\n        name: {\r\n            type: String,\r\n            required: true,\r\n        },\r\n    },\r\n    setup(props, ctx) {\r\n        const { push, remove, swap, insert, replace, update, prepend, move, fields } = useFieldArray(toRef(props, 'name'));\r\n        function slotProps() {\r\n            return {\r\n                fields: fields.value,\r\n                push,\r\n                remove,\r\n                swap,\r\n                insert,\r\n                update,\r\n                replace,\r\n                prepend,\r\n                move,\r\n            };\r\n        }\r\n        ctx.expose({\r\n            push,\r\n            remove,\r\n            swap,\r\n            insert,\r\n            update,\r\n            replace,\r\n            prepend,\r\n            move,\r\n        });\r\n        return () => {\r\n            const children = normalizeChildren(undefined, ctx, slotProps);\r\n            return children;\r\n        };\r\n    },\r\n});\r\nconst FieldArray = FieldArrayImpl;\n\nconst ErrorMessageImpl = defineComponent({\r\n    name: 'ErrorMessage',\r\n    props: {\r\n        as: {\r\n            type: String,\r\n            default: undefined,\r\n        },\r\n        name: {\r\n            type: String,\r\n            required: true,\r\n        },\r\n    },\r\n    setup(props, ctx) {\r\n        const form = inject(FormContextKey, undefined);\r\n        const message = computed(() => {\r\n            return form === null || form === void 0 ? void 0 : form.errors.value[props.name];\r\n        });\r\n        function slotProps() {\r\n            return {\r\n                message: message.value,\r\n            };\r\n        }\r\n        return () => {\r\n            // Renders nothing if there are no messages\r\n            if (!message.value) {\r\n                return undefined;\r\n            }\r\n            const tag = (props.as ? resolveDynamicComponent(props.as) : props.as);\r\n            const children = normalizeChildren(tag, ctx, slotProps);\r\n            const attrs = Object.assign({ role: 'alert' }, ctx.attrs);\r\n            // If no tag was specified and there are children\r\n            // render the slot as is without wrapping it\r\n            if (!tag && (Array.isArray(children) || !children) && (children === null || children === void 0 ? void 0 : children.length)) {\r\n                return children;\r\n            }\r\n            // If no children in slot\r\n            // render whatever specified and fallback to a <span> with the message in it's contents\r\n            if ((Array.isArray(children) || !children) && !(children === null || children === void 0 ? void 0 : children.length)) {\r\n                return h(tag || 'span', attrs, message.value);\r\n            }\r\n            return h(tag, attrs, children);\r\n        };\r\n    },\r\n});\r\nconst ErrorMessage = ErrorMessageImpl;\n\nfunction useResetForm() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return function resetForm(state) {\r\n        if (!form) {\r\n            return;\r\n        }\r\n        return form.resetForm(state);\r\n    };\r\n}\n\n/**\r\n * If a field is dirty or not\r\n */\r\nfunction useIsFieldDirty(path) {\r\n    const form = injectWithSelf(FormContextKey);\r\n    let field = path ? undefined : inject(FieldContextKey);\r\n    return computed(() => {\r\n        if (path) {\r\n            field = normalizeField(form === null || form === void 0 ? void 0 : form.fieldsByPath.value[unref(path)]);\r\n        }\r\n        if (!field) {\r\n            warn(`field with name ${unref(path)} was not found`);\r\n            return false;\r\n        }\r\n        return field.meta.dirty;\r\n    });\r\n}\n\n/**\r\n * If a field is touched or not\r\n */\r\nfunction useIsFieldTouched(path) {\r\n    const form = injectWithSelf(FormContextKey);\r\n    let field = path ? undefined : inject(FieldContextKey);\r\n    return computed(() => {\r\n        if (path) {\r\n            field = normalizeField(form === null || form === void 0 ? void 0 : form.fieldsByPath.value[unref(path)]);\r\n        }\r\n        if (!field) {\r\n            warn(`field with name ${unref(path)} was not found`);\r\n            return false;\r\n        }\r\n        return field.meta.touched;\r\n    });\r\n}\n\n/**\r\n * If a field is validated and is valid\r\n */\r\nfunction useIsFieldValid(path) {\r\n    const form = injectWithSelf(FormContextKey);\r\n    let field = path ? undefined : inject(FieldContextKey);\r\n    return computed(() => {\r\n        if (path) {\r\n            field = normalizeField(form === null || form === void 0 ? void 0 : form.fieldsByPath.value[unref(path)]);\r\n        }\r\n        if (!field) {\r\n            warn(`field with name ${unref(path)} was not found`);\r\n            return false;\r\n        }\r\n        return field.meta.valid;\r\n    });\r\n}\n\n/**\r\n * If the form is submitting or not\r\n */\r\nfunction useIsSubmitting() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return computed(() => {\r\n        var _a;\r\n        return (_a = form === null || form === void 0 ? void 0 : form.isSubmitting.value) !== null && _a !== void 0 ? _a : false;\r\n    });\r\n}\n\n/**\r\n * Validates a single field\r\n */\r\nfunction useValidateField(path) {\r\n    const form = injectWithSelf(FormContextKey);\r\n    let field = path ? undefined : inject(FieldContextKey);\r\n    return function validateField() {\r\n        if (path) {\r\n            field = normalizeField(form === null || form === void 0 ? void 0 : form.fieldsByPath.value[unref(path)]);\r\n        }\r\n        if (!field) {\r\n            warn(`field with name ${unref(path)} was not found`);\r\n            return Promise.resolve({\r\n                errors: [],\r\n                valid: true,\r\n            });\r\n        }\r\n        return field.validate();\r\n    };\r\n}\n\n/**\r\n * If the form is dirty or not\r\n */\r\nfunction useIsFormDirty() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return computed(() => {\r\n        var _a;\r\n        return (_a = form === null || form === void 0 ? void 0 : form.meta.value.dirty) !== null && _a !== void 0 ? _a : false;\r\n    });\r\n}\n\n/**\r\n * If the form is touched or not\r\n */\r\nfunction useIsFormTouched() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return computed(() => {\r\n        var _a;\r\n        return (_a = form === null || form === void 0 ? void 0 : form.meta.value.touched) !== null && _a !== void 0 ? _a : false;\r\n    });\r\n}\n\n/**\r\n * If the form has been validated and is valid\r\n */\r\nfunction useIsFormValid() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return computed(() => {\r\n        var _a;\r\n        return (_a = form === null || form === void 0 ? void 0 : form.meta.value.valid) !== null && _a !== void 0 ? _a : false;\r\n    });\r\n}\n\n/**\r\n * Validate multiple fields\r\n */\r\nfunction useValidateForm() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return function validateField() {\r\n        if (!form) {\r\n            return Promise.resolve({ results: {}, errors: {}, valid: true });\r\n        }\r\n        return form.validate();\r\n    };\r\n}\n\n/**\r\n * The number of form's submission count\r\n */\r\nfunction useSubmitCount() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return computed(() => {\r\n        var _a;\r\n        return (_a = form === null || form === void 0 ? void 0 : form.submitCount.value) !== null && _a !== void 0 ? _a : 0;\r\n    });\r\n}\n\n/**\r\n * Gives access to a field's current value\r\n */\r\nfunction useFieldValue(path) {\r\n    const form = injectWithSelf(FormContextKey);\r\n    // We don't want to use self injected context as it doesn't make sense\r\n    const field = path ? undefined : inject(FieldContextKey);\r\n    return computed(() => {\r\n        if (path) {\r\n            return getFromPath(form === null || form === void 0 ? void 0 : form.values, unref(path));\r\n        }\r\n        return unref(field === null || field === void 0 ? void 0 : field.value);\r\n    });\r\n}\n\n/**\r\n * Gives access to a form's values\r\n */\r\nfunction useFormValues() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return computed(() => {\r\n        return (form === null || form === void 0 ? void 0 : form.values) || {};\r\n    });\r\n}\n\n/**\r\n * Gives access to all form errors\r\n */\r\nfunction useFormErrors() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return computed(() => {\r\n        return ((form === null || form === void 0 ? void 0 : form.errors.value) || {});\r\n    });\r\n}\n\n/**\r\n * Gives access to a single field error\r\n */\r\nfunction useFieldError(path) {\r\n    const form = injectWithSelf(FormContextKey);\r\n    // We don't want to use self injected context as it doesn't make sense\r\n    const field = path ? undefined : inject(FieldContextKey);\r\n    return computed(() => {\r\n        if (path) {\r\n            return form === null || form === void 0 ? void 0 : form.errors.value[unref(path)];\r\n        }\r\n        return field === null || field === void 0 ? void 0 : field.errorMessage.value;\r\n    });\r\n}\n\nfunction useSubmitForm(cb) {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    const onSubmit = form ? form.handleSubmit(cb) : undefined;\r\n    return function submitForm(e) {\r\n        if (!onSubmit) {\r\n            return;\r\n        }\r\n        return onSubmit(e);\r\n    };\r\n}\n\nexport { ErrorMessage, Field, FieldArray, FieldContextKey, Form, FormContextKey, IS_ABSENT, configure, defineRule, useField, useFieldArray, useFieldError, useFieldValue, useForm, useFormErrors, useFormValues, useIsFieldDirty, useIsFieldTouched, useIsFieldValid, useIsFormDirty, useIsFormTouched, useIsFormValid, useIsSubmitting, useResetForm, useSubmitCount, useSubmitForm, useValidateField, useValidateForm, validate };\n","/*!\n  * shared v9.2.0-beta.35\n  * (c) 2022 kazuya kawaguchi\n  * Released under the MIT License.\n  */\n/**\r\n * Original Utilities\r\n * written by kazuya kawaguchi\r\n */\r\nconst inBrowser = typeof window !== 'undefined';\r\nlet mark;\r\nlet measure;\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n    const perf = inBrowser && window.performance;\r\n    if (perf &&\r\n        perf.mark &&\r\n        perf.measure &&\r\n        perf.clearMarks &&\r\n        perf.clearMeasures) {\r\n        mark = (tag) => perf.mark(tag);\r\n        measure = (name, startTag, endTag) => {\r\n            perf.measure(name, startTag, endTag);\r\n            perf.clearMarks(startTag);\r\n            perf.clearMarks(endTag);\r\n        };\r\n    }\r\n}\r\nconst RE_ARGS = /\\{([0-9a-zA-Z]+)\\}/g;\r\n/* eslint-disable */\r\nfunction format(message, ...args) {\r\n    if (args.length === 1 && isObject(args[0])) {\r\n        args = args[0];\r\n    }\r\n    if (!args || !args.hasOwnProperty) {\r\n        args = {};\r\n    }\r\n    return message.replace(RE_ARGS, (match, identifier) => {\r\n        return args.hasOwnProperty(identifier) ? args[identifier] : '';\r\n    });\r\n}\r\nconst hasSymbol = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\r\nconst makeSymbol = (name) => hasSymbol ? Symbol(name) : name;\r\nconst generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });\r\nconst friendlyJSONstringify = (json) => JSON.stringify(json)\r\n    .replace(/\\u2028/g, '\\\\u2028')\r\n    .replace(/\\u2029/g, '\\\\u2029')\r\n    .replace(/\\u0027/g, '\\\\u0027');\r\nconst isNumber = (val) => typeof val === 'number' && isFinite(val);\r\nconst isDate = (val) => toTypeString(val) === '[object Date]';\r\nconst isRegExp = (val) => toTypeString(val) === '[object RegExp]';\r\nconst isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length === 0;\r\nfunction warn(msg, err) {\r\n    if (typeof console !== 'undefined') {\r\n        console.warn(`[intlify] ` + msg);\r\n        /* istanbul ignore if */\r\n        if (err) {\r\n            console.warn(err.stack);\r\n        }\r\n    }\r\n}\r\nconst assign = Object.assign;\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n    // prettier-ignore\r\n    return (_globalThis ||\r\n        (_globalThis =\r\n            typeof globalThis !== 'undefined'\r\n                ? globalThis\r\n                : typeof self !== 'undefined'\r\n                    ? self\r\n                    : typeof window !== 'undefined'\r\n                        ? window\r\n                        : typeof global !== 'undefined'\r\n                            ? global\r\n                            : {}));\r\n};\r\nfunction escapeHtml(rawText) {\r\n    return rawText\r\n        .replace(/</g, '&lt;')\r\n        .replace(/>/g, '&gt;')\r\n        .replace(/\"/g, '&quot;')\r\n        .replace(/'/g, '&apos;');\r\n}\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nfunction hasOwn(obj, key) {\r\n    return hasOwnProperty.call(obj, key);\r\n}\r\n/* eslint-enable */\r\n/**\r\n * Useful Utilities By Evan you\r\n * Modified by kazuya kawaguchi\r\n * MIT License\r\n * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts\r\n * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts\r\n */\r\nconst isArray = Array.isArray;\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isBoolean = (val) => typeof val === 'boolean';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => // eslint-disable-line\r\n val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n    return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst isPlainObject = (val) => toTypeString(val) === '[object Object]';\r\n// for converting list and named values to displayed strings.\r\nconst toDisplayString = (val) => {\r\n    return val == null\r\n        ? ''\r\n        : isArray(val) || (isPlainObject(val) && val.toString === objectToString)\r\n            ? JSON.stringify(val, null, 2)\r\n            : String(val);\r\n};\r\nconst RANGE = 2;\r\nfunction generateCodeFrame(source, start = 0, end = source.length) {\r\n    const lines = source.split(/\\r?\\n/);\r\n    let count = 0;\r\n    const res = [];\r\n    for (let i = 0; i < lines.length; i++) {\r\n        count += lines[i].length + 1;\r\n        if (count >= start) {\r\n            for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {\r\n                if (j < 0 || j >= lines.length)\r\n                    continue;\r\n                const line = j + 1;\r\n                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);\r\n                const lineLength = lines[j].length;\r\n                if (j === i) {\r\n                    // push underline\r\n                    const pad = start - (count - lineLength) + 1;\r\n                    const length = Math.max(1, end > count ? lineLength - pad : end - start);\r\n                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));\r\n                }\r\n                else if (j > i) {\r\n                    if (end > count) {\r\n                        const length = Math.max(Math.min(end - count, lineLength), 1);\r\n                        res.push(`   |  ` + '^'.repeat(length));\r\n                    }\r\n                    count += lineLength + 1;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    }\r\n    return res.join('\\n');\r\n}\n\n/**\r\n * Event emitter, forked from the below:\r\n * - original repository url: https://github.com/developit/mitt\r\n * - code url: https://github.com/developit/mitt/blob/master/src/index.ts\r\n * - author: Jason Miller (https://github.com/developit)\r\n * - license: MIT\r\n */\r\n/**\r\n * Create a event emitter\r\n *\r\n * @returns An event emitter\r\n */\r\nfunction createEmitter() {\r\n    const events = new Map();\r\n    const emitter = {\r\n        events,\r\n        on(event, handler) {\r\n            const handlers = events.get(event);\r\n            const added = handlers && handlers.push(handler);\r\n            if (!added) {\r\n                events.set(event, [handler]);\r\n            }\r\n        },\r\n        off(event, handler) {\r\n            const handlers = events.get(event);\r\n            if (handlers) {\r\n                handlers.splice(handlers.indexOf(handler) >>> 0, 1);\r\n            }\r\n        },\r\n        emit(event, payload) {\r\n            (events.get(event) || [])\r\n                .slice()\r\n                .map(handler => handler(payload));\r\n            (events.get('*') || [])\r\n                .slice()\r\n                .map(handler => handler(event, payload));\r\n        }\r\n    };\r\n    return emitter;\r\n}\n\nexport { assign, createEmitter, escapeHtml, format, friendlyJSONstringify, generateCodeFrame, generateFormatCacheKey, getGlobalThis, hasOwn, inBrowser, isArray, isBoolean, isDate, isEmptyObject, isFunction, isNumber, isObject, isPlainObject, isPromise, isRegExp, isString, isSymbol, makeSymbol, mark, measure, objectToString, toDisplayString, toTypeString, warn };\n","/*!\n  * message-compiler v9.2.0-beta.35\n  * (c) 2022 kazuya kawaguchi\n  * Released under the MIT License.\n  */\nimport { format, assign, isString } from '@intlify/shared';\n\nconst CompileErrorCodes = {\r\n    // tokenizer error codes\r\n    EXPECTED_TOKEN: 1,\r\n    INVALID_TOKEN_IN_PLACEHOLDER: 2,\r\n    UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3,\r\n    UNKNOWN_ESCAPE_SEQUENCE: 4,\r\n    INVALID_UNICODE_ESCAPE_SEQUENCE: 5,\r\n    UNBALANCED_CLOSING_BRACE: 6,\r\n    UNTERMINATED_CLOSING_BRACE: 7,\r\n    EMPTY_PLACEHOLDER: 8,\r\n    NOT_ALLOW_NEST_PLACEHOLDER: 9,\r\n    INVALID_LINKED_FORMAT: 10,\r\n    // parser error codes\r\n    MUST_HAVE_MESSAGES_IN_PLURAL: 11,\r\n    UNEXPECTED_EMPTY_LINKED_MODIFIER: 12,\r\n    UNEXPECTED_EMPTY_LINKED_KEY: 13,\r\n    UNEXPECTED_LEXICAL_ANALYSIS: 14,\r\n    // Special value for higher-order compilers to pick up the last code\r\n    // to avoid collision of error codes. This should always be kept as the last\r\n    // item.\r\n    __EXTEND_POINT__: 15\r\n};\r\n/** @internal */\r\nconst errorMessages = {\r\n    // tokenizer error messages\r\n    [CompileErrorCodes.EXPECTED_TOKEN]: `Expected token: '{0}'`,\r\n    [CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER]: `Invalid token in placeholder: '{0}'`,\r\n    [CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER]: `Unterminated single quote in placeholder`,\r\n    [CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE]: `Unknown escape sequence: \\\\{0}`,\r\n    [CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE]: `Invalid unicode escape sequence: {0}`,\r\n    [CompileErrorCodes.UNBALANCED_CLOSING_BRACE]: `Unbalanced closing brace`,\r\n    [CompileErrorCodes.UNTERMINATED_CLOSING_BRACE]: `Unterminated closing brace`,\r\n    [CompileErrorCodes.EMPTY_PLACEHOLDER]: `Empty placeholder`,\r\n    [CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER]: `Not allowed nest placeholder`,\r\n    [CompileErrorCodes.INVALID_LINKED_FORMAT]: `Invalid linked format`,\r\n    // parser error messages\r\n    [CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL]: `Plural must have messages`,\r\n    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER]: `Unexpected empty linked modifier`,\r\n    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY]: `Unexpected empty linked key`,\r\n    [CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`\r\n};\r\nfunction createCompileError(code, loc, options = {}) {\r\n    const { domain, messages, args } = options;\r\n    const msg = (process.env.NODE_ENV !== 'production')\r\n        ? format((messages || errorMessages)[code] || '', ...(args || []))\r\n        : code;\r\n    const error = new SyntaxError(String(msg));\r\n    error.code = code;\r\n    if (loc) {\r\n        error.location = loc;\r\n    }\r\n    error.domain = domain;\r\n    return error;\r\n}\r\n/** @internal */\r\nfunction defaultOnError(error) {\r\n    throw error;\r\n}\n\nconst LocationStub = {\r\n    start: { line: 1, column: 1, offset: 0 },\r\n    end: { line: 1, column: 1, offset: 0 }\r\n};\r\nfunction createPosition(line, column, offset) {\r\n    return { line, column, offset };\r\n}\r\nfunction createLocation(start, end, source) {\r\n    const loc = { start, end };\r\n    if (source != null) {\r\n        loc.source = source;\r\n    }\r\n    return loc;\r\n}\n\nconst CHAR_SP = ' ';\r\nconst CHAR_CR = '\\r';\r\nconst CHAR_LF = '\\n';\r\nconst CHAR_LS = String.fromCharCode(0x2028);\r\nconst CHAR_PS = String.fromCharCode(0x2029);\r\nfunction createScanner(str) {\r\n    const _buf = str;\r\n    let _index = 0;\r\n    let _line = 1;\r\n    let _column = 1;\r\n    let _peekOffset = 0;\r\n    const isCRLF = (index) => _buf[index] === CHAR_CR && _buf[index + 1] === CHAR_LF;\r\n    const isLF = (index) => _buf[index] === CHAR_LF;\r\n    const isPS = (index) => _buf[index] === CHAR_PS;\r\n    const isLS = (index) => _buf[index] === CHAR_LS;\r\n    const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);\r\n    const index = () => _index;\r\n    const line = () => _line;\r\n    const column = () => _column;\r\n    const peekOffset = () => _peekOffset;\r\n    const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];\r\n    const currentChar = () => charAt(_index);\r\n    const currentPeek = () => charAt(_index + _peekOffset);\r\n    function next() {\r\n        _peekOffset = 0;\r\n        if (isLineEnd(_index)) {\r\n            _line++;\r\n            _column = 0;\r\n        }\r\n        if (isCRLF(_index)) {\r\n            _index++;\r\n        }\r\n        _index++;\r\n        _column++;\r\n        return _buf[_index];\r\n    }\r\n    function peek() {\r\n        if (isCRLF(_index + _peekOffset)) {\r\n            _peekOffset++;\r\n        }\r\n        _peekOffset++;\r\n        return _buf[_index + _peekOffset];\r\n    }\r\n    function reset() {\r\n        _index = 0;\r\n        _line = 1;\r\n        _column = 1;\r\n        _peekOffset = 0;\r\n    }\r\n    function resetPeek(offset = 0) {\r\n        _peekOffset = offset;\r\n    }\r\n    function skipToPeek() {\r\n        const target = _index + _peekOffset;\r\n        // eslint-disable-next-line no-unmodified-loop-condition\r\n        while (target !== _index) {\r\n            next();\r\n        }\r\n        _peekOffset = 0;\r\n    }\r\n    return {\r\n        index,\r\n        line,\r\n        column,\r\n        peekOffset,\r\n        charAt,\r\n        currentChar,\r\n        currentPeek,\r\n        next,\r\n        peek,\r\n        reset,\r\n        resetPeek,\r\n        skipToPeek\r\n    };\r\n}\n\nconst EOF = undefined;\r\nconst LITERAL_DELIMITER = \"'\";\r\nconst ERROR_DOMAIN$1 = 'tokenizer';\r\nfunction createTokenizer(source, options = {}) {\r\n    const location = options.location !== false;\r\n    const _scnr = createScanner(source);\r\n    const currentOffset = () => _scnr.index();\r\n    const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());\r\n    const _initLoc = currentPosition();\r\n    const _initOffset = currentOffset();\r\n    const _context = {\r\n        currentType: 14 /* EOF */,\r\n        offset: _initOffset,\r\n        startLoc: _initLoc,\r\n        endLoc: _initLoc,\r\n        lastType: 14 /* EOF */,\r\n        lastOffset: _initOffset,\r\n        lastStartLoc: _initLoc,\r\n        lastEndLoc: _initLoc,\r\n        braceNest: 0,\r\n        inLinked: false,\r\n        text: ''\r\n    };\r\n    const context = () => _context;\r\n    const { onError } = options;\r\n    function emitError(code, pos, offset, ...args) {\r\n        const ctx = context();\r\n        pos.column += offset;\r\n        pos.offset += offset;\r\n        if (onError) {\r\n            const loc = createLocation(ctx.startLoc, pos);\r\n            const err = createCompileError(code, loc, {\r\n                domain: ERROR_DOMAIN$1,\r\n                args\r\n            });\r\n            onError(err);\r\n        }\r\n    }\r\n    function getToken(context, type, value) {\r\n        context.endLoc = currentPosition();\r\n        context.currentType = type;\r\n        const token = { type };\r\n        if (location) {\r\n            token.loc = createLocation(context.startLoc, context.endLoc);\r\n        }\r\n        if (value != null) {\r\n            token.value = value;\r\n        }\r\n        return token;\r\n    }\r\n    const getEndToken = (context) => getToken(context, 14 /* EOF */);\r\n    function eat(scnr, ch) {\r\n        if (scnr.currentChar() === ch) {\r\n            scnr.next();\r\n            return ch;\r\n        }\r\n        else {\r\n            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);\r\n            return '';\r\n        }\r\n    }\r\n    function peekSpaces(scnr) {\r\n        let buf = '';\r\n        while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {\r\n            buf += scnr.currentPeek();\r\n            scnr.peek();\r\n        }\r\n        return buf;\r\n    }\r\n    function skipSpaces(scnr) {\r\n        const buf = peekSpaces(scnr);\r\n        scnr.skipToPeek();\r\n        return buf;\r\n    }\r\n    function isIdentifierStart(ch) {\r\n        if (ch === EOF) {\r\n            return false;\r\n        }\r\n        const cc = ch.charCodeAt(0);\r\n        return ((cc >= 97 && cc <= 122) || // a-z\r\n            (cc >= 65 && cc <= 90) || // A-Z\r\n            cc === 95 // _\r\n        );\r\n    }\r\n    function isNumberStart(ch) {\r\n        if (ch === EOF) {\r\n            return false;\r\n        }\r\n        const cc = ch.charCodeAt(0);\r\n        return cc >= 48 && cc <= 57; // 0-9\r\n    }\r\n    function isNamedIdentifierStart(scnr, context) {\r\n        const { currentType } = context;\r\n        if (currentType !== 2 /* BraceLeft */) {\r\n            return false;\r\n        }\r\n        peekSpaces(scnr);\r\n        const ret = isIdentifierStart(scnr.currentPeek());\r\n        scnr.resetPeek();\r\n        return ret;\r\n    }\r\n    function isListIdentifierStart(scnr, context) {\r\n        const { currentType } = context;\r\n        if (currentType !== 2 /* BraceLeft */) {\r\n            return false;\r\n        }\r\n        peekSpaces(scnr);\r\n        const ch = scnr.currentPeek() === '-' ? scnr.peek() : scnr.currentPeek();\r\n        const ret = isNumberStart(ch);\r\n        scnr.resetPeek();\r\n        return ret;\r\n    }\r\n    function isLiteralStart(scnr, context) {\r\n        const { currentType } = context;\r\n        if (currentType !== 2 /* BraceLeft */) {\r\n            return false;\r\n        }\r\n        peekSpaces(scnr);\r\n        const ret = scnr.currentPeek() === LITERAL_DELIMITER;\r\n        scnr.resetPeek();\r\n        return ret;\r\n    }\r\n    function isLinkedDotStart(scnr, context) {\r\n        const { currentType } = context;\r\n        if (currentType !== 8 /* LinkedAlias */) {\r\n            return false;\r\n        }\r\n        peekSpaces(scnr);\r\n        const ret = scnr.currentPeek() === \".\" /* LinkedDot */;\r\n        scnr.resetPeek();\r\n        return ret;\r\n    }\r\n    function isLinkedModifierStart(scnr, context) {\r\n        const { currentType } = context;\r\n        if (currentType !== 9 /* LinkedDot */) {\r\n            return false;\r\n        }\r\n        peekSpaces(scnr);\r\n        const ret = isIdentifierStart(scnr.currentPeek());\r\n        scnr.resetPeek();\r\n        return ret;\r\n    }\r\n    function isLinkedDelimiterStart(scnr, context) {\r\n        const { currentType } = context;\r\n        if (!(currentType === 8 /* LinkedAlias */ ||\r\n            currentType === 12 /* LinkedModifier */)) {\r\n            return false;\r\n        }\r\n        peekSpaces(scnr);\r\n        const ret = scnr.currentPeek() === \":\" /* LinkedDelimiter */;\r\n        scnr.resetPeek();\r\n        return ret;\r\n    }\r\n    function isLinkedReferStart(scnr, context) {\r\n        const { currentType } = context;\r\n        if (currentType !== 10 /* LinkedDelimiter */) {\r\n            return false;\r\n        }\r\n        const fn = () => {\r\n            const ch = scnr.currentPeek();\r\n            if (ch === \"{\" /* BraceLeft */) {\r\n                return isIdentifierStart(scnr.peek());\r\n            }\r\n            else if (ch === \"@\" /* LinkedAlias */ ||\r\n                ch === \"%\" /* Modulo */ ||\r\n                ch === \"|\" /* Pipe */ ||\r\n                ch === \":\" /* LinkedDelimiter */ ||\r\n                ch === \".\" /* LinkedDot */ ||\r\n                ch === CHAR_SP ||\r\n                !ch) {\r\n                return false;\r\n            }\r\n            else if (ch === CHAR_LF) {\r\n                scnr.peek();\r\n                return fn();\r\n            }\r\n            else {\r\n                // other characters\r\n                return isIdentifierStart(ch);\r\n            }\r\n        };\r\n        const ret = fn();\r\n        scnr.resetPeek();\r\n        return ret;\r\n    }\r\n    function isPluralStart(scnr) {\r\n        peekSpaces(scnr);\r\n        const ret = scnr.currentPeek() === \"|\" /* Pipe */;\r\n        scnr.resetPeek();\r\n        return ret;\r\n    }\r\n    function isTextStart(scnr, reset = true) {\r\n        const fn = (hasSpace = false, prev = '', detectModulo = false) => {\r\n            const ch = scnr.currentPeek();\r\n            if (ch === \"{\" /* BraceLeft */) {\r\n                return prev === \"%\" /* Modulo */ ? false : hasSpace;\r\n            }\r\n            else if (ch === \"@\" /* LinkedAlias */ || !ch) {\r\n                return prev === \"%\" /* Modulo */ ? true : hasSpace;\r\n            }\r\n            else if (ch === \"%\" /* Modulo */) {\r\n                scnr.peek();\r\n                return fn(hasSpace, \"%\" /* Modulo */, true);\r\n            }\r\n            else if (ch === \"|\" /* Pipe */) {\r\n                return prev === \"%\" /* Modulo */ || detectModulo\r\n                    ? true\r\n                    : !(prev === CHAR_SP || prev === CHAR_LF);\r\n            }\r\n            else if (ch === CHAR_SP) {\r\n                scnr.peek();\r\n                return fn(true, CHAR_SP, detectModulo);\r\n            }\r\n            else if (ch === CHAR_LF) {\r\n                scnr.peek();\r\n                return fn(true, CHAR_LF, detectModulo);\r\n            }\r\n            else {\r\n                return true;\r\n            }\r\n        };\r\n        const ret = fn();\r\n        reset && scnr.resetPeek();\r\n        return ret;\r\n    }\r\n    function takeChar(scnr, fn) {\r\n        const ch = scnr.currentChar();\r\n        if (ch === EOF) {\r\n            return EOF;\r\n        }\r\n        if (fn(ch)) {\r\n            scnr.next();\r\n            return ch;\r\n        }\r\n        return null;\r\n    }\r\n    function takeIdentifierChar(scnr) {\r\n        const closure = (ch) => {\r\n            const cc = ch.charCodeAt(0);\r\n            return ((cc >= 97 && cc <= 122) || // a-z\r\n                (cc >= 65 && cc <= 90) || // A-Z\r\n                (cc >= 48 && cc <= 57) || // 0-9\r\n                cc === 95 || // _\r\n                cc === 36 // $\r\n            );\r\n        };\r\n        return takeChar(scnr, closure);\r\n    }\r\n    function takeDigit(scnr) {\r\n        const closure = (ch) => {\r\n            const cc = ch.charCodeAt(0);\r\n            return cc >= 48 && cc <= 57; // 0-9\r\n        };\r\n        return takeChar(scnr, closure);\r\n    }\r\n    function takeHexDigit(scnr) {\r\n        const closure = (ch) => {\r\n            const cc = ch.charCodeAt(0);\r\n            return ((cc >= 48 && cc <= 57) || // 0-9\r\n                (cc >= 65 && cc <= 70) || // A-F\r\n                (cc >= 97 && cc <= 102)); // a-f\r\n        };\r\n        return takeChar(scnr, closure);\r\n    }\r\n    function getDigits(scnr) {\r\n        let ch = '';\r\n        let num = '';\r\n        while ((ch = takeDigit(scnr))) {\r\n            num += ch;\r\n        }\r\n        return num;\r\n    }\r\n    function readText(scnr) {\r\n        let buf = '';\r\n        while (true) {\r\n            const ch = scnr.currentChar();\r\n            if (ch === \"{\" /* BraceLeft */ ||\r\n                ch === \"}\" /* BraceRight */ ||\r\n                ch === \"@\" /* LinkedAlias */ ||\r\n                ch === \"|\" /* Pipe */ ||\r\n                !ch) {\r\n                break;\r\n            }\r\n            else if (ch === \"%\" /* Modulo */) {\r\n                if (isTextStart(scnr)) {\r\n                    buf += ch;\r\n                    scnr.next();\r\n                }\r\n                else {\r\n                    break;\r\n                }\r\n            }\r\n            else if (ch === CHAR_SP || ch === CHAR_LF) {\r\n                if (isTextStart(scnr)) {\r\n                    buf += ch;\r\n                    scnr.next();\r\n                }\r\n                else if (isPluralStart(scnr)) {\r\n                    break;\r\n                }\r\n                else {\r\n                    buf += ch;\r\n                    scnr.next();\r\n                }\r\n            }\r\n            else {\r\n                buf += ch;\r\n                scnr.next();\r\n            }\r\n        }\r\n        return buf;\r\n    }\r\n    function readNamedIdentifier(scnr) {\r\n        skipSpaces(scnr);\r\n        let ch = '';\r\n        let name = '';\r\n        while ((ch = takeIdentifierChar(scnr))) {\r\n            name += ch;\r\n        }\r\n        if (scnr.currentChar() === EOF) {\r\n            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);\r\n        }\r\n        return name;\r\n    }\r\n    function readListIdentifier(scnr) {\r\n        skipSpaces(scnr);\r\n        let value = '';\r\n        if (scnr.currentChar() === '-') {\r\n            scnr.next();\r\n            value += `-${getDigits(scnr)}`;\r\n        }\r\n        else {\r\n            value += getDigits(scnr);\r\n        }\r\n        if (scnr.currentChar() === EOF) {\r\n            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);\r\n        }\r\n        return value;\r\n    }\r\n    function readLiteral(scnr) {\r\n        skipSpaces(scnr);\r\n        eat(scnr, `\\'`);\r\n        let ch = '';\r\n        let literal = '';\r\n        const fn = (x) => x !== LITERAL_DELIMITER && x !== CHAR_LF;\r\n        while ((ch = takeChar(scnr, fn))) {\r\n            if (ch === '\\\\') {\r\n                literal += readEscapeSequence(scnr);\r\n            }\r\n            else {\r\n                literal += ch;\r\n            }\r\n        }\r\n        const current = scnr.currentChar();\r\n        if (current === CHAR_LF || current === EOF) {\r\n            emitError(CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER, currentPosition(), 0);\r\n            // TODO: Is it correct really?\r\n            if (current === CHAR_LF) {\r\n                scnr.next();\r\n                eat(scnr, `\\'`);\r\n            }\r\n            return literal;\r\n        }\r\n        eat(scnr, `\\'`);\r\n        return literal;\r\n    }\r\n    function readEscapeSequence(scnr) {\r\n        const ch = scnr.currentChar();\r\n        switch (ch) {\r\n            case '\\\\':\r\n            case `\\'`:\r\n                scnr.next();\r\n                return `\\\\${ch}`;\r\n            case 'u':\r\n                return readUnicodeEscapeSequence(scnr, ch, 4);\r\n            case 'U':\r\n                return readUnicodeEscapeSequence(scnr, ch, 6);\r\n            default:\r\n                emitError(CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE, currentPosition(), 0, ch);\r\n                return '';\r\n        }\r\n    }\r\n    function readUnicodeEscapeSequence(scnr, unicode, digits) {\r\n        eat(scnr, unicode);\r\n        let sequence = '';\r\n        for (let i = 0; i < digits; i++) {\r\n            const ch = takeHexDigit(scnr);\r\n            if (!ch) {\r\n                emitError(CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE, currentPosition(), 0, `\\\\${unicode}${sequence}${scnr.currentChar()}`);\r\n                break;\r\n            }\r\n            sequence += ch;\r\n        }\r\n        return `\\\\${unicode}${sequence}`;\r\n    }\r\n    function readInvalidIdentifier(scnr) {\r\n        skipSpaces(scnr);\r\n        let ch = '';\r\n        let identifiers = '';\r\n        const closure = (ch) => ch !== \"{\" /* BraceLeft */ &&\r\n            ch !== \"}\" /* BraceRight */ &&\r\n            ch !== CHAR_SP &&\r\n            ch !== CHAR_LF;\r\n        while ((ch = takeChar(scnr, closure))) {\r\n            identifiers += ch;\r\n        }\r\n        return identifiers;\r\n    }\r\n    function readLinkedModifier(scnr) {\r\n        let ch = '';\r\n        let name = '';\r\n        while ((ch = takeIdentifierChar(scnr))) {\r\n            name += ch;\r\n        }\r\n        return name;\r\n    }\r\n    function readLinkedRefer(scnr) {\r\n        const fn = (detect = false, buf) => {\r\n            const ch = scnr.currentChar();\r\n            if (ch === \"{\" /* BraceLeft */ ||\r\n                ch === \"%\" /* Modulo */ ||\r\n                ch === \"@\" /* LinkedAlias */ ||\r\n                ch === \"|\" /* Pipe */ ||\r\n                !ch) {\r\n                return buf;\r\n            }\r\n            else if (ch === CHAR_SP) {\r\n                return buf;\r\n            }\r\n            else if (ch === CHAR_LF) {\r\n                buf += ch;\r\n                scnr.next();\r\n                return fn(detect, buf);\r\n            }\r\n            else {\r\n                buf += ch;\r\n                scnr.next();\r\n                return fn(true, buf);\r\n            }\r\n        };\r\n        return fn(false, '');\r\n    }\r\n    function readPlural(scnr) {\r\n        skipSpaces(scnr);\r\n        const plural = eat(scnr, \"|\" /* Pipe */);\r\n        skipSpaces(scnr);\r\n        return plural;\r\n    }\r\n    // TODO: We need refactoring of token parsing ...\r\n    function readTokenInPlaceholder(scnr, context) {\r\n        let token = null;\r\n        const ch = scnr.currentChar();\r\n        switch (ch) {\r\n            case \"{\" /* BraceLeft */:\r\n                if (context.braceNest >= 1) {\r\n                    emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);\r\n                }\r\n                scnr.next();\r\n                token = getToken(context, 2 /* BraceLeft */, \"{\" /* BraceLeft */);\r\n                skipSpaces(scnr);\r\n                context.braceNest++;\r\n                return token;\r\n            case \"}\" /* BraceRight */:\r\n                if (context.braceNest > 0 &&\r\n                    context.currentType === 2 /* BraceLeft */) {\r\n                    emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);\r\n                }\r\n                scnr.next();\r\n                token = getToken(context, 3 /* BraceRight */, \"}\" /* BraceRight */);\r\n                context.braceNest--;\r\n                context.braceNest > 0 && skipSpaces(scnr);\r\n                if (context.inLinked && context.braceNest === 0) {\r\n                    context.inLinked = false;\r\n                }\r\n                return token;\r\n            case \"@\" /* LinkedAlias */:\r\n                if (context.braceNest > 0) {\r\n                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);\r\n                }\r\n                token = readTokenInLinked(scnr, context) || getEndToken(context);\r\n                context.braceNest = 0;\r\n                return token;\r\n            default:\r\n                let validNamedIdentifier = true;\r\n                let validListIdentifier = true;\r\n                let validLiteral = true;\r\n                if (isPluralStart(scnr)) {\r\n                    if (context.braceNest > 0) {\r\n                        emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);\r\n                    }\r\n                    token = getToken(context, 1 /* Pipe */, readPlural(scnr));\r\n                    // reset\r\n                    context.braceNest = 0;\r\n                    context.inLinked = false;\r\n                    return token;\r\n                }\r\n                if (context.braceNest > 0 &&\r\n                    (context.currentType === 5 /* Named */ ||\r\n                        context.currentType === 6 /* List */ ||\r\n                        context.currentType === 7 /* Literal */)) {\r\n                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);\r\n                    context.braceNest = 0;\r\n                    return readToken(scnr, context);\r\n                }\r\n                if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {\r\n                    token = getToken(context, 5 /* Named */, readNamedIdentifier(scnr));\r\n                    skipSpaces(scnr);\r\n                    return token;\r\n                }\r\n                if ((validListIdentifier = isListIdentifierStart(scnr, context))) {\r\n                    token = getToken(context, 6 /* List */, readListIdentifier(scnr));\r\n                    skipSpaces(scnr);\r\n                    return token;\r\n                }\r\n                if ((validLiteral = isLiteralStart(scnr, context))) {\r\n                    token = getToken(context, 7 /* Literal */, readLiteral(scnr));\r\n                    skipSpaces(scnr);\r\n                    return token;\r\n                }\r\n                if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {\r\n                    // TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...\r\n                    token = getToken(context, 13 /* InvalidPlace */, readInvalidIdentifier(scnr));\r\n                    emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);\r\n                    skipSpaces(scnr);\r\n                    return token;\r\n                }\r\n                break;\r\n        }\r\n        return token;\r\n    }\r\n    // TODO: We need refactoring of token parsing ...\r\n    function readTokenInLinked(scnr, context) {\r\n        const { currentType } = context;\r\n        let token = null;\r\n        const ch = scnr.currentChar();\r\n        if ((currentType === 8 /* LinkedAlias */ ||\r\n            currentType === 9 /* LinkedDot */ ||\r\n            currentType === 12 /* LinkedModifier */ ||\r\n            currentType === 10 /* LinkedDelimiter */) &&\r\n            (ch === CHAR_LF || ch === CHAR_SP)) {\r\n            emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);\r\n        }\r\n        switch (ch) {\r\n            case \"@\" /* LinkedAlias */:\r\n                scnr.next();\r\n                token = getToken(context, 8 /* LinkedAlias */, \"@\" /* LinkedAlias */);\r\n                context.inLinked = true;\r\n                return token;\r\n            case \".\" /* LinkedDot */:\r\n                skipSpaces(scnr);\r\n                scnr.next();\r\n                return getToken(context, 9 /* LinkedDot */, \".\" /* LinkedDot */);\r\n            case \":\" /* LinkedDelimiter */:\r\n                skipSpaces(scnr);\r\n                scnr.next();\r\n                return getToken(context, 10 /* LinkedDelimiter */, \":\" /* LinkedDelimiter */);\r\n            default:\r\n                if (isPluralStart(scnr)) {\r\n                    token = getToken(context, 1 /* Pipe */, readPlural(scnr));\r\n                    // reset\r\n                    context.braceNest = 0;\r\n                    context.inLinked = false;\r\n                    return token;\r\n                }\r\n                if (isLinkedDotStart(scnr, context) ||\r\n                    isLinkedDelimiterStart(scnr, context)) {\r\n                    skipSpaces(scnr);\r\n                    return readTokenInLinked(scnr, context);\r\n                }\r\n                if (isLinkedModifierStart(scnr, context)) {\r\n                    skipSpaces(scnr);\r\n                    return getToken(context, 12 /* LinkedModifier */, readLinkedModifier(scnr));\r\n                }\r\n                if (isLinkedReferStart(scnr, context)) {\r\n                    skipSpaces(scnr);\r\n                    if (ch === \"{\" /* BraceLeft */) {\r\n                        // scan the placeholder\r\n                        return readTokenInPlaceholder(scnr, context) || token;\r\n                    }\r\n                    else {\r\n                        return getToken(context, 11 /* LinkedKey */, readLinkedRefer(scnr));\r\n                    }\r\n                }\r\n                if (currentType === 8 /* LinkedAlias */) {\r\n                    emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);\r\n                }\r\n                context.braceNest = 0;\r\n                context.inLinked = false;\r\n                return readToken(scnr, context);\r\n        }\r\n    }\r\n    // TODO: We need refactoring of token parsing ...\r\n    function readToken(scnr, context) {\r\n        let token = { type: 14 /* EOF */ };\r\n        if (context.braceNest > 0) {\r\n            return readTokenInPlaceholder(scnr, context) || getEndToken(context);\r\n        }\r\n        if (context.inLinked) {\r\n            return readTokenInLinked(scnr, context) || getEndToken(context);\r\n        }\r\n        const ch = scnr.currentChar();\r\n        switch (ch) {\r\n            case \"{\" /* BraceLeft */:\r\n                return readTokenInPlaceholder(scnr, context) || getEndToken(context);\r\n            case \"}\" /* BraceRight */:\r\n                emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);\r\n                scnr.next();\r\n                return getToken(context, 3 /* BraceRight */, \"}\" /* BraceRight */);\r\n            case \"@\" /* LinkedAlias */:\r\n                return readTokenInLinked(scnr, context) || getEndToken(context);\r\n            default:\r\n                if (isPluralStart(scnr)) {\r\n                    token = getToken(context, 1 /* Pipe */, readPlural(scnr));\r\n                    // reset\r\n                    context.braceNest = 0;\r\n                    context.inLinked = false;\r\n                    return token;\r\n                }\r\n                if (isTextStart(scnr)) {\r\n                    return getToken(context, 0 /* Text */, readText(scnr));\r\n                }\r\n                if (ch === \"%\" /* Modulo */) {\r\n                    scnr.next();\r\n                    return getToken(context, 4 /* Modulo */, \"%\" /* Modulo */);\r\n                }\r\n                break;\r\n        }\r\n        return token;\r\n    }\r\n    function nextToken() {\r\n        const { currentType, offset, startLoc, endLoc } = _context;\r\n        _context.lastType = currentType;\r\n        _context.lastOffset = offset;\r\n        _context.lastStartLoc = startLoc;\r\n        _context.lastEndLoc = endLoc;\r\n        _context.offset = currentOffset();\r\n        _context.startLoc = currentPosition();\r\n        if (_scnr.currentChar() === EOF) {\r\n            return getToken(_context, 14 /* EOF */);\r\n        }\r\n        return readToken(_scnr, _context);\r\n    }\r\n    return {\r\n        nextToken,\r\n        currentOffset,\r\n        currentPosition,\r\n        context\r\n    };\r\n}\n\nconst ERROR_DOMAIN = 'parser';\r\n// Backslash backslash, backslash quote, uHHHH, UHHHHHH.\r\nconst KNOWN_ESCAPES = /(?:\\\\\\\\|\\\\'|\\\\u([0-9a-fA-F]{4})|\\\\U([0-9a-fA-F]{6}))/g;\r\nfunction fromEscapeSequence(match, codePoint4, codePoint6) {\r\n    switch (match) {\r\n        case `\\\\\\\\`:\r\n            return `\\\\`;\r\n        case `\\\\\\'`:\r\n            return `\\'`;\r\n        default: {\r\n            const codePoint = parseInt(codePoint4 || codePoint6, 16);\r\n            if (codePoint <= 0xd7ff || codePoint >= 0xe000) {\r\n                return String.fromCodePoint(codePoint);\r\n            }\r\n            // invalid ...\r\n            // Replace them with U+FFFD REPLACEMENT CHARACTER.\r\n            return '�';\r\n        }\r\n    }\r\n}\r\nfunction createParser(options = {}) {\r\n    const location = options.location !== false;\r\n    const { onError } = options;\r\n    function emitError(tokenzer, code, start, offset, ...args) {\r\n        const end = tokenzer.currentPosition();\r\n        end.offset += offset;\r\n        end.column += offset;\r\n        if (onError) {\r\n            const loc = createLocation(start, end);\r\n            const err = createCompileError(code, loc, {\r\n                domain: ERROR_DOMAIN,\r\n                args\r\n            });\r\n            onError(err);\r\n        }\r\n    }\r\n    function startNode(type, offset, loc) {\r\n        const node = {\r\n            type,\r\n            start: offset,\r\n            end: offset\r\n        };\r\n        if (location) {\r\n            node.loc = { start: loc, end: loc };\r\n        }\r\n        return node;\r\n    }\r\n    function endNode(node, offset, pos, type) {\r\n        node.end = offset;\r\n        if (type) {\r\n            node.type = type;\r\n        }\r\n        if (location && node.loc) {\r\n            node.loc.end = pos;\r\n        }\r\n    }\r\n    function parseText(tokenizer, value) {\r\n        const context = tokenizer.context();\r\n        const node = startNode(3 /* Text */, context.offset, context.startLoc);\r\n        node.value = value;\r\n        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());\r\n        return node;\r\n    }\r\n    function parseList(tokenizer, index) {\r\n        const context = tokenizer.context();\r\n        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc\r\n        const node = startNode(5 /* List */, offset, loc);\r\n        node.index = parseInt(index, 10);\r\n        tokenizer.nextToken(); // skip brach right\r\n        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());\r\n        return node;\r\n    }\r\n    function parseNamed(tokenizer, key) {\r\n        const context = tokenizer.context();\r\n        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc\r\n        const node = startNode(4 /* Named */, offset, loc);\r\n        node.key = key;\r\n        tokenizer.nextToken(); // skip brach right\r\n        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());\r\n        return node;\r\n    }\r\n    function parseLiteral(tokenizer, value) {\r\n        const context = tokenizer.context();\r\n        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc\r\n        const node = startNode(9 /* Literal */, offset, loc);\r\n        node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);\r\n        tokenizer.nextToken(); // skip brach right\r\n        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());\r\n        return node;\r\n    }\r\n    function parseLinkedModifier(tokenizer) {\r\n        const token = tokenizer.nextToken();\r\n        const context = tokenizer.context();\r\n        const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc\r\n        const node = startNode(8 /* LinkedModifier */, offset, loc);\r\n        if (token.type !== 12 /* LinkedModifier */) {\r\n            // empty modifier\r\n            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);\r\n            node.value = '';\r\n            endNode(node, offset, loc);\r\n            return {\r\n                nextConsumeToken: token,\r\n                node\r\n            };\r\n        }\r\n        // check token\r\n        if (token.value == null) {\r\n            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));\r\n        }\r\n        node.value = token.value || '';\r\n        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());\r\n        return {\r\n            node\r\n        };\r\n    }\r\n    function parseLinkedKey(tokenizer, value) {\r\n        const context = tokenizer.context();\r\n        const node = startNode(7 /* LinkedKey */, context.offset, context.startLoc);\r\n        node.value = value;\r\n        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());\r\n        return node;\r\n    }\r\n    function parseLinked(tokenizer) {\r\n        const context = tokenizer.context();\r\n        const linkedNode = startNode(6 /* Linked */, context.offset, context.startLoc);\r\n        let token = tokenizer.nextToken();\r\n        if (token.type === 9 /* LinkedDot */) {\r\n            const parsed = parseLinkedModifier(tokenizer);\r\n            linkedNode.modifier = parsed.node;\r\n            token = parsed.nextConsumeToken || tokenizer.nextToken();\r\n        }\r\n        // asset check token\r\n        if (token.type !== 10 /* LinkedDelimiter */) {\r\n            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));\r\n        }\r\n        token = tokenizer.nextToken();\r\n        // skip brace left\r\n        if (token.type === 2 /* BraceLeft */) {\r\n            token = tokenizer.nextToken();\r\n        }\r\n        switch (token.type) {\r\n            case 11 /* LinkedKey */:\r\n                if (token.value == null) {\r\n                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));\r\n                }\r\n                linkedNode.key = parseLinkedKey(tokenizer, token.value || '');\r\n                break;\r\n            case 5 /* Named */:\r\n                if (token.value == null) {\r\n                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));\r\n                }\r\n                linkedNode.key = parseNamed(tokenizer, token.value || '');\r\n                break;\r\n            case 6 /* List */:\r\n                if (token.value == null) {\r\n                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));\r\n                }\r\n                linkedNode.key = parseList(tokenizer, token.value || '');\r\n                break;\r\n            case 7 /* Literal */:\r\n                if (token.value == null) {\r\n                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));\r\n                }\r\n                linkedNode.key = parseLiteral(tokenizer, token.value || '');\r\n                break;\r\n            default:\r\n                // empty key\r\n                emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);\r\n                const nextContext = tokenizer.context();\r\n                const emptyLinkedKeyNode = startNode(7 /* LinkedKey */, nextContext.offset, nextContext.startLoc);\r\n                emptyLinkedKeyNode.value = '';\r\n                endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);\r\n                linkedNode.key = emptyLinkedKeyNode;\r\n                endNode(linkedNode, nextContext.offset, nextContext.startLoc);\r\n                return {\r\n                    nextConsumeToken: token,\r\n                    node: linkedNode\r\n                };\r\n        }\r\n        endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());\r\n        return {\r\n            node: linkedNode\r\n        };\r\n    }\r\n    function parseMessage(tokenizer) {\r\n        const context = tokenizer.context();\r\n        const startOffset = context.currentType === 1 /* Pipe */\r\n            ? tokenizer.currentOffset()\r\n            : context.offset;\r\n        const startLoc = context.currentType === 1 /* Pipe */\r\n            ? context.endLoc\r\n            : context.startLoc;\r\n        const node = startNode(2 /* Message */, startOffset, startLoc);\r\n        node.items = [];\r\n        let nextToken = null;\r\n        do {\r\n            const token = nextToken || tokenizer.nextToken();\r\n            nextToken = null;\r\n            switch (token.type) {\r\n                case 0 /* Text */:\r\n                    if (token.value == null) {\r\n                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));\r\n                    }\r\n                    node.items.push(parseText(tokenizer, token.value || ''));\r\n                    break;\r\n                case 6 /* List */:\r\n                    if (token.value == null) {\r\n                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));\r\n                    }\r\n                    node.items.push(parseList(tokenizer, token.value || ''));\r\n                    break;\r\n                case 5 /* Named */:\r\n                    if (token.value == null) {\r\n                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));\r\n                    }\r\n                    node.items.push(parseNamed(tokenizer, token.value || ''));\r\n                    break;\r\n                case 7 /* Literal */:\r\n                    if (token.value == null) {\r\n                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));\r\n                    }\r\n                    node.items.push(parseLiteral(tokenizer, token.value || ''));\r\n                    break;\r\n                case 8 /* LinkedAlias */:\r\n                    const parsed = parseLinked(tokenizer);\r\n                    node.items.push(parsed.node);\r\n                    nextToken = parsed.nextConsumeToken || null;\r\n                    break;\r\n            }\r\n        } while (context.currentType !== 14 /* EOF */ &&\r\n            context.currentType !== 1 /* Pipe */);\r\n        // adjust message node loc\r\n        const endOffset = context.currentType === 1 /* Pipe */\r\n            ? context.lastOffset\r\n            : tokenizer.currentOffset();\r\n        const endLoc = context.currentType === 1 /* Pipe */\r\n            ? context.lastEndLoc\r\n            : tokenizer.currentPosition();\r\n        endNode(node, endOffset, endLoc);\r\n        return node;\r\n    }\r\n    function parsePlural(tokenizer, offset, loc, msgNode) {\r\n        const context = tokenizer.context();\r\n        let hasEmptyMessage = msgNode.items.length === 0;\r\n        const node = startNode(1 /* Plural */, offset, loc);\r\n        node.cases = [];\r\n        node.cases.push(msgNode);\r\n        do {\r\n            const msg = parseMessage(tokenizer);\r\n            if (!hasEmptyMessage) {\r\n                hasEmptyMessage = msg.items.length === 0;\r\n            }\r\n            node.cases.push(msg);\r\n        } while (context.currentType !== 14 /* EOF */);\r\n        if (hasEmptyMessage) {\r\n            emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);\r\n        }\r\n        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());\r\n        return node;\r\n    }\r\n    function parseResource(tokenizer) {\r\n        const context = tokenizer.context();\r\n        const { offset, startLoc } = context;\r\n        const msgNode = parseMessage(tokenizer);\r\n        if (context.currentType === 14 /* EOF */) {\r\n            return msgNode;\r\n        }\r\n        else {\r\n            return parsePlural(tokenizer, offset, startLoc, msgNode);\r\n        }\r\n    }\r\n    function parse(source) {\r\n        const tokenizer = createTokenizer(source, assign({}, options));\r\n        const context = tokenizer.context();\r\n        const node = startNode(0 /* Resource */, context.offset, context.startLoc);\r\n        if (location && node.loc) {\r\n            node.loc.source = source;\r\n        }\r\n        node.body = parseResource(tokenizer);\r\n        // assert whether achieved to EOF\r\n        if (context.currentType !== 14 /* EOF */) {\r\n            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');\r\n        }\r\n        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());\r\n        return node;\r\n    }\r\n    return { parse };\r\n}\r\nfunction getTokenCaption(token) {\r\n    if (token.type === 14 /* EOF */) {\r\n        return 'EOF';\r\n    }\r\n    const name = (token.value || '').replace(/\\r?\\n/gu, '\\\\n');\r\n    return name.length > 10 ? name.slice(0, 9) + '…' : name;\r\n}\n\nfunction createTransformer(ast, options = {} // eslint-disable-line\r\n) {\r\n    const _context = {\r\n        ast,\r\n        helpers: new Set()\r\n    };\r\n    const context = () => _context;\r\n    const helper = (name) => {\r\n        _context.helpers.add(name);\r\n        return name;\r\n    };\r\n    return { context, helper };\r\n}\r\nfunction traverseNodes(nodes, transformer) {\r\n    for (let i = 0; i < nodes.length; i++) {\r\n        traverseNode(nodes[i], transformer);\r\n    }\r\n}\r\nfunction traverseNode(node, transformer) {\r\n    // TODO: if we need pre-hook of transform, should be implemented to here\r\n    switch (node.type) {\r\n        case 1 /* Plural */:\r\n            traverseNodes(node.cases, transformer);\r\n            transformer.helper(\"plural\" /* PLURAL */);\r\n            break;\r\n        case 2 /* Message */:\r\n            traverseNodes(node.items, transformer);\r\n            break;\r\n        case 6 /* Linked */:\r\n            const linked = node;\r\n            traverseNode(linked.key, transformer);\r\n            transformer.helper(\"linked\" /* LINKED */);\r\n            break;\r\n        case 5 /* List */:\r\n            transformer.helper(\"interpolate\" /* INTERPOLATE */);\r\n            transformer.helper(\"list\" /* LIST */);\r\n            break;\r\n        case 4 /* Named */:\r\n            transformer.helper(\"interpolate\" /* INTERPOLATE */);\r\n            transformer.helper(\"named\" /* NAMED */);\r\n            break;\r\n    }\r\n    // TODO: if we need post-hook of transform, should be implemented to here\r\n}\r\n// transform AST\r\nfunction transform(ast, options = {} // eslint-disable-line\r\n) {\r\n    const transformer = createTransformer(ast);\r\n    transformer.helper(\"normalize\" /* NORMALIZE */);\r\n    // traverse\r\n    ast.body && traverseNode(ast.body, transformer);\r\n    // set meta information\r\n    const context = transformer.context();\r\n    ast.helpers = Array.from(context.helpers);\r\n}\n\nfunction createCodeGenerator(ast, options) {\r\n    const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;\r\n    const _context = {\r\n        source: ast.loc.source,\r\n        filename,\r\n        code: '',\r\n        column: 1,\r\n        line: 1,\r\n        offset: 0,\r\n        map: undefined,\r\n        breakLineCode,\r\n        needIndent: _needIndent,\r\n        indentLevel: 0\r\n    };\r\n    const context = () => _context;\r\n    function push(code, node) {\r\n        _context.code += code;\r\n    }\r\n    function _newline(n, withBreakLine = true) {\r\n        const _breakLineCode = withBreakLine ? breakLineCode : '';\r\n        push(_needIndent ? _breakLineCode + `  `.repeat(n) : _breakLineCode);\r\n    }\r\n    function indent(withNewLine = true) {\r\n        const level = ++_context.indentLevel;\r\n        withNewLine && _newline(level);\r\n    }\r\n    function deindent(withNewLine = true) {\r\n        const level = --_context.indentLevel;\r\n        withNewLine && _newline(level);\r\n    }\r\n    function newline() {\r\n        _newline(_context.indentLevel);\r\n    }\r\n    const helper = (key) => `_${key}`;\r\n    const needIndent = () => _context.needIndent;\r\n    return {\r\n        context,\r\n        push,\r\n        indent,\r\n        deindent,\r\n        newline,\r\n        helper,\r\n        needIndent\r\n    };\r\n}\r\nfunction generateLinkedNode(generator, node) {\r\n    const { helper } = generator;\r\n    generator.push(`${helper(\"linked\" /* LINKED */)}(`);\r\n    generateNode(generator, node.key);\r\n    if (node.modifier) {\r\n        generator.push(`, `);\r\n        generateNode(generator, node.modifier);\r\n    }\r\n    generator.push(`)`);\r\n}\r\nfunction generateMessageNode(generator, node) {\r\n    const { helper, needIndent } = generator;\r\n    generator.push(`${helper(\"normalize\" /* NORMALIZE */)}([`);\r\n    generator.indent(needIndent());\r\n    const length = node.items.length;\r\n    for (let i = 0; i < length; i++) {\r\n        generateNode(generator, node.items[i]);\r\n        if (i === length - 1) {\r\n            break;\r\n        }\r\n        generator.push(', ');\r\n    }\r\n    generator.deindent(needIndent());\r\n    generator.push('])');\r\n}\r\nfunction generatePluralNode(generator, node) {\r\n    const { helper, needIndent } = generator;\r\n    if (node.cases.length > 1) {\r\n        generator.push(`${helper(\"plural\" /* PLURAL */)}([`);\r\n        generator.indent(needIndent());\r\n        const length = node.cases.length;\r\n        for (let i = 0; i < length; i++) {\r\n            generateNode(generator, node.cases[i]);\r\n            if (i === length - 1) {\r\n                break;\r\n            }\r\n            generator.push(', ');\r\n        }\r\n        generator.deindent(needIndent());\r\n        generator.push(`])`);\r\n    }\r\n}\r\nfunction generateResource(generator, node) {\r\n    if (node.body) {\r\n        generateNode(generator, node.body);\r\n    }\r\n    else {\r\n        generator.push('null');\r\n    }\r\n}\r\nfunction generateNode(generator, node) {\r\n    const { helper } = generator;\r\n    switch (node.type) {\r\n        case 0 /* Resource */:\r\n            generateResource(generator, node);\r\n            break;\r\n        case 1 /* Plural */:\r\n            generatePluralNode(generator, node);\r\n            break;\r\n        case 2 /* Message */:\r\n            generateMessageNode(generator, node);\r\n            break;\r\n        case 6 /* Linked */:\r\n            generateLinkedNode(generator, node);\r\n            break;\r\n        case 8 /* LinkedModifier */:\r\n            generator.push(JSON.stringify(node.value), node);\r\n            break;\r\n        case 7 /* LinkedKey */:\r\n            generator.push(JSON.stringify(node.value), node);\r\n            break;\r\n        case 5 /* List */:\r\n            generator.push(`${helper(\"interpolate\" /* INTERPOLATE */)}(${helper(\"list\" /* LIST */)}(${node.index}))`, node);\r\n            break;\r\n        case 4 /* Named */:\r\n            generator.push(`${helper(\"interpolate\" /* INTERPOLATE */)}(${helper(\"named\" /* NAMED */)}(${JSON.stringify(node.key)}))`, node);\r\n            break;\r\n        case 9 /* Literal */:\r\n            generator.push(JSON.stringify(node.value), node);\r\n            break;\r\n        case 3 /* Text */:\r\n            generator.push(JSON.stringify(node.value), node);\r\n            break;\r\n        default:\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                throw new Error(`unhandled codegen node type: ${node.type}`);\r\n            }\r\n    }\r\n}\r\n// generate code from AST\r\nconst generate = (ast, options = {} // eslint-disable-line\r\n) => {\r\n    const mode = isString(options.mode) ? options.mode : 'normal';\r\n    const filename = isString(options.filename)\r\n        ? options.filename\r\n        : 'message.intl';\r\n    const sourceMap = !!options.sourceMap;\r\n    // prettier-ignore\r\n    const breakLineCode = options.breakLineCode != null\r\n        ? options.breakLineCode\r\n        : mode === 'arrow'\r\n            ? ';'\r\n            : '\\n';\r\n    const needIndent = options.needIndent ? options.needIndent : mode !== 'arrow';\r\n    const helpers = ast.helpers || [];\r\n    const generator = createCodeGenerator(ast, {\r\n        mode,\r\n        filename,\r\n        sourceMap,\r\n        breakLineCode,\r\n        needIndent\r\n    });\r\n    generator.push(mode === 'normal' ? `function __msg__ (ctx) {` : `(ctx) => {`);\r\n    generator.indent(needIndent);\r\n    if (helpers.length > 0) {\r\n        generator.push(`const { ${helpers.map(s => `${s}: _${s}`).join(', ')} } = ctx`);\r\n        generator.newline();\r\n    }\r\n    generator.push(`return `);\r\n    generateNode(generator, ast);\r\n    generator.deindent(needIndent);\r\n    generator.push(`}`);\r\n    const { code, map } = generator.context();\r\n    return {\r\n        ast,\r\n        code,\r\n        map: map ? map.toJSON() : undefined // eslint-disable-line @typescript-eslint/no-explicit-any\r\n    };\r\n};\n\nfunction baseCompile(source, options = {}) {\r\n    const assignedOptions = assign({}, options);\r\n    // parse source codes\r\n    const parser = createParser(assignedOptions);\r\n    const ast = parser.parse(source);\r\n    // transform ASTs\r\n    transform(ast, assignedOptions);\r\n    // generate javascript codes\r\n    return generate(ast, assignedOptions);\r\n}\n\nexport { CompileErrorCodes, ERROR_DOMAIN, LocationStub, baseCompile, createCompileError, createLocation, createParser, createPosition, defaultOnError, errorMessages };\n","/*!\n  * devtools-if v9.2.0-beta.35\n  * (c) 2022 kazuya kawaguchi\n  * Released under the MIT License.\n  */\nconst IntlifyDevToolsHooks =  {\r\n    I18nInit: 'i18n:init',\r\n    FunctionTranslate: 'function:translate'\r\n};\n\nexport { IntlifyDevToolsHooks };\n","/*!\n  * core-base v9.2.0-beta.35\n  * (c) 2022 kazuya kawaguchi\n  * Released under the MIT License.\n  */\nimport { isObject, isNumber, isString, isFunction, isPlainObject, toDisplayString, format, isArray, isBoolean, assign, isRegExp, warn, escapeHtml, inBrowser, mark, measure, generateCodeFrame, generateFormatCacheKey, isEmptyObject, isDate, getGlobalThis } from '@intlify/shared';\nimport { defaultOnError, baseCompile, CompileErrorCodes, createCompileError } from '@intlify/message-compiler';\nexport { CompileErrorCodes, createCompileError } from '@intlify/message-compiler';\nimport { IntlifyDevToolsHooks } from '@intlify/devtools-if';\n\nconst pathStateMachine =  [];\r\npathStateMachine[0 /* BEFORE_PATH */] = {\r\n    [\"w\" /* WORKSPACE */]: [0 /* BEFORE_PATH */],\r\n    [\"i\" /* IDENT */]: [3 /* IN_IDENT */, 0 /* APPEND */],\r\n    [\"[\" /* LEFT_BRACKET */]: [4 /* IN_SUB_PATH */],\r\n    [\"o\" /* END_OF_FAIL */]: [7 /* AFTER_PATH */]\r\n};\r\npathStateMachine[1 /* IN_PATH */] = {\r\n    [\"w\" /* WORKSPACE */]: [1 /* IN_PATH */],\r\n    [\".\" /* DOT */]: [2 /* BEFORE_IDENT */],\r\n    [\"[\" /* LEFT_BRACKET */]: [4 /* IN_SUB_PATH */],\r\n    [\"o\" /* END_OF_FAIL */]: [7 /* AFTER_PATH */]\r\n};\r\npathStateMachine[2 /* BEFORE_IDENT */] = {\r\n    [\"w\" /* WORKSPACE */]: [2 /* BEFORE_IDENT */],\r\n    [\"i\" /* IDENT */]: [3 /* IN_IDENT */, 0 /* APPEND */],\r\n    [\"0\" /* ZERO */]: [3 /* IN_IDENT */, 0 /* APPEND */]\r\n};\r\npathStateMachine[3 /* IN_IDENT */] = {\r\n    [\"i\" /* IDENT */]: [3 /* IN_IDENT */, 0 /* APPEND */],\r\n    [\"0\" /* ZERO */]: [3 /* IN_IDENT */, 0 /* APPEND */],\r\n    [\"w\" /* WORKSPACE */]: [1 /* IN_PATH */, 1 /* PUSH */],\r\n    [\".\" /* DOT */]: [2 /* BEFORE_IDENT */, 1 /* PUSH */],\r\n    [\"[\" /* LEFT_BRACKET */]: [4 /* IN_SUB_PATH */, 1 /* PUSH */],\r\n    [\"o\" /* END_OF_FAIL */]: [7 /* AFTER_PATH */, 1 /* PUSH */]\r\n};\r\npathStateMachine[4 /* IN_SUB_PATH */] = {\r\n    [\"'\" /* SINGLE_QUOTE */]: [5 /* IN_SINGLE_QUOTE */, 0 /* APPEND */],\r\n    [\"\\\"\" /* DOUBLE_QUOTE */]: [6 /* IN_DOUBLE_QUOTE */, 0 /* APPEND */],\r\n    [\"[\" /* LEFT_BRACKET */]: [\r\n        4 /* IN_SUB_PATH */,\r\n        2 /* INC_SUB_PATH_DEPTH */\r\n    ],\r\n    [\"]\" /* RIGHT_BRACKET */]: [1 /* IN_PATH */, 3 /* PUSH_SUB_PATH */],\r\n    [\"o\" /* END_OF_FAIL */]: 8 /* ERROR */,\r\n    [\"l\" /* ELSE */]: [4 /* IN_SUB_PATH */, 0 /* APPEND */]\r\n};\r\npathStateMachine[5 /* IN_SINGLE_QUOTE */] = {\r\n    [\"'\" /* SINGLE_QUOTE */]: [4 /* IN_SUB_PATH */, 0 /* APPEND */],\r\n    [\"o\" /* END_OF_FAIL */]: 8 /* ERROR */,\r\n    [\"l\" /* ELSE */]: [5 /* IN_SINGLE_QUOTE */, 0 /* APPEND */]\r\n};\r\npathStateMachine[6 /* IN_DOUBLE_QUOTE */] = {\r\n    [\"\\\"\" /* DOUBLE_QUOTE */]: [4 /* IN_SUB_PATH */, 0 /* APPEND */],\r\n    [\"o\" /* END_OF_FAIL */]: 8 /* ERROR */,\r\n    [\"l\" /* ELSE */]: [6 /* IN_DOUBLE_QUOTE */, 0 /* APPEND */]\r\n};\r\n/**\r\n * Check if an expression is a literal value.\r\n */\r\nconst literalValueRE = /^\\s?(?:true|false|-?[\\d.]+|'[^']*'|\"[^\"]*\")\\s?$/;\r\nfunction isLiteral(exp) {\r\n    return literalValueRE.test(exp);\r\n}\r\n/**\r\n * Strip quotes from a string\r\n */\r\nfunction stripQuotes(str) {\r\n    const a = str.charCodeAt(0);\r\n    const b = str.charCodeAt(str.length - 1);\r\n    return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;\r\n}\r\n/**\r\n * Determine the type of a character in a keypath.\r\n */\r\nfunction getPathCharType(ch) {\r\n    if (ch === undefined || ch === null) {\r\n        return \"o\" /* END_OF_FAIL */;\r\n    }\r\n    const code = ch.charCodeAt(0);\r\n    switch (code) {\r\n        case 0x5b: // [\r\n        case 0x5d: // ]\r\n        case 0x2e: // .\r\n        case 0x22: // \"\r\n        case 0x27: // '\r\n            return ch;\r\n        case 0x5f: // _\r\n        case 0x24: // $\r\n        case 0x2d: // -\r\n            return \"i\" /* IDENT */;\r\n        case 0x09: // Tab (HT)\r\n        case 0x0a: // Newline (LF)\r\n        case 0x0d: // Return (CR)\r\n        case 0xa0: // No-break space (NBSP)\r\n        case 0xfeff: // Byte Order Mark (BOM)\r\n        case 0x2028: // Line Separator (LS)\r\n        case 0x2029: // Paragraph Separator (PS)\r\n            return \"w\" /* WORKSPACE */;\r\n    }\r\n    return \"i\" /* IDENT */;\r\n}\r\n/**\r\n * Format a subPath, return its plain form if it is\r\n * a literal string or number. Otherwise prepend the\r\n * dynamic indicator (*).\r\n */\r\nfunction formatSubPath(path) {\r\n    const trimmed = path.trim();\r\n    // invalid leading 0\r\n    if (path.charAt(0) === '0' && isNaN(parseInt(path))) {\r\n        return false;\r\n    }\r\n    return isLiteral(trimmed)\r\n        ? stripQuotes(trimmed)\r\n        : \"*\" /* ASTARISK */ + trimmed;\r\n}\r\n/**\r\n * Parse a string path into an array of segments\r\n */\r\nfunction parse(path) {\r\n    const keys = [];\r\n    let index = -1;\r\n    let mode = 0 /* BEFORE_PATH */;\r\n    let subPathDepth = 0;\r\n    let c;\r\n    let key; // eslint-disable-line\r\n    let newChar;\r\n    let type;\r\n    let transition;\r\n    let action;\r\n    let typeMap;\r\n    const actions = [];\r\n    actions[0 /* APPEND */] = () => {\r\n        if (key === undefined) {\r\n            key = newChar;\r\n        }\r\n        else {\r\n            key += newChar;\r\n        }\r\n    };\r\n    actions[1 /* PUSH */] = () => {\r\n        if (key !== undefined) {\r\n            keys.push(key);\r\n            key = undefined;\r\n        }\r\n    };\r\n    actions[2 /* INC_SUB_PATH_DEPTH */] = () => {\r\n        actions[0 /* APPEND */]();\r\n        subPathDepth++;\r\n    };\r\n    actions[3 /* PUSH_SUB_PATH */] = () => {\r\n        if (subPathDepth > 0) {\r\n            subPathDepth--;\r\n            mode = 4 /* IN_SUB_PATH */;\r\n            actions[0 /* APPEND */]();\r\n        }\r\n        else {\r\n            subPathDepth = 0;\r\n            if (key === undefined) {\r\n                return false;\r\n            }\r\n            key = formatSubPath(key);\r\n            if (key === false) {\r\n                return false;\r\n            }\r\n            else {\r\n                actions[1 /* PUSH */]();\r\n            }\r\n        }\r\n    };\r\n    function maybeUnescapeQuote() {\r\n        const nextChar = path[index + 1];\r\n        if ((mode === 5 /* IN_SINGLE_QUOTE */ &&\r\n            nextChar === \"'\" /* SINGLE_QUOTE */) ||\r\n            (mode === 6 /* IN_DOUBLE_QUOTE */ &&\r\n                nextChar === \"\\\"\" /* DOUBLE_QUOTE */)) {\r\n            index++;\r\n            newChar = '\\\\' + nextChar;\r\n            actions[0 /* APPEND */]();\r\n            return true;\r\n        }\r\n    }\r\n    while (mode !== null) {\r\n        index++;\r\n        c = path[index];\r\n        if (c === '\\\\' && maybeUnescapeQuote()) {\r\n            continue;\r\n        }\r\n        type = getPathCharType(c);\r\n        typeMap = pathStateMachine[mode];\r\n        transition = typeMap[type] || typeMap[\"l\" /* ELSE */] || 8 /* ERROR */;\r\n        // check parse error\r\n        if (transition === 8 /* ERROR */) {\r\n            return;\r\n        }\r\n        mode = transition[0];\r\n        if (transition[1] !== undefined) {\r\n            action = actions[transition[1]];\r\n            if (action) {\r\n                newChar = c;\r\n                if (action() === false) {\r\n                    return;\r\n                }\r\n            }\r\n        }\r\n        // check parse finish\r\n        if (mode === 7 /* AFTER_PATH */) {\r\n            return keys;\r\n        }\r\n    }\r\n}\r\n// path token cache\r\nconst cache = new Map();\r\n/**\r\n * key-value message resolver\r\n *\r\n * @remarks\r\n * Resolves messages with the key-value structure. Note that messages with a hierarchical structure such as objects cannot be resolved\r\n *\r\n * @param obj - A target object to be resolved with path\r\n * @param path - A {@link Path | path} to resolve the value of message\r\n *\r\n * @returns A resolved {@link PathValue | path value}\r\n *\r\n * @VueI18nGeneral\r\n */\r\nfunction resolveWithKeyValue(obj, path) {\r\n    return isObject(obj) ? obj[path] : null;\r\n}\r\n/**\r\n * message resolver\r\n *\r\n * @remarks\r\n * Resolves messages. messages with a hierarchical structure such as objects can be resolved. This resolver is used in VueI18n as default.\r\n *\r\n * @param obj - A target object to be resolved with path\r\n * @param path - A {@link Path | path} to resolve the value of message\r\n *\r\n * @returns A resolved {@link PathValue | path value}\r\n *\r\n * @VueI18nGeneral\r\n */\r\nfunction resolveValue(obj, path) {\r\n    // check object\r\n    if (!isObject(obj)) {\r\n        return null;\r\n    }\r\n    // parse path\r\n    let hit = cache.get(path);\r\n    if (!hit) {\r\n        hit = parse(path);\r\n        if (hit) {\r\n            cache.set(path, hit);\r\n        }\r\n    }\r\n    // check hit\r\n    if (!hit) {\r\n        return null;\r\n    }\r\n    // resolve path value\r\n    const len = hit.length;\r\n    let last = obj;\r\n    let i = 0;\r\n    while (i < len) {\r\n        const val = last[hit[i]];\r\n        if (val === undefined) {\r\n            return null;\r\n        }\r\n        last = val;\r\n        i++;\r\n    }\r\n    return last;\r\n}\n\nconst DEFAULT_MODIFIER = (str) => str;\r\nconst DEFAULT_MESSAGE = (ctx) => ''; // eslint-disable-line\r\nconst DEFAULT_MESSAGE_DATA_TYPE = 'text';\r\nconst DEFAULT_NORMALIZE = (values) => values.length === 0 ? '' : values.join('');\r\nconst DEFAULT_INTERPOLATE = toDisplayString;\r\nfunction pluralDefault(choice, choicesLength) {\r\n    choice = Math.abs(choice);\r\n    if (choicesLength === 2) {\r\n        // prettier-ignore\r\n        return choice\r\n            ? choice > 1\r\n                ? 1\r\n                : 0\r\n            : 1;\r\n    }\r\n    return choice ? Math.min(choice, 2) : 0;\r\n}\r\nfunction getPluralIndex(options) {\r\n    // prettier-ignore\r\n    const index = isNumber(options.pluralIndex)\r\n        ? options.pluralIndex\r\n        : -1;\r\n    // prettier-ignore\r\n    return options.named && (isNumber(options.named.count) || isNumber(options.named.n))\r\n        ? isNumber(options.named.count)\r\n            ? options.named.count\r\n            : isNumber(options.named.n)\r\n                ? options.named.n\r\n                : index\r\n        : index;\r\n}\r\nfunction normalizeNamed(pluralIndex, props) {\r\n    if (!props.count) {\r\n        props.count = pluralIndex;\r\n    }\r\n    if (!props.n) {\r\n        props.n = pluralIndex;\r\n    }\r\n}\r\nfunction createMessageContext(options = {}) {\r\n    const locale = options.locale;\r\n    const pluralIndex = getPluralIndex(options);\r\n    const pluralRule = isObject(options.pluralRules) &&\r\n        isString(locale) &&\r\n        isFunction(options.pluralRules[locale])\r\n        ? options.pluralRules[locale]\r\n        : pluralDefault;\r\n    const orgPluralRule = isObject(options.pluralRules) &&\r\n        isString(locale) &&\r\n        isFunction(options.pluralRules[locale])\r\n        ? pluralDefault\r\n        : undefined;\r\n    const plural = (messages) => messages[pluralRule(pluralIndex, messages.length, orgPluralRule)];\r\n    const _list = options.list || [];\r\n    const list = (index) => _list[index];\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    const _named = options.named || {};\r\n    isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);\r\n    const named = (key) => _named[key];\r\n    function message(key) {\r\n        // prettier-ignore\r\n        const msg = isFunction(options.messages)\r\n            ? options.messages(key)\r\n            : isObject(options.messages)\r\n                ? options.messages[key]\r\n                : false;\r\n        return !msg\r\n            ? options.parent\r\n                ? options.parent.message(key) // resolve from parent messages\r\n                : DEFAULT_MESSAGE\r\n            : msg;\r\n    }\r\n    const _modifier = (name) => options.modifiers\r\n        ? options.modifiers[name]\r\n        : DEFAULT_MODIFIER;\r\n    const normalize = isPlainObject(options.processor) && isFunction(options.processor.normalize)\r\n        ? options.processor.normalize\r\n        : DEFAULT_NORMALIZE;\r\n    const interpolate = isPlainObject(options.processor) &&\r\n        isFunction(options.processor.interpolate)\r\n        ? options.processor.interpolate\r\n        : DEFAULT_INTERPOLATE;\r\n    const linked = (key, modifier) => {\r\n        const msg = message(key)(ctx);\r\n        return isString(modifier) ? _modifier(modifier)(msg) : msg;\r\n    };\r\n    const type = isPlainObject(options.processor) && isString(options.processor.type)\r\n        ? options.processor.type\r\n        : DEFAULT_MESSAGE_DATA_TYPE;\r\n    const ctx = {\r\n        [\"list\" /* LIST */]: list,\r\n        [\"named\" /* NAMED */]: named,\r\n        [\"plural\" /* PLURAL */]: plural,\r\n        [\"linked\" /* LINKED */]: linked,\r\n        [\"message\" /* MESSAGE */]: message,\r\n        [\"type\" /* TYPE */]: type,\r\n        [\"interpolate\" /* INTERPOLATE */]: interpolate,\r\n        [\"normalize\" /* NORMALIZE */]: normalize\r\n    };\r\n    return ctx;\r\n}\n\nlet devtools = null;\r\nfunction setDevToolsHook(hook) {\r\n    devtools = hook;\r\n}\r\nfunction getDevToolsHook() {\r\n    return devtools;\r\n}\r\nfunction initI18nDevTools(i18n, version, meta) {\r\n    // TODO: queue if devtools is undefined\r\n    devtools &&\r\n        devtools.emit(IntlifyDevToolsHooks.I18nInit, {\r\n            timestamp: Date.now(),\r\n            i18n,\r\n            version,\r\n            meta\r\n        });\r\n}\r\nconst translateDevTools = /* #__PURE__*/ createDevToolsHook(IntlifyDevToolsHooks.FunctionTranslate);\r\nfunction createDevToolsHook(hook) {\r\n    return (payloads) => devtools && devtools.emit(hook, payloads);\r\n}\n\nconst CoreWarnCodes = {\r\n    NOT_FOUND_KEY: 1,\r\n    FALLBACK_TO_TRANSLATE: 2,\r\n    CANNOT_FORMAT_NUMBER: 3,\r\n    FALLBACK_TO_NUMBER_FORMAT: 4,\r\n    CANNOT_FORMAT_DATE: 5,\r\n    FALLBACK_TO_DATE_FORMAT: 6,\r\n    __EXTEND_POINT__: 7\r\n};\r\n/** @internal */\r\nconst warnMessages = {\r\n    [CoreWarnCodes.NOT_FOUND_KEY]: `Not found '{key}' key in '{locale}' locale messages.`,\r\n    [CoreWarnCodes.FALLBACK_TO_TRANSLATE]: `Fall back to translate '{key}' key with '{target}' locale.`,\r\n    [CoreWarnCodes.CANNOT_FORMAT_NUMBER]: `Cannot format a number value due to not supported Intl.NumberFormat.`,\r\n    [CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT]: `Fall back to number format '{key}' key with '{target}' locale.`,\r\n    [CoreWarnCodes.CANNOT_FORMAT_DATE]: `Cannot format a date value due to not supported Intl.DateTimeFormat.`,\r\n    [CoreWarnCodes.FALLBACK_TO_DATE_FORMAT]: `Fall back to datetime format '{key}' key with '{target}' locale.`\r\n};\r\nfunction getWarnMessage(code, ...args) {\r\n    return format(warnMessages[code], ...args);\r\n}\n\n/**\r\n * Fallback with simple implemenation\r\n *\r\n * @remarks\r\n * A fallback locale function implemented with a simple fallback algorithm.\r\n *\r\n * Basically, it returns the value as specified in the `fallbackLocale` props, and is processed with the fallback inside intlify.\r\n *\r\n * @param ctx - A {@link CoreContext | context}\r\n * @param fallback - A {@link FallbackLocale | fallback locale}\r\n * @param start - A starting {@link Locale | locale}\r\n *\r\n * @returns Fallback locales\r\n *\r\n * @VueI18nGeneral\r\n */\r\nfunction fallbackWithSimple(ctx, fallback, start // eslint-disable-line @typescript-eslint/no-unused-vars\r\n) {\r\n    // prettier-ignore\r\n    return [...new Set([\r\n            start,\r\n            ...(isArray(fallback)\r\n                ? fallback\r\n                : isObject(fallback)\r\n                    ? Object.keys(fallback)\r\n                    : isString(fallback)\r\n                        ? [fallback]\r\n                        : [start])\r\n        ])];\r\n}\r\n/**\r\n * Fallback with locale chain\r\n *\r\n * @remarks\r\n * A fallback locale function implemented with a fallback chain algorithm. It's used in VueI18n as default.\r\n *\r\n * @param ctx - A {@link CoreContext | context}\r\n * @param fallback - A {@link FallbackLocale | fallback locale}\r\n * @param start - A starting {@link Locale | locale}\r\n *\r\n * @returns Fallback locales\r\n *\r\n * @VueI18nSee [Fallbacking](../guide/essentials/fallback)\r\n *\r\n * @VueI18nGeneral\r\n */\r\nfunction fallbackWithLocaleChain(ctx, fallback, start) {\r\n    const startLocale = isString(start) ? start : DEFAULT_LOCALE;\r\n    const context = ctx;\r\n    if (!context.__localeChainCache) {\r\n        context.__localeChainCache = new Map();\r\n    }\r\n    let chain = context.__localeChainCache.get(startLocale);\r\n    if (!chain) {\r\n        chain = [];\r\n        // first block defined by start\r\n        let block = [start];\r\n        // while any intervening block found\r\n        while (isArray(block)) {\r\n            block = appendBlockToChain(chain, block, fallback);\r\n        }\r\n        // prettier-ignore\r\n        // last block defined by default\r\n        const defaults = isArray(fallback) || !isPlainObject(fallback)\r\n            ? fallback\r\n            : fallback['default']\r\n                ? fallback['default']\r\n                : null;\r\n        // convert defaults to array\r\n        block = isString(defaults) ? [defaults] : defaults;\r\n        if (isArray(block)) {\r\n            appendBlockToChain(chain, block, false);\r\n        }\r\n        context.__localeChainCache.set(startLocale, chain);\r\n    }\r\n    return chain;\r\n}\r\nfunction appendBlockToChain(chain, block, blocks) {\r\n    let follow = true;\r\n    for (let i = 0; i < block.length && isBoolean(follow); i++) {\r\n        const locale = block[i];\r\n        if (isString(locale)) {\r\n            follow = appendLocaleToChain(chain, block[i], blocks);\r\n        }\r\n    }\r\n    return follow;\r\n}\r\nfunction appendLocaleToChain(chain, locale, blocks) {\r\n    let follow;\r\n    const tokens = locale.split('-');\r\n    do {\r\n        const target = tokens.join('-');\r\n        follow = appendItemToChain(chain, target, blocks);\r\n        tokens.splice(-1, 1);\r\n    } while (tokens.length && follow === true);\r\n    return follow;\r\n}\r\nfunction appendItemToChain(chain, target, blocks) {\r\n    let follow = false;\r\n    if (!chain.includes(target)) {\r\n        follow = true;\r\n        if (target) {\r\n            follow = target[target.length - 1] !== '!';\r\n            const locale = target.replace(/!/g, '');\r\n            chain.push(locale);\r\n            if ((isArray(blocks) || isPlainObject(blocks)) &&\r\n                blocks[locale] // eslint-disable-line @typescript-eslint/no-explicit-any\r\n            ) {\r\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n                follow = blocks[locale];\r\n            }\r\n        }\r\n    }\r\n    return follow;\r\n}\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\r\n/**\r\n * Intlify core-base version\r\n * @internal\r\n */\r\nconst VERSION = '9.2.0-beta.35';\r\nconst NOT_REOSLVED = -1;\r\nconst DEFAULT_LOCALE = 'en-US';\r\nconst MISSING_RESOLVE_VALUE = '';\r\nfunction getDefaultLinkedModifiers() {\r\n    return {\r\n        upper: (val) => (isString(val) ? val.toUpperCase() : val),\r\n        lower: (val) => (isString(val) ? val.toLowerCase() : val),\r\n        // prettier-ignore\r\n        capitalize: (val) => (isString(val)\r\n            ? `${val.charAt(0).toLocaleUpperCase()}${val.substr(1)}`\r\n            : val)\r\n    };\r\n}\r\nlet _compiler;\r\nfunction registerMessageCompiler(compiler) {\r\n    _compiler = compiler;\r\n}\r\nlet _resolver;\r\n/**\r\n * Register the message resolver\r\n *\r\n * @param resolver - A {@link MessageResolver} function\r\n *\r\n * @VueI18nGeneral\r\n */\r\nfunction registerMessageResolver(resolver) {\r\n    _resolver = resolver;\r\n}\r\nlet _fallbacker;\r\n/**\r\n * Register the locale fallbacker\r\n *\r\n * @param fallbacker - A {@link LocaleFallbacker} function\r\n *\r\n * @VueI18nGeneral\r\n */\r\nfunction registerLocaleFallbacker(fallbacker) {\r\n    _fallbacker = fallbacker;\r\n}\r\n// Additional Meta for Intlify DevTools\r\nlet _additionalMeta = null;\r\nconst setAdditionalMeta =  (meta) => {\r\n    _additionalMeta = meta;\r\n};\r\nconst getAdditionalMeta =  () => _additionalMeta;\r\nlet _fallbackContext = null;\r\nconst setFallbackContext = (context) => {\r\n    _fallbackContext = context;\r\n};\r\nconst getFallbackContext = () => _fallbackContext;\r\n// ID for CoreContext\r\nlet _cid = 0;\r\nfunction createCoreContext(options = {}) {\r\n    // setup options\r\n    const version = isString(options.version) ? options.version : VERSION;\r\n    const locale = isString(options.locale) ? options.locale : DEFAULT_LOCALE;\r\n    const fallbackLocale = isArray(options.fallbackLocale) ||\r\n        isPlainObject(options.fallbackLocale) ||\r\n        isString(options.fallbackLocale) ||\r\n        options.fallbackLocale === false\r\n        ? options.fallbackLocale\r\n        : locale;\r\n    const messages = isPlainObject(options.messages)\r\n        ? options.messages\r\n        : { [locale]: {} };\r\n    const datetimeFormats = isPlainObject(options.datetimeFormats)\r\n            ? options.datetimeFormats\r\n            : { [locale]: {} }\r\n        ;\r\n    const numberFormats = isPlainObject(options.numberFormats)\r\n            ? options.numberFormats\r\n            : { [locale]: {} }\r\n        ;\r\n    const modifiers = assign({}, options.modifiers || {}, getDefaultLinkedModifiers());\r\n    const pluralRules = options.pluralRules || {};\r\n    const missing = isFunction(options.missing) ? options.missing : null;\r\n    const missingWarn = isBoolean(options.missingWarn) || isRegExp(options.missingWarn)\r\n        ? options.missingWarn\r\n        : true;\r\n    const fallbackWarn = isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn)\r\n        ? options.fallbackWarn\r\n        : true;\r\n    const fallbackFormat = !!options.fallbackFormat;\r\n    const unresolving = !!options.unresolving;\r\n    const postTranslation = isFunction(options.postTranslation)\r\n        ? options.postTranslation\r\n        : null;\r\n    const processor = isPlainObject(options.processor) ? options.processor : null;\r\n    const warnHtmlMessage = isBoolean(options.warnHtmlMessage)\r\n        ? options.warnHtmlMessage\r\n        : true;\r\n    const escapeParameter = !!options.escapeParameter;\r\n    const messageCompiler = isFunction(options.messageCompiler)\r\n        ? options.messageCompiler\r\n        : _compiler;\r\n    const messageResolver = isFunction(options.messageResolver)\r\n        ? options.messageResolver\r\n        : _resolver || resolveWithKeyValue;\r\n    const localeFallbacker = isFunction(options.localeFallbacker)\r\n        ? options.localeFallbacker\r\n        : _fallbacker || fallbackWithSimple;\r\n    const fallbackContext = isObject(options.fallbackContext)\r\n        ? options.fallbackContext\r\n        : undefined;\r\n    const onWarn = isFunction(options.onWarn) ? options.onWarn : warn;\r\n    // setup internal options\r\n    const internalOptions = options;\r\n    const __datetimeFormatters = isObject(internalOptions.__datetimeFormatters)\r\n            ? internalOptions.__datetimeFormatters\r\n            : new Map()\r\n        ;\r\n    const __numberFormatters = isObject(internalOptions.__numberFormatters)\r\n            ? internalOptions.__numberFormatters\r\n            : new Map()\r\n        ;\r\n    const __meta = isObject(internalOptions.__meta) ? internalOptions.__meta : {};\r\n    _cid++;\r\n    const context = {\r\n        version,\r\n        cid: _cid,\r\n        locale,\r\n        fallbackLocale,\r\n        messages,\r\n        modifiers,\r\n        pluralRules,\r\n        missing,\r\n        missingWarn,\r\n        fallbackWarn,\r\n        fallbackFormat,\r\n        unresolving,\r\n        postTranslation,\r\n        processor,\r\n        warnHtmlMessage,\r\n        escapeParameter,\r\n        messageCompiler,\r\n        messageResolver,\r\n        localeFallbacker,\r\n        fallbackContext,\r\n        onWarn,\r\n        __meta\r\n    };\r\n    {\r\n        context.datetimeFormats = datetimeFormats;\r\n        context.numberFormats = numberFormats;\r\n        context.__datetimeFormatters = __datetimeFormatters;\r\n        context.__numberFormatters = __numberFormatters;\r\n    }\r\n    // for vue-devtools timeline event\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        context.__v_emitter =\r\n            internalOptions.__v_emitter != null\r\n                ? internalOptions.__v_emitter\r\n                : undefined;\r\n    }\r\n    // NOTE: experimental !!\r\n    if ((process.env.NODE_ENV !== 'production') || __INTLIFY_PROD_DEVTOOLS__) {\r\n        initI18nDevTools(context, version, __meta);\r\n    }\r\n    return context;\r\n}\r\n/** @internal */\r\nfunction isTranslateFallbackWarn(fallback, key) {\r\n    return fallback instanceof RegExp ? fallback.test(key) : fallback;\r\n}\r\n/** @internal */\r\nfunction isTranslateMissingWarn(missing, key) {\r\n    return missing instanceof RegExp ? missing.test(key) : missing;\r\n}\r\n/** @internal */\r\nfunction handleMissing(context, key, locale, missingWarn, type) {\r\n    const { missing, onWarn } = context;\r\n    // for vue-devtools timeline event\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        const emitter = context.__v_emitter;\r\n        if (emitter) {\r\n            emitter.emit(\"missing\" /* MISSING */, {\r\n                locale,\r\n                key,\r\n                type,\r\n                groupId: `${type}:${key}`\r\n            });\r\n        }\r\n    }\r\n    if (missing !== null) {\r\n        const ret = missing(context, locale, key, type);\r\n        return isString(ret) ? ret : key;\r\n    }\r\n    else {\r\n        if ((process.env.NODE_ENV !== 'production') && isTranslateMissingWarn(missingWarn, key)) {\r\n            onWarn(getWarnMessage(CoreWarnCodes.NOT_FOUND_KEY, { key, locale }));\r\n        }\r\n        return key;\r\n    }\r\n}\r\n/** @internal */\r\nfunction updateFallbackLocale(ctx, locale, fallback) {\r\n    const context = ctx;\r\n    context.__localeChainCache = new Map();\r\n    ctx.localeFallbacker(ctx, fallback, locale);\r\n}\r\n/* eslint-enable @typescript-eslint/no-explicit-any */\n\nconst RE_HTML_TAG = /<\\/?[\\w\\s=\"/.':;#-\\/]+>/;\r\nconst WARN_MESSAGE = `Detected HTML in '{source}' message. Recommend not using HTML messages to avoid XSS.`;\r\nfunction checkHtmlMessage(source, options) {\r\n    const warnHtmlMessage = isBoolean(options.warnHtmlMessage)\r\n        ? options.warnHtmlMessage\r\n        : true;\r\n    if (warnHtmlMessage && RE_HTML_TAG.test(source)) {\r\n        warn(format(WARN_MESSAGE, { source }));\r\n    }\r\n}\r\nconst defaultOnCacheKey = (source) => source;\r\nlet compileCache = Object.create(null);\r\nfunction clearCompileCache() {\r\n    compileCache = Object.create(null);\r\n}\r\nfunction compileToFunction(source, options = {}) {\r\n    {\r\n        // check HTML message\r\n        (process.env.NODE_ENV !== 'production') && checkHtmlMessage(source, options);\r\n        // check caches\r\n        const onCacheKey = options.onCacheKey || defaultOnCacheKey;\r\n        const key = onCacheKey(source);\r\n        const cached = compileCache[key];\r\n        if (cached) {\r\n            return cached;\r\n        }\r\n        // compile error detecting\r\n        let occurred = false;\r\n        const onError = options.onError || defaultOnError;\r\n        options.onError = (err) => {\r\n            occurred = true;\r\n            onError(err);\r\n        };\r\n        // compile\r\n        const { code } = baseCompile(source, options);\r\n        // evaluate function\r\n        const msg = new Function(`return ${code}`)();\r\n        // if occurred compile error, don't cache\r\n        return !occurred ? (compileCache[key] = msg) : msg;\r\n    }\r\n}\n\nlet code = CompileErrorCodes.__EXTEND_POINT__;\r\nconst inc = () => ++code;\r\nconst CoreErrorCodes = {\r\n    INVALID_ARGUMENT: code,\r\n    INVALID_DATE_ARGUMENT: inc(),\r\n    INVALID_ISO_DATE_ARGUMENT: inc(),\r\n    __EXTEND_POINT__: inc() // 18\r\n};\r\nfunction createCoreError(code) {\r\n    return createCompileError(code, null, (process.env.NODE_ENV !== 'production') ? { messages: errorMessages } : undefined);\r\n}\r\n/** @internal */\r\nconst errorMessages = {\r\n    [CoreErrorCodes.INVALID_ARGUMENT]: 'Invalid arguments',\r\n    [CoreErrorCodes.INVALID_DATE_ARGUMENT]: 'The date provided is an invalid Date object.' +\r\n        'Make sure your Date represents a valid date.',\r\n    [CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT]: 'The argument provided is not a valid ISO date string'\r\n};\n\nconst NOOP_MESSAGE_FUNCTION = () => '';\r\nconst isMessageFunction = (val) => isFunction(val);\r\n// implementation of `translate` function\r\nfunction translate(context, ...args) {\r\n    const { fallbackFormat, postTranslation, unresolving, messageCompiler, fallbackLocale, messages } = context;\r\n    const [key, options] = parseTranslateArgs(...args);\r\n    const missingWarn = isBoolean(options.missingWarn)\r\n        ? options.missingWarn\r\n        : context.missingWarn;\r\n    const fallbackWarn = isBoolean(options.fallbackWarn)\r\n        ? options.fallbackWarn\r\n        : context.fallbackWarn;\r\n    const escapeParameter = isBoolean(options.escapeParameter)\r\n        ? options.escapeParameter\r\n        : context.escapeParameter;\r\n    const resolvedMessage = !!options.resolvedMessage;\r\n    // prettier-ignore\r\n    const defaultMsgOrKey = isString(options.default) || isBoolean(options.default) // default by function option\r\n        ? !isBoolean(options.default)\r\n            ? options.default\r\n            : (!messageCompiler ? () => key : key)\r\n        : fallbackFormat // default by `fallbackFormat` option\r\n            ? (!messageCompiler ? () => key : key)\r\n            : '';\r\n    const enableDefaultMsg = fallbackFormat || defaultMsgOrKey !== '';\r\n    const locale = isString(options.locale) ? options.locale : context.locale;\r\n    // escape params\r\n    escapeParameter && escapeParams(options);\r\n    // resolve message format\r\n    // eslint-disable-next-line prefer-const\r\n    let [formatScope, targetLocale, message] = !resolvedMessage\r\n        ? resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn)\r\n        : [\r\n            key,\r\n            locale,\r\n            messages[locale] || {}\r\n        ];\r\n    // NOTE:\r\n    //  Fix to work around `ssrTransfrom` bug in Vite.\r\n    //  https://github.com/vitejs/vite/issues/4306\r\n    //  To get around this, use temporary variables.\r\n    //  https://github.com/nuxt/framework/issues/1461#issuecomment-954606243\r\n    let format = formatScope;\r\n    // if you use default message, set it as message format!\r\n    let cacheBaseKey = key;\r\n    if (!resolvedMessage &&\r\n        !(isString(format) || isMessageFunction(format))) {\r\n        if (enableDefaultMsg) {\r\n            format = defaultMsgOrKey;\r\n            cacheBaseKey = format;\r\n        }\r\n    }\r\n    // checking message format and target locale\r\n    if (!resolvedMessage &&\r\n        (!(isString(format) || isMessageFunction(format)) ||\r\n            !isString(targetLocale))) {\r\n        return unresolving ? NOT_REOSLVED : key;\r\n    }\r\n    if ((process.env.NODE_ENV !== 'production') && isString(format) && context.messageCompiler == null) {\r\n        warn(`The message format compilation is not supported in this build. ` +\r\n            `Because message compiler isn't included. ` +\r\n            `You need to pre-compilation all message format. ` +\r\n            `So translate function return '${key}'.`);\r\n        return key;\r\n    }\r\n    // setup compile error detecting\r\n    let occurred = false;\r\n    const errorDetector = () => {\r\n        occurred = true;\r\n    };\r\n    // compile message format\r\n    const msg = !isMessageFunction(format)\r\n        ? compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, errorDetector)\r\n        : format;\r\n    // if occurred compile error, return the message format\r\n    if (occurred) {\r\n        return format;\r\n    }\r\n    // evaluate message with context\r\n    const ctxOptions = getMessageContextOptions(context, targetLocale, message, options);\r\n    const msgContext = createMessageContext(ctxOptions);\r\n    const messaged = evaluateMessage(context, msg, msgContext);\r\n    // if use post translation option, proceed it with handler\r\n    const ret = postTranslation ? postTranslation(messaged) : messaged;\r\n    // NOTE: experimental !!\r\n    if ((process.env.NODE_ENV !== 'production') || __INTLIFY_PROD_DEVTOOLS__) {\r\n        // prettier-ignore\r\n        const payloads = {\r\n            timestamp: Date.now(),\r\n            key: isString(key)\r\n                ? key\r\n                : isMessageFunction(format)\r\n                    ? format.key\r\n                    : '',\r\n            locale: targetLocale || (isMessageFunction(format)\r\n                ? format.locale\r\n                : ''),\r\n            format: isString(format)\r\n                ? format\r\n                : isMessageFunction(format)\r\n                    ? format.source\r\n                    : '',\r\n            message: ret\r\n        };\r\n        payloads.meta = assign({}, context.__meta, getAdditionalMeta() || {});\r\n        translateDevTools(payloads);\r\n    }\r\n    return ret;\r\n}\r\nfunction escapeParams(options) {\r\n    if (isArray(options.list)) {\r\n        options.list = options.list.map(item => isString(item) ? escapeHtml(item) : item);\r\n    }\r\n    else if (isObject(options.named)) {\r\n        Object.keys(options.named).forEach(key => {\r\n            if (isString(options.named[key])) {\r\n                options.named[key] = escapeHtml(options.named[key]);\r\n            }\r\n        });\r\n    }\r\n}\r\nfunction resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn) {\r\n    const { messages, onWarn, messageResolver: resolveValue, localeFallbacker } = context;\r\n    const locales = localeFallbacker(context, fallbackLocale, locale); // eslint-disable-line @typescript-eslint/no-explicit-any\r\n    let message = {};\r\n    let targetLocale;\r\n    let format = null;\r\n    let from = locale;\r\n    let to = null;\r\n    const type = 'translate';\r\n    for (let i = 0; i < locales.length; i++) {\r\n        targetLocale = to = locales[i];\r\n        if ((process.env.NODE_ENV !== 'production') &&\r\n            locale !== targetLocale &&\r\n            isTranslateFallbackWarn(fallbackWarn, key)) {\r\n            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_TRANSLATE, {\r\n                key,\r\n                target: targetLocale\r\n            }));\r\n        }\r\n        // for vue-devtools timeline event\r\n        if ((process.env.NODE_ENV !== 'production') && locale !== targetLocale) {\r\n            const emitter = context.__v_emitter;\r\n            if (emitter) {\r\n                emitter.emit(\"fallback\" /* FALBACK */, {\r\n                    type,\r\n                    key,\r\n                    from,\r\n                    to,\r\n                    groupId: `${type}:${key}`\r\n                });\r\n            }\r\n        }\r\n        message =\r\n            messages[targetLocale] || {};\r\n        // for vue-devtools timeline event\r\n        let start = null;\r\n        let startTag;\r\n        let endTag;\r\n        if ((process.env.NODE_ENV !== 'production') && inBrowser) {\r\n            start = window.performance.now();\r\n            startTag = 'intlify-message-resolve-start';\r\n            endTag = 'intlify-message-resolve-end';\r\n            mark && mark(startTag);\r\n        }\r\n        if ((format = resolveValue(message, key)) === null) {\r\n            // if null, resolve with object key path\r\n            format = message[key]; // eslint-disable-line @typescript-eslint/no-explicit-any\r\n        }\r\n        // for vue-devtools timeline event\r\n        if ((process.env.NODE_ENV !== 'production') && inBrowser) {\r\n            const end = window.performance.now();\r\n            const emitter = context.__v_emitter;\r\n            if (emitter && start && format) {\r\n                emitter.emit(\"message-resolve\" /* MESSAGE_RESOLVE */, {\r\n                    type: \"message-resolve\" /* MESSAGE_RESOLVE */,\r\n                    key,\r\n                    message: format,\r\n                    time: end - start,\r\n                    groupId: `${type}:${key}`\r\n                });\r\n            }\r\n            if (startTag && endTag && mark && measure) {\r\n                mark(endTag);\r\n                measure('intlify message resolve', startTag, endTag);\r\n            }\r\n        }\r\n        if (isString(format) || isFunction(format))\r\n            break;\r\n        const missingRet = handleMissing(context, // eslint-disable-line @typescript-eslint/no-explicit-any\r\n        key, targetLocale, missingWarn, type);\r\n        if (missingRet !== key) {\r\n            format = missingRet;\r\n        }\r\n        from = to;\r\n    }\r\n    return [format, targetLocale, message];\r\n}\r\nfunction compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, errorDetector) {\r\n    const { messageCompiler, warnHtmlMessage } = context;\r\n    if (isMessageFunction(format)) {\r\n        const msg = format;\r\n        msg.locale = msg.locale || targetLocale;\r\n        msg.key = msg.key || key;\r\n        return msg;\r\n    }\r\n    if (messageCompiler == null) {\r\n        const msg = (() => format);\r\n        msg.locale = targetLocale;\r\n        msg.key = key;\r\n        return msg;\r\n    }\r\n    // for vue-devtools timeline event\r\n    let start = null;\r\n    let startTag;\r\n    let endTag;\r\n    if ((process.env.NODE_ENV !== 'production') && inBrowser) {\r\n        start = window.performance.now();\r\n        startTag = 'intlify-message-compilation-start';\r\n        endTag = 'intlify-message-compilation-end';\r\n        mark && mark(startTag);\r\n    }\r\n    const msg = messageCompiler(format, getCompileOptions(context, targetLocale, cacheBaseKey, format, warnHtmlMessage, errorDetector));\r\n    // for vue-devtools timeline event\r\n    if ((process.env.NODE_ENV !== 'production') && inBrowser) {\r\n        const end = window.performance.now();\r\n        const emitter = context.__v_emitter;\r\n        if (emitter && start) {\r\n            emitter.emit(\"message-compilation\" /* MESSAGE_COMPILATION */, {\r\n                type: \"message-compilation\" /* MESSAGE_COMPILATION */,\r\n                message: format,\r\n                time: end - start,\r\n                groupId: `${'translate'}:${key}`\r\n            });\r\n        }\r\n        if (startTag && endTag && mark && measure) {\r\n            mark(endTag);\r\n            measure('intlify message compilation', startTag, endTag);\r\n        }\r\n    }\r\n    msg.locale = targetLocale;\r\n    msg.key = key;\r\n    msg.source = format;\r\n    return msg;\r\n}\r\nfunction evaluateMessage(context, msg, msgCtx) {\r\n    // for vue-devtools timeline event\r\n    let start = null;\r\n    let startTag;\r\n    let endTag;\r\n    if ((process.env.NODE_ENV !== 'production') && inBrowser) {\r\n        start = window.performance.now();\r\n        startTag = 'intlify-message-evaluation-start';\r\n        endTag = 'intlify-message-evaluation-end';\r\n        mark && mark(startTag);\r\n    }\r\n    const messaged = msg(msgCtx);\r\n    // for vue-devtools timeline event\r\n    if ((process.env.NODE_ENV !== 'production') && inBrowser) {\r\n        const end = window.performance.now();\r\n        const emitter = context.__v_emitter;\r\n        if (emitter && start) {\r\n            emitter.emit(\"message-evaluation\" /* MESSAGE_EVALUATION */, {\r\n                type: \"message-evaluation\" /* MESSAGE_EVALUATION */,\r\n                value: messaged,\r\n                time: end - start,\r\n                groupId: `${'translate'}:${msg.key}`\r\n            });\r\n        }\r\n        if (startTag && endTag && mark && measure) {\r\n            mark(endTag);\r\n            measure('intlify message evaluation', startTag, endTag);\r\n        }\r\n    }\r\n    return messaged;\r\n}\r\n/** @internal */\r\nfunction parseTranslateArgs(...args) {\r\n    const [arg1, arg2, arg3] = args;\r\n    const options = {};\r\n    if (!isString(arg1) && !isNumber(arg1) && !isMessageFunction(arg1)) {\r\n        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);\r\n    }\r\n    // prettier-ignore\r\n    const key = isNumber(arg1)\r\n        ? String(arg1)\r\n        : isMessageFunction(arg1)\r\n            ? arg1\r\n            : arg1;\r\n    if (isNumber(arg2)) {\r\n        options.plural = arg2;\r\n    }\r\n    else if (isString(arg2)) {\r\n        options.default = arg2;\r\n    }\r\n    else if (isPlainObject(arg2) && !isEmptyObject(arg2)) {\r\n        options.named = arg2;\r\n    }\r\n    else if (isArray(arg2)) {\r\n        options.list = arg2;\r\n    }\r\n    if (isNumber(arg3)) {\r\n        options.plural = arg3;\r\n    }\r\n    else if (isString(arg3)) {\r\n        options.default = arg3;\r\n    }\r\n    else if (isPlainObject(arg3)) {\r\n        assign(options, arg3);\r\n    }\r\n    return [key, options];\r\n}\r\nfunction getCompileOptions(context, locale, key, source, warnHtmlMessage, errorDetector) {\r\n    return {\r\n        warnHtmlMessage,\r\n        onError: (err) => {\r\n            errorDetector && errorDetector(err);\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                const message = `Message compilation error: ${err.message}`;\r\n                const codeFrame = err.location &&\r\n                    generateCodeFrame(source, err.location.start.offset, err.location.end.offset);\r\n                const emitter = context.__v_emitter;\r\n                if (emitter) {\r\n                    emitter.emit(\"compile-error\" /* COMPILE_ERROR */, {\r\n                        message: source,\r\n                        error: err.message,\r\n                        start: err.location && err.location.start.offset,\r\n                        end: err.location && err.location.end.offset,\r\n                        groupId: `${'translate'}:${key}`\r\n                    });\r\n                }\r\n                console.error(codeFrame ? `${message}\\n${codeFrame}` : message);\r\n            }\r\n            else {\r\n                throw err;\r\n            }\r\n        },\r\n        onCacheKey: (source) => generateFormatCacheKey(locale, key, source)\r\n    };\r\n}\r\nfunction getMessageContextOptions(context, locale, message, options) {\r\n    const { modifiers, pluralRules, messageResolver: resolveValue, fallbackLocale, fallbackWarn, missingWarn, fallbackContext } = context;\r\n    const resolveMessage = (key) => {\r\n        let val = resolveValue(message, key);\r\n        // fallback to root context\r\n        if (val == null && fallbackContext) {\r\n            const [, , message] = resolveMessageFormat(fallbackContext, key, locale, fallbackLocale, fallbackWarn, missingWarn);\r\n            val = resolveValue(message, key);\r\n        }\r\n        if (isString(val)) {\r\n            let occurred = false;\r\n            const errorDetector = () => {\r\n                occurred = true;\r\n            };\r\n            const msg = compileMessageFormat(context, key, locale, val, key, errorDetector);\r\n            return !occurred\r\n                ? msg\r\n                : NOOP_MESSAGE_FUNCTION;\r\n        }\r\n        else if (isMessageFunction(val)) {\r\n            return val;\r\n        }\r\n        else {\r\n            // TODO: should be implemented warning message\r\n            return NOOP_MESSAGE_FUNCTION;\r\n        }\r\n    };\r\n    const ctxOptions = {\r\n        locale,\r\n        modifiers,\r\n        pluralRules,\r\n        messages: resolveMessage\r\n    };\r\n    if (context.processor) {\r\n        ctxOptions.processor = context.processor;\r\n    }\r\n    if (options.list) {\r\n        ctxOptions.list = options.list;\r\n    }\r\n    if (options.named) {\r\n        ctxOptions.named = options.named;\r\n    }\r\n    if (isNumber(options.plural)) {\r\n        ctxOptions.pluralIndex = options.plural;\r\n    }\r\n    return ctxOptions;\r\n}\n\nconst intlDefined = typeof Intl !== 'undefined';\r\nconst Availabilities = {\r\n    dateTimeFormat: intlDefined && typeof Intl.DateTimeFormat !== 'undefined',\r\n    numberFormat: intlDefined && typeof Intl.NumberFormat !== 'undefined'\r\n};\n\n// implementation of `datetime` function\r\nfunction datetime(context, ...args) {\r\n    const { datetimeFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;\r\n    const { __datetimeFormatters } = context;\r\n    if ((process.env.NODE_ENV !== 'production') && !Availabilities.dateTimeFormat) {\r\n        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_DATE));\r\n        return MISSING_RESOLVE_VALUE;\r\n    }\r\n    const [key, value, options, overrides] = parseDateTimeArgs(...args);\r\n    const missingWarn = isBoolean(options.missingWarn)\r\n        ? options.missingWarn\r\n        : context.missingWarn;\r\n    const fallbackWarn = isBoolean(options.fallbackWarn)\r\n        ? options.fallbackWarn\r\n        : context.fallbackWarn;\r\n    const part = !!options.part;\r\n    const locale = isString(options.locale) ? options.locale : context.locale;\r\n    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any\r\n    fallbackLocale, locale);\r\n    if (!isString(key) || key === '') {\r\n        return new Intl.DateTimeFormat(locale).format(value);\r\n    }\r\n    // resolve format\r\n    let datetimeFormat = {};\r\n    let targetLocale;\r\n    let format = null;\r\n    let from = locale;\r\n    let to = null;\r\n    const type = 'datetime format';\r\n    for (let i = 0; i < locales.length; i++) {\r\n        targetLocale = to = locales[i];\r\n        if ((process.env.NODE_ENV !== 'production') &&\r\n            locale !== targetLocale &&\r\n            isTranslateFallbackWarn(fallbackWarn, key)) {\r\n            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_DATE_FORMAT, {\r\n                key,\r\n                target: targetLocale\r\n            }));\r\n        }\r\n        // for vue-devtools timeline event\r\n        if ((process.env.NODE_ENV !== 'production') && locale !== targetLocale) {\r\n            const emitter = context.__v_emitter;\r\n            if (emitter) {\r\n                emitter.emit(\"fallback\" /* FALBACK */, {\r\n                    type,\r\n                    key,\r\n                    from,\r\n                    to,\r\n                    groupId: `${type}:${key}`\r\n                });\r\n            }\r\n        }\r\n        datetimeFormat =\r\n            datetimeFormats[targetLocale] || {};\r\n        format = datetimeFormat[key];\r\n        if (isPlainObject(format))\r\n            break;\r\n        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any\r\n        from = to;\r\n    }\r\n    // checking format and target locale\r\n    if (!isPlainObject(format) || !isString(targetLocale)) {\r\n        return unresolving ? NOT_REOSLVED : key;\r\n    }\r\n    let id = `${targetLocale}__${key}`;\r\n    if (!isEmptyObject(overrides)) {\r\n        id = `${id}__${JSON.stringify(overrides)}`;\r\n    }\r\n    let formatter = __datetimeFormatters.get(id);\r\n    if (!formatter) {\r\n        formatter = new Intl.DateTimeFormat(targetLocale, assign({}, format, overrides));\r\n        __datetimeFormatters.set(id, formatter);\r\n    }\r\n    return !part ? formatter.format(value) : formatter.formatToParts(value);\r\n}\r\n/** @internal */\r\nfunction parseDateTimeArgs(...args) {\r\n    const [arg1, arg2, arg3, arg4] = args;\r\n    let options = {};\r\n    let overrides = {};\r\n    let value;\r\n    if (isString(arg1)) {\r\n        // Only allow ISO strings - other date formats are often supported,\r\n        // but may cause different results in different browsers.\r\n        const matches = arg1.match(/(\\d{4}-\\d{2}-\\d{2})(T|\\s)?(.*)/);\r\n        if (!matches) {\r\n            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);\r\n        }\r\n        // Some browsers can not parse the iso datetime separated by space,\r\n        // this is a compromise solution by replace the 'T'/' ' with 'T'\r\n        const dateTime = matches[3]\r\n            ? matches[3].trim().startsWith('T')\r\n                ? `${matches[1].trim()}${matches[3].trim()}`\r\n                : `${matches[1].trim()}T${matches[3].trim()}`\r\n            : matches[1].trim();\r\n        value = new Date(dateTime);\r\n        try {\r\n            // This will fail if the date is not valid\r\n            value.toISOString();\r\n        }\r\n        catch (e) {\r\n            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);\r\n        }\r\n    }\r\n    else if (isDate(arg1)) {\r\n        if (isNaN(arg1.getTime())) {\r\n            throw createCoreError(CoreErrorCodes.INVALID_DATE_ARGUMENT);\r\n        }\r\n        value = arg1;\r\n    }\r\n    else if (isNumber(arg1)) {\r\n        value = arg1;\r\n    }\r\n    else {\r\n        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);\r\n    }\r\n    if (isString(arg2)) {\r\n        options.key = arg2;\r\n    }\r\n    else if (isPlainObject(arg2)) {\r\n        options = arg2;\r\n    }\r\n    if (isString(arg3)) {\r\n        options.locale = arg3;\r\n    }\r\n    else if (isPlainObject(arg3)) {\r\n        overrides = arg3;\r\n    }\r\n    if (isPlainObject(arg4)) {\r\n        overrides = arg4;\r\n    }\r\n    return [options.key || '', value, options, overrides];\r\n}\r\n/** @internal */\r\nfunction clearDateTimeFormat(ctx, locale, format) {\r\n    const context = ctx;\r\n    for (const key in format) {\r\n        const id = `${locale}__${key}`;\r\n        if (!context.__datetimeFormatters.has(id)) {\r\n            continue;\r\n        }\r\n        context.__datetimeFormatters.delete(id);\r\n    }\r\n}\n\n// implementation of `number` function\r\nfunction number(context, ...args) {\r\n    const { numberFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;\r\n    const { __numberFormatters } = context;\r\n    if ((process.env.NODE_ENV !== 'production') && !Availabilities.numberFormat) {\r\n        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_NUMBER));\r\n        return MISSING_RESOLVE_VALUE;\r\n    }\r\n    const [key, value, options, overrides] = parseNumberArgs(...args);\r\n    const missingWarn = isBoolean(options.missingWarn)\r\n        ? options.missingWarn\r\n        : context.missingWarn;\r\n    const fallbackWarn = isBoolean(options.fallbackWarn)\r\n        ? options.fallbackWarn\r\n        : context.fallbackWarn;\r\n    const part = !!options.part;\r\n    const locale = isString(options.locale) ? options.locale : context.locale;\r\n    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any\r\n    fallbackLocale, locale);\r\n    if (!isString(key) || key === '') {\r\n        return new Intl.NumberFormat(locale).format(value);\r\n    }\r\n    // resolve format\r\n    let numberFormat = {};\r\n    let targetLocale;\r\n    let format = null;\r\n    let from = locale;\r\n    let to = null;\r\n    const type = 'number format';\r\n    for (let i = 0; i < locales.length; i++) {\r\n        targetLocale = to = locales[i];\r\n        if ((process.env.NODE_ENV !== 'production') &&\r\n            locale !== targetLocale &&\r\n            isTranslateFallbackWarn(fallbackWarn, key)) {\r\n            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT, {\r\n                key,\r\n                target: targetLocale\r\n            }));\r\n        }\r\n        // for vue-devtools timeline event\r\n        if ((process.env.NODE_ENV !== 'production') && locale !== targetLocale) {\r\n            const emitter = context.__v_emitter;\r\n            if (emitter) {\r\n                emitter.emit(\"fallback\" /* FALBACK */, {\r\n                    type,\r\n                    key,\r\n                    from,\r\n                    to,\r\n                    groupId: `${type}:${key}`\r\n                });\r\n            }\r\n        }\r\n        numberFormat =\r\n            numberFormats[targetLocale] || {};\r\n        format = numberFormat[key];\r\n        if (isPlainObject(format))\r\n            break;\r\n        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any\r\n        from = to;\r\n    }\r\n    // checking format and target locale\r\n    if (!isPlainObject(format) || !isString(targetLocale)) {\r\n        return unresolving ? NOT_REOSLVED : key;\r\n    }\r\n    let id = `${targetLocale}__${key}`;\r\n    if (!isEmptyObject(overrides)) {\r\n        id = `${id}__${JSON.stringify(overrides)}`;\r\n    }\r\n    let formatter = __numberFormatters.get(id);\r\n    if (!formatter) {\r\n        formatter = new Intl.NumberFormat(targetLocale, assign({}, format, overrides));\r\n        __numberFormatters.set(id, formatter);\r\n    }\r\n    return !part ? formatter.format(value) : formatter.formatToParts(value);\r\n}\r\n/** @internal */\r\nfunction parseNumberArgs(...args) {\r\n    const [arg1, arg2, arg3, arg4] = args;\r\n    let options = {};\r\n    let overrides = {};\r\n    if (!isNumber(arg1)) {\r\n        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);\r\n    }\r\n    const value = arg1;\r\n    if (isString(arg2)) {\r\n        options.key = arg2;\r\n    }\r\n    else if (isPlainObject(arg2)) {\r\n        options = arg2;\r\n    }\r\n    if (isString(arg3)) {\r\n        options.locale = arg3;\r\n    }\r\n    else if (isPlainObject(arg3)) {\r\n        overrides = arg3;\r\n    }\r\n    if (isPlainObject(arg4)) {\r\n        overrides = arg4;\r\n    }\r\n    return [options.key || '', value, options, overrides];\r\n}\r\n/** @internal */\r\nfunction clearNumberFormat(ctx, locale, format) {\r\n    const context = ctx;\r\n    for (const key in format) {\r\n        const id = `${locale}__${key}`;\r\n        if (!context.__numberFormatters.has(id)) {\r\n            continue;\r\n        }\r\n        context.__numberFormatters.delete(id);\r\n    }\r\n}\n\n// TODO: we could not exports for Node native ES Moudles yet...\r\n{\r\n    if (typeof __INTLIFY_PROD_DEVTOOLS__ !== 'boolean') {\r\n        getGlobalThis().__INTLIFY_PROD_DEVTOOLS__ = false;\r\n    }\r\n}\n\nexport { CoreErrorCodes, CoreWarnCodes, DEFAULT_LOCALE, DEFAULT_MESSAGE_DATA_TYPE, MISSING_RESOLVE_VALUE, NOT_REOSLVED, VERSION, clearCompileCache, clearDateTimeFormat, clearNumberFormat, compileToFunction, createCoreContext, createCoreError, createMessageContext, datetime, fallbackWithLocaleChain, fallbackWithSimple, getAdditionalMeta, getDevToolsHook, getFallbackContext, getWarnMessage, handleMissing, initI18nDevTools, isMessageFunction, isTranslateFallbackWarn, isTranslateMissingWarn, number, parse, parseDateTimeArgs, parseNumberArgs, parseTranslateArgs, registerLocaleFallbacker, registerMessageCompiler, registerMessageResolver, resolveValue, resolveWithKeyValue, setAdditionalMeta, setDevToolsHook, setFallbackContext, translate, translateDevTools, updateFallbackLocale };\n","/*!\n  * vue-i18n v9.2.0-beta.35\n  * (c) 2022 kazuya kawaguchi\n  * Released under the MIT License.\n  */\nimport { getGlobalThis, format, makeSymbol, isPlainObject, isArray, isString, hasOwn, isObject, isBoolean, isRegExp, isFunction, inBrowser, assign, isNumber, warn, createEmitter, isEmptyObject } from '@intlify/shared';\nimport { CoreWarnCodes, createCompileError, CompileErrorCodes, DEFAULT_LOCALE, updateFallbackLocale, setFallbackContext, createCoreContext, clearDateTimeFormat, clearNumberFormat, setAdditionalMeta, getFallbackContext, NOT_REOSLVED, isTranslateFallbackWarn, isTranslateMissingWarn, parseTranslateArgs, translate, MISSING_RESOLVE_VALUE, parseDateTimeArgs, datetime, parseNumberArgs, number, fallbackWithLocaleChain, registerMessageCompiler, compileToFunction, registerMessageResolver, resolveValue, registerLocaleFallbacker, setDevToolsHook } from '@intlify/core-base';\nimport { createVNode, Text, ref, getCurrentInstance, computed, watch, Fragment, h, effectScope, inject, onMounted, onUnmounted, shallowRef, onBeforeMount, isRef } from 'vue';\nimport { setupDevtoolsPlugin } from '@vue/devtools-api';\nimport { VueDevToolsLabels, VueDevToolsPlaceholders, VueDevToolsTimelineColors } from '@intlify/vue-devtools';\n\n/**\r\n * Vue I18n Version\r\n *\r\n * @remarks\r\n * Semver format. Same format as the package.json `version` field.\r\n *\r\n * @VueI18nGeneral\r\n */\r\nconst VERSION = '9.2.0-beta.35';\r\n/**\r\n * This is only called in esm-bundler builds.\r\n * istanbul-ignore-next\r\n */\r\nfunction initFeatureFlags() {\r\n    let needWarn = false;\r\n    if (typeof __VUE_I18N_FULL_INSTALL__ !== 'boolean') {\r\n        needWarn = true;\r\n        getGlobalThis().__VUE_I18N_FULL_INSTALL__ = true;\r\n    }\r\n    if (typeof __VUE_I18N_LEGACY_API__ !== 'boolean') {\r\n        needWarn = true;\r\n        getGlobalThis().__VUE_I18N_LEGACY_API__ = true;\r\n    }\r\n    if (typeof __INTLIFY_PROD_DEVTOOLS__ !== 'boolean') {\r\n        getGlobalThis().__INTLIFY_PROD_DEVTOOLS__ = false;\r\n    }\r\n    if ((process.env.NODE_ENV !== 'production') && needWarn) {\r\n        console.warn(`You are running the esm-bundler build of vue-i18n. It is recommended to ` +\r\n            `configure your bundler to explicitly replace feature flag globals ` +\r\n            `with boolean literals to get proper tree-shaking in the final bundle.`);\r\n    }\r\n}\n\nlet code$1 = CoreWarnCodes.__EXTEND_POINT__;\r\nconst inc$1 = () => ++code$1;\r\nconst I18nWarnCodes = {\r\n    FALLBACK_TO_ROOT: code$1,\r\n    NOT_SUPPORTED_PRESERVE: inc$1(),\r\n    NOT_SUPPORTED_FORMATTER: inc$1(),\r\n    NOT_SUPPORTED_PRESERVE_DIRECTIVE: inc$1(),\r\n    NOT_SUPPORTED_GET_CHOICE_INDEX: inc$1(),\r\n    COMPONENT_NAME_LEGACY_COMPATIBLE: inc$1(),\r\n    NOT_FOUND_PARENT_SCOPE: inc$1() // 13\r\n};\r\nconst warnMessages = {\r\n    [I18nWarnCodes.FALLBACK_TO_ROOT]: `Fall back to {type} '{key}' with root locale.`,\r\n    [I18nWarnCodes.NOT_SUPPORTED_PRESERVE]: `Not supported 'preserve'.`,\r\n    [I18nWarnCodes.NOT_SUPPORTED_FORMATTER]: `Not supported 'formatter'.`,\r\n    [I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE]: `Not supported 'preserveDirectiveContent'.`,\r\n    [I18nWarnCodes.NOT_SUPPORTED_GET_CHOICE_INDEX]: `Not supported 'getChoiceIndex'.`,\r\n    [I18nWarnCodes.COMPONENT_NAME_LEGACY_COMPATIBLE]: `Component name legacy compatible: '{name}' -> 'i18n'`,\r\n    [I18nWarnCodes.NOT_FOUND_PARENT_SCOPE]: `Not found parent scope. use the global scope.`\r\n};\r\nfunction getWarnMessage(code, ...args) {\r\n    return format(warnMessages[code], ...args);\r\n}\n\nlet code = CompileErrorCodes.__EXTEND_POINT__;\r\nconst inc = () => ++code;\r\nconst I18nErrorCodes = {\r\n    // composer module errors\r\n    UNEXPECTED_RETURN_TYPE: code,\r\n    // legacy module errors\r\n    INVALID_ARGUMENT: inc(),\r\n    // i18n module errors\r\n    MUST_BE_CALL_SETUP_TOP: inc(),\r\n    NOT_INSLALLED: inc(),\r\n    NOT_AVAILABLE_IN_LEGACY_MODE: inc(),\r\n    // directive module errors\r\n    REQUIRED_VALUE: inc(),\r\n    INVALID_VALUE: inc(),\r\n    // vue-devtools errors\r\n    CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN: inc(),\r\n    NOT_INSLALLED_WITH_PROVIDE: inc(),\r\n    // unexpected error\r\n    UNEXPECTED_ERROR: inc(),\r\n    // not compatible legacy vue-i18n constructor\r\n    NOT_COMPATIBLE_LEGACY_VUE_I18N: inc(),\r\n    // bridge support vue 2.x only\r\n    BRIDGE_SUPPORT_VUE_2_ONLY: inc(),\r\n    // need to define `i18n` option in `allowComposition: true` and `useScope: 'local' at `useI18n``\r\n    MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION: inc(),\r\n    // Not available Compostion API in Legacy API mode. Please make sure that the legacy API mode is working properly\r\n    NOT_AVAILABLE_COMPOSITION_IN_LEGACY: inc(),\r\n    // for enhancement\r\n    __EXTEND_POINT__: inc() // 29\r\n};\r\nfunction createI18nError(code, ...args) {\r\n    return createCompileError(code, null, (process.env.NODE_ENV !== 'production') ? { messages: errorMessages, args } : undefined);\r\n}\r\nconst errorMessages = {\r\n    [I18nErrorCodes.UNEXPECTED_RETURN_TYPE]: 'Unexpected return type in composer',\r\n    [I18nErrorCodes.INVALID_ARGUMENT]: 'Invalid argument',\r\n    [I18nErrorCodes.MUST_BE_CALL_SETUP_TOP]: 'Must be called at the top of a `setup` function',\r\n    [I18nErrorCodes.NOT_INSLALLED]: 'Need to install with `app.use` function',\r\n    [I18nErrorCodes.UNEXPECTED_ERROR]: 'Unexpected error',\r\n    [I18nErrorCodes.NOT_AVAILABLE_IN_LEGACY_MODE]: 'Not available in legacy mode',\r\n    [I18nErrorCodes.REQUIRED_VALUE]: `Required in value: {0}`,\r\n    [I18nErrorCodes.INVALID_VALUE]: `Invalid value`,\r\n    [I18nErrorCodes.CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN]: `Cannot setup vue-devtools plugin`,\r\n    [I18nErrorCodes.NOT_INSLALLED_WITH_PROVIDE]: 'Need to install with `provide` function',\r\n    [I18nErrorCodes.NOT_COMPATIBLE_LEGACY_VUE_I18N]: 'Not compatible legacy VueI18n.',\r\n    [I18nErrorCodes.BRIDGE_SUPPORT_VUE_2_ONLY]: 'vue-i18n-bridge support Vue 2.x only',\r\n    [I18nErrorCodes.MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION]: 'Must define ‘i18n’ option in Composition API with using local scope in Legacy API mode',\r\n    [I18nErrorCodes.NOT_AVAILABLE_COMPOSITION_IN_LEGACY]: 'Not available Compostion API in Legacy API mode. Please make sure that the legacy API mode is working properly'\r\n};\n\nconst TransrateVNodeSymbol = \r\n/* #__PURE__*/ makeSymbol('__transrateVNode');\r\nconst DatetimePartsSymbol = /* #__PURE__*/ makeSymbol('__datetimeParts');\r\nconst NumberPartsSymbol = /* #__PURE__*/ makeSymbol('__numberParts');\r\nconst EnableEmitter = /* #__PURE__*/ makeSymbol('__enableEmitter');\r\nconst DisableEmitter = /* #__PURE__*/ makeSymbol('__disableEmitter');\r\nconst SetPluralRulesSymbol = makeSymbol('__setPluralRules');\r\nmakeSymbol('__intlifyMeta');\r\nconst InejctWithOption = /* #__PURE__*/ makeSymbol('__injectWithOption');\r\nconst __VUE_I18N_BRIDGE__ =  '__VUE_I18N_BRIDGE__';\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\r\n/**\r\n * Transform flat json in obj to normal json in obj\r\n */\r\nfunction handleFlatJson(obj) {\r\n    // check obj\r\n    if (!isObject(obj)) {\r\n        return obj;\r\n    }\r\n    for (const key in obj) {\r\n        // check key\r\n        if (!hasOwn(obj, key)) {\r\n            continue;\r\n        }\r\n        // handle for normal json\r\n        if (!key.includes('.')) {\r\n            // recursive process value if value is also a object\r\n            if (isObject(obj[key])) {\r\n                handleFlatJson(obj[key]);\r\n            }\r\n        }\r\n        // handle for flat json, transform to normal json\r\n        else {\r\n            // go to the last object\r\n            const subKeys = key.split('.');\r\n            const lastIndex = subKeys.length - 1;\r\n            let currentObj = obj;\r\n            for (let i = 0; i < lastIndex; i++) {\r\n                if (!(subKeys[i] in currentObj)) {\r\n                    currentObj[subKeys[i]] = {};\r\n                }\r\n                currentObj = currentObj[subKeys[i]];\r\n            }\r\n            // update last object value, delete old property\r\n            currentObj[subKeys[lastIndex]] = obj[key];\r\n            delete obj[key];\r\n            // recursive process value if value is also a object\r\n            if (isObject(currentObj[subKeys[lastIndex]])) {\r\n                handleFlatJson(currentObj[subKeys[lastIndex]]);\r\n            }\r\n        }\r\n    }\r\n    return obj;\r\n}\r\nfunction getLocaleMessages(locale, options) {\r\n    const { messages, __i18n, messageResolver, flatJson } = options;\r\n    // prettier-ignore\r\n    const ret = isPlainObject(messages)\r\n        ? messages\r\n        : isArray(__i18n)\r\n            ? {}\r\n            : { [locale]: {} };\r\n    // merge locale messages of i18n custom block\r\n    if (isArray(__i18n)) {\r\n        __i18n.forEach(custom => {\r\n            if ('locale' in custom && 'resource' in custom) {\r\n                const { locale, resource } = custom;\r\n                if (locale) {\r\n                    ret[locale] = ret[locale] || {};\r\n                    deepCopy(resource, ret[locale]);\r\n                }\r\n                else {\r\n                    deepCopy(resource, ret);\r\n                }\r\n            }\r\n            else {\r\n                isString(custom) && deepCopy(JSON.parse(custom), ret);\r\n            }\r\n        });\r\n    }\r\n    // handle messages for flat json\r\n    if (messageResolver == null && flatJson) {\r\n        for (const key in ret) {\r\n            if (hasOwn(ret, key)) {\r\n                handleFlatJson(ret[key]);\r\n            }\r\n        }\r\n    }\r\n    return ret;\r\n}\r\nconst isNotObjectOrIsArray = (val) => !isObject(val) || isArray(val);\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\r\nfunction deepCopy(src, des) {\r\n    // src and des should both be objects, and non of then can be a array\r\n    if (isNotObjectOrIsArray(src) || isNotObjectOrIsArray(des)) {\r\n        throw createI18nError(I18nErrorCodes.INVALID_VALUE);\r\n    }\r\n    for (const key in src) {\r\n        if (hasOwn(src, key)) {\r\n            if (isNotObjectOrIsArray(src[key]) || isNotObjectOrIsArray(des[key])) {\r\n                // replace with src[key] when:\r\n                // src[key] or des[key] is not a object, or\r\n                // src[key] or des[key] is a array\r\n                des[key] = src[key];\r\n            }\r\n            else {\r\n                // src[key] and des[key] are both object, merge them\r\n                deepCopy(src[key], des[key]);\r\n            }\r\n        }\r\n    }\r\n}\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nfunction getComponentOptions(instance) {\r\n    return instance.type ;\r\n}\r\nfunction adjustI18nResources(global, options, componentOptions // eslint-disable-line @typescript-eslint/no-explicit-any\r\n) {\r\n    let messages = isObject(options.messages) ? options.messages : {};\r\n    if ('__i18nGlobal' in componentOptions) {\r\n        messages = getLocaleMessages(global.locale.value, {\r\n            messages,\r\n            __i18n: componentOptions.__i18nGlobal\r\n        });\r\n    }\r\n    // merge locale messages\r\n    const locales = Object.keys(messages);\r\n    if (locales.length) {\r\n        locales.forEach(locale => {\r\n            global.mergeLocaleMessage(locale, messages[locale]);\r\n        });\r\n    }\r\n    {\r\n        // merge datetime formats\r\n        if (isObject(options.datetimeFormats)) {\r\n            const locales = Object.keys(options.datetimeFormats);\r\n            if (locales.length) {\r\n                locales.forEach(locale => {\r\n                    global.mergeDateTimeFormat(locale, options.datetimeFormats[locale]);\r\n                });\r\n            }\r\n        }\r\n        // merge number formats\r\n        if (isObject(options.numberFormats)) {\r\n            const locales = Object.keys(options.numberFormats);\r\n            if (locales.length) {\r\n                locales.forEach(locale => {\r\n                    global.mergeNumberFormat(locale, options.numberFormats[locale]);\r\n                });\r\n            }\r\n        }\r\n    }\r\n}\r\nfunction createTextNode(key) {\r\n    return createVNode(Text, null, key, 0)\r\n        ;\r\n}\r\n/* eslint-enable @typescript-eslint/no-explicit-any */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\r\n// extend VNode interface\r\nconst DEVTOOLS_META = '__INTLIFY_META__';\r\nlet composerID = 0;\r\nfunction defineCoreMissingHandler(missing) {\r\n    return ((ctx, locale, key, type) => {\r\n        return missing(locale, key, getCurrentInstance() || undefined, type);\r\n    });\r\n}\r\n// for Intlify DevTools\r\nconst getMetaInfo =  () => {\r\n    const instance = getCurrentInstance();\r\n    let meta = null; // eslint-disable-line @typescript-eslint/no-explicit-any\r\n    return instance && (meta = getComponentOptions(instance)[DEVTOOLS_META])\r\n        ? { [DEVTOOLS_META]: meta } // eslint-disable-line @typescript-eslint/no-explicit-any\r\n        : null;\r\n};\r\n/**\r\n * Create composer interface factory\r\n *\r\n * @internal\r\n */\r\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\r\nfunction createComposer(options = {}, VueI18nLegacy) {\r\n    const { __root } = options;\r\n    const _isGlobal = __root === undefined;\r\n    let _inheritLocale = isBoolean(options.inheritLocale)\r\n        ? options.inheritLocale\r\n        : true;\r\n    const _locale = ref(\r\n    // prettier-ignore\r\n    __root && _inheritLocale\r\n        ? __root.locale.value\r\n        : isString(options.locale)\r\n            ? options.locale\r\n            : DEFAULT_LOCALE);\r\n    const _fallbackLocale = ref(\r\n    // prettier-ignore\r\n    __root && _inheritLocale\r\n        ? __root.fallbackLocale.value\r\n        : isString(options.fallbackLocale) ||\r\n            isArray(options.fallbackLocale) ||\r\n            isPlainObject(options.fallbackLocale) ||\r\n            options.fallbackLocale === false\r\n            ? options.fallbackLocale\r\n            : _locale.value);\r\n    const _messages = ref(getLocaleMessages(_locale.value, options));\r\n    // prettier-ignore\r\n    const _datetimeFormats = ref(isPlainObject(options.datetimeFormats)\r\n            ? options.datetimeFormats\r\n            : { [_locale.value]: {} })\r\n        ;\r\n    // prettier-ignore\r\n    const _numberFormats = ref(isPlainObject(options.numberFormats)\r\n            ? options.numberFormats\r\n            : { [_locale.value]: {} })\r\n        ;\r\n    // warning suppress options\r\n    // prettier-ignore\r\n    let _missingWarn = __root\r\n        ? __root.missingWarn\r\n        : isBoolean(options.missingWarn) || isRegExp(options.missingWarn)\r\n            ? options.missingWarn\r\n            : true;\r\n    // prettier-ignore\r\n    let _fallbackWarn = __root\r\n        ? __root.fallbackWarn\r\n        : isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn)\r\n            ? options.fallbackWarn\r\n            : true;\r\n    // prettier-ignore\r\n    let _fallbackRoot = __root\r\n        ? __root.fallbackRoot\r\n        : isBoolean(options.fallbackRoot)\r\n            ? options.fallbackRoot\r\n            : true;\r\n    // configure fall back to root\r\n    let _fallbackFormat = !!options.fallbackFormat;\r\n    // runtime missing\r\n    let _missing = isFunction(options.missing) ? options.missing : null;\r\n    let _runtimeMissing = isFunction(options.missing)\r\n        ? defineCoreMissingHandler(options.missing)\r\n        : null;\r\n    // postTranslation handler\r\n    let _postTranslation = isFunction(options.postTranslation)\r\n        ? options.postTranslation\r\n        : null;\r\n    // prettier-ignore\r\n    let _warnHtmlMessage = __root\r\n        ? __root.warnHtmlMessage\r\n        : isBoolean(options.warnHtmlMessage)\r\n            ? options.warnHtmlMessage\r\n            : true;\r\n    let _escapeParameter = !!options.escapeParameter;\r\n    // custom linked modifiers\r\n    // prettier-ignore\r\n    const _modifiers = __root\r\n        ? __root.modifiers\r\n        : isPlainObject(options.modifiers)\r\n            ? options.modifiers\r\n            : {};\r\n    // pluralRules\r\n    let _pluralRules = options.pluralRules || (__root && __root.pluralRules);\r\n    // runtime context\r\n    // eslint-disable-next-line prefer-const\r\n    let _context;\r\n    function getCoreContext() {\r\n        _isGlobal && setFallbackContext(null);\r\n        const ctxOptions = {\r\n            version: VERSION,\r\n            locale: _locale.value,\r\n            fallbackLocale: _fallbackLocale.value,\r\n            messages: _messages.value,\r\n            modifiers: _modifiers,\r\n            pluralRules: _pluralRules,\r\n            missing: _runtimeMissing === null ? undefined : _runtimeMissing,\r\n            missingWarn: _missingWarn,\r\n            fallbackWarn: _fallbackWarn,\r\n            fallbackFormat: _fallbackFormat,\r\n            unresolving: true,\r\n            postTranslation: _postTranslation === null ? undefined : _postTranslation,\r\n            warnHtmlMessage: _warnHtmlMessage,\r\n            escapeParameter: _escapeParameter,\r\n            messageResolver: options.messageResolver,\r\n            __meta: { framework: 'vue' }\r\n        };\r\n        {\r\n            ctxOptions.datetimeFormats = _datetimeFormats.value;\r\n            ctxOptions.numberFormats = _numberFormats.value;\r\n            ctxOptions.__datetimeFormatters = isPlainObject(_context)\r\n                ? _context.__datetimeFormatters\r\n                : undefined;\r\n            ctxOptions.__numberFormatters = isPlainObject(_context)\r\n                ? _context.__numberFormatters\r\n                : undefined;\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            ctxOptions.__v_emitter = isPlainObject(_context)\r\n                ? _context.__v_emitter\r\n                : undefined;\r\n        }\r\n        const ctx = createCoreContext(ctxOptions);\r\n        _isGlobal && setFallbackContext(ctx);\r\n        return ctx;\r\n    }\r\n    _context = getCoreContext();\r\n    updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);\r\n    // track reactivity\r\n    function trackReactivityValues() {\r\n        return [\r\n                _locale.value,\r\n                _fallbackLocale.value,\r\n                _messages.value,\r\n                _datetimeFormats.value,\r\n                _numberFormats.value\r\n            ]\r\n            ;\r\n    }\r\n    // locale\r\n    const locale = computed({\r\n        get: () => _locale.value,\r\n        set: val => {\r\n            _locale.value = val;\r\n            _context.locale = _locale.value;\r\n        }\r\n    });\r\n    // fallbackLocale\r\n    const fallbackLocale = computed({\r\n        get: () => _fallbackLocale.value,\r\n        set: val => {\r\n            _fallbackLocale.value = val;\r\n            _context.fallbackLocale = _fallbackLocale.value;\r\n            updateFallbackLocale(_context, _locale.value, val);\r\n        }\r\n    });\r\n    // messages\r\n    const messages = computed(() => _messages.value);\r\n    // datetimeFormats\r\n    const datetimeFormats = /* #__PURE__*/ computed(() => _datetimeFormats.value);\r\n    // numberFormats\r\n    const numberFormats = /* #__PURE__*/ computed(() => _numberFormats.value);\r\n    // getPostTranslationHandler\r\n    function getPostTranslationHandler() {\r\n        return isFunction(_postTranslation) ? _postTranslation : null;\r\n    }\r\n    // setPostTranslationHandler\r\n    function setPostTranslationHandler(handler) {\r\n        _postTranslation = handler;\r\n        _context.postTranslation = handler;\r\n    }\r\n    // getMissingHandler\r\n    function getMissingHandler() {\r\n        return _missing;\r\n    }\r\n    // setMissingHandler\r\n    function setMissingHandler(handler) {\r\n        if (handler !== null) {\r\n            _runtimeMissing = defineCoreMissingHandler(handler);\r\n        }\r\n        _missing = handler;\r\n        _context.missing = _runtimeMissing;\r\n    }\r\n    function isResolvedTranslateMessage(type, arg // eslint-disable-line @typescript-eslint/no-explicit-any\r\n    ) {\r\n        return type !== 'translate' || !arg.resolvedMessage;\r\n    }\r\n    function wrapWithDeps(fn, argumentParser, warnType, fallbackSuccess, fallbackFail, successCondition) {\r\n        trackReactivityValues(); // track reactive dependency\r\n        // NOTE: experimental !!\r\n        let ret;\r\n        if ((process.env.NODE_ENV !== 'production') || __INTLIFY_PROD_DEVTOOLS__) {\r\n            try {\r\n                setAdditionalMeta(getMetaInfo());\r\n                if (!_isGlobal) {\r\n                    _context.fallbackContext = __root\r\n                        ? getFallbackContext()\r\n                        : undefined;\r\n                }\r\n                ret = fn(_context);\r\n            }\r\n            finally {\r\n                setAdditionalMeta(null);\r\n                if (!_isGlobal) {\r\n                    _context.fallbackContext = undefined;\r\n                }\r\n            }\r\n        }\r\n        else {\r\n            ret = fn(_context);\r\n        }\r\n        if (isNumber(ret) && ret === NOT_REOSLVED) {\r\n            const [key, arg2] = argumentParser();\r\n            if ((process.env.NODE_ENV !== 'production') &&\r\n                __root &&\r\n                isString(key) &&\r\n                isResolvedTranslateMessage(warnType, arg2)) {\r\n                if (_fallbackRoot &&\r\n                    (isTranslateFallbackWarn(_fallbackWarn, key) ||\r\n                        isTranslateMissingWarn(_missingWarn, key))) {\r\n                    warn(getWarnMessage(I18nWarnCodes.FALLBACK_TO_ROOT, {\r\n                        key,\r\n                        type: warnType\r\n                    }));\r\n                }\r\n                // for vue-devtools timeline event\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    const { __v_emitter: emitter } = _context;\r\n                    if (emitter && _fallbackRoot) {\r\n                        emitter.emit(\"fallback\" /* FALBACK */, {\r\n                            type: warnType,\r\n                            key,\r\n                            to: 'global',\r\n                            groupId: `${warnType}:${key}`\r\n                        });\r\n                    }\r\n                }\r\n            }\r\n            return __root && _fallbackRoot\r\n                ? fallbackSuccess(__root)\r\n                : fallbackFail(key);\r\n        }\r\n        else if (successCondition(ret)) {\r\n            return ret;\r\n        }\r\n        else {\r\n            /* istanbul ignore next */\r\n            throw createI18nError(I18nErrorCodes.UNEXPECTED_RETURN_TYPE);\r\n        }\r\n    }\r\n    // t\r\n    function t(...args) {\r\n        return wrapWithDeps(context => Reflect.apply(translate, null, [context, ...args]), () => parseTranslateArgs(...args), 'translate', root => Reflect.apply(root.t, root, [...args]), key => key, val => isString(val));\r\n    }\r\n    // rt\r\n    function rt(...args) {\r\n        const [arg1, arg2, arg3] = args;\r\n        if (arg3 && !isObject(arg3)) {\r\n            throw createI18nError(I18nErrorCodes.INVALID_ARGUMENT);\r\n        }\r\n        return t(...[arg1, arg2, assign({ resolvedMessage: true }, arg3 || {})]);\r\n    }\r\n    // d\r\n    function d(...args) {\r\n        return wrapWithDeps(context => Reflect.apply(datetime, null, [context, ...args]), () => parseDateTimeArgs(...args), 'datetime format', root => Reflect.apply(root.d, root, [...args]), () => MISSING_RESOLVE_VALUE, val => isString(val));\r\n    }\r\n    // n\r\n    function n(...args) {\r\n        return wrapWithDeps(context => Reflect.apply(number, null, [context, ...args]), () => parseNumberArgs(...args), 'number format', root => Reflect.apply(root.n, root, [...args]), () => MISSING_RESOLVE_VALUE, val => isString(val));\r\n    }\r\n    // for custom processor\r\n    function normalize(values) {\r\n        return values.map(val => (isString(val) ? createTextNode(val) : val));\r\n    }\r\n    const interpolate = (val) => val;\r\n    const processor = {\r\n        normalize,\r\n        interpolate,\r\n        type: 'vnode'\r\n    };\r\n    // transrateVNode, using for `i18n-t` component\r\n    function transrateVNode(...args) {\r\n        return wrapWithDeps(context => {\r\n            let ret;\r\n            const _context = context;\r\n            try {\r\n                _context.processor = processor;\r\n                ret = Reflect.apply(translate, null, [_context, ...args]);\r\n            }\r\n            finally {\r\n                _context.processor = null;\r\n            }\r\n            return ret;\r\n        }, () => parseTranslateArgs(...args), 'translate', \r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        root => root[TransrateVNodeSymbol](...args), key => [createTextNode(key)], val => isArray(val));\r\n    }\r\n    // numberParts, using for `i18n-n` component\r\n    function numberParts(...args) {\r\n        return wrapWithDeps(context => Reflect.apply(number, null, [context, ...args]), () => parseNumberArgs(...args), 'number format', \r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        root => root[NumberPartsSymbol](...args), () => [], val => isString(val) || isArray(val));\r\n    }\r\n    // datetimeParts, using for `i18n-d` component\r\n    function datetimeParts(...args) {\r\n        return wrapWithDeps(context => Reflect.apply(datetime, null, [context, ...args]), () => parseDateTimeArgs(...args), 'datetime format', \r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        root => root[DatetimePartsSymbol](...args), () => [], val => isString(val) || isArray(val));\r\n    }\r\n    function setPluralRules(rules) {\r\n        _pluralRules = rules;\r\n        _context.pluralRules = _pluralRules;\r\n    }\r\n    // te\r\n    function te(key, locale) {\r\n        const targetLocale = isString(locale) ? locale : _locale.value;\r\n        const message = getLocaleMessage(targetLocale);\r\n        return _context.messageResolver(message, key) !== null;\r\n    }\r\n    function resolveMessages(key) {\r\n        let messages = null;\r\n        const locales = fallbackWithLocaleChain(_context, _fallbackLocale.value, _locale.value);\r\n        for (let i = 0; i < locales.length; i++) {\r\n            const targetLocaleMessages = _messages.value[locales[i]] || {};\r\n            const messageValue = _context.messageResolver(targetLocaleMessages, key);\r\n            if (messageValue != null) {\r\n                messages = messageValue;\r\n                break;\r\n            }\r\n        }\r\n        return messages;\r\n    }\r\n    // tm\r\n    function tm(key) {\r\n        const messages = resolveMessages(key);\r\n        // prettier-ignore\r\n        return messages != null\r\n            ? messages\r\n            : __root\r\n                ? __root.tm(key) || {}\r\n                : {};\r\n    }\r\n    // getLocaleMessage\r\n    function getLocaleMessage(locale) {\r\n        return (_messages.value[locale] || {});\r\n    }\r\n    // setLocaleMessage\r\n    function setLocaleMessage(locale, message) {\r\n        _messages.value[locale] = message;\r\n        _context.messages = _messages.value;\r\n    }\r\n    // mergeLocaleMessage\r\n    function mergeLocaleMessage(locale, message) {\r\n        _messages.value[locale] = _messages.value[locale] || {};\r\n        deepCopy(message, _messages.value[locale]);\r\n        _context.messages = _messages.value;\r\n    }\r\n    // getDateTimeFormat\r\n    function getDateTimeFormat(locale) {\r\n        return _datetimeFormats.value[locale] || {};\r\n    }\r\n    // setDateTimeFormat\r\n    function setDateTimeFormat(locale, format) {\r\n        _datetimeFormats.value[locale] = format;\r\n        _context.datetimeFormats = _datetimeFormats.value;\r\n        clearDateTimeFormat(_context, locale, format);\r\n    }\r\n    // mergeDateTimeFormat\r\n    function mergeDateTimeFormat(locale, format) {\r\n        _datetimeFormats.value[locale] = assign(_datetimeFormats.value[locale] || {}, format);\r\n        _context.datetimeFormats = _datetimeFormats.value;\r\n        clearDateTimeFormat(_context, locale, format);\r\n    }\r\n    // getNumberFormat\r\n    function getNumberFormat(locale) {\r\n        return _numberFormats.value[locale] || {};\r\n    }\r\n    // setNumberFormat\r\n    function setNumberFormat(locale, format) {\r\n        _numberFormats.value[locale] = format;\r\n        _context.numberFormats = _numberFormats.value;\r\n        clearNumberFormat(_context, locale, format);\r\n    }\r\n    // mergeNumberFormat\r\n    function mergeNumberFormat(locale, format) {\r\n        _numberFormats.value[locale] = assign(_numberFormats.value[locale] || {}, format);\r\n        _context.numberFormats = _numberFormats.value;\r\n        clearNumberFormat(_context, locale, format);\r\n    }\r\n    // for debug\r\n    composerID++;\r\n    // watch root locale & fallbackLocale\r\n    if (__root && inBrowser) {\r\n        watch(__root.locale, (val) => {\r\n            if (_inheritLocale) {\r\n                _locale.value = val;\r\n                _context.locale = val;\r\n                updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);\r\n            }\r\n        });\r\n        watch(__root.fallbackLocale, (val) => {\r\n            if (_inheritLocale) {\r\n                _fallbackLocale.value = val;\r\n                _context.fallbackLocale = val;\r\n                updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);\r\n            }\r\n        });\r\n    }\r\n    // define basic composition API!\r\n    const composer = {\r\n        id: composerID,\r\n        locale,\r\n        fallbackLocale,\r\n        get inheritLocale() {\r\n            return _inheritLocale;\r\n        },\r\n        set inheritLocale(val) {\r\n            _inheritLocale = val;\r\n            if (val && __root) {\r\n                _locale.value = __root.locale.value;\r\n                _fallbackLocale.value = __root.fallbackLocale.value;\r\n                updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);\r\n            }\r\n        },\r\n        get availableLocales() {\r\n            return Object.keys(_messages.value).sort();\r\n        },\r\n        messages,\r\n        get modifiers() {\r\n            return _modifiers;\r\n        },\r\n        get pluralRules() {\r\n            return _pluralRules || {};\r\n        },\r\n        get isGlobal() {\r\n            return _isGlobal;\r\n        },\r\n        get missingWarn() {\r\n            return _missingWarn;\r\n        },\r\n        set missingWarn(val) {\r\n            _missingWarn = val;\r\n            _context.missingWarn = _missingWarn;\r\n        },\r\n        get fallbackWarn() {\r\n            return _fallbackWarn;\r\n        },\r\n        set fallbackWarn(val) {\r\n            _fallbackWarn = val;\r\n            _context.fallbackWarn = _fallbackWarn;\r\n        },\r\n        get fallbackRoot() {\r\n            return _fallbackRoot;\r\n        },\r\n        set fallbackRoot(val) {\r\n            _fallbackRoot = val;\r\n        },\r\n        get fallbackFormat() {\r\n            return _fallbackFormat;\r\n        },\r\n        set fallbackFormat(val) {\r\n            _fallbackFormat = val;\r\n            _context.fallbackFormat = _fallbackFormat;\r\n        },\r\n        get warnHtmlMessage() {\r\n            return _warnHtmlMessage;\r\n        },\r\n        set warnHtmlMessage(val) {\r\n            _warnHtmlMessage = val;\r\n            _context.warnHtmlMessage = val;\r\n        },\r\n        get escapeParameter() {\r\n            return _escapeParameter;\r\n        },\r\n        set escapeParameter(val) {\r\n            _escapeParameter = val;\r\n            _context.escapeParameter = val;\r\n        },\r\n        t,\r\n        getLocaleMessage,\r\n        setLocaleMessage,\r\n        mergeLocaleMessage,\r\n        getPostTranslationHandler,\r\n        setPostTranslationHandler,\r\n        getMissingHandler,\r\n        setMissingHandler,\r\n        [SetPluralRulesSymbol]: setPluralRules\r\n    };\r\n    {\r\n        composer.datetimeFormats = datetimeFormats;\r\n        composer.numberFormats = numberFormats;\r\n        composer.rt = rt;\r\n        composer.te = te;\r\n        composer.tm = tm;\r\n        composer.d = d;\r\n        composer.n = n;\r\n        composer.getDateTimeFormat = getDateTimeFormat;\r\n        composer.setDateTimeFormat = setDateTimeFormat;\r\n        composer.mergeDateTimeFormat = mergeDateTimeFormat;\r\n        composer.getNumberFormat = getNumberFormat;\r\n        composer.setNumberFormat = setNumberFormat;\r\n        composer.mergeNumberFormat = mergeNumberFormat;\r\n        composer[InejctWithOption] = options.__injectWithOption;\r\n        composer[TransrateVNodeSymbol] = transrateVNode;\r\n        composer[DatetimePartsSymbol] = datetimeParts;\r\n        composer[NumberPartsSymbol] = numberParts;\r\n    }\r\n    // for vue-devtools timeline event\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        composer[EnableEmitter] = (emitter) => {\r\n            _context.__v_emitter = emitter;\r\n        };\r\n        composer[DisableEmitter] = () => {\r\n            _context.__v_emitter = undefined;\r\n        };\r\n    }\r\n    return composer;\r\n}\r\n/* eslint-enable @typescript-eslint/no-explicit-any */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\r\n/**\r\n * Convert to I18n Composer Options from VueI18n Options\r\n *\r\n * @internal\r\n */\r\nfunction convertComposerOptions(options) {\r\n    const locale = isString(options.locale) ? options.locale : DEFAULT_LOCALE;\r\n    const fallbackLocale = isString(options.fallbackLocale) ||\r\n        isArray(options.fallbackLocale) ||\r\n        isPlainObject(options.fallbackLocale) ||\r\n        options.fallbackLocale === false\r\n        ? options.fallbackLocale\r\n        : locale;\r\n    const missing = isFunction(options.missing) ? options.missing : undefined;\r\n    const missingWarn = isBoolean(options.silentTranslationWarn) ||\r\n        isRegExp(options.silentTranslationWarn)\r\n        ? !options.silentTranslationWarn\r\n        : true;\r\n    const fallbackWarn = isBoolean(options.silentFallbackWarn) ||\r\n        isRegExp(options.silentFallbackWarn)\r\n        ? !options.silentFallbackWarn\r\n        : true;\r\n    const fallbackRoot = isBoolean(options.fallbackRoot)\r\n        ? options.fallbackRoot\r\n        : true;\r\n    const fallbackFormat = !!options.formatFallbackMessages;\r\n    const modifiers = isPlainObject(options.modifiers) ? options.modifiers : {};\r\n    const pluralizationRules = options.pluralizationRules;\r\n    const postTranslation = isFunction(options.postTranslation)\r\n        ? options.postTranslation\r\n        : undefined;\r\n    const warnHtmlMessage = isString(options.warnHtmlInMessage)\r\n        ? options.warnHtmlInMessage !== 'off'\r\n        : true;\r\n    const escapeParameter = !!options.escapeParameterHtml;\r\n    const inheritLocale = isBoolean(options.sync) ? options.sync : true;\r\n    if ((process.env.NODE_ENV !== 'production') && options.formatter) {\r\n        warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_FORMATTER));\r\n    }\r\n    if ((process.env.NODE_ENV !== 'production') && options.preserveDirectiveContent) {\r\n        warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE));\r\n    }\r\n    let messages = options.messages;\r\n    if (isPlainObject(options.sharedMessages)) {\r\n        const sharedMessages = options.sharedMessages;\r\n        const locales = Object.keys(sharedMessages);\r\n        messages = locales.reduce((messages, locale) => {\r\n            const message = messages[locale] || (messages[locale] = {});\r\n            assign(message, sharedMessages[locale]);\r\n            return messages;\r\n        }, (messages || {}));\r\n    }\r\n    const { __i18n, __root, __injectWithOption } = options;\r\n    const datetimeFormats = options.datetimeFormats;\r\n    const numberFormats = options.numberFormats;\r\n    const flatJson = options.flatJson;\r\n    return {\r\n        locale,\r\n        fallbackLocale,\r\n        messages,\r\n        flatJson,\r\n        datetimeFormats,\r\n        numberFormats,\r\n        missing,\r\n        missingWarn,\r\n        fallbackWarn,\r\n        fallbackRoot,\r\n        fallbackFormat,\r\n        modifiers,\r\n        pluralRules: pluralizationRules,\r\n        postTranslation,\r\n        warnHtmlMessage,\r\n        escapeParameter,\r\n        messageResolver: options.messageResolver,\r\n        inheritLocale,\r\n        __i18n,\r\n        __root,\r\n        __injectWithOption\r\n    };\r\n}\r\n/**\r\n * create VueI18n interface factory\r\n *\r\n * @internal\r\n */\r\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\r\nfunction createVueI18n(options = {}, VueI18nLegacy) {\r\n    {\r\n        const composer = createComposer(convertComposerOptions(options));\r\n        // defines VueI18n\r\n        const vueI18n = {\r\n            // id\r\n            id: composer.id,\r\n            // locale\r\n            get locale() {\r\n                return composer.locale.value;\r\n            },\r\n            set locale(val) {\r\n                composer.locale.value = val;\r\n            },\r\n            // fallbackLocale\r\n            get fallbackLocale() {\r\n                return composer.fallbackLocale.value;\r\n            },\r\n            set fallbackLocale(val) {\r\n                composer.fallbackLocale.value = val;\r\n            },\r\n            // messages\r\n            get messages() {\r\n                return composer.messages.value;\r\n            },\r\n            // datetimeFormats\r\n            get datetimeFormats() {\r\n                return composer.datetimeFormats.value;\r\n            },\r\n            // numberFormats\r\n            get numberFormats() {\r\n                return composer.numberFormats.value;\r\n            },\r\n            // availableLocales\r\n            get availableLocales() {\r\n                return composer.availableLocales;\r\n            },\r\n            // formatter\r\n            get formatter() {\r\n                (process.env.NODE_ENV !== 'production') && warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_FORMATTER));\r\n                // dummy\r\n                return {\r\n                    interpolate() {\r\n                        return [];\r\n                    }\r\n                };\r\n            },\r\n            set formatter(val) {\r\n                (process.env.NODE_ENV !== 'production') && warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_FORMATTER));\r\n            },\r\n            // missing\r\n            get missing() {\r\n                return composer.getMissingHandler();\r\n            },\r\n            set missing(handler) {\r\n                composer.setMissingHandler(handler);\r\n            },\r\n            // silentTranslationWarn\r\n            get silentTranslationWarn() {\r\n                return isBoolean(composer.missingWarn)\r\n                    ? !composer.missingWarn\r\n                    : composer.missingWarn;\r\n            },\r\n            set silentTranslationWarn(val) {\r\n                composer.missingWarn = isBoolean(val) ? !val : val;\r\n            },\r\n            // silentFallbackWarn\r\n            get silentFallbackWarn() {\r\n                return isBoolean(composer.fallbackWarn)\r\n                    ? !composer.fallbackWarn\r\n                    : composer.fallbackWarn;\r\n            },\r\n            set silentFallbackWarn(val) {\r\n                composer.fallbackWarn = isBoolean(val) ? !val : val;\r\n            },\r\n            // modifiers\r\n            get modifiers() {\r\n                return composer.modifiers;\r\n            },\r\n            // formatFallbackMessages\r\n            get formatFallbackMessages() {\r\n                return composer.fallbackFormat;\r\n            },\r\n            set formatFallbackMessages(val) {\r\n                composer.fallbackFormat = val;\r\n            },\r\n            // postTranslation\r\n            get postTranslation() {\r\n                return composer.getPostTranslationHandler();\r\n            },\r\n            set postTranslation(handler) {\r\n                composer.setPostTranslationHandler(handler);\r\n            },\r\n            // sync\r\n            get sync() {\r\n                return composer.inheritLocale;\r\n            },\r\n            set sync(val) {\r\n                composer.inheritLocale = val;\r\n            },\r\n            // warnInHtmlMessage\r\n            get warnHtmlInMessage() {\r\n                return composer.warnHtmlMessage ? 'warn' : 'off';\r\n            },\r\n            set warnHtmlInMessage(val) {\r\n                composer.warnHtmlMessage = val !== 'off';\r\n            },\r\n            // escapeParameterHtml\r\n            get escapeParameterHtml() {\r\n                return composer.escapeParameter;\r\n            },\r\n            set escapeParameterHtml(val) {\r\n                composer.escapeParameter = val;\r\n            },\r\n            // preserveDirectiveContent\r\n            get preserveDirectiveContent() {\r\n                (process.env.NODE_ENV !== 'production') &&\r\n                    warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE));\r\n                return true;\r\n            },\r\n            set preserveDirectiveContent(val) {\r\n                (process.env.NODE_ENV !== 'production') &&\r\n                    warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE));\r\n            },\r\n            // pluralizationRules\r\n            get pluralizationRules() {\r\n                return composer.pluralRules || {};\r\n            },\r\n            // for internal\r\n            __composer: composer,\r\n            // t\r\n            t(...args) {\r\n                const [arg1, arg2, arg3] = args;\r\n                const options = {};\r\n                let list = null;\r\n                let named = null;\r\n                if (!isString(arg1)) {\r\n                    throw createI18nError(I18nErrorCodes.INVALID_ARGUMENT);\r\n                }\r\n                const key = arg1;\r\n                if (isString(arg2)) {\r\n                    options.locale = arg2;\r\n                }\r\n                else if (isArray(arg2)) {\r\n                    list = arg2;\r\n                }\r\n                else if (isPlainObject(arg2)) {\r\n                    named = arg2;\r\n                }\r\n                if (isArray(arg3)) {\r\n                    list = arg3;\r\n                }\r\n                else if (isPlainObject(arg3)) {\r\n                    named = arg3;\r\n                }\r\n                // return composer.t(key, (list || named || {}) as any, options)\r\n                return Reflect.apply(composer.t, composer, [\r\n                    key,\r\n                    (list || named || {}),\r\n                    options\r\n                ]);\r\n            },\r\n            rt(...args) {\r\n                return Reflect.apply(composer.rt, composer, [...args]);\r\n            },\r\n            // tc\r\n            tc(...args) {\r\n                const [arg1, arg2, arg3] = args;\r\n                const options = { plural: 1 };\r\n                let list = null;\r\n                let named = null;\r\n                if (!isString(arg1)) {\r\n                    throw createI18nError(I18nErrorCodes.INVALID_ARGUMENT);\r\n                }\r\n                const key = arg1;\r\n                if (isString(arg2)) {\r\n                    options.locale = arg2;\r\n                }\r\n                else if (isNumber(arg2)) {\r\n                    options.plural = arg2;\r\n                }\r\n                else if (isArray(arg2)) {\r\n                    list = arg2;\r\n                }\r\n                else if (isPlainObject(arg2)) {\r\n                    named = arg2;\r\n                }\r\n                if (isString(arg3)) {\r\n                    options.locale = arg3;\r\n                }\r\n                else if (isArray(arg3)) {\r\n                    list = arg3;\r\n                }\r\n                else if (isPlainObject(arg3)) {\r\n                    named = arg3;\r\n                }\r\n                // return composer.t(key, (list || named || {}) as any, options)\r\n                return Reflect.apply(composer.t, composer, [\r\n                    key,\r\n                    (list || named || {}),\r\n                    options\r\n                ]);\r\n            },\r\n            // te\r\n            te(key, locale) {\r\n                return composer.te(key, locale);\r\n            },\r\n            // tm\r\n            tm(key) {\r\n                return composer.tm(key);\r\n            },\r\n            // getLocaleMessage\r\n            getLocaleMessage(locale) {\r\n                return composer.getLocaleMessage(locale);\r\n            },\r\n            // setLocaleMessage\r\n            setLocaleMessage(locale, message) {\r\n                composer.setLocaleMessage(locale, message);\r\n            },\r\n            // mergeLocaleMessage\r\n            mergeLocaleMessage(locale, message) {\r\n                composer.mergeLocaleMessage(locale, message);\r\n            },\r\n            // d\r\n            d(...args) {\r\n                return Reflect.apply(composer.d, composer, [...args]);\r\n            },\r\n            // getDateTimeFormat\r\n            getDateTimeFormat(locale) {\r\n                return composer.getDateTimeFormat(locale);\r\n            },\r\n            // setDateTimeFormat\r\n            setDateTimeFormat(locale, format) {\r\n                composer.setDateTimeFormat(locale, format);\r\n            },\r\n            // mergeDateTimeFormat\r\n            mergeDateTimeFormat(locale, format) {\r\n                composer.mergeDateTimeFormat(locale, format);\r\n            },\r\n            // n\r\n            n(...args) {\r\n                return Reflect.apply(composer.n, composer, [...args]);\r\n            },\r\n            // getNumberFormat\r\n            getNumberFormat(locale) {\r\n                return composer.getNumberFormat(locale);\r\n            },\r\n            // setNumberFormat\r\n            setNumberFormat(locale, format) {\r\n                composer.setNumberFormat(locale, format);\r\n            },\r\n            // mergeNumberFormat\r\n            mergeNumberFormat(locale, format) {\r\n                composer.mergeNumberFormat(locale, format);\r\n            },\r\n            // getChoiceIndex\r\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n            getChoiceIndex(choice, choicesLength) {\r\n                (process.env.NODE_ENV !== 'production') &&\r\n                    warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_GET_CHOICE_INDEX));\r\n                return -1;\r\n            },\r\n            // for internal\r\n            __onComponentInstanceCreated(target) {\r\n                const { componentInstanceCreatedListener } = options;\r\n                if (componentInstanceCreatedListener) {\r\n                    componentInstanceCreatedListener(target, vueI18n);\r\n                }\r\n            }\r\n        };\r\n        // for vue-devtools timeline event\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            vueI18n.__enableEmitter = (emitter) => {\r\n                const __composer = composer;\r\n                __composer[EnableEmitter] && __composer[EnableEmitter](emitter);\r\n            };\r\n            vueI18n.__disableEmitter = () => {\r\n                const __composer = composer;\r\n                __composer[DisableEmitter] && __composer[DisableEmitter]();\r\n            };\r\n        }\r\n        return vueI18n;\r\n    }\r\n}\r\n/* eslint-enable @typescript-eslint/no-explicit-any */\n\nconst baseFormatProps = {\r\n    tag: {\r\n        type: [String, Object]\r\n    },\r\n    locale: {\r\n        type: String\r\n    },\r\n    scope: {\r\n        type: String,\r\n        // NOTE: avoid https://github.com/microsoft/rushstack/issues/1050\r\n        validator: (val /* ComponetI18nScope */) => val === 'parent' || val === 'global',\r\n        default: 'parent' /* ComponetI18nScope */\r\n    },\r\n    i18n: {\r\n        type: Object\r\n    }\r\n};\n\nfunction getInterpolateArg(\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n{ slots }, // SetupContext,\r\nkeys) {\r\n    if (keys.length === 1 && keys[0] === 'default') {\r\n        // default slot with list\r\n        const ret = slots.default ? slots.default() : [];\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        return ret.reduce((slot, current) => {\r\n            return (slot = [\r\n                ...slot,\r\n                ...(isArray(current.children) ? current.children : [current])\r\n            ]);\r\n        }, []);\r\n    }\r\n    else {\r\n        // named slots\r\n        return keys.reduce((arg, key) => {\r\n            const slot = slots[key];\r\n            if (slot) {\r\n                arg[key] = slot();\r\n            }\r\n            return arg;\r\n        }, {});\r\n    }\r\n}\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nfunction getFragmentableTag(tag) {\r\n    return Fragment ;\r\n}\n\n/**\r\n * Translation Component\r\n *\r\n * @remarks\r\n * See the following items for property about details\r\n *\r\n * @VueI18nSee [TranslationProps](component#translationprops)\r\n * @VueI18nSee [BaseFormatProps](component#baseformatprops)\r\n * @VueI18nSee [Component Interpolation](../guide/advanced/component)\r\n *\r\n * @example\r\n * ```html\r\n * <div id=\"app\">\r\n *   <!-- ... -->\r\n *   <i18n path=\"term\" tag=\"label\" for=\"tos\">\r\n *     <a :href=\"url\" target=\"_blank\">{{ $t('tos') }}</a>\r\n *   </i18n>\r\n *   <!-- ... -->\r\n * </div>\r\n * ```\r\n * ```js\r\n * import { createApp } from 'vue'\r\n * import { createI18n } from 'vue-i18n'\r\n *\r\n * const messages = {\r\n *   en: {\r\n *     tos: 'Term of Service',\r\n *     term: 'I accept xxx {0}.'\r\n *   },\r\n *   ja: {\r\n *     tos: '利用規約',\r\n *     term: '私は xxx の{0}に同意します。'\r\n *   }\r\n * }\r\n *\r\n * const i18n = createI18n({\r\n *   locale: 'en',\r\n *   messages\r\n * })\r\n *\r\n * const app = createApp({\r\n *   data: {\r\n *     url: '/term'\r\n *   }\r\n * }).use(i18n).mount('#app')\r\n * ```\r\n *\r\n * @VueI18nComponent\r\n */\r\nconst Translation =  /* defineComponent */ {\r\n    /* eslint-disable */\r\n    name: 'i18n-t',\r\n    props: assign({\r\n        keypath: {\r\n            type: String,\r\n            required: true\r\n        },\r\n        plural: {\r\n            type: [Number, String],\r\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n            validator: (val) => isNumber(val) || !isNaN(val)\r\n        }\r\n    }, baseFormatProps),\r\n    /* eslint-enable */\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    setup(props, context) {\r\n        const { slots, attrs } = context;\r\n        // NOTE: avoid https://github.com/microsoft/rushstack/issues/1050\r\n        const i18n = props.i18n ||\r\n            useI18n({\r\n                useScope: props.scope,\r\n                __useComponent: true\r\n            });\r\n        const keys = Object.keys(slots).filter(key => key !== '_');\r\n        return () => {\r\n            const options = {};\r\n            if (props.locale) {\r\n                options.locale = props.locale;\r\n            }\r\n            if (props.plural !== undefined) {\r\n                options.plural = isString(props.plural) ? +props.plural : props.plural;\r\n            }\r\n            const arg = getInterpolateArg(context, keys);\r\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n            const children = i18n[TransrateVNodeSymbol](props.keypath, arg, options);\r\n            const assignedAttrs = assign({}, attrs);\r\n            const tag = isString(props.tag) || isObject(props.tag)\r\n                ? props.tag\r\n                : getFragmentableTag();\r\n            return h(tag, assignedAttrs, children);\r\n        };\r\n    }\r\n};\n\nfunction isVNode(target) {\r\n    return isArray(target) && !isString(target[0]);\r\n}\r\nfunction renderFormatter(props, context, slotKeys, partFormatter) {\r\n    const { slots, attrs } = context;\r\n    return () => {\r\n        const options = { part: true };\r\n        let overrides = {};\r\n        if (props.locale) {\r\n            options.locale = props.locale;\r\n        }\r\n        if (isString(props.format)) {\r\n            options.key = props.format;\r\n        }\r\n        else if (isObject(props.format)) {\r\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n            if (isString(props.format.key)) {\r\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n                options.key = props.format.key;\r\n            }\r\n            // Filter out number format options only\r\n            overrides = Object.keys(props.format).reduce((options, prop) => {\r\n                return slotKeys.includes(prop)\r\n                    ? assign({}, options, { [prop]: props.format[prop] }) // eslint-disable-line @typescript-eslint/no-explicit-any\r\n                    : options;\r\n            }, {});\r\n        }\r\n        const parts = partFormatter(...[props.value, options, overrides]);\r\n        let children = [options.key];\r\n        if (isArray(parts)) {\r\n            children = parts.map((part, index) => {\r\n                const slot = slots[part.type];\r\n                const node = slot\r\n                    ? slot({ [part.type]: part.value, index, parts })\r\n                    : [part.value];\r\n                if (isVNode(node)) {\r\n                    node[0].key = `${part.type}-${index}`;\r\n                }\r\n                return node;\r\n            });\r\n        }\r\n        else if (isString(parts)) {\r\n            children = [parts];\r\n        }\r\n        const assignedAttrs = assign({}, attrs);\r\n        const tag = isString(props.tag) || isObject(props.tag)\r\n            ? props.tag\r\n            : getFragmentableTag();\r\n        return h(tag, assignedAttrs, children);\r\n    };\r\n}\n\nconst NUMBER_FORMAT_KEYS = [\r\n    'localeMatcher',\r\n    'style',\r\n    'unit',\r\n    'unitDisplay',\r\n    'currency',\r\n    'currencyDisplay',\r\n    'useGrouping',\r\n    'numberingSystem',\r\n    'minimumIntegerDigits',\r\n    'minimumFractionDigits',\r\n    'maximumFractionDigits',\r\n    'minimumSignificantDigits',\r\n    'maximumSignificantDigits',\r\n    'notation',\r\n    'formatMatcher'\r\n];\r\n/**\r\n * Number Format Component\r\n *\r\n * @remarks\r\n * See the following items for property about details\r\n *\r\n * @VueI18nSee [FormattableProps](component#formattableprops)\r\n * @VueI18nSee [BaseFormatProps](component#baseformatprops)\r\n * @VueI18nSee [Custom Formatting](../guide/essentials/number#custom-formatting)\r\n *\r\n * @VueI18nDanger\r\n * Not supported IE, due to no support `Intl.NumberFormat#formatToParts` in [IE](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/formatToParts)\r\n *\r\n * If you want to use it, you need to use [polyfill](https://github.com/formatjs/formatjs/tree/main/packages/intl-numberformat)\r\n *\r\n * @VueI18nComponent\r\n */\r\nconst NumberFormat =  /* defineComponent */ {\r\n    /* eslint-disable */\r\n    name: 'i18n-n',\r\n    props: assign({\r\n        value: {\r\n            type: Number,\r\n            required: true\r\n        },\r\n        format: {\r\n            type: [String, Object]\r\n        }\r\n    }, baseFormatProps),\r\n    /* eslint-enable */\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    setup(props, context) {\r\n        const i18n = props.i18n ||\r\n            useI18n({ useScope: 'parent', __useComponent: true });\r\n        return renderFormatter(props, context, NUMBER_FORMAT_KEYS, (...args) => \r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        i18n[NumberPartsSymbol](...args));\r\n    }\r\n};\n\nconst DATETIME_FORMAT_KEYS = [\r\n    'dateStyle',\r\n    'timeStyle',\r\n    'fractionalSecondDigits',\r\n    'calendar',\r\n    'dayPeriod',\r\n    'numberingSystem',\r\n    'localeMatcher',\r\n    'timeZone',\r\n    'hour12',\r\n    'hourCycle',\r\n    'formatMatcher',\r\n    'weekday',\r\n    'era',\r\n    'year',\r\n    'month',\r\n    'day',\r\n    'hour',\r\n    'minute',\r\n    'second',\r\n    'timeZoneName'\r\n];\r\n/**\r\n * Datetime Format Component\r\n *\r\n * @remarks\r\n * See the following items for property about details\r\n *\r\n * @VueI18nSee [FormattableProps](component#formattableprops)\r\n * @VueI18nSee [BaseFormatProps](component#baseformatprops)\r\n * @VueI18nSee [Custom Formatting](../guide/essentials/datetime#custom-formatting)\r\n *\r\n * @VueI18nDanger\r\n * Not supported IE, due to no support `Intl.DateTimeFormat#formatToParts` in [IE](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatToParts)\r\n *\r\n * If you want to use it, you need to use [polyfill](https://github.com/formatjs/formatjs/tree/main/packages/intl-datetimeformat)\r\n *\r\n * @VueI18nComponent\r\n */\r\nconst DatetimeFormat =  /*defineComponent */ {\r\n    /* eslint-disable */\r\n    name: 'i18n-d',\r\n    props: assign({\r\n        value: {\r\n            type: [Number, Date],\r\n            required: true\r\n        },\r\n        format: {\r\n            type: [String, Object]\r\n        }\r\n    }, baseFormatProps),\r\n    /* eslint-enable */\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    setup(props, context) {\r\n        const i18n = props.i18n ||\r\n            useI18n({ useScope: 'parent', __useComponent: true });\r\n        return renderFormatter(props, context, DATETIME_FORMAT_KEYS, (...args) => \r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        i18n[DatetimePartsSymbol](...args));\r\n    }\r\n};\n\nfunction getComposer$2(i18n, instance) {\r\n    const i18nInternal = i18n;\r\n    if (i18n.mode === 'composition') {\r\n        return (i18nInternal.__getInstance(instance) || i18n.global);\r\n    }\r\n    else {\r\n        const vueI18n = i18nInternal.__getInstance(instance);\r\n        return vueI18n != null\r\n            ? vueI18n.__composer\r\n            : i18n.global.__composer;\r\n    }\r\n}\r\nfunction vTDirective(i18n) {\r\n    const bind = (el, { instance, value, modifiers }) => {\r\n        /* istanbul ignore if */\r\n        if (!instance || !instance.$) {\r\n            throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);\r\n        }\r\n        const composer = getComposer$2(i18n, instance.$);\r\n        if ((process.env.NODE_ENV !== 'production') && modifiers.preserve) {\r\n            warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE));\r\n        }\r\n        const parsedValue = parseValue(value);\r\n        // el.textContent = composer.t(...makeParams(parsedValue))\r\n        el.textContent = Reflect.apply(composer.t, composer, [\r\n            ...makeParams(parsedValue)\r\n        ]);\r\n    };\r\n    return {\r\n        beforeMount: bind,\r\n        beforeUpdate: bind\r\n    };\r\n}\r\nfunction parseValue(value) {\r\n    if (isString(value)) {\r\n        return { path: value };\r\n    }\r\n    else if (isPlainObject(value)) {\r\n        if (!('path' in value)) {\r\n            throw createI18nError(I18nErrorCodes.REQUIRED_VALUE, 'path');\r\n        }\r\n        return value;\r\n    }\r\n    else {\r\n        throw createI18nError(I18nErrorCodes.INVALID_VALUE);\r\n    }\r\n}\r\nfunction makeParams(value) {\r\n    const { path, locale, args, choice, plural } = value;\r\n    const options = {};\r\n    const named = args || {};\r\n    if (isString(locale)) {\r\n        options.locale = locale;\r\n    }\r\n    if (isNumber(choice)) {\r\n        options.plural = choice;\r\n    }\r\n    if (isNumber(plural)) {\r\n        options.plural = plural;\r\n    }\r\n    return [path, named, options];\r\n}\n\nfunction apply(app, i18n, ...options) {\r\n    const pluginOptions = isPlainObject(options[0])\r\n        ? options[0]\r\n        : {};\r\n    const useI18nComponentName = !!pluginOptions.useI18nComponentName;\r\n    const globalInstall = isBoolean(pluginOptions.globalInstall)\r\n        ? pluginOptions.globalInstall\r\n        : true;\r\n    if ((process.env.NODE_ENV !== 'production') && globalInstall && useI18nComponentName) {\r\n        warn(getWarnMessage(I18nWarnCodes.COMPONENT_NAME_LEGACY_COMPATIBLE, {\r\n            name: Translation.name\r\n        }));\r\n    }\r\n    if (globalInstall) {\r\n        // install components\r\n        app.component(!useI18nComponentName ? Translation.name : 'i18n', Translation);\r\n        app.component(NumberFormat.name, NumberFormat);\r\n        app.component(DatetimeFormat.name, DatetimeFormat);\r\n    }\r\n    // install directive\r\n    {\r\n        app.directive('t', vTDirective(i18n));\r\n    }\r\n}\n\nconst VUE_I18N_COMPONENT_TYPES = 'vue-i18n: composer properties';\r\nlet devtoolsApi;\r\nasync function enableDevTools(app, i18n) {\r\n    return new Promise((resolve, reject) => {\r\n        try {\r\n            setupDevtoolsPlugin({\r\n                id: \"vue-devtools-plugin-vue-i18n\" /* PLUGIN */,\r\n                label: VueDevToolsLabels[\"vue-devtools-plugin-vue-i18n\" /* PLUGIN */],\r\n                packageName: 'vue-i18n',\r\n                homepage: 'https://vue-i18n.intlify.dev',\r\n                logo: 'https://vue-i18n.intlify.dev/vue-i18n-devtools-logo.png',\r\n                componentStateTypes: [VUE_I18N_COMPONENT_TYPES],\r\n                app\r\n            }, api => {\r\n                devtoolsApi = api;\r\n                api.on.visitComponentTree(({ componentInstance, treeNode }) => {\r\n                    updateComponentTreeTags(componentInstance, treeNode, i18n);\r\n                });\r\n                api.on.inspectComponent(({ componentInstance, instanceData }) => {\r\n                    if (componentInstance.vnode.el &&\r\n                        componentInstance.vnode.el.__VUE_I18N__ &&\r\n                        instanceData) {\r\n                        if (i18n.mode === 'legacy') {\r\n                            // ignore global scope on legacy mode\r\n                            if (componentInstance.vnode.el.__VUE_I18N__ !==\r\n                                i18n.global.__composer) {\r\n                                inspectComposer(instanceData, componentInstance.vnode.el.__VUE_I18N__);\r\n                            }\r\n                        }\r\n                        else {\r\n                            inspectComposer(instanceData, componentInstance.vnode.el.__VUE_I18N__);\r\n                        }\r\n                    }\r\n                });\r\n                api.addInspector({\r\n                    id: \"vue-i18n-resource-inspector\" /* CUSTOM_INSPECTOR */,\r\n                    label: VueDevToolsLabels[\"vue-i18n-resource-inspector\" /* CUSTOM_INSPECTOR */],\r\n                    icon: 'language',\r\n                    treeFilterPlaceholder: VueDevToolsPlaceholders[\"vue-i18n-resource-inspector\" /* CUSTOM_INSPECTOR */]\r\n                });\r\n                api.on.getInspectorTree(payload => {\r\n                    if (payload.app === app &&\r\n                        payload.inspectorId === \"vue-i18n-resource-inspector\" /* CUSTOM_INSPECTOR */) {\r\n                        registerScope(payload, i18n);\r\n                    }\r\n                });\r\n                const roots = new Map();\r\n                api.on.getInspectorState(async (payload) => {\r\n                    if (payload.app === app &&\r\n                        payload.inspectorId === \"vue-i18n-resource-inspector\" /* CUSTOM_INSPECTOR */) {\r\n                        api.unhighlightElement();\r\n                        inspectScope(payload, i18n);\r\n                        if (payload.nodeId === 'global') {\r\n                            if (!roots.has(payload.app)) {\r\n                                const [root] = await api.getComponentInstances(payload.app);\r\n                                roots.set(payload.app, root);\r\n                            }\r\n                            api.highlightElement(roots.get(payload.app));\r\n                        }\r\n                        else {\r\n                            const instance = getComponentInstance(payload.nodeId, i18n);\r\n                            instance && api.highlightElement(instance);\r\n                        }\r\n                    }\r\n                });\r\n                api.on.editInspectorState(payload => {\r\n                    if (payload.app === app &&\r\n                        payload.inspectorId === \"vue-i18n-resource-inspector\" /* CUSTOM_INSPECTOR */) {\r\n                        editScope(payload, i18n);\r\n                    }\r\n                });\r\n                api.addTimelineLayer({\r\n                    id: \"vue-i18n-timeline\" /* TIMELINE */,\r\n                    label: VueDevToolsLabels[\"vue-i18n-timeline\" /* TIMELINE */],\r\n                    color: VueDevToolsTimelineColors[\"vue-i18n-timeline\" /* TIMELINE */]\r\n                });\r\n                resolve(true);\r\n            });\r\n        }\r\n        catch (e) {\r\n            console.error(e);\r\n            reject(false);\r\n        }\r\n    });\r\n}\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nfunction getI18nScopeLable(instance) {\r\n    return (instance.type.name ||\r\n        instance.type.displayName ||\r\n        instance.type.__file ||\r\n        'Anonymous');\r\n}\r\nfunction updateComponentTreeTags(instance, // eslint-disable-line @typescript-eslint/no-explicit-any\r\ntreeNode, i18n) {\r\n    // prettier-ignore\r\n    const global = i18n.mode === 'composition'\r\n        ? i18n.global\r\n        : i18n.global.__composer;\r\n    if (instance && instance.vnode.el && instance.vnode.el.__VUE_I18N__) {\r\n        // add custom tags local scope only\r\n        if (instance.vnode.el.__VUE_I18N__ !== global) {\r\n            const tag = {\r\n                label: `i18n (${getI18nScopeLable(instance)} Scope)`,\r\n                textColor: 0x000000,\r\n                backgroundColor: 0xffcd19\r\n            };\r\n            treeNode.tags.push(tag);\r\n        }\r\n    }\r\n}\r\nfunction inspectComposer(instanceData, composer) {\r\n    const type = VUE_I18N_COMPONENT_TYPES;\r\n    instanceData.state.push({\r\n        type,\r\n        key: 'locale',\r\n        editable: true,\r\n        value: composer.locale.value\r\n    });\r\n    instanceData.state.push({\r\n        type,\r\n        key: 'availableLocales',\r\n        editable: false,\r\n        value: composer.availableLocales\r\n    });\r\n    instanceData.state.push({\r\n        type,\r\n        key: 'fallbackLocale',\r\n        editable: true,\r\n        value: composer.fallbackLocale.value\r\n    });\r\n    instanceData.state.push({\r\n        type,\r\n        key: 'inheritLocale',\r\n        editable: true,\r\n        value: composer.inheritLocale\r\n    });\r\n    instanceData.state.push({\r\n        type,\r\n        key: 'messages',\r\n        editable: false,\r\n        value: getLocaleMessageValue(composer.messages.value)\r\n    });\r\n    {\r\n        instanceData.state.push({\r\n            type,\r\n            key: 'datetimeFormats',\r\n            editable: false,\r\n            value: composer.datetimeFormats.value\r\n        });\r\n        instanceData.state.push({\r\n            type,\r\n            key: 'numberFormats',\r\n            editable: false,\r\n            value: composer.numberFormats.value\r\n        });\r\n    }\r\n}\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nfunction getLocaleMessageValue(messages) {\r\n    const value = {};\r\n    Object.keys(messages).forEach((key) => {\r\n        const v = messages[key];\r\n        if (isFunction(v) && 'source' in v) {\r\n            value[key] = getMessageFunctionDetails(v);\r\n        }\r\n        else if (isObject(v)) {\r\n            value[key] = getLocaleMessageValue(v);\r\n        }\r\n        else {\r\n            value[key] = v;\r\n        }\r\n    });\r\n    return value;\r\n}\r\nconst ESC = {\r\n    '<': '&lt;',\r\n    '>': '&gt;',\r\n    '\"': '&quot;',\r\n    '&': '&amp;'\r\n};\r\nfunction escape(s) {\r\n    return s.replace(/[<>\"&]/g, escapeChar);\r\n}\r\nfunction escapeChar(a) {\r\n    return ESC[a] || a;\r\n}\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nfunction getMessageFunctionDetails(func) {\r\n    const argString = func.source ? `(\"${escape(func.source)}\")` : `(?)`;\r\n    return {\r\n        _custom: {\r\n            type: 'function',\r\n            display: `<span>ƒ</span> ${argString}`\r\n        }\r\n    };\r\n}\r\nfunction registerScope(payload, i18n) {\r\n    payload.rootNodes.push({\r\n        id: 'global',\r\n        label: 'Global Scope'\r\n    });\r\n    // prettier-ignore\r\n    const global = i18n.mode === 'composition'\r\n        ? i18n.global\r\n        : i18n.global.__composer;\r\n    for (const [keyInstance, instance] of i18n.__instances) {\r\n        // prettier-ignore\r\n        const composer = i18n.mode === 'composition'\r\n            ? instance\r\n            : instance.__composer;\r\n        if (global === composer) {\r\n            continue;\r\n        }\r\n        payload.rootNodes.push({\r\n            id: composer.id.toString(),\r\n            label: `${getI18nScopeLable(keyInstance)} Scope`\r\n        });\r\n    }\r\n}\r\nfunction getComponentInstance(nodeId, i18n) {\r\n    let instance = null;\r\n    if (nodeId !== 'global') {\r\n        for (const [component, composer] of i18n.__instances.entries()) {\r\n            if (composer.id.toString() === nodeId) {\r\n                instance = component;\r\n                break;\r\n            }\r\n        }\r\n    }\r\n    return instance;\r\n}\r\nfunction getComposer$1(nodeId, i18n) {\r\n    if (nodeId === 'global') {\r\n        return i18n.mode === 'composition'\r\n            ? i18n.global\r\n            : i18n.global.__composer;\r\n    }\r\n    else {\r\n        const instance = Array.from(i18n.__instances.values()).find(item => item.id.toString() === nodeId);\r\n        if (instance) {\r\n            return i18n.mode === 'composition'\r\n                ? instance\r\n                : instance.__composer;\r\n        }\r\n        else {\r\n            return null;\r\n        }\r\n    }\r\n}\r\nfunction inspectScope(payload, i18n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n) {\r\n    const composer = getComposer$1(payload.nodeId, i18n);\r\n    if (composer) {\r\n        // TODO:\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        payload.state = makeScopeInspectState(composer);\r\n    }\r\n    return null;\r\n}\r\nfunction makeScopeInspectState(composer) {\r\n    const state = {};\r\n    const localeType = 'Locale related info';\r\n    const localeStates = [\r\n        {\r\n            type: localeType,\r\n            key: 'locale',\r\n            editable: true,\r\n            value: composer.locale.value\r\n        },\r\n        {\r\n            type: localeType,\r\n            key: 'fallbackLocale',\r\n            editable: true,\r\n            value: composer.fallbackLocale.value\r\n        },\r\n        {\r\n            type: localeType,\r\n            key: 'availableLocales',\r\n            editable: false,\r\n            value: composer.availableLocales\r\n        },\r\n        {\r\n            type: localeType,\r\n            key: 'inheritLocale',\r\n            editable: true,\r\n            value: composer.inheritLocale\r\n        }\r\n    ];\r\n    state[localeType] = localeStates;\r\n    const localeMessagesType = 'Locale messages info';\r\n    const localeMessagesStates = [\r\n        {\r\n            type: localeMessagesType,\r\n            key: 'messages',\r\n            editable: false,\r\n            value: getLocaleMessageValue(composer.messages.value)\r\n        }\r\n    ];\r\n    state[localeMessagesType] = localeMessagesStates;\r\n    {\r\n        const datetimeFormatsType = 'Datetime formats info';\r\n        const datetimeFormatsStates = [\r\n            {\r\n                type: datetimeFormatsType,\r\n                key: 'datetimeFormats',\r\n                editable: false,\r\n                value: composer.datetimeFormats.value\r\n            }\r\n        ];\r\n        state[datetimeFormatsType] = datetimeFormatsStates;\r\n        const numberFormatsType = 'Datetime formats info';\r\n        const numberFormatsStates = [\r\n            {\r\n                type: numberFormatsType,\r\n                key: 'numberFormats',\r\n                editable: false,\r\n                value: composer.numberFormats.value\r\n            }\r\n        ];\r\n        state[numberFormatsType] = numberFormatsStates;\r\n    }\r\n    return state;\r\n}\r\nfunction addTimelineEvent(event, payload) {\r\n    if (devtoolsApi) {\r\n        let groupId;\r\n        if (payload && 'groupId' in payload) {\r\n            groupId = payload.groupId;\r\n            delete payload.groupId;\r\n        }\r\n        devtoolsApi.addTimelineEvent({\r\n            layerId: \"vue-i18n-timeline\" /* TIMELINE */,\r\n            event: {\r\n                title: event,\r\n                groupId,\r\n                time: Date.now(),\r\n                meta: {},\r\n                data: payload || {},\r\n                logType: event === \"compile-error\" /* COMPILE_ERROR */\r\n                    ? 'error'\r\n                    : event === \"fallback\" /* FALBACK */ ||\r\n                        event === \"missing\" /* MISSING */\r\n                        ? 'warning'\r\n                        : 'default'\r\n            }\r\n        });\r\n    }\r\n}\r\nfunction editScope(payload, i18n) {\r\n    const composer = getComposer$1(payload.nodeId, i18n);\r\n    if (composer) {\r\n        const [field] = payload.path;\r\n        if (field === 'locale' && isString(payload.state.value)) {\r\n            composer.locale.value = payload.state.value;\r\n        }\r\n        else if (field === 'fallbackLocale' &&\r\n            (isString(payload.state.value) ||\r\n                isArray(payload.state.value) ||\r\n                isObject(payload.state.value))) {\r\n            composer.fallbackLocale.value = payload.state.value;\r\n        }\r\n        else if (field === 'inheritLocale' && isBoolean(payload.state.value)) {\r\n            composer.inheritLocale = payload.state.value;\r\n        }\r\n    }\r\n}\n\n/**\r\n * Supports compatibility for legacy vue-i18n APIs\r\n * This mixin is used when we use vue-i18n@v9.x or later\r\n */\r\nfunction defineMixin(vuei18n, composer, i18n) {\r\n    return {\r\n        beforeCreate() {\r\n            const instance = getCurrentInstance();\r\n            /* istanbul ignore if */\r\n            if (!instance) {\r\n                throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);\r\n            }\r\n            const options = this.$options;\r\n            if (options.i18n) {\r\n                const optionsI18n = options.i18n;\r\n                if (options.__i18n) {\r\n                    optionsI18n.__i18n = options.__i18n;\r\n                }\r\n                optionsI18n.__root = composer;\r\n                if (this === this.$root) {\r\n                    this.$i18n = mergeToRoot(vuei18n, optionsI18n);\r\n                }\r\n                else {\r\n                    optionsI18n.__injectWithOption = true;\r\n                    this.$i18n = createVueI18n(optionsI18n);\r\n                }\r\n            }\r\n            else if (options.__i18n) {\r\n                if (this === this.$root) {\r\n                    this.$i18n = mergeToRoot(vuei18n, options);\r\n                }\r\n                else {\r\n                    this.$i18n = createVueI18n({\r\n                        __i18n: options.__i18n,\r\n                        __injectWithOption: true,\r\n                        __root: composer\r\n                    });\r\n                }\r\n            }\r\n            else {\r\n                // set global\r\n                this.$i18n = vuei18n;\r\n            }\r\n            if (options.__i18nGlobal) {\r\n                adjustI18nResources(composer, options, options);\r\n            }\r\n            vuei18n.__onComponentInstanceCreated(this.$i18n);\r\n            i18n.__setInstance(instance, this.$i18n);\r\n            // defines vue-i18n legacy APIs\r\n            this.$t = (...args) => this.$i18n.t(...args);\r\n            this.$rt = (...args) => this.$i18n.rt(...args);\r\n            this.$tc = (...args) => this.$i18n.tc(...args);\r\n            this.$te = (key, locale) => this.$i18n.te(key, locale);\r\n            this.$d = (...args) => this.$i18n.d(...args);\r\n            this.$n = (...args) => this.$i18n.n(...args);\r\n            this.$tm = (key) => this.$i18n.tm(key);\r\n        },\r\n        mounted() {\r\n            /* istanbul ignore if */\r\n            if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) &&\r\n                !false &&\r\n                this.$el &&\r\n                this.$i18n) {\r\n                this.$el.__VUE_I18N__ = this.$i18n.__composer;\r\n                const emitter = (this.__v_emitter =\r\n                    createEmitter());\r\n                const _vueI18n = this.$i18n;\r\n                _vueI18n.__enableEmitter && _vueI18n.__enableEmitter(emitter);\r\n                emitter.on('*', addTimelineEvent);\r\n            }\r\n        },\r\n        unmounted() {\r\n            const instance = getCurrentInstance();\r\n            /* istanbul ignore if */\r\n            if (!instance) {\r\n                throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);\r\n            }\r\n            /* istanbul ignore if */\r\n            if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) &&\r\n                !false &&\r\n                this.$el &&\r\n                this.$el.__VUE_I18N__) {\r\n                if (this.__v_emitter) {\r\n                    this.__v_emitter.off('*', addTimelineEvent);\r\n                    delete this.__v_emitter;\r\n                }\r\n                if (this.$i18n) {\r\n                    const _vueI18n = this.$i18n;\r\n                    _vueI18n.__disableEmitter && _vueI18n.__disableEmitter();\r\n                    delete this.$el.__VUE_I18N__;\r\n                }\r\n            }\r\n            delete this.$t;\r\n            delete this.$rt;\r\n            delete this.$tc;\r\n            delete this.$te;\r\n            delete this.$d;\r\n            delete this.$n;\r\n            delete this.$tm;\r\n            i18n.__deleteInstance(instance);\r\n            delete this.$i18n;\r\n        }\r\n    };\r\n}\r\nfunction mergeToRoot(root, options) {\r\n    root.locale = options.locale || root.locale;\r\n    root.fallbackLocale = options.fallbackLocale || root.fallbackLocale;\r\n    root.missing = options.missing || root.missing;\r\n    root.silentTranslationWarn =\r\n        options.silentTranslationWarn || root.silentFallbackWarn;\r\n    root.silentFallbackWarn =\r\n        options.silentFallbackWarn || root.silentFallbackWarn;\r\n    root.formatFallbackMessages =\r\n        options.formatFallbackMessages || root.formatFallbackMessages;\r\n    root.postTranslation = options.postTranslation || root.postTranslation;\r\n    root.warnHtmlInMessage = options.warnHtmlInMessage || root.warnHtmlInMessage;\r\n    root.escapeParameterHtml =\r\n        options.escapeParameterHtml || root.escapeParameterHtml;\r\n    root.sync = options.sync || root.sync;\r\n    root.__composer[SetPluralRulesSymbol](options.pluralizationRules || root.pluralizationRules);\r\n    const messages = getLocaleMessages(root.locale, {\r\n        messages: options.messages,\r\n        __i18n: options.__i18n\r\n    });\r\n    Object.keys(messages).forEach(locale => root.mergeLocaleMessage(locale, messages[locale]));\r\n    if (options.datetimeFormats) {\r\n        Object.keys(options.datetimeFormats).forEach(locale => root.mergeDateTimeFormat(locale, options.datetimeFormats[locale]));\r\n    }\r\n    if (options.numberFormats) {\r\n        Object.keys(options.numberFormats).forEach(locale => root.mergeNumberFormat(locale, options.numberFormats[locale]));\r\n    }\r\n    return root;\r\n}\n\n/**\r\n * Injection key for {@link useI18n}\r\n *\r\n * @remarks\r\n * The global injection key for I18n instances with `useI18n`. this injection key is used in Web Components.\r\n * Specify the i18n instance created by {@link createI18n} together with `provide` function.\r\n *\r\n * @VueI18nGeneral\r\n */\r\nconst I18nInjectionKey = \r\n/* #__PURE__*/ makeSymbol('global-vue-i18n');\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\r\nfunction createI18n(options = {}, VueI18nLegacy) {\r\n    // prettier-ignore\r\n    const __legacyMode = __VUE_I18N_LEGACY_API__ && isBoolean(options.legacy)\r\n            ? options.legacy\r\n            : __VUE_I18N_LEGACY_API__;\r\n    // prettier-ignore\r\n    const __globalInjection = isBoolean(options.globalInjection)\r\n        ? options.globalInjection\r\n        : true;\r\n    // prettier-ignore\r\n    const __allowComposition = __VUE_I18N_LEGACY_API__ && __legacyMode\r\n            ? !!options.allowComposition\r\n            : true;\r\n    const __instances = new Map();\r\n    const [globalScope, __global] = createGlobal(options, __legacyMode);\r\n    const symbol = makeSymbol((process.env.NODE_ENV !== 'production') ? 'vue-i18n' : '');\r\n    function __getInstance(component) {\r\n        return __instances.get(component) || null;\r\n    }\r\n    function __setInstance(component, instance) {\r\n        __instances.set(component, instance);\r\n    }\r\n    function __deleteInstance(component) {\r\n        __instances.delete(component);\r\n    }\r\n    {\r\n        const i18n = {\r\n            // mode\r\n            get mode() {\r\n                return __VUE_I18N_LEGACY_API__ && __legacyMode\r\n                    ? 'legacy'\r\n                    : 'composition';\r\n            },\r\n            // allowComposition\r\n            get allowComposition() {\r\n                return __allowComposition;\r\n            },\r\n            // install plugin\r\n            async install(app, ...options) {\r\n                if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) &&\r\n                    !false) {\r\n                    app.__VUE_I18N__ = i18n;\r\n                }\r\n                // setup global provider\r\n                app.__VUE_I18N_SYMBOL__ = symbol;\r\n                app.provide(app.__VUE_I18N_SYMBOL__, i18n);\r\n                // global method and properties injection for Composition API\r\n                if (!__legacyMode && __globalInjection) {\r\n                    injectGlobalFields(app, i18n.global);\r\n                }\r\n                // install built-in components and directive\r\n                if (__VUE_I18N_FULL_INSTALL__) {\r\n                    apply(app, i18n, ...options);\r\n                }\r\n                // setup mixin for Legacy API\r\n                if (__VUE_I18N_LEGACY_API__ && __legacyMode) {\r\n                    app.mixin(defineMixin(__global, __global.__composer, i18n));\r\n                }\r\n                // release global scope\r\n                const unmountApp = app.unmount;\r\n                app.unmount = () => {\r\n                    i18n.dispose();\r\n                    unmountApp();\r\n                };\r\n                // setup vue-devtools plugin\r\n                if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) && !false) {\r\n                    const ret = await enableDevTools(app, i18n);\r\n                    if (!ret) {\r\n                        throw createI18nError(I18nErrorCodes.CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN);\r\n                    }\r\n                    const emitter = createEmitter();\r\n                    if (__legacyMode) {\r\n                        const _vueI18n = __global;\r\n                        _vueI18n.__enableEmitter && _vueI18n.__enableEmitter(emitter);\r\n                    }\r\n                    else {\r\n                        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n                        const _composer = __global;\r\n                        _composer[EnableEmitter] && _composer[EnableEmitter](emitter);\r\n                    }\r\n                    emitter.on('*', addTimelineEvent);\r\n                }\r\n            },\r\n            // global accessor\r\n            get global() {\r\n                return __global;\r\n            },\r\n            dispose() {\r\n                globalScope.stop();\r\n            },\r\n            // @internal\r\n            __instances,\r\n            // @internal\r\n            __getInstance,\r\n            // @internal\r\n            __setInstance,\r\n            // @internal\r\n            __deleteInstance\r\n        };\r\n        return i18n;\r\n    }\r\n}\r\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\r\nfunction useI18n(options = {}) {\r\n    const instance = getCurrentInstance();\r\n    if (instance == null) {\r\n        throw createI18nError(I18nErrorCodes.MUST_BE_CALL_SETUP_TOP);\r\n    }\r\n    if (!instance.isCE &&\r\n        instance.appContext.app != null &&\r\n        !instance.appContext.app.__VUE_I18N_SYMBOL__) {\r\n        throw createI18nError(I18nErrorCodes.NOT_INSLALLED);\r\n    }\r\n    const i18n = getI18nInstance(instance);\r\n    const global = getGlobalComposer(i18n);\r\n    const componentOptions = getComponentOptions(instance);\r\n    const scope = getScope(options, componentOptions);\r\n    if (__VUE_I18N_LEGACY_API__) {\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        if (i18n.mode === 'legacy' && !options.__useComponent) {\r\n            if (!i18n.allowComposition) {\r\n                throw createI18nError(I18nErrorCodes.NOT_AVAILABLE_IN_LEGACY_MODE);\r\n            }\r\n            return useI18nForLegacy(instance, scope, global, options);\r\n        }\r\n    }\r\n    if (scope === 'global') {\r\n        adjustI18nResources(global, options, componentOptions);\r\n        return global;\r\n    }\r\n    if (scope === 'parent') {\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        let composer = getComposer(i18n, instance, options.__useComponent);\r\n        if (composer == null) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                warn(getWarnMessage(I18nWarnCodes.NOT_FOUND_PARENT_SCOPE));\r\n            }\r\n            composer = global;\r\n        }\r\n        return composer;\r\n    }\r\n    const i18nInternal = i18n;\r\n    let composer = i18nInternal.__getInstance(instance);\r\n    if (composer == null) {\r\n        const composerOptions = assign({}, options);\r\n        if ('__i18n' in componentOptions) {\r\n            composerOptions.__i18n = componentOptions.__i18n;\r\n        }\r\n        if (global) {\r\n            composerOptions.__root = global;\r\n        }\r\n        composer = createComposer(composerOptions);\r\n        setupLifeCycle(i18nInternal, instance, composer);\r\n        i18nInternal.__setInstance(instance, composer);\r\n    }\r\n    return composer;\r\n}\r\n/**\r\n * Cast to VueI18n legacy compatible type\r\n *\r\n * @remarks\r\n * This API is provided only with [vue-i18n-bridge](https://vue-i18n.intlify.dev/guide/migration/ways.html#what-is-vue-i18n-bridge).\r\n *\r\n * The purpose of this function is to convert an {@link I18n} instance created with {@link createI18n | createI18n(legacy: true)} into a `vue-i18n@v8.x` compatible instance of `new VueI18n` in a TypeScript environment.\r\n *\r\n * @param i18n - An instance of {@link I18n}\r\n * @returns A i18n instance which is casted to {@link VueI18n} type\r\n *\r\n * @VueI18nTip\r\n * :new: provided by **vue-i18n-bridge only**\r\n *\r\n * @VueI18nGeneral\r\n */\r\nconst castToVueI18n =  (i18n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n) => {\r\n    if (!(__VUE_I18N_BRIDGE__ in i18n)) {\r\n        throw createI18nError(I18nErrorCodes.NOT_COMPATIBLE_LEGACY_VUE_I18N);\r\n    }\r\n    return i18n;\r\n};\r\nfunction createGlobal(options, legacyMode, VueI18nLegacy // eslint-disable-line @typescript-eslint/no-explicit-any\r\n) {\r\n    const scope = effectScope();\r\n    {\r\n        const obj = __VUE_I18N_LEGACY_API__ && legacyMode\r\n            ? scope.run(() => createVueI18n(options))\r\n            : scope.run(() => createComposer(options));\r\n        if (obj == null) {\r\n            throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);\r\n        }\r\n        return [scope, obj];\r\n    }\r\n}\r\nfunction getI18nInstance(instance) {\r\n    {\r\n        const i18n = inject(!instance.isCE\r\n            ? instance.appContext.app.__VUE_I18N_SYMBOL__\r\n            : I18nInjectionKey);\r\n        /* istanbul ignore if */\r\n        if (!i18n) {\r\n            throw createI18nError(!instance.isCE\r\n                ? I18nErrorCodes.UNEXPECTED_ERROR\r\n                : I18nErrorCodes.NOT_INSLALLED_WITH_PROVIDE);\r\n        }\r\n        return i18n;\r\n    }\r\n}\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nfunction getScope(options, componentOptions) {\r\n    // prettier-ignore\r\n    return isEmptyObject(options)\r\n        ? ('__i18n' in componentOptions)\r\n            ? 'local'\r\n            : 'global'\r\n        : !options.useScope\r\n            ? 'local'\r\n            : options.useScope;\r\n}\r\nfunction getGlobalComposer(i18n) {\r\n    // prettier-ignore\r\n    return i18n.mode === 'composition'\r\n            ? i18n.global\r\n            : i18n.global.__composer\r\n        ;\r\n}\r\nfunction getComposer(i18n, target, useComponent = false) {\r\n    let composer = null;\r\n    const root = target.root;\r\n    let current = target.parent;\r\n    while (current != null) {\r\n        const i18nInternal = i18n;\r\n        if (i18n.mode === 'composition') {\r\n            composer = i18nInternal.__getInstance(current);\r\n        }\r\n        else {\r\n            if (__VUE_I18N_LEGACY_API__) {\r\n                const vueI18n = i18nInternal.__getInstance(current);\r\n                if (vueI18n != null) {\r\n                    composer = vueI18n\r\n                        .__composer;\r\n                    if (useComponent &&\r\n                        composer &&\r\n                        !composer[InejctWithOption] // eslint-disable-line @typescript-eslint/no-explicit-any\r\n                    ) {\r\n                        composer = null;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        if (composer != null) {\r\n            break;\r\n        }\r\n        if (root === current) {\r\n            break;\r\n        }\r\n        current = current.parent;\r\n    }\r\n    return composer;\r\n}\r\nfunction setupLifeCycle(i18n, target, composer) {\r\n    let emitter = null;\r\n    {\r\n        onMounted(() => {\r\n            // inject composer instance to DOM for intlify-devtools\r\n            if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) &&\r\n                !false &&\r\n                target.vnode.el) {\r\n                target.vnode.el.__VUE_I18N__ = composer;\r\n                emitter = createEmitter();\r\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n                const _composer = composer;\r\n                _composer[EnableEmitter] && _composer[EnableEmitter](emitter);\r\n                emitter.on('*', addTimelineEvent);\r\n            }\r\n        }, target);\r\n        onUnmounted(() => {\r\n            // remove composer instance from DOM for intlify-devtools\r\n            if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) &&\r\n                !false &&\r\n                target.vnode.el &&\r\n                target.vnode.el.__VUE_I18N__) {\r\n                emitter && emitter.off('*', addTimelineEvent);\r\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n                const _composer = composer;\r\n                _composer[DisableEmitter] && _composer[DisableEmitter]();\r\n                delete target.vnode.el.__VUE_I18N__;\r\n            }\r\n            i18n.__deleteInstance(target);\r\n        }, target);\r\n    }\r\n}\r\nfunction useI18nForLegacy(instance, scope, root, options = {} // eslint-disable-line @typescript-eslint/no-explicit-any\r\n) {\r\n    const isLocale = scope === 'local';\r\n    const _composer = shallowRef(null);\r\n    if (isLocale && instance.proxy && !instance.proxy.$options.i18n) {\r\n        throw createI18nError(I18nErrorCodes.MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION);\r\n    }\r\n    const _inheritLocale = isBoolean(options.inheritLocale)\r\n        ? options.inheritLocale\r\n        : true;\r\n    const _locale = ref(\r\n    // prettier-ignore\r\n    isLocale && _inheritLocale\r\n        ? root.locale.value\r\n        : isString(options.locale)\r\n            ? options.locale\r\n            : DEFAULT_LOCALE);\r\n    const _fallbackLocale = ref(\r\n    // prettier-ignore\r\n    isLocale && _inheritLocale\r\n        ? root.fallbackLocale.value\r\n        : isString(options.fallbackLocale) ||\r\n            isArray(options.fallbackLocale) ||\r\n            isPlainObject(options.fallbackLocale) ||\r\n            options.fallbackLocale === false\r\n            ? options.fallbackLocale\r\n            : _locale.value);\r\n    const _messages = ref(getLocaleMessages(_locale.value, options));\r\n    // prettier-ignore\r\n    const _datetimeFormats = ref(isPlainObject(options.datetimeFormats)\r\n        ? options.datetimeFormats\r\n        : { [_locale.value]: {} });\r\n    // prettier-ignore\r\n    const _numberFormats = ref(isPlainObject(options.numberFormats)\r\n        ? options.numberFormats\r\n        : { [_locale.value]: {} });\r\n    // prettier-ignore\r\n    const _missingWarn = isLocale\r\n        ? root.missingWarn\r\n        : isBoolean(options.missingWarn) || isRegExp(options.missingWarn)\r\n            ? options.missingWarn\r\n            : true;\r\n    // prettier-ignore\r\n    const _fallbackWarn = isLocale\r\n        ? root.fallbackWarn\r\n        : isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn)\r\n            ? options.fallbackWarn\r\n            : true;\r\n    // prettier-ignore\r\n    const _fallbackRoot = isLocale\r\n        ? root.fallbackRoot\r\n        : isBoolean(options.fallbackRoot)\r\n            ? options.fallbackRoot\r\n            : true;\r\n    // configure fall back to root\r\n    const _fallbackFormat = !!options.fallbackFormat;\r\n    // runtime missing\r\n    const _missing = isFunction(options.missing) ? options.missing : null;\r\n    // postTranslation handler\r\n    const _postTranslation = isFunction(options.postTranslation)\r\n        ? options.postTranslation\r\n        : null;\r\n    // prettier-ignore\r\n    const _warnHtmlMessage = isLocale\r\n        ? root.warnHtmlMessage\r\n        : isBoolean(options.warnHtmlMessage)\r\n            ? options.warnHtmlMessage\r\n            : true;\r\n    const _escapeParameter = !!options.escapeParameter;\r\n    // prettier-ignore\r\n    const _modifiers = isLocale\r\n        ? root.modifiers\r\n        : isPlainObject(options.modifiers)\r\n            ? options.modifiers\r\n            : {};\r\n    // pluralRules\r\n    const _pluralRules = options.pluralRules || (isLocale && root.pluralRules);\r\n    // track reactivity\r\n    function trackReactivityValues() {\r\n        return [\r\n            _locale.value,\r\n            _fallbackLocale.value,\r\n            _messages.value,\r\n            _datetimeFormats.value,\r\n            _numberFormats.value\r\n        ];\r\n    }\r\n    // locale\r\n    const locale = computed({\r\n        get: () => {\r\n            return _composer.value ? _composer.value.locale.value : _locale.value;\r\n        },\r\n        set: val => {\r\n            if (_composer.value) {\r\n                _composer.value.locale.value = val;\r\n            }\r\n            _locale.value = val;\r\n        }\r\n    });\r\n    // fallbackLocale\r\n    const fallbackLocale = computed({\r\n        get: () => {\r\n            return _composer.value\r\n                ? _composer.value.fallbackLocale.value\r\n                : _fallbackLocale.value;\r\n        },\r\n        set: val => {\r\n            if (_composer.value) {\r\n                _composer.value.fallbackLocale.value = val;\r\n            }\r\n            _fallbackLocale.value = val;\r\n        }\r\n    });\r\n    // messages\r\n    const messages = computed(() => {\r\n        if (_composer.value) {\r\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n            return _composer.value.messages.value;\r\n        }\r\n        else {\r\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n            return _messages.value;\r\n        }\r\n    });\r\n    const datetimeFormats = computed(() => _datetimeFormats.value);\r\n    const numberFormats = computed(() => _numberFormats.value);\r\n    function getPostTranslationHandler() {\r\n        return _composer.value\r\n            ? _composer.value.getPostTranslationHandler()\r\n            : _postTranslation;\r\n    }\r\n    function setPostTranslationHandler(handler) {\r\n        if (_composer.value) {\r\n            _composer.value.setPostTranslationHandler(handler);\r\n        }\r\n    }\r\n    function getMissingHandler() {\r\n        return _composer.value ? _composer.value.getMissingHandler() : _missing;\r\n    }\r\n    function setMissingHandler(handler) {\r\n        if (_composer.value) {\r\n            _composer.value.setMissingHandler(handler);\r\n        }\r\n    }\r\n    function warpWithDeps(fn) {\r\n        trackReactivityValues();\r\n        return fn();\r\n    }\r\n    function t(...args) {\r\n        return _composer.value\r\n            ? warpWithDeps(() => Reflect.apply(_composer.value.t, null, [...args]))\r\n            : warpWithDeps(() => '');\r\n    }\r\n    function rt(...args) {\r\n        return _composer.value\r\n            ? Reflect.apply(_composer.value.rt, null, [...args])\r\n            : '';\r\n    }\r\n    function d(...args) {\r\n        return _composer.value\r\n            ? warpWithDeps(() => Reflect.apply(_composer.value.d, null, [...args]))\r\n            : warpWithDeps(() => '');\r\n    }\r\n    function n(...args) {\r\n        return _composer.value\r\n            ? warpWithDeps(() => Reflect.apply(_composer.value.n, null, [...args]))\r\n            : warpWithDeps(() => '');\r\n    }\r\n    function tm(key) {\r\n        return _composer.value ? _composer.value.tm(key) : {};\r\n    }\r\n    function te(key, locale) {\r\n        return _composer.value ? _composer.value.te(key, locale) : false;\r\n    }\r\n    function getLocaleMessage(locale) {\r\n        return _composer.value ? _composer.value.getLocaleMessage(locale) : {};\r\n    }\r\n    function setLocaleMessage(locale, message) {\r\n        if (_composer.value) {\r\n            _composer.value.setLocaleMessage(locale, message);\r\n            _messages.value[locale] = message;\r\n        }\r\n    }\r\n    function mergeLocaleMessage(locale, message) {\r\n        if (_composer.value) {\r\n            _composer.value.mergeLocaleMessage(locale, message);\r\n        }\r\n    }\r\n    function getDateTimeFormat(locale) {\r\n        return _composer.value ? _composer.value.getDateTimeFormat(locale) : {};\r\n    }\r\n    function setDateTimeFormat(locale, format) {\r\n        if (_composer.value) {\r\n            _composer.value.setDateTimeFormat(locale, format);\r\n            _datetimeFormats.value[locale] = format;\r\n        }\r\n    }\r\n    function mergeDateTimeFormat(locale, format) {\r\n        if (_composer.value) {\r\n            _composer.value.mergeDateTimeFormat(locale, format);\r\n        }\r\n    }\r\n    function getNumberFormat(locale) {\r\n        return _composer.value ? _composer.value.getNumberFormat(locale) : {};\r\n    }\r\n    function setNumberFormat(locale, format) {\r\n        if (_composer.value) {\r\n            _composer.value.setNumberFormat(locale, format);\r\n            _numberFormats.value[locale] = format;\r\n        }\r\n    }\r\n    function mergeNumberFormat(locale, format) {\r\n        if (_composer.value) {\r\n            _composer.value.mergeNumberFormat(locale, format);\r\n        }\r\n    }\r\n    const wrapper = {\r\n        get id() {\r\n            return _composer.value ? _composer.value.id : -1;\r\n        },\r\n        locale,\r\n        fallbackLocale,\r\n        messages,\r\n        datetimeFormats,\r\n        numberFormats,\r\n        get inheritLocale() {\r\n            return _composer.value ? _composer.value.inheritLocale : _inheritLocale;\r\n        },\r\n        set inheritLocale(val) {\r\n            if (_composer.value) {\r\n                _composer.value.inheritLocale = val;\r\n            }\r\n        },\r\n        get availableLocales() {\r\n            return _composer.value\r\n                ? _composer.value.availableLocales\r\n                : Object.keys(_messages.value);\r\n        },\r\n        get modifiers() {\r\n            return (_composer.value ? _composer.value.modifiers : _modifiers);\r\n        },\r\n        get pluralRules() {\r\n            return (_composer.value ? _composer.value.pluralRules : _pluralRules);\r\n        },\r\n        get isGlobal() {\r\n            return _composer.value ? _composer.value.isGlobal : false;\r\n        },\r\n        get missingWarn() {\r\n            return _composer.value ? _composer.value.missingWarn : _missingWarn;\r\n        },\r\n        set missingWarn(val) {\r\n            if (_composer.value) {\r\n                _composer.value.missingWarn = val;\r\n            }\r\n        },\r\n        get fallbackWarn() {\r\n            return _composer.value ? _composer.value.fallbackWarn : _fallbackWarn;\r\n        },\r\n        set fallbackWarn(val) {\r\n            if (_composer.value) {\r\n                _composer.value.missingWarn = val;\r\n            }\r\n        },\r\n        get fallbackRoot() {\r\n            return _composer.value ? _composer.value.fallbackRoot : _fallbackRoot;\r\n        },\r\n        set fallbackRoot(val) {\r\n            if (_composer.value) {\r\n                _composer.value.fallbackRoot = val;\r\n            }\r\n        },\r\n        get fallbackFormat() {\r\n            return _composer.value ? _composer.value.fallbackFormat : _fallbackFormat;\r\n        },\r\n        set fallbackFormat(val) {\r\n            if (_composer.value) {\r\n                _composer.value.fallbackFormat = val;\r\n            }\r\n        },\r\n        get warnHtmlMessage() {\r\n            return _composer.value\r\n                ? _composer.value.warnHtmlMessage\r\n                : _warnHtmlMessage;\r\n        },\r\n        set warnHtmlMessage(val) {\r\n            if (_composer.value) {\r\n                _composer.value.warnHtmlMessage = val;\r\n            }\r\n        },\r\n        get escapeParameter() {\r\n            return _composer.value\r\n                ? _composer.value.escapeParameter\r\n                : _escapeParameter;\r\n        },\r\n        set escapeParameter(val) {\r\n            if (_composer.value) {\r\n                _composer.value.escapeParameter = val;\r\n            }\r\n        },\r\n        t,\r\n        getPostTranslationHandler,\r\n        setPostTranslationHandler,\r\n        getMissingHandler,\r\n        setMissingHandler,\r\n        rt,\r\n        d,\r\n        n,\r\n        tm,\r\n        te,\r\n        getLocaleMessage,\r\n        setLocaleMessage,\r\n        mergeLocaleMessage,\r\n        getDateTimeFormat,\r\n        setDateTimeFormat,\r\n        mergeDateTimeFormat,\r\n        getNumberFormat,\r\n        setNumberFormat,\r\n        mergeNumberFormat\r\n    };\r\n    function sync(composer) {\r\n        composer.locale.value = _locale.value;\r\n        composer.fallbackLocale.value = _fallbackLocale.value;\r\n        Object.keys(_messages.value).forEach(locale => {\r\n            composer.mergeLocaleMessage(locale, _messages.value[locale]);\r\n        });\r\n        Object.keys(_datetimeFormats.value).forEach(locale => {\r\n            composer.mergeDateTimeFormat(locale, _datetimeFormats.value[locale]);\r\n        });\r\n        Object.keys(_numberFormats.value).forEach(locale => {\r\n            composer.mergeNumberFormat(locale, _numberFormats.value[locale]);\r\n        });\r\n        composer.escapeParameter = _escapeParameter;\r\n        composer.fallbackFormat = _fallbackFormat;\r\n        composer.fallbackRoot = _fallbackRoot;\r\n        composer.fallbackWarn = _fallbackWarn;\r\n        composer.missingWarn = _missingWarn;\r\n        composer.warnHtmlMessage = _warnHtmlMessage;\r\n    }\r\n    onBeforeMount(() => {\r\n        if (instance.proxy == null || instance.proxy.$i18n == null) {\r\n            throw createI18nError(I18nErrorCodes.NOT_AVAILABLE_COMPOSITION_IN_LEGACY);\r\n        }\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        const composer = (_composer.value = instance.proxy.$i18n\r\n            .__composer);\r\n        if (scope === 'global') {\r\n            _locale.value = composer.locale.value;\r\n            _fallbackLocale.value = composer.fallbackLocale.value;\r\n            _messages.value = composer.messages.value;\r\n            _datetimeFormats.value = composer.datetimeFormats.value;\r\n            _numberFormats.value = composer.numberFormats.value;\r\n        }\r\n        else if (isLocale) {\r\n            sync(composer);\r\n        }\r\n    });\r\n    return wrapper;\r\n}\r\nconst globalExportProps = [\r\n    'locale',\r\n    'fallbackLocale',\r\n    'availableLocales'\r\n];\r\nconst globalExportMethods = ['t', 'rt', 'd', 'n', 'tm'] ;\r\nfunction injectGlobalFields(app, composer) {\r\n    const i18n = Object.create(null);\r\n    globalExportProps.forEach(prop => {\r\n        const desc = Object.getOwnPropertyDescriptor(composer, prop);\r\n        if (!desc) {\r\n            throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);\r\n        }\r\n        const wrap = isRef(desc.value) // check computed props\r\n            ? {\r\n                get() {\r\n                    return desc.value.value;\r\n                },\r\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n                set(val) {\r\n                    desc.value.value = val;\r\n                }\r\n            }\r\n            : {\r\n                get() {\r\n                    return desc.get && desc.get();\r\n                }\r\n            };\r\n        Object.defineProperty(i18n, prop, wrap);\r\n    });\r\n    app.config.globalProperties.$i18n = i18n;\r\n    globalExportMethods.forEach(method => {\r\n        const desc = Object.getOwnPropertyDescriptor(composer, method);\r\n        if (!desc || !desc.value) {\r\n            throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);\r\n        }\r\n        Object.defineProperty(app.config.globalProperties, `$${method}`, desc);\r\n    });\r\n}\n\n// register message compiler at vue-i18n\r\nregisterMessageCompiler(compileToFunction);\r\n// register message resolver at vue-i18n\r\nregisterMessageResolver(resolveValue);\r\n// register fallback locale at vue-i18n\r\nregisterLocaleFallbacker(fallbackWithLocaleChain);\r\n{\r\n    initFeatureFlags();\r\n}\r\n// NOTE: experimental !!\r\nif ((process.env.NODE_ENV !== 'production') || __INTLIFY_PROD_DEVTOOLS__) {\r\n    const target = getGlobalThis();\r\n    target.__INTLIFY__ = true;\r\n    setDevToolsHook(target.__INTLIFY_DEVTOOLS_GLOBAL_HOOK__);\r\n}\r\nif ((process.env.NODE_ENV !== 'production')) ;\n\nexport { DatetimeFormat, I18nInjectionKey, NumberFormat, Translation, VERSION, castToVueI18n, createI18n, useI18n, vTDirective };\n","import * as Vue from 'vue'\n\nvar isVue2 = false\nvar isVue3 = true\nvar Vue2 = undefined\n\nfunction install() {}\n\nexport function set(target, key, val) {\n  if (Array.isArray(target)) {\n    target.length = Math.max(target.length, key)\n    target.splice(key, 1, val)\n    return val\n  }\n  target[key] = val\n  return val\n}\n\nexport function del(target, key) {\n  if (Array.isArray(target)) {\n    target.splice(key, 1)\n    return\n  }\n  delete target[key]\n}\n\nexport * from 'vue'\nexport {\n  Vue,\n  Vue2,\n  isVue2,\n  isVue3,\n  install,\n}\n","// peer dep is not installed during test\n// eslint-disable-next-line import/no-unresolved\nimport { h as createElement } from 'vue';\n\n/** @type {Record<string, PromiseWithState<Element>>} */\nconst cache = {};\n\n/**\n * Remove false attrs\n * @param {Object} attrs\n */\nfunction filterAttrs(attrs) {\n    return Object.keys(attrs).reduce((result, key) => {\n        if (attrs[key] !== false && attrs[key] !== null && attrs[key] !== undefined) {\n            result[key] = attrs[key];\n        }\n        return result;\n    }, {});\n}\n\nconst InlineSvg = {\n    name: 'InlineSvg',\n    inheritAttrs: false,\n    render() {\n        if (!this.svgElSource) {\n            return null;\n        }\n        return createElement(\n            'svg',\n            Object.assign(\n                {},\n                // source attrs\n                this.getSvgAttrs(this.svgElSource),\n                // component attrs and listeners\n                filterAttrs(this.$attrs),\n                // content\n                { innerHTML: this.getSvgContent(this.svgElSource) },\n            ),\n        );\n    },\n    props: {\n        src: {\n            type: String,\n            required: true,\n        },\n        title: {\n            type: String,\n        },\n        transformSource: {\n            type: Function,\n            default: (svg) => svg,\n        },\n        keepDuringLoading: {\n            type: Boolean,\n            default: true,\n        },\n    },\n    emits: ['loaded', 'unloaded', 'error'],\n    data() {\n        return {\n            /** @type {SVGElement} */\n            svgElSource: null,\n            /** @type {XMLHttpRequest} */\n            request: undefined,\n        };\n    },\n    watch: {\n        src(newValue) {\n            // re-generate cached svg (`svgElSource`)\n            this.getSource(newValue);\n        },\n    },\n    mounted() {\n        // generate `svgElSource`\n        this.getSource(this.src);\n    },\n    methods: {\n        getSvgAttrs(svgEl) {\n            // copy attrs\n            let svgAttrs = {};\n            const attrs = svgEl.attributes;\n            if (!attrs) {\n                return svgAttrs;\n            }\n            for (let i = attrs.length - 1; i >= 0; i--) {\n                svgAttrs[attrs[i].name] = attrs[i].value;\n            }\n            return svgAttrs;\n        },\n        getSvgContent(svgEl) {\n            svgEl = svgEl.cloneNode(true);\n            svgEl = this.transformSource(svgEl);\n            if (this.title) {\n                setTitle(svgEl, this.title);\n            }\n\n            // copy inner html\n            return svgEl.innerHTML;\n        },\n        /**\n         * Get svgElSource\n         * @param {string} src\n         */\n        getSource(src) {\n            // fill cache by src with promise\n            if (!cache[src]) {\n                // download\n                cache[src] = this.download(src);\n            }\n            // notify svg is unloaded\n            if (this.svgElSource && cache[src].getIsPending() && !this.keepDuringLoading) {\n                this.svgElSource = null;\n                this.$emit('unloaded');\n            }\n\n            // inline svg when cached promise resolves\n            cache[src]\n                .then((svg) => {\n                    this.svgElSource = svg;\n                    // wait to render\n                    this.$nextTick(() => {\n                        // notify\n                        this.$emit('loaded', this.$el);\n                    });\n                })\n                .catch((err) => {\n                    // notify svg is unloaded\n                    if (this.svgElSource) {\n                        this.svgElSource = null;\n                        this.$emit('unloaded');\n                    }\n                    // remove cached rejected promise so next image can try load again\n                    delete cache[src];\n                    this.$emit('error', err);\n                });\n        },\n\n        /**\n         * Get the contents of the SVG\n         * @param {string} url\n         * @returns {PromiseWithState<Element>}\n         */\n        download(url) {\n            return makePromiseState(new Promise((resolve, reject) => {\n                const request = new XMLHttpRequest();\n                request.open('GET', url, true);\n                this.request = request;\n\n                request.onload = () => {\n                    if (request.status >= 200 && request.status < 400) {\n                        try {\n                            // Setup a parser to convert the response to text/xml in order for it to be manipulated and changed\n                            const parser = new DOMParser();\n                            const result = parser.parseFromString(request.responseText, 'text/xml');\n                            let svgEl = result.getElementsByTagName('svg')[0];\n                            if (svgEl) {\n                                // svgEl = this.transformSource(svgEl);\n                                resolve(svgEl);\n                            } else {\n                                reject(new Error('Loaded file is not valid SVG\"'));\n                            }\n                        } catch (e) {\n                            reject(e);\n                        }\n                    } else {\n                        reject(new Error('Error loading SVG'));\n                    }\n                };\n\n                request.onerror = reject;\n                request.send();\n            }));\n        },\n    },\n};\n\n/**\n * Create or edit the <title> element of a SVG\n * @param {SVGElement} svg\n * @param {string} title\n */\nfunction setTitle(svg, title) {\n    const titleTags = svg.getElementsByTagName('title');\n    if (titleTags.length) { // overwrite existing title\n        titleTags[0].textContent = title;\n    } else { // create a title element if one doesn't already exist\n        const titleEl = document.createElementNS('http://www.w3.org/2000/svg', 'title');\n        titleEl.textContent = title;\n        // svg.prepend(titleEl);\n        svg.insertBefore(titleEl, svg.firstChild);\n    }\n}\n\n/**\n * @typedef {Promise & object} PromiseWithState\n * @property {function: boolean} getIsPending\n * @template T\n */\n\n/**\n * This function allow you to modify a JS Promise by adding some status properties.\n * @template {any} T\n * @param {Promise<T>|PromiseWithState<T>} promise\n * @return {PromiseWithState<T>}\n */\nfunction makePromiseState(promise) {\n    // Don't modify any promise that has been already modified.\n    if (promise.getIsPending) return promise;\n\n    // Set initial state\n    let isPending = true;\n\n    // Observe the promise, saving the fulfillment in a closure scope.\n    let result = promise.then(\n        (v) => {\n            isPending = false;\n            return v;\n        },\n        (e) => {\n            isPending = false;\n            throw e;\n        },\n    );\n\n    result.getIsPending = function getIsPending() { return isPending; };\n    return result;\n}\n\nexport default InlineSvg;\n"],"names":["originalFunctionToString","DEFAULT_IGNORE_ERRORS","InboundFilters","_options","this","name","id","prototype","setupOnce","event","hub","self","getIntegration","client","getClient","clientOptions","getOptions","options","_mergeOptions","_shouldDropEvent","_isSentryError","logger","warn","_isIgnoredError","_isDeniedUrl","_getEventFilterUrl","_isAllowedUrl","ignoreInternal","exception","values","type","_oO","ignoreErrors","length","_getPossibleEventMessages","some","message","pattern","denyUrls","url","allowUrls","whitelistUrls","blacklistUrls","_a","_b","_c","value","oO","error","stacktrace","frames_1","frames","filename","frames_2","FunctionToString","Function","toString","args","_i","arguments","context","__sentry_original__","apply","setPrototypeOf","Object","__proto__","Array","obj","proto","prop","hasOwnProperty","SentryError","_super","_newTarget","constructor","_this","call","Error","DSN_REGEX","ERROR_MESSAGE","Dsn","from","_fromString","_fromComponents","_validate","withPassword","host","path","pass","port","projectId","protocol","user","str","match","exec","slice","split","join","pop","projectMatch","components","forEach","component","isNaN","parseInt","installedIntegrations","setupIntegrations","integrations","defaultIntegrations","userIntegrations","isArray","userIntegrationsNames_1","map","i","pickedIntegrationsNames_1","defaultIntegration","indexOf","push","userIntegration","integrationsNames","alwaysLastToRun","splice","getIntegrationsToSetup","integration","log","setupIntegration","Status","BaseClient","backendClass","_integrations","_processing","_backend","dsn","_dsn","captureException","hint","scope","eventId","event_id","_process","_getBackend","eventFromException","then","_captureEvent","result","captureMessage","level","promisedEvent","is","eventFromMessage","String","captureEvent","captureSession","session","release","_sendSession","getDsn","flush","timeout","_isClientProcessing","ready","getTransport","close","transportFlushed","enabled","_isEnabled","_updateSessionFromEvent","e_1","userAgent","crashed","errored","exceptions","exceptions_1","exceptions_1_1","next","done","mechanism","handled","e_1_1","return","headers","request","key","toLowerCase","update","status","Crashed","errors","Number","sendSession","resolve","ticked","interval","setInterval","clearInterval","undefined","_prepareEvent","normalizeDepth","prepared","timestamp","_applyClientOptions","_applyIntegrationsMetadata","finalScope","captureContext","clone","applyToEvent","evt","_normalizeEvent","depth","normalized","breadcrumbs","b","data","contexts","extra","trace","environment","dist","maxValueLength","sdkInfo","sdk","integrationsArray","keys","_sendEvent","sendEvent","_processEvent","finalEvent","reason","beforeSend","sampleRate","reject","isTransaction","Math","random","__sentry__","beforeSendResult","e","processedEvent","getSession","originalException","promise","fromHttpCode","code","Success","RateLimit","Invalid","Failed","Unknown","Severity","NoopTransport","_","Skipped","BaseBackend","_transport","_setupTransport","_exception","_hint","_message","_level","supportsFetch","Headers","Request","Response","isNativeFetch","func","test","supportsReferrerPolicy","referrerPolicy","fromString","Debug","Info","Warning","Fatal","Critical","Log","UNKNOWN_FUNCTION","chrome","gecko","winjs","geckoEval","chromeEval","reactMinifiedRegexp","computeStackTrace","ex","stack","popSize","framesToPop","parts","opera10Regex","opera11Regex","lines","line","element","column","extractMessage","computeStackTraceFromStacktraceProp","popFrames","submatch","isNative","substr","columnNumber","computeStackTraceFromStackProp","failed","exceptionFromStacktrace","prepareFramesForEvent","eventFromStacktrace","localStack","firstFrameFunction","lastFrameFunction","frame","colno","function","in_app","lineno","reverse","eventFromUnknownInput","syntheticException","domException","name_1","eventFromString","tags","rejection","__serialized__","eventFromPlainObject","synthetic","input","attachStacktrace","sessionToSentryRequest","api","body","JSON","stringify","sent_at","Date","toISOString","getEnvelopeEndpointWithUrlEncodedAuth","eventToSentryRequest","samplingMethod","__sentry_samplingMethod","__sentry_sampleRate","otherTags","useEnvelope","req","getStoreEndpointWithUrlEncodedAuth","envelope","sample_rates","rate","API","_dsnObject","getBaseApiEndpoint","getStoreEndpoint","_getIngestEndpoint","_encodedAuth","_getEnvelopeEndpoint","getStoreEndpointPath","getRequestHeaders","clientName","clientVersion","header","getReportDialogEndpoint","dialogOptions","endpoint","encodedOptions","encodeURIComponent","email","target","auth","sentry_key","sentry_version","PromiseBuffer","_limit","_buffer","isReady","add","task","remove","drain","capturedSetTimeout","setTimeout","all","clearTimeout","BaseTransport","_rateLimits","_api","_handleResponse","requestType","response","_handleRateLimit","_disabledUntil","category","_isRateLimited","now","e_2","rlHeader","raHeader","trim","_d","parameters","headerDelay","delay","_e","_f","e_2_1","global","FetchTransport","_sendRequest","sentryRequest","originalPayload","Promise","method","fetchParameters","assign","fetch","get","catch","XHRTransport","XMLHttpRequest","onreadystatechange","readyState","getResponseHeader","open","setRequestHeader","send","BrowserBackend","transportOptions","transport","ignoreOnError","shouldIgnoreOnError","wrap","fn","before","__sentry_wrapped__","sentryWrapped","wrappedArguments","arg","handleEvent","addEventProcessor","property","defineProperty","enumerable","defineProperties","getOwnPropertyDescriptor","configurable","injectReportDialog","script","document","createElement","async","src","onLoad","onload","head","appendChild","lastHref","handlers","instrumented","instrument","console","originalConsoleLevel","triggerHandlers","instrumentConsole","addEventListener","domEventHandler","bind","keypressEventHandler","original","eventName","innerOriginal","instrumentDOM","requestKeys","requestValues","xhrproto","originalOpen","xhr","__sentry_xhr__","toUpperCase","__sentry_own_request__","onreadystatechangeHandler","status_code","requestPos","args_1","endTimestamp","startTimestamp","readyStateArgs","originalSend","instrumentXHR","doc","sandbox","hidden","contentWindow","removeChild","err","supportsNativeFetch","originalFetch","handlerData","fetchData","getFetchMethod","getFetchUrl","instrumentFetch","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","supportsHistory","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","to","location","href","instrumentHistory","_oldOnErrorHandler","onerror","msg","_oldOnUnhandledRejectionHandler","onunhandledrejection","addInstrumentationHandler","handler","callback","fetchArgs","keypressTimeout","lastCapturedEvent","debounceDuration","debounceTimer","debounce","tagName","isContentEditable","Breadcrumbs","dom","sentry","addSentryBreadcrumb","addBreadcrumb","_consoleBreadcrumb","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","breadcrumb","parsedLoc","parsedFrom","parsedTo","relative","SDK_VERSION","BrowserClient","showReportDialog","platform","packages","version","DEFAULT_EVENT_TARGET","TryCatch","eventTarget","requestAnimationFrame","_wrapTimeFunction","_wrapRAF","_wrapXHR","_wrapEventTarget","originalCallback","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","wrapOptions","GlobalHandlers","_onErrorHandlerInstalled","_onUnhandledRejectionHandlerInstalled","stackTraceLimit","_installGlobalOnErrorHandler","_installGlobalOnUnhandledRejectionHandler","currentHub","hasIntegration","isFailedOwnDelivery","_eventFromIncompleteOnError","_enhanceEventWithInitialFrame","detail","_eventFromRejectionWithPrimitive","groups","LinkedErrors","_key","limit","_handler","linkedErrors","_walkErrorTree","UserAgent","navigator","referrer","Referer","init","window_1","SENTRY_RELEASE","autoSessionTracking","clientClass","debug","enable","bindClient","initAndBind","window","loadResolved","fcpResolved","possiblyEndSession","endSession","resolveWindowLoaded","removeEventListener","startSession","po","PerformanceObserver","entryList","getEntries","entry","startTime","firstHiddenTime_1","disconnect","visibilityState","Infinity","min","timeStamp","once","observe","buffered","startSessionTracking","Session","sid","started","duration","Ok","ip_address","ipAddress","did","username","Exited","toJSON","attrs","user_agent","API_VERSION","Hub","_version","_stack","getStackTop","isOlderThan","pushScope","getScope","getStack","popScope","withScope","_lastEventId","finalHint","_invokeClient","lastEventId","beforeBreadcrumb","maxBreadcrumbs","mergedBreadcrumb","finalBreadcrumb","setUser","setTags","setExtras","extras","setTag","setExtra","setContext","configureScope","run","oldHub","makeMain","startSpan","_callExtensionMethod","startTransaction","customSamplingContext","traceHeaders","getUser","setSession","getMainCarrier","__SENTRY__","extensions","carrier","registry","getHubFromCarrier","setHubOnCarrier","getCurrentHub","hasHubOnCarrier","activeDomain","domain","active","registryHubTopStack","_Oo","getHubFromActiveDomain","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_user","_tags","_extra","_contexts","newScope","_span","_session","_transactionName","_fingerprint","addScopeListener","_notifyScopeListeners","setFingerprint","fingerprint","setLevel","setTransactionName","setTransaction","setSpan","span","getSpan","getTransaction","transaction","spanRecorder","spans","updatedScope","clear","clearBreadcrumbs","getTraceContext","transactionName","_applyFingerprint","_notifyEventProcessors","getGlobalEventProcessors","processors","index","processor","final","concat","globalEventProcessors","addGlobalEventProcessor","splitPathRe","splitPath","TRACING_GETTER","BROWSER_TRACING_GETTER","HOOKS","activate","create","destroy","mount","COMPONENT_NAME_REGEXP","ROOT_COMPONENT_NAME","ANONYMOUS_COMPONENT_NAME","Vue","_componentsCache","_applyTracingHooks","vm","$options","$_sentryPerfHook","_getComponentName","rootMount","rootHandler","hook","time","_rootSpan","_finishRootSpan","$once","tracingIntegration","_tracingActivity","pushActivity","startChild","description","op","activeTransaction","getActiveTransaction","childHandler","operation","shouldTrack","tracingOptions","trackComponents","finish","hooks","internalHooks","internalHook","currentValue","attachProps","logErrors","tracing","_attachErrorHandler","_startTracing","$root","_componentTag","__file","unifiedFile","replace","ext","f","c","_rootSpanTimer","popActivity","applyTracingHooks","mixin","beforeCreate","currentErrorHandler","config","errorHandler","info","metadata","componentName","propsData","lifecycleHook","util","callOnHub","SessionStatus","htmlTreeAsString","elem","currentElem","out","height","len","nextStr","_htmlElementAsString","separator","parentNode","el","className","classes","attr","allowedAttrs","getAttribute","isError","wat","isInstanceOf","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","Boolean","isSyntheticEvent","base","PREFIX","Logger","_enabled","disable","fallbackGlobalObject","getGlobalObject","g","uuid4","crypto","msCrypto","getRandomValues","arr","Uint16Array","pad","num","v","r","parseUrl","query","fragment","getEventDescription","consoleSandbox","originalConsole","wrappedLevels","addExceptionTypeValue","addExceptionMechanism","getLocationHref","defaultRetryAfter","parseRetryAfterHeader","headerDate","parse","isNodeEnv","process","dynamicRequire","mod","require","Memo","_hasWeakSet","WeakSet","_inner","memoize","has","unmemoize","delete","fill","source","replacementFactory","wrapped","urlEncode","object","getWalkSource","event_1","currentTarget","CustomEvent","jsonSize","encodeURI","utf8Length","normalizeToSize","maxSize","serialized","normalize","normalizeValue","_events","walk","memo","serializeValue","acc","innerKey","extractExceptionKeysForMessage","maxLength","sort","includedKeys","dropUndefinedKeys","val","rv","defaultFunctionName","getFunctionName","truncate","max","safeJoin","delimiter","output","isMatchingPattern","States","SyncPromise","executor","_state","PENDING","_handlers","_resolve","_setResult","RESOLVED","_reject","REJECTED","state","_value","_executeHandlers","_attachHandler","cachedHandlers","onfulfilled","onrejected","collection","counter","resolvedCollection","item","TypeError","finally","onfinally","isRejected","dateTimestampSource","nowSeconds","platformPerformance","module","performance","getNodePerformance","timeOrigin","getBrowserPerformance","timestampSource","dateTimestampInSeconds","timestampWithMs","timing","navigationStart","isCallable","interpolate","template","param","placeholder","params","paramIndex","merge","Dictionary","locale","dictionary","container","ctx","format","getLocaleDefault","field","fields","_default","messages","_g","_h","rule","form","fieldName","names","DICTIONARY","localize","generateMessage","setLocale","getSingleParam","paramName","isEmpty","confirmedValidator","emailValidator","re","every","extValidator","files","regex","RegExp","file","integerValidator","isNullOrUndefined","maxLengthValidator","maxValueValidator","minValidator","minValueValidator","requiredValidator","urlValidator","URL","extendStatics","d","p","__extends","__","__assign","t","s","n","__rest","getOwnPropertySymbols","propertyIsEnumerable","__values","o","Symbol","iterator","m","__read","ar","__spread","phones","isMobilePhone","invalidType","assertString","strictMode","startsWith","isObject","isIndex","RULES","defineRule","validator","guardExtend","FormContextKey","FieldContextKey","IS_ABSENT","isLocator","__locatorRef","isYupValidator","validate","hasCheckedAttr","isEmptyContainer","isNotNestedPath","isNativeSelect","shouldHaveValueBinding","tag","hasTruthyBindingValue","includes","multiple","isNativeMultiSelectNode","isFormSubmitEvent","srcElement","isPropPresent","fastDeepEqual","equal","a","flags","valueOf","cleanupNonNestedPath","getFromPath","fallback","filter","reduce","propKey","setInPath","unset","unsetPath","pathValues","idx","keysOf","record","injectWithSelf","symbol","def","getCurrentInstance","provides","inject","resolveNextCheckboxValue","checkedValue","uncheckedValue","newVal","findIndex","debounceAsync","inner","ms","timer","resolves","applyModelModifiers","modifiers","number","parseFloat","toNumber","normalizeChildren","slotProps","slots","default","getBoundValue","hasValueBinding","normalizeEventValue","opt","selected","disabled","selectedOption","find","normalizeRules","rules","writable","_$$isNormalized","prev","curr","normalizeParams","buildParams","parsedRule","parseRule","provided","mapValueToLocator","locator","crossTable","createLocator","currentConfig","bails","validateOnBlur","validateOnChange","validateOnInput","validateOnModelUpdate","getConfig","configure","newConf","shouldBail","formData","opts","abortEarly","validateFieldWithYup","pipeline","_generateFieldError","normalizedContext","rulesKeys","_test","valid","fillTargetValues","fieldCtx","validateObjectSchema","schema","validations","fieldResult","bailsMap","isAllValid","validationResults","results","set","klona","x","k","list","tmp","Set","Map","buffer","getOwnPropertyNames","es6","size","entries","ArrayBuffer","isView","ID_COUNTER","useFieldState","initialValue","setInitialValue","_useFieldValue","modelValue","standalone","errorMessage","setErrors","shouldInjectForm","normalizeErrors","ref","computed","errorBag","unref","setFieldErrorBag","_useFieldErrors","meta","reactive","touched","pending","validated","dirty","watch","immediate","_useFieldMeta","MAX_SAFE_INTEGER","setState","modelRef","resolveInitialValue","initialValues","stageInitialValue","setFieldValue","inThrottle","lastResult","throttle","nextTick","sendInspectorState","INSPECTOR_ID","sendInspectorTree","useField","patchCheckboxApi","handleChange","checked","checkedVal","handleCheckboxChange","shouldValidate","newValue","_useField","useCheckboxField","validateOnMount","label","validateOnValueUpdate","keepValueOnUnmount","modelPropName","syncVModel","defaults","valueProp","normalizeOptions","markedForRemoval","propName","emitName","props","getCurrentModelValue","emit","propValue","modelModifiers","useVModel","normalizedRules","rulesValue","extractRuleFromSchema","validateCurrentValue","mode","validateSchema","validateWithStateMutation","validateValidStateOnly","unwatchValue","watchValue","oldVal","deep","resetField","onMounted","handleReset","handleBlur","setTouched","isTouched","setValue","provide","isRef","oldValue","register","onBeforeUnmount","unregister","dependencies","rulesVal","deps","dep","depAcc","depName","depValue","oldDeps","resolveTag","as","Field","defineComponent","inheritAttrs","required","keepValue","setup","toRef","validateField","onChangeHandler","onInputHandler","handleInput","fieldProps","resolveValidationTriggers","baseOnBlur","onBlur","baseOnInput","onInput","baseOnChange","onChange","expose","reset","resolveDynamicComponent","children","h","FORM_COUNTER","useForm","formId","RESET_LOCK","fieldsByPath","isSubmitting","submitCount","fieldArrays","formValues","setErrorBag","initialErrors","normalizeErrorItem","useErrorBag","bag","getFirstFieldAtPath","fieldOrGroup","fieldExists","fieldNames","fieldBailsMap","keepValuesOnUnmount","originalInitialValues","setInitialValues","providedValues","updateFields","fieldPath","wasTouched","useFormInitialValues","currentValues","MERGE_STRATEGIES","isDirty","calculateFlags","flat","flag","mergeMethod","watchEffect","useFormMeta","validationSchema","formCtx","formResult","debouncedSilentValidation","debouncedValidation","fieldsById","currentErrorsPaths","validation","setFieldError","applyFieldMutation","wasValidated","insertFieldAtPath","newPath","oldPath","removeFieldFromPath","initialErrorMessage","fieldInstance","isGroup","isFieldGroup","shouldKeepValue","currentGroupValue","valueIdx","force","setValues","setFieldTouched","resetForm","handleSubmit","updateOriginal","setFieldInitialValue","unsetInitialValue","useFieldModel","mutation","mutateAllFields","clonedValue","createModel","rawField","markRaw","fieldAtPath","onValidationError","preventDefault","stopPropagation","returnVal","_validateSchema","schemaValue","errorObjects","validateYupSchema","submitForm","submit","initialTouched","FormImpl","onSubmit","onInvalidSubmit","keepValues","handleFormReset","onReset","handleScopedSlotSubmit","formAttrs","novalidate","Form","swap","insert","prepend","move","arrayPath","noOp","noOpApi","alreadyExists","entryCounter","initFields","createEntry","updateEntryFlags","fieldsLength","isFirst","isLast","pathName","pathValue","fieldArrayCtx","normalizedPathValue","indexA","indexB","newFields","temp","tempEntry","unshift","oldIdx","newIdx","movedItem","movedValue","useFieldArray","role","inBrowser","hasSymbol","toStringTag","generateFormatCacheKey","friendlyJSONstringify","l","json","isNumber","isFinite","isDate","toTypeString","isEmptyObject","_globalThis","getGlobalThis","globalThis","escapeHtml","rawText","hasOwn","objectToString","CompileErrorCodes","createCompileError","loc","SyntaxError","defaultOnError","createLocation","start","end","CHAR_SP","CHAR_LF","CHAR_LS","fromCharCode","CHAR_PS","createScanner","_buf","_index","_line","_column","_peekOffset","isCRLF","isPS","isLS","isLineEnd","isLF","charAt","offset","peekOffset","currentChar","currentPeek","peek","resetPeek","skipToPeek","EOF","createTokenizer","_scnr","currentOffset","currentPosition","createPosition","_initLoc","_initOffset","_context","currentType","startLoc","endLoc","lastType","lastOffset","lastStartLoc","lastEndLoc","braceNest","inLinked","text","onError","emitError","pos","getToken","token","getEndToken","eat","scnr","ch","peekSpaces","buf","skipSpaces","isIdentifierStart","cc","charCodeAt","isListIdentifierStart","ret","isNumberStart","isPluralStart","isTextStart","hasSpace","detectModulo","takeChar","takeIdentifierChar","takeDigit","takeHexDigit","getDigits","readEscapeSequence","readUnicodeEscapeSequence","unicode","digits","sequence","readPlural","plural","readTokenInPlaceholder","readTokenInLinked","validNamedIdentifier","validListIdentifier","validLiteral","readToken","isNamedIdentifierStart","readNamedIdentifier","readListIdentifier","isLiteralStart","literal","current","readLiteral","identifiers","closure","readInvalidIdentifier","isLinkedDotStart","isLinkedDelimiterStart","isLinkedModifierStart","readLinkedModifier","isLinkedReferStart","detect","readLinkedRefer","readText","nextToken","KNOWN_ESCAPES","fromEscapeSequence","codePoint4","codePoint6","codePoint","fromCodePoint","createParser","tokenzer","startNode","node","endNode","parseText","tokenizer","parseList","parseNamed","parseLiteral","parseLinked","linkedNode","parsed","nextConsumeToken","getTokenCaption","parseLinkedModifier","modifier","parseLinkedKey","nextContext","emptyLinkedKeyNode","parseMessage","items","parseResource","msgNode","hasEmptyMessage","cases","parsePlural","traverseNodes","nodes","transformer","traverseNode","helper","transform","ast","helpers","createTransformer","generateNode","generator","generateResource","needIndent","indent","deindent","generatePluralNode","generateMessageNode","generateLinkedNode","baseCompile","assignedOptions","sourceMap","breakLineCode","_needIndent","indentLevel","_newline","withBreakLine","_breakLineCode","repeat","withNewLine","newline","createCodeGenerator","generate","IntlifyDevToolsHooks","I18nInit","FunctionTranslate","pathStateMachine","literalValueRE","getPathCharType","formatSubPath","trimmed","exp","stripQuotes","cache","resolveWithKeyValue","DEFAULT_MODIFIER","DEFAULT_MESSAGE","DEFAULT_MESSAGE_DATA_TYPE","DEFAULT_NORMALIZE","DEFAULT_INTERPOLATE","pluralDefault","choice","choicesLength","abs","createMessageContext","pluralIndex","named","count","getPluralIndex","pluralRule","pluralRules","orgPluralRule","_list","_named","normalizeNamed","parent","devtools","translateDevTools","createDevToolsHook","payloads","CoreWarnCodes","fallbackWithSimple","fallbackWithLocaleChain","startLocale","DEFAULT_LOCALE","__localeChainCache","chain","block","appendBlockToChain","blocks","follow","appendLocaleToChain","tokens","appendItemToChain","VERSION","NOT_REOSLVED","MISSING_RESOLVE_VALUE","_compiler","_resolver","_fallbacker","_additionalMeta","setAdditionalMeta","getAdditionalMeta","_fallbackContext","setFallbackContext","getFallbackContext","_cid","createCoreContext","fallbackLocale","datetimeFormats","numberFormats","upper","lower","capitalize","toLocaleUpperCase","missing","missingWarn","fallbackWarn","fallbackFormat","unresolving","postTranslation","warnHtmlMessage","escapeParameter","messageCompiler","messageResolver","localeFallbacker","fallbackContext","onWarn","internalOptions","__datetimeFormatters","__numberFormatters","__meta","cid","__INTLIFY_PROD_DEVTOOLS__","i18n","initI18nDevTools","handleMissing","updateFallbackLocale","defaultOnCacheKey","compileCache","inc","CoreErrorCodes","INVALID_ARGUMENT","INVALID_DATE_ARGUMENT","INVALID_ISO_DATE_ARGUMENT","__EXTEND_POINT__","createCoreError","NOOP_MESSAGE_FUNCTION","isMessageFunction","translate","parseTranslateArgs","resolvedMessage","defaultMsgOrKey","enableDefaultMsg","escapeParams","formatScope","targetLocale","resolveMessageFormat","cacheBaseKey","occurred","compileMessageFormat","ctxOptions","resolveValue","resolveMessage","getMessageContextOptions","messaged","msgCtx","evaluateMessage","locales","missingRet","errorDetector","onCacheKey","getCompileOptions","arg1","arg2","arg3","intlDefined","Intl","DateTimeFormat","NumberFormat","datetime","overrides","parseDateTimeArgs","part","datetimeFormat","formatter","formatToParts","arg4","matches","dateTime","getTime","clearDateTimeFormat","parseNumberArgs","numberFormat","clearNumberFormat","code$1","inc$1","I18nErrorCodes","UNEXPECTED_RETURN_TYPE","MUST_BE_CALL_SETUP_TOP","NOT_INSLALLED","NOT_AVAILABLE_IN_LEGACY_MODE","REQUIRED_VALUE","INVALID_VALUE","CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN","NOT_INSLALLED_WITH_PROVIDE","UNEXPECTED_ERROR","NOT_COMPATIBLE_LEGACY_VUE_I18N","BRIDGE_SUPPORT_VUE_2_ONLY","MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION","NOT_AVAILABLE_COMPOSITION_IN_LEGACY","createI18nError","TransrateVNodeSymbol","DatetimePartsSymbol","NumberPartsSymbol","SetPluralRulesSymbol","InejctWithOption","handleFlatJson","subKeys","lastIndex","currentObj","getLocaleMessages","__i18n","flatJson","custom","resource","deepCopy","isNotObjectOrIsArray","des","getComponentOptions","instance","adjustI18nResources","componentOptions","__i18nGlobal","mergeLocaleMessage","mergeDateTimeFormat","mergeNumberFormat","createTextNode","createVNode","Text","DEVTOOLS_META","composerID","defineCoreMissingHandler","getMetaInfo","createComposer","VueI18nLegacy","__root","_isGlobal","_inheritLocale","inheritLocale","_locale","_fallbackLocale","_messages","_datetimeFormats","_numberFormats","_missingWarn","_fallbackWarn","_fallbackRoot","fallbackRoot","_fallbackFormat","_missing","_runtimeMissing","_postTranslation","_warnHtmlMessage","_escapeParameter","_modifiers","_pluralRules","framework","getCoreContext","wrapWithDeps","argumentParser","warnType","fallbackSuccess","fallbackFail","successCondition","Reflect","root","getLocaleMessage","composer","availableLocales","isGlobal","setLocaleMessage","getPostTranslationHandler","setPostTranslationHandler","getMissingHandler","setMissingHandler","rt","te","tm","targetLocaleMessages","messageValue","resolveMessages","getDateTimeFormat","setDateTimeFormat","getNumberFormat","setNumberFormat","__injectWithOption","createVueI18n","silentTranslationWarn","silentFallbackWarn","formatFallbackMessages","pluralizationRules","warnHtmlInMessage","escapeParameterHtml","sync","sharedMessages","convertComposerOptions","vueI18n","preserveDirectiveContent","__composer","tc","getChoiceIndex","__onComponentInstanceCreated","componentInstanceCreatedListener","baseFormatProps","getFragmentableTag","Fragment","Translation","keypath","useI18n","useScope","__useComponent","slot","getInterpolateArg","assignedAttrs","renderFormatter","slotKeys","partFormatter","NUMBER_FORMAT_KEYS","DATETIME_FORMAT_KEYS","DatetimeFormat","vTDirective","$","i18nInternal","__getInstance","getComposer$2","parsedValue","parseValue","textContent","makeParams","beforeMount","beforeUpdate","mergeToRoot","I18nInjectionKey","createI18n","__legacyMode","__VUE_I18N_LEGACY_API__","legacy","__globalInjection","globalInjection","__allowComposition","allowComposition","__instances","globalScope","__global","legacyMode","effectScope","createGlobal","install","__VUE_I18N_SYMBOL__","globalExportProps","desc","globalProperties","$i18n","globalExportMethods","injectGlobalFields","__VUE_I18N_FULL_INSTALL__","pluginOptions","useI18nComponentName","globalInstall","directive","vuei18n","optionsI18n","__setInstance","$t","$rt","$tc","$te","$d","$n","$tm","mounted","unmounted","__deleteInstance","defineMixin","unmountApp","unmount","dispose","stop","isCE","appContext","getI18nInstance","getGlobalComposer","isLocale","_composer","shallowRef","proxy","trackReactivityValues","warpWithDeps","wrapper","onBeforeMount","useI18nForLegacy","useComponent","getComposer","composerOptions","onUnmounted","setupLifeCycle","compiler","cached","hit","newChar","transition","action","typeMap","subPathDepth","actions","maybeUnescapeQuote","nextChar","last","needWarn","initFeatureFlags","__INTLIFY__","__INTLIFY_DEVTOOLS_GLOBAL_HOOK__","isVue2","isVue3","InlineSvg","render","svgElSource","getSvgAttrs","$attrs","innerHTML","getSvgContent","title","transformSource","svg","keepDuringLoading","emits","getSource","methods","svgEl","svgAttrs","attributes","cloneNode","titleTags","getElementsByTagName","titleEl","createElementNS","insertBefore","firstChild","setTitle","download","getIsPending","$emit","$nextTick","$el","isPending","makePromiseState","parser","DOMParser","parseFromString","responseText"],"sourceRoot":""}