@nanahoshi/mona-ui 0.23.3 → 0.24.1

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

@@ -0,0 +1,888 @@
+import { isDevMode } from '@angular/core';
+import { formatNumber, MONA_FALLBACK_LOCALE_ID, tryCanonicalizeLocaleId, canonicalizeLocaleId } from '@nanahoshi/mona-ui/i18n';
+
+// Generated by scripts/generate-message-parameters.ts from i18n/message-types. Do not edit.
+// Run `npm run generate:message-parameters` after changing a message type.
+/**
+ * The parameters of every message, by namespace and key, in the order the message function takes them. A plain
+ * string message has `null`.
+ */
+const MONA_MESSAGE_PARAMETERS = {
+    autoComplete: {
+        clear: null
+    },
+    breadcrumb: {
+        breadcrumb: null
+    },
+    buttonGroup: {
+        buttonGroup: null
+    },
+    calendar: {
+        calendarLabel: [{ name: "formattedMonthAndYear", type: "string" }],
+        decadeRange: [
+            { name: "start", type: "number" },
+            { name: "end", type: "number" }
+        ],
+        decadeViewLabel: [
+            { name: "start", type: "number" },
+            { name: "end", type: "number" }
+        ],
+        goToToday: [{ name: "formattedDate", type: "string" }],
+        nextDecade: null,
+        nextMonth: null,
+        nextYear: null,
+        previousDecade: null,
+        previousMonth: null,
+        previousYear: null,
+        switchToDecadeView: [{ name: "currentYear", type: "string" }],
+        switchToYearView: [{ name: "currentMonthAndYear", type: "string" }],
+        today: null,
+        yearCellLabel: [{ name: "year", type: "number" }],
+        yearViewLabel: [{ name: "year", type: "string" }]
+    },
+    card: {
+        actionsLabel: null
+    },
+    chart: {
+        change: null,
+        chart: null,
+        chartLegend: null,
+        close: null,
+        closeAbbreviation: null,
+        colorScale: null,
+        conversion: null,
+        divergingRangeDescription: [
+            { name: "title", type: "string" },
+            { name: "minimum", type: "string" },
+            { name: "midpoint", type: "string" },
+            { name: "maximum", type: "string" }
+        ],
+        dropOff: null,
+        falling: null,
+        high: null,
+        highAbbreviation: null,
+        labelValueSeparator: null,
+        low: null,
+        lowAbbreviation: null,
+        noData: null,
+        open: null,
+        openAbbreviation: null,
+        overall: null,
+        range: null,
+        rangeDescription: [
+            { name: "title", type: "string" },
+            { name: "minimum", type: "string" },
+            { name: "maximum", type: "string" }
+        ],
+        rising: null,
+        runningTotal: null,
+        size: null,
+        unchanged: null,
+        value: null,
+        visualIndicatorClamped: null
+    },
+    chip: {
+        removeLabel: [{ name: "label", optional: true, type: "string" }]
+    },
+    colorGradient: {
+        apply: null,
+        cancel: null,
+        clearColor: null,
+        copyAsHex: null,
+        copyAsRgb: null,
+        copyColor: null,
+        currentColor: null,
+        previousColor: null,
+        saturationAndValue: null,
+        saturationAndValueText: [
+            { name: "saturation", type: "number" },
+            { name: "value", type: "number" }
+        ],
+        switchColorMode: null
+    },
+    colorPalette: {
+        color: [{ name: "color", type: "string" }],
+        colorPalette: null
+    },
+    colorPicker: {
+        clearColor: null,
+        colorGradientPicker: null,
+        colorPalettePicker: null,
+        colorPicker: null
+    },
+    comboBox: {
+        clear: null
+    },
+    datePicker: {
+        datePicker: null,
+        openCalendar: null
+    },
+    dateTimePicker: {
+        calendar: null,
+        cancel: null,
+        date: null,
+        dateTimePicker: null,
+        openDateTimePicker: null,
+        set: null,
+        time: null,
+        timePicker: null
+    },
+    dialog: {
+        cancel: null,
+        closeDialog: null,
+        ok: null
+    },
+    dropdownList: {
+        clear: null
+    },
+    dropdowns: {
+        itemPosition: [
+            { name: "text", type: "string" },
+            { name: "position", type: "number" },
+            { name: "total", type: "number" }
+        ],
+        noResultsFound: null,
+        resultsAvailable: [{ name: "count", type: "number" }]
+    },
+    editor: {
+        addColumnAfter: null,
+        addColumnBefore: null,
+        addHorizontalLine: null,
+        addRowAfter: null,
+        addRowBefore: null,
+        alignCenter: null,
+        alignLeft: null,
+        alignRight: null,
+        altText: null,
+        backgroundColor: null,
+        bold: null,
+        cancel: null,
+        codeBlock: null,
+        color: null,
+        deleteColumn: null,
+        deleteRow: null,
+        deleteTable: null,
+        enterUrl: null,
+        fontSize: null,
+        format: null,
+        heading: [{ name: "level", type: "number" }],
+        heightPx: null,
+        imageUrl: null,
+        indent: null,
+        insert: null,
+        insertImage: null,
+        insertLink: null,
+        insertOrderedList: null,
+        insertTable: null,
+        insertTaskList: null,
+        insertUnorderedList: null,
+        italic: null,
+        justify: null,
+        mergeCells: null,
+        outdent: null,
+        paragraph: null,
+        quotation: null,
+        redo: null,
+        removeLink: null,
+        selectFontFamily: null,
+        selectFontSize: null,
+        splitCell: null,
+        strikethrough: null,
+        subscript: null,
+        superscript: null,
+        toggleHeaderRow: null,
+        underline: null,
+        undo: null,
+        widthPx: null
+    },
+    filter: {
+        and: null,
+        apply: null,
+        clear: null,
+        contains: null,
+        doesNotContain: null,
+        endsWith: null,
+        isAfter: null,
+        isAfterOrEqualTo: null,
+        isBefore: null,
+        isBeforeOrEqualTo: null,
+        isEmpty: null,
+        isEqualTo: null,
+        isFalse: null,
+        isGreaterThan: null,
+        isGreaterThanOrEqualTo: null,
+        isLessThan: null,
+        isLessThanOrEqualTo: null,
+        isNotEmpty: null,
+        isNotEqualTo: null,
+        isNotNull: null,
+        isNotNullOrEmpty: null,
+        isNull: null,
+        isNullOrEmpty: null,
+        isTrue: null,
+        or: null,
+        startsWith: null
+    },
+    grid: {
+        all: null,
+        apply: null,
+        cancel: null,
+        cancelRowEdit: null,
+        columns: null,
+        columnsSelected: [{ name: "count", type: "number" }],
+        delete: null,
+        deleteRowConfirmation: null,
+        deleteRowTitle: null,
+        dragColumnHeaderToGroup: null,
+        edit: null,
+        editRow: null,
+        fieldValidationError: null,
+        filterByColumn: [{ name: "column", type: "string" }],
+        filterPlaceholder: null,
+        modified: null,
+        moveAsNext: null,
+        moveAsPrevious: null,
+        moveRow: null,
+        noData: null,
+        remove: null,
+        removeRow: null,
+        reorderRow: [{ name: "rowNumber", type: "number" }],
+        resizeColumn: null,
+        rowReorder: null,
+        rowReorderDisabled: null,
+        rowReorderDisabledEditing: null,
+        rowReorderDisabledFiltered: null,
+        rowReorderDisabledGrouped: null,
+        rowReorderDisabledServerBinding: null,
+        rowReorderDisabledSingleRow: null,
+        rowReorderDisabledSorted: null,
+        rowReorderDisabledVirtualScroll: null,
+        rowReorderHandleAriaLabel: [
+            { name: "rowLabel", type: "string" },
+            { name: "keyboardHint", type: "string" },
+            { name: "disabledReason", optional: true, type: "string" }
+        ],
+        rowReorderKeyboardHint: null,
+        rowReorderMoved: [
+            { name: "fromRowNumber", type: "number" },
+            { name: "toPosition", type: "number" }
+        ],
+        rowValidationError: null,
+        save: null,
+        saveRow: null,
+        selectAllRows: null,
+        selectRow: [{ name: "rowNumber", type: "number" }]
+    },
+    list: {
+        filterList: null,
+        noData: null
+    },
+    listBox: {
+        clearSelection: null,
+        moveDown: null,
+        moveUp: null,
+        remove: null,
+        transferAllFrom: null,
+        transferAllTo: null,
+        transferFrom: null,
+        transferTo: null
+    },
+    multiSelect: {
+        clear: null,
+        itemsCount: [{ name: "count", type: "number" }]
+    },
+    notification: {
+        close: null,
+        error: null,
+        info: null,
+        success: null,
+        warning: null
+    },
+    numericTextBox: {
+        decrease: null,
+        increase: null
+    },
+    otpInput: {
+        verificationCode: null
+    },
+    pager: {
+        firstPageLabel: null,
+        jumpBackwardLabel: [{ name: "pages", type: "number" }],
+        jumpForwardLabel: [{ name: "pages", type: "number" }],
+        lastPageLabel: null,
+        nextPageLabel: null,
+        ofText: null,
+        pageLabel: [{ name: "page", type: "number" }],
+        pageSizeLabel: [{ name: "pageSize", type: "number" }],
+        pageStatus: [
+            { name: "page", type: "number" },
+            { name: "totalPages", type: "number" }
+        ],
+        pageText: null,
+        previousPageLabel: null,
+        rangeStatus: [
+            { name: "start", type: "number" },
+            { name: "end", type: "number" },
+            { name: "total", type: "number" }
+        ]
+    },
+    rating: {
+        notRated: null,
+        valueText: [
+            { name: "value", type: "number" },
+            { name: "max", type: "number" }
+        ]
+    },
+    scrollView: {
+        carousel: null,
+        nextPage: null,
+        page: [{ name: "current", type: "number" }],
+        pageOf: [
+            { name: "current", type: "number" },
+            { name: "total", type: "number" }
+        ],
+        previousPage: null,
+        scrollPagerNext: null,
+        scrollPagerPrevious: null,
+        slide: null
+    },
+    sheet: {
+        closeSheet: null
+    },
+    slider: {
+        maximumValue: null,
+        minimumValue: null,
+        sliderValue: null
+    },
+    spinner: {
+        cancel: null,
+        loading: null
+    },
+    splitButton: {
+        menuButtonAriaLabel: null,
+        splitButton: [{ name: "text", type: "string" }]
+    },
+    splitter: {
+        collapseDown: null,
+        collapseNext: null,
+        collapsePrevious: null,
+        collapseUp: null,
+        resizer: null
+    },
+    stepper: {
+        stepProgress: null,
+        stepper: null
+    },
+    tabs: {
+        closeTab: null,
+        scrollNext: null,
+        scrollPrevious: null
+    },
+    textBox: {
+        clear: null
+    },
+    timePicker: {
+        openTimePicker: null,
+        timePicker: null
+    },
+    timeSelector: {
+        am: null,
+        amPm: null,
+        headerHours: null,
+        headerMinutes: null,
+        headerSeconds: null,
+        hours: null,
+        minutes: null,
+        now: null,
+        pm: null,
+        seconds: null,
+        set: null,
+        timeSelector: null
+    },
+    treeView: {
+        collapse: null,
+        expand: null,
+        filter: null,
+        filterTree: null
+    },
+    window: {
+        close: null,
+        closeWindow: null,
+        maximize: null,
+        minimize: null,
+        moveWindow: null,
+        resizeBottom: null,
+        resizeBottomLeft: null,
+        resizeBottomRight: null,
+        resizeLeft: null,
+        resizeRight: null,
+        resizeTop: null,
+        resizeTopLeft: null,
+        resizeTopRight: null,
+        restore: null
+    }
+};
+
+/** The `select` key that an absent or empty argument selects, before falling back to `other`. */
+const ICU_ABSENT_SELECT_KEY = "undefined";
+const pluralRulesCache = new Map();
+/**
+ * Formats a parsed message. Numbers go through `formatNumber`, so they use the locale's digits and grouping, the
+ * same as Mona's TypeScript catalogs.
+ *
+ * - An absent argument (`undefined`) formats as an empty string.
+ * - In `select`, an absent or empty argument picks the `undefined` option, then `other`; a present value never
+ *   picks `undefined`.
+ * - In `plural`, an exact `=N` option wins over the value's plural category, which is taken after the offset.
+ */
+function formatIcuMessage(elements, values, localeId) {
+    return formatElements(elements, values, localeId, null);
+}
+function formatElements(elements, values, localeId, pound) {
+    let result = "";
+    for (const element of elements) {
+        switch (element.kind) {
+            case "literal":
+                result += element.value;
+                break;
+            case "argument":
+            case "number": {
+                const value = values.get(element.name);
+                result +=
+                    typeof value === "number"
+                        ? formatNumber(value, localeId, element.kind === "number" ? element.options : undefined)
+                        : (value ?? "");
+                break;
+            }
+            case "pound":
+                result += pound == null ? "#" : formatNumber(pound, localeId);
+                break;
+            case "plural": {
+                const value = Number(values.get(element.name));
+                const exact = [...element.options].find(([key]) => key.startsWith("=") && Number(key.slice(1)) === value);
+                const adjusted = value - element.offset;
+                const option = exact?.[1] ??
+                    element.options.get(getPluralRules(localeId, element.ordinal).select(adjusted)) ??
+                    element.options.get("other");
+                result += formatElements(option, values, localeId, adjusted);
+                break;
+            }
+            case "select": {
+                const option = selectOption(element.options, values.get(element.name)) ?? element.options.get("other");
+                result += formatElements(option, values, localeId, pound);
+                break;
+            }
+        }
+    }
+    return result;
+}
+function getPluralRules(localeId, ordinal) {
+    const cacheKey = `${ordinal ? "ordinal" : "cardinal"}:${localeId}`;
+    let rules = pluralRulesCache.get(cacheKey);
+    if (rules == null) {
+        rules = new Intl.PluralRules(localeId, { type: ordinal ? "ordinal" : "cardinal" });
+        pluralRulesCache.set(cacheKey, rules);
+    }
+    return rules;
+}
+function selectOption(options, value) {
+    if (value == null || value === "") {
+        return options.get(ICU_ABSENT_SELECT_KEY);
+    }
+    const key = String(value);
+    return key === ICU_ABSENT_SELECT_KEY ? undefined : options.get(key);
+}
+
+/**
+ * Parser for the subset of ICU MessageFormat that Mona supports:
+ *
+ * - `{name}` and `{name, number}`, with the `integer` and `percent` styles and the `::group-off`,
+ *   `::percent` and `::precision-integer` skeletons
+ * - `{name, plural, ...}` and `{name, selectordinal, ...}`, with `=N` and CLDR category selectors, `offset:N`, and `#`
+ * - `{name, select, ...}`
+ * - apostrophe quoting: `''` is an apostrophe, and `'{'`, `'}'` and, inside a plural, `'#'` are literal
+ *
+ * Dates, times and other argument types are rejected, because no Mona message takes one.
+ */
+class IcuSyntaxError extends Error {
+    constructor(message, offset, kind = "syntax") {
+        super(`${message} at position ${offset}`);
+        this.name = "IcuSyntaxError";
+        this.kind = kind;
+        this.offset = offset;
+    }
+}
+/** Arguments can nest this deep; deeper input is rejected rather than risking a stack overflow. */
+const MAX_DEPTH = 16;
+const PLURAL_CATEGORIES = new Set(["few", "many", "one", "other", "two", "zero"]);
+const IDENTIFIER_REGEX = /[A-Za-z_][A-Za-z0-9_]*/y;
+const KEYWORD_REGEX = /[\p{L}\p{N}_-]+/uy;
+const EXACT_SELECTOR_REGEX = /=-?\d+(?:\.\d+)?/y;
+const OFFSET_REGEX = /offset:\s*(\d+)/y;
+const WHITESPACE_REGEX = /\s*/y;
+const NUMBER_SKELETON_OPTIONS = {
+    "group-off": { useGrouping: false },
+    percent: { style: "percent" },
+    "precision-integer": { maximumFractionDigits: 0 }
+};
+/** Parses an ICU message. Throws an {@link IcuSyntaxError} for input outside the supported subset. */
+function parseIcuMessage(source) {
+    const state = { pos: 0, source };
+    return parseMessage(state, 0, false, false);
+}
+function expect(state, char) {
+    if (state.source[state.pos] !== char) {
+        throw new IcuSyntaxError(state.pos >= state.source.length ? `Expected "${char}" but the message ended` : `Expected "${char}"`, state.pos);
+    }
+    state.pos++;
+}
+function match(state, regex) {
+    regex.lastIndex = state.pos;
+    const result = regex.exec(state.source);
+    if (result != null) {
+        state.pos = regex.lastIndex;
+    }
+    return result;
+}
+function parseArgument(state, depth, inPlural) {
+    const start = state.pos;
+    if (depth > MAX_DEPTH) {
+        throw new IcuSyntaxError(`Arguments are nested more than ${MAX_DEPTH} levels deep`, start);
+    }
+    expect(state, "{");
+    skipWhitespace(state);
+    const name = match(state, IDENTIFIER_REGEX)?.[0];
+    if (name == null) {
+        throw new IcuSyntaxError("Expected an argument name", state.pos);
+    }
+    skipWhitespace(state);
+    if (state.source[state.pos] === "}") {
+        state.pos++;
+        return { kind: "argument", name };
+    }
+    expect(state, ",");
+    skipWhitespace(state);
+    const typeStart = state.pos;
+    const type = match(state, IDENTIFIER_REGEX)?.[0];
+    skipWhitespace(state);
+    switch (type) {
+        case "number":
+            return parseNumberArgument(state, name);
+        case "plural":
+        case "selectordinal":
+            return parsePluralArgument(state, name, type === "selectordinal", depth, start);
+        case "select":
+            expect(state, ",");
+            return { kind: "select", name, options: parseOptions(state, depth, inPlural, false, start) };
+        default:
+            throw new IcuSyntaxError(type == null ? "Expected an argument type" : `Unsupported argument type "${type}"`, typeStart);
+    }
+}
+function parseMessage(state, depth, inPlural, nested) {
+    const { source } = state;
+    const elements = [];
+    let text = "";
+    const flush = () => {
+        if (text !== "") {
+            elements.push({ kind: "literal", value: text });
+            text = "";
+        }
+    };
+    while (state.pos < source.length) {
+        const char = source[state.pos];
+        if (char === "'") {
+            text += readApostrophe(state, inPlural);
+        }
+        else if (char === "{") {
+            flush();
+            elements.push(parseArgument(state, depth + 1, inPlural));
+        }
+        else if (char === "}") {
+            if (nested) {
+                break;
+            }
+            throw new IcuSyntaxError('Unexpected "}"', state.pos);
+        }
+        else if (char === "#" && inPlural) {
+            flush();
+            elements.push({ kind: "pound" });
+            state.pos++;
+        }
+        else {
+            text += char;
+            state.pos++;
+        }
+    }
+    flush();
+    return elements;
+}
+function parseNumberArgument(state, name) {
+    if (state.source[state.pos] === "}") {
+        state.pos++;
+        return { kind: "number", name };
+    }
+    expect(state, ",");
+    const styleStart = state.pos;
+    const end = state.source.indexOf("}", state.pos);
+    if (end < 0) {
+        throw new IcuSyntaxError('Expected "}" but the message ended', state.source.length);
+    }
+    const style = state.source.slice(state.pos, end).trim();
+    state.pos = end + 1;
+    if (style === "integer") {
+        return { kind: "number", name, options: NUMBER_SKELETON_OPTIONS["precision-integer"] };
+    }
+    if (style === "percent") {
+        return { kind: "number", name, options: NUMBER_SKELETON_OPTIONS["percent"] };
+    }
+    if (style.startsWith("::")) {
+        let options = {};
+        for (const token of style.slice(2).trim().split(/\s+/)) {
+            if (!Object.hasOwn(NUMBER_SKELETON_OPTIONS, token)) {
+                throw new IcuSyntaxError(`Unsupported number skeleton "${token}"`, styleStart);
+            }
+            options = { ...options, ...NUMBER_SKELETON_OPTIONS[token] };
+        }
+        return { kind: "number", name, options };
+    }
+    throw new IcuSyntaxError(`Unsupported number style "${style}"`, styleStart);
+}
+/**
+ * Parses the `selector {message}` pairs that follow the comma after the argument type (and offset), up to and including the argument's closing brace. Every plural and select must
+ * have an `other` option, which is used when no other selector matches.
+ */
+function parseOptions(state, depth, inPlural, plural, argumentStart) {
+    skipWhitespace(state);
+    const options = new Map();
+    while (state.source[state.pos] !== "}") {
+        if (state.pos >= state.source.length) {
+            throw new IcuSyntaxError('Expected "}" but the message ended', state.pos);
+        }
+        const selectorStart = state.pos;
+        const selector = (plural ? match(state, EXACT_SELECTOR_REGEX)?.[0] : undefined) ?? match(state, KEYWORD_REGEX)?.[0];
+        if (selector == null) {
+            throw new IcuSyntaxError("Expected a selector", selectorStart);
+        }
+        if (plural && !selector.startsWith("=") && !PLURAL_CATEGORIES.has(selector)) {
+            throw new IcuSyntaxError(`Unknown plural category "${selector}"`, selectorStart);
+        }
+        if (options.has(selector)) {
+            throw new IcuSyntaxError(`Duplicate selector "${selector}"`, selectorStart);
+        }
+        skipWhitespace(state);
+        expect(state, "{");
+        options.set(selector, parseMessage(state, depth, inPlural || plural, true));
+        expect(state, "}");
+        skipWhitespace(state);
+    }
+    state.pos++;
+    if (!options.has("other")) {
+        throw new IcuSyntaxError('Missing the "other" option', argumentStart, "missing-other");
+    }
+    return options;
+}
+function parsePluralArgument(state, name, ordinal, depth, argumentStart) {
+    expect(state, ",");
+    skipWhitespace(state);
+    const offset = Number(match(state, OFFSET_REGEX)?.[1] ?? 0);
+    return { kind: "plural", name, offset, options: parseOptions(state, depth, true, true, argumentStart), ordinal };
+}
+/**
+ * Reads apostrophe quoting at the current position. `''` is one apostrophe. An apostrophe before `{`, `}`, or `#`
+ * inside a plural starts quoted text, which ends at the next single apostrophe. Any other apostrophe is literal.
+ */
+function readApostrophe(state, inPlural) {
+    const { source } = state;
+    const next = source[state.pos + 1];
+    if (next === "'") {
+        state.pos += 2;
+        return "'";
+    }
+    if (next !== "{" && next !== "}" && !(next === "#" && inPlural)) {
+        state.pos++;
+        return "'";
+    }
+    state.pos++;
+    let text = "";
+    while (state.pos < source.length) {
+        if (source[state.pos] === "'") {
+            if (source[state.pos + 1] === "'") {
+                text += "'";
+                state.pos += 2;
+                continue;
+            }
+            state.pos++;
+            break;
+        }
+        text += source[state.pos];
+        state.pos++;
+    }
+    return text;
+}
+function skipWhitespace(state) {
+    match(state, WHITESPACE_REGEX);
+}
+
+/** Thrown by `compileMonaLocale` in strict mode when the data has issues. */
+class MonaLocaleDataError extends Error {
+    constructor(issues) {
+        super(`[mona-ui] The locale data has ${issues.length} issue(s):\n` +
+            issues.map(issue => `- ${issue.path || "(root)"}: ${issue.message}`).join("\n"));
+        this.name = "MonaLocaleDataError";
+        this.issues = issues;
+    }
+}
+/**
+ * Compiles locale data, such as a JSON catalog from a translation-management system, into a `MonaLocale`. Messages
+ * with parameters become functions; plain messages become strings.
+ *
+ * By default, a message with an issue (an unknown key or parameter, or a syntax error) is skipped, so components
+ * show their English default for it, and a dev-mode warning lists the issues. With `{ strict: true }`, any issue
+ * throws a {@link MonaLocaleDataError} instead.
+ *
+ * ```ts
+ * provideMonaI18n({
+ *     loadLocale: id => fetch(`/i18n/${id}.json`).then(r => r.json()).then(data => compileMonaLocale(data))
+ * });
+ * ```
+ */
+function compileMonaLocale(data, options) {
+    const { issues, locale } = analyzeLocaleData(data);
+    if (issues.length > 0) {
+        if (options?.strict === true) {
+            throw new MonaLocaleDataError(issues);
+        }
+        if (isDevMode()) {
+            console.warn(`[mona-ui] compileMonaLocale skipped what it could not compile; those messages fall back to English.`, issues);
+        }
+    }
+    return locale;
+}
+/**
+ * Checks locale data without compiling it, for example in CI before a catalog exported from a
+ * translation-management system ships. Returns every issue; an empty array means the data compiles cleanly.
+ */
+function validateMonaLocaleData(data) {
+    return analyzeLocaleData(data).issues;
+}
+function analyzeLocaleData(data) {
+    const issues = [];
+    const report = (code, path, message) => {
+        issues.push({ code, message, path });
+    };
+    if (!isRecord(data)) {
+        report("invalid-structure", "", "Locale data must be an object with id, direction and messages.");
+        return { issues, locale: { direction: "ltr", id: MONA_FALLBACK_LOCALE_ID, messages: {} } };
+    }
+    let id = MONA_FALLBACK_LOCALE_ID;
+    if (typeof data["id"] === "string" && tryCanonicalizeLocaleId(data["id"]) != null) {
+        id = data["id"];
+    }
+    else {
+        report("invalid-id", "id", "id must be a valid BCP 47 locale id, such as de-DE.");
+    }
+    let direction = "ltr";
+    if (data["direction"] === "ltr" || data["direction"] === "rtl") {
+        direction = data["direction"];
+    }
+    else {
+        report("invalid-direction", "direction", 'direction must be "ltr" or "rtl".');
+    }
+    const messages = {};
+    const localeId = canonicalizeLocaleId(id);
+    const dataMessages = data["messages"];
+    if (!isRecord(dataMessages)) {
+        report("invalid-structure", "messages", "messages must be an object of namespaces.");
+        return { issues, locale: { direction, id, messages: {} } };
+    }
+    for (const [namespace, namespaceMessages] of Object.entries(dataMessages)) {
+        const namespacePath = `messages.${namespace}`;
+        if (!Object.hasOwn(MONA_MESSAGE_PARAMETERS, namespace)) {
+            report("unknown-namespace", namespacePath, `"${namespace}" is not a message namespace.`);
+            continue;
+        }
+        if (!isRecord(namespaceMessages)) {
+            report("invalid-structure", namespacePath, "A namespace must be an object of messages.");
+            continue;
+        }
+        const namespaceParameters = MONA_MESSAGE_PARAMETERS[namespace];
+        const compiled = {};
+        for (const [key, source] of Object.entries(namespaceMessages)) {
+            const path = `${namespacePath}.${key}`;
+            if (!Object.hasOwn(namespaceParameters, key)) {
+                report("unknown-key", path, `"${key}" is not a message of the "${namespace}" namespace.`);
+                continue;
+            }
+            if (typeof source !== "string") {
+                report("not-a-string", path, "A message must be a string.");
+                continue;
+            }
+            const message = compileMessage(source, namespaceParameters[key], localeId, path, report);
+            if (message !== undefined) {
+                compiled[key] = message;
+            }
+        }
+        messages[namespace] = compiled;
+    }
+    return { issues, locale: { direction, id, messages: messages } };
+}
+function checkArguments(elements, parameters, path, report) {
+    let valid = true;
+    for (const element of elements) {
+        if (element.kind === "literal" || element.kind === "pound") {
+            continue;
+        }
+        const parameter = parameters.find(p => p.name === element.name);
+        if (parameter == null) {
+            const known = parameters.length === 0 ? "it takes none" : `it takes ${parameters.map(p => p.name).join(", ")}`;
+            report("unknown-parameter", path, `"${element.name}" is not a parameter of this message; ${known}.`);
+            valid = false;
+            continue;
+        }
+        if ((element.kind === "number" || element.kind === "plural") && parameter.type !== "number") {
+            report("parameter-type", path, `"${element.name}" is a ${parameter.type}, so it cannot be a ${element.kind}.`);
+            valid = false;
+        }
+        if (element.kind === "plural" || element.kind === "select") {
+            for (const option of element.options.values()) {
+                valid = checkArguments(option, parameters, path, report) && valid;
+            }
+        }
+    }
+    return valid;
+}
+/** Compiles one message to a string or a function, or reports its issues and returns `undefined`. */
+function compileMessage(source, parameters, localeId, path, report) {
+    let elements;
+    try {
+        elements = parseIcuMessage(source);
+    }
+    catch (error) {
+        if (error instanceof IcuSyntaxError) {
+            report(error.kind, path, error.message);
+            return undefined;
+        }
+        throw error;
+    }
+    if (!checkArguments(elements, parameters ?? [], path, report)) {
+        return undefined;
+    }
+    if (parameters == null) {
+        return formatIcuMessage(elements, new Map(), localeId);
+    }
+    return (...args) => formatIcuMessage(elements, new Map(parameters.map((p, index) => [p.name, args[index]])), localeId);
+}
+function isRecord(value) {
+    return typeof value === "object" && value != null && !Array.isArray(value);
+}
+
+/*
+ * Public API Surface of @nanahoshi/mona-ui/i18n/icu
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { MONA_MESSAGE_PARAMETERS, MonaLocaleDataError, compileMonaLocale, validateMonaLocaleData };
+//# sourceMappingURL=nanahoshi-mona-ui-i18n-icu.mjs.map