@intlify/core-base 10.0.0-beta.6 → 10.0.0

package/dist/core-base.cjs

@@ -1,5 +1,5 @@
 /*!
-  * core-base v10.0.0-beta.6
+  * core-base v10.0.0
   * (c) 2024 kazuya kawaguchi
   * Released under the MIT License.
   */
@@ -8,402 +8,146 @@
 var messageCompiler = require('@intlify/message-compiler');
 var shared = require('@intlify/shared');
 
-const pathStateMachine =  [];
-pathStateMachine[0 /* States.BEFORE_PATH */] = {
-    ["w" /* PathCharTypes.WORKSPACE */]: [0 /* States.BEFORE_PATH */],
-    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
-    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
-    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
-};
-pathStateMachine[1 /* States.IN_PATH */] = {
-    ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */],
-    ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */],
-    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
-    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
-};
-pathStateMachine[2 /* States.BEFORE_IDENT */] = {
-    ["w" /* PathCharTypes.WORKSPACE */]: [2 /* States.BEFORE_IDENT */],
-    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
-    ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */]
-};
-pathStateMachine[3 /* States.IN_IDENT */] = {
-    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
-    ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
-    ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */, 1 /* Actions.PUSH */],
-    ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */, 1 /* Actions.PUSH */],
-    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */, 1 /* Actions.PUSH */],
-    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */, 1 /* Actions.PUSH */]
-};
-pathStateMachine[4 /* States.IN_SUB_PATH */] = {
-    ["'" /* PathCharTypes.SINGLE_QUOTE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */],
-    ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */],
-    ["[" /* PathCharTypes.LEFT_BRACKET */]: [
-        4 /* States.IN_SUB_PATH */,
-        2 /* Actions.INC_SUB_PATH_DEPTH */
-    ],
-    ["]" /* PathCharTypes.RIGHT_BRACKET */]: [1 /* States.IN_PATH */, 3 /* Actions.PUSH_SUB_PATH */],
-    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
-    ["l" /* PathCharTypes.ELSE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */]
-};
-pathStateMachine[5 /* States.IN_SINGLE_QUOTE */] = {
-    ["'" /* PathCharTypes.SINGLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
-    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
-    ["l" /* PathCharTypes.ELSE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */]
-};
-pathStateMachine[6 /* States.IN_DOUBLE_QUOTE */] = {
-    ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
-    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
-    ["l" /* PathCharTypes.ELSE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */]
-};
-/**
- * Check if an expression is a literal value.
- */
-const literalValueRE = /^\s?(?:true|false|-?[\d.]+|'[^']*'|"[^"]*")\s?$/;
-function isLiteral(exp) {
-    return literalValueRE.test(exp);
-}
-/**
- * Strip quotes from a string
- */
-function stripQuotes(str) {
-    const a = str.charCodeAt(0);
-    const b = str.charCodeAt(str.length - 1);
-    return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;
+function format(ast) {
+    const msg = (ctx) => formatParts(ctx, ast);
+    return msg;
 }
-/**
- * Determine the type of a character in a keypath.
- */
-function getPathCharType(ch) {
-    if (ch === undefined || ch === null) {
-        return "o" /* PathCharTypes.END_OF_FAIL */;
+function formatParts(ctx, ast) {
+    const body = ast.b || ast.body;
+    if ((body.t || body.type) === 1 /* NodeTypes.Plural */) {
+        const plural = body;
+        const cases = plural.c || plural.cases;
+        return ctx.plural(cases.reduce((messages, c) => [
+            ...messages,
+            formatMessageParts(ctx, c)
+        ], []));
     }
-    const code = ch.charCodeAt(0);
-    switch (code) {
-        case 0x5b: // [
-        case 0x5d: // ]
-        case 0x2e: // .
-        case 0x22: // "
-        case 0x27: // '
-            return ch;
-        case 0x5f: // _
-        case 0x24: // $
-        case 0x2d: // -
-            return "i" /* PathCharTypes.IDENT */;
-        case 0x09: // Tab (HT)
-        case 0x0a: // Newline (LF)
-        case 0x0d: // Return (CR)
-        case 0xa0: // No-break space (NBSP)
-        case 0xfeff: // Byte Order Mark (BOM)
-        case 0x2028: // Line Separator (LS)
-        case 0x2029: // Paragraph Separator (PS)
-            return "w" /* PathCharTypes.WORKSPACE */;
+    else {
+        return formatMessageParts(ctx, body);
     }
-    return "i" /* PathCharTypes.IDENT */;
 }
-/**
- * Format a subPath, return its plain form if it is
- * a literal string or number. Otherwise prepend the
- * dynamic indicator (*).
- */
-function formatSubPath(path) {
-    const trimmed = path.trim();
-    // invalid leading 0
-    if (path.charAt(0) === '0' && isNaN(parseInt(path))) {
-        return false;
+function formatMessageParts(ctx, node) {
+    const _static = node.s || node.static;
+    if (_static) {
+        return ctx.type === 'text'
+            ? _static
+            : ctx.normalize([_static]);
+    }
+    else {
+        const messages = (node.i || node.items).reduce((acm, c) => [...acm, formatMessagePart(ctx, c)], []);
+        return ctx.normalize(messages);
     }
-    return isLiteral(trimmed)
-        ? stripQuotes(trimmed)
-        : "*" /* PathCharTypes.ASTARISK */ + trimmed;
 }
-/**
- * Parse a string path into an array of segments
- */
-function parse(path) {
-    const keys = [];
-    let index = -1;
-    let mode = 0 /* States.BEFORE_PATH */;
-    let subPathDepth = 0;
-    let c;
-    let key; // eslint-disable-line
-    let newChar;
-    let type;
-    let transition;
-    let action;
-    let typeMap;
-    const actions = [];
-    actions[0 /* Actions.APPEND */] = () => {
-        if (key === undefined) {
-            key = newChar;
-        }
-        else {
-            key += newChar;
-        }
-    };
-    actions[1 /* Actions.PUSH */] = () => {
-        if (key !== undefined) {
-            keys.push(key);
-            key = undefined;
-        }
-    };
-    actions[2 /* Actions.INC_SUB_PATH_DEPTH */] = () => {
-        actions[0 /* Actions.APPEND */]();
-        subPathDepth++;
-    };
-    actions[3 /* Actions.PUSH_SUB_PATH */] = () => {
-        if (subPathDepth > 0) {
-            subPathDepth--;
-            mode = 4 /* States.IN_SUB_PATH */;
-            actions[0 /* Actions.APPEND */]();
+function formatMessagePart(ctx, node) {
+    const type = node.t || node.type;
+    switch (type) {
+        case 3 /* NodeTypes.Text */: {
+            const text = node;
+            return (text.v || text.value);
         }
-        else {
-            subPathDepth = 0;
-            if (key === undefined) {
-                return false;
-            }
-            key = formatSubPath(key);
-            if (key === false) {
-                return false;
-            }
-            else {
-                actions[1 /* Actions.PUSH */]();
-            }
+        case 9 /* NodeTypes.Literal */: {
+            const literal = node;
+            return (literal.v || literal.value);
         }
-    };
-    function maybeUnescapeQuote() {
-        const nextChar = path[index + 1];
-        if ((mode === 5 /* States.IN_SINGLE_QUOTE */ &&
-            nextChar === "'" /* PathCharTypes.SINGLE_QUOTE */) ||
-            (mode === 6 /* States.IN_DOUBLE_QUOTE */ &&
-                nextChar === "\"" /* PathCharTypes.DOUBLE_QUOTE */)) {
-            index++;
-            newChar = '\\' + nextChar;
-            actions[0 /* Actions.APPEND */]();
-            return true;
+        case 4 /* NodeTypes.Named */: {
+            const named = node;
+            return ctx.interpolate(ctx.named(named.k || named.key));
         }
-    }
-    while (mode !== null) {
-        index++;
-        c = path[index];
-        if (c === '\\' && maybeUnescapeQuote()) {
-            continue;
+        case 5 /* NodeTypes.List */: {
+            const list = node;
+            return ctx.interpolate(ctx.list(list.i != null ? list.i : list.index));
         }
-        type = getPathCharType(c);
-        typeMap = pathStateMachine[mode];
-        transition = typeMap[type] || typeMap["l" /* PathCharTypes.ELSE */] || 8 /* States.ERROR */;
-        // check parse error
-        if (transition === 8 /* States.ERROR */) {
-            return;
+        case 6 /* NodeTypes.Linked */: {
+            const linked = node;
+            const modifier = linked.m || linked.modifier;
+            return ctx.linked(formatMessagePart(ctx, linked.k || linked.key), modifier ? formatMessagePart(ctx, modifier) : undefined, ctx.type);
         }
-        mode = transition[0];
-        if (transition[1] !== undefined) {
-            action = actions[transition[1]];
-            if (action) {
-                newChar = c;
-                if (action() === false) {
-                    return;
-                }
-            }
+        case 7 /* NodeTypes.LinkedKey */: {
+            const linkedKey = node;
+            return (linkedKey.v || linkedKey.value);
         }
-        // check parse finish
-        if (mode === 7 /* States.AFTER_PATH */) {
-            return keys;
+        case 8 /* NodeTypes.LinkedModifier */: {
+            const linkedModifier = node;
+            return (linkedModifier.v || linkedModifier.value);
         }
+        default:
+            throw new Error(`unhandled node type on format message part: ${type}`);
     }
 }
-// path token cache
-const cache = new Map();
-/**
- * key-value message resolver
- *
- * @remarks
- * Resolves messages with the key-value structure. Note that messages with a hierarchical structure such as objects cannot be resolved
- *
- * @param obj - A target object to be resolved with path
- * @param path - A {@link Path | path} to resolve the value of message
- *
- * @returns A resolved {@link PathValue | path value}
- *
- * @VueI18nGeneral
- */
-function resolveWithKeyValue(obj, path) {
-    return shared.isObject(obj) ? obj[path] : null;
-}
-/**
- * message resolver
- *
- * @remarks
- * Resolves messages. messages with a hierarchical structure such as objects can be resolved. This resolver is used in VueI18n as default.
- *
- * @param obj - A target object to be resolved with path
- * @param path - A {@link Path | path} to resolve the value of message
- *
- * @returns A resolved {@link PathValue | path value}
- *
- * @VueI18nGeneral
- */
-function resolveValue(obj, path) {
-    // check object
-    if (!shared.isObject(obj)) {
-        return null;
-    }
-    // parse path
-    let hit = cache.get(path);
-    if (!hit) {
-        hit = parse(path);
-        if (hit) {
-            cache.set(path, hit);
-        }
-    }
-    // check hit
-    if (!hit) {
-        return null;
-    }
-    // resolve path value
-    const len = hit.length;
-    let last = obj;
-    let i = 0;
-    while (i < len) {
-        const val = last[hit[i]];
-        if (val === undefined) {
-            return null;
-        }
-        if (shared.isFunction(last)) {
-            return null;
-        }
-        last = val;
-        i++;
-    }
-    return last;
-}
 
-const DEFAULT_MODIFIER = (str) => str;
-const DEFAULT_MESSAGE = (ctx) => ''; // eslint-disable-line
-const DEFAULT_MESSAGE_DATA_TYPE = 'text';
-const DEFAULT_NORMALIZE = (values) => values.length === 0 ? '' : shared.join(values);
-const DEFAULT_INTERPOLATE = shared.toDisplayString;
-function pluralDefault(choice, choicesLength) {
-    choice = Math.abs(choice);
-    if (choicesLength === 2) {
-        // prettier-ignore
-        return choice
-            ? choice > 1
-                ? 1
-                : 0
-            : 1;
+const WARN_MESSAGE = `Detected HTML in '{source}' message. Recommend not using HTML messages to avoid XSS.`;
+function checkHtmlMessage(source, warnHtmlMessage) {
+    if (warnHtmlMessage && messageCompiler.detectHtmlTag(source)) {
+        shared.warn(shared.format(WARN_MESSAGE, { source }));
     }
-    return choice ? Math.min(choice, 2) : 0;
-}
-function getPluralIndex(options) {
-    // prettier-ignore
-    const index = shared.isNumber(options.pluralIndex)
-        ? options.pluralIndex
-        : -1;
-    // prettier-ignore
-    return options.named && (shared.isNumber(options.named.count) || shared.isNumber(options.named.n))
-        ? shared.isNumber(options.named.count)
-            ? options.named.count
-            : shared.isNumber(options.named.n)
-                ? options.named.n
-                : index
-        : index;
 }
-function normalizeNamed(pluralIndex, props) {
-    if (!props.count) {
-        props.count = pluralIndex;
-    }
-    if (!props.n) {
-        props.n = pluralIndex;
-    }
+const defaultOnCacheKey = (message) => message;
+let compileCache = Object.create(null);
+function clearCompileCache() {
+    compileCache = Object.create(null);
 }
-function createMessageContext(options = {}) {
-    const locale = options.locale;
-    const pluralIndex = getPluralIndex(options);
-    const pluralRule = shared.isObject(options.pluralRules) &&
-        shared.isString(locale) &&
-        shared.isFunction(options.pluralRules[locale])
-        ? options.pluralRules[locale]
-        : pluralDefault;
-    const orgPluralRule = shared.isObject(options.pluralRules) &&
-        shared.isString(locale) &&
-        shared.isFunction(options.pluralRules[locale])
-        ? pluralDefault
-        : undefined;
-    const plural = (messages) => {
-        return messages[pluralRule(pluralIndex, messages.length, orgPluralRule)];
+const isMessageAST = (val) => shared.isObject(val) &&
+    (val.t === 0 || val.type === 0) &&
+    ('b' in val || 'body' in val);
+function baseCompile(message, options = {}) {
+    // error detecting on compile
+    let detectError = false;
+    const onError = options.onError || messageCompiler.defaultOnError;
+    options.onError = (err) => {
+        detectError = true;
+        onError(err);
     };
-    const _list = options.list || [];
-    const list = (index) => _list[index];
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const _named = options.named || {};
-    shared.isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);
-    const named = (key) => _named[key];
-    function message(key, useLinked) {
-        // prettier-ignore
-        const msg = shared.isFunction(options.messages)
-            ? options.messages(key, !!useLinked)
-            : shared.isObject(options.messages)
-                ? options.messages[key]
-                : false;
-        return !msg
-            ? options.parent
-                ? options.parent.message(key) // resolve from parent messages
-                : DEFAULT_MESSAGE
+    // compile with mesasge-compiler
+    return { ...messageCompiler.baseCompile(message, options), detectError };
+}
+/* #__NO_SIDE_EFFECTS__ */
+function compile(message, context) {
+    if (shared.isString(message)) {
+        // check HTML message
+        const warnHtmlMessage = shared.isBoolean(context.warnHtmlMessage)
+            ? context.warnHtmlMessage
+            : true;
+        checkHtmlMessage(message, warnHtmlMessage);
+        // check caches
+        const onCacheKey = context.onCacheKey || defaultOnCacheKey;
+        const cacheKey = onCacheKey(message);
+        const cached = compileCache[cacheKey];
+        if (cached) {
+            return cached;
+        }
+        // compile with JIT mode
+        const { ast, detectError } = baseCompile(message, {
+            ...context,
+            location: true,
+            jit: true
+        });
+        // compose message function from AST
+        const msg = format(ast);
+        // if occurred compile error, don't cache
+        return !detectError
+            ? (compileCache[cacheKey] = msg)
             : msg;
     }
-    const _modifier = (name) => options.modifiers
-        ? options.modifiers[name]
-        : DEFAULT_MODIFIER;
-    const normalize = shared.isPlainObject(options.processor) && shared.isFunction(options.processor.normalize)
-        ? options.processor.normalize
-        : DEFAULT_NORMALIZE;
-    const interpolate = shared.isPlainObject(options.processor) &&
-        shared.isFunction(options.processor.interpolate)
-        ? options.processor.interpolate
-        : DEFAULT_INTERPOLATE;
-    const type = shared.isPlainObject(options.processor) && shared.isString(options.processor.type)
-        ? options.processor.type
-        : DEFAULT_MESSAGE_DATA_TYPE;
-    const linked = (key, ...args) => {
-        const [arg1, arg2] = args;
-        let type = 'text';
-        let modifier = '';
-        if (args.length === 1) {
-            if (shared.isObject(arg1)) {
-                modifier = arg1.modifier || modifier;
-                type = arg1.type || type;
-            }
-            else if (shared.isString(arg1)) {
-                modifier = arg1 || modifier;
-            }
+    else {
+        if (!isMessageAST(message)) {
+            shared.warn(`the message that is resolve with key '${context.key}' is not supported for jit compilation`);
+            return (() => message);
         }
-        else if (args.length === 2) {
-            if (shared.isString(arg1)) {
-                modifier = arg1 || modifier;
-            }
-            if (shared.isString(arg2)) {
-                type = arg2 || type;
+        // AST case (passed from bundler)
+        const cacheKey = message.cacheKey;
+        if (cacheKey) {
+            const cached = compileCache[cacheKey];
+            if (cached) {
+                return cached;
             }
+            // compose message function from message (AST)
+            return (compileCache[cacheKey] =
+                format(message));
         }
-        const ret = message(key, true)(ctx);
-        const msg = 
-        // The message in vnode resolved with linked are returned as an array by processor.nomalize
-        type === 'vnode' && shared.isArray(ret) && modifier
-            ? ret[0]
-            : ret;
-        return modifier ? _modifier(modifier)(msg, type) : msg;
-    };
-    const ctx = {
-        ["list" /* HelperNameMap.LIST */]: list,
-        ["named" /* HelperNameMap.NAMED */]: named,
-        ["plural" /* HelperNameMap.PLURAL */]: plural,
-        ["linked" /* HelperNameMap.LINKED */]: linked,
-        ["message" /* HelperNameMap.MESSAGE */]: message,
-        ["type" /* HelperNameMap.TYPE */]: type,
-        ["interpolate" /* HelperNameMap.INTERPOLATE */]: interpolate,
-        ["normalize" /* HelperNameMap.NORMALIZE */]: normalize,
-        ["values" /* HelperNameMap.VALUES */]: shared.assign({}, _list, _named)
-    };
-    return ctx;
+        else {
+            return format(message);
+        }
+    }
 }
 
 let devtools = null;
@@ -429,30 +173,6 @@ function createDevToolsHook(hook) {
     return (payloads) => devtools && devtools.emit(hook, payloads);
 }
 
-const CoreWarnCodes = {
-    NOT_FOUND_KEY: 1,
-    FALLBACK_TO_TRANSLATE: 2,
-    CANNOT_FORMAT_NUMBER: 3,
-    FALLBACK_TO_NUMBER_FORMAT: 4,
-    CANNOT_FORMAT_DATE: 5,
-    FALLBACK_TO_DATE_FORMAT: 6,
-    EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER: 7
-};
-const CORE_WARN_CODES_EXTEND_POINT = 8;
-/** @internal */
-const warnMessages = {
-    [CoreWarnCodes.NOT_FOUND_KEY]: `Not found '{key}' key in '{locale}' locale messages.`,
-    [CoreWarnCodes.FALLBACK_TO_TRANSLATE]: `Fall back to translate '{key}' key with '{target}' locale.`,
-    [CoreWarnCodes.CANNOT_FORMAT_NUMBER]: `Cannot format a number value due to not supported Intl.NumberFormat.`,
-    [CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT]: `Fall back to number format '{key}' key with '{target}' locale.`,
-    [CoreWarnCodes.CANNOT_FORMAT_DATE]: `Cannot format a date value due to not supported Intl.DateTimeFormat.`,
-    [CoreWarnCodes.FALLBACK_TO_DATE_FORMAT]: `Fall back to datetime format '{key}' key with '{target}' locale.`,
-    [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.`
-};
-function getWarnMessage(code, ...args) {
-    return shared.format(warnMessages[code], ...args);
-}
-
 const CoreErrorCodes = {
     INVALID_ARGUMENT: messageCompiler.COMPILE_ERROR_CODES_EXTEND_POINT, // 17
     INVALID_DATE_ARGUMENT: 18,
@@ -626,64 +346,356 @@ function appendItemToChain(chain, target, blocks) {
     return follow;
 }
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * Intlify core-base version
- * @internal
+const pathStateMachine =  [];
+pathStateMachine[0 /* States.BEFORE_PATH */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [0 /* States.BEFORE_PATH */],
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
+};
+pathStateMachine[1 /* States.IN_PATH */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */],
+    ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
+};
+pathStateMachine[2 /* States.BEFORE_IDENT */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [2 /* States.BEFORE_IDENT */],
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[3 /* States.IN_IDENT */] = {
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */, 1 /* Actions.PUSH */],
+    ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */, 1 /* Actions.PUSH */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */, 1 /* Actions.PUSH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */, 1 /* Actions.PUSH */]
+};
+pathStateMachine[4 /* States.IN_SUB_PATH */] = {
+    ["'" /* PathCharTypes.SINGLE_QUOTE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */],
+    ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [
+        4 /* States.IN_SUB_PATH */,
+        2 /* Actions.INC_SUB_PATH_DEPTH */
+    ],
+    ["]" /* PathCharTypes.RIGHT_BRACKET */]: [1 /* States.IN_PATH */, 3 /* Actions.PUSH_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[5 /* States.IN_SINGLE_QUOTE */] = {
+    ["'" /* PathCharTypes.SINGLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[6 /* States.IN_DOUBLE_QUOTE */] = {
+    ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */]
+};
+/**
+ * Check if an expression is a literal value.
  */
-const VERSION = '10.0.0-beta.6';
-const NOT_REOSLVED = -1;
-const DEFAULT_LOCALE = 'en-US';
-const MISSING_RESOLVE_VALUE = '';
-const capitalize = (str) => `${str.charAt(0).toLocaleUpperCase()}${str.substr(1)}`;
-function getDefaultLinkedModifiers() {
-    return {
-        upper: (val, type) => {
-            // prettier-ignore
-            return type === 'text' && shared.isString(val)
-                ? val.toUpperCase()
-                : type === 'vnode' && shared.isObject(val) && '__v_isVNode' in val
-                    ? val.children.toUpperCase()
-                    : val;
-        },
-        lower: (val, type) => {
-            // prettier-ignore
-            return type === 'text' && shared.isString(val)
-                ? val.toLowerCase()
-                : type === 'vnode' && shared.isObject(val) && '__v_isVNode' in val
-                    ? val.children.toLowerCase()
-                    : val;
-        },
-        capitalize: (val, type) => {
-            // prettier-ignore
-            return (type === 'text' && shared.isString(val)
-                ? capitalize(val)
-                : type === 'vnode' && shared.isObject(val) && '__v_isVNode' in val
-                    ? capitalize(val.children)
-                    : val);
+const literalValueRE = /^\s?(?:true|false|-?[\d.]+|'[^']*'|"[^"]*")\s?$/;
+function isLiteral(exp) {
+    return literalValueRE.test(exp);
+}
+/**
+ * Strip quotes from a string
+ */
+function stripQuotes(str) {
+    const a = str.charCodeAt(0);
+    const b = str.charCodeAt(str.length - 1);
+    return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;
+}
+/**
+ * Determine the type of a character in a keypath.
+ */
+function getPathCharType(ch) {
+    if (ch === undefined || ch === null) {
+        return "o" /* PathCharTypes.END_OF_FAIL */;
+    }
+    const code = ch.charCodeAt(0);
+    switch (code) {
+        case 0x5b: // [
+        case 0x5d: // ]
+        case 0x2e: // .
+        case 0x22: // "
+        case 0x27: // '
+            return ch;
+        case 0x5f: // _
+        case 0x24: // $
+        case 0x2d: // -
+            return "i" /* PathCharTypes.IDENT */;
+        case 0x09: // Tab (HT)
+        case 0x0a: // Newline (LF)
+        case 0x0d: // Return (CR)
+        case 0xa0: // No-break space (NBSP)
+        case 0xfeff: // Byte Order Mark (BOM)
+        case 0x2028: // Line Separator (LS)
+        case 0x2029: // Paragraph Separator (PS)
+            return "w" /* PathCharTypes.WORKSPACE */;
+    }
+    return "i" /* PathCharTypes.IDENT */;
+}
+/**
+ * Format a subPath, return its plain form if it is
+ * a literal string or number. Otherwise prepend the
+ * dynamic indicator (*).
+ */
+function formatSubPath(path) {
+    const trimmed = path.trim();
+    // invalid leading 0
+    if (path.charAt(0) === '0' && isNaN(parseInt(path))) {
+        return false;
+    }
+    return isLiteral(trimmed)
+        ? stripQuotes(trimmed)
+        : "*" /* PathCharTypes.ASTARISK */ + trimmed;
+}
+/**
+ * Parse a string path into an array of segments
+ */
+function parse(path) {
+    const keys = [];
+    let index = -1;
+    let mode = 0 /* States.BEFORE_PATH */;
+    let subPathDepth = 0;
+    let c;
+    let key; // eslint-disable-line
+    let newChar;
+    let type;
+    let transition;
+    let action;
+    let typeMap;
+    const actions = [];
+    actions[0 /* Actions.APPEND */] = () => {
+        if (key === undefined) {
+            key = newChar;
+        }
+        else {
+            key += newChar;
         }
     };
+    actions[1 /* Actions.PUSH */] = () => {
+        if (key !== undefined) {
+            keys.push(key);
+            key = undefined;
+        }
+    };
+    actions[2 /* Actions.INC_SUB_PATH_DEPTH */] = () => {
+        actions[0 /* Actions.APPEND */]();
+        subPathDepth++;
+    };
+    actions[3 /* Actions.PUSH_SUB_PATH */] = () => {
+        if (subPathDepth > 0) {
+            subPathDepth--;
+            mode = 4 /* States.IN_SUB_PATH */;
+            actions[0 /* Actions.APPEND */]();
+        }
+        else {
+            subPathDepth = 0;
+            if (key === undefined) {
+                return false;
+            }
+            key = formatSubPath(key);
+            if (key === false) {
+                return false;
+            }
+            else {
+                actions[1 /* Actions.PUSH */]();
+            }
+        }
+    };
+    function maybeUnescapeQuote() {
+        const nextChar = path[index + 1];
+        if ((mode === 5 /* States.IN_SINGLE_QUOTE */ &&
+            nextChar === "'" /* PathCharTypes.SINGLE_QUOTE */) ||
+            (mode === 6 /* States.IN_DOUBLE_QUOTE */ &&
+                nextChar === "\"" /* PathCharTypes.DOUBLE_QUOTE */)) {
+            index++;
+            newChar = '\\' + nextChar;
+            actions[0 /* Actions.APPEND */]();
+            return true;
+        }
+    }
+    while (mode !== null) {
+        index++;
+        c = path[index];
+        if (c === '\\' && maybeUnescapeQuote()) {
+            continue;
+        }
+        type = getPathCharType(c);
+        typeMap = pathStateMachine[mode];
+        transition = typeMap[type] || typeMap["l" /* PathCharTypes.ELSE */] || 8 /* States.ERROR */;
+        // check parse error
+        if (transition === 8 /* States.ERROR */) {
+            return;
+        }
+        mode = transition[0];
+        if (transition[1] !== undefined) {
+            action = actions[transition[1]];
+            if (action) {
+                newChar = c;
+                if (action() === false) {
+                    return;
+                }
+            }
+        }
+        // check parse finish
+        if (mode === 7 /* States.AFTER_PATH */) {
+            return keys;
+        }
+    }
 }
-let _compiler;
-function registerMessageCompiler(compiler) {
-    _compiler = compiler;
-}
-let _resolver;
+// path token cache
+const cache = new Map();
 /**
- * Register the message resolver
+ * key-value message resolver
  *
- * @param resolver - A {@link MessageResolver} function
+ * @remarks
+ * Resolves messages with the key-value structure. Note that messages with a hierarchical structure such as objects cannot be resolved
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
  *
  * @VueI18nGeneral
  */
-function registerMessageResolver(resolver) {
-    _resolver = resolver;
+function resolveWithKeyValue(obj, path) {
+    return shared.isObject(obj) ? obj[path] : null;
 }
-let _fallbacker;
 /**
- * Register the locale fallbacker
+ * message resolver
  *
- * @param fallbacker - A {@link LocaleFallbacker} function
+ * @remarks
+ * Resolves messages. messages with a hierarchical structure such as objects can be resolved. This resolver is used in VueI18n as default.
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+function resolveValue(obj, path) {
+    // check object
+    if (!shared.isObject(obj)) {
+        return null;
+    }
+    // parse path
+    let hit = cache.get(path);
+    if (!hit) {
+        hit = parse(path);
+        if (hit) {
+            cache.set(path, hit);
+        }
+    }
+    // check hit
+    if (!hit) {
+        return null;
+    }
+    // resolve path value
+    const len = hit.length;
+    let last = obj;
+    let i = 0;
+    while (i < len) {
+        const val = last[hit[i]];
+        if (val === undefined) {
+            return null;
+        }
+        if (shared.isFunction(last)) {
+            return null;
+        }
+        last = val;
+        i++;
+    }
+    return last;
+}
+
+const CoreWarnCodes = {
+    NOT_FOUND_KEY: 1,
+    FALLBACK_TO_TRANSLATE: 2,
+    CANNOT_FORMAT_NUMBER: 3,
+    FALLBACK_TO_NUMBER_FORMAT: 4,
+    CANNOT_FORMAT_DATE: 5,
+    FALLBACK_TO_DATE_FORMAT: 6,
+    EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER: 7
+};
+const CORE_WARN_CODES_EXTEND_POINT = 8;
+/** @internal */
+const warnMessages = {
+    [CoreWarnCodes.NOT_FOUND_KEY]: `Not found '{key}' key in '{locale}' locale messages.`,
+    [CoreWarnCodes.FALLBACK_TO_TRANSLATE]: `Fall back to translate '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.CANNOT_FORMAT_NUMBER]: `Cannot format a number value due to not supported Intl.NumberFormat.`,
+    [CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT]: `Fall back to number format '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.CANNOT_FORMAT_DATE]: `Cannot format a date value due to not supported Intl.DateTimeFormat.`,
+    [CoreWarnCodes.FALLBACK_TO_DATE_FORMAT]: `Fall back to datetime format '{key}' key with '{target}' locale.`,
+    [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.`
+};
+function getWarnMessage(code, ...args) {
+    return shared.format(warnMessages[code], ...args);
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Intlify core-base version
+ * @internal
+ */
+const VERSION = '10.0.0';
+const NOT_REOSLVED = -1;
+const DEFAULT_LOCALE = 'en-US';
+const MISSING_RESOLVE_VALUE = '';
+const capitalize = (str) => `${str.charAt(0).toLocaleUpperCase()}${str.substr(1)}`;
+function getDefaultLinkedModifiers() {
+    return {
+        upper: (val, type) => {
+            // prettier-ignore
+            return type === 'text' && shared.isString(val)
+                ? val.toUpperCase()
+                : type === 'vnode' && shared.isObject(val) && '__v_isVNode' in val
+                    ? val.children.toUpperCase()
+                    : val;
+        },
+        lower: (val, type) => {
+            // prettier-ignore
+            return type === 'text' && shared.isString(val)
+                ? val.toLowerCase()
+                : type === 'vnode' && shared.isObject(val) && '__v_isVNode' in val
+                    ? val.children.toLowerCase()
+                    : val;
+        },
+        capitalize: (val, type) => {
+            // prettier-ignore
+            return (type === 'text' && shared.isString(val)
+                ? capitalize(val)
+                : type === 'vnode' && shared.isObject(val) && '__v_isVNode' in val
+                    ? capitalize(val.children)
+                    : val);
+        }
+    };
+}
+let _compiler;
+function registerMessageCompiler(compiler) {
+    _compiler = compiler;
+}
+let _resolver;
+/**
+ * Register the message resolver
+ *
+ * @param resolver - A {@link MessageResolver} function
+ *
+ * @VueI18nGeneral
+ */
+function registerMessageResolver(resolver) {
+    _resolver = resolver;
+}
+let _fallbacker;
+/**
+ * Register the locale fallbacker
+ *
+ * @param fallbacker - A {@link LocaleFallbacker} function
  *
  * @VueI18nGeneral
  */
@@ -806,652 +818,269 @@ function createCoreContext(options = {}) {
         context.__datetimeFormatters = __datetimeFormatters;
         context.__numberFormatters = __numberFormatters;
     }
-    // for vue-devtools timeline event
-    {
-        context.__v_emitter =
-            internalOptions.__v_emitter != null
-                ? internalOptions.__v_emitter
-                : undefined;
-    }
-    // NOTE: experimental !!
-    {
-        initI18nDevTools(context, version, __meta);
-    }
-    return context;
-}
-/** @internal */
-function isTranslateFallbackWarn(fallback, key) {
-    return fallback instanceof RegExp ? fallback.test(key) : fallback;
-}
-/** @internal */
-function isTranslateMissingWarn(missing, key) {
-    return missing instanceof RegExp ? missing.test(key) : missing;
-}
-/** @internal */
-function handleMissing(context, key, locale, missingWarn, type) {
-    const { missing, onWarn } = context;
-    // for vue-devtools timeline event
-    {
-        const emitter = context.__v_emitter;
-        if (emitter) {
-            emitter.emit('missing', {
-                locale,
-                key,
-                type,
-                groupId: `${type}:${key}`
-            });
-        }
-    }
-    if (missing !== null) {
-        const ret = missing(context, locale, key, type);
-        return shared.isString(ret) ? ret : key;
-    }
-    else {
-        if (isTranslateMissingWarn(missingWarn, key)) {
-            onWarn(getWarnMessage(CoreWarnCodes.NOT_FOUND_KEY, { key, locale }));
-        }
-        return key;
-    }
-}
-/** @internal */
-function updateFallbackLocale(ctx, locale, fallback) {
-    const context = ctx;
-    context.__localeChainCache = new Map();
-    ctx.localeFallbacker(ctx, fallback, locale);
-}
-/** @internal */
-function isAlmostSameLocale(locale, compareLocale) {
-    if (locale === compareLocale)
-        return false;
-    return locale.split('-')[0] === compareLocale.split('-')[0];
-}
-/** @internal */
-function isImplicitFallback(targetLocale, locales) {
-    const index = locales.indexOf(targetLocale);
-    if (index === -1) {
-        return false;
-    }
-    for (let i = index + 1; i < locales.length; i++) {
-        if (isAlmostSameLocale(targetLocale, locales[i])) {
-            return true;
-        }
-    }
-    return false;
-}
-/* eslint-enable @typescript-eslint/no-explicit-any */
-
-function format(ast) {
-    const msg = (ctx) => formatParts(ctx, ast);
-    return msg;
-}
-function formatParts(ctx, ast) {
-    const body = ast.b || ast.body;
-    if ((body.t || body.type) === 1 /* NodeTypes.Plural */) {
-        const plural = body;
-        const cases = plural.c || plural.cases;
-        return ctx.plural(cases.reduce((messages, c) => [
-            ...messages,
-            formatMessageParts(ctx, c)
-        ], []));
-    }
-    else {
-        return formatMessageParts(ctx, body);
-    }
-}
-function formatMessageParts(ctx, node) {
-    const _static = node.s || node.static;
-    if (_static) {
-        return ctx.type === 'text'
-            ? _static
-            : ctx.normalize([_static]);
-    }
-    else {
-        const messages = (node.i || node.items).reduce((acm, c) => [...acm, formatMessagePart(ctx, c)], []);
-        return ctx.normalize(messages);
-    }
-}
-function formatMessagePart(ctx, node) {
-    const type = node.t || node.type;
-    switch (type) {
-        case 3 /* NodeTypes.Text */: {
-            const text = node;
-            return (text.v || text.value);
-        }
-        case 9 /* NodeTypes.Literal */: {
-            const literal = node;
-            return (literal.v || literal.value);
-        }
-        case 4 /* NodeTypes.Named */: {
-            const named = node;
-            return ctx.interpolate(ctx.named(named.k || named.key));
-        }
-        case 5 /* NodeTypes.List */: {
-            const list = node;
-            return ctx.interpolate(ctx.list(list.i != null ? list.i : list.index));
-        }
-        case 6 /* NodeTypes.Linked */: {
-            const linked = node;
-            const modifier = linked.m || linked.modifier;
-            return ctx.linked(formatMessagePart(ctx, linked.k || linked.key), modifier ? formatMessagePart(ctx, modifier) : undefined, ctx.type);
-        }
-        case 7 /* NodeTypes.LinkedKey */: {
-            const linkedKey = node;
-            return (linkedKey.v || linkedKey.value);
-        }
-        case 8 /* NodeTypes.LinkedModifier */: {
-            const linkedModifier = node;
-            return (linkedModifier.v || linkedModifier.value);
-        }
-        default:
-            throw new Error(`unhandled node type on format message part: ${type}`);
-    }
-}
-
-const WARN_MESSAGE = `Detected HTML in '{source}' message. Recommend not using HTML messages to avoid XSS.`;
-function checkHtmlMessage(source, warnHtmlMessage) {
-    if (warnHtmlMessage && messageCompiler.detectHtmlTag(source)) {
-        shared.warn(shared.format(WARN_MESSAGE, { source }));
-    }
-}
-const defaultOnCacheKey = (message) => message;
-let compileCache = Object.create(null);
-function clearCompileCache() {
-    compileCache = Object.create(null);
-}
-const isMessageAST = (val) => shared.isObject(val) &&
-    (val.t === 0 || val.type === 0) &&
-    ('b' in val || 'body' in val);
-function baseCompile(message, options = {}) {
-    // error detecting on compile
-    let detectError = false;
-    const onError = options.onError || messageCompiler.defaultOnError;
-    options.onError = (err) => {
-        detectError = true;
-        onError(err);
-    };
-    // compile with mesasge-compiler
-    return { ...messageCompiler.baseCompile(message, options), detectError };
-}
-/* #__NO_SIDE_EFFECTS__ */
-function compile(message, context) {
-    if (shared.isString(message)) {
-        // check HTML message
-        const warnHtmlMessage = shared.isBoolean(context.warnHtmlMessage)
-            ? context.warnHtmlMessage
-            : true;
-        checkHtmlMessage(message, warnHtmlMessage);
-        // check caches
-        const onCacheKey = context.onCacheKey || defaultOnCacheKey;
-        const cacheKey = onCacheKey(message);
-        const cached = compileCache[cacheKey];
-        if (cached) {
-            return cached;
-        }
-        // compile with JIT mode
-        const { ast, detectError } = baseCompile(message, {
-            ...context,
-            location: true,
-            jit: true
-        });
-        // compose message function from AST
-        const msg = format(ast);
-        // if occurred compile error, don't cache
-        return !detectError
-            ? (compileCache[cacheKey] = msg)
-            : msg;
-    }
-    else {
-        if (!isMessageAST(message)) {
-            shared.warn(`the message that is resolve with key '${context.key}' is not supported for jit compilation`);
-            return (() => message);
-        }
-        // AST case (passed from bundler)
-        const cacheKey = message.cacheKey;
-        if (cacheKey) {
-            const cached = compileCache[cacheKey];
-            if (cached) {
-                return cached;
-            }
-            // compose message function from message (AST)
-            return (compileCache[cacheKey] =
-                format(message));
-        }
-        else {
-            return format(message);
-        }
-    }
-}
-
-const NOOP_MESSAGE_FUNCTION = () => '';
-const isMessageFunction = (val) => shared.isFunction(val);
-// implementation of `translate` function
-function translate(context, ...args) {
-    const { fallbackFormat, postTranslation, unresolving, messageCompiler, fallbackLocale, messages } = context;
-    const [key, options] = parseTranslateArgs(...args);
-    const missingWarn = shared.isBoolean(options.missingWarn)
-        ? options.missingWarn
-        : context.missingWarn;
-    const fallbackWarn = shared.isBoolean(options.fallbackWarn)
-        ? options.fallbackWarn
-        : context.fallbackWarn;
-    const escapeParameter = shared.isBoolean(options.escapeParameter)
-        ? options.escapeParameter
-        : context.escapeParameter;
-    const resolvedMessage = !!options.resolvedMessage;
-    // prettier-ignore
-    const defaultMsgOrKey = shared.isString(options.default) || shared.isBoolean(options.default) // default by function option
-        ? !shared.isBoolean(options.default)
-            ? options.default
-            : (!messageCompiler ? () => key : key)
-        : fallbackFormat // default by `fallbackFormat` option
-            ? (!messageCompiler ? () => key : key)
-            : null;
-    const enableDefaultMsg = fallbackFormat ||
-        (defaultMsgOrKey != null &&
-            (shared.isString(defaultMsgOrKey) || shared.isFunction(defaultMsgOrKey)));
-    const locale = getLocale(context, options);
-    // escape params
-    escapeParameter && escapeParams(options);
-    // resolve message format
-    // eslint-disable-next-line prefer-const
-    let [formatScope, targetLocale, message] = !resolvedMessage
-        ? resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn)
-        : [
-            key,
-            locale,
-            messages[locale] || {}
-        ];
-    // NOTE:
-    //  Fix to work around `ssrTransfrom` bug in Vite.
-    //  https://github.com/vitejs/vite/issues/4306
-    //  To get around this, use temporary variables.
-    //  https://github.com/nuxt/framework/issues/1461#issuecomment-954606243
-    let format = formatScope;
-    // if you use default message, set it as message format!
-    let cacheBaseKey = key;
-    if (!resolvedMessage &&
-        !(shared.isString(format) ||
-            isMessageAST(format) ||
-            isMessageFunction(format))) {
-        if (enableDefaultMsg) {
-            format = defaultMsgOrKey;
-            cacheBaseKey = format;
-        }
-    }
-    // checking message format and target locale
-    if (!resolvedMessage &&
-        (!(shared.isString(format) ||
-            isMessageAST(format) ||
-            isMessageFunction(format)) ||
-            !shared.isString(targetLocale))) {
-        return unresolving ? NOT_REOSLVED : key;
-    }
-    // TODO: refactor
-    if (shared.isString(format) && context.messageCompiler == null) {
-        shared.warn(`The message format compilation is not supported in this build. ` +
-            `Because message compiler isn't included. ` +
-            `You need to pre-compilation all message format. ` +
-            `So translate function return '${key}'.`);
-        return key;
-    }
-    // setup compile error detecting
-    let occurred = false;
-    const onError = () => {
-        occurred = true;
-    };
-    // compile message format
-    const msg = !isMessageFunction(format)
-        ? compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError)
-        : format;
-    // if occurred compile error, return the message format
-    if (occurred) {
-        return format;
+    // for vue-devtools timeline event
+    {
+        context.__v_emitter =
+            internalOptions.__v_emitter != null
+                ? internalOptions.__v_emitter
+                : undefined;
     }
-    // evaluate message with context
-    const ctxOptions = getMessageContextOptions(context, targetLocale, message, options);
-    const msgContext = createMessageContext(ctxOptions);
-    const messaged = evaluateMessage(context, msg, msgContext);
-    // if use post translation option, proceed it with handler
-    const ret = postTranslation
-        ? postTranslation(messaged, key)
-        : messaged;
     // NOTE: experimental !!
     {
-        // prettier-ignore
-        const payloads = {
-            timestamp: Date.now(),
-            key: shared.isString(key)
-                ? key
-                : isMessageFunction(format)
-                    ? format.key
-                    : '',
-            locale: targetLocale || (isMessageFunction(format)
-                ? format.locale
-                : ''),
-            format: shared.isString(format)
-                ? format
-                : isMessageFunction(format)
-                    ? format.source
-                    : '',
-            message: ret
-        };
-        payloads.meta = shared.assign({}, context.__meta, getAdditionalMeta() || {});
-        translateDevTools(payloads);
+        initI18nDevTools(context, version, __meta);
     }
-    return ret;
+    return context;
 }
-function escapeParams(options) {
-    if (shared.isArray(options.list)) {
-        options.list = options.list.map(item => shared.isString(item) ? shared.escapeHtml(item) : item);
-    }
-    else if (shared.isObject(options.named)) {
-        Object.keys(options.named).forEach(key => {
-            if (shared.isString(options.named[key])) {
-                options.named[key] = shared.escapeHtml(options.named[key]);
-            }
-        });
-    }
+/** @internal */
+function isTranslateFallbackWarn(fallback, key) {
+    return fallback instanceof RegExp ? fallback.test(key) : fallback;
 }
-function resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn) {
-    const { messages, onWarn, messageResolver: resolveValue, localeFallbacker } = context;
-    const locales = localeFallbacker(context, fallbackLocale, locale); // eslint-disable-line @typescript-eslint/no-explicit-any
-    let message = {};
-    let targetLocale;
-    let format = null;
-    let from = locale;
-    let to = null;
-    const type = 'translate';
-    for (let i = 0; i < locales.length; i++) {
-        targetLocale = to = locales[i];
-        if (locale !== targetLocale &&
-            !isAlmostSameLocale(locale, targetLocale) &&
-            isTranslateFallbackWarn(fallbackWarn, key)) {
-            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_TRANSLATE, {
+/** @internal */
+function isTranslateMissingWarn(missing, key) {
+    return missing instanceof RegExp ? missing.test(key) : missing;
+}
+/** @internal */
+function handleMissing(context, key, locale, missingWarn, type) {
+    const { missing, onWarn } = context;
+    // for vue-devtools timeline event
+    {
+        const emitter = context.__v_emitter;
+        if (emitter) {
+            emitter.emit('missing', {
+                locale,
                 key,
-                target: targetLocale
-            }));
-        }
-        // for vue-devtools timeline event
-        if (locale !== targetLocale) {
-            const emitter = context.__v_emitter;
-            if (emitter) {
-                emitter.emit('fallback', {
-                    type,
-                    key,
-                    from,
-                    to,
-                    groupId: `${type}:${key}`
-                });
-            }
-        }
-        message =
-            messages[targetLocale] || {};
-        // for vue-devtools timeline event
-        let start = null;
-        let startTag;
-        let endTag;
-        if (shared.inBrowser) {
-            start = window.performance.now();
-            startTag = 'intlify-message-resolve-start';
-            endTag = 'intlify-message-resolve-end';
-            shared.mark && shared.mark(startTag);
-        }
-        if ((format = resolveValue(message, key)) === null) {
-            // if null, resolve with object key path
-            format = message[key]; // eslint-disable-line @typescript-eslint/no-explicit-any
-        }
-        // for vue-devtools timeline event
-        if (shared.inBrowser) {
-            const end = window.performance.now();
-            const emitter = context.__v_emitter;
-            if (emitter && start && format) {
-                emitter.emit('message-resolve', {
-                    type: 'message-resolve',
-                    key,
-                    message: format,
-                    time: end - start,
-                    groupId: `${type}:${key}`
-                });
-            }
-            if (startTag && endTag && shared.mark && shared.measure) {
-                shared.mark(endTag);
-                shared.measure('intlify message resolve', startTag, endTag);
-            }
-        }
-        if (shared.isString(format) || isMessageAST(format) || isMessageFunction(format)) {
-            break;
+                type,
+                groupId: `${type}:${key}`
+            });
         }
-        if (!isImplicitFallback(targetLocale, locales)) {
-            const missingRet = handleMissing(context, // eslint-disable-line @typescript-eslint/no-explicit-any
-            key, targetLocale, missingWarn, type);
-            if (missingRet !== key) {
-                format = missingRet;
-            }
+    }
+    if (missing !== null) {
+        const ret = missing(context, locale, key, type);
+        return shared.isString(ret) ? ret : key;
+    }
+    else {
+        if (isTranslateMissingWarn(missingWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.NOT_FOUND_KEY, { key, locale }));
         }
-        from = to;
+        return key;
     }
-    return [format, targetLocale, message];
 }
-function compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError) {
-    const { messageCompiler, warnHtmlMessage } = context;
-    if (isMessageFunction(format)) {
-        const msg = format;
-        msg.locale = msg.locale || targetLocale;
-        msg.key = msg.key || key;
-        return msg;
+/** @internal */
+function updateFallbackLocale(ctx, locale, fallback) {
+    const context = ctx;
+    context.__localeChainCache = new Map();
+    ctx.localeFallbacker(ctx, fallback, locale);
+}
+/** @internal */
+function isAlmostSameLocale(locale, compareLocale) {
+    if (locale === compareLocale)
+        return false;
+    return locale.split('-')[0] === compareLocale.split('-')[0];
+}
+/** @internal */
+function isImplicitFallback(targetLocale, locales) {
+    const index = locales.indexOf(targetLocale);
+    if (index === -1) {
+        return false;
     }
-    if (messageCompiler == null) {
-        const msg = (() => format);
-        msg.locale = targetLocale;
-        msg.key = key;
-        return msg;
+    for (let i = index + 1; i < locales.length; i++) {
+        if (isAlmostSameLocale(targetLocale, locales[i])) {
+            return true;
+        }
     }
-    // for vue-devtools timeline event
-    let start = null;
-    let startTag;
-    let endTag;
-    if (shared.inBrowser) {
-        start = window.performance.now();
-        startTag = 'intlify-message-compilation-start';
-        endTag = 'intlify-message-compilation-end';
-        shared.mark && shared.mark(startTag);
+    return false;
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+const intlDefined = typeof Intl !== 'undefined';
+const Availabilities = {
+    dateTimeFormat: intlDefined && typeof Intl.DateTimeFormat !== 'undefined',
+    numberFormat: intlDefined && typeof Intl.NumberFormat !== 'undefined'
+};
+
+// implementation of `datetime` function
+function datetime(context, ...args) {
+    const { datetimeFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { __datetimeFormatters } = context;
+    if (!Availabilities.dateTimeFormat) {
+        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_DATE));
+        return MISSING_RESOLVE_VALUE;
     }
-    const msg = messageCompiler(format, getCompileContext(context, targetLocale, cacheBaseKey, format, warnHtmlMessage, onError));
-    // for vue-devtools timeline event
-    if (shared.inBrowser) {
-        const end = window.performance.now();
-        const emitter = context.__v_emitter;
-        if (emitter && start) {
-            emitter.emit('message-compilation', {
-                type: 'message-compilation',
-                message: format,
-                time: end - start,
-                groupId: `${'translate'}:${key}`
-            });
+    const [key, value, options, overrides] = parseDateTimeArgs(...args);
+    const missingWarn = shared.isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    const fallbackWarn = shared.isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const part = !!options.part;
+    const locale = getLocale(context, options);
+    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+    fallbackLocale, locale);
+    if (!shared.isString(key) || key === '') {
+        return new Intl.DateTimeFormat(locale, overrides).format(value);
+    }
+    // resolve format
+    let datetimeFormat = {};
+    let targetLocale;
+    let format = null;
+    let from = locale;
+    let to = null;
+    const type = 'datetime format';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = to = locales[i];
+        if (locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_DATE_FORMAT, {
+                key,
+                target: targetLocale
+            }));
         }
-        if (startTag && endTag && shared.mark && shared.measure) {
-            shared.mark(endTag);
-            shared.measure('intlify message compilation', startTag, endTag);
+        // for vue-devtools timeline event
+        if (locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit('fallback', {
+                    type,
+                    key,
+                    from,
+                    to,
+                    groupId: `${type}:${key}`
+                });
+            }
         }
+        datetimeFormat =
+            datetimeFormats[targetLocale] || {};
+        format = datetimeFormat[key];
+        if (shared.isPlainObject(format))
+            break;
+        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+        from = to;
     }
-    msg.locale = targetLocale;
-    msg.key = key;
-    msg.source = format;
-    return msg;
-}
-function evaluateMessage(context, msg, msgCtx) {
-    // for vue-devtools timeline event
-    let start = null;
-    let startTag;
-    let endTag;
-    if (shared.inBrowser) {
-        start = window.performance.now();
-        startTag = 'intlify-message-evaluation-start';
-        endTag = 'intlify-message-evaluation-end';
-        shared.mark && shared.mark(startTag);
+    // checking format and target locale
+    if (!shared.isPlainObject(format) || !shared.isString(targetLocale)) {
+        return unresolving ? NOT_REOSLVED : key;
     }
-    const messaged = msg(msgCtx);
-    // for vue-devtools timeline event
-    if (shared.inBrowser) {
-        const end = window.performance.now();
-        const emitter = context.__v_emitter;
-        if (emitter && start) {
-            emitter.emit('message-evaluation', {
-                type: 'message-evaluation',
-                value: messaged,
-                time: end - start,
-                groupId: `${'translate'}:${msg.key}`
-            });
-        }
-        if (startTag && endTag && shared.mark && shared.measure) {
-            shared.mark(endTag);
-            shared.measure('intlify message evaluation', startTag, endTag);
-        }
+    let id = `${targetLocale}__${key}`;
+    if (!shared.isEmptyObject(overrides)) {
+        id = `${id}__${JSON.stringify(overrides)}`;
     }
-    return messaged;
+    let formatter = __datetimeFormatters.get(id);
+    if (!formatter) {
+        formatter = new Intl.DateTimeFormat(targetLocale, shared.assign({}, format, overrides));
+        __datetimeFormatters.set(id, formatter);
+    }
+    return !part ? formatter.format(value) : formatter.formatToParts(value);
 }
 /** @internal */
-function parseTranslateArgs(...args) {
-    const [arg1, arg2, arg3] = args;
+const DATETIME_FORMAT_OPTIONS_KEYS = [
+    'localeMatcher',
+    'weekday',
+    'era',
+    'year',
+    'month',
+    'day',
+    'hour',
+    'minute',
+    'second',
+    'timeZoneName',
+    'formatMatcher',
+    'hour12',
+    'timeZone',
+    'dateStyle',
+    'timeStyle',
+    'calendar',
+    'dayPeriod',
+    'numberingSystem',
+    'hourCycle',
+    'fractionalSecondDigits'
+];
+/** @internal */
+function parseDateTimeArgs(...args) {
+    const [arg1, arg2, arg3, arg4] = args;
     const options = {};
-    if (!shared.isString(arg1) &&
-        !shared.isNumber(arg1) &&
-        !isMessageFunction(arg1) &&
-        !isMessageAST(arg1)) {
-        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
-    }
-    // prettier-ignore
-    const key = shared.isNumber(arg1)
-        ? String(arg1)
-        : isMessageFunction(arg1)
-            ? arg1
-            : arg1;
-    if (shared.isNumber(arg2)) {
-        options.plural = arg2;
-    }
-    else if (shared.isString(arg2)) {
-        options.default = arg2;
-    }
-    else if (shared.isPlainObject(arg2) && !shared.isEmptyObject(arg2)) {
-        options.named = arg2;
+    let overrides = {};
+    let value;
+    if (shared.isString(arg1)) {
+        // Only allow ISO strings - other date formats are often supported,
+        // but may cause different results in different browsers.
+        const matches = arg1.match(/(\d{4}-\d{2}-\d{2})(T|\s)?(.*)/);
+        if (!matches) {
+            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+        }
+        // Some browsers can not parse the iso datetime separated by space,
+        // this is a compromise solution by replace the 'T'/' ' with 'T'
+        const dateTime = matches[3]
+            ? matches[3].trim().startsWith('T')
+                ? `${matches[1].trim()}${matches[3].trim()}`
+                : `${matches[1].trim()}T${matches[3].trim()}`
+            : matches[1].trim();
+        value = new Date(dateTime);
+        try {
+            // This will fail if the date is not valid
+            value.toISOString();
+        }
+        catch {
+            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+        }
     }
-    else if (shared.isArray(arg2)) {
-        options.list = arg2;
+    else if (shared.isDate(arg1)) {
+        if (isNaN(arg1.getTime())) {
+            throw createCoreError(CoreErrorCodes.INVALID_DATE_ARGUMENT);
+        }
+        value = arg1;
     }
-    if (shared.isNumber(arg3)) {
-        options.plural = arg3;
+    else if (shared.isNumber(arg1)) {
+        value = arg1;
     }
-    else if (shared.isString(arg3)) {
-        options.default = arg3;
+    else {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
     }
-    else if (shared.isPlainObject(arg3)) {
-        shared.assign(options, arg3);
+    if (shared.isString(arg2)) {
+        options.key = arg2;
     }
-    return [key, options];
-}
-function getCompileContext(context, locale, key, source, warnHtmlMessage, onError) {
-    return {
-        locale,
-        key,
-        warnHtmlMessage,
-        onError: (err) => {
-            onError && onError(err);
-            {
-                const _source = getSourceForCodeFrame(source);
-                const message = `Message compilation error: ${err.message}`;
-                const codeFrame = err.location &&
-                    _source &&
-                    shared.generateCodeFrame(_source, err.location.start.offset, err.location.end.offset);
-                const emitter = context.__v_emitter;
-                if (emitter && _source) {
-                    emitter.emit('compile-error', {
-                        message: _source,
-                        error: err.message,
-                        start: err.location && err.location.start.offset,
-                        end: err.location && err.location.end.offset,
-                        groupId: `${'translate'}:${key}`
-                    });
-                }
-                console.error(codeFrame ? `${message}\n${codeFrame}` : message);
+    else if (shared.isPlainObject(arg2)) {
+        Object.keys(arg2).forEach(key => {
+            if (DATETIME_FORMAT_OPTIONS_KEYS.includes(key)) {
+                overrides[key] = arg2[key];
             }
-        },
-        onCacheKey: (source) => shared.generateFormatCacheKey(locale, key, source)
-    };
-}
-function getSourceForCodeFrame(source) {
-    if (shared.isString(source)) {
-        return source;
-    }
-    else {
-        if (source.loc && source.loc.source) {
-            return source.loc.source;
-        }
+            else {
+                options[key] = arg2[key];
+            }
+        });
     }
-}
-function getMessageContextOptions(context, locale, message, options) {
-    const { modifiers, pluralRules, messageResolver: resolveValue, fallbackLocale, fallbackWarn, missingWarn, fallbackContext } = context;
-    const resolveMessage = (key, useLinked) => {
-        let val = resolveValue(message, key);
-        // fallback
-        if (val == null && (fallbackContext || useLinked)) {
-            const [, , message] = resolveMessageFormat(fallbackContext || context, // NOTE: if has fallbackContext, fallback to root, else if use linked, fallback to local context
-            key, locale, fallbackLocale, fallbackWarn, missingWarn);
-            val = resolveValue(message, key);
-        }
-        if (shared.isString(val) || isMessageAST(val)) {
-            let occurred = false;
-            const onError = () => {
-                occurred = true;
-            };
-            const msg = compileMessageFormat(context, key, locale, val, key, onError);
-            return !occurred
-                ? msg
-                : NOOP_MESSAGE_FUNCTION;
-        }
-        else if (isMessageFunction(val)) {
-            return val;
-        }
-        else {
-            // TODO: should be implemented warning message
-            return NOOP_MESSAGE_FUNCTION;
-        }
-    };
-    const ctxOptions = {
-        locale,
-        modifiers,
-        pluralRules,
-        messages: resolveMessage
-    };
-    if (context.processor) {
-        ctxOptions.processor = context.processor;
+    if (shared.isString(arg3)) {
+        options.locale = arg3;
     }
-    if (options.list) {
-        ctxOptions.list = options.list;
+    else if (shared.isPlainObject(arg3)) {
+        overrides = arg3;
     }
-    if (options.named) {
-        ctxOptions.named = options.named;
+    if (shared.isPlainObject(arg4)) {
+        overrides = arg4;
     }
-    if (shared.isNumber(options.plural)) {
-        ctxOptions.pluralIndex = options.plural;
+    return [options.key || '', value, options, overrides];
+}
+/** @internal */
+function clearDateTimeFormat(ctx, locale, format) {
+    const context = ctx;
+    for (const key in format) {
+        const id = `${locale}__${key}`;
+        if (!context.__datetimeFormatters.has(id)) {
+            continue;
+        }
+        context.__datetimeFormatters.delete(id);
     }
-    return ctxOptions;
 }
 
-const intlDefined = typeof Intl !== 'undefined';
-const Availabilities = {
-    dateTimeFormat: intlDefined && typeof Intl.DateTimeFormat !== 'undefined',
-    numberFormat: intlDefined && typeof Intl.NumberFormat !== 'undefined'
-};
-
-// implementation of `datetime` function
-function datetime(context, ...args) {
-    const { datetimeFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
-    const { __datetimeFormatters } = context;
-    if (!Availabilities.dateTimeFormat) {
-        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_DATE));
+// implementation of `number` function
+function number(context, ...args) {
+    const { numberFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { __numberFormatters } = context;
+    if (!Availabilities.numberFormat) {
+        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_NUMBER));
         return MISSING_RESOLVE_VALUE;
     }
-    const [key, value, options, overrides] = parseDateTimeArgs(...args);
+    const [key, value, options, overrides] = parseNumberArgs(...args);
     const missingWarn = shared.isBoolean(options.missingWarn)
         ? options.missingWarn
         : context.missingWarn;
@@ -1463,20 +1092,20 @@ function datetime(context, ...args) {
     const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
     fallbackLocale, locale);
     if (!shared.isString(key) || key === '') {
-        return new Intl.DateTimeFormat(locale, overrides).format(value);
+        return new Intl.NumberFormat(locale, overrides).format(value);
     }
     // resolve format
-    let datetimeFormat = {};
+    let numberFormat = {};
     let targetLocale;
     let format = null;
     let from = locale;
     let to = null;
-    const type = 'datetime format';
+    const type = 'number format';
     for (let i = 0; i < locales.length; i++) {
         targetLocale = to = locales[i];
         if (locale !== targetLocale &&
             isTranslateFallbackWarn(fallbackWarn, key)) {
-            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_DATE_FORMAT, {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT, {
                 key,
                 target: targetLocale
             }));
@@ -1494,9 +1123,9 @@ function datetime(context, ...args) {
                 });
             }
         }
-        datetimeFormat =
-            datetimeFormats[targetLocale] || {};
-        format = datetimeFormat[key];
+        numberFormat =
+            numberFormats[targetLocale] || {};
+        format = numberFormat[key];
         if (shared.isPlainObject(format))
             break;
         handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
@@ -1510,147 +1139,356 @@ function datetime(context, ...args) {
     if (!shared.isEmptyObject(overrides)) {
         id = `${id}__${JSON.stringify(overrides)}`;
     }
-    let formatter = __datetimeFormatters.get(id);
+    let formatter = __numberFormatters.get(id);
     if (!formatter) {
-        formatter = new Intl.DateTimeFormat(targetLocale, shared.assign({}, format, overrides));
-        __datetimeFormatters.set(id, formatter);
+        formatter = new Intl.NumberFormat(targetLocale, shared.assign({}, format, overrides));
+        __numberFormatters.set(id, formatter);
     }
     return !part ? formatter.format(value) : formatter.formatToParts(value);
 }
 /** @internal */
-const DATETIME_FORMAT_OPTIONS_KEYS = [
+const NUMBER_FORMAT_OPTIONS_KEYS = [
     'localeMatcher',
-    'weekday',
-    'era',
-    'year',
-    'month',
-    'day',
-    'hour',
-    'minute',
-    'second',
-    'timeZoneName',
-    'formatMatcher',
-    'hour12',
-    'timeZone',
-    'dateStyle',
-    'timeStyle',
-    'calendar',
-    'dayPeriod',
-    'numberingSystem',
-    'hourCycle',
-    'fractionalSecondDigits'
+    'style',
+    'currency',
+    'currencyDisplay',
+    'currencySign',
+    'useGrouping',
+    'minimumIntegerDigits',
+    'minimumFractionDigits',
+    'maximumFractionDigits',
+    'minimumSignificantDigits',
+    'maximumSignificantDigits',
+    'compactDisplay',
+    'notation',
+    'signDisplay',
+    'unit',
+    'unitDisplay',
+    'roundingMode',
+    'roundingPriority',
+    'roundingIncrement',
+    'trailingZeroDisplay'
 ];
 /** @internal */
-function parseDateTimeArgs(...args) {
+function parseNumberArgs(...args) {
     const [arg1, arg2, arg3, arg4] = args;
     const options = {};
     let overrides = {};
-    let value;
-    if (shared.isString(arg1)) {
-        // Only allow ISO strings - other date formats are often supported,
-        // but may cause different results in different browsers.
-        const matches = arg1.match(/(\d{4}-\d{2}-\d{2})(T|\s)?(.*)/);
-        if (!matches) {
-            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
-        }
-        // Some browsers can not parse the iso datetime separated by space,
-        // this is a compromise solution by replace the 'T'/' ' with 'T'
-        const dateTime = matches[3]
-            ? matches[3].trim().startsWith('T')
-                ? `${matches[1].trim()}${matches[3].trim()}`
-                : `${matches[1].trim()}T${matches[3].trim()}`
-            : matches[1].trim();
-        value = new Date(dateTime);
-        try {
-            // This will fail if the date is not valid
-            value.toISOString();
-        }
-        catch (e) {
-            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+    if (!shared.isNumber(arg1)) {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    const value = arg1;
+    if (shared.isString(arg2)) {
+        options.key = arg2;
+    }
+    else if (shared.isPlainObject(arg2)) {
+        Object.keys(arg2).forEach(key => {
+            if (NUMBER_FORMAT_OPTIONS_KEYS.includes(key)) {
+                overrides[key] = arg2[key];
+            }
+            else {
+                options[key] = arg2[key];
+            }
+        });
+    }
+    if (shared.isString(arg3)) {
+        options.locale = arg3;
+    }
+    else if (shared.isPlainObject(arg3)) {
+        overrides = arg3;
+    }
+    if (shared.isPlainObject(arg4)) {
+        overrides = arg4;
+    }
+    return [options.key || '', value, options, overrides];
+}
+/** @internal */
+function clearNumberFormat(ctx, locale, format) {
+    const context = ctx;
+    for (const key in format) {
+        const id = `${locale}__${key}`;
+        if (!context.__numberFormatters.has(id)) {
+            continue;
         }
+        context.__numberFormatters.delete(id);
     }
-    else if (shared.isDate(arg1)) {
-        if (isNaN(arg1.getTime())) {
-            throw createCoreError(CoreErrorCodes.INVALID_DATE_ARGUMENT);
+}
+
+const DEFAULT_MODIFIER = (str) => str;
+const DEFAULT_MESSAGE = (ctx) => ''; // eslint-disable-line
+const DEFAULT_MESSAGE_DATA_TYPE = 'text';
+const DEFAULT_NORMALIZE = (values) => values.length === 0 ? '' : shared.join(values);
+const DEFAULT_INTERPOLATE = shared.toDisplayString;
+function pluralDefault(choice, choicesLength) {
+    choice = Math.abs(choice);
+    if (choicesLength === 2) {
+        // prettier-ignore
+        return choice
+            ? choice > 1
+                ? 1
+                : 0
+            : 1;
+    }
+    return choice ? Math.min(choice, 2) : 0;
+}
+function getPluralIndex(options) {
+    // prettier-ignore
+    const index = shared.isNumber(options.pluralIndex)
+        ? options.pluralIndex
+        : -1;
+    // prettier-ignore
+    return options.named && (shared.isNumber(options.named.count) || shared.isNumber(options.named.n))
+        ? shared.isNumber(options.named.count)
+            ? options.named.count
+            : shared.isNumber(options.named.n)
+                ? options.named.n
+                : index
+        : index;
+}
+function normalizeNamed(pluralIndex, props) {
+    if (!props.count) {
+        props.count = pluralIndex;
+    }
+    if (!props.n) {
+        props.n = pluralIndex;
+    }
+}
+function createMessageContext(options = {}) {
+    const locale = options.locale;
+    const pluralIndex = getPluralIndex(options);
+    const pluralRule = shared.isObject(options.pluralRules) &&
+        shared.isString(locale) &&
+        shared.isFunction(options.pluralRules[locale])
+        ? options.pluralRules[locale]
+        : pluralDefault;
+    const orgPluralRule = shared.isObject(options.pluralRules) &&
+        shared.isString(locale) &&
+        shared.isFunction(options.pluralRules[locale])
+        ? pluralDefault
+        : undefined;
+    const plural = (messages) => {
+        return messages[pluralRule(pluralIndex, messages.length, orgPluralRule)];
+    };
+    const _list = options.list || [];
+    const list = (index) => _list[index];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const _named = options.named || {};
+    shared.isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);
+    const named = (key) => _named[key];
+    function message(key, useLinked) {
+        // prettier-ignore
+        const msg = shared.isFunction(options.messages)
+            ? options.messages(key, !!useLinked)
+            : shared.isObject(options.messages)
+                ? options.messages[key]
+                : false;
+        return !msg
+            ? options.parent
+                ? options.parent.message(key) // resolve from parent messages
+                : DEFAULT_MESSAGE
+            : msg;
+    }
+    const _modifier = (name) => options.modifiers
+        ? options.modifiers[name]
+        : DEFAULT_MODIFIER;
+    const normalize = shared.isPlainObject(options.processor) && shared.isFunction(options.processor.normalize)
+        ? options.processor.normalize
+        : DEFAULT_NORMALIZE;
+    const interpolate = shared.isPlainObject(options.processor) &&
+        shared.isFunction(options.processor.interpolate)
+        ? options.processor.interpolate
+        : DEFAULT_INTERPOLATE;
+    const type = shared.isPlainObject(options.processor) && shared.isString(options.processor.type)
+        ? options.processor.type
+        : DEFAULT_MESSAGE_DATA_TYPE;
+    const linked = (key, ...args) => {
+        const [arg1, arg2] = args;
+        let type = 'text';
+        let modifier = '';
+        if (args.length === 1) {
+            if (shared.isObject(arg1)) {
+                modifier = arg1.modifier || modifier;
+                type = arg1.type || type;
+            }
+            else if (shared.isString(arg1)) {
+                modifier = arg1 || modifier;
+            }
         }
-        value = arg1;
-    }
-    else if (shared.isNumber(arg1)) {
-        value = arg1;
-    }
-    else {
-        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
-    }
-    if (shared.isString(arg2)) {
-        options.key = arg2;
-    }
-    else if (shared.isPlainObject(arg2)) {
-        Object.keys(arg2).forEach(key => {
-            if (DATETIME_FORMAT_OPTIONS_KEYS.includes(key)) {
-                overrides[key] = arg2[key];
+        else if (args.length === 2) {
+            if (shared.isString(arg1)) {
+                modifier = arg1 || modifier;
             }
-            else {
-                options[key] = arg2[key];
+            if (shared.isString(arg2)) {
+                type = arg2 || type;
             }
-        });
-    }
-    if (shared.isString(arg3)) {
-        options.locale = arg3;
-    }
-    else if (shared.isPlainObject(arg3)) {
-        overrides = arg3;
-    }
-    if (shared.isPlainObject(arg4)) {
-        overrides = arg4;
-    }
-    return [options.key || '', value, options, overrides];
-}
-/** @internal */
-function clearDateTimeFormat(ctx, locale, format) {
-    const context = ctx;
-    for (const key in format) {
-        const id = `${locale}__${key}`;
-        if (!context.__datetimeFormatters.has(id)) {
-            continue;
         }
-        context.__datetimeFormatters.delete(id);
-    }
+        const ret = message(key, true)(ctx);
+        const msg = 
+        // The message in vnode resolved with linked are returned as an array by processor.nomalize
+        type === 'vnode' && shared.isArray(ret) && modifier
+            ? ret[0]
+            : ret;
+        return modifier ? _modifier(modifier)(msg, type) : msg;
+    };
+    const ctx = {
+        ["list" /* HelperNameMap.LIST */]: list,
+        ["named" /* HelperNameMap.NAMED */]: named,
+        ["plural" /* HelperNameMap.PLURAL */]: plural,
+        ["linked" /* HelperNameMap.LINKED */]: linked,
+        ["message" /* HelperNameMap.MESSAGE */]: message,
+        ["type" /* HelperNameMap.TYPE */]: type,
+        ["interpolate" /* HelperNameMap.INTERPOLATE */]: interpolate,
+        ["normalize" /* HelperNameMap.NORMALIZE */]: normalize,
+        ["values" /* HelperNameMap.VALUES */]: shared.assign({}, _list, _named)
+    };
+    return ctx;
 }
 
-// implementation of `number` function
-function number(context, ...args) {
-    const { numberFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
-    const { __numberFormatters } = context;
-    if (!Availabilities.numberFormat) {
-        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_NUMBER));
-        return MISSING_RESOLVE_VALUE;
-    }
-    const [key, value, options, overrides] = parseNumberArgs(...args);
+const NOOP_MESSAGE_FUNCTION = () => '';
+const isMessageFunction = (val) => shared.isFunction(val);
+// implementation of `translate` function
+function translate(context, ...args) {
+    const { fallbackFormat, postTranslation, unresolving, messageCompiler, fallbackLocale, messages } = context;
+    const [key, options] = parseTranslateArgs(...args);
     const missingWarn = shared.isBoolean(options.missingWarn)
         ? options.missingWarn
         : context.missingWarn;
     const fallbackWarn = shared.isBoolean(options.fallbackWarn)
         ? options.fallbackWarn
         : context.fallbackWarn;
-    const part = !!options.part;
+    const escapeParameter = shared.isBoolean(options.escapeParameter)
+        ? options.escapeParameter
+        : context.escapeParameter;
+    const resolvedMessage = !!options.resolvedMessage;
+    // prettier-ignore
+    const defaultMsgOrKey = shared.isString(options.default) || shared.isBoolean(options.default) // default by function option
+        ? !shared.isBoolean(options.default)
+            ? options.default
+            : (!messageCompiler ? () => key : key)
+        : fallbackFormat // default by `fallbackFormat` option
+            ? (!messageCompiler ? () => key : key)
+            : null;
+    const enableDefaultMsg = fallbackFormat ||
+        (defaultMsgOrKey != null &&
+            (shared.isString(defaultMsgOrKey) || shared.isFunction(defaultMsgOrKey)));
     const locale = getLocale(context, options);
-    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
-    fallbackLocale, locale);
-    if (!shared.isString(key) || key === '') {
-        return new Intl.NumberFormat(locale, overrides).format(value);
+    // escape params
+    escapeParameter && escapeParams(options);
+    // resolve message format
+    // eslint-disable-next-line prefer-const
+    let [formatScope, targetLocale, message] = !resolvedMessage
+        ? resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn)
+        : [
+            key,
+            locale,
+            messages[locale] || {}
+        ];
+    // NOTE:
+    //  Fix to work around `ssrTransfrom` bug in Vite.
+    //  https://github.com/vitejs/vite/issues/4306
+    //  To get around this, use temporary variables.
+    //  https://github.com/nuxt/framework/issues/1461#issuecomment-954606243
+    let format = formatScope;
+    // if you use default message, set it as message format!
+    let cacheBaseKey = key;
+    if (!resolvedMessage &&
+        !(shared.isString(format) ||
+            isMessageAST(format) ||
+            isMessageFunction(format))) {
+        if (enableDefaultMsg) {
+            format = defaultMsgOrKey;
+            cacheBaseKey = format;
+        }
     }
-    // resolve format
-    let numberFormat = {};
+    // checking message format and target locale
+    if (!resolvedMessage &&
+        (!(shared.isString(format) ||
+            isMessageAST(format) ||
+            isMessageFunction(format)) ||
+            !shared.isString(targetLocale))) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    // TODO: refactor
+    if (shared.isString(format) && context.messageCompiler == null) {
+        shared.warn(`The message format compilation is not supported in this build. ` +
+            `Because message compiler isn't included. ` +
+            `You need to pre-compilation all message format. ` +
+            `So translate function return '${key}'.`);
+        return key;
+    }
+    // setup compile error detecting
+    let occurred = false;
+    const onError = () => {
+        occurred = true;
+    };
+    // compile message format
+    const msg = !isMessageFunction(format)
+        ? compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError)
+        : format;
+    // if occurred compile error, return the message format
+    if (occurred) {
+        return format;
+    }
+    // evaluate message with context
+    const ctxOptions = getMessageContextOptions(context, targetLocale, message, options);
+    const msgContext = createMessageContext(ctxOptions);
+    const messaged = evaluateMessage(context, msg, msgContext);
+    // if use post translation option, proceed it with handler
+    const ret = postTranslation
+        ? postTranslation(messaged, key)
+        : messaged;
+    // NOTE: experimental !!
+    {
+        // prettier-ignore
+        const payloads = {
+            timestamp: Date.now(),
+            key: shared.isString(key)
+                ? key
+                : isMessageFunction(format)
+                    ? format.key
+                    : '',
+            locale: targetLocale || (isMessageFunction(format)
+                ? format.locale
+                : ''),
+            format: shared.isString(format)
+                ? format
+                : isMessageFunction(format)
+                    ? format.source
+                    : '',
+            message: ret
+        };
+        payloads.meta = shared.assign({}, context.__meta, getAdditionalMeta() || {});
+        translateDevTools(payloads);
+    }
+    return ret;
+}
+function escapeParams(options) {
+    if (shared.isArray(options.list)) {
+        options.list = options.list.map(item => shared.isString(item) ? shared.escapeHtml(item) : item);
+    }
+    else if (shared.isObject(options.named)) {
+        Object.keys(options.named).forEach(key => {
+            if (shared.isString(options.named[key])) {
+                options.named[key] = shared.escapeHtml(options.named[key]);
+            }
+        });
+    }
+}
+function resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn) {
+    const { messages, onWarn, messageResolver: resolveValue, localeFallbacker } = context;
+    const locales = localeFallbacker(context, fallbackLocale, locale); // eslint-disable-line @typescript-eslint/no-explicit-any
+    let message = {};
     let targetLocale;
     let format = null;
     let from = locale;
     let to = null;
-    const type = 'number format';
+    const type = 'translate';
     for (let i = 0; i < locales.length; i++) {
         targetLocale = to = locales[i];
         if (locale !== targetLocale &&
+            !isAlmostSameLocale(locale, targetLocale) &&
             isTranslateFallbackWarn(fallbackWarn, key)) {
-            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT, {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_TRANSLATE, {
                 key,
                 target: targetLocale
             }));
@@ -1668,95 +1506,257 @@ function number(context, ...args) {
                 });
             }
         }
-        numberFormat =
-            numberFormats[targetLocale] || {};
-        format = numberFormat[key];
-        if (shared.isPlainObject(format))
+        message =
+            messages[targetLocale] || {};
+        // for vue-devtools timeline event
+        let start = null;
+        let startTag;
+        let endTag;
+        if (shared.inBrowser) {
+            start = window.performance.now();
+            startTag = 'intlify-message-resolve-start';
+            endTag = 'intlify-message-resolve-end';
+            shared.mark && shared.mark(startTag);
+        }
+        if ((format = resolveValue(message, key)) === null) {
+            // if null, resolve with object key path
+            format = message[key]; // eslint-disable-line @typescript-eslint/no-explicit-any
+        }
+        // for vue-devtools timeline event
+        if (shared.inBrowser) {
+            const end = window.performance.now();
+            const emitter = context.__v_emitter;
+            if (emitter && start && format) {
+                emitter.emit('message-resolve', {
+                    type: 'message-resolve',
+                    key,
+                    message: format,
+                    time: end - start,
+                    groupId: `${type}:${key}`
+                });
+            }
+            if (startTag && endTag && shared.mark && shared.measure) {
+                shared.mark(endTag);
+                shared.measure('intlify message resolve', startTag, endTag);
+            }
+        }
+        if (shared.isString(format) || isMessageAST(format) || isMessageFunction(format)) {
             break;
-        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+        }
+        if (!isImplicitFallback(targetLocale, locales)) {
+            const missingRet = handleMissing(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+            key, targetLocale, missingWarn, type);
+            if (missingRet !== key) {
+                format = missingRet;
+            }
+        }
         from = to;
     }
-    // checking format and target locale
-    if (!shared.isPlainObject(format) || !shared.isString(targetLocale)) {
-        return unresolving ? NOT_REOSLVED : key;
+    return [format, targetLocale, message];
+}
+function compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError) {
+    const { messageCompiler, warnHtmlMessage } = context;
+    if (isMessageFunction(format)) {
+        const msg = format;
+        msg.locale = msg.locale || targetLocale;
+        msg.key = msg.key || key;
+        return msg;
     }
-    let id = `${targetLocale}__${key}`;
-    if (!shared.isEmptyObject(overrides)) {
-        id = `${id}__${JSON.stringify(overrides)}`;
+    if (messageCompiler == null) {
+        const msg = (() => format);
+        msg.locale = targetLocale;
+        msg.key = key;
+        return msg;
     }
-    let formatter = __numberFormatters.get(id);
-    if (!formatter) {
-        formatter = new Intl.NumberFormat(targetLocale, shared.assign({}, format, overrides));
-        __numberFormatters.set(id, formatter);
+    // for vue-devtools timeline event
+    let start = null;
+    let startTag;
+    let endTag;
+    if (shared.inBrowser) {
+        start = window.performance.now();
+        startTag = 'intlify-message-compilation-start';
+        endTag = 'intlify-message-compilation-end';
+        shared.mark && shared.mark(startTag);
     }
-    return !part ? formatter.format(value) : formatter.formatToParts(value);
+    const msg = messageCompiler(format, getCompileContext(context, targetLocale, cacheBaseKey, format, warnHtmlMessage, onError));
+    // for vue-devtools timeline event
+    if (shared.inBrowser) {
+        const end = window.performance.now();
+        const emitter = context.__v_emitter;
+        if (emitter && start) {
+            emitter.emit('message-compilation', {
+                type: 'message-compilation',
+                message: format,
+                time: end - start,
+                groupId: `${'translate'}:${key}`
+            });
+        }
+        if (startTag && endTag && shared.mark && shared.measure) {
+            shared.mark(endTag);
+            shared.measure('intlify message compilation', startTag, endTag);
+        }
+    }
+    msg.locale = targetLocale;
+    msg.key = key;
+    msg.source = format;
+    return msg;
+}
+function evaluateMessage(context, msg, msgCtx) {
+    // for vue-devtools timeline event
+    let start = null;
+    let startTag;
+    let endTag;
+    if (shared.inBrowser) {
+        start = window.performance.now();
+        startTag = 'intlify-message-evaluation-start';
+        endTag = 'intlify-message-evaluation-end';
+        shared.mark && shared.mark(startTag);
+    }
+    const messaged = msg(msgCtx);
+    // for vue-devtools timeline event
+    if (shared.inBrowser) {
+        const end = window.performance.now();
+        const emitter = context.__v_emitter;
+        if (emitter && start) {
+            emitter.emit('message-evaluation', {
+                type: 'message-evaluation',
+                value: messaged,
+                time: end - start,
+                groupId: `${'translate'}:${msg.key}`
+            });
+        }
+        if (startTag && endTag && shared.mark && shared.measure) {
+            shared.mark(endTag);
+            shared.measure('intlify message evaluation', startTag, endTag);
+        }
+    }
+    return messaged;
 }
 /** @internal */
-const NUMBER_FORMAT_OPTIONS_KEYS = [
-    'localeMatcher',
-    'style',
-    'currency',
-    'currencyDisplay',
-    'currencySign',
-    'useGrouping',
-    'minimumIntegerDigits',
-    'minimumFractionDigits',
-    'maximumFractionDigits',
-    'minimumSignificantDigits',
-    'maximumSignificantDigits',
-    'compactDisplay',
-    'notation',
-    'signDisplay',
-    'unit',
-    'unitDisplay',
-    'roundingMode',
-    'roundingPriority',
-    'roundingIncrement',
-    'trailingZeroDisplay'
-];
-/** @internal */
-function parseNumberArgs(...args) {
-    const [arg1, arg2, arg3, arg4] = args;
+function parseTranslateArgs(...args) {
+    const [arg1, arg2, arg3] = args;
     const options = {};
-    let overrides = {};
-    if (!shared.isNumber(arg1)) {
+    if (!shared.isString(arg1) &&
+        !shared.isNumber(arg1) &&
+        !isMessageFunction(arg1) &&
+        !isMessageAST(arg1)) {
         throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
     }
-    const value = arg1;
-    if (shared.isString(arg2)) {
-        options.key = arg2;
+    // prettier-ignore
+    const key = shared.isNumber(arg1)
+        ? String(arg1)
+        : isMessageFunction(arg1)
+            ? arg1
+            : arg1;
+    if (shared.isNumber(arg2)) {
+        options.plural = arg2;
     }
-    else if (shared.isPlainObject(arg2)) {
-        Object.keys(arg2).forEach(key => {
-            if (NUMBER_FORMAT_OPTIONS_KEYS.includes(key)) {
-                overrides[key] = arg2[key];
-            }
-            else {
-                options[key] = arg2[key];
-            }
-        });
+    else if (shared.isString(arg2)) {
+        options.default = arg2;
     }
-    if (shared.isString(arg3)) {
-        options.locale = arg3;
+    else if (shared.isPlainObject(arg2) && !shared.isEmptyObject(arg2)) {
+        options.named = arg2;
+    }
+    else if (shared.isArray(arg2)) {
+        options.list = arg2;
+    }
+    if (shared.isNumber(arg3)) {
+        options.plural = arg3;
+    }
+    else if (shared.isString(arg3)) {
+        options.default = arg3;
     }
     else if (shared.isPlainObject(arg3)) {
-        overrides = arg3;
+        shared.assign(options, arg3);
     }
-    if (shared.isPlainObject(arg4)) {
-        overrides = arg4;
+    return [key, options];
+}
+function getCompileContext(context, locale, key, source, warnHtmlMessage, onError) {
+    return {
+        locale,
+        key,
+        warnHtmlMessage,
+        onError: (err) => {
+            onError && onError(err);
+            {
+                const _source = getSourceForCodeFrame(source);
+                const message = `Message compilation error: ${err.message}`;
+                const codeFrame = err.location &&
+                    _source &&
+                    shared.generateCodeFrame(_source, err.location.start.offset, err.location.end.offset);
+                const emitter = context.__v_emitter;
+                if (emitter && _source) {
+                    emitter.emit('compile-error', {
+                        message: _source,
+                        error: err.message,
+                        start: err.location && err.location.start.offset,
+                        end: err.location && err.location.end.offset,
+                        groupId: `${'translate'}:${key}`
+                    });
+                }
+                console.error(codeFrame ? `${message}\n${codeFrame}` : message);
+            }
+        },
+        onCacheKey: (source) => shared.generateFormatCacheKey(locale, key, source)
+    };
+}
+function getSourceForCodeFrame(source) {
+    if (shared.isString(source)) {
+        return source;
+    }
+    else {
+        if (source.loc && source.loc.source) {
+            return source.loc.source;
+        }
     }
-    return [options.key || '', value, options, overrides];
 }
-/** @internal */
-function clearNumberFormat(ctx, locale, format) {
-    const context = ctx;
-    for (const key in format) {
-        const id = `${locale}__${key}`;
-        if (!context.__numberFormatters.has(id)) {
-            continue;
+function getMessageContextOptions(context, locale, message, options) {
+    const { modifiers, pluralRules, messageResolver: resolveValue, fallbackLocale, fallbackWarn, missingWarn, fallbackContext } = context;
+    const resolveMessage = (key, useLinked) => {
+        let val = resolveValue(message, key);
+        // fallback
+        if (val == null && (fallbackContext || useLinked)) {
+            const [, , message] = resolveMessageFormat(fallbackContext || context, // NOTE: if has fallbackContext, fallback to root, else if use linked, fallback to local context
+            key, locale, fallbackLocale, fallbackWarn, missingWarn);
+            val = resolveValue(message, key);
         }
-        context.__numberFormatters.delete(id);
+        if (shared.isString(val) || isMessageAST(val)) {
+            let occurred = false;
+            const onError = () => {
+                occurred = true;
+            };
+            const msg = compileMessageFormat(context, key, locale, val, key, onError);
+            return !occurred
+                ? msg
+                : NOOP_MESSAGE_FUNCTION;
+        }
+        else if (isMessageFunction(val)) {
+            return val;
+        }
+        else {
+            // TODO: should be implemented warning message
+            return NOOP_MESSAGE_FUNCTION;
+        }
+    };
+    const ctxOptions = {
+        locale,
+        modifiers,
+        pluralRules,
+        messages: resolveMessage
+    };
+    if (context.processor) {
+        ctxOptions.processor = context.processor;
+    }
+    if (options.list) {
+        ctxOptions.list = options.list;
+    }
+    if (options.named) {
+        ctxOptions.named = options.named;
     }
+    if (shared.isNumber(options.plural)) {
+        ctxOptions.pluralIndex = options.plural;
+    }
+    return ctxOptions;
 }
 
 exports.CompileErrorCodes = messageCompiler.CompileErrorCodes;