@nanahoshi/mona-ui 0.18.6 → 0.20.0

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

@@ -0,0 +1,4874 @@
+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 cleanLocale = (locale ?? "").trim() || "en-US";
+    const key = `${cleanLocale}:${serializeOptions(options)}`;
+    let formatter = numberFormatterCache.get(key);
+    if (!formatter) {
+        try {
+            formatter = new Intl.NumberFormat(cleanLocale, options);
+        }
+        catch {
+            formatter = new Intl.NumberFormat("en-US", 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) {
+    const trimmed = (localeId ?? "").trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const loc = new Intl.Locale(trimmed, { calendar: "gregory" });
+            return loc.toString();
+        }
+    }
+    catch {
+        // Fallback safely if localeId is malformed
+    }
+    return trimmed;
+}
+/**
+ * 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
+    });
+}
+/**
+ * Regular expression matching Unicode bidirectional formatting controls
+ * (such as LRM, RLM, ALM, embeddings, overrides, and isolates).
+ */
+const BIDI_CONTROL_REGEX = /[\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]/g;
+/**
+ * Strips Unicode bidirectional formatting controls from a string.
+ */
+function stripBidiControls(value) {
+    return value.replace(BIDI_CONTROL_REGEX, "");
+}
+/**
+ * Sanitizes date/time text by stripping invisible bidi controls and
+ * normalizing typographic/non-breaking spaces to standard ASCII spaces.
+ */
+function sanitizeDateText(value) {
+    return stripBidiControls(value).replace(/[\u00A0\u2009\u202F]/g, " ");
+}
+/**
+ * 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 sanitizedText = sanitizeDateText(text);
+        const sanitizedFormat = sanitizeDateText(format);
+        dt = DateTime.fromFormat(sanitizedText, sanitizedFormat, { locale, outputCalendar: "gregory" });
+        if (!dt.isValid) {
+            let normalizedText = normalizeLocalizedDigits(sanitizedText, 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, sanitizedFormat, { locale: latnLocale, outputCalendar: "gregory" });
+            if (!dt.isValid) {
+                dt = DateTime.fromFormat(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, {
+                        locale: effectiveLocale,
+                        outputCalendar: "gregory"
+                    });
+                    if (!dt.isValid && effectiveLocale !== locale) {
+                        dt = DateTime.fromFormat(textWithDotSpaces, sanitizedFormat, {
+                            locale,
+                            outputCalendar: "gregory"
+                        });
+                    }
+                    if (dt.isValid) {
+                        return dt;
+                    }
+                    normalizedText = textWithDotSpaces;
+                }
+                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, {
+                        locale: effectiveLocale,
+                        outputCalendar: "gregory"
+                    });
+                    if (!dt.isValid && effectiveLocale !== locale) {
+                        dt = DateTime.fromFormat(withDotBeforeTime, sanitizedFormat, {
+                            locale,
+                            outputCalendar: "gregory"
+                        });
+                    }
+                    if (dt.isValid) {
+                        return dt;
+                    }
+                }
+                const trimmedFormat = sanitizedFormat.trimEnd();
+                const trimmedText = normalizedText.trim();
+                if (trimmedFormat.endsWith(".")) {
+                    const textWithDot = trimmedText.endsWith(".") ? trimmedText : trimmedText + ".";
+                    dt = DateTime.fromFormat(textWithDot, trimmedFormat, {
+                        locale: effectiveLocale,
+                        outputCalendar: "gregory"
+                    });
+                    if (!dt.isValid && effectiveLocale !== locale) {
+                        dt = DateTime.fromFormat(textWithDot, trimmedFormat, {
+                            locale,
+                            outputCalendar: "gregory"
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return dt;
+}
+
+/**
+ * Pinned Unicode CLDR release: 46 / Unicode 16.0
+ * Sources:
+ *   - cldr-core/supplemental/weekData.json (weekData/firstDay)
+ *   - cldr-core/supplemental/likelySubtags.json
+ * Default territory ("001") is Monday.
+ * Generated by scripts/generate-cldr-week-data.ts from the pinned CLDR dataset.
+ * Update from the pinned CLDR dataset rather than editing ad hoc.
+ */
+const CLDR_WEEK_DATA_VERSION = "46";
+const CLDR_LIKELY_SUBTAGS_VERSION = "46";
+// Territories where firstDay is Friday (CLDR weekData/firstDay day="fri")
+const FRIDAY_FIRST_REGIONS = new Set([
+    "MV"
+]);
+// Territories where firstDay is Saturday (CLDR weekData/firstDay day="sat")
+const SATURDAY_FIRST_REGIONS = new Set([
+    "AF",
+    "BH",
+    "DJ",
+    "DZ",
+    "EG",
+    "IQ",
+    "IR",
+    "JO",
+    "KW",
+    "LY",
+    "OM",
+    "QA",
+    "SD",
+    "SY"
+]);
+// Territories where firstDay is Sunday (CLDR weekData/firstDay day="sun")
+const SUNDAY_FIRST_REGIONS = new Set([
+    "AG",
+    "AS",
+    "BD",
+    "BR",
+    "BS",
+    "BT",
+    "BW",
+    "BZ",
+    "CA",
+    "CO",
+    "DM",
+    "DO",
+    "ET",
+    "GT",
+    "GU",
+    "HK",
+    "HN",
+    "ID",
+    "IL",
+    "IN",
+    "JM",
+    "JP",
+    "KE",
+    "KH",
+    "KR",
+    "LA",
+    "MH",
+    "MM",
+    "MO",
+    "MT",
+    "MX",
+    "MZ",
+    "NI",
+    "NP",
+    "PA",
+    "PE",
+    "PH",
+    "PK",
+    "PR",
+    "PT",
+    "PY",
+    "SA",
+    "SG",
+    "SV",
+    "TH",
+    "TT",
+    "TW",
+    "UM",
+    "US",
+    "VE",
+    "VI",
+    "WS",
+    "YE",
+    "ZA",
+    "ZW"
+]);
+// Base language, undefined-language, and language-script tags whose CLDR likely territory is Friday-first
+const LIKELY_FRIDAY_FIRST_TAGS = new Set([
+    "dv",
+    "und-Diak",
+    "und-Thaa"
+]);
+// Base language, undefined-language, and language-script tags whose CLDR likely territory is Saturday-first
+const LIKELY_SATURDAY_FIRST_TAGS = new Set([
+    "aao",
+    "abv",
+    "acm",
+    "acx",
+    "acz",
+    "adf",
+    "ae",
+    "aec",
+    "aee",
+    "afb",
+    "aii",
+    "aiq",
+    "akk",
+    "amw",
+    "apc",
+    "ar",
+    "arc",
+    "arc-Hatr",
+    "arc-Nbat",
+    "arc-Palm",
+    "arq",
+    "arz",
+    "ask",
+    "atn",
+    "auj",
+    "avd",
+    "avl",
+    "ayl",
+    "ayp",
+    "az-Arab",
+    "azb",
+    "bdi",
+    "bej",
+    "bhm",
+    "bjm",
+    "bqi",
+    "brk",
+    "bsh",
+    "ckb",
+    "cop",
+    "daj",
+    "dec",
+    "def",
+    "dgl",
+    "dil",
+    "egy",
+    "esh",
+    "fa",
+    "fay",
+    "faz",
+    "fia",
+    "fvr",
+    "gbz",
+    "gha",
+    "glh",
+    "glk",
+    "gwt",
+    "gza",
+    "gzi",
+    "hac",
+    "haz",
+    "hbn",
+    "hoh",
+    "hrz",
+    "hss",
+    "isk",
+    "jat",
+    "jbn",
+    "jle",
+    "jum",
+    "kab",
+    "kcp",
+    "kcy",
+    "kec",
+    "keg",
+    "kfm",
+    "kgo",
+    "kho",
+    "kib",
+    "kko",
+    "klj",
+    "kmz",
+    "kqd",
+    "ktl",
+    "ku-Arab",
+    "lhs",
+    "liu",
+    "lki",
+    "lmd",
+    "lrc",
+    "lrl",
+    "lro",
+    "lsa",
+    "luv",
+    "luz",
+    "mhj",
+    "mid",
+    "mls",
+    "mnj",
+    "mor",
+    "myz",
+    "mzn",
+    "nli",
+    "ntz",
+    "nyi",
+    "nyq",
+    "oar",
+    "obm",
+    "otr",
+    "pal",
+    "pbt",
+    "peo",
+    "phv",
+    "prc",
+    "prd",
+    "ps",
+    "psh",
+    "psi",
+    "qxq",
+    "rdb",
+    "rmt",
+    "sdb",
+    "sdf",
+    "sdg",
+    "sdh",
+    "sgr",
+    "sgy",
+    "shj",
+    "shm",
+    "shv",
+    "shw",
+    "shy",
+    "siy",
+    "siz",
+    "smy",
+    "sqo",
+    "srz",
+    "sts",
+    "syn",
+    "syr",
+    "tag",
+    "taz",
+    "tbi",
+    "teq",
+    "tey",
+    "thv",
+    "tic",
+    "tjo",
+    "tks",
+    "tov",
+    "tra",
+    "trm",
+    "udu",
+    "uga",
+    "und-Arab",
+    "und-Armi",
+    "und-Avst",
+    "und-Copt",
+    "und-Egyp",
+    "und-Elym",
+    "und-Hatr",
+    "und-Mand",
+    "und-Merc",
+    "und-Mero",
+    "und-Nbat",
+    "und-Palm",
+    "und-Phli",
+    "und-Prti",
+    "und-Syrc",
+    "und-Ugar",
+    "und-Xpeo",
+    "und-Xsux",
+    "uz-Arab",
+    "uzs",
+    "vaf",
+    "vmh",
+    "wbk",
+    "wsv",
+    "xkc",
+    "xkj",
+    "xkp",
+    "xly",
+    "xmr",
+    "xnz",
+    "xom",
+    "xpr",
+    "xtc",
+    "xtq",
+    "xvi",
+    "zag",
+    "zmo",
+    "zum"
+]);
+// Base language, undefined-language, and language-script tags whose CLDR likely territory is Sunday-first
+const LIKELY_SUNDAY_FIRST_TAGS = new Set([
+    "aa",
+    "aaf",
+    "aan",
+    "aap",
+    "aaq",
+    "aax",
+    "aaz",
+    "abc",
+    "abd",
+    "abe",
+    "abl",
+    "abp",
+    "abs",
+    "abx",
+    "abz",
+    "aca",
+    "ace",
+    "acq",
+    "acr",
+    "acs",
+    "acv",
+    "acw",
+    "adi",
+    "adl",
+    "adn",
+    "adr",
+    "adw",
+    "aeq",
+    "af",
+    "afs",
+    "afz",
+    "aga",
+    "agf",
+    "agi",
+    "agj",
+    "agk",
+    "agn",
+    "agr",
+    "agt",
+    "agu",
+    "agv",
+    "agy",
+    "agz",
+    "ahg",
+    "ahh",
+    "ahk",
+    "aho",
+    "ahr",
+    "aht",
+    "aig",
+    "aij",
+    "aim",
+    "ain",
+    "aio",
+    "aip",
+    "air",
+    "ait",
+    "aiw",
+    "ajz",
+    "akb",
+    "akc",
+    "akg",
+    "akl",
+    "akz",
+    "ale",
+    "alj",
+    "alk",
+    "all",
+    "alo",
+    "alp",
+    "alq",
+    "alw",
+    "am",
+    "ama",
+    "amc",
+    "ame",
+    "amf",
+    "ami",
+    "amk",
+    "amq",
+    "amr",
+    "ams",
+    "amu",
+    "amv",
+    "ana",
+    "anb",
+    "and",
+    "anl",
+    "anm",
+    "ano",
+    "anp",
+    "anq",
+    "anr",
+    "ans",
+    "anu",
+    "aoc",
+    "aol",
+    "aos",
+    "aot",
+    "aoz",
+    "apf",
+    "apg",
+    "aph",
+    "api",
+    "apj",
+    "apk",
+    "apl",
+    "apm",
+    "apn",
+    "apt",
+    "apu",
+    "apv",
+    "apw",
+    "apx",
+    "apy",
+    "aqm",
+    "aqn",
+    "aqt",
+    "aqz",
+    "arh",
+    "ari",
+    "arj",
+    "ark",
+    "arl",
+    "arp",
+    "arr",
+    "ars",
+    "aru",
+    "arx",
+    "as",
+    "asb",
+    "asc",
+    "ase",
+    "ash",
+    "asi",
+    "asl",
+    "asn",
+    "asr",
+    "asu",
+    "asy",
+    "asz",
+    "atc",
+    "atd",
+    "atj",
+    "atk",
+    "atl",
+    "atm",
+    "atp",
+    "atq",
+    "atr",
+    "ats",
+    "att",
+    "atw",
+    "atx",
+    "atz",
+    "auq",
+    "auu",
+    "auw",
+    "avo",
+    "avs",
+    "avv",
+    "awa",
+    "awe",
+    "awh",
+    "awn",
+    "awr",
+    "aws",
+    "awt",
+    "awu",
+    "awv",
+    "awy",
+    "axg",
+    "ayc",
+    "ayh",
+    "ayn",
+    "ayo",
+    "ays",
+    "ayt",
+    "ayz",
+    "azd",
+    "azg",
+    "azm",
+    "azn",
+    "azt",
+    "azz",
+    "bac",
+    "bae",
+    "bah",
+    "baj",
+    "bal",
+    "ban",
+    "bao",
+    "bap",
+    "bap-Krai",
+    "bay",
+    "bbc",
+    "bcd",
+    "bcq",
+    "bcr",
+    "bdb",
+    "bdc",
+    "bdl",
+    "bdv",
+    "bdw",
+    "bdx",
+    "bdz",
+    "bea",
+    "bed",
+    "bee",
+    "bei",
+    "bep",
+    "beu",
+    "bew",
+    "bfb",
+    "bfe",
+    "bfg",
+    "bfq",
+    "bft",
+    "bfu",
+    "bfw",
+    "bfx",
+    "bfy",
+    "bfz",
+    "bgb",
+    "bgc",
+    "bgd",
+    "bgg",
+    "bgi",
+    "bgn",
+    "bgp",
+    "bgq",
+    "bgr",
+    "bgs",
+    "bgv",
+    "bgw",
+    "bgy",
+    "bgz",
+    "bha",
+    "bhb",
+    "bhc",
+    "bhd",
+    "bhe",
+    "bhh",
+    "bhi",
+    "bhj",
+    "bho",
+    "bhp",
+    "bhq",
+    "bht",
+    "bhu",
+    "bhv",
+    "bhw",
+    "bhz",
+    "bik",
+    "biu",
+    "biy",
+    "bjf",
+    "bji",
+    "bjj",
+    "bjn",
+    "bjx",
+    "bkd",
+    "bkk",
+    "bkl",
+    "bkn",
+    "bkq",
+    "bkr",
+    "bks",
+    "bku",
+    "bkz",
+    "bla",
+    "blc",
+    "bld",
+    "blf",
+    "blj",
+    "blk",
+    "bln",
+    "bls",
+    "blw",
+    "blx",
+    "blz",
+    "bmj",
+    "bmr",
+    "bn",
+    "bna",
+    "bnc",
+    "bnd",
+    "bne",
+    "bnf",
+    "bnj",
+    "bnn",
+    "bno",
+    "bnq",
+    "bns",
+    "bnu",
+    "bnv",
+    "boa",
+    "bob",
+    "bor",
+    "bpg",
+    "bpo",
+    "bpp",
+    "bpq",
+    "bpr",
+    "bps",
+    "bpv",
+    "bpx",
+    "bpy",
+    "bpz",
+    "bqb",
+    "bqq",
+    "bqr",
+    "bra",
+    "brb",
+    "brd",
+    "brh",
+    "brl",
+    "bro",
+    "brp",
+    "brs",
+    "brv",
+    "brw",
+    "brx",
+    "bsa",
+    "bsk",
+    "bsm",
+    "bsn",
+    "bst",
+    "bsu",
+    "bsw",
+    "btd",
+    "bti",
+    "btj",
+    "btm",
+    "btn",
+    "bto",
+    "bts",
+    "btv",
+    "btw",
+    "btx",
+    "bty",
+    "btz",
+    "bue",
+    "bug",
+    "bup",
+    "bve",
+    "bvk",
+    "bvt",
+    "bvu",
+    "bvv",
+    "bvy",
+    "bvz",
+    "bwe",
+    "bwg",
+    "bwi",
+    "bwo",
+    "bwp",
+    "bya",
+    "byd",
+    "byh",
+    "byl",
+    "byw",
+    "bzb",
+    "bzi",
+    "bzj",
+    "bzk",
+    "bzl",
+    "bzn",
+    "bzp",
+    "bzq",
+    "bzu",
+    "caa",
+    "cab",
+    "cac",
+    "cad",
+    "caf",
+    "cag",
+    "cah",
+    "cak",
+    "caq",
+    "car",
+    "cay",
+    "cbb",
+    "cbc",
+    "cbd",
+    "cbg",
+    "cbk",
+    "cbl",
+    "cbn",
+    "cbr",
+    "cbs",
+    "cbt",
+    "cbu",
+    "cbv",
+    "cbw",
+    "cby",
+    "ccc",
+    "ccd",
+    "cce",
+    "cco",
+    "ccp",
+    "ccr",
+    "cde",
+    "cdf",
+    "cdh",
+    "cdi",
+    "cdj",
+    "cdm",
+    "cdz",
+    "cea",
+    "ceb",
+    "ceg",
+    "cek",
+    "cey",
+    "cfm",
+    "cgc",
+    "cgk",
+    "ch",
+    "chb",
+    "chd",
+    "chf",
+    "chh",
+    "chj",
+    "chl",
+    "chn",
+    "cho",
+    "chp",
+    "chq",
+    "chr",
+    "cht",
+    "chw",
+    "chx",
+    "chy",
+    "chz",
+    "cia",
+    "cic",
+    "cih",
+    "cin",
+    "cip",
+    "ciw",
+    "ciy",
+    "cja",
+    "cjh",
+    "cjo",
+    "ckn",
+    "cku",
+    "ckv",
+    "ckz",
+    "clc",
+    "cle",
+    "clh",
+    "clj",
+    "clk",
+    "clm",
+    "clo",
+    "clt",
+    "clu",
+    "cly",
+    "cmi",
+    "cml",
+    "cmr",
+    "cmt",
+    "cna",
+    "cnb",
+    "cnh",
+    "cni",
+    "cnk",
+    "cnl",
+    "cns",
+    "cnt",
+    "cnw",
+    "cob",
+    "coc",
+    "cod",
+    "coe",
+    "cog",
+    "coh",
+    "coj",
+    "cok",
+    "col",
+    "com",
+    "coo",
+    "coq",
+    "cot",
+    "cox",
+    "coz",
+    "cpa",
+    "cpb",
+    "cpc",
+    "cps",
+    "cpu",
+    "cpy",
+    "cr",
+    "cra",
+    "crd",
+    "crf",
+    "crg",
+    "crj",
+    "crk",
+    "crl",
+    "crm",
+    "crn",
+    "cro",
+    "crv",
+    "crx",
+    "crz",
+    "csa",
+    "csh",
+    "csj",
+    "csm",
+    "cso",
+    "css",
+    "cst",
+    "csv",
+    "csw",
+    "csy",
+    "csz",
+    "cta",
+    "ctc",
+    "ctd",
+    "cte",
+    "ctg",
+    "cth",
+    "ctl",
+    "ctm",
+    "ctn",
+    "cto",
+    "ctp",
+    "cts",
+    "ctt",
+    "ctu",
+    "cty",
+    "ctz",
+    "cub",
+    "cuc",
+    "cuh",
+    "cui",
+    "cuj",
+    "cuk",
+    "cul",
+    "cuo",
+    "cup",
+    "cut",
+    "cux",
+    "cuy",
+    "cvg",
+    "cvn",
+    "cwb",
+    "cya",
+    "cyo",
+    "czn",
+    "czt",
+    "dak",
+    "dal",
+    "dao",
+    "daq",
+    "dav",
+    "daw",
+    "daz",
+    "dbe",
+    "dbf",
+    "dbn",
+    "dcc",
+    "dcr",
+    "ddw",
+    "deh",
+    "dei",
+    "del",
+    "dem",
+    "den",
+    "der",
+    "des",
+    "dgc",
+    "dgr",
+    "dhi",
+    "dhn",
+    "dho",
+    "dhw",
+    "dig",
+    "dih",
+    "dij",
+    "dis",
+    "diy",
+    "djo",
+    "dka",
+    "dkk",
+    "dln",
+    "dmk",
+    "dml",
+    "dmr",
+    "dms",
+    "dmu",
+    "dmx",
+    "dmy",
+    "dna",
+    "dni",
+    "dnk",
+    "dnt",
+    "dnu",
+    "dnv",
+    "dnw",
+    "dny",
+    "doi",
+    "dok",
+    "dov",
+    "dox",
+    "drc",
+    "dre",
+    "drn",
+    "drq",
+    "drs",
+    "dru",
+    "dry",
+    "dsh",
+    "dsn",
+    "dso",
+    "dtd",
+    "dty",
+    "dub",
+    "due",
+    "dug",
+    "duh",
+    "dul",
+    "dun",
+    "duo",
+    "dup",
+    "duq",
+    "dus",
+    "duv",
+    "duw",
+    "duy",
+    "dwk",
+    "dwr",
+    "dwz",
+    "dyg",
+    "dz",
+    "dzl",
+    "ebc",
+    "ebk",
+    "ebu",
+    "eip",
+    "ekg",
+    "ekl",
+    "eko",
+    "eky",
+    "elo",
+    "emb",
+    "emg",
+    "emm",
+    "emp",
+    "ems",
+    "emu",
+    "emw",
+    "en",
+    "enb",
+    "end",
+    "enl",
+    "eno",
+    "enr",
+    "enx",
+    "era",
+    "ert",
+    "erw",
+    "esg",
+    "esi",
+    "ess",
+    "esu",
+    "esy",
+    "etz",
+    "eud",
+    "eya",
+    "eyo",
+    "fau",
+    "fbl",
+    "fif",
+    "fil",
+    "fla",
+    "flh",
+    "fly",
+    "fmu",
+    "fng",
+    "fos",
+    "frc",
+    "frd",
+    "fun",
+    "gac",
+    "gad",
+    "gae",
+    "gak",
+    "gaq",
+    "gas",
+    "gau",
+    "gax",
+    "gay",
+    "gbi",
+    "gbj",
+    "gbk",
+    "gbl",
+    "gbm",
+    "gct",
+    "gdb",
+    "gdg",
+    "gdl",
+    "gdq",
+    "gdx",
+    "gef",
+    "geh",
+    "gei",
+    "ges",
+    "gez",
+    "ggg",
+    "ghe",
+    "ghk",
+    "ghr",
+    "ght",
+    "gic",
+    "gig",
+    "git",
+    "gjk",
+    "gju",
+    "gku",
+    "gmv",
+    "gn",
+    "gnb",
+    "gnk",
+    "gob",
+    "goe",
+    "gof",
+    "goj",
+    "gok",
+    "gon",
+    "gop",
+    "goq",
+    "gor",
+    "gqn",
+    "gra",
+    "grs",
+    "grt",
+    "gru",
+    "gta",
+    "gu",
+    "gub",
+    "guc",
+    "guh",
+    "guk",
+    "gul",
+    "gum",
+    "gun",
+    "guo",
+    "guq",
+    "guu",
+    "guz",
+    "gva",
+    "gvc",
+    "gvj",
+    "gvo",
+    "gvp",
+    "gvr",
+    "gwc",
+    "gwd",
+    "gwf",
+    "gwi",
+    "gwj",
+    "gyl",
+    "gym",
+    "gyo",
+    "gzn",
+    "haa",
+    "had",
+    "hae",
+    "hai",
+    "haj",
+    "hap",
+    "har",
+    "has",
+    "haw",
+    "hax",
+    "hbo",
+    "hch",
+    "hdy",
+    "he",
+    "heg",
+    "hei",
+    "hi",
+    "hib",
+    "hid",
+    "hii",
+    "hik",
+    "hil",
+    "hio",
+    "hir",
+    "hix",
+    "hji",
+    "hkh",
+    "hlb",
+    "hlt",
+    "hmr",
+    "hmu",
+    "hnd",
+    "hne",
+    "hnh",
+    "hnj",
+    "hnj-Hmng",
+    "hnn",
+    "hno",
+    "hoc",
+    "hoi",
+    "hoj",
+    "hop",
+    "hov",
+    "hoy",
+    "hpo",
+    "hra",
+    "hrk",
+    "hru",
+    "hrx",
+    "hti",
+    "hto",
+    "htu",
+    "hub",
+    "huc",
+    "hud",
+    "hue",
+    "hug",
+    "huk",
+    "hup",
+    "hur",
+    "hus",
+    "hut",
+    "huu",
+    "huv",
+    "huw",
+    "hux",
+    "huy",
+    "hve",
+    "hvn",
+    "hvv",
+    "hwc",
+    "ibg",
+    "ibl",
+    "ibu",
+    "icr",
+    "id",
+    "ida",
+    "idb",
+    "ifa",
+    "ifb",
+    "ifk",
+    "ifu",
+    "ify",
+    "ihb",
+    "ihp",
+    "ik",
+    "ikt",
+    "ila",
+    "ilk",
+    "ilo",
+    "ilp",
+    "ilu",
+    "iml",
+    "imr",
+    "in",
+    "inb",
+    "ing",
+    "inj",
+    "inn",
+    "inp",
+    "int",
+    "ior",
+    "iow",
+    "iqu",
+    "ire",
+    "irh",
+    "irn",
+    "iru",
+    "irx",
+    "iry",
+    "isc",
+    "isd",
+    "ism",
+    "itb",
+    "itd",
+    "iti",
+    "itt",
+    "itv",
+    "itx",
+    "ity",
+    "itz",
+    "iu",
+    "ivb",
+    "ivv",
+    "iw",
+    "iwk",
+    "iwo",
+    "ixc",
+    "ixl",
+    "ja",
+    "jaa",
+    "jac",
+    "jal",
+    "jam",
+    "jaq",
+    "jau",
+    "jax",
+    "jbe",
+    "jbj",
+    "jbr",
+    "jbt",
+    "jda",
+    "jdg",
+    "jeb",
+    "jee",
+    "jei",
+    "jel",
+    "jic",
+    "jje",
+    "jka",
+    "jkm",
+    "jmd",
+    "jml",
+    "jmn",
+    "jmx",
+    "jna",
+    "jnd",
+    "jnj",
+    "jnl",
+    "jns",
+    "jog",
+    "jpr",
+    "jqr",
+    "jrb",
+    "jru",
+    "jua",
+    "jul",
+    "jun",
+    "jup",
+    "jur",
+    "juy",
+    "jv",
+    "jvd",
+    "jw",
+    "jye",
+    "kac",
+    "kak",
+    "kam",
+    "kaq",
+    "kav",
+    "kaw",
+    "kax",
+    "kay",
+    "kbb",
+    "kbc",
+    "kbg",
+    "kbh",
+    "kbi",
+    "kbr",
+    "kbu",
+    "kbv",
+    "kcd",
+    "kck",
+    "kdn",
+    "kdq",
+    "kdt",
+    "kdw",
+    "kdy",
+    "kee",
+    "kei",
+    "kek",
+    "kev",
+    "kex",
+    "key",
+    "kfa",
+    "kfb",
+    "kfc",
+    "kfd",
+    "kfe",
+    "kff",
+    "kfg",
+    "kfh",
+    "kfi",
+    "kfk",
+    "kfp",
+    "kfq",
+    "kfr",
+    "kfs",
+    "kfu",
+    "kfv",
+    "kfw",
+    "kfx",
+    "kfy",
+    "kgb",
+    "kge",
+    "kgj",
+    "kgk",
+    "kgp",
+    "kgq",
+    "kgr",
+    "kgv",
+    "kgw",
+    "kgx",
+    "kgy",
+    "kha",
+    "khc",
+    "khd",
+    "khe",
+    "khf",
+    "khh",
+    "khn",
+    "khp",
+    "khr",
+    "kht",
+    "khw",
+    "ki",
+    "kic",
+    "kif",
+    "kig",
+    "kio",
+    "kip",
+    "kiq",
+    "kix",
+    "kiy",
+    "kja",
+    "kjb",
+    "kjc",
+    "kje",
+    "kjg",
+    "kjk",
+    "kjl",
+    "kjo",
+    "kjp",
+    "kjq",
+    "kjr",
+    "kjt",
+    "kju",
+    "kjz",
+    "kkb",
+    "kkf",
+    "kkg",
+    "kkh",
+    "kkl",
+    "kkt",
+    "kkv",
+    "kkx",
+    "kkz",
+    "kla",
+    "klb",
+    "kle",
+    "klg",
+    "kli",
+    "kll",
+    "kln",
+    "klr",
+    "kls",
+    "klw",
+    "kly",
+    "klz",
+    "km",
+    "kmd",
+    "kmj",
+    "kmk",
+    "kml",
+    "kmm",
+    "kmq",
+    "kmt",
+    "kmv",
+    "kn",
+    "knb",
+    "knd",
+    "kne",
+    "knj",
+    "knl",
+    "knm",
+    "knn",
+    "knt",
+    "knx",
+    "ko",
+    "kod",
+    "kog",
+    "kok",
+    "koy",
+    "kpc",
+    "kpd",
+    "kpi",
+    "kpj",
+    "kpn",
+    "kpq",
+    "kps",
+    "kpu",
+    "kqe",
+    "kqq",
+    "kqu",
+    "kqv",
+    "kqy",
+    "kqz",
+    "kra",
+    "krb",
+    "kre",
+    "krj",
+    "krr",
+    "kru",
+    "krv",
+    "krz",
+    "ks",
+    "ksc",
+    "ksk",
+    "ksn",
+    "ksu",
+    "ksw",
+    "ksx",
+    "ksz",
+    "ktb",
+    "kte",
+    "kti",
+    "ktn",
+    "ktq",
+    "kts",
+    "ktt",
+    "ktw",
+    "ktx",
+    "kuc",
+    "kuf",
+    "kui",
+    "kuk",
+    "kuq",
+    "kut",
+    "kuu",
+    "kuv",
+    "kvb",
+    "kvd",
+    "kvh",
+    "kvl",
+    "kvn",
+    "kvo",
+    "kvp",
+    "kvq",
+    "kvr",
+    "kvt",
+    "kvv",
+    "kvw",
+    "kvx",
+    "kvy",
+    "kvz",
+    "kwa",
+    "kwe",
+    "kwh",
+    "kwi",
+    "kwk",
+    "kwr",
+    "kwt",
+    "kxc",
+    "kxf",
+    "kxk",
+    "kxm",
+    "kxo",
+    "kxp",
+    "kxq",
+    "kxv",
+    "kyb",
+    "kyd",
+    "kyh",
+    "kyj",
+    "kyk",
+    "kyl",
+    "kyn",
+    "kyo",
+    "kyr",
+    "kyt",
+    "kyu",
+    "kyv",
+    "kyw",
+    "kyz",
+    "kzb",
+    "kzd",
+    "kzf",
+    "kzl",
+    "kzm",
+    "kzp",
+    "kzu",
+    "kzv",
+    "kzw",
+    "kzx",
+    "kzz",
+    "laa",
+    "lac",
+    "lad",
+    "lae",
+    "lah",
+    "lau",
+    "law",
+    "lax",
+    "lbf",
+    "lbj",
+    "lbl",
+    "lbm",
+    "lbn",
+    "lbo",
+    "lbr",
+    "lbw",
+    "lbx",
+    "lcc",
+    "lcd",
+    "lce",
+    "lcf",
+    "lcl",
+    "lcq",
+    "lcs",
+    "len",
+    "lep",
+    "lev",
+    "lew",
+    "lex",
+    "ley",
+    "lgi",
+    "lgn",
+    "lhh",
+    "lhm",
+    "lif",
+    "lif-Limb",
+    "lil",
+    "lio",
+    "liq",
+    "liw",
+    "lix",
+    "lje",
+    "lji",
+    "ljl",
+    "ljp",
+    "lkb",
+    "lkd",
+    "lkh",
+    "lko",
+    "lks",
+    "lkt",
+    "llb",
+    "llg",
+    "llm",
+    "llq",
+    "lmf",
+    "lmh",
+    "lmj",
+    "lmk",
+    "lmn",
+    "lmq",
+    "lmr",
+    "lmw",
+    "lmy",
+    "lnd",
+    "lo",
+    "loa",
+    "loc",
+    "loe",
+    "lou",
+    "lox",
+    "loy",
+    "lpe",
+    "lpn",
+    "lri",
+    "lrk",
+    "lrm",
+    "lrn",
+    "lrt",
+    "lsd",
+    "lsi",
+    "lss",
+    "lti",
+    "ltn",
+    "lto",
+    "lts",
+    "ltu",
+    "lui",
+    "luk",
+    "luo",
+    "lur",
+    "lus",
+    "lut",
+    "luu",
+    "luy",
+    "lvi",
+    "lvu",
+    "lwe",
+    "lwg",
+    "lwl",
+    "lwt",
+    "lya",
+    "lzn",
+    "maa",
+    "mab",
+    "mad",
+    "mag",
+    "mai",
+    "maj",
+    "mak",
+    "mam",
+    "maq",
+    "mas",
+    "mat",
+    "mau",
+    "mav",
+    "max",
+    "maz",
+    "mba",
+    "mbb",
+    "mbc",
+    "mbd",
+    "mbf",
+    "mbi",
+    "mbj",
+    "mbl",
+    "mbn",
+    "mbp",
+    "mbr",
+    "mbs",
+    "mbt",
+    "mby",
+    "mbz",
+    "mca",
+    "mcb",
+    "mcd",
+    "mce",
+    "mcf",
+    "mcg",
+    "mch",
+    "mcl",
+    "mco",
+    "mdh",
+    "mdr",
+    "mdv",
+    "mdx",
+    "mdy",
+    "mdz",
+    "meh",
+    "mej",
+    "mer",
+    "mez",
+    "mfa",
+    "mfb",
+    "mfp",
+    "mfx",
+    "mfy",
+    "mgf",
+    "mgh",
+    "mgk",
+    "mgp",
+    "mh",
+    "mhc",
+    "mhm",
+    "mhp",
+    "mhq",
+    "mhs",
+    "mht",
+    "mhu",
+    "mhw",
+    "mhx",
+    "mhy",
+    "mhz",
+    "mia",
+    "mib",
+    "mic",
+    "mie",
+    "mig",
+    "mih",
+    "mii",
+    "mik",
+    "mil",
+    "mim",
+    "min",
+    "mio",
+    "mip",
+    "miq",
+    "mir",
+    "mit",
+    "miu",
+    "mix",
+    "miy",
+    "miz",
+    "mjc",
+    "mjd",
+    "mjl",
+    "mjq",
+    "mjr",
+    "mjt",
+    "mju",
+    "mjv",
+    "mjw",
+    "mjx",
+    "mjy",
+    "mjz",
+    "mkb",
+    "mke",
+    "mki",
+    "mkm",
+    "mkn",
+    "mks",
+    "mkx",
+    "mky",
+    "ml",
+    "mlf",
+    "mli",
+    "mlk",
+    "mlz",
+    "mmb",
+    "mmc",
+    "mmh",
+    "mmn",
+    "mmv",
+    "mnb",
+    "mnd",
+    "mni",
+    "mnr",
+    "mnu",
+    "mnw",
+    "mnx",
+    "mny",
+    "mnz",
+    "mod",
+    "moe",
+    "mog",
+    "moh",
+    "mok",
+    "mom",
+    "mop",
+    "moq",
+    "mot",
+    "mov",
+    "moy",
+    "mpd",
+    "mpe",
+    "mpm",
+    "mpq",
+    "mpu",
+    "mpw",
+    "mpy",
+    "mpz",
+    "mqa",
+    "mqc",
+    "mqf",
+    "mqg",
+    "mqh",
+    "mqi",
+    "mqj",
+    "mqk",
+    "mqn",
+    "mqo",
+    "mqp",
+    "mqr",
+    "mqs",
+    "mqx",
+    "mqy",
+    "mr",
+    "mra",
+    "mrc",
+    "mrd",
+    "mrf",
+    "mrg",
+    "mrh",
+    "mro",
+    "mrr",
+    "mrw",
+    "mrx",
+    "mry",
+    "mrz",
+    "msb",
+    "msf",
+    "msg",
+    "msk",
+    "msl",
+    "msm",
+    "mso",
+    "msp",
+    "mss",
+    "mt",
+    "mta",
+    "mtd",
+    "mtg",
+    "mth",
+    "mtj",
+    "mtn",
+    "mto",
+    "mtr",
+    "mts",
+    "mtu",
+    "mtw",
+    "mtx",
+    "mui",
+    "muk",
+    "mus",
+    "mut",
+    "muu",
+    "muv",
+    "muz",
+    "mvd",
+    "mve",
+    "mvg",
+    "mvp",
+    "mvr",
+    "mvs",
+    "mvx",
+    "mvy",
+    "mvz",
+    "mwl",
+    "mwq",
+    "mwr",
+    "mws",
+    "mwt",
+    "mwv",
+    "mww",
+    "mxa",
+    "mxb",
+    "mxc",
+    "mxd",
+    "mxj",
+    "mxn",
+    "mxp",
+    "mxq",
+    "mxs",
+    "mxt",
+    "mxv",
+    "mxy",
+    "mxz",
+    "my",
+    "myf",
+    "myh",
+    "myl",
+    "mym",
+    "myp",
+    "myr",
+    "myu",
+    "myy",
+    "mza",
+    "mzi",
+    "mzl",
+    "mzo",
+    "mzq",
+    "mzr",
+    "naa",
+    "nab",
+    "nae",
+    "nag",
+    "nao",
+    "naz",
+    "nbc",
+    "nbe",
+    "nbi",
+    "nbn",
+    "nbq",
+    "nbt",
+    "nbu",
+    "ncb",
+    "ncd",
+    "ncg",
+    "nch",
+    "nci",
+    "ncj",
+    "ncl",
+    "ncq",
+    "nct",
+    "ncx",
+    "ncz",
+    "nd",
+    "ndc",
+    "ndx",
+    "ne",
+    "nea",
+    "nec",
+    "neh",
+    "neq",
+    "ner",
+    "new",
+    "nez",
+    "nfa",
+    "ngh",
+    "ngl",
+    "ngt",
+    "ngu",
+    "nhc",
+    "nhd",
+    "nhe",
+    "nhg",
+    "nhi",
+    "nhk",
+    "nhm",
+    "nhn",
+    "nhp",
+    "nhq",
+    "nhr",
+    "nht",
+    "nhv",
+    "nhw",
+    "nhx",
+    "nhy",
+    "nhz",
+    "nia",
+    "nij",
+    "nil",
+    "niq",
+    "nir",
+    "nit",
+    "njb",
+    "njh",
+    "njm",
+    "njn",
+    "njo",
+    "njs",
+    "njz",
+    "nkb",
+    "nkd",
+    "nkf",
+    "nkh",
+    "nki",
+    "nkj",
+    "nks",
+    "nlc",
+    "nle",
+    "nlk",
+    "nlm",
+    "nlq",
+    "nlv",
+    "nlx",
+    "nma",
+    "nme",
+    "nmf",
+    "nmh",
+    "nmm",
+    "nmn",
+    "nmo",
+    "nmq",
+    "nmu",
+    "nng",
+    "nni",
+    "nnj",
+    "nnl",
+    "nnp",
+    "nnt",
+    "noa",
+    "nod",
+    "noe",
+    "noi",
+    "noj",
+    "nok",
+    "not",
+    "npb",
+    "npg",
+    "nph",
+    "npl",
+    "npo",
+    "nps",
+    "npu",
+    "npy",
+    "nqm",
+    "nqq",
+    "nqy",
+    "nr",
+    "nre",
+    "nri",
+    "nsa",
+    "nsb",
+    "nsk",
+    "nsm",
+    "nso",
+    "nsq",
+    "nst",
+    "nsu",
+    "nsy",
+    "nsz",
+    "nte",
+    "ntp",
+    "ntx",
+    "nuc",
+    "nuk",
+    "nun",
+    "nuz",
+    "nv",
+    "nwc",
+    "nwx",
+    "nxe",
+    "nxg",
+    "nxl",
+    "nxx",
+    "nyd",
+    "nyf",
+    "nyl",
+    "nyu",
+    "nyw",
+    "nzm",
+    "obi",
+    "obk",
+    "obo",
+    "obr",
+    "oca",
+    "ocu",
+    "odk",
+    "oia",
+    "oj",
+    "ojb",
+    "ojc",
+    "ojs",
+    "ojw",
+    "oka",
+    "oki",
+    "okm",
+    "oko",
+    "okz",
+    "ola",
+    "ole",
+    "om",
+    "oma",
+    "omc",
+    "omg",
+    "omp",
+    "omr",
+    "omt",
+    "omu",
+    "omx",
+    "one",
+    "oni",
+    "ono",
+    "onp",
+    "onx",
+    "ood",
+    "oon",
+    "oor",
+    "opk",
+    "opt",
+    "opy",
+    "or",
+    "orc",
+    "ore",
+    "ort",
+    "oru",
+    "orw",
+    "orz",
+    "osa",
+    "osi",
+    "otd",
+    "ote",
+    "oti",
+    "otl",
+    "otm",
+    "otn",
+    "otq",
+    "ots",
+    "ott",
+    "otu",
+    "otw",
+    "otx",
+    "oty",
+    "otz",
+    "oyd",
+    "oym",
+    "pa",
+    "pa-Arab",
+    "pab",
+    "pad",
+    "paf",
+    "pag",
+    "pah",
+    "pak",
+    "pam",
+    "pao",
+    "par",
+    "pas",
+    "pav",
+    "paw",
+    "pax",
+    "pay",
+    "paz",
+    "pbb",
+    "pbe",
+    "pbf",
+    "pbg",
+    "pbh",
+    "pbm",
+    "pbs",
+    "pbv",
+    "pca",
+    "pcb",
+    "pce",
+    "pcf",
+    "pcg",
+    "pch",
+    "pci",
+    "pcj",
+    "pck",
+    "pdc",
+    "pdn",
+    "pdo",
+    "pdt",
+    "pdu",
+    "pea",
+    "peb",
+    "pee",
+    "peg",
+    "pei",
+    "pel",
+    "peq",
+    "pev",
+    "pey",
+    "pgd",
+    "pgg",
+    "pgu",
+    "phd",
+    "phk",
+    "phl",
+    "phm",
+    "pho",
+    "phr",
+    "pht",
+    "phu",
+    "phw",
+    "pi",
+    "pia",
+    "pib",
+    "pid",
+    "pig",
+    "pij",
+    "pim",
+    "pio",
+    "pir",
+    "pka",
+    "pkb",
+    "pkh",
+    "pko",
+    "pkr",
+    "pku",
+    "plc",
+    "ple",
+    "plh",
+    "plk",
+    "pll",
+    "pln",
+    "plo",
+    "pls",
+    "plu",
+    "plv",
+    "plw",
+    "pmf",
+    "pmh",
+    "pmo",
+    "pmq",
+    "pmw",
+    "pmx",
+    "pmy",
+    "pmz",
+    "pnc",
+    "pni",
+    "pno",
+    "pnp",
+    "pns",
+    "poc",
+    "poe",
+    "pog",
+    "poh",
+    "poi",
+    "pok",
+    "pom",
+    "poo",
+    "poq",
+    "pos",
+    "pot",
+    "pow",
+    "ppi",
+    "ppk",
+    "ppl",
+    "ppm",
+    "pps",
+    "pqm",
+    "pra",
+    "prf",
+    "prh",
+    "prk",
+    "prq",
+    "prr",
+    "prt",
+    "pru",
+    "prx",
+    "psa",
+    "pse",
+    "psn",
+    "pst",
+    "psu",
+    "pt",
+    "pta",
+    "pth",
+    "ptn",
+    "pto",
+    "ptt",
+    "ptu",
+    "pua",
+    "pub",
+    "puc",
+    "pud",
+    "puf",
+    "pui",
+    "puj",
+    "pum",
+    "pur",
+    "put",
+    "puy",
+    "pwm",
+    "pwn",
+    "pwo",
+    "pwr",
+    "pww",
+    "pxm",
+    "pyn",
+    "pyu",
+    "pyx",
+    "pyy",
+    "pzh",
+    "pzn",
+    "qu",
+    "qua",
+    "qub",
+    "quc",
+    "quf",
+    "qui",
+    "quk",
+    "qum",
+    "qun",
+    "qup",
+    "qur",
+    "quv",
+    "qux",
+    "quy",
+    "qva",
+    "qvc",
+    "qve",
+    "qvh",
+    "qvl",
+    "qvm",
+    "qvn",
+    "qvo",
+    "qvp",
+    "qvs",
+    "qvw",
+    "qwa",
+    "qwc",
+    "qwh",
+    "qws",
+    "qwt",
+    "qxa",
+    "qxc",
+    "qxh",
+    "qxn",
+    "qxo",
+    "qxp",
+    "qxt",
+    "qxu",
+    "qxw",
+    "qyp",
+    "raa",
+    "rab",
+    "rac",
+    "raf",
+    "rag",
+    "rah",
+    "raj",
+    "ram",
+    "ran",
+    "rav",
+    "raw",
+    "raz",
+    "rbb",
+    "rbk",
+    "rbl",
+    "reb",
+    "rei",
+    "rej",
+    "rel",
+    "rem",
+    "ret",
+    "rgr",
+    "rgu",
+    "rhg",
+    "ria",
+    "ril",
+    "rir",
+    "riu",
+    "rjg",
+    "rji",
+    "rjs",
+    "rka",
+    "rkb",
+    "rki",
+    "rkt",
+    "rma",
+    "rmh",
+    "rmm",
+    "rmz",
+    "rng",
+    "rnl",
+    "rnn",
+    "rob",
+    "rol",
+    "ror",
+    "row",
+    "rtc",
+    "rth",
+    "rtw",
+    "rwr",
+    "ryu",
+    "sa",
+    "sab",
+    "sac",
+    "sae",
+    "saj",
+    "sao",
+    "saq",
+    "sas",
+    "sat",
+    "sau",
+    "saw",
+    "saz",
+    "sbg",
+    "sbl",
+    "sbn",
+    "sbr",
+    "sbt",
+    "sbu",
+    "sbx",
+    "scf",
+    "scg",
+    "sch",
+    "sck",
+    "scl",
+    "scp",
+    "scs",
+    "sct",
+    "scu",
+    "sd",
+    "sd-Deva",
+    "sd-Khoj",
+    "sd-Sind",
+    "sda",
+    "sdq",
+    "sdr",
+    "sdu",
+    "sec",
+    "see",
+    "seh",
+    "sei",
+    "sek",
+    "ser",
+    "set",
+    "seu",
+    "sez",
+    "sfe",
+    "sgb",
+    "sgc",
+    "sgd",
+    "sge",
+    "sgj",
+    "sgm",
+    "sgp",
+    "sgt",
+    "sgu",
+    "sgw",
+    "shb",
+    "shd",
+    "she",
+    "shg",
+    "shh",
+    "shn",
+    "shp",
+    "shs",
+    "sht",
+    "sid",
+    "sii",
+    "sik",
+    "sip",
+    "sis",
+    "sja",
+    "sjb",
+    "sjl",
+    "sjm",
+    "sjp",
+    "sjw",
+    "ska",
+    "skb",
+    "skd",
+    "skf",
+    "skh",
+    "ski",
+    "skj",
+    "skn",
+    "sko",
+    "skr",
+    "skv",
+    "skx",
+    "skz",
+    "slc",
+    "slg",
+    "slh",
+    "slj",
+    "slm",
+    "sln",
+    "slp",
+    "slu",
+    "sly",
+    "slz",
+    "sm",
+    "smk",
+    "sml",
+    "smp",
+    "smr",
+    "smt",
+    "smu",
+    "smw",
+    "sn",
+    "sni",
+    "snl",
+    "snn",
+    "sno",
+    "snu",
+    "soa",
+    "sob",
+    "soi",
+    "sou",
+    "spb",
+    "spc",
+    "spi",
+    "spn",
+    "spo",
+    "spq",
+    "spr",
+    "spt",
+    "spv",
+    "sqq",
+    "sqt",
+    "squ",
+    "srb",
+    "sre",
+    "srg",
+    "sri",
+    "srl",
+    "srs",
+    "srt",
+    "sru",
+    "srv",
+    "srw",
+    "srx",
+    "ss",
+    "ssb",
+    "sse",
+    "ssf",
+    "ssn",
+    "ssq",
+    "sss",
+    "st",
+    "stb",
+    "ste",
+    "sto",
+    "stp",
+    "str",
+    "stv",
+    "su",
+    "suc",
+    "suq",
+    "sut",
+    "suv",
+    "suy",
+    "suz",
+    "sve",
+    "swo",
+    "swr",
+    "sws",
+    "swt",
+    "swu",
+    "swv",
+    "swx",
+    "sxb",
+    "sxn",
+    "sxr",
+    "sya",
+    "syb",
+    "syl",
+    "syo",
+    "syw",
+    "szb",
+    "szn",
+    "szp",
+    "szw",
+    "szy",
+    "ta",
+    "taa",
+    "tac",
+    "tad",
+    "tae",
+    "taf",
+    "taj",
+    "tao",
+    "tar",
+    "tau",
+    "tav",
+    "tay",
+    "tba",
+    "tbk",
+    "tbl",
+    "tbn",
+    "tbp",
+    "tbu",
+    "tbw",
+    "tby",
+    "tca",
+    "tcb",
+    "tce",
+    "tcf",
+    "tcg",
+    "tcm",
+    "tcn",
+    "tco",
+    "tcp",
+    "tcq",
+    "tcu",
+    "tcw",
+    "tcx",
+    "tcy",
+    "tcz",
+    "tdb",
+    "tdc",
+    "tdg",
+    "tdh",
+    "tdi",
+    "tdj",
+    "tdn",
+    "tds",
+    "tdy",
+    "te",
+    "tec",
+    "tee",
+    "ten",
+    "tep",
+    "ter",
+    "tes",
+    "tev",
+    "tew",
+    "tfn",
+    "tfo",
+    "tfr",
+    "tft",
+    "tg-Arab",
+    "tga",
+    "tge",
+    "tgf",
+    "tgh",
+    "tgj",
+    "tgn",
+    "tgt",
+    "tgv",
+    "tgx",
+    "th",
+    "the",
+    "thf",
+    "thh",
+    "thi",
+    "thk",
+    "thl",
+    "thm",
+    "thp",
+    "thq",
+    "thr",
+    "ths",
+    "tht",
+    "ti",
+    "tij",
+    "til",
+    "tip",
+    "tis",
+    "tit",
+    "tiu",
+    "tix",
+    "tiy",
+    "tjg",
+    "tjl",
+    "tka",
+    "tkb",
+    "tke",
+    "tkf",
+    "tkt",
+    "tku",
+    "tkx",
+    "tl",
+    "tla",
+    "tlb",
+    "tlc",
+    "tld",
+    "tlg",
+    "tli",
+    "tlk",
+    "tln",
+    "tlp",
+    "tlq",
+    "tlt",
+    "tlu",
+    "tlv",
+    "tme",
+    "tmf",
+    "tmg",
+    "tmj",
+    "tml",
+    "tmn",
+    "tmr",
+    "tmu",
+    "tmz",
+    "tn",
+    "tnb",
+    "tnc",
+    "tnd",
+    "tni",
+    "tnm",
+    "tnq",
+    "tnt",
+    "tnv",
+    "tnw",
+    "toc",
+    "toh",
+    "toj",
+    "tol",
+    "tom",
+    "too",
+    "top",
+    "tos",
+    "tow",
+    "toy",
+    "tpc",
+    "tpe",
+    "tpf",
+    "tpg",
+    "tpj",
+    "tpk",
+    "tpl",
+    "tpn",
+    "tpp",
+    "tpr",
+    "tpt",
+    "tpu",
+    "tpx",
+    "tpy",
+    "tqb",
+    "tqn",
+    "tqt",
+    "tqw",
+    "trc",
+    "tre",
+    "trf",
+    "trg",
+    "tro",
+    "trp",
+    "trq",
+    "trr",
+    "trs",
+    "trt",
+    "trv",
+    "trw",
+    "try",
+    "trz",
+    "ts",
+    "tsb",
+    "tsc",
+    "tsg",
+    "tsi",
+    "tsj",
+    "tsu",
+    "tsz",
+    "ttc",
+    "tth",
+    "tti",
+    "ttk",
+    "ttm",
+    "ttn",
+    "tto",
+    "ttp",
+    "tts",
+    "tty",
+    "ttz",
+    "tub",
+    "tud",
+    "tue",
+    "tuf",
+    "tuj",
+    "tun",
+    "tuo",
+    "tus",
+    "tuu",
+    "tuv",
+    "tux",
+    "tuy",
+    "tve",
+    "tvm",
+    "tvn",
+    "tvo",
+    "tvs",
+    "tvt",
+    "tvw",
+    "tvx",
+    "twa",
+    "twb",
+    "twe",
+    "twf",
+    "twg",
+    "twl",
+    "twm",
+    "two",
+    "twr",
+    "twt",
+    "twu",
+    "twx",
+    "twy",
+    "txe",
+    "txi",
+    "txm",
+    "txn",
+    "txo",
+    "txq",
+    "txs",
+    "txt",
+    "txu",
+    "tyn",
+    "tyu",
+    "tzh",
+    "tzj",
+    "tzn",
+    "tzo",
+    "uam",
+    "ubl",
+    "udg",
+    "udj",
+    "ues",
+    "ugo",
+    "uhn",
+    "uka",
+    "uki",
+    "ukk",
+    "ulf",
+    "ulm",
+    "ulu",
+    "ulw",
+    "uma",
+    "umn",
+    "umo",
+    "ums",
+    "und",
+    "und-Ahom",
+    "und-Bali",
+    "und-Batk",
+    "und-Beng",
+    "und-Bhks",
+    "und-Bopo",
+    "und-Brah",
+    "und-Bugi",
+    "und-Buhd",
+    "und-Cakm",
+    "und-Cans",
+    "und-Cher",
+    "und-Deva",
+    "und-Dogr",
+    "und-Ethi",
+    "und-Gong",
+    "und-Gonm",
+    "und-Gran",
+    "und-Gujr",
+    "und-Gukh",
+    "und-Guru",
+    "und-Hanb",
+    "und-Hang",
+    "und-Hano",
+    "und-Hant",
+    "und-Hebr",
+    "und-Hira",
+    "und-Hmng",
+    "und-Hmnp",
+    "und-Jamo",
+    "und-Java",
+    "und-Jpan",
+    "und-Kali",
+    "und-Kana",
+    "und-Kawi",
+    "und-Khar",
+    "und-Khmr",
+    "und-Khoj",
+    "und-Knda",
+    "und-Kore",
+    "und-Krai",
+    "und-Kthi",
+    "und-Lana",
+    "und-Laoo",
+    "und-Latf",
+    "und-Latg",
+    "und-Latn",
+    "und-Lepc",
+    "und-Limb",
+    "und-Mahj",
+    "und-Maka",
+    "und-Mlym",
+    "und-Modi",
+    "und-Mroo",
+    "und-Mtei",
+    "und-Mult",
+    "und-Mymr",
+    "und-Nagm",
+    "und-Nand",
+    "und-Narb",
+    "und-Newa",
+    "und-Olck",
+    "und-Onao",
+    "und-Orya",
+    "und-Osge",
+    "und-Pauc",
+    "und-Rjng",
+    "und-Rohg",
+    "und-Samr",
+    "und-Sarb",
+    "und-Saur",
+    "und-Sgnw",
+    "und-Shrd",
+    "und-Sidd",
+    "und-Sind",
+    "und-Sora",
+    "und-Sund",
+    "und-Sunu",
+    "und-Sylo",
+    "und-Tagb",
+    "und-Takr",
+    "und-Taml",
+    "und-Telu",
+    "und-Tglg",
+    "und-Thai",
+    "und-Tirh",
+    "und-Tnsa",
+    "und-Toto",
+    "und-Tutg",
+    "und-Wara",
+    "und-Wcho",
+    "unk",
+    "unm",
+    "unr",
+    "unr-Deva",
+    "unx",
+    "unz",
+    "uon",
+    "ur",
+    "ura",
+    "urb",
+    "urk",
+    "urn",
+    "urp",
+    "uru",
+    "ury",
+    "urz",
+    "ush",
+    "usi",
+    "usp",
+    "ute",
+    "vaa",
+    "vah",
+    "vap",
+    "var",
+    "vas",
+    "vav",
+    "vay",
+    "vbb",
+    "vbk",
+    "ve",
+    "veo",
+    "vgr",
+    "vjk",
+    "vkk",
+    "vkl",
+    "vkm",
+    "vko",
+    "vkp",
+    "vkt",
+    "vmc",
+    "vmd",
+    "vme",
+    "vmj",
+    "vmk",
+    "vmm",
+    "vmp",
+    "vmq",
+    "vmr",
+    "vms",
+    "vmw",
+    "vmx",
+    "vmy",
+    "vmz",
+    "vto",
+    "waa",
+    "wac",
+    "wad",
+    "waf",
+    "wah",
+    "wai",
+    "wal",
+    "wam",
+    "war",
+    "was",
+    "wau",
+    "waw",
+    "wba",
+    "wbb",
+    "wbe",
+    "wbl",
+    "wbq",
+    "wbr",
+    "wbw",
+    "wca",
+    "wdt",
+    "weo",
+    "wet",
+    "weu",
+    "wew",
+    "wfg",
+    "wgo",
+    "wha",
+    "whk",
+    "whu",
+    "wic",
+    "win",
+    "wir",
+    "wiy",
+    "wkd",
+    "wle",
+    "wli",
+    "wlo",
+    "wlw",
+    "wmd",
+    "wme",
+    "wmm",
+    "wms",
+    "wmw",
+    "wne",
+    "wng",
+    "wnk",
+    "wno",
+    "wnw",
+    "wod",
+    "woi",
+    "woo",
+    "wor",
+    "wow",
+    "wpc",
+    "wrp",
+    "wru",
+    "wrx",
+    "wsa",
+    "wsg",
+    "wsu",
+    "wti",
+    "wtm",
+    "wtw",
+    "wul",
+    "wuy",
+    "wyn",
+    "wyr",
+    "xai",
+    "xaj",
+    "xak",
+    "xam",
+    "xan",
+    "xat",
+    "xau",
+    "xav",
+    "xaw",
+    "xay",
+    "xbr",
+    "xbw",
+    "xch",
+    "xdy",
+    "xeg",
+    "xem",
+    "xer",
+    "xet",
+    "xh",
+    "xhe",
+    "xhm",
+    "xii",
+    "xin",
+    "xir",
+    "xis",
+    "xiy",
+    "xka",
+    "xkd",
+    "xke",
+    "xkf",
+    "xkl",
+    "xkn",
+    "xkq",
+    "xkr",
+    "xks",
+    "xkv",
+    "xkw",
+    "xkz",
+    "xmc",
+    "xmm",
+    "xmo",
+    "xmt",
+    "xmx",
+    "xmz",
+    "xna",
+    "xnb",
+    "xnn",
+    "xnq",
+    "xnr",
+    "xnt",
+    "xod",
+    "xok",
+    "xoo",
+    "xor",
+    "xpk",
+    "xpn",
+    "xpo",
+    "xpq",
+    "xra",
+    "xre",
+    "xri",
+    "xsa",
+    "xsb",
+    "xse",
+    "xsq",
+    "xsr",
+    "xsu",
+    "xsy",
+    "xta",
+    "xtb",
+    "xtd",
+    "xte",
+    "xti",
+    "xtj",
+    "xtl",
+    "xtm",
+    "xtn",
+    "xtp",
+    "xts",
+    "xtt",
+    "xtu",
+    "xtw",
+    "xty",
+    "xub",
+    "xuj",
+    "xwa",
+    "xwr",
+    "xxk",
+    "xxr",
+    "xxt",
+    "xyl",
+    "xzp",
+    "yaa",
+    "yab",
+    "yac",
+    "yad",
+    "yae",
+    "yak",
+    "yan",
+    "yao",
+    "yaq",
+    "yar",
+    "yau",
+    "yaw",
+    "ybh",
+    "ybi",
+    "ybn",
+    "ycn",
+    "ycr",
+    "ydg",
+    "yea",
+    "yet",
+    "yeu",
+    "yey",
+    "yhd",
+    "yim",
+    "yir",
+    "yka",
+    "yki",
+    "yli",
+    "yme",
+    "ymk",
+    "ymn",
+    "ynu",
+    "yog",
+    "yoi",
+    "yok",
+    "yoy",
+    "yrl",
+    "yro",
+    "yrs",
+    "yua",
+    "yuc",
+    "yud",
+    "yue",
+    "yuf",
+    "yui",
+    "yum",
+    "yup",
+    "yur",
+    "yva",
+    "yvt",
+    "ywn",
+    "zaa",
+    "zab",
+    "zac",
+    "zad",
+    "zae",
+    "zaf",
+    "zam",
+    "zao",
+    "zap",
+    "zaq",
+    "zar",
+    "zas",
+    "zat",
+    "zau",
+    "zav",
+    "zaw",
+    "zax",
+    "zay",
+    "zbt",
+    "zca",
+    "zh-Bopo",
+    "zh-Hanb",
+    "zh-Hant",
+    "zka",
+    "zkd",
+    "zkp",
+    "zoc",
+    "zoh",
+    "zom",
+    "zoo",
+    "zoq",
+    "zor",
+    "zos",
+    "zpa",
+    "zpb",
+    "zpc",
+    "zpd",
+    "zpe",
+    "zpf",
+    "zpg",
+    "zph",
+    "zpi",
+    "zpj",
+    "zpk",
+    "zpl",
+    "zpm",
+    "zpn",
+    "zpo",
+    "zpp",
+    "zpq",
+    "zpr",
+    "zps",
+    "zpt",
+    "zpu",
+    "zpv",
+    "zpw",
+    "zpx",
+    "zpy",
+    "zpz",
+    "zrg",
+    "zrs",
+    "zsr",
+    "zte",
+    "ztg",
+    "ztl",
+    "ztm",
+    "ztn",
+    "ztp",
+    "ztq",
+    "zts",
+    "ztt",
+    "ztu",
+    "ztx",
+    "zty",
+    "zu",
+    "zun",
+    "zwa",
+    "zyp"
+]);
+// Specific language-script combinations that resolve to Monday in CLDR despite their base language resolving to non-Monday
+const LIKELY_MONDAY_SCRIPT_OVERRIDES = new Set([
+    "en-Shaw",
+    "pal-Phlp",
+    "und-Adlm",
+    "und-Aghb",
+    "und-Armn",
+    "und-Bamu",
+    "und-Bass",
+    "und-Brai",
+    "und-Cari",
+    "und-Cham",
+    "und-Chrs",
+    "und-Cpmn",
+    "und-Cprt",
+    "und-Cyrl",
+    "und-Dupl",
+    "und-Elba",
+    "und-Gara",
+    "und-Geor",
+    "und-Glag",
+    "und-Goth",
+    "und-Grek",
+    "und-Hani",
+    "und-Hans",
+    "und-Hluw",
+    "und-Hung",
+    "und-Ital",
+    "und-Kits",
+    "und-Lina",
+    "und-Linb",
+    "und-Lisu",
+    "und-Lyci",
+    "und-Lydi",
+    "und-Mani",
+    "und-Marc",
+    "und-Medf",
+    "und-Mend",
+    "und-Mong",
+    "und-Nkoo",
+    "und-Nshu",
+    "und-Ogam",
+    "und-Orkh",
+    "und-Osma",
+    "und-Ougr",
+    "und-Perm",
+    "und-Phag",
+    "und-Phlp",
+    "und-Phnx",
+    "und-Plrd",
+    "und-Runr",
+    "und-Shaw",
+    "und-Sinh",
+    "und-Sogd",
+    "und-Sogo",
+    "und-Soyo",
+    "und-Tale",
+    "und-Talu",
+    "und-Tang",
+    "und-Tavt",
+    "und-Tfng",
+    "und-Tibt",
+    "und-Todr",
+    "und-Vaii",
+    "und-Vith",
+    "und-Yezi",
+    "und-Yiii",
+    "und-Zanb",
+    "yue-Hans"
+]);
+/**
+ * Resolves the likely first day of week for a base language tag, undefined-language tag,
+ * or language-script tag when native Intl.Locale.maximize() is unavailable.
+ */
+function resolveLikelyFirstDayOfWeek(baseTag) {
+    if (LIKELY_MONDAY_SCRIPT_OVERRIDES.has(baseTag)) {
+        return "monday";
+    }
+    if (LIKELY_FRIDAY_FIRST_TAGS.has(baseTag)) {
+        return "friday";
+    }
+    if (LIKELY_SATURDAY_FIRST_TAGS.has(baseTag)) {
+        return "saturday";
+    }
+    if (LIKELY_SUNDAY_FIRST_TAGS.has(baseTag)) {
+        return "sunday";
+    }
+    return null;
+}
+
+const FW_TO_FIRST_DAY = {
+    mon: "monday",
+    tue: "tuesday",
+    wed: "wednesday",
+    thu: "thursday",
+    fri: "friday",
+    sat: "saturday",
+    sun: "sunday"
+};
+const ISO_DAY_MAP = {
+    1: "monday",
+    2: "tuesday",
+    3: "wednesday",
+    4: "thursday",
+    5: "friday",
+    6: "saturday",
+    7: "sunday"
+};
+/**
+ * Extracts explicit Unicode extension 'fw' (first day of week) subtag if present.
+ * Example: 'en-US-u-fw-mon' -> 'monday'.
+ */
+function resolveExplicitFirstDayOverride(localeId) {
+    if (!localeId) {
+        return null;
+    }
+    const normalized = localeId.trim().replace(/_/g, "-");
+    const subtags = normalized.split("-");
+    let inUExtension = false;
+    for (let i = 0; i < subtags.length; i++) {
+        const subtag = subtags[i].toLowerCase();
+        if (subtag.length === 1) {
+            if (subtag === "x") {
+                break;
+            }
+            inUExtension = subtag === "u";
+            continue;
+        }
+        if (inUExtension && subtag === "fw") {
+            const nextSubtag = subtags[i + 1]?.toLowerCase();
+            if (nextSubtag && nextSubtag in FW_TO_FIRST_DAY) {
+                return FW_TO_FIRST_DAY[nextSubtag];
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Resolves the 2-letter ISO region code from a locale tag.
+ * 1. Uses Intl.Locale.region, then Intl.Locale.maximize().region.
+ * 2. If Intl.Locale is unavailable or fails, canonicalizes via Intl.getCanonicalLocales() to map numeric M49 region codes to alpha-2.
+ * 3. Falls back to manual base language tag parsing (safely stripping extension singletons like -u- or -x-) for 2-letter alpha territory subtags.
+ * Private-use tags (e.g. 'x-US') without a standard language tag are ignored.
+ */
+function resolveLikelyRegion(localeId) {
+    if (!localeId) {
+        return null;
+    }
+    const normalized = localeId.trim().replace(/_/g, "-");
+    if (!normalized || /^[xX](?:-|$)/.test(normalized)) {
+        return null;
+    }
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const loc = new Intl.Locale(normalized);
+            if (loc.region) {
+                return loc.region.toUpperCase();
+            }
+            if (typeof loc.maximize === "function") {
+                const maximized = loc.maximize();
+                if (maximized.region) {
+                    return maximized.region.toUpperCase();
+                }
+            }
+        }
+    }
+    catch {
+        // Fallback safely to canonicalization / manual base tag parser
+    }
+    let tagToParse = normalized;
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.getCanonicalLocales === "function") {
+            const canonical = Intl.getCanonicalLocales(normalized)[0];
+            if (canonical) {
+                tagToParse = canonical;
+            }
+        }
+    }
+    catch {
+        // Continue with normalized tag
+    }
+    // Manual BCP-47 fallback: strip singleton extensions (-u-, -x-, -t-, etc.) and everything following
+    const basePart = tagToParse.split(/-[a-zA-Z0-9]-/)[0];
+    const subtags = basePart.split("-");
+    if (!subtags[0] || subtags[0].length <= 1) {
+        return null;
+    }
+    for (let i = 1; i < subtags.length; i++) {
+        const subtag = subtags[i];
+        if (/^[a-zA-Z]{2}$/.test(subtag)) {
+            return subtag.toUpperCase();
+        }
+    }
+    return null;
+}
+/**
+ * Pure fallback resolver when Intl.Locale.weekInfo / getWeekInfo() is unavailable.
+ */
+function resolveFallbackFirstDayOfWeek(localeId) {
+    const normalized = (localeId ?? "").trim();
+    if (!normalized) {
+        return "monday";
+    }
+    const explicitOverride = resolveExplicitFirstDayOverride(normalized);
+    if (explicitOverride) {
+        return explicitOverride;
+    }
+    const region = resolveLikelyRegion(normalized);
+    if (region) {
+        if (FRIDAY_FIRST_REGIONS.has(region)) {
+            return "friday";
+        }
+        if (SATURDAY_FIRST_REGIONS.has(region)) {
+            return "saturday";
+        }
+        if (SUNDAY_FIRST_REGIONS.has(region)) {
+            return "sunday";
+        }
+        return "monday";
+    }
+    // Base tag fallback for primitive environments where maximize() was unavailable
+    const tag = normalized.replace(/_/g, "-");
+    if (/^[xX](?:-|$)/.test(tag)) {
+        return "monday";
+    }
+    const basePart = tag.split(/-[a-zA-Z0-9]-/)[0];
+    const subtags = basePart.split("-");
+    if (!subtags[0] || subtags[0].length <= 1) {
+        return "monday";
+    }
+    // If an explicit region subtag was present (alpha-2 or 3-digit numeric) but could not be mapped,
+    // do not fall back to language-only likely subtags; use deterministic default (Monday).
+    const hasRegion = subtags.slice(1).some(s => /^[a-zA-Z]{2}$|^\d{3}$/.test(s));
+    if (hasRegion) {
+        return "monday";
+    }
+    const baseLang = subtags[0].toLowerCase();
+    if (subtags.length > 1 && /^[a-zA-Z]{4}$/.test(subtags[1])) {
+        const script = subtags[1].charAt(0).toUpperCase() + subtags[1].slice(1).toLowerCase();
+        const langScript = `${baseLang}-${script}`;
+        const scriptFirstDay = resolveLikelyFirstDayOfWeek(langScript);
+        if (scriptFirstDay) {
+            return scriptFirstDay;
+        }
+    }
+    const langFirstDay = resolveLikelyFirstDayOfWeek(baseLang);
+    if (langFirstDay) {
+        return langFirstDay;
+    }
+    return "monday";
+}
+/**
+ * Pure, uncached resolver for locale first day of week.
+ * 1. Checks Intl.Locale.weekInfo / getWeekInfo()
+ * 2. Falls back to deterministic CLDR fallback
+ */
+function resolveLocaleFirstDayOfWeek(localeId) {
+    const normalized = (localeId ?? "").trim();
+    if (!normalized) {
+        return "monday";
+    }
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const loc = new Intl.Locale(normalized);
+            const weekInfo = loc.weekInfo ?? loc.getWeekInfo?.();
+            if (weekInfo && typeof weekInfo.firstDay === "number") {
+                const dayNum = weekInfo.firstDay === 0 ? 7 : weekInfo.firstDay;
+                const mapped = ISO_DAY_MAP[dayNum];
+                if (mapped) {
+                    return mapped;
+                }
+            }
+        }
+    }
+    catch {
+        // fallback
+    }
+    return resolveFallbackFirstDayOfWeek(normalized);
+}
+
+const dateFormatCache = new Map();
+const timeFormatCache = new Map();
+const dateTimeFormatCache = new Map();
+const firstDayCache = new Map();
+function normalizeEditableLiteral(value) {
+    return sanitizeDateText(value);
+}
+/**
+ * Derives a localized numeric date format (e.g. "yyyy/MM/dd" or "dd/MM/yyyy") for the given locale.
+ */
+function getLocaleDateInputFormat(localeId) {
+    const locale = normalizeGregorianLocale(localeId);
+    let format = dateFormatCache.get(locale);
+    if (!format) {
+        try {
+            const dtf = new Intl.DateTimeFormat(locale, {
+                calendar: "gregory",
+                year: "numeric",
+                month: "2-digit",
+                day: "2-digit"
+            });
+            const parts = dtf.formatToParts(new Date(2026, 8, 15));
+            let derived = "";
+            for (const part of parts) {
+                if (part.type === "year") {
+                    derived += "yyyy";
+                }
+                else if (part.type === "month") {
+                    derived += "MM";
+                }
+                else if (part.type === "day") {
+                    derived += "dd";
+                }
+                else if (part.type === "literal") {
+                    derived += normalizeEditableLiteral(part.value);
+                }
+            }
+            format = derived || "dd/MM/yyyy";
+        }
+        catch {
+            format = "dd/MM/yyyy";
+        }
+        dateFormatCache.set(locale, format);
+    }
+    return format;
+}
+/**
+ * Derives a localized time format (e.g. "HH:mm", "ahh:mm", "hh:mm a") for the given locale.
+ */
+function getLocaleTimeInputFormat(localeId, options) {
+    const locale = normalizeGregorianLocale(localeId);
+    const hourFormat = options?.hourFormat ?? "24";
+    const showSeconds = options?.showSeconds ?? false;
+    const cacheKey = `${locale}|${hourFormat}|${showSeconds}`;
+    let format = timeFormatCache.get(cacheKey);
+    if (!format) {
+        const is12 = hourFormat === "12";
+        try {
+            const dtfOptions = {
+                calendar: "gregory",
+                hour: "2-digit",
+                minute: "2-digit",
+                hour12: is12
+            };
+            if (showSeconds) {
+                dtfOptions.second = "2-digit";
+            }
+            const dtf = new Intl.DateTimeFormat(locale, dtfOptions);
+            const parts = dtf.formatToParts(new Date(2026, 8, 15, 21, 30, 45));
+            let derived = "";
+            for (const part of parts) {
+                if (part.type === "hour") {
+                    derived += is12 ? "hh" : "HH";
+                }
+                else if (part.type === "minute") {
+                    derived += "mm";
+                }
+                else if (part.type === "second") {
+                    derived += "ss";
+                }
+                else if (part.type === "dayPeriod") {
+                    derived += "a";
+                }
+                else if (part.type === "literal") {
+                    derived += normalizeEditableLiteral(part.value);
+                }
+            }
+            format =
+                derived ||
+                    (is12 ? (showSeconds ? "hh:mm:ss a" : "hh:mm a") : showSeconds ? "HH:mm:ss" : "HH:mm");
+        }
+        catch {
+            format = is12 ? (showSeconds ? "hh:mm:ss a" : "hh:mm a") : showSeconds ? "HH:mm:ss" : "HH:mm";
+        }
+        timeFormatCache.set(cacheKey, format);
+    }
+    return format;
+}
+/**
+ * Derives a localized date-time format for the given locale.
+ */
+function getLocaleDateTimeInputFormat(localeId, options) {
+    const locale = normalizeGregorianLocale(localeId);
+    const hourFormat = options?.hourFormat ?? "24";
+    const showSeconds = options?.showSeconds ?? false;
+    const cacheKey = `${locale}|${hourFormat}|${showSeconds}`;
+    let format = dateTimeFormatCache.get(cacheKey);
+    if (!format) {
+        const is12 = hourFormat === "12";
+        try {
+            const dtfOptions = {
+                calendar: "gregory",
+                year: "numeric",
+                month: "2-digit",
+                day: "2-digit",
+                hour: "2-digit",
+                minute: "2-digit",
+                hour12: is12
+            };
+            if (showSeconds) {
+                dtfOptions.second = "2-digit";
+            }
+            const dtf = new Intl.DateTimeFormat(locale, dtfOptions);
+            const parts = dtf.formatToParts(new Date(2026, 8, 15, 21, 30, 45));
+            let derived = "";
+            for (const part of parts) {
+                if (part.type === "year") {
+                    derived += "yyyy";
+                }
+                else if (part.type === "month") {
+                    derived += "MM";
+                }
+                else if (part.type === "day") {
+                    derived += "dd";
+                }
+                else if (part.type === "hour") {
+                    derived += is12 ? "hh" : "HH";
+                }
+                else if (part.type === "minute") {
+                    derived += "mm";
+                }
+                else if (part.type === "second") {
+                    derived += "ss";
+                }
+                else if (part.type === "dayPeriod") {
+                    derived += "a";
+                }
+                else if (part.type === "literal") {
+                    derived += normalizeEditableLiteral(part.value);
+                }
+            }
+            format = derived || `${getLocaleDateInputFormat(localeId)} ${getLocaleTimeInputFormat(localeId, options)}`;
+        }
+        catch {
+            format = `${getLocaleDateInputFormat(localeId)} ${getLocaleTimeInputFormat(localeId, options)}`;
+        }
+        dateTimeFormatCache.set(cacheKey, format);
+    }
+    return format;
+}
+/**
+ * Resolves the first day of the week for the given locale using Intl.Locale.weekInfo,
+ * Intl.Locale.getWeekInfo(), or CLDR fallbacks.
+ */
+function getLocaleFirstDayOfWeek(localeId) {
+    const normalizedLocaleId = (localeId ?? "").trim();
+    let firstDay = firstDayCache.get(normalizedLocaleId);
+    if (!firstDay) {
+        firstDay = resolveLocaleFirstDayOfWeek(normalizedLocaleId);
+        firstDayCache.set(normalizedLocaleId, firstDay);
+    }
+    return firstDay;
+}
+
+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 { 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 };
+//# sourceMappingURL=nanahoshi-mona-ui-i18n.mjs.map