@intlify/core-base 11.4.7 → 11.4.8

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

@@ -1,25 +1,8 @@
 /*!
-  * core-base v11.4.7
+  * core-base v11.4.8
   * (c) 2026 kazuya kawaguchi
   * Released under the MIT License.
   */
-function warn(msg, err) {
-    if (typeof console !== 'undefined') {
-        console.warn(`[intlify] ` + msg);
-        /* istanbul ignore if */
-        if (err) {
-            console.warn(err.stack);
-        }
-    }
-}
-const hasWarned = {};
-function warnOnce(msg) {
-    if (!hasWarned[msg]) {
-        hasWarned[msg] = true;
-        warn(msg);
-    }
-}
-
 /**
  * Original Utilities
  * written by kazuya kawaguchi
@@ -70,6 +53,93 @@ const isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length ===
 const assign = Object.assign;
 const _create = Object.create;
 const create = (obj = null) => _create(obj);
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/* eslint-enable */
+/**
+ * Useful Utilities By Evan you
+ * Modified by kazuya kawaguchi
+ * MIT License
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+ */
+const isArray = Array.isArray;
+const isFunction = (val) => typeof val === 'function';
+const isString = (val) => typeof val === 'string';
+const isBoolean = (val) => typeof val === 'boolean';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isObject = (val) => val !== null && typeof val === 'object';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isPromise = (val) => {
+    return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const isPlainObject = (val) => toTypeString(val) === '[object Object]';
+// for converting list and named values to displayed strings.
+const toDisplayString = (val) => {
+    return val == null
+        ? ''
+        : isArray(val) || (isPlainObject(val) && val.toString === objectToString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+};
+function join(items, separator = '') {
+    return items.reduce((str, item, index) => (index === 0 ? str + item : str + separator + item), '');
+}
+const RANGE = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`   |  ` + '^'.repeat(length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+
+function warn(msg, err) {
+    if (typeof console !== 'undefined') {
+        console.warn(`[intlify] ` + msg);
+        /* istanbul ignore if */
+        if (err) {
+            console.warn(err.stack);
+        }
+    }
+}
+const hasWarned = {};
+function warnOnce(msg) {
+    if (!hasWarned[msg]) {
+        hasWarned[msg] = true;
+        warn(msg);
+    }
+}
+
 function escapeHtml(rawText) {
     return rawText
         .replace(/&/g, '&amp;') // escape `&` first to avoid double escaping
@@ -82,16 +152,37 @@ function escapeHtml(rawText) {
 }
 function escapeAttributeValue(value) {
     return value
-        .replace(/&(?![a-zA-Z0-9#]{2,6};)/g, '&amp;') // escape unescaped `&`
+        .replace(/&(?![a-z0-9#]{2,6};)/gi, '&amp;') // escape unescaped `&`
         .replace(/"/g, '&quot;')
         .replace(/'/g, '&apos;')
         .replace(/</g, '&lt;')
         .replace(/>/g, '&gt;');
 }
-const javascriptSchemePattern = /^\s*javascript\s*(?::|&#0*58;?|&#x0*3a;?|&colon;?)/i;
+const javascriptSchemePattern = /^javascript:/i;
 const urlAttributePattern = /^(?:href|src|action|formaction)$/i;
+const numericCharacterReferencePattern = /&#(?:x([0-9a-f]+)|(\d+));?/gi;
+const namedWhitespaceCharacterReferencePattern = /&(?:Tab|NewLine);/g;
+const colonCharacterReferencePattern = /&colon;?/gi;
+// eslint-disable-next-line no-control-regex -- URL scheme normalization requires the full control range
+const controlOrWhitespacePattern = /[\u0000-\u0020\u007f-\u009f]/g;
+const eventHandlerPattern = /(?:^|[\s"'<>/])on\w+\s*=\s*["']?[^"'>]+["']?/i;
+const eventHandlerAttributePattern = /(^|[\s"'<>/])on(\w+\s*=)/gi;
+const unquotedUrlAttributePattern = /(^|[\s"'<>/])((?:href|src|action|formaction)\s*=\s*)([^\s"'=<>`]+)/gi;
+function decodeNumericCharacterReference(match, hex, decimal) {
+    const digits = hex || decimal;
+    if (!digits) {
+        return match;
+    }
+    const codePoint = Number.parseInt(digits, hex ? 16 : 10);
+    return codePoint <= 0x7f ? String.fromCharCode(codePoint) : match;
+}
 function hasJavascriptScheme(value) {
-    return javascriptSchemePattern.test(value);
+    const normalized = value
+        .replace(numericCharacterReferencePattern, decodeNumericCharacterReference)
+        .replace(namedWhitespaceCharacterReferencePattern, '')
+        .replace(colonCharacterReferencePattern, ':')
+        .replace(controlOrWhitespacePattern, '');
+    return javascriptSchemePattern.test(normalized);
 }
 function sanitizeStyleValue(value) {
     const urlPattern = /url\s*\(/gi;
@@ -155,88 +246,18 @@ function sanitizeTranslatedHtml(html) {
     // Process attributes with single quotes
     html = html.replace(/([\w:-]+)\s*=\s*'([^']*)'/g, (_, attrName, attrValue) => `${attrName}='${sanitizeAttributeValue(attrName, attrValue)}'`);
     // Detect and neutralize event handler attributes
-    const eventHandlerPattern = /\s*on\w+\s*=\s*["']?[^"'>]+["']?/gi;
     if (eventHandlerPattern.test(html)) {
         {
             warn('Potentially dangerous event handlers detected in translation. ' +
                 'Consider removing onclick, onerror, etc. from your translation messages.');
         }
         // Neutralize event handler attributes by escaping 'on'
-        html = html.replace(/(\s+)(on)(\w+\s*=)/gi, '$1&#111;n$3');
+        html = html.replace(eventHandlerAttributePattern, '$1&#111;n$2');
     }
     // Disable javascript: URLs in unquoted attributes
-    html = html.replace(/(\s+(?:href|src|action|formaction)\s*=\s*)([^\s"'=<>`]+)/gi, (match, prefix, attrValue) => hasJavascriptScheme(attrValue) ? `${prefix}about:blank` : match);
+    html = html.replace(unquotedUrlAttributePattern, (match, boundary, prefix, attrValue) => hasJavascriptScheme(attrValue) ? `${boundary}${prefix}about:blank` : match);
     return html;
 }
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/* eslint-enable */
-/**
- * Useful Utilities By Evan you
- * Modified by kazuya kawaguchi
- * MIT License
- * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
- * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
- */
-const isArray = Array.isArray;
-const isFunction = (val) => typeof val === 'function';
-const isString = (val) => typeof val === 'string';
-const isBoolean = (val) => typeof val === 'boolean';
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const isObject = (val) => val !== null && typeof val === 'object';
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const isPromise = (val) => {
-    return isObject(val) && isFunction(val.then) && isFunction(val.catch);
-};
-const objectToString = Object.prototype.toString;
-const toTypeString = (value) => objectToString.call(value);
-const isPlainObject = (val) => toTypeString(val) === '[object Object]';
-// for converting list and named values to displayed strings.
-const toDisplayString = (val) => {
-    return val == null
-        ? ''
-        : isArray(val) || (isPlainObject(val) && val.toString === objectToString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-};
-function join(items, separator = '') {
-    return items.reduce((str, item, index) => (index === 0 ? str + item : str + separator + item), '');
-}
-const RANGE = 2;
-function generateCodeFrame(source, start = 0, end = source.length) {
-    const lines = source.split(/\r?\n/);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
-        count += lines[i].length + 1;
-        if (count >= start) {
-            for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {
-                if (j < 0 || j >= lines.length)
-                    continue;
-                const line = j + 1;
-                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);
-                const lineLength = lines[j].length;
-                if (j === i) {
-                    // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
-                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
-                }
-                else if (j > i) {
-                    if (end > count) {
-                        const length = Math.max(Math.min(end - count, lineLength), 1);
-                        res.push(`   |  ` + '^'.repeat(length));
-                    }
-                    count += lineLength + 1;
-                }
-            }
-            break;
-        }
-    }
-    return res.join('\n');
-}
 
 function createPosition(line, column, offset) {
     return { line, column, offset };
@@ -2511,7 +2532,7 @@ function getWarnMessage(code, ...args) {
  * Intlify core-base version
  * @internal
  */
-const VERSION = '11.4.7';
+const VERSION = '11.4.8';
 const NOT_REOSLVED = -1;
 const DEFAULT_LOCALE = 'en-US';
 const MISSING_RESOLVE_VALUE = '';
@@ -2761,6 +2782,88 @@ function isImplicitFallback(targetLocale, locales) {
 }
 /* eslint-enable @typescript-eslint/no-explicit-any */
 
+function resolveFormatLocale(context, key, locale, formats, missingWarn, fallbackWarn, type) {
+    const { fallbackLocale, localeFallbacker, onWarn } = context;
+    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+    fallbackLocale, locale);
+    let from = locale;
+    for (let i = 0; i < locales.length; i++) {
+        const targetLocale = locales[i];
+        if (locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(type === 'datetime format'
+                ? CoreWarnCodes.FALLBACK_TO_DATE_FORMAT
+                : CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT, {
+                key,
+                target: targetLocale
+            }));
+        }
+        if (locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit('fallback', {
+                    type,
+                    key,
+                    from,
+                    to: targetLocale,
+                    groupId: `${type}:${key}`
+                });
+            }
+        }
+        const format = (formats[targetLocale] || {})[key];
+        if (isPlainObject(format) && isString(targetLocale)) {
+            return targetLocale;
+        }
+        handleMissing(context, key, targetLocale, missingWarn, type);
+        from = targetLocale;
+    }
+    return null;
+}
+function getFormatterCacheKey(locale, key, overrides) {
+    let id = `${locale}__${key}`;
+    if (isPlainObject(overrides) && !isEmptyObject(overrides)) {
+        id = `${id}__${JSON.stringify(overrides)}`;
+    }
+    return id;
+}
+function clearFormatCache(formatters, locale, format) {
+    for (const key in format) {
+        const prefix = `${locale}__${key}`;
+        for (const id of formatters.keys()) {
+            if (id === prefix || id.startsWith(`${prefix}__`)) {
+                formatters.delete(id);
+            }
+        }
+    }
+}
+function parseFormatArgs(args, options, initialOverrides, optionsKeys) {
+    const [, arg2, arg3, arg4] = args;
+    let overrides = initialOverrides;
+    if (isString(arg2)) {
+        options.key = arg2;
+    }
+    else if (isPlainObject(arg2)) {
+        Object.keys(arg2).forEach(key => {
+            if (optionsKeys.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 overrides;
+}
+
 const intlDefined = typeof Intl !== 'undefined';
 const Availabilities = {
     dateTimeFormat: intlDefined && typeof Intl.DateTimeFormat !== 'undefined',
@@ -2769,7 +2872,7 @@ const Availabilities = {
 
 // implementation of `datetime` function
 function datetime(context, ...args) {
-    const { datetimeFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { datetimeFormats, unresolving, onWarn } = context;
     const { __datetimeFormatters } = context;
     if (!Availabilities.dateTimeFormat) {
         onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_DATE));
@@ -2792,57 +2895,16 @@ function datetime(context, ...args) {
         : 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 === '') {
         const formatter = new Intl.DateTimeFormat(locale.replace(/!/g, ''), overrides);
         return !part ? formatter.format(value) : formatter.formatToParts(value);
     }
-    // resolve format
-    let datetimeFormat = {};
-    let targetLocale;
-    let format = null;
-    let from = locale;
-    let to = null;
-    const type = 'datetime format';
-    for (let i = 0; i < locales.length; i++) {
-        targetLocale = to = locales[i];
-        if (locale !== targetLocale &&
-            isTranslateFallbackWarn(fallbackWarn, key)) {
-            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_DATE_FORMAT, {
-                key,
-                target: targetLocale
-            }));
-        }
-        // 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;
-    }
-    // checking format and target locale
-    if (!isPlainObject(format) || !isString(targetLocale)) {
+    const targetLocale = resolveFormatLocale(context, key, locale, datetimeFormats, missingWarn, fallbackWarn, 'datetime format');
+    if (!isString(targetLocale)) {
         return unresolving ? NOT_REOSLVED : key;
     }
-    let id = `${targetLocale}__${key}`;
-    if (!isEmptyObject(overrides)) {
-        id = `${id}__${JSON.stringify(overrides)}`;
-    }
+    const format = datetimeFormats[targetLocale][key];
+    const id = getFormatterCacheKey(targetLocale, key, overrides);
     let formatter = __datetimeFormatters.get(id);
     if (!formatter) {
         formatter = new Intl.DateTimeFormat(targetLocale, assign({}, format, overrides));
@@ -2875,9 +2937,9 @@ const DATETIME_FORMAT_OPTIONS_KEYS = [
 ];
 /** @internal */
 function parseDateTimeArgs(...args) {
-    const [arg1, arg2, arg3, arg4] = args;
+    const [arg1] = args;
     const options = create();
-    let overrides = create();
+    const initialOverrides = create();
     let value;
     if (isString(arg1)) {
         // Only allow ISO strings - other date formats are often supported,
@@ -2914,45 +2976,18 @@ function parseDateTimeArgs(...args) {
     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 (isPlainObject(arg4)) {
-        overrides = arg4;
-    }
+    const overrides = parseFormatArgs(args, options, initialOverrides, DATETIME_FORMAT_OPTIONS_KEYS);
     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);
-    }
+    clearFormatCache(context.__datetimeFormatters, locale, format);
 }
 
 // implementation of `number` function
 function number(context, ...args) {
-    const { numberFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { numberFormats, unresolving, onWarn } = context;
     const { __numberFormatters } = context;
     if (!Availabilities.numberFormat) {
         onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_NUMBER));
@@ -2975,57 +3010,16 @@ function number(context, ...args) {
         : 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 === '') {
         const formatter = new Intl.NumberFormat(locale.replace(/!/g, ''), overrides);
         return !part ? formatter.format(value) : formatter.formatToParts(value);
     }
-    // resolve format
-    let numberFormat = {};
-    let targetLocale;
-    let format = null;
-    let from = locale;
-    let to = null;
-    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_NUMBER_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}`
-                });
-            }
-        }
-        numberFormat =
-            numberFormats[targetLocale] || {};
-        format = numberFormat[key];
-        if (isPlainObject(format))
-            break;
-        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
-        from = to;
-    }
-    // checking format and target locale
-    if (!isPlainObject(format) || !isString(targetLocale)) {
+    const targetLocale = resolveFormatLocale(context, key, locale, numberFormats, missingWarn, fallbackWarn, 'number format');
+    if (!isString(targetLocale)) {
         return unresolving ? NOT_REOSLVED : key;
     }
-    let id = `${targetLocale}__${key}`;
-    if (!isEmptyObject(overrides)) {
-        id = `${id}__${JSON.stringify(overrides)}`;
-    }
+    const format = numberFormats[targetLocale][key];
+    const id = getFormatterCacheKey(targetLocale, key, overrides);
     let formatter = __numberFormatters.get(id);
     if (!formatter) {
         formatter = new Intl.NumberFormat(targetLocale, assign({}, format, overrides));
@@ -3058,47 +3052,20 @@ const NUMBER_FORMAT_OPTIONS_KEYS = [
 ];
 /** @internal */
 function parseNumberArgs(...args) {
-    const [arg1, arg2, arg3, arg4] = args;
+    const [arg1] = args;
     const options = create();
-    let overrides = create();
+    const initialOverrides = create();
     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;
-    }
+    const overrides = parseFormatArgs(args, options, initialOverrides, NUMBER_FORMAT_OPTIONS_KEYS);
     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);
-    }
+    clearFormatCache(context.__numberFormatters, locale, format);
 }
 
 const DEFAULT_MODIFIER = (str) => str;