@nanahoshi/mona-ui 0.23.1 → 0.23.3

package/fesm2022/nanahoshi-mona-ui-i18n.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, signal, computed, Injectable, ElementRef, DestroyRef, makeEnvironmentProviders } from '@angular/core';
+import { InjectionToken, inject, signal, computed, Injectable, isDevMode, ElementRef, DestroyRef, makeEnvironmentProviders } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
 import { DateTime } from 'luxon';
 
@@ -13,6 +13,45 @@ const MONA_I18N_CONFIG = new InjectionToken("MONA_I18N_CONFIG", {
     factory: () => ({})
 });
 
+/**
+ * Locale id used whenever a supplied id cannot be turned into a valid BCP 47 tag.
+ * Matches the id of `MONA_DEFAULT_LOCALE`.
+ */
+const MONA_FALLBACK_LOCALE_ID = "en-US";
+const canonicalLocaleCache = new Map();
+/**
+ * Converts a locale id to a canonical BCP 47 tag, or returns `null` when it is not a valid tag.
+ *
+ * POSIX/Java style ids are accepted: `en_US` becomes `en-US`, and an encoding or modifier suffix
+ * (`de_DE.UTF-8`, `de_DE@euro`) is dropped.
+ */
+function tryCanonicalizeLocaleId(localeId) {
+    const raw = (localeId ?? "").trim();
+    if (!raw) {
+        return null;
+    }
+    if (canonicalLocaleCache.has(raw)) {
+        return canonicalLocaleCache.get(raw) ?? null;
+    }
+    let canonical = null;
+    try {
+        const tag = raw.replace(/[.@].*$/, "").replace(/_/g, "-");
+        canonical = Intl.getCanonicalLocales(tag)[0] ?? null;
+    }
+    catch {
+        canonical = null;
+    }
+    canonicalLocaleCache.set(raw, canonical);
+    return canonical;
+}
+/**
+ * Converts a locale id to a canonical BCP 47 tag. Ids that are empty or not valid tags resolve to
+ * {@link MONA_FALLBACK_LOCALE_ID}, so every formatter receives the same, valid locale.
+ */
+function canonicalizeLocaleId(localeId) {
+    return tryCanonicalizeLocaleId(localeId) ?? MONA_FALLBACK_LOCALE_ID;
+}
+
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -43,38 +82,80 @@ function mergeMessages(fallback, localeMessages, overrideMessages) {
 }
 
 class MonaI18nService {
+    #config;
+    #locale;
+    #localeOverrides;
+    #overrides;
     constructor() {
         this.#config = inject(MONA_I18N_CONFIG);
         this.#locale = signal(this.#config.locale ?? MONA_DEFAULT_LOCALE, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "#locale" }] : /* istanbul ignore next */ []));
+        this.#localeOverrides = signal(createLocaleOverrides(this.#config.localeMessages), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#localeOverrides" }] : /* istanbul ignore next */ []));
         this.#overrides = signal(this.#config.messages ?? {}, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "#overrides" }] : /* istanbul ignore next */ []));
         this.direction = computed(() => this.#locale().direction, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "direction" }] : /* istanbul ignore next */ []));
         this.locale = this.#locale.asReadonly();
-        this.localeId = computed(() => this.#locale().id, /* @ts-ignore */
+        /**
+         * Canonical BCP 47 id of the active locale. POSIX ids such as `en_US` are converted to `en-US`,
+         * and invalid ids resolve to `MONA_FALLBACK_LOCALE_ID` so formatters always receive a valid tag.
+         */
+        this.localeId = computed(() => canonicalizeLocaleId(this.#locale().id), /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "localeId" }] : /* istanbul ignore next */ []));
+        warnOnInvalidLocaleId(this.#locale().id);
     }
-    #config;
-    #locale;
-    #overrides;
-    clearMessages() {
-        this.#overrides.set({});
+    /**
+     * Removes overrides. With `options.locale`, only that locale's overrides are removed; without it, every
+     * override is removed, global and per locale.
+     */
+    clearMessages(options) {
+        if (options?.locale == null) {
+            this.#overrides.set({});
+            this.#localeOverrides.set(new Map());
+            return;
+        }
+        const localeId = canonicalizeLocaleId(options.locale);
+        this.#localeOverrides.update(current => {
+            const next = new Map(current);
+            next.delete(localeId);
+            return next;
+        });
     }
     componentMessages(namespace, fallback) {
         return computed(() => {
             const localeMessages = this.#locale().messages[namespace];
             const overrideMessages = this.#overrides()[namespace];
-            return mergeMessages(fallback, localeMessages, overrideMessages);
+            const localeOverrideMessages = this.#localeOverrides().get(this.localeId())?.[namespace];
+            const merged = mergeMessages(fallback, localeMessages, overrideMessages);
+            return mergeTwo(merged, localeOverrideMessages);
         });
     }
-    patchMessages(messages) {
-        this.#overrides.update(current => mergeTwo(current, messages));
+    /**
+     * Merges overrides into the existing ones. With `options.locale`, they apply only while that locale is
+     * active, so overrides patched for German do not show after switching to English.
+     */
+    patchMessages(messages, options) {
+        if (options?.locale == null) {
+            this.#overrides.update(current => mergeTwo(current, messages));
+            return;
+        }
+        const localeId = canonicalizeLocaleId(options.locale);
+        this.#localeOverrides.update(current => new Map(current).set(localeId, mergeTwo(current.get(localeId) ?? {}, messages)));
     }
-    setMessages(messages) {
-        this.#overrides.set(messages);
+    /**
+     * Replaces the existing overrides. With `options.locale`, only that locale's overrides are replaced.
+     */
+    setMessages(messages, options) {
+        if (options?.locale == null) {
+            this.#overrides.set(messages);
+            return;
+        }
+        const localeId = canonicalizeLocaleId(options.locale);
+        this.#localeOverrides.update(current => new Map(current).set(localeId, messages));
     }
     use(locale) {
+        warnOnInvalidLocaleId(locale.id);
         this.#locale.set(locale);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: MonaI18nService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
@@ -85,7 +166,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.6", ngImpor
             args: [{
                     providedIn: "root"
                 }]
-        }] });
+        }], ctorParameters: () => [] });
+function createLocaleOverrides(localeMessages) {
+    const overrides = new Map();
+    for (const [localeId, messages] of Object.entries(localeMessages ?? {})) {
+        const canonicalId = canonicalizeLocaleId(localeId);
+        overrides.set(canonicalId, mergeTwo(overrides.get(canonicalId) ?? {}, messages));
+    }
+    return overrides;
+}
+function warnOnInvalidLocaleId(localeId) {
+    if (isDevMode() && tryCanonicalizeLocaleId(localeId) == null) {
+        console.warn(`[mona-ui] "${localeId}" is not a valid BCP 47 locale id. Falling back to "${MONA_FALLBACK_LOCALE_ID}".`);
+    }
+}
 
 /**
  * Reads semantic document direction for a connected browser element using `:dir(rtl)` and `:dir(ltr)`.
@@ -366,6 +460,15 @@ function provideMonaI18n(config = {}) {
     ]);
 }
 
+/** Full-width forms of printable ASCII ("！" to "～"), offset from ASCII by U+FEE0. */
+const FULLWIDTH_ASCII_START = 0xff01;
+const FULLWIDTH_ASCII_END = 0xff5e;
+const FULLWIDTH_ASCII_OFFSET = 0xfee0;
+const DECIMAL_DIGIT_REGEX = /^\p{Nd}$/u;
+/** Apostrophe, right single quotation mark and modifier letter apostrophe. */
+const APOSTROPHE_REGEX = /^['\u2019\u02BC]$/;
+const APOSTROPHE_REGEX_GLOBAL = /['\u2019\u02BC]/g;
+const asciiDigitCache = new Map();
 const numberSymbolsCache = new Map();
 const numberFormatterCache = new Map();
 const numberGroupingCache = new Map();
@@ -376,7 +479,8 @@ function serializeOptions(options) {
     const keys = Object.keys(options).sort();
     return keys.map(k => `${k}:${String(options[k])}`).join(";");
 }
-function getNumberGroupingPattern(localeId) {
+function getNumberGroupingPattern(locale) {
+    const localeId = canonicalizeLocaleId(locale);
     let pattern = numberGroupingCache.get(localeId);
     if (!pattern) {
         try {
@@ -439,7 +543,8 @@ function getNumberGroupingPattern(localeId) {
     }
     return pattern;
 }
-function getNumberSymbols(localeId) {
+function getNumberSymbols(locale) {
+    const localeId = canonicalizeLocaleId(locale);
     let symbols = numberSymbolsCache.get(localeId);
     if (!symbols) {
         const digitMap = new Map();
@@ -482,7 +587,7 @@ function getNumberSymbols(localeId) {
     return symbols;
 }
 function getNumberFormatter(locale, options) {
-    const cleanLocale = (locale ?? "").trim() || "en-US";
+    const cleanLocale = canonicalizeLocaleId(locale);
     const key = `${cleanLocale}:${serializeOptions(options)}`;
     let formatter = numberFormatterCache.get(key);
     if (!formatter) {
@@ -499,6 +604,30 @@ function getNumberFormatter(locale, options) {
 function formatNumber(value, locale, options) {
     return getNumberFormatter(locale, options).format(value);
 }
+/**
+ * ASCII value of a Unicode decimal digit (\p{Nd}), or null for any other character. Unicode encodes every
+ * decimal digit set as a contiguous 0-9 run, so the value is the distance from the start of the run.
+ */
+function toAsciiDigit(char) {
+    let digit = asciiDigitCache.get(char);
+    if (digit === undefined) {
+        digit = null;
+        if (DECIMAL_DIGIT_REGEX.test(char)) {
+            const code = char.codePointAt(0);
+            let runStart = code;
+            while (DECIMAL_DIGIT_REGEX.test(String.fromCodePoint(runStart - 1))) {
+                runStart--;
+            }
+            digit = String((code - runStart) % 10);
+        }
+        asciiDigitCache.set(char, digit);
+    }
+    return digit;
+}
+/**
+ * Converts digits of any script to ASCII digits. Full-width forms typed by CJK input methods
+ * ("１２．５", "－３", "１，０００") are folded to ASCII first.
+ */
 function normalizeLocalizedDigits(text, localeId) {
     if (!text) {
         return text;
@@ -506,27 +635,11 @@ function normalizeLocalizedDigits(text, localeId) {
     const symbols = localeId ? getNumberSymbols(localeId) : null;
     let result = "";
     for (const char of text) {
-        if (symbols?.digits.has(char)) {
-            result += symbols.digits.get(char);
-        }
-        else {
-            const code = char.charCodeAt(0);
-            if (code >= 0x0660 && code <= 0x0669) {
-                result += String(code - 0x0660);
-            }
-            else if (code >= 0x06f0 && code <= 0x06f9) {
-                result += String(code - 0x06f0);
-            }
-            else if (code >= 0x09e6 && code <= 0x09ef) {
-                result += String(code - 0x09e6);
-            }
-            else if (code >= 0x0966 && code <= 0x096f) {
-                result += String(code - 0x0966);
-            }
-            else {
-                result += char;
-            }
-        }
+        const code = char.codePointAt(0);
+        const folded = code >= FULLWIDTH_ASCII_START && code <= FULLWIDTH_ASCII_END
+            ? String.fromCharCode(code - FULLWIDTH_ASCII_OFFSET)
+            : char;
+        result += symbols?.digits.get(folded) ?? toAsciiDigit(folded) ?? folded;
     }
     return result;
 }
@@ -548,6 +661,21 @@ function normalizeLocalizedInput(text, localeId) {
     cleaned = normalizeLocalizedDigits(cleaned, localeId);
     return cleaned;
 }
+/**
+ * Decimal separators accepted while editing: the locale's own, plus "." and "," so a separator typed on a
+ * keyboard layout that does not match the locale still works. An alternate is dropped when it is the locale's
+ * group separator; otherwise "1,234" typed in en-US (or "1.234" in de-DE) would be read as 1.234.
+ */
+function getEditDecimalSeparators(symbols) {
+    const primary = symbols.decimal || ".";
+    const separators = new Set([primary]);
+    for (const alternate of [".", ","]) {
+        if (alternate !== symbols.group) {
+            separators.add(alternate);
+        }
+    }
+    return separators;
+}
 function parseLocalizedNumber(text, localeId, options) {
     if (text == null) {
         return null;
@@ -581,6 +709,11 @@ function parseLocalizedNumber(text, localeId, options) {
         const groupSep = grouping.groupSeparator;
         const isSpaceGroup = /[ \u00A0\u202F]/.test(groupSep);
         const decimalSep = symbols.decimal;
+        // Engines disagree on the apostrophe a locale groups with (de-CH: Node ICU "'", Chrome "’"),
+        // and keyboards type "'", so every apostrophe variant counts as that locale's group separator.
+        if (APOSTROPHE_REGEX.test(groupSep)) {
+            cleaned = cleaned.replace(APOSTROPHE_REGEX_GLOBAL, groupSep);
+        }
         // Reject non-accepted control or whitespace characters (tabs, newlines, formfeeds)
         if (/[^\S\u0020\u00A0\u202F]/.test(cleaned)) {
             return null;
@@ -656,11 +789,8 @@ function parseLocalizedNumber(text, localeId, options) {
                 if (intGroups.length < 2) {
                     return null;
                 }
-                // Canonical strict check: must meet locale's minimum grouping threshold
-                const totalGroupedDigits = intGroups.join("").length;
-                if (totalGroupedDigits < grouping.minimumGroupedIntegerDigits) {
-                    return null;
-                }
+                // Grouping below the locale's minimum (es-ES formats 1000, not 1.000) is still accepted:
+                // users type and paste it, and it is unambiguous because the group sizes are checked below.
                 // Last (rightmost) group: must match primaryGroupSize digits
                 const lastGroup = intGroups[intGroups.length - 1];
                 if (lastGroup.length !== grouping.primaryGroupSize || !/^\d+$/.test(lastGroup)) {
@@ -699,27 +829,7 @@ function parseLocalizedNumber(text, localeId, options) {
         if (/[\s\u00A0\u202F]/.test(cleaned)) {
             return null;
         }
-        const primaryDec = symbols.decimal || ".";
-        const candidateSeparators = new Set();
-        candidateSeparators.add(primaryDec);
-        if (primaryDec === ".") {
-            candidateSeparators.add(",");
-        }
-        else if (primaryDec === ",") {
-            candidateSeparators.add(".");
-        }
-        else {
-            candidateSeparators.add(".");
-            candidateSeparators.add(",");
-        }
-        if (primaryDec === "\u066B") {
-            candidateSeparators.add(".");
-            candidateSeparators.add(",");
-        }
-        if (primaryDec === "/") {
-            candidateSeparators.add(".");
-            candidateSeparators.add(",");
-        }
+        const candidateSeparators = getEditDecimalSeparators(symbols);
         let foundSep = null;
         let sepIndex = -1;
         for (let i = 0; i < cleaned.length; i++) {
@@ -878,25 +988,7 @@ function validateLocalizedNumberEdit(text, localeId, options) {
     if (normalized === "") {
         return { valid: true, complete: false, value: null };
     }
-    // Identify allowed decimal separators
-    const primaryDec = symbols.decimal || ".";
-    // Candidate separators: primary decimal, plus alternate '.' or ','
-    const candidateSeparators = new Set();
-    candidateSeparators.add(primaryDec);
-    if (primaryDec === ".") {
-        candidateSeparators.add(",");
-    }
-    else if (primaryDec === ",") {
-        candidateSeparators.add(".");
-    }
-    else {
-        candidateSeparators.add(".");
-        candidateSeparators.add(",");
-    }
-    if (primaryDec === "\u066B") {
-        candidateSeparators.add(".");
-        candidateSeparators.add(",");
-    }
+    const candidateSeparators = getEditDecimalSeparators(symbols);
     // Count how many separators from the candidate set appear
     let foundSep = null;
     let sepIndex = -1;
@@ -957,22 +1049,20 @@ function validateLocalizedNumberEdit(text, localeId, options) {
 /**
  * Normalizes a locale string to ensure it uses the Gregorian calendar system
  * and doesn't contain a conflicting -u-ca-* extension.
+ * Empty or malformed ids resolve to `MONA_FALLBACK_LOCALE_ID` (en-US).
  */
 function normalizeGregorianLocale(localeId) {
-    const trimmed = (localeId ?? "").trim();
-    if (!trimmed) {
-        return trimmed;
-    }
+    const canonical = canonicalizeLocaleId(localeId);
     try {
         if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
-            const loc = new Intl.Locale(trimmed, { calendar: "gregory" });
+            const loc = new Intl.Locale(canonical, { calendar: "gregory" });
             return loc.toString();
         }
     }
     catch {
-        // Fallback safely if localeId is malformed
+        // Canonical tags are always accepted; keep the canonical id if Intl.Locale still refuses it
     }
-    return trimmed;
+    return canonical;
 }
 /**
  * Creates a Luxon DateTime from a Date instance, reconfigured to the specified locale
@@ -1023,17 +1113,29 @@ function stripBidiControls(value) {
 function sanitizeDateText(value) {
     return stripBidiControls(value).replace(/[\u00A0\u2009\u202F]/g, " ");
 }
+/**
+ * Luxon throws for formats that mix incompatible fields (e.g. ordinal and month/day tokens). Callers treat
+ * such input as unparsable, so the error becomes an invalid DateTime.
+ */
+function fromFormatSafe(text, format, options) {
+    try {
+        return DateTime.fromFormat(text, format, options);
+    }
+    catch (error) {
+        return DateTime.invalid("unparsable", error instanceof Error ? error.message : String(error));
+    }
+}
 /**
  * Parses a date string using the specified format and locale, forcing Gregorian calendar.
  * Localized digits are normalized first to support locales that use native numbering systems.
  */
 function parseGregorianDate(text, format, localeId) {
     const locale = normalizeGregorianLocale(localeId);
-    let dt = DateTime.fromFormat(text, format, { locale, outputCalendar: "gregory" });
+    let dt = fromFormatSafe(text, format, { locale, outputCalendar: "gregory" });
     if (!dt.isValid) {
         const sanitizedText = sanitizeDateText(text);
         const sanitizedFormat = sanitizeDateText(format);
-        dt = DateTime.fromFormat(sanitizedText, sanitizedFormat, { locale, outputCalendar: "gregory" });
+        dt = fromFormatSafe(sanitizedText, sanitizedFormat, { locale, outputCalendar: "gregory" });
         if (!dt.isValid) {
             let normalizedText = normalizeLocalizedDigits(sanitizedText, locale);
             let latnLocale = locale;
@@ -1045,20 +1147,20 @@ function parseGregorianDate(text, format, localeId) {
             catch {
                 // fallback
             }
-            dt = DateTime.fromFormat(normalizedText, sanitizedFormat, { locale: latnLocale, outputCalendar: "gregory" });
+            dt = fromFormatSafe(normalizedText, sanitizedFormat, { locale: latnLocale, outputCalendar: "gregory" });
             if (!dt.isValid) {
-                dt = DateTime.fromFormat(normalizedText, sanitizedFormat, { locale, outputCalendar: "gregory" });
+                dt = fromFormatSafe(normalizedText, sanitizedFormat, { locale, outputCalendar: "gregory" });
             }
             if (!dt.isValid) {
                 const effectiveLocale = latnLocale !== locale ? latnLocale : locale;
                 if (sanitizedFormat.includes(". ") && !normalizedText.includes(". ")) {
                     const textWithDotSpaces = normalizedText.replace(/\.(?!\s|$)/g, ". ");
-                    dt = DateTime.fromFormat(textWithDotSpaces, sanitizedFormat, {
+                    dt = fromFormatSafe(textWithDotSpaces, sanitizedFormat, {
                         locale: effectiveLocale,
                         outputCalendar: "gregory"
                     });
                     if (!dt.isValid && effectiveLocale !== locale) {
-                        dt = DateTime.fromFormat(textWithDotSpaces, sanitizedFormat, {
+                        dt = fromFormatSafe(textWithDotSpaces, sanitizedFormat, {
                             locale,
                             outputCalendar: "gregory"
                         });
@@ -1071,12 +1173,12 @@ function parseGregorianDate(text, format, localeId) {
                 if (sanitizedFormat.includes("dd. ") &&
                     /(\b\d{4}\.\s*\d{1,2}\.\s*\d{1,2})\.?\s+/.test(normalizedText)) {
                     const withDotBeforeTime = normalizedText.replace(/(\b\d{4}\.\s*\d{1,2}\.\s*\d{1,2})\.?\s+/, (_match, datePart) => `${datePart}. `);
-                    dt = DateTime.fromFormat(withDotBeforeTime, sanitizedFormat, {
+                    dt = fromFormatSafe(withDotBeforeTime, sanitizedFormat, {
                         locale: effectiveLocale,
                         outputCalendar: "gregory"
                     });
                     if (!dt.isValid && effectiveLocale !== locale) {
-                        dt = DateTime.fromFormat(withDotBeforeTime, sanitizedFormat, {
+                        dt = fromFormatSafe(withDotBeforeTime, sanitizedFormat, {
                             locale,
                             outputCalendar: "gregory"
                         });
@@ -1089,12 +1191,12 @@ function parseGregorianDate(text, format, localeId) {
                 const trimmedText = normalizedText.trim();
                 if (trimmedFormat.endsWith(".")) {
                     const textWithDot = trimmedText.endsWith(".") ? trimmedText : trimmedText + ".";
-                    dt = DateTime.fromFormat(textWithDot, trimmedFormat, {
+                    dt = fromFormatSafe(textWithDot, trimmedFormat, {
                         locale: effectiveLocale,
                         outputCalendar: "gregory"
                     });
                     if (!dt.isValid && effectiveLocale !== locale) {
-                        dt = DateTime.fromFormat(textWithDot, trimmedFormat, {
+                        dt = fromFormatSafe(textWithDot, trimmedFormat, {
                             locale,
                             outputCalendar: "gregory"
                         });
@@ -4560,8 +4662,15 @@ const dateFormatCache = new Map();
 const timeFormatCache = new Map();
 const dateTimeFormatCache = new Map();
 const firstDayCache = new Map();
+/**
+ * Turns an Intl literal part into Luxon format text. ASCII letters would otherwise be read as format tokens
+ * (the "h" in fr-CA "21 h 30", the "klo" in fi-FI "15.09.2026 klo 21.30"), so letter runs are quoted and
+ * apostrophes are doubled.
+ */
 function normalizeEditableLiteral(value) {
-    return sanitizeDateText(value);
+    return sanitizeDateText(value)
+        .replace(/'/g, "''")
+        .replace(/[A-Za-z]+/g, run => `'${run}'`);
 }
 /**
  * Derives a localized numeric date format (e.g. "yyyy/MM/dd" or "dd/MM/yyyy") for the given locale.
@@ -4721,7 +4830,7 @@ function getLocaleDateTimeInputFormat(localeId, options) {
  * Intl.Locale.getWeekInfo(), or CLDR fallbacks.
  */
 function getLocaleFirstDayOfWeek(localeId) {
-    const normalizedLocaleId = (localeId ?? "").trim();
+    const normalizedLocaleId = canonicalizeLocaleId(localeId);
     let firstDay = firstDayCache.get(normalizedLocaleId);
     if (!firstDay) {
         firstDay = resolveLocaleFirstDayOfWeek(normalizedLocaleId);
@@ -4870,5 +4979,5 @@ function generatePseudoLocale(catalogs, options) {
  * Generated bundle index. Do not edit.
  */
 
-export { BIDI_CONTROL_REGEX, MONA_DEFAULT_LOCALE, MONA_I18N_CONFIG, MonaDirectionService, MonaI18nService, formatGregorianDateToLocaleString, formatNumber, generatePseudoLocale, getLocaleDateInputFormat, getLocaleDateTimeInputFormat, getLocaleFirstDayOfWeek, getLocaleTimeInputFormat, getNumberFormatter, getNumberGroupingPattern, getNumberSymbols, gregorianDateTime, gregorianDateTimeFromObject, injectComponentDirection, mergeMessages, mergeTwo, normalizeGregorianLocale, normalizeLocalizedDigits, normalizeLocalizedInput, normalizeLocalizedMinus, observeComponentDirection, parseGregorianDate, parseLocalizedNumber, provideMonaI18n, pseudoLocalize, pseudoLocalizeCatalog, resolveComponentDirection, sanitizeDateText, stripBidiControls, validateLocalizedNumber, validateLocalizedNumberEdit };
+export { BIDI_CONTROL_REGEX, MONA_DEFAULT_LOCALE, MONA_I18N_CONFIG, MonaDirectionService, MonaI18nService, formatGregorianDateToLocaleString, formatNumber, generatePseudoLocale, getEditDecimalSeparators, getLocaleDateInputFormat, getLocaleDateTimeInputFormat, getLocaleFirstDayOfWeek, getLocaleTimeInputFormat, getNumberFormatter, getNumberGroupingPattern, getNumberSymbols, gregorianDateTime, gregorianDateTimeFromObject, injectComponentDirection, mergeMessages, mergeTwo, normalizeGregorianLocale, normalizeLocalizedDigits, normalizeLocalizedInput, normalizeLocalizedMinus, observeComponentDirection, parseGregorianDate, parseLocalizedNumber, provideMonaI18n, pseudoLocalize, pseudoLocalizeCatalog, resolveComponentDirection, sanitizeDateText, stripBidiControls, validateLocalizedNumber, validateLocalizedNumberEdit };
 //# sourceMappingURL=nanahoshi-mona-ui-i18n.mjs.map