{"version":3,"file":"js/vendors-fff081be.min.js?t=1746616748569","mappings":"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","sources":["webpack://frontend/./node_modules/@intlify/core-base/dist/core-base.mjs"],"sourcesContent":["/*!\n  * core-base v9.14.3\n  * (c) 2025 kazuya kawaguchi\n  * Released under the MIT License.\n  */\nimport { getGlobalThis, isObject, isFunction, isString, create, isNumber, isPlainObject, assign, join, toDisplayString, isArray, incrementer, format as format$1, isPromise, isBoolean, warn, isRegExp, warnOnce, hasOwn, escapeHtml, inBrowser, mark, measure, isEmptyObject, generateCodeFrame, generateFormatCacheKey, isDate } from '@intlify/shared';\nimport { CompileWarnCodes, CompileErrorCodes, createCompileError, detectHtmlTag, defaultOnError, baseCompile as baseCompile$1 } from '@intlify/message-compiler';\nexport { CompileErrorCodes, createCompileError } from '@intlify/message-compiler';\n\n/**\n * This is only called in esm-bundler builds.\n * istanbul-ignore-next\n */\nfunction initFeatureFlags() {\n    if (typeof __INTLIFY_PROD_DEVTOOLS__ !== 'boolean') {\n        getGlobalThis().__INTLIFY_PROD_DEVTOOLS__ = false;\n    }\n    if (typeof __INTLIFY_JIT_COMPILATION__ !== 'boolean') {\n        getGlobalThis().__INTLIFY_JIT_COMPILATION__ = false;\n    }\n    if (typeof __INTLIFY_DROP_MESSAGE_COMPILER__ !== 'boolean') {\n        getGlobalThis().__INTLIFY_DROP_MESSAGE_COMPILER__ = false;\n    }\n}\n\nconst pathStateMachine =  [];\npathStateMachine[0 /* States.BEFORE_PATH */] = {\n    [\"w\" /* PathCharTypes.WORKSPACE */]: [0 /* States.BEFORE_PATH */],\n    [\"i\" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],\n    [\"[\" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],\n    [\"o\" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]\n};\npathStateMachine[1 /* States.IN_PATH */] = {\n    [\"w\" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */],\n    [\".\" /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */],\n    [\"[\" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],\n    [\"o\" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]\n};\npathStateMachine[2 /* States.BEFORE_IDENT */] = {\n    [\"w\" /* PathCharTypes.WORKSPACE */]: [2 /* States.BEFORE_IDENT */],\n    [\"i\" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],\n    [\"0\" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */]\n};\npathStateMachine[3 /* States.IN_IDENT */] = {\n    [\"i\" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],\n    [\"0\" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],\n    [\"w\" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */, 1 /* Actions.PUSH */],\n    [\".\" /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */, 1 /* Actions.PUSH */],\n    [\"[\" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */, 1 /* Actions.PUSH */],\n    [\"o\" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */, 1 /* Actions.PUSH */]\n};\npathStateMachine[4 /* States.IN_SUB_PATH */] = {\n    [\"'\" /* PathCharTypes.SINGLE_QUOTE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */],\n    [\"\\\"\" /* PathCharTypes.DOUBLE_QUOTE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */],\n    [\"[\" /* PathCharTypes.LEFT_BRACKET */]: [\n        4 /* States.IN_SUB_PATH */,\n        2 /* Actions.INC_SUB_PATH_DEPTH */\n    ],\n    [\"]\" /* PathCharTypes.RIGHT_BRACKET */]: [1 /* States.IN_PATH */, 3 /* Actions.PUSH_SUB_PATH */],\n    [\"o\" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,\n    [\"l\" /* PathCharTypes.ELSE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */]\n};\npathStateMachine[5 /* States.IN_SINGLE_QUOTE */] = {\n    [\"'\" /* PathCharTypes.SINGLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],\n    [\"o\" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,\n    [\"l\" /* PathCharTypes.ELSE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */]\n};\npathStateMachine[6 /* States.IN_DOUBLE_QUOTE */] = {\n    [\"\\\"\" /* PathCharTypes.DOUBLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],\n    [\"o\" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,\n    [\"l\" /* PathCharTypes.ELSE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */]\n};\n/**\n * Check if an expression is a literal value.\n */\nconst literalValueRE = /^\\s?(?:true|false|-?[\\d.]+|'[^']*'|\"[^\"]*\")\\s?$/;\nfunction isLiteral(exp) {\n    return literalValueRE.test(exp);\n}\n/**\n * Strip quotes from a string\n */\nfunction stripQuotes(str) {\n    const a = str.charCodeAt(0);\n    const b = str.charCodeAt(str.length - 1);\n    return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;\n}\n/**\n * Determine the type of a character in a keypath.\n */\nfunction getPathCharType(ch) {\n    if (ch === undefined || ch === null) {\n        return \"o\" /* PathCharTypes.END_OF_FAIL */;\n    }\n    const code = ch.charCodeAt(0);\n    switch (code) {\n        case 0x5b: // [\n        case 0x5d: // ]\n        case 0x2e: // .\n        case 0x22: // \"\n        case 0x27: // '\n            return ch;\n        case 0x5f: // _\n        case 0x24: // $\n        case 0x2d: // -\n            return \"i\" /* PathCharTypes.IDENT */;\n        case 0x09: // Tab (HT)\n        case 0x0a: // Newline (LF)\n        case 0x0d: // Return (CR)\n        case 0xa0: // No-break space (NBSP)\n        case 0xfeff: // Byte Order Mark (BOM)\n        case 0x2028: // Line Separator (LS)\n        case 0x2029: // Paragraph Separator (PS)\n            return \"w\" /* PathCharTypes.WORKSPACE */;\n    }\n    return \"i\" /* PathCharTypes.IDENT */;\n}\n/**\n * Format a subPath, return its plain form if it is\n * a literal string or number. Otherwise prepend the\n * dynamic indicator (*).\n */\nfunction formatSubPath(path) {\n    const trimmed = path.trim();\n    // invalid leading 0\n    if (path.charAt(0) === '0' && isNaN(parseInt(path))) {\n        return false;\n    }\n    return isLiteral(trimmed)\n        ? stripQuotes(trimmed)\n        : \"*\" /* PathCharTypes.ASTARISK */ + trimmed;\n}\n/**\n * Parse a string path into an array of segments\n */\nfunction parse(path) {\n    const keys = [];\n    let index = -1;\n    let mode = 0 /* States.BEFORE_PATH */;\n    let subPathDepth = 0;\n    let c;\n    let key; // eslint-disable-line\n    let newChar;\n    let type;\n    let transition;\n    let action;\n    let typeMap;\n    const actions = [];\n    actions[0 /* Actions.APPEND */] = () => {\n        if (key === undefined) {\n            key = newChar;\n        }\n        else {\n            key += newChar;\n        }\n    };\n    actions[1 /* Actions.PUSH */] = () => {\n        if (key !== undefined) {\n            keys.push(key);\n            key = undefined;\n        }\n    };\n    actions[2 /* Actions.INC_SUB_PATH_DEPTH */] = () => {\n        actions[0 /* Actions.APPEND */]();\n        subPathDepth++;\n    };\n    actions[3 /* Actions.PUSH_SUB_PATH */] = () => {\n        if (subPathDepth > 0) {\n            subPathDepth--;\n            mode = 4 /* States.IN_SUB_PATH */;\n            actions[0 /* Actions.APPEND */]();\n        }\n        else {\n            subPathDepth = 0;\n            if (key === undefined) {\n                return false;\n            }\n            key = formatSubPath(key);\n            if (key === false) {\n                return false;\n            }\n            else {\n                actions[1 /* Actions.PUSH */]();\n            }\n        }\n    };\n    function maybeUnescapeQuote() {\n        const nextChar = path[index + 1];\n        if ((mode === 5 /* States.IN_SINGLE_QUOTE */ &&\n            nextChar === \"'\" /* PathCharTypes.SINGLE_QUOTE */) ||\n            (mode === 6 /* States.IN_DOUBLE_QUOTE */ &&\n                nextChar === \"\\\"\" /* PathCharTypes.DOUBLE_QUOTE */)) {\n            index++;\n            newChar = '\\\\' + nextChar;\n            actions[0 /* Actions.APPEND */]();\n            return true;\n        }\n    }\n    while (mode !== null) {\n        index++;\n        c = path[index];\n        if (c === '\\\\' && maybeUnescapeQuote()) {\n            continue;\n        }\n        type = getPathCharType(c);\n        typeMap = pathStateMachine[mode];\n        transition = typeMap[type] || typeMap[\"l\" /* PathCharTypes.ELSE */] || 8 /* States.ERROR */;\n        // check parse error\n        if (transition === 8 /* States.ERROR */) {\n            return;\n        }\n        mode = transition[0];\n        if (transition[1] !== undefined) {\n            action = actions[transition[1]];\n            if (action) {\n                newChar = c;\n                if (action() === false) {\n                    return;\n                }\n            }\n        }\n        // check parse finish\n        if (mode === 7 /* States.AFTER_PATH */) {\n            return keys;\n        }\n    }\n}\n// path token cache\nconst cache = new Map();\n/**\n * key-value message resolver\n *\n * @remarks\n * Resolves messages with the key-value structure. Note that messages with a hierarchical structure such as objects cannot be resolved\n *\n * @param obj - A target object to be resolved with path\n * @param path - A {@link Path | path} to resolve the value of message\n *\n * @returns A resolved {@link PathValue | path value}\n *\n * @VueI18nGeneral\n */\nfunction resolveWithKeyValue(obj, path) {\n    return isObject(obj) ? obj[path] : null;\n}\n/**\n * message resolver\n *\n * @remarks\n * Resolves messages. messages with a hierarchical structure such as objects can be resolved. This resolver is used in VueI18n as default.\n *\n * @param obj - A target object to be resolved with path\n * @param path - A {@link Path | path} to resolve the value of message\n *\n * @returns A resolved {@link PathValue | path value}\n *\n * @VueI18nGeneral\n */\nfunction resolveValue$1(obj, path) {\n    // check object\n    if (!isObject(obj)) {\n        return null;\n    }\n    // parse path\n    let hit = cache.get(path);\n    if (!hit) {\n        hit = parse(path);\n        if (hit) {\n            cache.set(path, hit);\n        }\n    }\n    // check hit\n    if (!hit) {\n        return null;\n    }\n    // resolve path value\n    const len = hit.length;\n    let last = obj;\n    let i = 0;\n    while (i < len) {\n        const val = last[hit[i]];\n        if (val === undefined) {\n            return null;\n        }\n        if (isFunction(last)) {\n            return null;\n        }\n        last = val;\n        i++;\n    }\n    return last;\n}\n\nconst DEFAULT_MODIFIER = (str) => str;\nconst DEFAULT_MESSAGE = (ctx) => ''; // eslint-disable-line\nconst DEFAULT_MESSAGE_DATA_TYPE = 'text';\nconst DEFAULT_NORMALIZE = (values) => values.length === 0 ? '' : join(values);\nconst DEFAULT_INTERPOLATE = toDisplayString;\nfunction pluralDefault(choice, choicesLength) {\n    choice = Math.abs(choice);\n    if (choicesLength === 2) {\n        // prettier-ignore\n        return choice\n            ? choice > 1\n                ? 1\n                : 0\n            : 1;\n    }\n    return choice ? Math.min(choice, 2) : 0;\n}\nfunction getPluralIndex(options) {\n    // prettier-ignore\n    const index = isNumber(options.pluralIndex)\n        ? options.pluralIndex\n        : -1;\n    // prettier-ignore\n    return options.named && (isNumber(options.named.count) || isNumber(options.named.n))\n        ? isNumber(options.named.count)\n            ? options.named.count\n            : isNumber(options.named.n)\n                ? options.named.n\n                : index\n        : index;\n}\nfunction normalizeNamed(pluralIndex, props) {\n    if (!props.count) {\n        props.count = pluralIndex;\n    }\n    if (!props.n) {\n        props.n = pluralIndex;\n    }\n}\nfunction createMessageContext(options = {}) {\n    const locale = options.locale;\n    const pluralIndex = getPluralIndex(options);\n    const pluralRule = isObject(options.pluralRules) &&\n        isString(locale) &&\n        isFunction(options.pluralRules[locale])\n        ? options.pluralRules[locale]\n        : pluralDefault;\n    const orgPluralRule = isObject(options.pluralRules) &&\n        isString(locale) &&\n        isFunction(options.pluralRules[locale])\n        ? pluralDefault\n        : undefined;\n    const plural = (messages) => {\n        return messages[pluralRule(pluralIndex, messages.length, orgPluralRule)];\n    };\n    const _list = options.list || [];\n    const list = (index) => _list[index];\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const _named = options.named || create();\n    isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);\n    const named = (key) => _named[key];\n    function message(key) {\n        // prettier-ignore\n        const msg = isFunction(options.messages)\n            ? options.messages(key)\n            : isObject(options.messages)\n                ? options.messages[key]\n                : false;\n        return !msg\n            ? options.parent\n                ? options.parent.message(key) // resolve from parent messages\n                : DEFAULT_MESSAGE\n            : msg;\n    }\n    const _modifier = (name) => options.modifiers\n        ? options.modifiers[name]\n        : DEFAULT_MODIFIER;\n    const normalize = isPlainObject(options.processor) && isFunction(options.processor.normalize)\n        ? options.processor.normalize\n        : DEFAULT_NORMALIZE;\n    const interpolate = isPlainObject(options.processor) &&\n        isFunction(options.processor.interpolate)\n        ? options.processor.interpolate\n        : DEFAULT_INTERPOLATE;\n    const type = isPlainObject(options.processor) && isString(options.processor.type)\n        ? options.processor.type\n        : DEFAULT_MESSAGE_DATA_TYPE;\n    const linked = (key, ...args) => {\n        const [arg1, arg2] = args;\n        let type = 'text';\n        let modifier = '';\n        if (args.length === 1) {\n            if (isObject(arg1)) {\n                modifier = arg1.modifier || modifier;\n                type = arg1.type || type;\n            }\n            else if (isString(arg1)) {\n                modifier = arg1 || modifier;\n            }\n        }\n        else if (args.length === 2) {\n            if (isString(arg1)) {\n                modifier = arg1 || modifier;\n            }\n            if (isString(arg2)) {\n                type = arg2 || type;\n            }\n        }\n        const ret = message(key)(ctx);\n        const msg = \n        // The message in vnode resolved with linked are returned as an array by processor.nomalize\n        type === 'vnode' && isArray(ret) && modifier\n            ? ret[0]\n            : ret;\n        return modifier ? _modifier(modifier)(msg, type) : msg;\n    };\n    const ctx = {\n        [\"list\" /* HelperNameMap.LIST */]: list,\n        [\"named\" /* HelperNameMap.NAMED */]: named,\n        [\"plural\" /* HelperNameMap.PLURAL */]: plural,\n        [\"linked\" /* HelperNameMap.LINKED */]: linked,\n        [\"message\" /* HelperNameMap.MESSAGE */]: message,\n        [\"type\" /* HelperNameMap.TYPE */]: type,\n        [\"interpolate\" /* HelperNameMap.INTERPOLATE */]: interpolate,\n        [\"normalize\" /* HelperNameMap.NORMALIZE */]: normalize,\n        [\"values\" /* HelperNameMap.VALUES */]: assign(create(), _list, _named)\n    };\n    return ctx;\n}\n\nlet devtools = null;\nfunction setDevToolsHook(hook) {\n    devtools = hook;\n}\nfunction getDevToolsHook() {\n    return devtools;\n}\nfunction initI18nDevTools(i18n, version, meta) {\n    // TODO: queue if devtools is undefined\n    devtools &&\n        devtools.emit(\"i18n:init\" /* IntlifyDevToolsHooks.I18nInit */, {\n            timestamp: Date.now(),\n            i18n,\n            version,\n            meta\n        });\n}\nconst translateDevTools = /* #__PURE__*/ createDevToolsHook(\"function:translate\" /* IntlifyDevToolsHooks.FunctionTranslate */);\nfunction createDevToolsHook(hook) {\n    return (payloads) => devtools && devtools.emit(hook, payloads);\n}\n\nconst code$1 = CompileWarnCodes.__EXTEND_POINT__;\nconst inc$1 = incrementer(code$1);\nconst CoreWarnCodes = {\n    NOT_FOUND_KEY: code$1, // 2\n    FALLBACK_TO_TRANSLATE: inc$1(), // 3\n    CANNOT_FORMAT_NUMBER: inc$1(), // 4\n    FALLBACK_TO_NUMBER_FORMAT: inc$1(), // 5\n    CANNOT_FORMAT_DATE: inc$1(), // 6\n    FALLBACK_TO_DATE_FORMAT: inc$1(), // 7\n    EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER: inc$1(), // 8\n    __EXTEND_POINT__: inc$1() // 9\n};\n/** @internal */\nconst warnMessages = {\n    [CoreWarnCodes.NOT_FOUND_KEY]: `Not found '{key}' key in '{locale}' locale messages.`,\n    [CoreWarnCodes.FALLBACK_TO_TRANSLATE]: `Fall back to translate '{key}' key with '{target}' locale.`,\n    [CoreWarnCodes.CANNOT_FORMAT_NUMBER]: `Cannot format a number value due to not supported Intl.NumberFormat.`,\n    [CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT]: `Fall back to number format '{key}' key with '{target}' locale.`,\n    [CoreWarnCodes.CANNOT_FORMAT_DATE]: `Cannot format a date value due to not supported Intl.DateTimeFormat.`,\n    [CoreWarnCodes.FALLBACK_TO_DATE_FORMAT]: `Fall back to datetime format '{key}' key with '{target}' locale.`,\n    [CoreWarnCodes.EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER]: `This project is using Custom Message Compiler, which is an experimental feature. It may receive breaking changes or be removed in the future.`\n};\nfunction getWarnMessage(code, ...args) {\n    return format$1(warnMessages[code], ...args);\n}\n\nconst code = CompileErrorCodes.__EXTEND_POINT__;\nconst inc = incrementer(code);\nconst CoreErrorCodes = {\n    INVALID_ARGUMENT: code, // 17\n    INVALID_DATE_ARGUMENT: inc(), // 18\n    INVALID_ISO_DATE_ARGUMENT: inc(), // 19\n    NOT_SUPPORT_NON_STRING_MESSAGE: inc(), // 20\n    NOT_SUPPORT_LOCALE_PROMISE_VALUE: inc(), // 21\n    NOT_SUPPORT_LOCALE_ASYNC_FUNCTION: inc(), // 22\n    NOT_SUPPORT_LOCALE_TYPE: inc(), // 23\n    __EXTEND_POINT__: inc() // 24\n};\nfunction createCoreError(code) {\n    return createCompileError(code, null, (process.env.NODE_ENV !== 'production') ? { messages: errorMessages } : undefined);\n}\n/** @internal */\nconst errorMessages = {\n    [CoreErrorCodes.INVALID_ARGUMENT]: 'Invalid arguments',\n    [CoreErrorCodes.INVALID_DATE_ARGUMENT]: 'The date provided is an invalid Date object.' +\n        'Make sure your Date represents a valid date.',\n    [CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT]: 'The argument provided is not a valid ISO date string',\n    [CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE]: 'Not support non-string message',\n    [CoreErrorCodes.NOT_SUPPORT_LOCALE_PROMISE_VALUE]: 'cannot support promise value',\n    [CoreErrorCodes.NOT_SUPPORT_LOCALE_ASYNC_FUNCTION]: 'cannot support async function',\n    [CoreErrorCodes.NOT_SUPPORT_LOCALE_TYPE]: 'cannot support locale type'\n};\n\n/** @internal */\nfunction getLocale(context, options) {\n    return options.locale != null\n        ? resolveLocale(options.locale)\n        : resolveLocale(context.locale);\n}\nlet _resolveLocale;\n/** @internal */\nfunction resolveLocale(locale) {\n    if (isString(locale)) {\n        return locale;\n    }\n    else {\n        if (isFunction(locale)) {\n            if (locale.resolvedOnce && _resolveLocale != null) {\n                return _resolveLocale;\n            }\n            else if (locale.constructor.name === 'Function') {\n                const resolve = locale();\n                if (isPromise(resolve)) {\n                    throw createCoreError(CoreErrorCodes.NOT_SUPPORT_LOCALE_PROMISE_VALUE);\n                }\n                return (_resolveLocale = resolve);\n            }\n            else {\n                throw createCoreError(CoreErrorCodes.NOT_SUPPORT_LOCALE_ASYNC_FUNCTION);\n            }\n        }\n        else {\n            throw createCoreError(CoreErrorCodes.NOT_SUPPORT_LOCALE_TYPE);\n        }\n    }\n}\n/**\n * Fallback with simple implemenation\n *\n * @remarks\n * A fallback locale function implemented with a simple fallback algorithm.\n *\n * Basically, it returns the value as specified in the `fallbackLocale` props, and is processed with the fallback inside intlify.\n *\n * @param ctx - A {@link CoreContext | context}\n * @param fallback - A {@link FallbackLocale | fallback locale}\n * @param start - A starting {@link Locale | locale}\n *\n * @returns Fallback locales\n *\n * @VueI18nGeneral\n */\nfunction fallbackWithSimple(ctx, fallback, start // eslint-disable-line @typescript-eslint/no-unused-vars\n) {\n    // prettier-ignore\n    return [...new Set([\n            start,\n            ...(isArray(fallback)\n                ? fallback\n                : isObject(fallback)\n                    ? Object.keys(fallback)\n                    : isString(fallback)\n                        ? [fallback]\n                        : [start])\n        ])];\n}\n/**\n * Fallback with locale chain\n *\n * @remarks\n * A fallback locale function implemented with a fallback chain algorithm. It's used in VueI18n as default.\n *\n * @param ctx - A {@link CoreContext | context}\n * @param fallback - A {@link FallbackLocale | fallback locale}\n * @param start - A starting {@link Locale | locale}\n *\n * @returns Fallback locales\n *\n * @VueI18nSee [Fallbacking](../guide/essentials/fallback)\n *\n * @VueI18nGeneral\n */\nfunction fallbackWithLocaleChain(ctx, fallback, start) {\n    const startLocale = isString(start) ? start : DEFAULT_LOCALE;\n    const context = ctx;\n    if (!context.__localeChainCache) {\n        context.__localeChainCache = new Map();\n    }\n    let chain = context.__localeChainCache.get(startLocale);\n    if (!chain) {\n        chain = [];\n        // first block defined by start\n        let block = [start];\n        // while any intervening block found\n        while (isArray(block)) {\n            block = appendBlockToChain(chain, block, fallback);\n        }\n        // prettier-ignore\n        // last block defined by default\n        const defaults = isArray(fallback) || !isPlainObject(fallback)\n            ? fallback\n            : fallback['default']\n                ? fallback['default']\n                : null;\n        // convert defaults to array\n        block = isString(defaults) ? [defaults] : defaults;\n        if (isArray(block)) {\n            appendBlockToChain(chain, block, false);\n        }\n        context.__localeChainCache.set(startLocale, chain);\n    }\n    return chain;\n}\nfunction appendBlockToChain(chain, block, blocks) {\n    let follow = true;\n    for (let i = 0; i < block.length && isBoolean(follow); i++) {\n        const locale = block[i];\n        if (isString(locale)) {\n            follow = appendLocaleToChain(chain, block[i], blocks);\n        }\n    }\n    return follow;\n}\nfunction appendLocaleToChain(chain, locale, blocks) {\n    let follow;\n    const tokens = locale.split('-');\n    do {\n        const target = tokens.join('-');\n        follow = appendItemToChain(chain, target, blocks);\n        tokens.splice(-1, 1);\n    } while (tokens.length && follow === true);\n    return follow;\n}\nfunction appendItemToChain(chain, target, blocks) {\n    let follow = false;\n    if (!chain.includes(target)) {\n        follow = true;\n        if (target) {\n            follow = target[target.length - 1] !== '!';\n            const locale = target.replace(/!/g, '');\n            chain.push(locale);\n            if ((isArray(blocks) || isPlainObject(blocks)) &&\n                blocks[locale] // eslint-disable-line @typescript-eslint/no-explicit-any\n            ) {\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                follow = blocks[locale];\n            }\n        }\n    }\n    return follow;\n}\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/**\n * Intlify core-base version\n * @internal\n */\nconst VERSION = '9.14.3';\nconst NOT_REOSLVED = -1;\nconst DEFAULT_LOCALE = 'en-US';\nconst MISSING_RESOLVE_VALUE = '';\nconst capitalize = (str) => `${str.charAt(0).toLocaleUpperCase()}${str.substr(1)}`;\nfunction getDefaultLinkedModifiers() {\n    return {\n        upper: (val, type) => {\n            // prettier-ignore\n            return type === 'text' && isString(val)\n                ? val.toUpperCase()\n                : type === 'vnode' && isObject(val) && '__v_isVNode' in val\n                    ? val.children.toUpperCase()\n                    : val;\n        },\n        lower: (val, type) => {\n            // prettier-ignore\n            return type === 'text' && isString(val)\n                ? val.toLowerCase()\n                : type === 'vnode' && isObject(val) && '__v_isVNode' in val\n                    ? val.children.toLowerCase()\n                    : val;\n        },\n        capitalize: (val, type) => {\n            // prettier-ignore\n            return (type === 'text' && isString(val)\n                ? capitalize(val)\n                : type === 'vnode' && isObject(val) && '__v_isVNode' in val\n                    ? capitalize(val.children)\n                    : val);\n        }\n    };\n}\nlet _compiler;\nfunction registerMessageCompiler(compiler) {\n    _compiler = compiler;\n}\nlet _resolver;\n/**\n * Register the message resolver\n *\n * @param resolver - A {@link MessageResolver} function\n *\n * @VueI18nGeneral\n */\nfunction registerMessageResolver(resolver) {\n    _resolver = resolver;\n}\nlet _fallbacker;\n/**\n * Register the locale fallbacker\n *\n * @param fallbacker - A {@link LocaleFallbacker} function\n *\n * @VueI18nGeneral\n */\nfunction registerLocaleFallbacker(fallbacker) {\n    _fallbacker = fallbacker;\n}\n// Additional Meta for Intlify DevTools\nlet _additionalMeta =  null;\n/* #__NO_SIDE_EFFECTS__ */\nconst setAdditionalMeta = (meta) => {\n    _additionalMeta = meta;\n};\n/* #__NO_SIDE_EFFECTS__ */\nconst getAdditionalMeta = () => _additionalMeta;\nlet _fallbackContext = null;\nconst setFallbackContext = (context) => {\n    _fallbackContext = context;\n};\nconst getFallbackContext = () => _fallbackContext;\n// ID for CoreContext\nlet _cid = 0;\nfunction createCoreContext(options = {}) {\n    // setup options\n    const onWarn = isFunction(options.onWarn) ? options.onWarn : warn;\n    const version = isString(options.version) ? options.version : VERSION;\n    const locale = isString(options.locale) || isFunction(options.locale)\n        ? options.locale\n        : DEFAULT_LOCALE;\n    const _locale = isFunction(locale) ? DEFAULT_LOCALE : locale;\n    const fallbackLocale = isArray(options.fallbackLocale) ||\n        isPlainObject(options.fallbackLocale) ||\n        isString(options.fallbackLocale) ||\n        options.fallbackLocale === false\n        ? options.fallbackLocale\n        : _locale;\n    const messages = isPlainObject(options.messages)\n        ? options.messages\n        : createResources(_locale);\n    const datetimeFormats = isPlainObject(options.datetimeFormats)\n            ? options.datetimeFormats\n            : createResources(_locale)\n        ;\n    const numberFormats = isPlainObject(options.numberFormats)\n            ? options.numberFormats\n            : createResources(_locale)\n        ;\n    const modifiers = assign(create(), options.modifiers, getDefaultLinkedModifiers());\n    const pluralRules = options.pluralRules || create();\n    const missing = isFunction(options.missing) ? options.missing : null;\n    const missingWarn = isBoolean(options.missingWarn) || isRegExp(options.missingWarn)\n        ? options.missingWarn\n        : true;\n    const fallbackWarn = isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn)\n        ? options.fallbackWarn\n        : true;\n    const fallbackFormat = !!options.fallbackFormat;\n    const unresolving = !!options.unresolving;\n    const postTranslation = isFunction(options.postTranslation)\n        ? options.postTranslation\n        : null;\n    const processor = isPlainObject(options.processor) ? options.processor : null;\n    const warnHtmlMessage = isBoolean(options.warnHtmlMessage)\n        ? options.warnHtmlMessage\n        : true;\n    const escapeParameter = !!options.escapeParameter;\n    const messageCompiler = isFunction(options.messageCompiler)\n        ? options.messageCompiler\n        : _compiler;\n    if ((process.env.NODE_ENV !== 'production') &&\n        !false &&\n        !false &&\n        isFunction(options.messageCompiler)) {\n        warnOnce(getWarnMessage(CoreWarnCodes.EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER));\n    }\n    const messageResolver = isFunction(options.messageResolver)\n        ? options.messageResolver\n        : _resolver || resolveWithKeyValue;\n    const localeFallbacker = isFunction(options.localeFallbacker)\n        ? options.localeFallbacker\n        : _fallbacker || fallbackWithSimple;\n    const fallbackContext = isObject(options.fallbackContext)\n        ? options.fallbackContext\n        : undefined;\n    // setup internal options\n    const internalOptions = options;\n    const __datetimeFormatters = isObject(internalOptions.__datetimeFormatters)\n            ? internalOptions.__datetimeFormatters\n            : new Map()\n        ;\n    const __numberFormatters = isObject(internalOptions.__numberFormatters)\n            ? internalOptions.__numberFormatters\n            : new Map()\n        ;\n    const __meta = isObject(internalOptions.__meta) ? internalOptions.__meta : {};\n    _cid++;\n    const context = {\n        version,\n        cid: _cid,\n        locale,\n        fallbackLocale,\n        messages,\n        modifiers,\n        pluralRules,\n        missing,\n        missingWarn,\n        fallbackWarn,\n        fallbackFormat,\n        unresolving,\n        postTranslation,\n        processor,\n        warnHtmlMessage,\n        escapeParameter,\n        messageCompiler,\n        messageResolver,\n        localeFallbacker,\n        fallbackContext,\n        onWarn,\n        __meta\n    };\n    {\n        context.datetimeFormats = datetimeFormats;\n        context.numberFormats = numberFormats;\n        context.__datetimeFormatters = __datetimeFormatters;\n        context.__numberFormatters = __numberFormatters;\n    }\n    // for vue-devtools timeline event\n    if ((process.env.NODE_ENV !== 'production')) {\n        context.__v_emitter =\n            internalOptions.__v_emitter != null\n                ? internalOptions.__v_emitter\n                : undefined;\n    }\n    // NOTE: experimental !!\n    if ((process.env.NODE_ENV !== 'production') || __INTLIFY_PROD_DEVTOOLS__) {\n        initI18nDevTools(context, version, __meta);\n    }\n    return context;\n}\nconst createResources = (locale) => ({ [locale]: create() });\n/** @internal */\nfunction isTranslateFallbackWarn(fallback, key) {\n    return fallback instanceof RegExp ? fallback.test(key) : fallback;\n}\n/** @internal */\nfunction isTranslateMissingWarn(missing, key) {\n    return missing instanceof RegExp ? missing.test(key) : missing;\n}\n/** @internal */\nfunction handleMissing(context, key, locale, missingWarn, type) {\n    const { missing, onWarn } = context;\n    // for vue-devtools timeline event\n    if ((process.env.NODE_ENV !== 'production')) {\n        const emitter = context.__v_emitter;\n        if (emitter) {\n            emitter.emit(\"missing\" /* VueDevToolsTimelineEvents.MISSING */, {\n                locale,\n                key,\n                type,\n                groupId: `${type}:${key}`\n            });\n        }\n    }\n    if (missing !== null) {\n        const ret = missing(context, locale, key, type);\n        return isString(ret) ? ret : key;\n    }\n    else {\n        if ((process.env.NODE_ENV !== 'production') && isTranslateMissingWarn(missingWarn, key)) {\n            onWarn(getWarnMessage(CoreWarnCodes.NOT_FOUND_KEY, { key, locale }));\n        }\n        return key;\n    }\n}\n/** @internal */\nfunction updateFallbackLocale(ctx, locale, fallback) {\n    const context = ctx;\n    context.__localeChainCache = new Map();\n    ctx.localeFallbacker(ctx, fallback, locale);\n}\n/** @internal */\nfunction isAlmostSameLocale(locale, compareLocale) {\n    if (locale === compareLocale)\n        return false;\n    return locale.split('-')[0] === compareLocale.split('-')[0];\n}\n/** @internal */\nfunction isImplicitFallback(targetLocale, locales) {\n    const index = locales.indexOf(targetLocale);\n    if (index === -1) {\n        return false;\n    }\n    for (let i = index + 1; i < locales.length; i++) {\n        if (isAlmostSameLocale(targetLocale, locales[i])) {\n            return true;\n        }\n    }\n    return false;\n}\n/* eslint-enable @typescript-eslint/no-explicit-any */\n\nfunction format(ast) {\n    const msg = (ctx) => formatParts(ctx, ast);\n    return msg;\n}\nfunction formatParts(ctx, ast) {\n    const body = resolveBody(ast);\n    if (body == null) {\n        throw createUnhandleNodeError(0 /* NodeTypes.Resource */);\n    }\n    const type = resolveType(body);\n    if (type === 1 /* NodeTypes.Plural */) {\n        const plural = body;\n        const cases = resolveCases(plural);\n        return ctx.plural(cases.reduce((messages, c) => [\n            ...messages,\n            formatMessageParts(ctx, c)\n        ], []));\n    }\n    else {\n        return formatMessageParts(ctx, body);\n    }\n}\nconst PROPS_BODY = ['b', 'body'];\nfunction resolveBody(node) {\n    return resolveProps(node, PROPS_BODY);\n}\nconst PROPS_CASES = ['c', 'cases'];\nfunction resolveCases(node) {\n    return resolveProps(node, PROPS_CASES, []);\n}\nfunction formatMessageParts(ctx, node) {\n    const static_ = resolveStatic(node);\n    if (static_ != null) {\n        return ctx.type === 'text'\n            ? static_\n            : ctx.normalize([static_]);\n    }\n    else {\n        const messages = resolveItems(node).reduce((acm, c) => [...acm, formatMessagePart(ctx, c)], []);\n        return ctx.normalize(messages);\n    }\n}\nconst PROPS_STATIC = ['s', 'static'];\nfunction resolveStatic(node) {\n    return resolveProps(node, PROPS_STATIC);\n}\nconst PROPS_ITEMS = ['i', 'items'];\nfunction resolveItems(node) {\n    return resolveProps(node, PROPS_ITEMS, []);\n}\nfunction formatMessagePart(ctx, node) {\n    const type = resolveType(node);\n    switch (type) {\n        case 3 /* NodeTypes.Text */: {\n            return resolveValue(node, type);\n        }\n        case 9 /* NodeTypes.Literal */: {\n            return resolveValue(node, type);\n        }\n        case 4 /* NodeTypes.Named */: {\n            const named = node;\n            if (hasOwn(named, 'k') && named.k) {\n                return ctx.interpolate(ctx.named(named.k));\n            }\n            if (hasOwn(named, 'key') && named.key) {\n                return ctx.interpolate(ctx.named(named.key));\n            }\n            throw createUnhandleNodeError(type);\n        }\n        case 5 /* NodeTypes.List */: {\n            const list = node;\n            if (hasOwn(list, 'i') && isNumber(list.i)) {\n                return ctx.interpolate(ctx.list(list.i));\n            }\n            if (hasOwn(list, 'index') && isNumber(list.index)) {\n                return ctx.interpolate(ctx.list(list.index));\n            }\n            throw createUnhandleNodeError(type);\n        }\n        case 6 /* NodeTypes.Linked */: {\n            const linked = node;\n            const modifier = resolveLinkedModifier(linked);\n            const key = resolveLinkedKey(linked);\n            return ctx.linked(formatMessagePart(ctx, key), modifier ? formatMessagePart(ctx, modifier) : undefined, ctx.type);\n        }\n        case 7 /* NodeTypes.LinkedKey */: {\n            return resolveValue(node, type);\n        }\n        case 8 /* NodeTypes.LinkedModifier */: {\n            return resolveValue(node, type);\n        }\n        default:\n            throw new Error(`unhandled node on format message part: ${type}`);\n    }\n}\nconst PROPS_TYPE = ['t', 'type'];\nfunction resolveType(node) {\n    return resolveProps(node, PROPS_TYPE);\n}\nconst PROPS_VALUE = ['v', 'value'];\nfunction resolveValue(node, type) {\n    const resolved = resolveProps(node, PROPS_VALUE);\n    if (resolved) {\n        return resolved;\n    }\n    else {\n        throw createUnhandleNodeError(type);\n    }\n}\nconst PROPS_MODIFIER = ['m', 'modifier'];\nfunction resolveLinkedModifier(node) {\n    return resolveProps(node, PROPS_MODIFIER);\n}\nconst PROPS_KEY = ['k', 'key'];\nfunction resolveLinkedKey(node) {\n    const resolved = resolveProps(node, PROPS_KEY);\n    if (resolved) {\n        return resolved;\n    }\n    else {\n        throw createUnhandleNodeError(6 /* NodeTypes.Linked */);\n    }\n}\nfunction resolveProps(node, props, defaultValue) {\n    for (let i = 0; i < props.length; i++) {\n        const prop = props[i];\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        if (hasOwn(node, prop) && node[prop] != null) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            return node[prop];\n        }\n    }\n    return defaultValue;\n}\nfunction createUnhandleNodeError(type) {\n    return new Error(`unhandled node type: ${type}`);\n}\n\nconst WARN_MESSAGE = `Detected HTML in '{source}' message. Recommend not using HTML messages to avoid XSS.`;\nfunction checkHtmlMessage(source, warnHtmlMessage) {\n    if (warnHtmlMessage && detectHtmlTag(source)) {\n        warn(format$1(WARN_MESSAGE, { source }));\n    }\n}\nconst defaultOnCacheKey = (message) => message;\nlet compileCache = create();\nfunction onCompileWarn(_warn) {\n    if (_warn.code === CompileWarnCodes.USE_MODULO_SYNTAX) {\n        warn(`The use of named interpolation with modulo syntax is deprecated. ` +\n            `It will be removed in v10.\\n` +\n            `reference: https://vue-i18n.intlify.dev/guide/essentials/syntax#rails-i18n-format \\n` +\n            `(message compiler warning message: ${_warn.message})`);\n    }\n}\nfunction clearCompileCache() {\n    compileCache = create();\n}\nfunction isMessageAST(val) {\n    return (isObject(val) &&\n        resolveType(val) === 0 &&\n        (hasOwn(val, 'b') || hasOwn(val, 'body')));\n}\nfunction baseCompile(message, options = {}) {\n    // error detecting on compile\n    let detectError = false;\n    const onError = options.onError || defaultOnError;\n    options.onError = (err) => {\n        detectError = true;\n        onError(err);\n    };\n    // compile with mesasge-compiler\n    return { ...baseCompile$1(message, options), detectError };\n}\n/* #__NO_SIDE_EFFECTS__ */\nconst compileToFunction = (message, context) => {\n    if (!isString(message)) {\n        throw createCoreError(CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE);\n    }\n    // set onWarn\n    if ((process.env.NODE_ENV !== 'production')) {\n        context.onWarn = onCompileWarn;\n    }\n    {\n        // check HTML message\n        const warnHtmlMessage = isBoolean(context.warnHtmlMessage)\n            ? context.warnHtmlMessage\n            : true;\n        (process.env.NODE_ENV !== 'production') && checkHtmlMessage(message, warnHtmlMessage);\n        // check caches\n        const onCacheKey = context.onCacheKey || defaultOnCacheKey;\n        const cacheKey = onCacheKey(message);\n        const cached = compileCache[cacheKey];\n        if (cached) {\n            return cached;\n        }\n        // compile\n        const { code, detectError } = baseCompile(message, context);\n        // evaluate function\n        const msg = new Function(`return ${code}`)();\n        // if occurred compile error, don't cache\n        return !detectError\n            ? (compileCache[cacheKey] = msg)\n            : msg;\n    }\n};\nfunction compile(message, context) {\n    // set onWarn\n    if ((process.env.NODE_ENV !== 'production')) {\n        context.onWarn = onCompileWarn;\n    }\n    if (((__INTLIFY_JIT_COMPILATION__ && !__INTLIFY_DROP_MESSAGE_COMPILER__)) &&\n        isString(message)) {\n        // check HTML message\n        const warnHtmlMessage = isBoolean(context.warnHtmlMessage)\n            ? context.warnHtmlMessage\n            : true;\n        (process.env.NODE_ENV !== 'production') && checkHtmlMessage(message, warnHtmlMessage);\n        // check caches\n        const onCacheKey = context.onCacheKey || defaultOnCacheKey;\n        const cacheKey = onCacheKey(message);\n        const cached = compileCache[cacheKey];\n        if (cached) {\n            return cached;\n        }\n        // compile with JIT mode\n        const { ast, detectError } = baseCompile(message, {\n            ...context,\n            location: (process.env.NODE_ENV !== 'production'),\n            jit: true\n        });\n        // compose message function from AST\n        const msg = format(ast);\n        // if occurred compile error, don't cache\n        return !detectError\n            ? (compileCache[cacheKey] = msg)\n            : msg;\n    }\n    else {\n        if ((process.env.NODE_ENV !== 'production') && !isMessageAST(message)) {\n            warn(`the message that is resolve with key '${context.key}' is not supported for jit compilation`);\n            return (() => message);\n        }\n        // AST case (passed from bundler)\n        const cacheKey = message.cacheKey;\n        if (cacheKey) {\n            const cached = compileCache[cacheKey];\n            if (cached) {\n                return cached;\n            }\n            // compose message function from message (AST)\n            return (compileCache[cacheKey] =\n                format(message));\n        }\n        else {\n            return format(message);\n        }\n    }\n}\n\nconst NOOP_MESSAGE_FUNCTION = () => '';\nconst isMessageFunction = (val) => isFunction(val);\n// implementation of `translate` function\nfunction translate(context, ...args) {\n    const { fallbackFormat, postTranslation, unresolving, messageCompiler, fallbackLocale, messages } = context;\n    const [key, options] = parseTranslateArgs(...args);\n    const missingWarn = isBoolean(options.missingWarn)\n        ? options.missingWarn\n        : context.missingWarn;\n    const fallbackWarn = isBoolean(options.fallbackWarn)\n        ? options.fallbackWarn\n        : context.fallbackWarn;\n    const escapeParameter = isBoolean(options.escapeParameter)\n        ? options.escapeParameter\n        : context.escapeParameter;\n    const resolvedMessage = !!options.resolvedMessage;\n    // prettier-ignore\n    const defaultMsgOrKey = isString(options.default) || isBoolean(options.default) // default by function option\n        ? !isBoolean(options.default)\n            ? options.default\n            : (!messageCompiler ? () => key : key)\n        : fallbackFormat // default by `fallbackFormat` option\n            ? (!messageCompiler ? () => key : key)\n            : '';\n    const enableDefaultMsg = fallbackFormat || defaultMsgOrKey !== '';\n    const locale = getLocale(context, options);\n    // escape params\n    escapeParameter && escapeParams(options);\n    // resolve message format\n    // eslint-disable-next-line prefer-const\n    let [formatScope, targetLocale, message] = !resolvedMessage\n        ? resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn)\n        : [\n            key,\n            locale,\n            messages[locale] || create()\n        ];\n    // NOTE:\n    //  Fix to work around `ssrTransfrom` bug in Vite.\n    //  https://github.com/vitejs/vite/issues/4306\n    //  To get around this, use temporary variables.\n    //  https://github.com/nuxt/framework/issues/1461#issuecomment-954606243\n    let format = formatScope;\n    // if you use default message, set it as message format!\n    let cacheBaseKey = key;\n    if (!resolvedMessage &&\n        !(isString(format) ||\n            isMessageAST(format) ||\n            isMessageFunction(format))) {\n        if (enableDefaultMsg) {\n            format = defaultMsgOrKey;\n            cacheBaseKey = format;\n        }\n    }\n    // checking message format and target locale\n    if (!resolvedMessage &&\n        (!(isString(format) ||\n            isMessageAST(format) ||\n            isMessageFunction(format)) ||\n            !isString(targetLocale))) {\n        return unresolving ? NOT_REOSLVED : key;\n    }\n    // TODO: refactor\n    if ((process.env.NODE_ENV !== 'production') && isString(format) && context.messageCompiler == null) {\n        warn(`The message format compilation is not supported in this build. ` +\n            `Because message compiler isn't included. ` +\n            `You need to pre-compilation all message format. ` +\n            `So translate function return '${key}'.`);\n        return key;\n    }\n    // setup compile error detecting\n    let occurred = false;\n    const onError = () => {\n        occurred = true;\n    };\n    // compile message format\n    const msg = !isMessageFunction(format)\n        ? compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError)\n        : format;\n    // if occurred compile error, return the message format\n    if (occurred) {\n        return format;\n    }\n    // evaluate message with context\n    const ctxOptions = getMessageContextOptions(context, targetLocale, message, options);\n    const msgContext = createMessageContext(ctxOptions);\n    const messaged = evaluateMessage(context, msg, msgContext);\n    // if use post translation option, proceed it with handler\n    const ret = postTranslation\n        ? postTranslation(messaged, key)\n        : messaged;\n    // NOTE: experimental !!\n    if ((process.env.NODE_ENV !== 'production') || __INTLIFY_PROD_DEVTOOLS__) {\n        // prettier-ignore\n        const payloads = {\n            timestamp: Date.now(),\n            key: isString(key)\n                ? key\n                : isMessageFunction(format)\n                    ? format.key\n                    : '',\n            locale: targetLocale || (isMessageFunction(format)\n                ? format.locale\n                : ''),\n            format: isString(format)\n                ? format\n                : isMessageFunction(format)\n                    ? format.source\n                    : '',\n            message: ret\n        };\n        payloads.meta = assign({}, context.__meta, getAdditionalMeta() || {});\n        translateDevTools(payloads);\n    }\n    return ret;\n}\nfunction escapeParams(options) {\n    if (isArray(options.list)) {\n        options.list = options.list.map(item => isString(item) ? escapeHtml(item) : item);\n    }\n    else if (isObject(options.named)) {\n        Object.keys(options.named).forEach(key => {\n            if (isString(options.named[key])) {\n                options.named[key] = escapeHtml(options.named[key]);\n            }\n        });\n    }\n}\nfunction resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn) {\n    const { messages, onWarn, messageResolver: resolveValue, localeFallbacker } = context;\n    const locales = localeFallbacker(context, fallbackLocale, locale); // eslint-disable-line @typescript-eslint/no-explicit-any\n    let message = create();\n    let targetLocale;\n    let format = null;\n    let from = locale;\n    let to = null;\n    const type = 'translate';\n    for (let i = 0; i < locales.length; i++) {\n        targetLocale = to = locales[i];\n        if ((process.env.NODE_ENV !== 'production') &&\n            locale !== targetLocale &&\n            !isAlmostSameLocale(locale, targetLocale) &&\n            isTranslateFallbackWarn(fallbackWarn, key)) {\n            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_TRANSLATE, {\n                key,\n                target: targetLocale\n            }));\n        }\n        // for vue-devtools timeline event\n        if ((process.env.NODE_ENV !== 'production') && locale !== targetLocale) {\n            const emitter = context.__v_emitter;\n            if (emitter) {\n                emitter.emit(\"fallback\" /* VueDevToolsTimelineEvents.FALBACK */, {\n                    type,\n                    key,\n                    from,\n                    to,\n                    groupId: `${type}:${key}`\n                });\n            }\n        }\n        message =\n            messages[targetLocale] || create();\n        // for vue-devtools timeline event\n        let start = null;\n        let startTag;\n        let endTag;\n        if ((process.env.NODE_ENV !== 'production') && inBrowser) {\n            start = window.performance.now();\n            startTag = 'intlify-message-resolve-start';\n            endTag = 'intlify-message-resolve-end';\n            mark && mark(startTag);\n        }\n        if ((format = resolveValue(message, key)) === null) {\n            // if null, resolve with object key path\n            format = message[key]; // eslint-disable-line @typescript-eslint/no-explicit-any\n        }\n        // for vue-devtools timeline event\n        if ((process.env.NODE_ENV !== 'production') && inBrowser) {\n            const end = window.performance.now();\n            const emitter = context.__v_emitter;\n            if (emitter && start && format) {\n                emitter.emit(\"message-resolve\" /* VueDevToolsTimelineEvents.MESSAGE_RESOLVE */, {\n                    type: \"message-resolve\" /* VueDevToolsTimelineEvents.MESSAGE_RESOLVE */,\n                    key,\n                    message: format,\n                    time: end - start,\n                    groupId: `${type}:${key}`\n                });\n            }\n            if (startTag && endTag && mark && measure) {\n                mark(endTag);\n                measure('intlify message resolve', startTag, endTag);\n            }\n        }\n        if (isString(format) || isMessageAST(format) || isMessageFunction(format)) {\n            break;\n        }\n        if (!isImplicitFallback(targetLocale, locales)) {\n            const missingRet = handleMissing(context, // eslint-disable-line @typescript-eslint/no-explicit-any\n            key, targetLocale, missingWarn, type);\n            if (missingRet !== key) {\n                format = missingRet;\n            }\n        }\n        from = to;\n    }\n    return [format, targetLocale, message];\n}\nfunction compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError) {\n    const { messageCompiler, warnHtmlMessage } = context;\n    if (isMessageFunction(format)) {\n        const msg = format;\n        msg.locale = msg.locale || targetLocale;\n        msg.key = msg.key || key;\n        return msg;\n    }\n    if (messageCompiler == null) {\n        const msg = (() => format);\n        msg.locale = targetLocale;\n        msg.key = key;\n        return msg;\n    }\n    // for vue-devtools timeline event\n    let start = null;\n    let startTag;\n    let endTag;\n    if ((process.env.NODE_ENV !== 'production') && inBrowser) {\n        start = window.performance.now();\n        startTag = 'intlify-message-compilation-start';\n        endTag = 'intlify-message-compilation-end';\n        mark && mark(startTag);\n    }\n    const msg = messageCompiler(format, getCompileContext(context, targetLocale, cacheBaseKey, format, warnHtmlMessage, onError));\n    // for vue-devtools timeline event\n    if ((process.env.NODE_ENV !== 'production') && inBrowser) {\n        const end = window.performance.now();\n        const emitter = context.__v_emitter;\n        if (emitter && start) {\n            emitter.emit(\"message-compilation\" /* VueDevToolsTimelineEvents.MESSAGE_COMPILATION */, {\n                type: \"message-compilation\" /* VueDevToolsTimelineEvents.MESSAGE_COMPILATION */,\n                message: format,\n                time: end - start,\n                groupId: `${'translate'}:${key}`\n            });\n        }\n        if (startTag && endTag && mark && measure) {\n            mark(endTag);\n            measure('intlify message compilation', startTag, endTag);\n        }\n    }\n    msg.locale = targetLocale;\n    msg.key = key;\n    msg.source = format;\n    return msg;\n}\nfunction evaluateMessage(context, msg, msgCtx) {\n    // for vue-devtools timeline event\n    let start = null;\n    let startTag;\n    let endTag;\n    if ((process.env.NODE_ENV !== 'production') && inBrowser) {\n        start = window.performance.now();\n        startTag = 'intlify-message-evaluation-start';\n        endTag = 'intlify-message-evaluation-end';\n        mark && mark(startTag);\n    }\n    const messaged = msg(msgCtx);\n    // for vue-devtools timeline event\n    if ((process.env.NODE_ENV !== 'production') && inBrowser) {\n        const end = window.performance.now();\n        const emitter = context.__v_emitter;\n        if (emitter && start) {\n            emitter.emit(\"message-evaluation\" /* VueDevToolsTimelineEvents.MESSAGE_EVALUATION */, {\n                type: \"message-evaluation\" /* VueDevToolsTimelineEvents.MESSAGE_EVALUATION */,\n                value: messaged,\n                time: end - start,\n                groupId: `${'translate'}:${msg.key}`\n            });\n        }\n        if (startTag && endTag && mark && measure) {\n            mark(endTag);\n            measure('intlify message evaluation', startTag, endTag);\n        }\n    }\n    return messaged;\n}\n/** @internal */\nfunction parseTranslateArgs(...args) {\n    const [arg1, arg2, arg3] = args;\n    const options = create();\n    if (!isString(arg1) &&\n        !isNumber(arg1) &&\n        !isMessageFunction(arg1) &&\n        !isMessageAST(arg1)) {\n        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);\n    }\n    // prettier-ignore\n    const key = isNumber(arg1)\n        ? String(arg1)\n        : isMessageFunction(arg1)\n            ? arg1\n            : arg1;\n    if (isNumber(arg2)) {\n        options.plural = arg2;\n    }\n    else if (isString(arg2)) {\n        options.default = arg2;\n    }\n    else if (isPlainObject(arg2) && !isEmptyObject(arg2)) {\n        options.named = arg2;\n    }\n    else if (isArray(arg2)) {\n        options.list = arg2;\n    }\n    if (isNumber(arg3)) {\n        options.plural = arg3;\n    }\n    else if (isString(arg3)) {\n        options.default = arg3;\n    }\n    else if (isPlainObject(arg3)) {\n        assign(options, arg3);\n    }\n    return [key, options];\n}\nfunction getCompileContext(context, locale, key, source, warnHtmlMessage, onError) {\n    return {\n        locale,\n        key,\n        warnHtmlMessage,\n        onError: (err) => {\n            onError && onError(err);\n            if ((process.env.NODE_ENV !== 'production')) {\n                const _source = getSourceForCodeFrame(source);\n                const message = `Message compilation error: ${err.message}`;\n                const codeFrame = err.location &&\n                    _source &&\n                    generateCodeFrame(_source, err.location.start.offset, err.location.end.offset);\n                const emitter = context.__v_emitter;\n                if (emitter && _source) {\n                    emitter.emit(\"compile-error\" /* VueDevToolsTimelineEvents.COMPILE_ERROR */, {\n                        message: _source,\n                        error: err.message,\n                        start: err.location && err.location.start.offset,\n                        end: err.location && err.location.end.offset,\n                        groupId: `${'translate'}:${key}`\n                    });\n                }\n                console.error(codeFrame ? `${message}\\n${codeFrame}` : message);\n            }\n            else {\n                throw err;\n            }\n        },\n        onCacheKey: (source) => generateFormatCacheKey(locale, key, source)\n    };\n}\nfunction getSourceForCodeFrame(source) {\n    if (isString(source)) {\n        return source;\n    }\n    else {\n        if (source.loc && source.loc.source) {\n            return source.loc.source;\n        }\n    }\n}\nfunction getMessageContextOptions(context, locale, message, options) {\n    const { modifiers, pluralRules, messageResolver: resolveValue, fallbackLocale, fallbackWarn, missingWarn, fallbackContext } = context;\n    const resolveMessage = (key) => {\n        let val = resolveValue(message, key);\n        // fallback to root context\n        if (val == null && fallbackContext) {\n            const [, , message] = resolveMessageFormat(fallbackContext, key, locale, fallbackLocale, fallbackWarn, missingWarn);\n            val = resolveValue(message, key);\n        }\n        if (isString(val) || isMessageAST(val)) {\n            let occurred = false;\n            const onError = () => {\n                occurred = true;\n            };\n            const msg = compileMessageFormat(context, key, locale, val, key, onError);\n            return !occurred\n                ? msg\n                : NOOP_MESSAGE_FUNCTION;\n        }\n        else if (isMessageFunction(val)) {\n            return val;\n        }\n        else {\n            // TODO: should be implemented warning message\n            return NOOP_MESSAGE_FUNCTION;\n        }\n    };\n    const ctxOptions = {\n        locale,\n        modifiers,\n        pluralRules,\n        messages: resolveMessage\n    };\n    if (context.processor) {\n        ctxOptions.processor = context.processor;\n    }\n    if (options.list) {\n        ctxOptions.list = options.list;\n    }\n    if (options.named) {\n        ctxOptions.named = options.named;\n    }\n    if (isNumber(options.plural)) {\n        ctxOptions.pluralIndex = options.plural;\n    }\n    return ctxOptions;\n}\n\nconst intlDefined = typeof Intl !== 'undefined';\nconst Availabilities = {\n    dateTimeFormat: intlDefined && typeof Intl.DateTimeFormat !== 'undefined',\n    numberFormat: intlDefined && typeof Intl.NumberFormat !== 'undefined'\n};\n\n// implementation of `datetime` function\nfunction datetime(context, ...args) {\n    const { datetimeFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;\n    const { __datetimeFormatters } = context;\n    if ((process.env.NODE_ENV !== 'production') && !Availabilities.dateTimeFormat) {\n        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_DATE));\n        return MISSING_RESOLVE_VALUE;\n    }\n    const [key, value, options, overrides] = parseDateTimeArgs(...args);\n    const missingWarn = isBoolean(options.missingWarn)\n        ? options.missingWarn\n        : context.missingWarn;\n    const fallbackWarn = isBoolean(options.fallbackWarn)\n        ? options.fallbackWarn\n        : context.fallbackWarn;\n    const part = !!options.part;\n    const locale = getLocale(context, options);\n    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any\n    fallbackLocale, locale);\n    if (!isString(key) || key === '') {\n        return new Intl.DateTimeFormat(locale, overrides).format(value);\n    }\n    // resolve format\n    let datetimeFormat = {};\n    let targetLocale;\n    let format = null;\n    let from = locale;\n    let to = null;\n    const type = 'datetime format';\n    for (let i = 0; i < locales.length; i++) {\n        targetLocale = to = locales[i];\n        if ((process.env.NODE_ENV !== 'production') &&\n            locale !== targetLocale &&\n            isTranslateFallbackWarn(fallbackWarn, key)) {\n            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_DATE_FORMAT, {\n                key,\n                target: targetLocale\n            }));\n        }\n        // for vue-devtools timeline event\n        if ((process.env.NODE_ENV !== 'production') && locale !== targetLocale) {\n            const emitter = context.__v_emitter;\n            if (emitter) {\n                emitter.emit(\"fallback\" /* VueDevToolsTimelineEvents.FALBACK */, {\n                    type,\n                    key,\n                    from,\n                    to,\n                    groupId: `${type}:${key}`\n                });\n            }\n        }\n        datetimeFormat =\n            datetimeFormats[targetLocale] || {};\n        format = datetimeFormat[key];\n        if (isPlainObject(format))\n            break;\n        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any\n        from = to;\n    }\n    // checking format and target locale\n    if (!isPlainObject(format) || !isString(targetLocale)) {\n        return unresolving ? NOT_REOSLVED : key;\n    }\n    let id = `${targetLocale}__${key}`;\n    if (!isEmptyObject(overrides)) {\n        id = `${id}__${JSON.stringify(overrides)}`;\n    }\n    let formatter = __datetimeFormatters.get(id);\n    if (!formatter) {\n        formatter = new Intl.DateTimeFormat(targetLocale, assign({}, format, overrides));\n        __datetimeFormatters.set(id, formatter);\n    }\n    return !part ? formatter.format(value) : formatter.formatToParts(value);\n}\n/** @internal */\nconst DATETIME_FORMAT_OPTIONS_KEYS = [\n    'localeMatcher',\n    'weekday',\n    'era',\n    'year',\n    'month',\n    'day',\n    'hour',\n    'minute',\n    'second',\n    'timeZoneName',\n    'formatMatcher',\n    'hour12',\n    'timeZone',\n    'dateStyle',\n    'timeStyle',\n    'calendar',\n    'dayPeriod',\n    'numberingSystem',\n    'hourCycle',\n    'fractionalSecondDigits'\n];\n/** @internal */\nfunction parseDateTimeArgs(...args) {\n    const [arg1, arg2, arg3, arg4] = args;\n    const options = create();\n    let overrides = create();\n    let value;\n    if (isString(arg1)) {\n        // Only allow ISO strings - other date formats are often supported,\n        // but may cause different results in different browsers.\n        const matches = arg1.match(/(\\d{4}-\\d{2}-\\d{2})(T|\\s)?(.*)/);\n        if (!matches) {\n            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);\n        }\n        // Some browsers can not parse the iso datetime separated by space,\n        // this is a compromise solution by replace the 'T'/' ' with 'T'\n        const dateTime = matches[3]\n            ? matches[3].trim().startsWith('T')\n                ? `${matches[1].trim()}${matches[3].trim()}`\n                : `${matches[1].trim()}T${matches[3].trim()}`\n            : matches[1].trim();\n        value = new Date(dateTime);\n        try {\n            // This will fail if the date is not valid\n            value.toISOString();\n        }\n        catch (e) {\n            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);\n        }\n    }\n    else if (isDate(arg1)) {\n        if (isNaN(arg1.getTime())) {\n            throw createCoreError(CoreErrorCodes.INVALID_DATE_ARGUMENT);\n        }\n        value = arg1;\n    }\n    else if (isNumber(arg1)) {\n        value = arg1;\n    }\n    else {\n        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);\n    }\n    if (isString(arg2)) {\n        options.key = arg2;\n    }\n    else if (isPlainObject(arg2)) {\n        Object.keys(arg2).forEach(key => {\n            if (DATETIME_FORMAT_OPTIONS_KEYS.includes(key)) {\n                overrides[key] = arg2[key];\n            }\n            else {\n                options[key] = arg2[key];\n            }\n        });\n    }\n    if (isString(arg3)) {\n        options.locale = arg3;\n    }\n    else if (isPlainObject(arg3)) {\n        overrides = arg3;\n    }\n    if (isPlainObject(arg4)) {\n        overrides = arg4;\n    }\n    return [options.key || '', value, options, overrides];\n}\n/** @internal */\nfunction clearDateTimeFormat(ctx, locale, format) {\n    const context = ctx;\n    for (const key in format) {\n        const id = `${locale}__${key}`;\n        if (!context.__datetimeFormatters.has(id)) {\n            continue;\n        }\n        context.__datetimeFormatters.delete(id);\n    }\n}\n\n// implementation of `number` function\nfunction number(context, ...args) {\n    const { numberFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;\n    const { __numberFormatters } = context;\n    if ((process.env.NODE_ENV !== 'production') && !Availabilities.numberFormat) {\n        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_NUMBER));\n        return MISSING_RESOLVE_VALUE;\n    }\n    const [key, value, options, overrides] = parseNumberArgs(...args);\n    const missingWarn = isBoolean(options.missingWarn)\n        ? options.missingWarn\n        : context.missingWarn;\n    const fallbackWarn = isBoolean(options.fallbackWarn)\n        ? options.fallbackWarn\n        : context.fallbackWarn;\n    const part = !!options.part;\n    const locale = getLocale(context, options);\n    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any\n    fallbackLocale, locale);\n    if (!isString(key) || key === '') {\n        return new Intl.NumberFormat(locale, overrides).format(value);\n    }\n    // resolve format\n    let numberFormat = {};\n    let targetLocale;\n    let format = null;\n    let from = locale;\n    let to = null;\n    const type = 'number format';\n    for (let i = 0; i < locales.length; i++) {\n        targetLocale = to = locales[i];\n        if ((process.env.NODE_ENV !== 'production') &&\n            locale !== targetLocale &&\n            isTranslateFallbackWarn(fallbackWarn, key)) {\n            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT, {\n                key,\n                target: targetLocale\n            }));\n        }\n        // for vue-devtools timeline event\n        if ((process.env.NODE_ENV !== 'production') && locale !== targetLocale) {\n            const emitter = context.__v_emitter;\n            if (emitter) {\n                emitter.emit(\"fallback\" /* VueDevToolsTimelineEvents.FALBACK */, {\n                    type,\n                    key,\n                    from,\n                    to,\n                    groupId: `${type}:${key}`\n                });\n            }\n        }\n        numberFormat =\n            numberFormats[targetLocale] || {};\n        format = numberFormat[key];\n        if (isPlainObject(format))\n            break;\n        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any\n        from = to;\n    }\n    // checking format and target locale\n    if (!isPlainObject(format) || !isString(targetLocale)) {\n        return unresolving ? NOT_REOSLVED : key;\n    }\n    let id = `${targetLocale}__${key}`;\n    if (!isEmptyObject(overrides)) {\n        id = `${id}__${JSON.stringify(overrides)}`;\n    }\n    let formatter = __numberFormatters.get(id);\n    if (!formatter) {\n        formatter = new Intl.NumberFormat(targetLocale, assign({}, format, overrides));\n        __numberFormatters.set(id, formatter);\n    }\n    return !part ? formatter.format(value) : formatter.formatToParts(value);\n}\n/** @internal */\nconst NUMBER_FORMAT_OPTIONS_KEYS = [\n    'localeMatcher',\n    'style',\n    'currency',\n    'currencyDisplay',\n    'currencySign',\n    'useGrouping',\n    'minimumIntegerDigits',\n    'minimumFractionDigits',\n    'maximumFractionDigits',\n    'minimumSignificantDigits',\n    'maximumSignificantDigits',\n    'compactDisplay',\n    'notation',\n    'signDisplay',\n    'unit',\n    'unitDisplay',\n    'roundingMode',\n    'roundingPriority',\n    'roundingIncrement',\n    'trailingZeroDisplay'\n];\n/** @internal */\nfunction parseNumberArgs(...args) {\n    const [arg1, arg2, arg3, arg4] = args;\n    const options = create();\n    let overrides = create();\n    if (!isNumber(arg1)) {\n        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);\n    }\n    const value = arg1;\n    if (isString(arg2)) {\n        options.key = arg2;\n    }\n    else if (isPlainObject(arg2)) {\n        Object.keys(arg2).forEach(key => {\n            if (NUMBER_FORMAT_OPTIONS_KEYS.includes(key)) {\n                overrides[key] = arg2[key];\n            }\n            else {\n                options[key] = arg2[key];\n            }\n        });\n    }\n    if (isString(arg3)) {\n        options.locale = arg3;\n    }\n    else if (isPlainObject(arg3)) {\n        overrides = arg3;\n    }\n    if (isPlainObject(arg4)) {\n        overrides = arg4;\n    }\n    return [options.key || '', value, options, overrides];\n}\n/** @internal */\nfunction clearNumberFormat(ctx, locale, format) {\n    const context = ctx;\n    for (const key in format) {\n        const id = `${locale}__${key}`;\n        if (!context.__numberFormatters.has(id)) {\n            continue;\n        }\n        context.__numberFormatters.delete(id);\n    }\n}\n\n{\n    initFeatureFlags();\n}\n\nexport { CoreErrorCodes, CoreWarnCodes, DATETIME_FORMAT_OPTIONS_KEYS, DEFAULT_LOCALE, DEFAULT_MESSAGE_DATA_TYPE, MISSING_RESOLVE_VALUE, NOT_REOSLVED, NUMBER_FORMAT_OPTIONS_KEYS, VERSION, clearCompileCache, clearDateTimeFormat, clearNumberFormat, compile, compileToFunction, createCoreContext, createCoreError, createMessageContext, datetime, fallbackWithLocaleChain, fallbackWithSimple, getAdditionalMeta, getDevToolsHook, getFallbackContext, getLocale, getWarnMessage, handleMissing, initI18nDevTools, isAlmostSameLocale, isImplicitFallback, isMessageAST, isMessageFunction, isTranslateFallbackWarn, isTranslateMissingWarn, number, parse, parseDateTimeArgs, parseNumberArgs, parseTranslateArgs, registerLocaleFallbacker, registerMessageCompiler, registerMessageResolver, resolveLocale, resolveValue$1 as resolveValue, resolveWithKeyValue, setAdditionalMeta, setDevToolsHook, setFallbackContext, translate, translateDevTools, updateFallbackLocale };\n"],"names":["pathStateMachine","literalValueRE","getPathCharType","ch","charCodeAt","cache","Map","resolveWithKeyValue","obj","path","resolveValue$1","hit","get","keys","c","key","newChar","type","transition","action","typeMap","index","mode","subPathDepth","actions","maybeUnescapeQuote","nextChar","undefined","push","trimmed","trim","charAt","isNaN","parseInt","exp","test","str","a","length","slice","stripQuotes","formatSubPath","parse","set","len","last","i","val","DEFAULT_MODIFIER","DEFAULT_MESSAGE","ctx","DEFAULT_MESSAGE_DATA_TYPE","DEFAULT_NORMALIZE","values","DEFAULT_INTERPOLATE","pluralDefault","choice","choicesLength","Math","abs","min","devtools","setDevToolsHook","hook","translateDevTools","createDevToolsHook","payloads","emit","code$1","__EXTEND_POINT__","inc$1","CoreWarnCodes","NOT_FOUND_KEY","FALLBACK_TO_TRANSLATE","CANNOT_FORMAT_NUMBER","FALLBACK_TO_NUMBER_FORMAT","CANNOT_FORMAT_DATE","FALLBACK_TO_DATE_FORMAT","EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER","code","inc","CoreErrorCodes","INVALID_ARGUMENT","INVALID_DATE_ARGUMENT","INVALID_ISO_DATE_ARGUMENT","NOT_SUPPORT_NON_STRING_MESSAGE","NOT_SUPPORT_LOCALE_PROMISE_VALUE","NOT_SUPPORT_LOCALE_ASYNC_FUNCTION","NOT_SUPPORT_LOCALE_TYPE","createCoreError","getLocale","context","options","locale","resolveLocale","_resolveLocale","resolvedOnce","constructor","name","resolve","fallbackWithSimple","fallback","start","Set","Object","fallbackWithLocaleChain","startLocale","DEFAULT_LOCALE","__localeChainCache","chain","block","appendBlockToChain","defaults","blocks","follow","appendLocaleToChain","tokens","split","appendItemToChain","join","splice","target","includes","replace","VERSION","NOT_REOSLVED","MISSING_RESOLVE_VALUE","capitalize","toLocaleUpperCase","substr","_compiler","_resolver","_fallbacker","registerMessageCompiler","compiler","registerMessageResolver","resolver","registerLocaleFallbacker","fallbacker","_additionalMeta","setAdditionalMeta","meta","getAdditionalMeta","_fallbackContext","setFallbackContext","getFallbackContext","_cid","createCoreContext","onWarn","version","_locale","fallbackLocale","messages","createResources","datetimeFormats","numberFormats","modifiers","upper","toUpperCase","children","lower","toLowerCase","pluralRules","missing","missingWarn","fallbackWarn","fallbackFormat","unresolving","postTranslation","processor","warnHtmlMessage","escapeParameter","messageCompiler","messageResolver","localeFallbacker","fallbackContext","internalOptions","__datetimeFormatters","__numberFormatters","__meta","cid","__INTLIFY_PROD_DEVTOOLS__","i18n","timestamp","Date","now","initI18nDevTools","handleMissing","ret","updateFallbackLocale","isImplicitFallback","targetLocale","locales","indexOf","compareLocale","format","ast","body","resolveProps","PROPS_BODY","createUnhandleNodeError","resolveType","cases","node","PROPS_CASES","resolveCases","plural","reduce","formatMessageParts","formatParts","static_","PROPS_STATIC","resolveStatic","normalize","PROPS_ITEMS","resolveItems","acm","formatMessagePart","resolved","PROPS_VALUE","resolveValue","named","k","interpolate","list","linked","modifier","PROPS_MODIFIER","resolveLinkedModifier","PROPS_KEY","resolveLinkedKey","Error","PROPS_TYPE","props","defaultValue","prop","defaultOnCacheKey","message","compileCache","isMessageAST","baseCompile","detectError","onError","err","compileToFunction","cacheKey","onCacheKey","cached","msg","Function","compile","__INTLIFY_JIT_COMPILATION__","__INTLIFY_DROP_MESSAGE_COMPILER__","location","jit","NOOP_MESSAGE_FUNCTION","isMessageFunction","translate","args","parseTranslateArgs","resolvedMessage","defaultMsgOrKey","default","enableDefaultMsg","map","item","forEach","escapeParams","formatScope","resolveMessageFormat","cacheBaseKey","occurred","compileMessageFormat","ctxOptions","pluralIndex","getMessageContextOptions","messaged","msgCtx","evaluateMessage","count","n","getPluralIndex","pluralRule","orgPluralRule","_list","_named","parent","normalizeNamed","arg1","arg2","createMessageContext","source","from","to","missingRet","getCompileContext","arg3","String","intlDefined","Intl","datetime","value","overrides","parseDateTimeArgs","part","DateTimeFormat","datetimeFormat","id","JSON","stringify","formatter","formatToParts","NumberFormat","DATETIME_FORMAT_OPTIONS_KEYS","arg4","matches","match","dateTime","startsWith","toISOString","e","getTime","clearDateTimeFormat","has","delete","number","parseNumberArgs","numberFormat","NUMBER_FORMAT_OPTIONS_KEYS","clearNumberFormat"],"sourceRoot":""}