@intlify/core-base 10.0.0-beta.5 → 10.0.0-rc.1

package/dist/core-base.global.js

@@ -1,5 +1,5 @@
 /*!
-  * core-base v10.0.0-beta.5
+  * core-base v10.0.0-rc.1
   * (c) 2024 kazuya kawaguchi
   * Released under the MIT License.
   */
@@ -1650,402 +1650,146 @@ var IntlifyCoreBase = (function (exports) {
       }
   }
 
-  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 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 (!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 (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 ? '' : join(values);
-  const DEFAULT_INTERPOLATE = 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 && detectHtmlTag(source)) {
+          warn(format$1(WARN_MESSAGE, { source }));
       }
-      return choice ? Math.min(choice, 2) : 0;
-  }
-  function getPluralIndex(options) {
-      // prettier-ignore
-      const index = isNumber(options.pluralIndex)
-          ? options.pluralIndex
-          : -1;
-      // prettier-ignore
-      return options.named && (isNumber(options.named.count) || isNumber(options.named.n))
-          ? isNumber(options.named.count)
-              ? options.named.count
-              : 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 = isObject(options.pluralRules) &&
-          isString(locale) &&
-          isFunction(options.pluralRules[locale])
-          ? options.pluralRules[locale]
-          : pluralDefault;
-      const orgPluralRule = isObject(options.pluralRules) &&
-          isString(locale) &&
-          isFunction(options.pluralRules[locale])
-          ? pluralDefault
-          : undefined;
-      const plural = (messages) => {
-          return messages[pluralRule(pluralIndex, messages.length, orgPluralRule)];
+  const isMessageAST = (val) => 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 || 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 || {};
-      isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);
-      const named = (key) => _named[key];
-      function message(key) {
-          // prettier-ignore
-          const msg = isFunction(options.messages)
-              ? options.messages(key)
-              : 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 { ...baseCompile$1(message, options), detectError };
+  }
+  /* #__NO_SIDE_EFFECTS__ */
+  function compile(message, context) {
+      if (isString(message)) {
+          // check HTML message
+          const warnHtmlMessage = 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 = isPlainObject(options.processor) && isFunction(options.processor.normalize)
-          ? options.processor.normalize
-          : DEFAULT_NORMALIZE;
-      const interpolate = isPlainObject(options.processor) &&
-          isFunction(options.processor.interpolate)
-          ? options.processor.interpolate
-          : DEFAULT_INTERPOLATE;
-      const type = isPlainObject(options.processor) && 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 (isObject(arg1)) {
-                  modifier = arg1.modifier || modifier;
-                  type = arg1.type || type;
-              }
-              else if (isString(arg1)) {
-                  modifier = arg1 || modifier;
-              }
+      else {
+          if (!isMessageAST(message)) {
+              warn(`the message that is resolve with key '${context.key}' is not supported for jit compilation`);
+              return (() => message);
           }
-          else if (args.length === 2) {
-              if (isString(arg1)) {
-                  modifier = arg1 || modifier;
-              }
-              if (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)(ctx);
-          const msg = 
-          // The message in vnode resolved with linked are returned as an array by processor.nomalize
-          type === 'vnode' && 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 */]: assign({}, _list, _named)
-      };
-      return ctx;
+          else {
+              return format(message);
+          }
+      }
   }
 
   let devtools = null;
@@ -2071,30 +1815,6 @@ var IntlifyCoreBase = (function (exports) {
       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 format$1(warnMessages[code], ...args);
-  }
-
   const CoreErrorCodes = {
       INVALID_ARGUMENT: COMPILE_ERROR_CODES_EXTEND_POINT, // 17
       INVALID_DATE_ARGUMENT: 18,
@@ -2268,66 +1988,358 @@ var IntlifyCoreBase = (function (exports) {
       return follow;
   }
 
-  /* eslint-disable @typescript-eslint/no-explicit-any */
-  /**
-   * Intlify core-base version
-   * @internal
-   */
-  const VERSION = '10.0.0-beta.5';
-  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' && isString(val)
-                  ? val.toUpperCase()
-                  : type === 'vnode' && isObject(val) && '__v_isVNode' in val
-                      ? val.children.toUpperCase()
-                      : val;
-          },
-          lower: (val, type) => {
-              // prettier-ignore
-              return type === 'text' && isString(val)
-                  ? val.toLowerCase()
-                  : type === 'vnode' && isObject(val) && '__v_isVNode' in val
-                      ? val.children.toLowerCase()
-                      : val;
-          },
-          capitalize: (val, type) => {
-              // prettier-ignore
-              return (type === 'text' && isString(val)
-                  ? capitalize(val)
-                  : type === 'vnode' && isObject(val) && '__v_isVNode' in val
-                      ? capitalize(val.children)
-                      : val);
+  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;
+  }
+  /**
+   * 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 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.
    *
-   * @VueI18nGeneral
+   * @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 (!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 (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 format$1(warnMessages[code], ...args);
+  }
+
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  /**
+   * Intlify core-base version
+   * @internal
+   */
+  const VERSION = '10.0.0-rc.1';
+  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' && isString(val)
+                  ? val.toUpperCase()
+                  : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                      ? val.children.toUpperCase()
+                      : val;
+          },
+          lower: (val, type) => {
+              // prettier-ignore
+              return type === 'text' && isString(val)
+                  ? val.toLowerCase()
+                  : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                      ? val.children.toLowerCase()
+                      : val;
+          },
+          capitalize: (val, type) => {
+              // prettier-ignore
+              return (type === 'text' && isString(val)
+                  ? capitalize(val)
+                  : type === 'vnode' && 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
    */
   function registerLocaleFallbacker(fallbacker) {
       _fallbacker = fallbacker;
@@ -2426,670 +2438,288 @@ var IntlifyCoreBase = (function (exports) {
           missing,
           missingWarn,
           fallbackWarn,
-          fallbackFormat,
-          unresolving,
-          postTranslation,
-          processor,
-          warnHtmlMessage,
-          escapeParameter,
-          messageCompiler,
-          messageResolver,
-          localeFallbacker,
-          fallbackContext,
-          onWarn,
-          __meta
-      };
-      {
-          context.datetimeFormats = datetimeFormats;
-          context.numberFormats = numberFormats;
-          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 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 && detectHtmlTag(source)) {
-          warn(format$1(WARN_MESSAGE, { source }));
-      }
-  }
-  const defaultOnCacheKey = (message) => message;
-  let compileCache = Object.create(null);
-  function clearCompileCache() {
-      compileCache = Object.create(null);
-  }
-  const isMessageAST = (val) => 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 || defaultOnError;
-      options.onError = (err) => {
-          detectError = true;
-          onError(err);
-      };
-      // compile with mesasge-compiler
-      return { ...baseCompile$1(message, options), detectError };
-  }
-  /* #__NO_SIDE_EFFECTS__ */
-  function compile(message, context) {
-      if (isString(message)) {
-          // check HTML message
-          const warnHtmlMessage = 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)) {
-              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) => 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 = isBoolean(options.missingWarn)
-          ? options.missingWarn
-          : context.missingWarn;
-      const fallbackWarn = isBoolean(options.fallbackWarn)
-          ? options.fallbackWarn
-          : context.fallbackWarn;
-      const escapeParameter = isBoolean(options.escapeParameter)
-          ? options.escapeParameter
-          : context.escapeParameter;
-      const resolvedMessage = !!options.resolvedMessage;
-      // prettier-ignore
-      const defaultMsgOrKey = isString(options.default) || isBoolean(options.default) // default by function option
-          ? !isBoolean(options.default)
-              ? options.default
-              : (!messageCompiler ? () => key : key)
-          : fallbackFormat // default by `fallbackFormat` option
-              ? (!messageCompiler ? () => key : key)
-              : null;
-      const enableDefaultMsg = fallbackFormat ||
-          (defaultMsgOrKey != null &&
-              (isString(defaultMsgOrKey) || 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 &&
-          !(isString(format) ||
-              isMessageAST(format) ||
-              isMessageFunction(format))) {
-          if (enableDefaultMsg) {
-              format = defaultMsgOrKey;
-              cacheBaseKey = format;
-          }
-      }
-      // checking message format and target locale
-      if (!resolvedMessage &&
-          (!(isString(format) ||
-              isMessageAST(format) ||
-              isMessageFunction(format)) ||
-              !isString(targetLocale))) {
-          return unresolving ? NOT_REOSLVED : key;
-      }
-      // TODO: refactor
-      if (isString(format) && context.messageCompiler == null) {
-          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;
+          fallbackFormat,
+          unresolving,
+          postTranslation,
+          processor,
+          warnHtmlMessage,
+          escapeParameter,
+          messageCompiler,
+          messageResolver,
+          localeFallbacker,
+          fallbackContext,
+          onWarn,
+          __meta
       };
-      // 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;
+      {
+          context.datetimeFormats = datetimeFormats;
+          context.numberFormats = numberFormats;
+          context.__datetimeFormatters = __datetimeFormatters;
+          context.__numberFormatters = __numberFormatters;
+      }
+      // 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: isString(key)
-                  ? key
-                  : isMessageFunction(format)
-                      ? format.key
-                      : '',
-              locale: targetLocale || (isMessageFunction(format)
-                  ? format.locale
-                  : ''),
-              format: isString(format)
-                  ? format
-                  : isMessageFunction(format)
-                      ? format.source
-                      : '',
-              message: ret
-          };
-          payloads.meta = assign({}, context.__meta, getAdditionalMeta() || {});
-          translateDevTools(payloads);
+          initI18nDevTools(context, version, __meta);
       }
-      return ret;
+      return context;
   }
-  function escapeParams(options) {
-      if (isArray(options.list)) {
-          options.list = options.list.map(item => isString(item) ? escapeHtml(item) : item);
-      }
-      else if (isObject(options.named)) {
-          Object.keys(options.named).forEach(key => {
-              if (isString(options.named[key])) {
-                  options.named[key] = 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, {
-                  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 (inBrowser) {
-              start = window.performance.now();
-              startTag = 'intlify-message-resolve-start';
-              endTag = 'intlify-message-resolve-end';
-              mark && 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 (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 && mark && measure) {
-                  mark(endTag);
-                  measure('intlify message resolve', startTag, endTag);
-              }
-          }
-          if (isString(format) || isMessageAST(format) || isMessageFunction(format)) {
-              break;
-          }
-          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;
-      }
-      return [format, targetLocale, message];
+  /** @internal */
+  function isTranslateMissingWarn(missing, key) {
+      return missing instanceof RegExp ? missing.test(key) : missing;
   }
-  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;
-      }
-      if (messageCompiler == null) {
-          const msg = (() => format);
-          msg.locale = targetLocale;
-          msg.key = key;
-          return msg;
-      }
-      // for vue-devtools timeline event
-      let start = null;
-      let startTag;
-      let endTag;
-      if (inBrowser) {
-          start = window.performance.now();
-          startTag = 'intlify-message-compilation-start';
-          endTag = 'intlify-message-compilation-end';
-          mark && mark(startTag);
-      }
-      const msg = messageCompiler(format, getCompileContext(context, targetLocale, cacheBaseKey, format, warnHtmlMessage, onError));
+  /** @internal */
+  function handleMissing(context, key, locale, missingWarn, type) {
+      const { missing, onWarn } = context;
       // for vue-devtools timeline event
-      if (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 (emitter) {
+              emitter.emit('missing', {
+                  locale,
+                  key,
+                  type,
+                  groupId: `${type}:${key}`
               });
           }
-          if (startTag && endTag && mark && measure) {
-              mark(endTag);
-              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 (inBrowser) {
-          start = window.performance.now();
-          startTag = 'intlify-message-evaluation-start';
-          endTag = 'intlify-message-evaluation-end';
-          mark && mark(startTag);
+      if (missing !== null) {
+          const ret = missing(context, locale, key, type);
+          return isString(ret) ? ret : key;
       }
-      const messaged = msg(msgCtx);
-      // for vue-devtools timeline event
-      if (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 && mark && measure) {
-              mark(endTag);
-              measure('intlify message evaluation', startTag, endTag);
+      else {
+          if (isTranslateMissingWarn(missingWarn, key)) {
+              onWarn(getWarnMessage(CoreWarnCodes.NOT_FOUND_KEY, { key, locale }));
           }
+          return key;
       }
-      return messaged;
   }
   /** @internal */
-  function parseTranslateArgs(...args) {
-      const [arg1, arg2, arg3] = args;
-      const options = {};
-      if (!isString(arg1) &&
-          !isNumber(arg1) &&
-          !isMessageFunction(arg1) &&
-          !isMessageAST(arg1)) {
-          throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
-      }
-      // prettier-ignore
-      const key = isNumber(arg1)
-          ? String(arg1)
-          : isMessageFunction(arg1)
-              ? arg1
-              : arg1;
-      if (isNumber(arg2)) {
-          options.plural = arg2;
-      }
-      else if (isString(arg2)) {
-          options.default = arg2;
+  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;
       }
-      else if (isPlainObject(arg2) && !isEmptyObject(arg2)) {
-          options.named = arg2;
+      for (let i = index + 1; i < locales.length; i++) {
+          if (isAlmostSameLocale(targetLocale, locales[i])) {
+              return true;
+          }
       }
-      else if (isArray(arg2)) {
-          options.list = arg2;
+      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;
       }
-      if (isNumber(arg3)) {
-          options.plural = arg3;
+      const [key, value, options, overrides] = parseDateTimeArgs(...args);
+      const missingWarn = isBoolean(options.missingWarn)
+          ? options.missingWarn
+          : context.missingWarn;
+      const fallbackWarn = 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 (!isString(key) || key === '') {
+          return new Intl.DateTimeFormat(locale, overrides).format(value);
       }
-      else if (isString(arg3)) {
-          options.default = arg3;
+      // 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
+              }));
+          }
+          // 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 (isPlainObject(format))
+              break;
+          handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+          from = to;
       }
-      else if (isPlainObject(arg3)) {
-          assign(options, arg3);
+      // checking format and target locale
+      if (!isPlainObject(format) || !isString(targetLocale)) {
+          return unresolving ? NOT_REOSLVED : key;
       }
-      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 &&
-                      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) => generateFormatCacheKey(locale, key, source)
-      };
-  }
-  function getSourceForCodeFrame(source) {
-      if (isString(source)) {
-          return source;
+      let id = `${targetLocale}__${key}`;
+      if (!isEmptyObject(overrides)) {
+          id = `${id}__${JSON.stringify(overrides)}`;
       }
-      else {
-          if (source.loc && source.loc.source) {
-              return source.loc.source;
-          }
+      let formatter = __datetimeFormatters.get(id);
+      if (!formatter) {
+          formatter = new Intl.DateTimeFormat(targetLocale, assign({}, format, overrides));
+          __datetimeFormatters.set(id, formatter);
       }
+      return !part ? formatter.format(value) : formatter.formatToParts(value);
   }
-  function getMessageContextOptions(context, locale, message, options) {
-      const { modifiers, pluralRules, messageResolver: resolveValue, fallbackLocale, fallbackWarn, missingWarn, fallbackContext } = context;
-      const resolveMessage = (key) => {
-          let val = resolveValue(message, key);
-          // fallback to root context
-          if (val == null && fallbackContext) {
-              const [, , message] = resolveMessageFormat(fallbackContext, key, locale, fallbackLocale, fallbackWarn, missingWarn);
-              val = resolveValue(message, key);
+  /** @internal */
+  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 = {};
+      let overrides = {};
+      let value;
+      if (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);
           }
-          if (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;
+          // 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();
           }
-          else if (isMessageFunction(val)) {
-              return val;
+          catch {
+              throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
           }
-          else {
-              // TODO: should be implemented warning message
-              return NOOP_MESSAGE_FUNCTION;
+      }
+      else if (isDate(arg1)) {
+          if (isNaN(arg1.getTime())) {
+              throw createCoreError(CoreErrorCodes.INVALID_DATE_ARGUMENT);
           }
-      };
-      const ctxOptions = {
-          locale,
-          modifiers,
-          pluralRules,
-          messages: resolveMessage
-      };
-      if (context.processor) {
-          ctxOptions.processor = context.processor;
+          value = arg1;
       }
-      if (options.list) {
-          ctxOptions.list = options.list;
+      else if (isNumber(arg1)) {
+          value = arg1;
+      }
+      else {
+          throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+      }
+      if (isString(arg2)) {
+          options.key = arg2;
+      }
+      else if (isPlainObject(arg2)) {
+          Object.keys(arg2).forEach(key => {
+              if (DATETIME_FORMAT_OPTIONS_KEYS.includes(key)) {
+                  overrides[key] = arg2[key];
+              }
+              else {
+                  options[key] = arg2[key];
+              }
+          });
+      }
+      if (isString(arg3)) {
+          options.locale = arg3;
+      }
+      else if (isPlainObject(arg3)) {
+          overrides = arg3;
       }
-      if (options.named) {
-          ctxOptions.named = options.named;
+      if (isPlainObject(arg4)) {
+          overrides = arg4;
       }
-      if (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 = isBoolean(options.missingWarn)
           ? options.missingWarn
           : context.missingWarn;
@@ -3101,20 +2731,20 @@ var IntlifyCoreBase = (function (exports) {
       const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
       fallbackLocale, locale);
       if (!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
               }));
@@ -3132,9 +2762,9 @@ var IntlifyCoreBase = (function (exports) {
                   });
               }
           }
-          datetimeFormat =
-              datetimeFormats[targetLocale] || {};
-          format = datetimeFormat[key];
+          numberFormat =
+              numberFormats[targetLocale] || {};
+          format = numberFormat[key];
           if (isPlainObject(format))
               break;
           handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
@@ -3148,147 +2778,356 @@ var IntlifyCoreBase = (function (exports) {
       if (!isEmptyObject(overrides)) {
           id = `${id}__${JSON.stringify(overrides)}`;
       }
-      let formatter = __datetimeFormatters.get(id);
+      let formatter = __numberFormatters.get(id);
       if (!formatter) {
-          formatter = new Intl.DateTimeFormat(targetLocale, assign({}, format, overrides));
-          __datetimeFormatters.set(id, formatter);
+          formatter = new Intl.NumberFormat(targetLocale, 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 (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 (!isNumber(arg1)) {
+          throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+      }
+      const value = arg1;
+      if (isString(arg2)) {
+          options.key = arg2;
+      }
+      else if (isPlainObject(arg2)) {
+          Object.keys(arg2).forEach(key => {
+              if (NUMBER_FORMAT_OPTIONS_KEYS.includes(key)) {
+                  overrides[key] = arg2[key];
+              }
+              else {
+                  options[key] = arg2[key];
+              }
+          });
+      }
+      if (isString(arg3)) {
+          options.locale = arg3;
+      }
+      else if (isPlainObject(arg3)) {
+          overrides = arg3;
+      }
+      if (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 (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 ? '' : join(values);
+  const DEFAULT_INTERPOLATE = 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 = isNumber(options.pluralIndex)
+          ? options.pluralIndex
+          : -1;
+      // prettier-ignore
+      return options.named && (isNumber(options.named.count) || isNumber(options.named.n))
+          ? isNumber(options.named.count)
+              ? options.named.count
+              : 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 = isObject(options.pluralRules) &&
+          isString(locale) &&
+          isFunction(options.pluralRules[locale])
+          ? options.pluralRules[locale]
+          : pluralDefault;
+      const orgPluralRule = isObject(options.pluralRules) &&
+          isString(locale) &&
+          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 || {};
+      isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);
+      const named = (key) => _named[key];
+      function message(key, useLinked) {
+          // prettier-ignore
+          const msg = isFunction(options.messages)
+              ? options.messages(key, !!useLinked)
+              : 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 = isPlainObject(options.processor) && isFunction(options.processor.normalize)
+          ? options.processor.normalize
+          : DEFAULT_NORMALIZE;
+      const interpolate = isPlainObject(options.processor) &&
+          isFunction(options.processor.interpolate)
+          ? options.processor.interpolate
+          : DEFAULT_INTERPOLATE;
+      const type = isPlainObject(options.processor) && 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 (isObject(arg1)) {
+                  modifier = arg1.modifier || modifier;
+                  type = arg1.type || type;
+              }
+              else if (isString(arg1)) {
+                  modifier = arg1 || modifier;
+              }
           }
-          value = arg1;
-      }
-      else if (isNumber(arg1)) {
-          value = arg1;
-      }
-      else {
-          throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
-      }
-      if (isString(arg2)) {
-          options.key = arg2;
-      }
-      else if (isPlainObject(arg2)) {
-          Object.keys(arg2).forEach(key => {
-              if (DATETIME_FORMAT_OPTIONS_KEYS.includes(key)) {
-                  overrides[key] = arg2[key];
+          else if (args.length === 2) {
+              if (isString(arg1)) {
+                  modifier = arg1 || modifier;
               }
-              else {
-                  options[key] = arg2[key];
+              if (isString(arg2)) {
+                  type = arg2 || type;
               }
-          });
-      }
-      if (isString(arg3)) {
-          options.locale = arg3;
-      }
-      else if (isPlainObject(arg3)) {
-          overrides = arg3;
-      }
-      if (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' && 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 */]: 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) => 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 = isBoolean(options.missingWarn)
           ? options.missingWarn
           : context.missingWarn;
       const fallbackWarn = isBoolean(options.fallbackWarn)
           ? options.fallbackWarn
           : context.fallbackWarn;
-      const part = !!options.part;
+      const escapeParameter = isBoolean(options.escapeParameter)
+          ? options.escapeParameter
+          : context.escapeParameter;
+      const resolvedMessage = !!options.resolvedMessage;
+      // prettier-ignore
+      const defaultMsgOrKey = isString(options.default) || isBoolean(options.default) // default by function option
+          ? !isBoolean(options.default)
+              ? options.default
+              : (!messageCompiler ? () => key : key)
+          : fallbackFormat // default by `fallbackFormat` option
+              ? (!messageCompiler ? () => key : key)
+              : null;
+      const enableDefaultMsg = fallbackFormat ||
+          (defaultMsgOrKey != null &&
+              (isString(defaultMsgOrKey) || isFunction(defaultMsgOrKey)));
       const locale = getLocale(context, options);
-      const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
-      fallbackLocale, locale);
-      if (!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 &&
+          !(isString(format) ||
+              isMessageAST(format) ||
+              isMessageFunction(format))) {
+          if (enableDefaultMsg) {
+              format = defaultMsgOrKey;
+              cacheBaseKey = format;
+          }
       }
-      // resolve format
-      let numberFormat = {};
+      // checking message format and target locale
+      if (!resolvedMessage &&
+          (!(isString(format) ||
+              isMessageAST(format) ||
+              isMessageFunction(format)) ||
+              !isString(targetLocale))) {
+          return unresolving ? NOT_REOSLVED : key;
+      }
+      // TODO: refactor
+      if (isString(format) && context.messageCompiler == null) {
+          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: isString(key)
+                  ? key
+                  : isMessageFunction(format)
+                      ? format.key
+                      : '',
+              locale: targetLocale || (isMessageFunction(format)
+                  ? format.locale
+                  : ''),
+              format: isString(format)
+                  ? format
+                  : isMessageFunction(format)
+                      ? format.source
+                      : '',
+              message: ret
+          };
+          payloads.meta = assign({}, context.__meta, getAdditionalMeta() || {});
+          translateDevTools(payloads);
+      }
+      return ret;
+  }
+  function escapeParams(options) {
+      if (isArray(options.list)) {
+          options.list = options.list.map(item => isString(item) ? escapeHtml(item) : item);
+      }
+      else if (isObject(options.named)) {
+          Object.keys(options.named).forEach(key => {
+              if (isString(options.named[key])) {
+                  options.named[key] = 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
               }));
@@ -3306,95 +3145,257 @@ var IntlifyCoreBase = (function (exports) {
                   });
               }
           }
-          numberFormat =
-              numberFormats[targetLocale] || {};
-          format = numberFormat[key];
-          if (isPlainObject(format))
-              break;
-          handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+          message =
+              messages[targetLocale] || {};
+          // for vue-devtools timeline event
+          let start = null;
+          let startTag;
+          let endTag;
+          if (inBrowser) {
+              start = window.performance.now();
+              startTag = 'intlify-message-resolve-start';
+              endTag = 'intlify-message-resolve-end';
+              mark && 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 (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 && mark && measure) {
+                  mark(endTag);
+                  measure('intlify message resolve', startTag, endTag);
+              }
+          }
+          if (isString(format) || isMessageAST(format) || isMessageFunction(format)) {
+              break;
+          }
+          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 (!isPlainObject(format) || !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 (!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, assign({}, format, overrides));
-          __numberFormatters.set(id, formatter);
+      // for vue-devtools timeline event
+      let start = null;
+      let startTag;
+      let endTag;
+      if (inBrowser) {
+          start = window.performance.now();
+          startTag = 'intlify-message-compilation-start';
+          endTag = 'intlify-message-compilation-end';
+          mark && 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 (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 && mark && measure) {
+              mark(endTag);
+              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 (inBrowser) {
+          start = window.performance.now();
+          startTag = 'intlify-message-evaluation-start';
+          endTag = 'intlify-message-evaluation-end';
+          mark && mark(startTag);
+      }
+      const messaged = msg(msgCtx);
+      // for vue-devtools timeline event
+      if (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 && mark && measure) {
+              mark(endTag);
+              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 (!isNumber(arg1)) {
+      if (!isString(arg1) &&
+          !isNumber(arg1) &&
+          !isMessageFunction(arg1) &&
+          !isMessageAST(arg1)) {
           throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
       }
-      const value = arg1;
-      if (isString(arg2)) {
-          options.key = arg2;
+      // prettier-ignore
+      const key = isNumber(arg1)
+          ? String(arg1)
+          : isMessageFunction(arg1)
+              ? arg1
+              : arg1;
+      if (isNumber(arg2)) {
+          options.plural = arg2;
       }
-      else if (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 (isString(arg2)) {
+          options.default = arg2;
       }
-      if (isString(arg3)) {
-          options.locale = arg3;
+      else if (isPlainObject(arg2) && !isEmptyObject(arg2)) {
+          options.named = arg2;
+      }
+      else if (isArray(arg2)) {
+          options.list = arg2;
+      }
+      if (isNumber(arg3)) {
+          options.plural = arg3;
+      }
+      else if (isString(arg3)) {
+          options.default = arg3;
       }
       else if (isPlainObject(arg3)) {
-          overrides = arg3;
+          assign(options, arg3);
       }
-      if (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 &&
+                      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) => generateFormatCacheKey(locale, key, source)
+      };
+  }
+  function getSourceForCodeFrame(source) {
+      if (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 (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 (isNumber(options.plural)) {
+          ctxOptions.pluralIndex = options.plural;
+      }
+      return ctxOptions;
   }
 
   exports.CORE_ERROR_CODES_EXTEND_POINT = CORE_ERROR_CODES_EXTEND_POINT;