@intlify/core-base 9.13.1 → 10.0.0-alpha.2

package/dist/core-base.esm-browser.js

@@ -1,5 +1,5 @@
 /*!
-  * core-base v9.13.1
+  * core-base v10.0.0-alpha.2
   * (c) 2024 kazuya kawaguchi
   * Released under the MIT License.
   */
@@ -161,23 +161,6 @@ function createLocation(start, end, source) {
     return loc;
 }
 
-const CompileWarnCodes = {
-    USE_MODULO_SYNTAX: 1,
-    __EXTEND_POINT__: 2
-};
-/** @internal */
-const warnMessages$1 = {
-    [CompileWarnCodes.USE_MODULO_SYNTAX]: `Use modulo before '{{0}}'.`
-};
-function createCompileWarn(code, loc, ...args) {
-    const msg = format$1(warnMessages$1[code] || '', ...(args || [])) ;
-    const message = { message: String(msg), code };
-    if (loc) {
-        message.location = loc;
-    }
-    return message;
-}
-
 const CompileErrorCodes = {
     // tokenizer error codes
     EXPECTED_TOKEN: 1,
@@ -302,7 +285,6 @@ function createScanner(str) {
     }
     function skipToPeek() {
         const target = _index + _peekOffset;
-        // eslint-disable-next-line no-unmodified-loop-condition
         while (target !== _index) {
             next();
         }
@@ -336,11 +318,11 @@ function createTokenizer(source, options = {}) {
     const _initLoc = currentPosition();
     const _initOffset = currentOffset();
     const _context = {
-        currentType: 14 /* TokenTypes.EOF */,
+        currentType: 13 /* TokenTypes.EOF */,
         offset: _initOffset,
         startLoc: _initLoc,
         endLoc: _initLoc,
-        lastType: 14 /* TokenTypes.EOF */,
+        lastType: 13 /* TokenTypes.EOF */,
         lastOffset: _initOffset,
         lastStartLoc: _initLoc,
         lastEndLoc: _initLoc,
@@ -375,7 +357,7 @@ function createTokenizer(source, options = {}) {
         }
         return token;
     }
-    const getEndToken = (context) => getToken(context, 14 /* TokenTypes.EOF */);
+    const getEndToken = (context) => getToken(context, 13 /* TokenTypes.EOF */);
     function eat(scnr, ch) {
         if (scnr.currentChar() === ch) {
             scnr.next();
@@ -449,7 +431,7 @@ function createTokenizer(source, options = {}) {
     }
     function isLinkedDotStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 8 /* TokenTypes.LinkedAlias */) {
+        if (currentType !== 7 /* TokenTypes.LinkedAlias */) {
             return false;
         }
         peekSpaces(scnr);
@@ -459,7 +441,7 @@ function createTokenizer(source, options = {}) {
     }
     function isLinkedModifierStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 9 /* TokenTypes.LinkedDot */) {
+        if (currentType !== 8 /* TokenTypes.LinkedDot */) {
             return false;
         }
         peekSpaces(scnr);
@@ -469,8 +451,8 @@ function createTokenizer(source, options = {}) {
     }
     function isLinkedDelimiterStart(scnr, context) {
         const { currentType } = context;
-        if (!(currentType === 8 /* TokenTypes.LinkedAlias */ ||
-            currentType === 12 /* TokenTypes.LinkedModifier */)) {
+        if (!(currentType === 7 /* TokenTypes.LinkedAlias */ ||
+            currentType === 11 /* TokenTypes.LinkedModifier */)) {
             return false;
         }
         peekSpaces(scnr);
@@ -480,7 +462,7 @@ function createTokenizer(source, options = {}) {
     }
     function isLinkedReferStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 10 /* TokenTypes.LinkedDelimiter */) {
+        if (currentType !== 9 /* TokenTypes.LinkedDelimiter */) {
             return false;
         }
         const fn = () => {
@@ -489,7 +471,6 @@ function createTokenizer(source, options = {}) {
                 return isIdentifierStart(scnr.peek());
             }
             else if (ch === "@" /* TokenChars.LinkedAlias */ ||
-                ch === "%" /* TokenChars.Modulo */ ||
                 ch === "|" /* TokenChars.Pipe */ ||
                 ch === ":" /* TokenChars.LinkedDelimiter */ ||
                 ch === "." /* TokenChars.LinkedDot */ ||
@@ -516,41 +497,25 @@ function createTokenizer(source, options = {}) {
         scnr.resetPeek();
         return ret;
     }
-    function detectModuloStart(scnr) {
-        const spaces = peekSpaces(scnr);
-        const ret = scnr.currentPeek() === "%" /* TokenChars.Modulo */ &&
-            scnr.peek() === "{" /* TokenChars.BraceLeft */;
-        scnr.resetPeek();
-        return {
-            isModulo: ret,
-            hasSpace: spaces.length > 0
-        };
-    }
     function isTextStart(scnr, reset = true) {
-        const fn = (hasSpace = false, prev = '', detectModulo = false) => {
+        const fn = (hasSpace = false, prev = '') => {
             const ch = scnr.currentPeek();
             if (ch === "{" /* TokenChars.BraceLeft */) {
-                return prev === "%" /* TokenChars.Modulo */ ? false : hasSpace;
+                return hasSpace;
             }
             else if (ch === "@" /* TokenChars.LinkedAlias */ || !ch) {
-                return prev === "%" /* TokenChars.Modulo */ ? true : hasSpace;
-            }
-            else if (ch === "%" /* TokenChars.Modulo */) {
-                scnr.peek();
-                return fn(hasSpace, "%" /* TokenChars.Modulo */, true);
+                return hasSpace;
             }
             else if (ch === "|" /* TokenChars.Pipe */) {
-                return prev === "%" /* TokenChars.Modulo */ || detectModulo
-                    ? true
-                    : !(prev === CHAR_SP || prev === CHAR_LF);
+                return !(prev === CHAR_SP || prev === CHAR_LF);
             }
             else if (ch === CHAR_SP) {
                 scnr.peek();
-                return fn(true, CHAR_SP, detectModulo);
+                return fn(true, CHAR_SP);
             }
             else if (ch === CHAR_LF) {
                 scnr.peek();
-                return fn(true, CHAR_LF, detectModulo);
+                return fn(true, CHAR_LF);
             }
             else {
                 return true;
@@ -620,18 +585,8 @@ function createTokenizer(source, options = {}) {
         }
         return num;
     }
-    function readModulo(scnr) {
-        skipSpaces(scnr);
-        const ch = scnr.currentChar();
-        if (ch !== "%" /* TokenChars.Modulo */) {
-            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
-        }
-        scnr.next();
-        return "%" /* TokenChars.Modulo */;
-    }
     function readText(scnr) {
         let buf = '';
-        // eslint-disable-next-line no-constant-condition
         while (true) {
             const ch = scnr.currentChar();
             if (ch === "{" /* TokenChars.BraceLeft */ ||
@@ -641,15 +596,6 @@ function createTokenizer(source, options = {}) {
                 !ch) {
                 break;
             }
-            else if (ch === "%" /* TokenChars.Modulo */) {
-                if (isTextStart(scnr)) {
-                    buf += ch;
-                    scnr.next();
-                }
-                else {
-                    break;
-                }
-            }
             else if (ch === CHAR_SP || ch === CHAR_LF) {
                 if (isTextStart(scnr)) {
                     buf += ch;
@@ -785,7 +731,6 @@ function createTokenizer(source, options = {}) {
         const fn = (buf) => {
             const ch = scnr.currentChar();
             if (ch === "{" /* TokenChars.BraceLeft */ ||
-                ch === "%" /* TokenChars.Modulo */ ||
                 ch === "@" /* TokenChars.LinkedAlias */ ||
                 ch === "|" /* TokenChars.Pipe */ ||
                 ch === "(" /* TokenChars.ParenLeft */ ||
@@ -864,31 +809,31 @@ function createTokenizer(source, options = {}) {
                     return token;
                 }
                 if (context.braceNest > 0 &&
-                    (context.currentType === 5 /* TokenTypes.Named */ ||
-                        context.currentType === 6 /* TokenTypes.List */ ||
-                        context.currentType === 7 /* TokenTypes.Literal */)) {
+                    (context.currentType === 4 /* TokenTypes.Named */ ||
+                        context.currentType === 5 /* TokenTypes.List */ ||
+                        context.currentType === 6 /* TokenTypes.Literal */)) {
                     emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
                     context.braceNest = 0;
                     return readToken(scnr, context);
                 }
                 if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
-                    token = getToken(context, 5 /* TokenTypes.Named */, readNamedIdentifier(scnr));
+                    token = getToken(context, 4 /* TokenTypes.Named */, readNamedIdentifier(scnr));
                     skipSpaces(scnr);
                     return token;
                 }
                 if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
-                    token = getToken(context, 6 /* TokenTypes.List */, readListIdentifier(scnr));
+                    token = getToken(context, 5 /* TokenTypes.List */, readListIdentifier(scnr));
                     skipSpaces(scnr);
                     return token;
                 }
                 if ((validLiteral = isLiteralStart(scnr, context))) {
-                    token = getToken(context, 7 /* TokenTypes.Literal */, readLiteral(scnr));
+                    token = getToken(context, 6 /* TokenTypes.Literal */, readLiteral(scnr));
                     skipSpaces(scnr);
                     return token;
                 }
                 if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
                     // TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
-                    token = getToken(context, 13 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
+                    token = getToken(context, 12 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
                     emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
                     skipSpaces(scnr);
                     return token;
@@ -903,27 +848,27 @@ function createTokenizer(source, options = {}) {
         const { currentType } = context;
         let token = null;
         const ch = scnr.currentChar();
-        if ((currentType === 8 /* TokenTypes.LinkedAlias */ ||
-            currentType === 9 /* TokenTypes.LinkedDot */ ||
-            currentType === 12 /* TokenTypes.LinkedModifier */ ||
-            currentType === 10 /* TokenTypes.LinkedDelimiter */) &&
+        if ((currentType === 7 /* TokenTypes.LinkedAlias */ ||
+            currentType === 8 /* TokenTypes.LinkedDot */ ||
+            currentType === 11 /* TokenTypes.LinkedModifier */ ||
+            currentType === 9 /* TokenTypes.LinkedDelimiter */) &&
             (ch === CHAR_LF || ch === CHAR_SP)) {
             emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
         }
         switch (ch) {
             case "@" /* TokenChars.LinkedAlias */:
                 scnr.next();
-                token = getToken(context, 8 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
+                token = getToken(context, 7 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
                 context.inLinked = true;
                 return token;
             case "." /* TokenChars.LinkedDot */:
                 skipSpaces(scnr);
                 scnr.next();
-                return getToken(context, 9 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
+                return getToken(context, 8 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
             case ":" /* TokenChars.LinkedDelimiter */:
                 skipSpaces(scnr);
                 scnr.next();
-                return getToken(context, 10 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
+                return getToken(context, 9 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
             default:
                 if (isPluralStart(scnr)) {
                     token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
@@ -939,7 +884,7 @@ function createTokenizer(source, options = {}) {
                 }
                 if (isLinkedModifierStart(scnr, context)) {
                     skipSpaces(scnr);
-                    return getToken(context, 12 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
+                    return getToken(context, 11 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
                 }
                 if (isLinkedReferStart(scnr, context)) {
                     skipSpaces(scnr);
@@ -948,10 +893,10 @@ function createTokenizer(source, options = {}) {
                         return readTokenInPlaceholder(scnr, context) || token;
                     }
                     else {
-                        return getToken(context, 11 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
+                        return getToken(context, 10 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
                     }
                 }
-                if (currentType === 8 /* TokenTypes.LinkedAlias */) {
+                if (currentType === 7 /* TokenTypes.LinkedAlias */) {
                     emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
                 }
                 context.braceNest = 0;
@@ -961,7 +906,7 @@ function createTokenizer(source, options = {}) {
     }
     // TODO: We need refactoring of token parsing ...
     function readToken(scnr, context) {
-        let token = { type: 14 /* TokenTypes.EOF */ };
+        let token = { type: 13 /* TokenTypes.EOF */ };
         if (context.braceNest > 0) {
             return readTokenInPlaceholder(scnr, context) || getEndToken(context);
         }
@@ -986,12 +931,6 @@ function createTokenizer(source, options = {}) {
                     context.inLinked = false;
                     return token;
                 }
-                const { isModulo, hasSpace } = detectModuloStart(scnr);
-                if (isModulo) {
-                    return hasSpace
-                        ? getToken(context, 0 /* TokenTypes.Text */, readText(scnr))
-                        : getToken(context, 4 /* TokenTypes.Modulo */, readModulo(scnr));
-                }
                 if (isTextStart(scnr)) {
                     return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
                 }
@@ -1009,7 +948,7 @@ function createTokenizer(source, options = {}) {
         _context.offset = currentOffset();
         _context.startLoc = currentPosition();
         if (_scnr.currentChar() === EOF) {
-            return getToken(_context, 14 /* TokenTypes.EOF */);
+            return getToken(_context, 13 /* TokenTypes.EOF */);
         }
         return readToken(_scnr, _context);
     }
@@ -1045,7 +984,7 @@ function fromEscapeSequence(match, codePoint4, codePoint6) {
 }
 function createParser(options = {}) {
     const location = options.location !== false;
-    const { onError, onWarn } = options;
+    const { onError } = options;
     function emitError(tokenzer, code, start, offset, ...args) {
         const end = tokenzer.currentPosition();
         end.offset += offset;
@@ -1059,15 +998,6 @@ function createParser(options = {}) {
             onError(err);
         }
     }
-    function emitWarn(tokenzer, code, start, offset, ...args) {
-        const end = tokenzer.currentPosition();
-        end.offset += offset;
-        end.column += offset;
-        if (onWarn) {
-            const loc = location ? createLocation(start, end) : null;
-            onWarn(createCompileWarn(code, loc, args));
-        }
-    }
     function startNode(type, offset, loc) {
         const node = { type };
         if (location) {
@@ -1104,14 +1034,11 @@ function createParser(options = {}) {
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
         return node;
     }
-    function parseNamed(tokenizer, key, modulo) {
+    function parseNamed(tokenizer, key) {
         const context = tokenizer.context();
         const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
         const node = startNode(4 /* NodeTypes.Named */, offset, loc);
         node.key = key;
-        if (modulo === true) {
-            node.modulo = true;
-        }
         tokenizer.nextToken(); // skip brach right
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
         return node;
@@ -1130,7 +1057,7 @@ function createParser(options = {}) {
         const context = tokenizer.context();
         const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
         const node = startNode(8 /* NodeTypes.LinkedModifier */, offset, loc);
-        if (token.type !== 12 /* TokenTypes.LinkedModifier */) {
+        if (token.type !== 11 /* TokenTypes.LinkedModifier */) {
             // empty modifier
             emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
             node.value = '';
@@ -1161,13 +1088,13 @@ function createParser(options = {}) {
         const context = tokenizer.context();
         const linkedNode = startNode(6 /* NodeTypes.Linked */, context.offset, context.startLoc);
         let token = tokenizer.nextToken();
-        if (token.type === 9 /* TokenTypes.LinkedDot */) {
+        if (token.type === 8 /* TokenTypes.LinkedDot */) {
             const parsed = parseLinkedModifier(tokenizer);
             linkedNode.modifier = parsed.node;
             token = parsed.nextConsumeToken || tokenizer.nextToken();
         }
         // asset check token
-        if (token.type !== 10 /* TokenTypes.LinkedDelimiter */) {
+        if (token.type !== 9 /* TokenTypes.LinkedDelimiter */) {
             emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
         }
         token = tokenizer.nextToken();
@@ -1176,25 +1103,25 @@ function createParser(options = {}) {
             token = tokenizer.nextToken();
         }
         switch (token.type) {
-            case 11 /* TokenTypes.LinkedKey */:
+            case 10 /* TokenTypes.LinkedKey */:
                 if (token.value == null) {
                     emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                 }
                 linkedNode.key = parseLinkedKey(tokenizer, token.value || '');
                 break;
-            case 5 /* TokenTypes.Named */:
+            case 4 /* TokenTypes.Named */:
                 if (token.value == null) {
                     emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                 }
                 linkedNode.key = parseNamed(tokenizer, token.value || '');
                 break;
-            case 6 /* TokenTypes.List */:
+            case 5 /* TokenTypes.List */:
                 if (token.value == null) {
                     emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                 }
                 linkedNode.key = parseList(tokenizer, token.value || '');
                 break;
-            case 7 /* TokenTypes.Literal */:
+            case 6 /* TokenTypes.Literal */:
                 if (token.value == null) {
                     emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                 }
@@ -1231,7 +1158,6 @@ function createParser(options = {}) {
         const node = startNode(2 /* NodeTypes.Message */, startOffset, startLoc);
         node.items = [];
         let nextToken = null;
-        let modulo = null;
         do {
             const token = nextToken || tokenizer.nextToken();
             nextToken = null;
@@ -1242,39 +1168,32 @@ function createParser(options = {}) {
                     }
                     node.items.push(parseText(tokenizer, token.value || ''));
                     break;
-                case 6 /* TokenTypes.List */:
+                case 5 /* TokenTypes.List */:
                     if (token.value == null) {
                         emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                     }
                     node.items.push(parseList(tokenizer, token.value || ''));
                     break;
-                case 4 /* TokenTypes.Modulo */:
-                    modulo = true;
-                    break;
-                case 5 /* TokenTypes.Named */:
+                case 4 /* TokenTypes.Named */:
                     if (token.value == null) {
                         emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                     }
-                    node.items.push(parseNamed(tokenizer, token.value || '', !!modulo));
-                    if (modulo) {
-                        emitWarn(tokenizer, CompileWarnCodes.USE_MODULO_SYNTAX, context.lastStartLoc, 0, getTokenCaption(token));
-                        modulo = null;
-                    }
+                    node.items.push(parseNamed(tokenizer, token.value || ''));
                     break;
-                case 7 /* TokenTypes.Literal */:
+                case 6 /* TokenTypes.Literal */:
                     if (token.value == null) {
                         emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                     }
                     node.items.push(parseLiteral(tokenizer, token.value || ''));
                     break;
-                case 8 /* TokenTypes.LinkedAlias */: {
+                case 7 /* TokenTypes.LinkedAlias */: {
                     const parsed = parseLinked(tokenizer);
                     node.items.push(parsed.node);
                     nextToken = parsed.nextConsumeToken || null;
                     break;
                 }
             }
-        } while (context.currentType !== 14 /* TokenTypes.EOF */ &&
+        } while (context.currentType !== 13 /* TokenTypes.EOF */ &&
             context.currentType !== 1 /* TokenTypes.Pipe */);
         // adjust message node loc
         const endOffset = context.currentType === 1 /* TokenTypes.Pipe */
@@ -1298,7 +1217,7 @@ function createParser(options = {}) {
                 hasEmptyMessage = msg.items.length === 0;
             }
             node.cases.push(msg);
-        } while (context.currentType !== 14 /* TokenTypes.EOF */);
+        } while (context.currentType !== 13 /* TokenTypes.EOF */);
         if (hasEmptyMessage) {
             emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
         }
@@ -1309,7 +1228,7 @@ function createParser(options = {}) {
         const context = tokenizer.context();
         const { offset, startLoc } = context;
         const msgNode = parseMessage(tokenizer);
-        if (context.currentType === 14 /* TokenTypes.EOF */) {
+        if (context.currentType === 13 /* TokenTypes.EOF */) {
             return msgNode;
         }
         else {
@@ -1328,7 +1247,7 @@ function createParser(options = {}) {
             node.cacheKey = options.onCacheKey(source);
         }
         // assert whether achieved to EOF
-        if (context.currentType !== 14 /* TokenTypes.EOF */) {
+        if (context.currentType !== 13 /* TokenTypes.EOF */) {
             emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
         }
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
@@ -1337,7 +1256,7 @@ function createParser(options = {}) {
     return { parse };
 }
 function getTokenCaption(token) {
-    if (token.type === 14 /* TokenTypes.EOF */) {
+    if (token.type === 13 /* TokenTypes.EOF */) {
         return 'EOF';
     }
     const name = (token.value || '').replace(/\r?\n/gu, '\\n');
@@ -1675,8 +1594,7 @@ function generateNode(generator, node) {
     }
 }
 // generate code from AST
-const generate = (ast, options = {} // eslint-disable-line
-) => {
+const generate = (ast, options = {}) => {
     const mode = isString(options.mode) ? options.mode : 'normal';
     const filename = isString(options.filename)
         ? options.filename
@@ -2160,17 +2078,17 @@ function createDevToolsHook(hook) {
     return (payloads) => devtools && devtools.emit(hook, payloads);
 }
 
-const code$1 = CompileWarnCodes.__EXTEND_POINT__;
+const code$1 = 1;
 const inc$1 = incrementer(code$1);
 const CoreWarnCodes = {
-    NOT_FOUND_KEY: code$1, // 2
-    FALLBACK_TO_TRANSLATE: inc$1(), // 3
-    CANNOT_FORMAT_NUMBER: inc$1(), // 4
-    FALLBACK_TO_NUMBER_FORMAT: inc$1(), // 5
-    CANNOT_FORMAT_DATE: inc$1(), // 6
-    FALLBACK_TO_DATE_FORMAT: inc$1(), // 7
-    EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER: inc$1(), // 8
-    __EXTEND_POINT__: inc$1() // 9
+    NOT_FOUND_KEY: code$1, // 1
+    FALLBACK_TO_TRANSLATE: inc$1(), // 2
+    CANNOT_FORMAT_NUMBER: inc$1(), // 3
+    FALLBACK_TO_NUMBER_FORMAT: inc$1(), // 4
+    CANNOT_FORMAT_DATE: inc$1(), // 5
+    FALLBACK_TO_DATE_FORMAT: inc$1(), // 6
+    EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER: inc$1(), // 7
+    __EXTEND_POINT__: inc$1() // 8
 };
 /** @internal */
 const warnMessages = {
@@ -2262,8 +2180,7 @@ function resolveLocale(locale) {
  *
  * @VueI18nGeneral
  */
-function fallbackWithSimple(ctx, fallback, start // eslint-disable-line @typescript-eslint/no-unused-vars
-) {
+function fallbackWithSimple(ctx, fallback, start) {
     // prettier-ignore
     return [...new Set([
             start,
@@ -2367,7 +2284,7 @@ function appendItemToChain(chain, target, blocks) {
  * Intlify core-base version
  * @internal
  */
-const VERSION = '9.13.1';
+const VERSION = '10.0.0-alpha.2';
 const NOT_REOSLVED = -1;
 const DEFAULT_LOCALE = 'en-US';
 const MISSING_RESOLVE_VALUE = '';
@@ -2691,14 +2608,6 @@ function checkHtmlMessage(source, warnHtmlMessage) {
 }
 const defaultOnCacheKey = (message) => message;
 let compileCache = Object.create(null);
-function onCompileWarn(_warn) {
-    if (_warn.code === CompileWarnCodes.USE_MODULO_SYNTAX) {
-        warn(`The use of named interpolation with modulo syntax is deprecated. ` +
-            `It will be removed in v10.\n` +
-            `reference: https://vue-i18n.intlify.dev/guide/essentials/syntax#rails-i18n-format \n` +
-            `(message compiler warning message: ${_warn.message})`);
-    }
-}
 function clearCompileCache() {
     compileCache = Object.create(null);
 }
@@ -2721,10 +2630,6 @@ const compileToFunction = (message, context) => {
     if (!isString(message)) {
         throw createCoreError(CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE);
     }
-    // set onWarn
-    {
-        context.onWarn = onCompileWarn;
-    }
     {
         // check HTML message
         const warnHtmlMessage = isBoolean(context.warnHtmlMessage)
@@ -2749,10 +2654,6 @@ const compileToFunction = (message, context) => {
     }
 };
 function compile(message, context) {
-    // set onWarn
-    {
-        context.onWarn = onCompileWarn;
-    }
     if (isString(message)) {
         // check HTML message
         const warnHtmlMessage = isBoolean(context.warnHtmlMessage)