@nanahoshi/mona-ui 0.23.2 → 0.24.0

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

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, signal, computed, Injectable, isDevMode, ElementRef, DestroyRef, makeEnvironmentProviders } from '@angular/core';
+import { InjectionToken, inject, signal, computed, Injectable, isDevMode, ElementRef, DestroyRef, afterNextRender, Injector, makeEnvironmentProviders, provideAppInitializer } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
 import { DateTime } from 'luxon';
 
@@ -83,16 +83,36 @@ function mergeMessages(fallback, localeMessages, overrideMessages) {
 
 class MonaI18nService {
     #config;
+    #loadError;
+    #loadedLocales;
+    #loadingLocaleId;
     #locale;
+    #localeOverrides;
     #overrides;
+    /** Incremented by every `load()` and `use()`, so only the latest request changes the locale. */
+    #localeRequest;
     constructor() {
         this.#config = inject(MONA_I18N_CONFIG);
+        this.#loadError = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#loadError" }] : /* istanbul ignore next */ []));
+        this.#loadedLocales = new Map();
+        this.#loadingLocaleId = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#loadingLocaleId" }] : /* istanbul ignore next */ []));
         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 */ []));
+        /** Incremented by every `load()` and `use()`, so only the latest request changes the locale. */
+        this.#localeRequest = 0;
         this.direction = computed(() => this.#locale().direction, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "direction" }] : /* istanbul ignore next */ []));
+        /** The error of the latest `load()` when it failed, otherwise `null`. */
+        this.loadError = this.#loadError.asReadonly();
+        /** Whether a `load()` is in progress and has not been superseded. */
+        this.loading = computed(() => this.#loadingLocaleId() != null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
         this.locale = this.#locale.asReadonly();
         /**
          * Canonical BCP 47 id of the active locale. POSIX ids such as `en_US` are converted to `en-US`,
@@ -102,23 +122,108 @@ class MonaI18nService {
         ...(ngDevMode ? [{ debugName: "localeId" }] : /* istanbul ignore next */ []));
         warnOnInvalidLocaleId(this.#locale().id);
     }
-    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));
+    /**
+     * Loads a locale with the `loadLocale` function configured in `provideMonaI18n` and switches to it.
+     *
+     * - Ids are canonicalized, and each locale is loaded once: later calls reuse it, and concurrent calls for the
+     *   same id share one request.
+     * - The latest `load()` or `use()` wins. When a newer one starts before this one finishes, this one resolves
+     *   without switching.
+     * - When loading fails, the current locale stays, `loadError` is set and the promise rejects. The failed
+     *   locale is not cached, so a later call retries it.
+     */
+    async load(localeId) {
+        const loadLocale = this.#config.loadLocale;
+        if (loadLocale == null) {
+            throw new Error("[mona-ui] MonaI18nService.load() needs a loader: provideMonaI18n({ loadLocale: loadMonaLocale }).");
+        }
+        const canonicalId = canonicalizeLocaleId(localeId);
+        const request = ++this.#localeRequest;
+        this.#loadingLocaleId.set(canonicalId);
+        this.#loadError.set(null);
+        let pending = this.#loadedLocales.get(canonicalId);
+        if (pending == null) {
+            pending = Promise.resolve().then(() => loadLocale(canonicalId));
+            this.#loadedLocales.set(canonicalId, pending);
+        }
+        try {
+            const locale = await pending;
+            if (request === this.#localeRequest) {
+                this.#applyLocale(locale);
+            }
+        }
+        catch (error) {
+            if (this.#loadedLocales.get(canonicalId) === pending) {
+                this.#loadedLocales.delete(canonicalId);
+            }
+            if (request === this.#localeRequest) {
+                this.#loadError.set(error);
+            }
+            throw error;
+        }
+        finally {
+            if (request === this.#localeRequest) {
+                this.#loadingLocaleId.set(null);
+            }
+        }
+    }
+    /**
+     * 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));
     }
+    /** Switches to a locale that is already loaded. It supersedes a `load()` still in progress. */
     use(locale) {
+        this.#localeRequest++;
+        this.#loadingLocaleId.set(null);
+        this.#loadError.set(null);
+        this.#applyLocale(locale);
+    }
+    #applyLocale(locale) {
         warnOnInvalidLocaleId(locale.id);
         this.#locale.set(locale);
     }
@@ -131,6 +236,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.6", ngImpor
                     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}".`);
@@ -197,39 +310,94 @@ function resolveComponentDirection(hostElement, directionality) {
     }
     return "ltr";
 }
-const documentObservers = new WeakMap();
-function observeDocumentDirChanges(doc, callback) {
-    let entry = documentObservers.get(doc);
-    if (!entry) {
-        const callbacks = new Set();
-        const observer = new MutationObserver(() => {
-            for (const cb of Array.from(callbacks)) {
-                cb();
+/**
+ * One `dir` attribute observer per observed root (the document element, a shadow root, or the top of a detached
+ * tree), shared by every direction-aware instance under it. A mutation only invalidates the instances it can affect,
+ * so a `dir` written on an overlay pane does not re-resolve every component on the page.
+ */
+const directionRegistries = new WeakMap();
+function isShadowRoot(node) {
+    return node.nodeType === 11 && "host" in node;
+}
+function getComposedParent(node) {
+    if (node.parentNode) {
+        return node.parentNode;
+    }
+    return isShadowRoot(node) ? node.host : null;
+}
+function composedContains(ancestor, node) {
+    for (let current = node; current; current = getComposedParent(current)) {
+        if (current === ancestor) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * A `dir` change affects an instance when it lands on the instance's element or one of its ancestors, or anywhere
+ * inside the `dir="auto"` root it resolves against (a nested explicit direction changes which text counts).
+ */
+function isAffectedByDirChange(subscriber, targets) {
+    for (let current = subscriber.element; current; current = getComposedParent(current)) {
+        if (targets.has(current)) {
+            return true;
+        }
+    }
+    const autoRoot = subscriber.autoRoot;
+    if (autoRoot) {
+        for (const target of targets) {
+            if (composedContains(autoRoot, target)) {
+                return true;
             }
-        });
-        if (doc.documentElement) {
-            observer.observe(doc.documentElement, {
-                attributes: true,
-                attributeFilter: ["dir"],
-                subtree: true
-            });
         }
-        entry = { refCount: 0, observer, callbacks };
-        documentObservers.set(doc, entry);
     }
-    entry.refCount++;
-    entry.callbacks.add(callback);
-    let cleanedUp = false;
+    return false;
+}
+function getObservedRoots(element) {
+    const roots = [];
+    let root = element.getRootNode?.() ?? null;
+    while (root && isShadowRoot(root)) {
+        roots.push(root);
+        root = root.host.getRootNode?.() ?? null;
+    }
+    // The top of a detached tree, so a host that is not attached yet still sees its own subtree change.
+    if (root && root !== element && root.nodeType === 1) {
+        roots.push(root);
+    }
+    const documentElement = element.ownerDocument?.documentElement;
+    if (documentElement && !roots.includes(documentElement)) {
+        roots.push(documentElement);
+    }
+    return roots;
+}
+function registerDirectionSubscriber(observedRoot, subscriber) {
+    let registry = directionRegistries.get(observedRoot);
+    if (!registry) {
+        const subscribers = new Set();
+        const observer = new MutationObserver(records => {
+            const targets = new Set();
+            for (const record of records) {
+                targets.add(record.target);
+            }
+            for (const candidate of Array.from(subscribers)) {
+                if (subscribers.has(candidate) && isAffectedByDirChange(candidate, targets)) {
+                    candidate.invalidate();
+                }
+            }
+        });
+        observer.observe(observedRoot, { attributes: true, attributeFilter: ["dir"], subtree: true });
+        registry = { observer, subscribers };
+        directionRegistries.set(observedRoot, registry);
+    }
+    const activeRegistry = registry;
+    activeRegistry.subscribers.add(subscriber);
     return () => {
-        if (cleanedUp || !entry) {
-            return;
-        }
-        cleanedUp = true;
-        entry.callbacks.delete(callback);
-        entry.refCount--;
-        if (entry.refCount <= 0) {
-            entry.observer.disconnect();
-            documentObservers.delete(doc);
+        activeRegistry.subscribers.delete(subscriber);
+        if (activeRegistry.subscribers.size === 0) {
+            activeRegistry.observer.disconnect();
+            if (directionRegistries.get(observedRoot) === activeRegistry) {
+                directionRegistries.delete(observedRoot);
+            }
         }
     };
 }
@@ -276,46 +444,61 @@ function observeAutoDirectionChanges(autoRoot, callback) {
         }
     };
 }
+/** The nearest `dir="auto"` ancestor-or-self, unless an explicit `ltr`/`rtl` comes first. */
+function findAutoRoot(element) {
+    for (let current = element; current; current = current.parentElement) {
+        const rawDir = current.getAttribute?.("dir")?.trim().toLowerCase();
+        if (rawDir === "auto") {
+            return current;
+        }
+        if (rawDir === "rtl" || rawDir === "ltr") {
+            return null;
+        }
+    }
+    return null;
+}
 function observeComponentDirection(hostElement, directionality, onChange) {
     const element = hostElement instanceof ElementRef ? hostElement.nativeElement : hostElement;
+    const canObserve = typeof MutationObserver !== "undefined" && !!element;
     let currentDir = resolveComponentDirection(element, directionality);
     let unobserveAuto = null;
-    let observedAutoElement = null;
+    const rootSubscriptions = new Map();
+    const subscriber = element
+        ? { autoRoot: null, element, invalidate: () => check() }
+        : null;
     const updateAutoContentObserver = () => {
-        if (typeof MutationObserver === "undefined" || !element) {
+        if (!canObserve || !subscriber) {
             return;
         }
-        let autoRoot = null;
-        let current = element;
-        while (current) {
-            const rawDir = current.getAttribute?.("dir")?.trim().toLowerCase();
-            if (rawDir === "auto") {
-                autoRoot = current;
-                break;
-            }
-            if (rawDir === "rtl" || rawDir === "ltr") {
-                break;
-            }
-            current = current.parentElement;
+        const autoRoot = findAutoRoot(subscriber.element);
+        if (autoRoot === subscriber.autoRoot) {
+            return;
         }
-        if (autoRoot) {
-            if (observedAutoElement !== autoRoot) {
-                if (unobserveAuto) {
-                    unobserveAuto();
-                }
-                observedAutoElement = autoRoot;
-                unobserveAuto = observeAutoDirectionChanges(autoRoot, () => check());
+        unobserveAuto?.();
+        unobserveAuto = autoRoot ? observeAutoDirectionChanges(autoRoot, () => check()) : null;
+        subscriber.autoRoot = autoRoot;
+    };
+    // Re-registers with the roots the host is under now: it may have been created in a detached view and inserted
+    // into the document or a shadow root later.
+    const syncObservedRoots = () => {
+        if (!canObserve || !subscriber) {
+            return;
+        }
+        const roots = getObservedRoots(subscriber.element);
+        for (const [root, unsubscribe] of rootSubscriptions) {
+            if (!roots.includes(root)) {
+                unsubscribe();
+                rootSubscriptions.delete(root);
             }
         }
-        else {
-            if (unobserveAuto) {
-                unobserveAuto();
-                unobserveAuto = null;
-                observedAutoElement = null;
+        for (const root of roots) {
+            if (!rootSubscriptions.has(root)) {
+                rootSubscriptions.set(root, registerDirectionSubscriber(root, subscriber));
             }
         }
     };
     const check = () => {
+        syncObservedRoots();
         updateAutoContentObserver();
         const nextDir = resolveComponentDirection(element, directionality);
         if (nextDir !== currentDir) {
@@ -333,27 +516,24 @@ function observeComponentDirection(hostElement, directionality, onChange) {
         });
         cleanupFns.push(() => sub.unsubscribe());
     }
-    if (typeof MutationObserver !== "undefined") {
-        if (element) {
-            const elObserver = new MutationObserver(() => check());
-            elObserver.observe(element, { attributes: true, attributeFilter: ["dir"] });
-            cleanupFns.push(() => elObserver.disconnect());
-            const root = element.getRootNode?.();
-            if (root && root !== element && root !== element.ownerDocument) {
-                const rootObserver = new MutationObserver(() => check());
-                rootObserver.observe(root, { attributes: true, attributeFilter: ["dir"], subtree: true });
-                cleanupFns.push(() => rootObserver.disconnect());
-            }
-            if (element.ownerDocument) {
-                cleanupFns.push(observeDocumentDirChanges(element.ownerDocument, check));
-            }
-        }
+    if (canObserve && element) {
+        // The host's own dir, which the shared root observers miss while the host is outside them (detached or moved).
+        const hostObserver = new MutationObserver(() => check());
+        hostObserver.observe(element, { attributes: true, attributeFilter: ["dir"] });
+        cleanupFns.push(() => hostObserver.disconnect());
     }
+    syncObservedRoots();
+    cleanupFns.push(() => {
+        for (const unsubscribe of rootSubscriptions.values()) {
+            unsubscribe();
+        }
+        rootSubscriptions.clear();
+    });
     cleanupFns.push(() => {
-        if (unobserveAuto) {
-            unobserveAuto();
-            unobserveAuto = null;
-            observedAutoElement = null;
+        unobserveAuto?.();
+        unobserveAuto = null;
+        if (subscriber) {
+            subscriber.autoRoot = null;
         }
     });
     const handle = Object.assign(() => {
@@ -372,17 +552,17 @@ function injectComponentDirection(hostElementRef) {
     const destroyRef = inject(DestroyRef, { optional: true });
     const domVersion = signal(0, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "domVersion" }] : /* istanbul ignore next */ []));
-    let updateAutoObserverFn = () => { };
     if (destroyRef) {
-        const cleanup = observeComponentDirection(hostRef, directionality, () => {
+        const handle = observeComponentDirection(hostRef, directionality, () => {
             domVersion.update(v => v + 1);
         });
-        updateAutoObserverFn = cleanup.updateAutoObserver;
-        destroyRef.onDestroy(() => cleanup());
+        destroyRef.onDestroy(() => handle());
+        // A host can be moved under a different `dir="auto"` root after it is created; re-check once it has rendered.
+        afterNextRender(() => handle.check(), { injector: inject(Injector) });
     }
+    // Pure: observers are managed by the handle above, never during signal evaluation.
     return computed(() => {
         domVersion();
-        updateAutoObserverFn();
         return resolveComponentDirection(hostRef, directionality);
     });
 }
@@ -408,11 +588,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.6", ngImpor
         }] });
 
 function provideMonaI18n(config = {}) {
+    const initialLocale = config.initialLocale;
     return makeEnvironmentProviders([
         {
             provide: MONA_I18N_CONFIG,
             useValue: config
-        }
+        },
+        ...(initialLocale == null
+            ? []
+            : [
+                // A failed load must not stop the application from starting: it keeps the configured locale.
+                provideAppInitializer(() => inject(MonaI18nService)
+                    .load(initialLocale)
+                    .catch((error) => console.error(`[mona-ui] Could not load the initial locale "${initialLocale}".`, error)))
+            ])
     ]);
 }
 
@@ -421,6 +610,9 @@ 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();
@@ -554,7 +746,12 @@ function getNumberFormatter(locale, options) {
     }
     return formatter;
 }
+/**
+ * Formats a number for the locale. A decimal string, such as one returned by {@link parseLocalizedDecimal}, is
+ * formatted exactly, without converting it to a `number` first.
+ */
 function formatNumber(value, locale, options) {
+    // Intl.NumberFormat formats decimal strings exactly (Intl.NumberFormat v3); the ES2022 lib types only declare numbers.
     return getNumberFormatter(locale, options).format(value);
 }
 /**
@@ -629,7 +826,52 @@ function getEditDecimalSeparators(symbols) {
     }
     return separators;
 }
+const MAX_SAFE_INTEGER_DIGITS = String(Number.MAX_SAFE_INTEGER);
+/** The most significant digits a double reproduces exactly when converted from decimal text and back. */
+const MAX_EXACT_SIGNIFICANT_DIGITS = 15;
+/** Whether ASCII integer and fraction digits survive conversion to a `number` unchanged. */
+function isRepresentableAsNumber(intDigits, fracDigits) {
+    const integer = intDigits.replace(/^0+/, "");
+    const fraction = fracDigits.replace(/0+$/, "");
+    if (fraction === "") {
+        return (integer.length < MAX_SAFE_INTEGER_DIGITS.length ||
+            (integer.length === MAX_SAFE_INTEGER_DIGITS.length && integer <= MAX_SAFE_INTEGER_DIGITS));
+    }
+    return (integer + fraction).replace(/^0+/, "").length <= MAX_EXACT_SIGNIFICANT_DIGITS;
+}
+function partsToNumber(parts) {
+    if (!isRepresentableAsNumber(parts.integer, parts.fraction)) {
+        return "precision";
+    }
+    return Number((parts.negative ? "-" : "") + parts.integer + (parts.fraction ? "." + parts.fraction : ""));
+}
+/** Leading zeros, trailing fraction zeros and the sign of zero are dropped: `"-0012.500"` becomes `"-12.5"`. */
+function partsToDecimal(parts) {
+    const integer = parts.integer.replace(/^0+(?=\d)/, "") || "0";
+    const fraction = parts.fraction.replace(/0+$/, "");
+    const digits = fraction ? `${integer}.${fraction}` : integer;
+    return parts.negative && /[1-9]/.test(digits) ? `-${digits}` : digits;
+}
+/**
+ * Parses localized text to a number. Returns `null` when the text is not a number in the locale, or when a
+ * `number` cannot hold it exactly (see {@link LocalizedNumberInvalidReason}); it never rounds silently.
+ * Use {@link parseLocalizedDecimal} for values that need more precision.
+ */
 function parseLocalizedNumber(text, localeId, options) {
+    const parts = parseLocalizedNumberParts(text, localeId, options);
+    const value = parts === null ? null : partsToNumber(parts);
+    return value === "precision" ? null : value;
+}
+/**
+ * Parses localized text with the same rules as {@link parseLocalizedNumber}, but returns a canonical decimal string
+ * (`"-1234.5"`: ASCII digits, `.` as the decimal separator, no grouping, exponent, leading zeros or trailing
+ * fraction zeros) and has no precision limit. Returns `null` when the text is not a number in the locale.
+ */
+function parseLocalizedDecimal(text, localeId, options) {
+    const parts = parseLocalizedNumberParts(text, localeId, options);
+    return parts === null ? null : partsToDecimal(parts);
+}
+function parseLocalizedNumberParts(text, localeId, options) {
     if (text == null) {
         return null;
     }
@@ -662,6 +904,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;
@@ -737,11 +984,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)) {
@@ -770,9 +1014,7 @@ function parseLocalizedNumber(text, localeId, options) {
                 }
             }
         }
-        const normalizedStr = sign + intPart + (fracPart && fracPart.length > 0 ? "." + fracPart : "");
-        const num = Number(normalizedStr);
-        return Number.isFinite(num) ? num : null;
+        return { fraction: fracPart ?? "", integer: intPart, negative: sign === "-" };
     }
     else {
         // mode === "edit": editor buffer grammar with exactly one decimal separator (locale primary or alternate)
@@ -826,11 +1068,7 @@ function parseLocalizedNumber(text, localeId, options) {
             intPart = cleaned;
             fracPart = "";
         }
-        const normalizedStr = sign +
-            (intPart.length > 0 ? intPart : "0") +
-            (fracPart.length > 0 ? "." + fracPart : cleaned.endsWith(foundSep ?? "") ? "" : "");
-        const num = Number(normalizedStr);
-        return Number.isFinite(num) ? num : null;
+        return { fraction: fracPart, integer: intPart.length > 0 ? intPart : "0", negative: sign === "-" };
     }
 }
 function validateLocalizedNumber(text, localeId, options) {
@@ -842,9 +1080,13 @@ function validateLocalizedNumber(text, localeId, options) {
         return { value: null, valid: true, fractionDigits: 0 };
     }
     const mode = options?.mode ?? "locale";
-    const parsed = parseLocalizedNumber(trimmed, localeId, { mode });
+    const parts = parseLocalizedNumberParts(trimmed, localeId, { mode });
+    const parsed = parts === null ? null : partsToNumber(parts);
+    if (parsed === "precision") {
+        return { value: null, valid: false, fractionDigits: 0, reason: "precision" };
+    }
     if (parsed === null || !Number.isFinite(parsed)) {
-        return { value: null, valid: false, fractionDigits: 0 };
+        return { value: null, valid: false, fractionDigits: 0, reason: "syntax" };
     }
     // Determine the number of fraction digits from the source string
     const symbols = getNumberSymbols(localeId);
@@ -903,11 +1145,42 @@ function validateLocalizedNumber(text, localeId, options) {
         }
     }
     if (options?.decimals !== undefined && fractionDigits > options.decimals) {
-        return { value: parsed, valid: false, fractionDigits };
+        return { value: parsed, valid: false, fractionDigits, reason: "decimals" };
     }
     return { value: parsed, valid: true, fractionDigits };
 }
+/**
+ * Validates localized text like {@link validateLocalizedNumber}, but returns a canonical decimal string and has no
+ * precision limit, so `reason` is never `"precision"`.
+ */
+function validateLocalizedDecimal(text, localeId, options) {
+    const trimmed = text == null ? "" : String(text).trim();
+    if (trimmed === "" || trimmed === "-" || trimmed === "+") {
+        return { fractionDigits: 0, valid: true, value: null };
+    }
+    const parts = parseLocalizedNumberParts(trimmed, localeId, { mode: options?.mode ?? "locale" });
+    if (parts === null) {
+        return { fractionDigits: 0, reason: "syntax", valid: false, value: null };
+    }
+    const value = partsToDecimal(parts);
+    const fractionDigits = parts.fraction.length;
+    if (options?.decimals !== undefined && fractionDigits > options.decimals) {
+        return { fractionDigits, reason: "decimals", valid: false, value };
+    }
+    return { fractionDigits, valid: true, value };
+}
+const EDIT_SYNTAX_ERROR = { complete: false, reason: "syntax", valid: false, value: null };
 function validateLocalizedNumberEdit(text, localeId, options) {
+    return validateEditInput(text, localeId, options, partsToNumber);
+}
+/**
+ * Validates text while it is typed, like {@link validateLocalizedNumberEdit}, but returns a canonical decimal string
+ * and has no precision limit.
+ */
+function validateLocalizedDecimalEdit(text, localeId, options) {
+    return validateEditInput(text, localeId, options, partsToDecimal);
+}
+function validateEditInput(text, localeId, options, convert) {
     if (text == null) {
         return { valid: true, complete: false, value: null };
     }
@@ -917,7 +1190,7 @@ function validateLocalizedNumberEdit(text, localeId, options) {
     }
     // Reject control or whitespace characters in interactive typing
     if (/[\s\u00A0\u202F]/.test(raw)) {
-        return { valid: false, complete: false, value: null };
+        return EDIT_SYNTAX_ERROR;
     }
     const symbols = getNumberSymbols(localeId);
     // Normalize minus signs and bidi controls
@@ -928,12 +1201,12 @@ function validateLocalizedNumberEdit(text, localeId, options) {
     const allowSign = options?.allowSign ?? true;
     if (normalized.startsWith("-") || normalized.startsWith("+")) {
         if (!allowSign) {
-            return { valid: false, complete: false, value: null };
+            return EDIT_SYNTAX_ERROR;
         }
         normalized = normalized.slice(1);
     }
     if (normalized.includes("-") || normalized.includes("+")) {
-        return { valid: false, complete: false, value: null };
+        return EDIT_SYNTAX_ERROR;
     }
     // If input was just "-" or "+"
     if (normalized === "") {
@@ -948,7 +1221,7 @@ function validateLocalizedNumberEdit(text, localeId, options) {
             if (normalized.startsWith(sep, i)) {
                 if (foundSep !== null) {
                     // More than one separator is rejected in edit mode
-                    return { valid: false, complete: false, value: null };
+                    return EDIT_SYNTAX_ERROR;
                 }
                 foundSep = sep;
                 sepIndex = i;
@@ -961,23 +1234,28 @@ function validateLocalizedNumberEdit(text, localeId, options) {
     if (foundSep !== null) {
         if (decimals === 0) {
             // No decimal point permitted when decimals === 0
-            return { valid: false, complete: false, value: null };
+            return { valid: false, complete: false, value: null, reason: "decimals" };
         }
         const intPart = normalized.slice(0, sepIndex);
         const fracPart = normalized.slice(sepIndex + foundSep.length);
         // Integer part before separator must consist purely of ASCII digits (or empty, e.g. ".5")
         if (intPart.length > 0 && !/^\d+$/.test(intPart)) {
-            return { valid: false, complete: false, value: null };
+            return EDIT_SYNTAX_ERROR;
         }
         // Fractional part after separator must consist purely of ASCII digits (or empty, e.g. "12.")
         if (fracPart.length > 0 && !/^\d+$/.test(fracPart)) {
-            return { valid: false, complete: false, value: null };
+            return EDIT_SYNTAX_ERROR;
         }
         // Count fraction digits using normalized ASCII characters (safe against UTF-16 astral splitting)
         if (fracPart.length > decimals) {
-            return { valid: false, complete: false, value: null };
+            return { valid: false, complete: false, value: null, reason: "decimals" };
+        }
+        const parts = parseLocalizedNumberParts(raw, localeId, { mode: "edit" });
+        const parsed = parts === null ? null : convert(parts);
+        // Refuse the keystroke that would make the value too precise for the target type, instead of rounding it.
+        if (parsed === "precision") {
+            return { valid: false, complete: false, value: null, reason: "precision" };
         }
-        const parsed = parseLocalizedNumber(raw, localeId, { mode: "edit" });
         const complete = fracPart.length > 0 && (intPart.length > 0 || fracPart.length > 0);
         return {
             valid: true,
@@ -987,9 +1265,13 @@ function validateLocalizedNumberEdit(text, localeId, options) {
     }
     // No separator found: must be purely ASCII digits
     if (!/^\d+$/.test(normalized)) {
-        return { valid: false, complete: false, value: null };
+        return EDIT_SYNTAX_ERROR;
+    }
+    const parts = parseLocalizedNumberParts(raw, localeId, { mode: "edit" });
+    const parsed = parts === null ? null : convert(parts);
+    if (parsed === "precision") {
+        return { valid: false, complete: false, value: null, reason: "precision" };
     }
-    const parsed = parseLocalizedNumber(raw, localeId, { mode: "edit" });
     return {
         valid: true,
         complete: true,
@@ -4930,5 +5212,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, 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 };
+export { BIDI_CONTROL_REGEX, MONA_DEFAULT_LOCALE, MONA_FALLBACK_LOCALE_ID, MONA_I18N_CONFIG, MonaDirectionService, MonaI18nService, canonicalizeLocaleId, formatGregorianDateToLocaleString, formatNumber, generatePseudoLocale, getEditDecimalSeparators, getLocaleDateInputFormat, getLocaleDateTimeInputFormat, getLocaleFirstDayOfWeek, getLocaleTimeInputFormat, getNumberFormatter, getNumberGroupingPattern, getNumberSymbols, gregorianDateTime, gregorianDateTimeFromObject, injectComponentDirection, mergeMessages, mergeTwo, normalizeGregorianLocale, normalizeLocalizedDigits, normalizeLocalizedInput, normalizeLocalizedMinus, observeComponentDirection, parseGregorianDate, parseLocalizedDecimal, parseLocalizedNumber, provideMonaI18n, pseudoLocalize, pseudoLocalizeCatalog, resolveComponentDirection, sanitizeDateText, stripBidiControls, tryCanonicalizeLocaleId, validateLocalizedDecimal, validateLocalizedDecimalEdit, validateLocalizedNumber, validateLocalizedNumberEdit };
 //# sourceMappingURL=nanahoshi-mona-ui-i18n.mjs.map