@nanahoshi/mona-ui 0.18.5 → 0.19.0

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

@@ -0,0 +1,1168 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, signal, computed, Injectable, ElementRef, DestroyRef, makeEnvironmentProviders } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+import { DateTime } from 'luxon';
+
+const MONA_DEFAULT_LOCALE = {
+    direction: "ltr",
+    id: "en-US",
+    messages: {}
+};
+
+const MONA_I18N_CONFIG = new InjectionToken("MONA_I18N_CONFIG", {
+    factory: () => ({})
+});
+
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mergeTwo(base, source) {
+    if (!source) {
+        return base;
+    }
+    const result = { ...base };
+    const sourceObj = source;
+    for (const key of Object.keys(sourceObj)) {
+        const sourceVal = sourceObj[key];
+        if (sourceVal === undefined) {
+            continue;
+        }
+        const baseVal = result[key];
+        if (isPlainObject(baseVal) && isPlainObject(sourceVal)) {
+            result[key] = mergeTwo(baseVal, sourceVal);
+        }
+        else {
+            result[key] = sourceVal;
+        }
+    }
+    return result;
+}
+function mergeMessages(fallback, localeMessages, overrideMessages) {
+    const withLocale = mergeTwo(fallback, localeMessages);
+    return mergeTwo(withLocale, overrideMessages);
+}
+
+class MonaI18nService {
+    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.#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 */
+        ...(ngDevMode ? [{ debugName: "localeId" }] : /* istanbul ignore next */ []));
+    }
+    #config;
+    #locale;
+    #overrides;
+    clearMessages() {
+        this.#overrides.set({});
+    }
+    componentMessages(namespace, fallback) {
+        return computed(() => {
+            const localeMessages = this.#locale().messages[namespace];
+            const overrideMessages = this.#overrides()[namespace];
+            return mergeMessages(fallback, localeMessages, overrideMessages);
+        });
+    }
+    patchMessages(messages) {
+        this.#overrides.update(current => mergeTwo(current, messages));
+    }
+    setMessages(messages) {
+        this.#overrides.set(messages);
+    }
+    use(locale) {
+        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 }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: MonaI18nService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: MonaI18nService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }] });
+
+/**
+ * Reads semantic document direction for a connected browser element using `:dir(rtl)` and `:dir(ltr)`.
+ *
+ * Mona UI direction-sensitive behaviors follow semantic document directionality
+ * (`:dir(...)`, `[dir]`, and CDK Directionality), matching Tailwind's `rtl:`/`ltr:`
+ * variant matching. Styling-only CSS `direction` property is not treated as the
+ * authoritative Mona direction switch.
+ */
+function readSemanticDirection(element) {
+    if (!element || !element.isConnected) {
+        return null;
+    }
+    try {
+        if (element.matches(":dir(rtl)")) {
+            return "rtl";
+        }
+        if (element.matches(":dir(ltr)")) {
+            return "ltr";
+        }
+    }
+    catch {
+        // selector unsupported / environment limitation
+    }
+    return null;
+}
+function findNearestValidDirState(element) {
+    let current = element;
+    while (current) {
+        const rawDir = current.getAttribute?.("dir")?.trim().toLowerCase();
+        if (rawDir === "rtl" || rawDir === "ltr") {
+            return rawDir;
+        }
+        if (rawDir === "auto") {
+            const semanticDir = readSemanticDirection(current) ?? readSemanticDirection(element);
+            if (semanticDir) {
+                return semanticDir;
+            }
+        }
+        current = current.parentElement;
+    }
+    return null;
+}
+function resolveComponentDirection(hostElement, directionality) {
+    const element = hostElement instanceof ElementRef ? hostElement.nativeElement : hostElement;
+    // 1. Connected browser semantic direction (:dir(rtl) / :dir(ltr))
+    const semantic = readSemanticDirection(element);
+    if (semantic) {
+        return semantic;
+    }
+    // 2. Non-browser / unattached DOM fallback: nearest ancestor explicit dir attribute ("ltr", "rtl", or "auto")
+    const explicit = findNearestValidDirState(element);
+    if (explicit) {
+        return explicit;
+    }
+    // 3. Angular CDK Directionality fallback
+    if (directionality?.value === "rtl" || directionality?.value === "ltr") {
+        return directionality.value;
+    }
+    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();
+            }
+        });
+        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 () => {
+        if (cleanedUp || !entry) {
+            return;
+        }
+        cleanedUp = true;
+        entry.callbacks.delete(callback);
+        entry.refCount--;
+        if (entry.refCount <= 0) {
+            entry.observer.disconnect();
+            documentObservers.delete(doc);
+        }
+    };
+}
+const autoDirectionObservers = new WeakMap();
+function observeAutoDirectionChanges(autoRoot, callback) {
+    let entry = autoDirectionObservers.get(autoRoot);
+    if (!entry) {
+        const callbacks = new Set();
+        const observer = new MutationObserver(() => {
+            const currentDir = readSemanticDirection(autoRoot);
+            if (entry && (entry.lastDirection === null || currentDir !== entry.lastDirection)) {
+                entry.lastDirection = currentDir;
+                for (const cb of Array.from(callbacks)) {
+                    cb();
+                }
+            }
+        });
+        observer.observe(autoRoot, {
+            childList: true,
+            characterData: true,
+            subtree: true
+        });
+        entry = {
+            refCount: 0,
+            observer,
+            callbacks,
+            lastDirection: readSemanticDirection(autoRoot)
+        };
+        autoDirectionObservers.set(autoRoot, entry);
+    }
+    entry.refCount++;
+    entry.callbacks.add(callback);
+    let cleanedUp = false;
+    return () => {
+        if (cleanedUp || !entry) {
+            return;
+        }
+        cleanedUp = true;
+        entry.callbacks.delete(callback);
+        entry.refCount--;
+        if (entry.refCount <= 0) {
+            entry.observer.disconnect();
+            autoDirectionObservers.delete(autoRoot);
+        }
+    };
+}
+function observeComponentDirection(hostElement, directionality, onChange) {
+    const element = hostElement instanceof ElementRef ? hostElement.nativeElement : hostElement;
+    let currentDir = resolveComponentDirection(element, directionality);
+    let unobserveAuto = null;
+    let observedAutoElement = null;
+    const updateAutoContentObserver = () => {
+        if (typeof MutationObserver === "undefined" || !element) {
+            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;
+        }
+        if (autoRoot) {
+            if (observedAutoElement !== autoRoot) {
+                if (unobserveAuto) {
+                    unobserveAuto();
+                }
+                observedAutoElement = autoRoot;
+                unobserveAuto = observeAutoDirectionChanges(autoRoot, () => check());
+            }
+        }
+        else {
+            if (unobserveAuto) {
+                unobserveAuto();
+                unobserveAuto = null;
+                observedAutoElement = null;
+            }
+        }
+    };
+    const check = () => {
+        updateAutoContentObserver();
+        const nextDir = resolveComponentDirection(element, directionality);
+        if (nextDir !== currentDir) {
+            currentDir = nextDir;
+            onChange(nextDir);
+        }
+    };
+    updateAutoContentObserver();
+    const cleanupFns = [];
+    if (directionality) {
+        const sub = directionality.change.subscribe(dir => {
+            if (dir === "rtl" || dir === "ltr") {
+                check();
+            }
+        });
+        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));
+            }
+        }
+    }
+    cleanupFns.push(() => {
+        if (unobserveAuto) {
+            unobserveAuto();
+            unobserveAuto = null;
+            observedAutoElement = null;
+        }
+    });
+    const handle = Object.assign(() => {
+        for (const fn of cleanupFns) {
+            fn();
+        }
+    }, {
+        check,
+        updateAutoObserver: updateAutoContentObserver
+    });
+    return handle;
+}
+function injectComponentDirection(hostElementRef) {
+    const directionality = inject(Directionality, { optional: true });
+    const hostRef = hostElementRef ?? inject((ElementRef), { optional: true });
+    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, () => {
+            domVersion.update(v => v + 1);
+        });
+        updateAutoObserverFn = cleanup.updateAutoObserver;
+        destroyRef.onDestroy(() => cleanup());
+    }
+    return computed(() => {
+        domVersion();
+        updateAutoObserverFn();
+        return resolveComponentDirection(hostRef, directionality);
+    });
+}
+class MonaDirectionService {
+    #directionality = inject(Directionality, { optional: true });
+    getDirection(element) {
+        return resolveComponentDirection(element, this.#directionality);
+    }
+    isRtl(element) {
+        return this.getDirection(element) === "rtl";
+    }
+    observeDirection(element, onChange) {
+        return observeComponentDirection(element, this.#directionality, onChange);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: MonaDirectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: MonaDirectionService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: MonaDirectionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }] });
+
+function provideMonaI18n(config = {}) {
+    return makeEnvironmentProviders([
+        {
+            provide: MONA_I18N_CONFIG,
+            useValue: config
+        }
+    ]);
+}
+
+const numberSymbolsCache = new Map();
+const numberFormatterCache = new Map();
+const numberGroupingCache = new Map();
+function serializeOptions(options) {
+    if (!options) {
+        return "";
+    }
+    const keys = Object.keys(options).sort();
+    return keys.map(k => `${k}:${String(options[k])}`).join(";");
+}
+function getNumberGroupingPattern(localeId) {
+    let pattern = numberGroupingCache.get(localeId);
+    if (!pattern) {
+        try {
+            const formatter = new Intl.NumberFormat(localeId, {
+                useGrouping: true,
+                maximumFractionDigits: 0
+            });
+            const parts = formatter.formatToParts(123456789012345);
+            const integerParts = parts.filter(p => p.type === "integer");
+            const groupParts = parts.filter(p => p.type === "group");
+            const groupSeparator = groupParts[0]?.value ?? getNumberSymbols(localeId).group ?? ",";
+            let minimumGroupedIntegerDigits = 4;
+            try {
+                const defaultFormatter = new Intl.NumberFormat(localeId);
+                let probe = 1000;
+                let digits = 4;
+                while (digits <= 8) {
+                    if (defaultFormatter.formatToParts(probe).some(p => p.type === "group")) {
+                        minimumGroupedIntegerDigits = digits;
+                        break;
+                    }
+                    probe *= 10;
+                    digits++;
+                }
+            }
+            catch {
+                minimumGroupedIntegerDigits = 4;
+            }
+            if (integerParts.length >= 2) {
+                const primaryStr = integerParts[integerParts.length - 1].value.replace(/[\u061C\u200E\u200F\s]/g, "");
+                const secondaryStr = integerParts[integerParts.length - 2].value.replace(/[\u061C\u200E\u200F\s]/g, "");
+                const primaryGroupSize = Array.from(primaryStr).length;
+                const secondaryGroupSize = Array.from(secondaryStr).length;
+                pattern = {
+                    primaryGroupSize: primaryGroupSize > 0 ? primaryGroupSize : 3,
+                    secondaryGroupSize: secondaryGroupSize > 0 ? secondaryGroupSize : 3,
+                    groupSeparator,
+                    minimumGroupedIntegerDigits
+                };
+            }
+            else {
+                pattern = {
+                    primaryGroupSize: 3,
+                    secondaryGroupSize: 3,
+                    groupSeparator,
+                    minimumGroupedIntegerDigits
+                };
+            }
+        }
+        catch {
+            const groupSeparator = getNumberSymbols(localeId).group ?? ",";
+            pattern = {
+                primaryGroupSize: 3,
+                secondaryGroupSize: 3,
+                groupSeparator,
+                minimumGroupedIntegerDigits: 4
+            };
+        }
+        numberGroupingCache.set(localeId, pattern);
+    }
+    return pattern;
+}
+function getNumberSymbols(localeId) {
+    let symbols = numberSymbolsCache.get(localeId);
+    if (!symbols) {
+        const digitMap = new Map();
+        // Seed digit map with common localized scripts as fallback
+        for (let i = 0; i <= 9; i++) {
+            digitMap.set(String(i), String(i));
+            digitMap.set(String.fromCharCode(0x0660 + i), String(i)); // Arabic-Indic
+            digitMap.set(String.fromCharCode(0x06f0 + i), String(i)); // Eastern Arabic-Indic / Persian
+            digitMap.set(String.fromCharCode(0x09e6 + i), String(i)); // Bengali
+            digitMap.set(String.fromCharCode(0x0966 + i), String(i)); // Devanagari
+        }
+        try {
+            const parts = new Intl.NumberFormat(localeId).formatToParts(-12345.6);
+            const decimal = parts.find(p => p.type === "decimal")?.value ?? ".";
+            const group = parts.find(p => p.type === "group")?.value ?? ",";
+            const minus = parts.find(p => p.type === "minusSign")?.value ?? "-";
+            // Dynamically query localized digit glyphs for this locale
+            try {
+                const digitFormatter = new Intl.NumberFormat(localeId, {
+                    useGrouping: false,
+                    maximumFractionDigits: 0
+                });
+                for (let i = 0; i <= 9; i++) {
+                    const glyph = digitFormatter.format(i).replace(/[\u061C\u200E\u200F\s]/g, "");
+                    if (glyph) {
+                        digitMap.set(glyph, String(i));
+                    }
+                }
+            }
+            catch {
+                // Ignore formatter failure
+            }
+            symbols = { decimal, group, minus, digits: digitMap };
+        }
+        catch {
+            symbols = { decimal: ".", group: ",", minus: "-", digits: digitMap };
+        }
+        numberSymbolsCache.set(localeId, symbols);
+    }
+    return symbols;
+}
+function getNumberFormatter(locale, options) {
+    const key = `${locale}:${serializeOptions(options)}`;
+    let formatter = numberFormatterCache.get(key);
+    if (!formatter) {
+        formatter = new Intl.NumberFormat(locale, options);
+        numberFormatterCache.set(key, formatter);
+    }
+    return formatter;
+}
+function formatNumber(value, locale, options) {
+    return getNumberFormatter(locale, options).format(value);
+}
+function normalizeLocalizedDigits(text, localeId) {
+    if (!text) {
+        return text;
+    }
+    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;
+            }
+        }
+    }
+    return result;
+}
+function normalizeLocalizedMinus(text, symbols) {
+    if (!text) {
+        return text;
+    }
+    let result = text
+        .replace(/[\u2212\uFE63\uFF0D]/g, "-")
+        .replace(/[\u061C\u200E\u200F]/g, "");
+    if (symbols?.minus && symbols.minus !== "-") {
+        result = result.replaceAll(symbols.minus, "-");
+    }
+    return result;
+}
+function normalizeLocalizedInput(text, localeId) {
+    const symbols = getNumberSymbols(localeId);
+    let cleaned = normalizeLocalizedMinus(text, symbols);
+    cleaned = normalizeLocalizedDigits(cleaned, localeId);
+    return cleaned;
+}
+function parseLocalizedNumber(text, localeId, options) {
+    if (text == null) {
+        return null;
+    }
+    let cleaned = String(text).trim();
+    if (cleaned === "") {
+        return null;
+    }
+    const symbols = getNumberSymbols(localeId);
+    // Normalize minus signs, bidi controls, and localized digits
+    cleaned = normalizeLocalizedMinus(cleaned, symbols);
+    cleaned = normalizeLocalizedDigits(cleaned, localeId);
+    if (cleaned === "-" || cleaned === "+") {
+        return null;
+    }
+    // Only one leading sign is permitted
+    let sign = "";
+    if (cleaned.startsWith("-")) {
+        sign = "-";
+        cleaned = cleaned.slice(1);
+    }
+    else if (cleaned.startsWith("+")) {
+        cleaned = cleaned.slice(1);
+    }
+    if (cleaned.includes("-") || cleaned.includes("+")) {
+        return null;
+    }
+    const mode = options?.mode ?? (options?.alternateDecimal ? "edit" : "locale");
+    if (mode === "locale") {
+        const grouping = getNumberGroupingPattern(localeId);
+        const groupSep = grouping.groupSeparator;
+        const isSpaceGroup = /[ \u00A0\u202F]/.test(groupSep);
+        const decimalSep = symbols.decimal;
+        // Reject non-accepted control or whitespace characters (tabs, newlines, formfeeds)
+        if (/[^\S\u0020\u00A0\u202F]/.test(cleaned)) {
+            return null;
+        }
+        // In strict locale mode, if grouping separator is not space-like, any internal whitespace is invalid
+        if (!isSpaceGroup && /[\s\u00A0\u202F]/.test(cleaned)) {
+            return null;
+        }
+        // Split integer and fraction by canonical decimal separator
+        let intPart;
+        let fracPart = null;
+        if (decimalSep && cleaned.includes(decimalSep)) {
+            if (cleaned.indexOf(decimalSep) !== cleaned.lastIndexOf(decimalSep)) {
+                return null;
+            }
+            const decimalIdx = cleaned.indexOf(decimalSep);
+            intPart = cleaned.slice(0, decimalIdx);
+            fracPart = cleaned.slice(decimalIdx + decimalSep.length);
+        }
+        else {
+            // If the string contains an unexpected decimal-like character that is not the group separator, reject
+            if (decimalSep === "," && groupSep !== "." && cleaned.includes(".")) {
+                return null;
+            }
+            if (decimalSep === "." && groupSep !== "," && cleaned.includes(",")) {
+                return null;
+            }
+            intPart = cleaned;
+        }
+        // Fractional part validation
+        if (fracPart !== null) {
+            // Group separators or whitespace are never permitted in the fractional part
+            if (groupSep && fracPart.includes(groupSep)) {
+                return null;
+            }
+            if (/[\s\u00A0\u202F]/.test(fracPart)) {
+                return null;
+            }
+            if (fracPart.length > 0 && !/^\d+$/.test(fracPart)) {
+                return null;
+            }
+        }
+        // Integer part validation
+        if (intPart.length === 0) {
+            if (fracPart === null || fracPart.length === 0) {
+                return null;
+            }
+            intPart = "0";
+        }
+        else {
+            let intGroups;
+            let hasGroup = false;
+            if (isSpaceGroup) {
+                if (/[ \u00A0\u202F]/.test(intPart)) {
+                    hasGroup = true;
+                    // Splitting by single accepted space character preserves empty strings for consecutive spaces
+                    intGroups = intPart.split(/[ \u00A0\u202F]/);
+                }
+                else {
+                    intGroups = [intPart];
+                }
+            }
+            else {
+                if (groupSep && intPart.includes(groupSep)) {
+                    hasGroup = true;
+                    intGroups = intPart.split(groupSep);
+                }
+                else {
+                    intGroups = [intPart];
+                }
+            }
+            if (hasGroup) {
+                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;
+                }
+                // Last (rightmost) group: must match primaryGroupSize digits
+                const lastGroup = intGroups[intGroups.length - 1];
+                if (lastGroup.length !== grouping.primaryGroupSize || !/^\d+$/.test(lastGroup)) {
+                    return null;
+                }
+                // Intermediate groups: must match secondaryGroupSize digits
+                for (let i = 1; i < intGroups.length - 1; i++) {
+                    const midGroup = intGroups[i];
+                    if (midGroup.length !== grouping.secondaryGroupSize || !/^\d+$/.test(midGroup)) {
+                        return null;
+                    }
+                }
+                // First group: must have 1..secondaryGroupSize digits
+                const firstGroup = intGroups[0];
+                if (firstGroup.length < 1 ||
+                    firstGroup.length > grouping.secondaryGroupSize ||
+                    !/^\d+$/.test(firstGroup)) {
+                    return null;
+                }
+                intPart = intGroups.join("");
+            }
+            else {
+                // Ungrouped integer must consist solely of digits
+                if (!/^\d+$/.test(intPart)) {
+                    return null;
+                }
+            }
+        }
+        const normalizedStr = sign + intPart + (fracPart && fracPart.length > 0 ? "." + fracPart : "");
+        const num = Number(normalizedStr);
+        return Number.isFinite(num) ? num : null;
+    }
+    else {
+        // mode === "edit": editor buffer grammar with exactly one decimal separator (locale primary or alternate)
+        // No group separators or internal whitespace permitted in editor buffer
+        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(",");
+        }
+        let foundSep = null;
+        let sepIndex = -1;
+        for (let i = 0; i < cleaned.length; i++) {
+            for (const sep of candidateSeparators) {
+                if (cleaned.startsWith(sep, i)) {
+                    if (foundSep !== null) {
+                        // More than one separator (or repeated alternate separators) is rejected
+                        return null;
+                    }
+                    foundSep = sep;
+                    sepIndex = i;
+                    i += sep.length - 1;
+                    break;
+                }
+            }
+        }
+        // Reject if any non-candidate dot or comma remains
+        if (cleaned.includes(".") && !candidateSeparators.has(".")) {
+            return null;
+        }
+        if (cleaned.includes(",") && !candidateSeparators.has(",")) {
+            return null;
+        }
+        let intPart;
+        let fracPart;
+        if (foundSep !== null) {
+            intPart = cleaned.slice(0, sepIndex);
+            fracPart = cleaned.slice(sepIndex + foundSep.length);
+            if (intPart.length > 0 && !/^\d+$/.test(intPart)) {
+                return null;
+            }
+            if (fracPart.length > 0 && !/^\d+$/.test(fracPart)) {
+                return null;
+            }
+            if (intPart.length === 0 && fracPart.length === 0) {
+                return null;
+            }
+        }
+        else {
+            if (!/^\d+$/.test(cleaned)) {
+                return null;
+            }
+            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;
+    }
+}
+function validateLocalizedNumber(text, localeId, options) {
+    if (text == null) {
+        return { value: null, valid: true, fractionDigits: 0 };
+    }
+    const trimmed = String(text).trim();
+    if (trimmed === "" || trimmed === "-" || trimmed === "+") {
+        return { value: null, valid: true, fractionDigits: 0 };
+    }
+    const mode = options?.mode ?? "locale";
+    const parsed = parseLocalizedNumber(trimmed, localeId, { mode });
+    if (parsed === null || !Number.isFinite(parsed)) {
+        return { value: null, valid: false, fractionDigits: 0 };
+    }
+    // Determine the number of fraction digits from the source string
+    const symbols = getNumberSymbols(localeId);
+    let normalized = normalizeLocalizedMinus(trimmed, symbols);
+    normalized = normalizeLocalizedDigits(normalized, localeId);
+    normalized = normalized.replace(/[ \u00A0\u202F]/g, "");
+    let fractionDigits = 0;
+    if (mode === "locale") {
+        if (symbols.decimal && normalized.includes(symbols.decimal)) {
+            const fracPart = normalized
+                .slice(normalized.lastIndexOf(symbols.decimal) + symbols.decimal.length)
+                .replace(/\D/g, "");
+            fractionDigits = fracPart.length;
+        }
+        else if (normalized.includes("\u066B")) {
+            const fracPart = normalized.slice(normalized.lastIndexOf("\u066B") + 1).replace(/\D/g, "");
+            fractionDigits = fracPart.length;
+        }
+    }
+    else {
+        let sep = null;
+        if (symbols.decimal === ",") {
+            if (normalized.includes(",")) {
+                sep = ",";
+            }
+            else if (normalized.includes(".")) {
+                const dotParts = normalized.split(".");
+                if (dotParts.length === 2) {
+                    sep = ".";
+                }
+            }
+        }
+        else {
+            if (symbols.decimal && symbols.decimal !== "." && symbols.decimal !== "," && normalized.includes(symbols.decimal)) {
+                sep = symbols.decimal;
+            }
+            else if (normalized.includes(".")) {
+                sep = ".";
+            }
+            else if (normalized.includes("\u066B")) {
+                sep = "\u066B";
+            }
+            else if (normalized.includes("/")) {
+                sep = "/";
+            }
+            else if (normalized.includes(",")) {
+                const commaParts = normalized.split(",");
+                if (commaParts.length === 2) {
+                    sep = ",";
+                }
+            }
+        }
+        if (sep != null) {
+            const fracPart = normalized.slice(normalized.lastIndexOf(sep) + sep.length).replace(/\D/g, "");
+            fractionDigits = fracPart.length;
+        }
+    }
+    if (options?.decimals !== undefined && fractionDigits > options.decimals) {
+        return { value: parsed, valid: false, fractionDigits };
+    }
+    return { value: parsed, valid: true, fractionDigits };
+}
+function validateLocalizedNumberEdit(text, localeId, options) {
+    if (text == null) {
+        return { valid: true, complete: false, value: null };
+    }
+    const raw = String(text);
+    if (raw === "") {
+        return { valid: true, complete: false, value: null };
+    }
+    // Reject control or whitespace characters in interactive typing
+    if (/[\s\u00A0\u202F]/.test(raw)) {
+        return { valid: false, complete: false, value: null };
+    }
+    const symbols = getNumberSymbols(localeId);
+    // Normalize minus signs and bidi controls
+    let normalized = normalizeLocalizedMinus(raw, symbols);
+    // Normalize localized digits to ASCII
+    normalized = normalizeLocalizedDigits(normalized, localeId);
+    // Sign handling
+    const allowSign = options?.allowSign ?? true;
+    if (normalized.startsWith("-") || normalized.startsWith("+")) {
+        if (!allowSign) {
+            return { valid: false, complete: false, value: null };
+        }
+        normalized = normalized.slice(1);
+    }
+    if (normalized.includes("-") || normalized.includes("+")) {
+        return { valid: false, complete: false, value: null };
+    }
+    // If input was just "-" or "+"
+    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(",");
+    }
+    // Count how many separators from the candidate set appear
+    let foundSep = null;
+    let sepIndex = -1;
+    for (let i = 0; i < normalized.length; i++) {
+        for (const sep of candidateSeparators) {
+            if (normalized.startsWith(sep, i)) {
+                if (foundSep !== null) {
+                    // More than one separator is rejected in edit mode
+                    return { valid: false, complete: false, value: null };
+                }
+                foundSep = sep;
+                sepIndex = i;
+                i += sep.length - 1;
+                break;
+            }
+        }
+    }
+    const decimals = options?.decimals ?? 0;
+    if (foundSep !== null) {
+        if (decimals === 0) {
+            // No decimal point permitted when decimals === 0
+            return { valid: false, complete: false, value: null };
+        }
+        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 };
+        }
+        // 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 };
+        }
+        // Count fraction digits using normalized ASCII characters (safe against UTF-16 astral splitting)
+        if (fracPart.length > decimals) {
+            return { valid: false, complete: false, value: null };
+        }
+        const parsed = parseLocalizedNumber(raw, localeId, { mode: "edit" });
+        const complete = fracPart.length > 0 && (intPart.length > 0 || fracPart.length > 0);
+        return {
+            valid: true,
+            complete,
+            value: parsed
+        };
+    }
+    // No separator found: must be purely ASCII digits
+    if (!/^\d+$/.test(normalized)) {
+        return { valid: false, complete: false, value: null };
+    }
+    const parsed = parseLocalizedNumber(raw, localeId, { mode: "edit" });
+    return {
+        valid: true,
+        complete: true,
+        value: parsed
+    };
+}
+
+/**
+ * Normalizes a locale string to ensure it uses the Gregorian calendar system
+ * and doesn't contain a conflicting -u-ca-* extension.
+ */
+function normalizeGregorianLocale(localeId) {
+    if (!localeId) {
+        return localeId;
+    }
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const loc = new Intl.Locale(localeId, { calendar: "gregory" });
+            return loc.toString();
+        }
+    }
+    catch {
+        // Fallback safely if localeId is malformed
+    }
+    return localeId;
+}
+/**
+ * Creates a Luxon DateTime from a Date instance, reconfigured to the specified locale
+ * with an explicit Gregorian output calendar.
+ */
+function gregorianDateTime(date, localeId) {
+    const locale = normalizeGregorianLocale(localeId);
+    return DateTime.fromJSDate(date).reconfigure({
+        locale,
+        outputCalendar: "gregory"
+    });
+}
+/**
+ * Creates a Luxon DateTime from object components (year, month, etc.), reconfigured to the
+ * specified locale with an explicit Gregorian output calendar.
+ */
+function gregorianDateTimeFromObject(obj, localeId) {
+    const locale = normalizeGregorianLocale(localeId);
+    return DateTime.fromObject(obj).reconfigure({
+        locale,
+        outputCalendar: "gregory"
+    });
+}
+/**
+ * Formats a date using locale-native token ordering and explicit Gregorian calendar.
+ */
+function formatGregorianDateToLocaleString(date, localeId, options) {
+    const locale = normalizeGregorianLocale(localeId);
+    return gregorianDateTime(date, locale).toLocaleString({
+        ...options
+    });
+}
+/**
+ * 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" });
+    if (!dt.isValid) {
+        const normalizedText = normalizeLocalizedDigits(text, locale);
+        let latnLocale = locale;
+        try {
+            if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+                latnLocale = new Intl.Locale(locale, { numberingSystem: "latn" }).toString();
+            }
+        }
+        catch {
+            // fallback
+        }
+        dt = DateTime.fromFormat(normalizedText, format, { locale: latnLocale, outputCalendar: "gregory" });
+        if (!dt.isValid) {
+            dt = DateTime.fromFormat(normalizedText, format, { locale, outputCalendar: "gregory" });
+        }
+    }
+    return dt;
+}
+
+const PSEUDO_MAP = {
+    a: "å",
+    b: "ƀ",
+    c: "ç",
+    d: "đ",
+    e: "é",
+    f: "ƒ",
+    g: "ĝ",
+    h: "ĥ",
+    i: "î",
+    j: "ĵ",
+    k: "ķ",
+    l: "ļ",
+    m: "m",
+    n: "ñ",
+    o: "ö",
+    p: "þ",
+    q: "q",
+    r: "ř",
+    s: "š",
+    t: "ţ",
+    u: "û",
+    v: "ṽ",
+    w: "ŵ",
+    x: "x",
+    y: "ŷ",
+    z: "ž",
+    A: "Å",
+    B: "Ɓ",
+    C: "Ç",
+    D: "Đ",
+    E: "É",
+    F: "Ƒ",
+    G: "Ĝ",
+    H: "Ĥ",
+    I: "Î",
+    J: "Ĵ",
+    K: "Ķ",
+    L: "Ļ",
+    M: "M",
+    N: "Ñ",
+    O: "Ö",
+    P: "Þ",
+    Q: "Q",
+    R: "Ř",
+    S: "Š",
+    T: "Ţ",
+    U: "Û",
+    V: "Ṽ",
+    W: "Ŵ",
+    X: "X",
+    Y: "Ŷ",
+    Z: "Ž"
+};
+/**
+ * Transforms a text string into pseudo-localized text (e.g. "Apply" -> "[!! Åþþļÿ~~ !!]").
+ * Tokens enclosed in single braces {placeholder}, double braces {{placeholder}}, or HTML tags <tag>
+ * are preserved verbatim so formatting / parameter substitution continues to function.
+ */
+function pseudoLocalize(text, options = {}) {
+    if (!text || typeof text !== "string") {
+        return text;
+    }
+    const { prefix = "[!! ", suffix = " !!]", expand = true, expansionFactor = 0.3 } = options;
+    if (text.startsWith(prefix) && text.endsWith(suffix)) {
+        return text;
+    }
+    // Preserve tokens like {0}, {name}, {{val}}, <span ...>, </b>
+    const tokens = text.split(/(\{[^{}]+\}|\{\{[^{}]+\}|<[^>]+>)/g);
+    const convertedTokens = tokens.map((segment, index) => {
+        // Odd indices match the split token regex
+        if (index % 2 === 1) {
+            return segment;
+        }
+        return segment
+            .split("")
+            .map(char => PSEUDO_MAP[char] ?? char)
+            .join("");
+    });
+    let transformed = convertedTokens.join("");
+    if (expand) {
+        const expansionLen = Math.max(1, Math.round(text.length * expansionFactor));
+        transformed += "~".repeat(expansionLen);
+    }
+    return `${prefix}${transformed}${suffix}`;
+}
+/**
+ * Recursively pseudo-localizes a message catalog or nested object of message catalogs.
+ * Plain strings are pseudo-localized, and message functions (e.g. (page: number) => string)
+ * are wrapped so their string outputs are pseudo-localized when invoked.
+ */
+function pseudoLocalizeCatalog(catalog, options) {
+    const result = {};
+    for (const [key, value] of Object.entries(catalog)) {
+        if (typeof value === "string") {
+            result[key] = pseudoLocalize(value, options);
+        }
+        else if (typeof value === "function") {
+            result[key] = (...args) => {
+                const out = value(...args);
+                return typeof out === "string" ? pseudoLocalize(out, options) : out;
+            };
+        }
+        else if (value && typeof value === "object" && !Array.isArray(value)) {
+            result[key] = pseudoLocalizeCatalog(value, options);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Generates a full pseudo-localized MonaLocale (e.g. en-XA) from a dictionary of message catalogs.
+ */
+function generatePseudoLocale(catalogs, options) {
+    const id = options?.id ?? "en-XA";
+    const direction = options?.direction ?? "ltr";
+    const pseudoOptions = options?.pseudoOptions;
+    const messages = {};
+    for (const [namespace, catalog] of Object.entries(catalogs)) {
+        if (catalog && typeof catalog === "object") {
+            messages[namespace] = pseudoLocalizeCatalog(catalog, pseudoOptions);
+        }
+    }
+    return {
+        direction,
+        id,
+        messages: messages
+    };
+}
+
+/*
+ * Public API Surface of @nanahoshi/mona-ui/i18n
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { MONA_DEFAULT_LOCALE, MONA_I18N_CONFIG, MonaDirectionService, MonaI18nService, formatGregorianDateToLocaleString, formatNumber, generatePseudoLocale, getNumberFormatter, getNumberGroupingPattern, getNumberSymbols, gregorianDateTime, gregorianDateTimeFromObject, injectComponentDirection, mergeMessages, mergeTwo, normalizeGregorianLocale, normalizeLocalizedDigits, normalizeLocalizedInput, normalizeLocalizedMinus, observeComponentDirection, parseGregorianDate, parseLocalizedNumber, provideMonaI18n, pseudoLocalize, pseudoLocalizeCatalog, resolveComponentDirection, validateLocalizedNumber, validateLocalizedNumberEdit };
+//# sourceMappingURL=nanahoshi-mona-ui-i18n.mjs.map