@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/validate-BxpupdAf.js

@@ -0,0 +1,2615 @@
+import { a as diagnosticError, o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { hash } from "node:crypto";
+//#region src/core/icu/skeleton.ts
+const fail = (code, message) => ({
+	ok: false,
+	code,
+	message
+});
+/**
+* Resolves the style text of `{name, type, style}` as FormatJS leaves it
+* (`trimEnd`ed; `null` when absent).
+*/
+function resolveStyle(type, style) {
+	if (style === null) return {
+		ok: true,
+		style: null,
+		options: keywordOptions(type, null)
+	};
+	if (style.startsWith("::")) {
+		const skeleton = style.slice(2).trimStart();
+		return type === "number" ? numberSkeleton(skeleton) : dateSkeleton(skeleton);
+	}
+	if (type === "number") {
+		if (style === "integer" || style === "percent") return {
+			ok: true,
+			style: {
+				kind: "keyword",
+				value: style
+			},
+			options: keywordOptions(type, style)
+		};
+		if (style === "currency") return fail("icu-unknown-currency", "{…, number, currency} needs a currency code: write ::currency/EUR (with the code you need)");
+	} else if (style === "short" || style === "medium" || style === "long" || style === "full") return {
+		ok: true,
+		style: {
+			kind: "keyword",
+			value: style
+		},
+		options: keywordOptions(type, style)
+	};
+	return fail("icu-pattern-style", `"${style}" is not a ${type} style: use ${type === "number" ? "integer, percent" : "short, medium, long, full"} or a ::skeleton`);
+}
+/** FormatJS's default `formats` (intl-messageformat), copied fresh per message. */
+function keywordOptions(type, keyword) {
+	switch (type) {
+		case "number":
+			if (keyword === "integer") return { maximumFractionDigits: 0 };
+			if (keyword === "percent") return { style: "percent" };
+			return null;
+		case "date": switch (keyword) {
+			case "short": return {
+				month: "numeric",
+				day: "numeric",
+				year: "2-digit"
+			};
+			case "medium": return {
+				month: "short",
+				day: "numeric",
+				year: "numeric"
+			};
+			case "long": return {
+				month: "long",
+				day: "numeric",
+				year: "numeric"
+			};
+			case "full": return {
+				weekday: "long",
+				month: "long",
+				day: "numeric",
+				year: "numeric"
+			};
+			default: return null;
+		}
+		case "time": switch (keyword) {
+			case "short": return {
+				hour: "numeric",
+				minute: "numeric"
+			};
+			case "long":
+			case "full": return {
+				hour: "numeric",
+				minute: "numeric",
+				second: "numeric",
+				timeZoneName: "short"
+			};
+			default: return {
+				hour: "numeric",
+				minute: "numeric",
+				second: "numeric"
+			};
+		}
+	}
+}
+/** `@formatjs/icu-skeleton-parser`'s token separator (Pattern_White_Space). */
+const SKELETON_SPACE = /[\t-\r \x85\u200E\u200F\u2028\u2029]/;
+const FRACTION_PRECISION = /^\.(?:(0+)(\*)?|(#+)|(0+)(#+))$/;
+const SIGNIFICANT_PRECISION = /^(@+)(\+|#+)?([rs])?$/;
+const CONCISE_INTEGER_WIDTH = /^0+$/;
+const CONCISE_SCIENTIFIC = /^(EE?)(\+[!?])?(0+)$/;
+const SIGN$1 = {
+	"sign-auto": { signDisplay: "auto" },
+	"sign-accounting": { currencySign: "accounting" },
+	"()": { currencySign: "accounting" },
+	"sign-always": { signDisplay: "always" },
+	"+!": { signDisplay: "always" },
+	"sign-accounting-always": {
+		signDisplay: "always",
+		currencySign: "accounting"
+	},
+	"()!": {
+		signDisplay: "always",
+		currencySign: "accounting"
+	},
+	"sign-except-zero": { signDisplay: "exceptZero" },
+	"+?": { signDisplay: "exceptZero" },
+	"sign-accounting-except-zero": {
+		signDisplay: "exceptZero",
+		currencySign: "accounting"
+	},
+	"()?": {
+		signDisplay: "exceptZero",
+		currencySign: "accounting"
+	},
+	"sign-never": { signDisplay: "never" },
+	"+_": { signDisplay: "never" }
+};
+/** Option-less stems with fixed options (FormatJS `parseNumberSkeleton`). */
+const SIMPLE_STEMS = {
+	percent: { style: "percent" },
+	"%": { style: "percent" },
+	"group-off": { useGrouping: false },
+	",_": { useGrouping: false },
+	"precision-integer": { maximumFractionDigits: 0 },
+	".": { maximumFractionDigits: 0 },
+	"compact-short": {
+		notation: "compact",
+		compactDisplay: "short"
+	},
+	K: {
+		notation: "compact",
+		compactDisplay: "short"
+	},
+	"compact-long": {
+		notation: "compact",
+		compactDisplay: "long"
+	},
+	KK: {
+		notation: "compact",
+		compactDisplay: "long"
+	},
+	"notation-simple": { notation: "standard" },
+	"unit-width-narrow": {
+		currencyDisplay: "narrowSymbol",
+		unitDisplay: "narrow"
+	},
+	"unit-width-short": {
+		currencyDisplay: "code",
+		unitDisplay: "short"
+	},
+	"unit-width-full-name": {
+		currencyDisplay: "name",
+		unitDisplay: "long"
+	},
+	"unit-width-iso-code": { currencyDisplay: "symbol" },
+	"rounding-mode-floor": { roundingMode: "floor" },
+	"rounding-mode-ceiling": { roundingMode: "ceil" },
+	"rounding-mode-down": { roundingMode: "trunc" },
+	"rounding-mode-up": { roundingMode: "expand" },
+	"rounding-mode-half-even": { roundingMode: "halfEven" },
+	"rounding-mode-half-down": { roundingMode: "halfTrunc" },
+	"rounding-mode-half-up": { roundingMode: "halfExpand" }
+};
+/**
+* Converts a number skeleton (without `::`). The canonical style joins the
+* tokens with one space; options come from FormatJS's conversion.
+*/
+function numberSkeleton(skeleton) {
+	const tokens = skeleton.split(SKELETON_SPACE).filter((token) => token.length > 0);
+	if (tokens.length === 0) return fail("icu-syntax", "Expected a number skeleton after ::");
+	const options = {};
+	for (const token of tokens) {
+		const parts = token.split("/");
+		const stem = parts[0];
+		for (let i = 1; i < parts.length; i++) if (parts[i] === "") return fail("icu-syntax", `Number skeleton token "${token}" has an empty option`);
+		const problem = applyNumberStem(stem, parts, token, options);
+		if (problem !== null) return problem;
+	}
+	try {
+		new Intl.NumberFormat("en", options);
+	} catch (error) {
+		return fail("icu-unknown-skeleton", `Number skeleton "${tokens.join(" ")}" cannot be formatted: ${error.message}`);
+	}
+	return {
+		ok: true,
+		style: {
+			kind: "skeleton",
+			value: tokens.join(" ")
+		},
+		options: nonEmpty(options)
+	};
+}
+function applyNumberStem(stem, parts, token, options) {
+	const optionCount = parts.length - 1;
+	const simple = Object.hasOwn(SIMPLE_STEMS, stem) ? SIMPLE_STEMS[stem] : void 0;
+	if (simple !== void 0) {
+		if (optionCount > 0) return unknownStem(token, `${stem} takes no option`);
+		Object.assign(options, simple);
+		return null;
+	}
+	switch (stem) {
+		case "currency": {
+			const code = parts[1];
+			if (optionCount !== 1 || code === void 0) return fail("icu-unknown-currency", `${token} needs one currency code: write ::currency/EUR (with the code you need)`);
+			if (!supportedCurrencies().has(code)) return fail("icu-unknown-currency", `Unknown currency code "${code}": use an ISO 4217 code such as EUR`);
+			options.style = "currency";
+			options.currency = code;
+			return null;
+		}
+		case "measure-unit":
+		case "unit": {
+			const written = parts[1];
+			if (optionCount !== 1 || written === void 0) return fail("icu-unknown-unit", `${token} needs one unit: write ::unit/kilometer or ::measure-unit/length-meter`);
+			const unit = written.replace(/^(.*?)-/, "");
+			if (stem === "unit" && unit !== written) return fail("icu-unknown-unit", isSupportedUnit(unit) && !isSupportedUnit(written) ? `${token} has a unit type: write ::unit/${unit} or ::measure-unit/${written}` : `${token} names a hyphenated unit, which ::unit/ cannot express: write ::measure-unit/<type>-${written}, as in ::measure-unit/volume-fluid-ounce or ::measure-unit/speed-kilometer-per-hour`);
+			if (!isSupportedUnit(unit)) return fail("icu-unknown-unit", `Unknown unit "${written}": use a unit Intl.NumberFormat supports, such as kilometer`);
+			options.style = "unit";
+			options.unit = unit;
+			return null;
+		}
+		case "scientific":
+		case "engineering":
+			options.notation = stem;
+			for (let i = 1; i < parts.length; i++) {
+				const option = parts[i];
+				if (!Object.hasOwn(SIGN$1, option)) return unknownStem(token, `"${option}" is not a sign option`);
+				Object.assign(options, SIGN$1[option]);
+			}
+			return null;
+		case "integer-width": {
+			const match = optionCount === 1 ? /^\*(0+)$/.exec(parts[1]) : null;
+			if (match === null) return unknownStem(token, "vi18n supports integer-width/*0… (a minimum) only");
+			options.minimumIntegerDigits = match[1].length;
+			return null;
+		}
+		case "scale":
+		case "%x100": return unknownStem(token, "scaling is not supported: scale the value before formatting it");
+	}
+	if (CONCISE_INTEGER_WIDTH.test(stem)) {
+		if (optionCount > 0) return unknownStem(token, `${stem} takes no option`);
+		options.minimumIntegerDigits = stem.length;
+		return null;
+	}
+	const fraction = FRACTION_PRECISION.exec(stem);
+	if (fraction !== null) {
+		if (optionCount > 1) return unknownStem(token, "fraction precision takes at most one option");
+		const [, zeros, star, hashes, minZeros, maxHashes] = fraction;
+		if (star === "*") options.minimumFractionDigits = zeros.length;
+		else if (hashes !== void 0) options.maximumFractionDigits = hashes.length;
+		else if (minZeros !== void 0 && maxHashes !== void 0) {
+			options.minimumFractionDigits = minZeros.length;
+			options.maximumFractionDigits = minZeros.length + maxHashes.length;
+		} else {
+			options.minimumFractionDigits = zeros.length;
+			options.maximumFractionDigits = zeros.length;
+		}
+		const option = parts[1];
+		if (option === "w") options.trailingZeroDisplay = "stripIfInteger";
+		else if (option !== void 0 && !applySignificant(option, options)) return unknownStem(token, `"${option}" is neither w nor a significant-digits option such as @@#`);
+		return null;
+	}
+	if (stem.startsWith("@")) {
+		if (optionCount > 0) return unknownStem(token, `${stem} takes no option`);
+		if (!applySignificant(stem, options)) return unknownStem(token, "malformed significant digits");
+		return null;
+	}
+	if (Object.hasOwn(SIGN$1, stem)) {
+		if (optionCount > 0) return unknownStem(token, `${stem} takes no option`);
+		Object.assign(options, SIGN$1[stem]);
+		return null;
+	}
+	const concise = CONCISE_SCIENTIFIC.exec(stem);
+	if (concise !== null) {
+		if (optionCount > 0) return unknownStem(token, `${stem} takes no option`);
+		options.notation = concise[1] === "EE" ? "engineering" : "scientific";
+		if (concise[2] === "+!") options.signDisplay = "always";
+		else if (concise[2] === "+?") options.signDisplay = "exceptZero";
+		options.minimumIntegerDigits = concise[3].length;
+		return null;
+	}
+	return unknownStem(token, "not a number skeleton stem vi18n supports");
+}
+/** FormatJS `parseSignificantPrecision`, restricted to inputs it does not crash on. */
+function applySignificant(text, options) {
+	const match = SIGNIFICANT_PRECISION.exec(text);
+	if (match === null) return false;
+	const [, ats, extra, priority] = match;
+	if (priority === "r") options.roundingPriority = "morePrecision";
+	else if (priority === "s") options.roundingPriority = "lessPrecision";
+	if (extra === void 0) {
+		options.minimumSignificantDigits = ats.length;
+		options.maximumSignificantDigits = ats.length;
+	} else if (extra === "+") options.minimumSignificantDigits = ats.length;
+	else {
+		options.minimumSignificantDigits = ats.length;
+		options.maximumSignificantDigits = ats.length + extra.length;
+	}
+	return true;
+}
+function unknownStem(token, why) {
+	return fail("icu-unknown-skeleton", `Unsupported skeleton token "${token}": ${why}`);
+}
+/**
+* FormatJS's field regex (runs of one symbol), plus `j` and `J`, which
+* FormatJS resolves only when given a locale. FormatJS skips quoted text with
+* a lookahead that rescans the rest of the skeleton at every letter, which is
+* quadratic; `unquotedFields` masks quoted text first instead.
+*/
+const DATE_FIELD = /(?:[Eec]{1,6}|G{1,5}|[Qq]{1,5}|(?:[yYur]+|U{1,5})|[ML]{1,5}|d{1,2}|D{1,3}|F{1}|[abB]{1,5}|[hkHK]{1,2}|[jJ]{1,2}|w{1,2}|W{1}|m{1,2}|s{1,2}|[zZOvVxX]{1,4})/g;
+/**
+* The skeleton with every character FormatJS's lookahead
+* `(?=([^']*'[^']*')*[^']*$)` treats as quoted (an odd number of apostrophes
+* follows it) replaced by a space, in linear time.
+*/
+function unquotedFields(value) {
+	let following = 0;
+	for (let i = 0; i < value.length; i++) if (value.charCodeAt(i) === 39) following++;
+	if (following === 0) return value;
+	let out = "";
+	let start = 0;
+	for (let i = 0; i <= value.length; i++) {
+		if (i < value.length && value.charCodeAt(i) !== 39) continue;
+		out += following % 2 === 0 ? value.slice(start, i) : " ".repeat(i - start);
+		if (i < value.length) {
+			out += "'";
+			following--;
+		}
+		start = i + 1;
+	}
+	return out;
+}
+const NUMERIC_2DIGIT = ["numeric", "2-digit"];
+const MONTH_WIDTHS = [
+	"numeric",
+	"2-digit",
+	"short",
+	"long",
+	"narrow"
+];
+const LOCAL_WEEKDAY = [
+	"short",
+	"long",
+	"narrow",
+	"short"
+];
+const HOUR_CYCLES = {
+	h: "h12",
+	H: "h23",
+	K: "h11",
+	k: "h24"
+};
+/**
+* Converts a date/time skeleton (without `::`). Like FormatJS, characters that
+* are not ASCII letters, and quoted text, are ignored; unlike FormatJS, an
+* unknown or unsupported letter, a mixed run (`yY`) or a field given twice is
+* rejected.
+*/
+function dateSkeleton(skeleton) {
+	const tokens = skeleton.split(SKELETON_SPACE).filter((token) => token.length > 0);
+	if (tokens.length === 0) return fail("icu-syntax", "Expected a date skeleton after ::");
+	const value = tokens.join(" ");
+	const options = {};
+	let covered = 0;
+	let letters = 0;
+	let quoted = false;
+	for (let i = 0; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c === 39) quoted = !quoted;
+		else if (!quoted && isAsciiLetter$1(c)) letters++;
+	}
+	const fields = unquotedFields(value);
+	DATE_FIELD.lastIndex = 0;
+	for (let match = DATE_FIELD.exec(fields); match !== null; match = DATE_FIELD.exec(fields)) {
+		const run = match[0];
+		covered += run.length;
+		const problem = applyDateField(run, options);
+		if (problem !== null) return problem;
+	}
+	if (covered !== letters) {
+		quoted = false;
+		for (let i = 0; i < value.length; i++) {
+			const c = value.charCodeAt(i);
+			if (c === 39) quoted = !quoted;
+			else if (!quoted && isAsciiLetter$1(c) && !/[EecGQqyYurUMLdDFabBhkHKjJwWmszZOvVxX]/.test(value[i])) return unknownDate(value[i], "not a date field symbol");
+		}
+		return unknownDate(value, "a field is longer than its symbol allows");
+	}
+	return {
+		ok: true,
+		style: {
+			kind: "skeleton",
+			value
+		},
+		options: nonEmpty(options)
+	};
+}
+function applyDateField(run, options) {
+	const symbol = run[0];
+	const length = run.length;
+	for (let i = 1; i < length; i++) if (run[i] !== symbol) return unknownDate(run, "mixes field symbols");
+	const set = (option, value) => {
+		if (Object.hasOwn(options, option)) return unknownDate(run, `repeats the ${option} field`);
+		options[option] = value;
+		return null;
+	};
+	switch (symbol) {
+		case "G": return set("era", length === 4 ? "long" : length === 5 ? "narrow" : "short");
+		case "y": return set("year", length === 2 ? "2-digit" : "numeric");
+		case "M":
+		case "L": return set("month", MONTH_WIDTHS[length - 1]);
+		case "d": return set("day", NUMERIC_2DIGIT[length - 1]);
+		case "E": return set("weekday", length === 4 ? "long" : length === 5 ? "narrow" : "short");
+		case "e":
+		case "c":
+			if (length < 4) return unknownDate(run, "numeric weekdays are not supported; use EEE or EEEE");
+			return set("weekday", LOCAL_WEEKDAY[length - 3]);
+		case "a": return set("hour12", true);
+		case "h":
+		case "H":
+		case "K":
+		case "k": return set("hourCycle", HOUR_CYCLES[symbol]) ?? set("hour", NUMERIC_2DIGIT[length - 1]);
+		case "j": return set("hour", NUMERIC_2DIGIT[length - 1]);
+		case "J": return set("hourCycle", "h23") ?? set("hour", NUMERIC_2DIGIT[length - 1]);
+		case "m": return set("minute", NUMERIC_2DIGIT[length - 1]);
+		case "s": return set("second", NUMERIC_2DIGIT[length - 1]);
+		case "z": return set("timeZoneName", length < 4 ? "short" : "long");
+		case "Y":
+		case "u":
+		case "U":
+		case "r": return unknownDate(run, "use y for the year");
+		case "D":
+		case "F": return unknownDate(run, "use d for the day");
+		case "b":
+		case "B": return unknownDate(run, "use a for the day period, or j for the locale's preferred hour");
+		case "Z":
+		case "O":
+		case "v":
+		case "V":
+		case "X":
+		case "x": return unknownDate(run, "use z for the time zone");
+		default: return unknownDate(run, "Intl.DateTimeFormat cannot format this field");
+	}
+}
+function unknownDate(field, why) {
+	return fail("icu-unknown-skeleton", `Unsupported date skeleton field "${field}": ${why}`);
+}
+function isAsciiLetter$1(c) {
+	return c >= 65 && c <= 90 || c >= 97 && c <= 122;
+}
+function nonEmpty(options) {
+	for (const _ in options) return options;
+	return null;
+}
+let currencies;
+let units;
+function supportedCurrencies() {
+	return currencies ??= new Set(Intl.supportedValuesOf("currency"));
+}
+/** A sanctioned unit, or `<unit>-per-<unit>` of two (what Intl.NumberFormat accepts). */
+function isSupportedUnit(unit) {
+	units ??= new Set(Intl.supportedValuesOf("unit"));
+	if (units.has(unit)) return true;
+	const per = unit.indexOf("-per-");
+	return per > 0 && units.has(unit.slice(0, per)) && units.has(unit.slice(per + 5));
+}
+//#endregion
+//#region src/core/icu/parse.ts
+/**
+* ICU MessageFormat 1 in FormatJS's dialect (INTERNALS §2.1), written as one
+* recursive-descent pass over UTF-16 code units: every syntax character is
+* ASCII, so literal text is copied by slices and never walked by code point.
+*
+* Deviations from `@formatjs/icu-messageformat-parser` 3.5.21, each tested:
+* standalone tags (`<br/>`) are tag nodes; RBNF types, `choice`, pattern
+* styles, unknown skeletons, currencies and units are rejected; `=N` keys are
+* normalised (so `=1` and `=01` are duplicates); and `#` follows the
+* pound-sensitivity rule below instead of looking at the parent argument only.
+*/
+const TAB$1 = 9;
+const CR$2 = 13;
+const SPACE$1 = 32;
+const HASH$1 = 35;
+const APOS = 39;
+const PLUS$1 = 43;
+const COMMA = 44;
+const MINUS$1 = 45;
+const SLASH$1 = 47;
+const COLON$1 = 58;
+const LT = 60;
+const EQUALS$1 = 61;
+const GT = 62;
+const LBRACE$1 = 123;
+const RBRACE$1 = 125;
+/** `[^\p{White_Space}\p{Pattern_Syntax}]*`: FormatJS's argument and selector names. */
+const IDENTIFIER = /[^\p{White_Space}\p{Pattern_Syntax}]*/uy;
+const UNSUPPORTED_TYPES = /* @__PURE__ */ new Set([
+	"spellout",
+	"ordinal",
+	"duration",
+	"choice"
+]);
+/**
+* Options and tags nested deeper than this are rejected. The parser, printer
+* and validator recurse, so without a limit one hostile catalog entry of a
+* few kilobytes overflows the stack with a RangeError instead of a diagnostic.
+*/
+const MAX_DEPTH = 200;
+/**
+* Parses a message already passed through `normalizeSource` (NFC + LF), so
+* offsets in `loc` and in errors refer to that string.
+*
+* @throws {DiagnosticError} `icu-*` with 1-based `line`/`column` in the message.
+*/
+function parseICU(source, options) {
+	return new Parser$1(source, options?.locations === true, null).parseRoot();
+}
+/**
+* Offsets of apostrophes that open quoted literal text (`'{`, `'<`, `'}`,
+* `'>`, `'#` where pound-sensitive). The apostrophe lint reports them: most
+* are a typographic apostrophe that silently swallowed a placeholder. Returns
+* what was found before a syntax error, if any.
+*/
+function quoteStarts(source) {
+	const found = [];
+	try {
+		new Parser$1(source, false, found).parseRoot();
+	} catch {}
+	return found;
+}
+/** 1-based line and column (UTF-16 code units) of an offset. */
+function positionAt(source, offset) {
+	let line = 1;
+	let lineStart = 0;
+	const end = Math.min(offset, source.length);
+	for (let i = source.indexOf("\n"); i !== -1 && i < end; i = source.indexOf("\n", i + 1)) {
+		line++;
+		lineStart = i + 1;
+	}
+	return {
+		line,
+		column: end - lineStart + 1
+	};
+}
+var Parser$1 = class {
+	src;
+	locations;
+	quotes;
+	pos = 0;
+	constructor(src, locations, quotes) {
+		this.src = src;
+		this.locations = locations;
+		this.quotes = quotes;
+	}
+	parseRoot() {
+		return this.parseMessage(0, false, false, false);
+	}
+	/**
+	* @param depth          > 0 inside an option or a tag, where `}` ends the message
+	* @param pluralParent   the nearest enclosing argument is a plural or selectordinal
+	* @param poundSensitive any enclosing argument is a plural or selectordinal
+	* @param inTag          a closing tag ends the message instead of being an error
+	*/
+	parseMessage(depth, pluralParent, poundSensitive, inTag) {
+		if (depth > MAX_DEPTH) throw this.error("icu-syntax", `Message is nested too deeply (more than ${MAX_DEPTH} levels of options and tags): split it`, this.pos);
+		const nodes = [];
+		const src = this.src;
+		while (this.pos < src.length) {
+			const c = src.charCodeAt(this.pos);
+			if (c === LBRACE$1) nodes.push(this.parseArgument(depth, poundSensitive, inTag));
+			else if (c === RBRACE$1 && depth > 0) break;
+			else if (c === HASH$1 && poundSensitive) {
+				if (!pluralParent) throw this.error("icu-pound-nested", "# is ambiguous inside a select nested in a plural: write the plural's argument (as in {count}) for the number, or '#' for a literal #", this.pos);
+				const start = this.pos++;
+				nodes.push(this.locations ? {
+					type: "pound",
+					loc: {
+						start,
+						end: this.pos
+					}
+				} : { type: "pound" });
+			} else if (c === LT && src.charCodeAt(this.pos + 1) === SLASH$1) {
+				if (inTag) break;
+				throw this.error("icu-syntax", "Closing tag without a matching opening tag", this.pos);
+			} else if (c === LT && isAsciiLetter(src.charCodeAt(this.pos + 1))) nodes.push(this.parseTag(depth, pluralParent, poundSensitive));
+			else {
+				const start = this.pos;
+				const value = this.parseLiteral(depth, poundSensitive);
+				nodes.push(this.locations ? {
+					type: "literal",
+					value,
+					loc: {
+						start,
+						end: this.pos
+					}
+				} : {
+					type: "literal",
+					value
+				});
+			}
+		}
+		return nodes;
+	}
+	/** Reads literal text up to the next syntax character, removing ICU quoting. */
+	parseLiteral(depth, poundSensitive) {
+		const src = this.src;
+		const length = src.length;
+		let value = "";
+		let pos = this.pos;
+		let run = pos;
+		while (pos < length) {
+			const c = src.charCodeAt(pos);
+			if (c === APOS) {
+				const next = src.charCodeAt(pos + 1);
+				if (next === APOS) {
+					value += src.slice(run, pos + 1);
+					pos += 2;
+					run = pos;
+					continue;
+				}
+				if (next === LBRACE$1 || next === RBRACE$1 || next === LT || next === GT || next === HASH$1 && poundSensitive) {
+					this.quotes?.push(pos);
+					value += src.slice(run, pos);
+					let quoted = pos + 1;
+					pos += 2;
+					for (;;) {
+						if (pos >= length) {
+							value += src.slice(quoted, pos);
+							break;
+						}
+						if (src.charCodeAt(pos) === APOS) {
+							if (src.charCodeAt(pos + 1) === APOS) {
+								value += src.slice(quoted, pos + 1);
+								pos += 2;
+								quoted = pos;
+								continue;
+							}
+							value += src.slice(quoted, pos);
+							pos++;
+							break;
+						}
+						pos++;
+					}
+					run = pos;
+					continue;
+				}
+				pos++;
+				continue;
+			}
+			if (c === LBRACE$1) break;
+			if (c === LT) {
+				const next = src.charCodeAt(pos + 1);
+				if (next === SLASH$1 || isAsciiLetter(next)) break;
+			} else if (c === HASH$1 && poundSensitive || c === RBRACE$1 && depth > 0) break;
+			pos++;
+		}
+		this.pos = pos;
+		if (value === "") return src.slice(run, pos);
+		return (run === pos ? value : value + src.slice(run, pos)).normalize("NFC");
+	}
+	parseTag(depth, pluralParent, poundSensitive) {
+		const start = this.pos++;
+		const name = this.parseTagName();
+		this.skipSpace();
+		if (this.src.startsWith("/>", this.pos)) {
+			this.pos += 2;
+			return this.locations ? {
+				type: "tag",
+				name,
+				children: null,
+				loc: {
+					start,
+					end: this.pos
+				}
+			} : {
+				type: "tag",
+				name,
+				children: null
+			};
+		}
+		if (this.src.charCodeAt(this.pos) !== GT) throw this.error("icu-syntax", `Malformed tag <${name}: tags have no attributes`, start);
+		this.pos++;
+		const children = this.parseMessage(depth + 1, pluralParent, poundSensitive, true);
+		const closeStart = this.pos;
+		if (!this.src.startsWith("</", this.pos)) throw this.error("icu-syntax", `Tag <${name}> is not closed: add </${name}>`, start);
+		this.pos += 2;
+		if (!isAsciiLetter(this.src.charCodeAt(this.pos))) throw this.error("icu-syntax", `Malformed closing tag for <${name}>`, closeStart);
+		const closeName = this.parseTagName();
+		if (closeName !== name) throw this.error("icu-syntax", `Closing tag </${closeName}> does not match <${name}>`, closeStart);
+		this.skipSpace();
+		if (this.src.charCodeAt(this.pos) !== GT) throw this.error("icu-syntax", `Malformed closing tag for <${name}>`, closeStart);
+		this.pos++;
+		return this.locations ? {
+			type: "tag",
+			name,
+			children,
+			loc: {
+				start,
+				end: this.pos
+			}
+		} : {
+			type: "tag",
+			name,
+			children
+		};
+	}
+	/** Assumes the current character is an ASCII letter (checked by the caller). */
+	parseTagName() {
+		const src = this.src;
+		const start = this.pos++;
+		while (this.pos < src.length) {
+			const c = src.codePointAt(this.pos);
+			if (!isTagNameChar(c)) break;
+			this.pos += c > 65535 ? 2 : 1;
+		}
+		return src.slice(start, this.pos);
+	}
+	parseArgument(depth, poundSensitive, inTag) {
+		const src = this.src;
+		const open = this.pos++;
+		this.skipSpace();
+		if (this.pos >= src.length) throw this.unclosed(open);
+		if (src.charCodeAt(this.pos) === RBRACE$1) throw this.error("icu-syntax", "Empty argument {}: name it, as in {name}", open);
+		const name = this.identifier();
+		if (name === "") throw this.malformed(open);
+		this.skipSpace();
+		if (this.pos >= src.length) throw this.unclosed(open);
+		const c = src.charCodeAt(this.pos);
+		if (c === RBRACE$1) {
+			this.pos++;
+			return this.locations ? {
+				type: "argument",
+				name,
+				loc: {
+					start: open,
+					end: this.pos
+				}
+			} : {
+				type: "argument",
+				name
+			};
+		}
+		if (c !== COMMA) throw this.malformed(open);
+		this.pos++;
+		this.skipSpace();
+		if (this.pos >= src.length) throw this.unclosed(open);
+		const typeStart = this.pos;
+		const type = this.identifier();
+		switch (type) {
+			case "number":
+			case "date":
+			case "time": return this.parseFormatted(type, name, open);
+			case "select":
+			case "plural":
+			case "selectordinal": return this.parseChoice(type, name, open, depth, poundSensitive, inTag);
+			case "": throw this.error("icu-syntax", `Expected an argument type after {${name},`, typeStart);
+			default:
+				if (UNSUPPORTED_TYPES.has(type)) throw this.error("icu-unsupported-type", type === "choice" ? "{…, choice} is not supported: use {…, plural} or {…, select}" : `{…, ${type}} is not supported because Intl cannot render it: use {…, number}, {…, plural} or {…, selectordinal}`, typeStart);
+				throw this.error("icu-syntax", `Unknown argument type "${type}": use number, date, time, select, plural or selectordinal`, typeStart);
+		}
+	}
+	parseFormatted(type, name, open) {
+		const src = this.src;
+		this.skipSpace();
+		let style = null;
+		let styleStart = this.pos;
+		if (src.charCodeAt(this.pos) === COMMA) {
+			this.pos++;
+			this.skipSpace();
+			styleStart = this.pos;
+			style = this.simpleStyle().trimEnd();
+			if (style.length === 0) throw this.error("icu-syntax", `Expected a style after {${name}, ${type},`, this.pos);
+		}
+		if (src.charCodeAt(this.pos) !== RBRACE$1) throw this.unclosed(open);
+		this.pos++;
+		const resolved = resolveStyle(type, style);
+		if (!resolved.ok) throw this.error(resolved.code, resolved.message, styleStart);
+		const node = {
+			type,
+			name,
+			style: resolved.style,
+			options: resolved.options
+		};
+		if (this.locations) node.loc = {
+			start: open,
+			end: this.pos
+		};
+		return node;
+	}
+	/** ICU `MessagePattern` simple style: up to the unbalanced `}`, quotes kept. */
+	simpleStyle() {
+		const src = this.src;
+		const start = this.pos;
+		let nested = 0;
+		while (this.pos < src.length) {
+			const c = src.charCodeAt(this.pos);
+			if (c === APOS) {
+				const close = src.indexOf("'", this.pos + 1);
+				if (close === -1) throw this.error("icu-syntax", "Unclosed quote in the argument style", this.pos);
+				this.pos = close + 1;
+			} else if (c === LBRACE$1) {
+				nested++;
+				this.pos++;
+			} else if (c === RBRACE$1) {
+				if (nested === 0) break;
+				nested--;
+				this.pos++;
+			} else this.pos++;
+		}
+		return src.slice(start, this.pos);
+	}
+	parseChoice(type, name, open, depth, poundSensitive, inTag) {
+		const src = this.src;
+		this.skipSpace();
+		if (src.charCodeAt(this.pos) !== COMMA) throw this.error("icu-syntax", `Expected options after {${name}, ${type}`, this.pos);
+		this.pos++;
+		this.skipSpace();
+		let keyStart = this.pos;
+		let selector = this.identifier();
+		let offset = 0;
+		const plural = type !== "select";
+		if (plural && selector === "offset") {
+			if (src.charCodeAt(this.pos) !== COLON$1) throw this.error("icu-syntax", "Expected offset:<integer>", this.pos);
+			this.pos++;
+			this.skipSpace();
+			offset = this.decimal("Expected an integer after offset:");
+			this.skipSpace();
+			keyStart = this.pos;
+			selector = this.identifier();
+		}
+		const options = [];
+		const keys = /* @__PURE__ */ new Set();
+		const childPoundSensitive = poundSensitive || plural;
+		for (;;) {
+			let key = selector;
+			if (key === "") {
+				if (!plural || src.charCodeAt(this.pos) !== EQUALS$1) break;
+				this.pos++;
+				key = "=" + String(this.decimal(`Expected a number after = in {${name}, ${type}}`));
+			}
+			if (keys.has(key)) throw this.error("icu-syntax", `Duplicate option "${key}" in {${name}, ${type}}`, keyStart);
+			keys.add(key);
+			this.skipSpace();
+			if (src.charCodeAt(this.pos) !== LBRACE$1) throw this.error("icu-syntax", `Expected {…} after option "${key}" in {${name}, ${type}}`, this.pos);
+			const valueOpen = this.pos++;
+			const value = this.parseMessage(depth + 1, plural, childPoundSensitive, inTag);
+			if (src.charCodeAt(this.pos) !== RBRACE$1) throw this.unclosed(valueOpen);
+			this.pos++;
+			options.push(this.locations ? {
+				key,
+				value,
+				loc: {
+					start: keyStart,
+					end: this.pos
+				}
+			} : {
+				key,
+				value
+			});
+			this.skipSpace();
+			keyStart = this.pos;
+			selector = this.identifier();
+		}
+		if (options.length === 0) throw this.error("icu-syntax", `Expected at least one option in {${name}, ${type}}`, this.pos);
+		if (!keys.has("other")) throw this.error("icu-missing-other", `{${name}, ${type}} needs an other {…} option`, open);
+		if (src.charCodeAt(this.pos) !== RBRACE$1) throw this.unclosed(open);
+		this.pos++;
+		if (type === "select") return this.locations ? {
+			type: "select",
+			name,
+			options,
+			loc: {
+				start: open,
+				end: this.pos
+			}
+		} : {
+			type: "select",
+			name,
+			options
+		};
+		const node = {
+			type: "plural",
+			pluralType: type === "plural" ? "cardinal" : "ordinal",
+			name,
+			offset,
+			options
+		};
+		if (this.locations) node.loc = {
+			start: open,
+			end: this.pos
+		};
+		return node;
+	}
+	/** FormatJS `tryParseDecimalInteger`: optional sign, ASCII digits, a safe integer. */
+	decimal(expected) {
+		const src = this.src;
+		const start = this.pos;
+		let sign = 1;
+		const c = src.charCodeAt(this.pos);
+		if (c === PLUS$1) this.pos++;
+		else if (c === MINUS$1) {
+			sign = -1;
+			this.pos++;
+		}
+		const digits = this.pos;
+		let value = 0;
+		while (this.pos < src.length) {
+			const d = src.charCodeAt(this.pos) - 48;
+			if (d < 0 || d > 9) break;
+			value = value * 10 + d;
+			this.pos++;
+		}
+		if (this.pos === digits) throw this.error("icu-syntax", expected, start);
+		if (!Number.isSafeInteger(value)) throw this.error("icu-syntax", "Number is too large", start);
+		return sign * value + 0;
+	}
+	identifier() {
+		IDENTIFIER.lastIndex = this.pos;
+		const match = IDENTIFIER.exec(this.src);
+		const name = match === null ? "" : match[0];
+		this.pos += name.length;
+		return name;
+	}
+	/** FormatJS `bumpSpace`: Pattern_White_Space (note: LRM/RLM yes, NBSP no). */
+	skipSpace() {
+		const src = this.src;
+		while (this.pos < src.length) {
+			const c = src.charCodeAt(this.pos);
+			if (c >= TAB$1 && c <= CR$2 || c === SPACE$1 || c === 133 || c === 8206 || c === 8207 || c === 8232 || c === 8233) this.pos++;
+			else break;
+		}
+	}
+	unclosed(open) {
+		return this.error("icu-syntax", "Argument is not closed: expected }", open);
+	}
+	malformed(open) {
+		return this.error("icu-syntax", "Malformed argument: names cannot contain spaces or ICU syntax characters", open);
+	}
+	error(code, message, offset) {
+		const { line, column } = positionAt(this.src, offset);
+		return diagnosticError({
+			code,
+			severity: "error",
+			message,
+			line,
+			column
+		});
+	}
+};
+function isAsciiLetter(c) {
+	return c >= 65 && c <= 90 || c >= 97 && c <= 122;
+}
+/** FormatJS `_isPotentialElementNameChar` (custom-element name characters); MF2 markup names are checked with it too. */
+function isTagNameChar(c) {
+	return c === 45 || c === 46 || c >= 48 && c <= 57 || c === 95 || c >= 97 && c <= 122 || c >= 65 && c <= 90 || c === 183 || c >= 192 && c <= 214 || c >= 216 && c <= 246 || c >= 248 && c <= 893 || c >= 895 && c <= 8191 || c >= 8204 && c <= 8205 || c >= 8255 && c <= 8256 || c >= 8304 && c <= 8591 || c >= 11264 && c <= 12271 || c >= 12289 && c <= 55295 || c >= 63744 && c <= 64975 || c >= 65008 && c <= 65533 || c >= 65536 && c <= 983039;
+}
+//#endregion
+//#region src/core/mf2/syntax.ts
+/**
+* MessageFormat 2 syntax (Unicode LDML part 9, `message.abnf`) read into its
+* data model, with the spec's data-model errors (PLAN §4.2, INTERNALS §2.1.4).
+* This is the second front end: `lower.ts` turns the result into the ICU AST
+* that validation, ids, catalogs and the IR compiler already read, so nothing
+* after the parser knows MF2 exists.
+*
+* One pass over UTF-16 code units; names are read by code point. Every error
+* is `icu-syntax` with an "MF2:" message and a 1-based position.
+*/
+const NUL = 0;
+const TAB = 9;
+const LF = 10;
+const CR$1 = 13;
+const SPACE = 32;
+const HASH = 35;
+const DOLLAR = 36;
+const PLUS = 43;
+const MINUS = 45;
+const DOT = 46;
+const SLASH = 47;
+const COLON = 58;
+const EQUALS = 61;
+const AT = 64;
+const BACKSLASH = 92;
+const UNDERSCORE = 95;
+const LBRACE = 123;
+const PIPE = 124;
+const RBRACE = 125;
+const IDEOGRAPHIC_SPACE = 12288;
+/** `ws`: SP, HTAB, CR, LF, U+3000. */
+const isWs = (c) => c === SPACE || c === TAB || c === LF || c === CR$1 || c === IDEOGRAPHIC_SPACE;
+/** `bidi`: ALM, LRM, RLM and the four isolates. */
+const isBidi = (c) => c === 1564 || c === 8206 || c === 8207 || c >= 8294 && c <= 8297;
+/** `name-start`, by code point. */
+function isNameStart(c) {
+	if (c < 161) return c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === PLUS || c === UNDERSCORE;
+	return (c <= 1563 || c >= 1565 && c <= 5759 || c >= 5761 && c <= 8191 || c >= 8203 && c <= 8205 || c >= 8208 && c <= 8231 || c >= 8240 && c <= 8286 || c >= 8288 && c <= 8293 || c >= 8298 && c <= 12287 || c >= 12289 && c <= 55295 || c >= 57344 && c <= 64975 || c >= 65008 && c <= 65533 || c >= 65536 && c <= 1114109) && (c & 65534) !== 65534;
+}
+const isNameChar = (c) => isNameStart(c) || c >= 48 && c <= 57 || c === MINUS || c === DOT;
+/**
+* Every MF2 diagnostic: syntax and data-model errors are `icu-syntax`, and
+* what vi18n cannot express is `icu-unsupported-type` (`lower.ts`), so the
+* CLI, catalogs and `check` report them like any invalid message.
+*/
+function mf2Error(source, message, offset, code = "icu-syntax") {
+	const { line, column } = positionAt(source, offset);
+	return diagnosticError({
+		code,
+		severity: "error",
+		message: `MF2: ${message}`,
+		line,
+		column
+	});
+}
+/**
+* Parses a message already passed through `normalizeSource` (NFC + LF).
+*
+* @throws {DiagnosticError} `icu-syntax` for syntax and data-model errors.
+*/
+function parseMf2Syntax(source) {
+	const message = new Parser(source).message();
+	checkDataModel(source, message);
+	return message;
+}
+var Parser = class {
+	src;
+	pos = 0;
+	constructor(src) {
+		this.src = src;
+	}
+	message() {
+		this.optional();
+		if (this.at(DOT) || this.src.startsWith("{{", this.pos)) return this.complex();
+		this.pos = 0;
+		return {
+			declarations: [],
+			selectors: [],
+			variants: [],
+			pattern: this.pattern(false),
+			matchAt: 0
+		};
+	}
+	complex() {
+		const declarations = [];
+		for (;;) {
+			this.optional();
+			const at = this.pos;
+			if (this.keyword(".input")) {
+				this.optional();
+				if (!this.at(LBRACE)) throw this.fail("expected {$variable …} after .input");
+				const value = this.expression();
+				if (value.operand?.type !== "variable") throw this.fail(".input declares a variable: write .input {$name …}", value.at);
+				declarations.push({
+					kind: "input",
+					name: value.operand.name,
+					value,
+					at
+				});
+			} else if (this.keyword(".local")) {
+				this.space("expected a space after .local");
+				if (!this.at(DOLLAR)) throw this.fail("expected $variable after .local");
+				const name = this.variable();
+				this.optional();
+				if (!this.at(EQUALS)) throw this.fail(`expected = after .local $${name}`);
+				this.pos++;
+				this.optional();
+				if (!this.at(LBRACE)) throw this.fail(`expected {…} after .local $${name} =`);
+				declarations.push({
+					kind: "local",
+					name,
+					value: this.expression(),
+					at
+				});
+			} else if (this.keyword(".match")) return this.matcher(declarations, at);
+			else if (this.src.startsWith("{{", this.pos)) {
+				this.pos += 2;
+				const pattern = this.pattern(true);
+				this.end();
+				return {
+					declarations,
+					selectors: [],
+					variants: [],
+					pattern,
+					matchAt: 0
+				};
+			} else if (this.at(DOT)) throw this.fail("unknown keyword: use .input, .local or .match");
+			else throw this.fail("expected a declaration, .match or a {{…}} body");
+		}
+	}
+	matcher(declarations, matchAt) {
+		const selectors = [];
+		for (;;) {
+			const save = this.pos;
+			if (!this.optional() || !this.at(DOLLAR)) {
+				this.pos = save;
+				break;
+			}
+			selectors.push(this.variable());
+		}
+		if (selectors.length === 0) throw this.fail("expected $variable after .match");
+		this.space("expected a space before the first variant");
+		const variants = [];
+		for (;;) {
+			const at = this.pos;
+			const keys = [this.key()];
+			for (;;) {
+				const spaced = this.optional();
+				if (this.src.startsWith("{{", this.pos)) break;
+				if (!spaced) throw this.fail("expected a space between keys, or {{");
+				keys.push(this.key());
+			}
+			this.pos += 2;
+			variants.push({
+				keys,
+				pattern: this.pattern(true),
+				at
+			});
+			this.optional();
+			if (this.pos >= this.src.length) break;
+		}
+		return {
+			declarations,
+			selectors,
+			variants,
+			pattern: null,
+			matchAt
+		};
+	}
+	key() {
+		const c = this.src.charCodeAt(this.pos);
+		if (c === 42) {
+			this.pos++;
+			return null;
+		}
+		if (c === PIPE || isNameChar(this.codePoint())) return this.literal().value;
+		throw this.fail("expected a key: a literal or *");
+	}
+	/**
+	* A pattern up to the end of the message (simple) or up to `}}` (quoted).
+	* Text keeps every character but the escapes.
+	*/
+	pattern(quoted) {
+		const src = this.src;
+		const parts = [];
+		let text = "";
+		let run = this.pos;
+		for (;;) {
+			if (this.pos >= src.length) {
+				if (quoted) throw this.fail("the pattern is not closed: add }}");
+				text += src.slice(run, this.pos);
+				break;
+			}
+			const c = src.charCodeAt(this.pos);
+			if (c === BACKSLASH) {
+				text += src.slice(run, this.pos) + this.escape();
+				run = this.pos;
+			} else if (c === LBRACE) {
+				text += src.slice(run, this.pos);
+				if (text !== "") parts.push(text);
+				text = "";
+				parts.push(this.placeholder());
+				run = this.pos;
+			} else if (c === RBRACE) {
+				if (!quoted || src.charCodeAt(this.pos + 1) !== RBRACE) throw this.fail("} must be escaped as \\} in text");
+				text += src.slice(run, this.pos);
+				this.pos += 2;
+				break;
+			} else this.textChar(c);
+		}
+		if (text !== "") parts.push(text);
+		return parts;
+	}
+	/** Moves past one text code point, rejecting NUL and lone surrogates. */
+	textChar(c) {
+		if (c === NUL) throw this.fail("NUL is not allowed in a message");
+		if (c >= 55296 && c <= 57343) {
+			const next = this.src.charCodeAt(this.pos + 1);
+			if (c > 56319 || !(next >= 56320 && next <= 57343)) throw this.fail("lone surrogate code unit");
+			this.pos += 2;
+			return;
+		}
+		this.pos++;
+	}
+	escape() {
+		const next = this.src.charCodeAt(this.pos + 1);
+		if (next === BACKSLASH || next === LBRACE || next === PIPE || next === RBRACE) {
+			this.pos += 2;
+			return String.fromCharCode(next);
+		}
+		throw this.fail("\\ escapes only \\, {, | and }");
+	}
+	placeholder() {
+		const at = this.pos++;
+		this.optional();
+		const c = this.src.charCodeAt(this.pos);
+		if (c === HASH || c === SLASH) return this.markup(at, c === HASH);
+		this.pos = at;
+		return this.expression();
+	}
+	/** `{` o (literal | variable | function) … `}`; markup is not an expression. */
+	expression() {
+		const at = this.pos++;
+		this.optional();
+		let operand = null;
+		let fn = null;
+		const c = this.src.charCodeAt(this.pos);
+		if (c === DOLLAR) operand = {
+			type: "variable",
+			name: this.variable()
+		};
+		else if (c === COLON) fn = this.fn();
+		else if (c === PIPE || isNameChar(this.codePoint())) operand = this.literal();
+		else if (c === HASH || c === SLASH) throw this.fail("markup cannot be used here");
+		else throw this.fail("expected a value, $variable or :function in {…}");
+		let attributes = false;
+		for (;;) {
+			const spaced = this.optional();
+			if (this.at(RBRACE)) {
+				this.pos++;
+				return {
+					type: "expression",
+					operand,
+					fn,
+					at
+				};
+			}
+			if (!spaced) throw this.fail("expected a space or }");
+			if (this.at(COLON) && fn === null && !attributes) fn = this.fn();
+			else if (this.at(AT)) {
+				this.attribute();
+				attributes = true;
+			} else throw this.fail("expected :function, @attribute or }");
+		}
+	}
+	markup(at, open) {
+		this.pos++;
+		const name = this.identifier();
+		const options = this.options();
+		let kind = open ? "open" : "close";
+		for (;;) {
+			const spaced = this.optional();
+			if (this.at(RBRACE)) break;
+			if (open && this.at(SLASH)) {
+				this.pos++;
+				if (!this.at(RBRACE)) throw this.fail("expected } after /");
+				kind = "standalone";
+				break;
+			}
+			if (!spaced || !this.at(AT)) throw this.fail("expected @attribute or }");
+			this.attribute();
+		}
+		this.pos++;
+		return {
+			type: "markup",
+			kind,
+			name,
+			options,
+			at
+		};
+	}
+	/** `:` identifier *(s option). */
+	fn() {
+		this.pos++;
+		return {
+			name: this.identifier(),
+			options: this.options()
+		};
+	}
+	options() {
+		const options = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (;;) {
+			const save = this.pos;
+			if (!this.optional() || !this.nameStartsHere()) {
+				this.pos = save;
+				return options;
+			}
+			const at = this.pos;
+			const name = this.identifier();
+			this.optional();
+			if (!this.at(EQUALS)) throw this.fail(`expected = after the option ${name}`);
+			this.pos++;
+			this.optional();
+			const value = this.at(DOLLAR) ? {
+				type: "variable",
+				name: this.variable()
+			} : this.literal();
+			if (seen.has(name)) throw this.fail(`the option ${name} is given twice`, at);
+			seen.add(name);
+			options.push({
+				name,
+				value
+			});
+		}
+	}
+	/** `@` identifier [o `=` o literal]. Attributes never change the output. */
+	attribute() {
+		this.pos++;
+		this.identifier();
+		const save = this.pos;
+		this.optional();
+		if (!this.at(EQUALS)) {
+			this.pos = save;
+			return;
+		}
+		this.pos++;
+		this.optional();
+		this.literal();
+	}
+	literal() {
+		const src = this.src;
+		if (this.at(PIPE)) {
+			this.pos++;
+			let value = "";
+			let run = this.pos;
+			for (;;) {
+				if (this.pos >= src.length) throw this.fail("the literal is not closed: add |");
+				const c = src.charCodeAt(this.pos);
+				if (c === PIPE) break;
+				if (c === BACKSLASH) {
+					value += src.slice(run, this.pos) + this.escape();
+					run = this.pos;
+				} else this.textChar(c);
+			}
+			value += src.slice(run, this.pos);
+			this.pos++;
+			return {
+				type: "literal",
+				value
+			};
+		}
+		const start = this.pos;
+		while (this.pos < src.length && isNameChar(this.codePoint())) this.advance();
+		if (this.pos === start) throw this.fail("expected a literal");
+		return {
+			type: "literal",
+			value: src.slice(start, this.pos)
+		};
+	}
+	variable() {
+		this.pos++;
+		return this.name();
+	}
+	/** [namespace `:`] name. */
+	identifier() {
+		const first = this.name();
+		if (!this.at(COLON)) return first;
+		this.pos++;
+		return first + ":" + this.name();
+	}
+	/** [bidi] name-start *name-char [bidi]; the marks are not part of the name. */
+	name() {
+		if (isBidi(this.src.charCodeAt(this.pos))) this.pos++;
+		if (!isNameStart(this.codePoint())) throw this.fail("expected a name");
+		const start = this.pos;
+		while (this.pos < this.src.length && isNameChar(this.codePoint())) this.advance();
+		const name = this.src.slice(start, this.pos);
+		if (isBidi(this.src.charCodeAt(this.pos))) this.pos++;
+		return name;
+	}
+	nameStartsHere() {
+		const c = this.src.charCodeAt(this.pos);
+		return isBidi(c) || isNameStart(this.codePoint());
+	}
+	/** `s`: whitespace (with bidi marks) that must contain a ws character. */
+	space(expected) {
+		if (!this.optional()) throw this.fail(expected);
+	}
+	/** `o`: skips whitespace and bidi marks; true when a ws character was among them. */
+	optional() {
+		let ws = false;
+		for (;;) {
+			const c = this.src.charCodeAt(this.pos);
+			if (isWs(c)) ws = true;
+			else if (!isBidi(c)) return ws;
+			this.pos++;
+		}
+	}
+	/**
+	* Keywords are case-sensitive. What may follow one (`{`, whitespace, `$`)
+	* is checked by the caller, so `.inputs` fails there.
+	*/
+	keyword(word) {
+		if (!this.src.startsWith(word, this.pos)) return false;
+		this.pos += word.length;
+		return true;
+	}
+	end() {
+		this.optional();
+		if (this.pos < this.src.length) throw this.fail("unexpected text after the message body");
+	}
+	at(c) {
+		return this.src.charCodeAt(this.pos) === c;
+	}
+	codePoint() {
+		return this.src.codePointAt(this.pos) ?? -1;
+	}
+	advance() {
+		this.pos += this.src.codePointAt(this.pos) > 65535 ? 2 : 1;
+	}
+	fail(message, offset = this.pos) {
+		return mf2Error(this.src, message, offset);
+	}
+};
+/**
+* The spec's data-model errors: duplicate declarations, selectors without
+* an annotation, variants with the wrong number of keys, a missing `* …`
+* fallback and duplicate variants.
+*/
+function checkDataModel(source, message) {
+	const mentioned = /* @__PURE__ */ new Set();
+	const declared = /* @__PURE__ */ new Map();
+	for (const declaration of message.declarations) {
+		const own = variablesOf(declaration.value);
+		if (declaration.kind === "local" && own.includes(declaration.name) || declared.has(declaration.name) || mentioned.has(declaration.name)) throw mf2Error(source, `$${declaration.name} is declared after it was used or declared: declare each variable once, before its first use`, declaration.at);
+		declared.set(declaration.name, declaration);
+		for (const name of own) mentioned.add(name);
+	}
+	if (message.pattern !== null) return;
+	for (const selector of message.selectors) if (!annotated(selector, declared, /* @__PURE__ */ new Set())) throw mf2Error(source, `.match $${selector} needs a selector function: declare it as .input {$${selector} :number} or {$${selector} :string}`, message.matchAt);
+	const count = message.selectors.length;
+	let fallback = false;
+	const seen = /* @__PURE__ */ new Set();
+	for (const variant of message.variants) {
+		if (variant.keys.length !== count) throw mf2Error(source, `this variant has ${variant.keys.length} key${variant.keys.length === 1 ? "" : "s"} for ${count} selector${count === 1 ? "" : "s"}`, variant.at);
+		if (variant.keys.every((key) => key === null)) fallback = true;
+		const id = JSON.stringify(variant.keys);
+		if (seen.has(id)) throw mf2Error(source, "two variants have the same keys", variant.at);
+		seen.add(id);
+	}
+	if (!fallback) throw mf2Error(source, `.match needs a fallback variant whose keys are all * (${Array(count).fill("*").join(" ")} {{…}})`, message.matchAt);
+}
+function variablesOf(expression) {
+	const names = [];
+	if (expression.operand?.type === "variable") names.push(expression.operand.name);
+	for (const option of expression.fn?.options ?? []) if (option.value.type === "variable") names.push(option.value.name);
+	return names;
+}
+/** A selector needs a function on its declaration or, through `.local` aliases, on one it refers to. */
+function annotated(name, declared, visiting) {
+	const declaration = declared.get(name);
+	if (declaration === void 0 || visiting.has(name)) return false;
+	if (declaration.value.fn !== null) return true;
+	const operand = declaration.value.operand;
+	visiting.add(name);
+	return operand?.type === "variable" && declaration.kind === "local" ? annotated(operand.name, declared, visiting) : false;
+}
+//#endregion
+//#region src/core/mf2/lower.ts
+/**
+* MF2 data model → the ICU AST (INTERNALS §2.1.4): the IR, ids, catalogs,
+* validation and pseudo-locales read MF2 messages exactly as they read ICU
+* ones, and the runtime gains no opcode (the reserved `.match` opcode 10
+* stays unused).
+*
+* `.match` with several selectors becomes nested select and plural
+* arguments built so that every value picks the variant MF2's pattern
+* selection picks: variants are filtered per selector and ranked by the
+* first selector, then the second, with `*` last. An exact number key is
+* preferred to a plural category, which only the runtime knows, so the case
+* of an `=N` key holds a second plural on the same argument for the
+* categories. Constant selectors (`.local $x = {a :string}`) are decided here.
+*
+* What the IR cannot express is `icu-unsupported-type`: formatting a literal
+* number, options set from variables, `:percent` as a selector, names that
+* are no ICU argument, select keys that are no ICU identifier, markup with
+* options or left open.
+*/
+const KNOWN = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"integer",
+	"percent",
+	"currency",
+	"date",
+	"time",
+	"datetime"
+]);
+const NUMERIC = /* @__PURE__ */ new Set([
+	"number",
+	"integer",
+	"percent",
+	"currency"
+]);
+/** `[^\p{White_Space}\p{Pattern_Syntax}]+`: ICU argument names and select keys. */
+const ICU_IDENTIFIER = /^[^\p{White_Space}\p{Pattern_Syntax}]+$/u;
+/** MF2's `number-literal`. */
+const NUMBER_LITERAL = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][-+]?\d+)?$/;
+/** Exact keys vi18n can match: `=N` takes integers. */
+const INTEGER_KEY = /^(?:0|-?[1-9]\d*)$/;
+/** MF2's `digit-size-option`. */
+const DIGIT_SIZE = /^(?:0|[1-9]\d?)$/;
+const CATEGORIES = [
+	"zero",
+	"one",
+	"two",
+	"few",
+	"many",
+	"other"
+];
+/**
+* Steps of the `.match` expansion one message may take. Keys multiply across
+* selectors, so a hostile or generated message could otherwise take
+* exponential time; real messages stay far below.
+*/
+const MAX_STEPS = 2e4;
+/**
+* An option problem, thrown by the style builders and turned into a
+* diagnostic where the expression's offset is known: an unknown option or
+* value is an error (`icu-syntax`), a valid one the IR cannot express is
+* `icu-unsupported-type`.
+*/
+var Unsupported = class {
+	message;
+	code;
+	constructor(message, code = "icu-unsupported-type") {
+		this.message = message;
+		this.code = code;
+	}
+};
+const invalid = (message) => new Unsupported(message, "icu-syntax");
+/**
+* Lowers a parsed MF2 message (`parseMf2Syntax`) to the ICU AST.
+*
+* @throws {DiagnosticError} `icu-syntax` (unknown function, bad operand or
+*   option) or `icu-unsupported-type` (valid MF2 that the IR cannot express).
+*/
+function lowerMf2(source, message) {
+	return new Lowering(source, message).run();
+}
+var Lowering = class {
+	source;
+	message;
+	env = /* @__PURE__ */ new Map();
+	lowered = /* @__PURE__ */ new Map();
+	steps = 0;
+	constructor(source, message) {
+		this.source = source;
+		this.message = message;
+	}
+	run() {
+		for (const declaration of this.message.declarations) this.env.set(declaration.name, this.resolve(declaration.value));
+		if (this.message.pattern !== null) return this.pattern(this.message.pattern);
+		const selectors = this.message.selectors.map((name) => this.selector(name));
+		return this.expand(selectors, 0, [this.message.variants]);
+	}
+	resolve(expression) {
+		const { operand, fn, at } = expression;
+		if (fn !== null && !KNOWN.has(fn.name)) throw this.fail(fn.name === "offset" || fn.name === "math" ? `:${fn.name} is not supported: pass the adjusted number as a value` : `unknown function :${fn.name}: use :string, :number, :integer, :percent, :currency, :date, :time or :datetime`, at, fn.name === "offset" || fn.name === "math" ? "icu-unsupported-type" : "icu-syntax");
+		let base;
+		if (operand === null) throw this.fail(`{:${fn?.name}} has no operand: write {$name :${fn?.name}}`, at);
+		else if (operand.type === "literal") base = {
+			kind: "text",
+			text: operand.value
+		};
+		else base = this.env.get(operand.name) ?? {
+			kind: "arg",
+			name: operand.name,
+			fn: null
+		};
+		if (fn === null) return base;
+		const name = fn.name;
+		const own = this.options(name, fn.options, at);
+		if (name === "string") {
+			if (base.kind === "arg") return {
+				kind: "arg",
+				name: base.name,
+				fn: annotation(name, own)
+			};
+			return {
+				kind: "text",
+				text: base.text
+			};
+		}
+		if (NUMERIC.has(name)) {
+			const merged = inherit(name, base.kind === "text" ? null : base.fn, own);
+			if (name === "currency" && !merged.options.has("currency")) throw this.fail(":currency needs currency=EUR (the ISO 4217 code)", at);
+			this.style(merged, at);
+			if (base.kind === "text") {
+				if (!NUMBER_LITERAL.test(base.text)) throw this.fail(`${JSON.stringify(base.text)} is not a number for :${name}`, at);
+				return {
+					kind: "number",
+					text: base.text,
+					fn: merged
+				};
+			}
+			if (base.kind === "number") return {
+				kind: "number",
+				text: base.text,
+				fn: merged
+			};
+			return {
+				kind: "arg",
+				name: base.name,
+				fn: merged
+			};
+		}
+		if (base.kind !== "arg") throw this.fail(`formatting a literal date depends on the time zone: pass the date as a value`, at, "icu-unsupported-type");
+		const fnDate = annotation(name, own);
+		this.style(fnDate, at);
+		return {
+			kind: "arg",
+			name: base.name,
+			fn: fnDate
+		};
+	}
+	/** Literal option values; a variable must name a constant declared earlier. */
+	options(fn, options, at) {
+		const out = /* @__PURE__ */ new Map();
+		for (const option of options) {
+			if (option.name === "u:id") continue;
+			if (option.name.startsWith("u:")) throw this.fail(option.name === "u:dir" ? "u:dir is not supported: vi18n isolates string values itself (FSI … PDI)" : `the option ${option.name} is not supported`, at, "icu-unsupported-type");
+			let value;
+			if (option.value.type === "literal") value = option.value.value;
+			else {
+				const found = this.env.get(option.value.name);
+				if (found?.kind !== "text" || option.name === "select") throw this.fail(`the option ${option.name} is set from $${option.value.name}: options must be literals`, at, "icu-unsupported-type");
+				value = found.text;
+			}
+			out.set(option.name, value);
+		}
+		if (fn === "string" && out.size > 0) throw this.fail(`:string takes no options`, at);
+		return out;
+	}
+	pattern(pattern) {
+		const root = [];
+		const stack = [];
+		let nodes = root;
+		for (const part of pattern) if (typeof part === "string") push(nodes, {
+			type: "literal",
+			value: part
+		});
+		else if (part.type === "expression") push(nodes, this.placeholder(this.resolve(part), part.at));
+		else {
+			if (!isTagName(part.name)) throw this.fail(`markup {#${part.name}} has no ICU tag equivalent: tag names start with an ASCII letter and have no namespace`, part.at, "icu-unsupported-type");
+			if (part.options.some((option) => option.name !== "u:id")) throw this.fail(`markup options are not supported: pass what {#${part.name}} needs to its tag handler`, part.at, "icu-unsupported-type");
+			if (part.kind === "standalone") push(nodes, {
+				type: "tag",
+				name: part.name,
+				children: null
+			});
+			else if (part.kind === "open") {
+				stack.push({
+					name: part.name,
+					nodes,
+					at: part.at
+				});
+				nodes = [];
+			} else {
+				const open = stack.pop();
+				if (open === void 0 || open.name !== part.name) throw this.fail(open === void 0 ? `{/${part.name}} closes markup that was never opened` : `{/${part.name}} closes {#${open.name}}: close markup in the order it was opened`, part.at, "icu-unsupported-type");
+				push(open.nodes, {
+					type: "tag",
+					name: part.name,
+					children: nodes
+				});
+				nodes = open.nodes;
+			}
+		}
+		const unclosed = stack.pop();
+		if (unclosed !== void 0) throw this.fail(`{#${unclosed.name}} is never closed: add {/${unclosed.name}} (or write {#${unclosed.name}/})`, unclosed.at, "icu-unsupported-type");
+		return root;
+	}
+	placeholder(value, at) {
+		if (value.kind === "text") return {
+			type: "literal",
+			value: value.text
+		};
+		if (value.kind === "number") throw this.fail(`formatting the literal ${value.text} depends on the locale: pass it as a value, or write it as text`, at, "icu-unsupported-type");
+		const name = this.argumentName(value.name, at);
+		const fn = value.fn;
+		if (fn === null || fn.name === "string") return {
+			type: "argument",
+			name
+		};
+		return {
+			name,
+			...this.style(fn, at)
+		};
+	}
+	/** A formatting annotation as the ICU node's type, style and options. */
+	style(fn, at) {
+		let type = "number";
+		let style;
+		try {
+			if (NUMERIC.has(fn.name)) style = numberStyle(fn);
+			else [type, style] = dateStyle(fn);
+		} catch (error) {
+			if (error instanceof Unsupported) throw this.fail(error.message, at, error.code);
+			throw error;
+		}
+		const resolved = resolveStyle(type, style);
+		if (!resolved.ok) throw this.fail(resolved.message, at, resolved.code);
+		return {
+			type,
+			style: resolved.style,
+			options: resolved.options
+		};
+	}
+	argumentName(name, at) {
+		if (!ICU_IDENTIFIER.test(name)) throw this.fail(`$${name} cannot be an ICU argument name (no punctuation such as - . +): rename it`, at, "icu-unsupported-type");
+		return name;
+	}
+	selector(name) {
+		const at = this.message.matchAt;
+		const value = this.env.get(name);
+		if (value.kind === "text") return {
+			kind: "constant",
+			text: value.text
+		};
+		const fn = value.fn;
+		if (fn.name === "string") return value.kind === "arg" ? {
+			kind: "string",
+			name: this.argumentName(value.name, at)
+		} : {
+			kind: "constant",
+			text: value.text
+		};
+		if (fn.name === "number" || fn.name === "integer") {
+			if (fn.inheritedSelect) throw this.fail(`$${name} takes select from the value it is declared from: set select on its own annotation`, at);
+			const select = fn.options.get("select") ?? "plural";
+			if (select !== "plural" && select !== "ordinal" && select !== "exact") throw this.fail(`select=${select}: use plural, ordinal or exact`, at);
+			if (value.kind === "number") return {
+				kind: "constant-number",
+				text: value.text,
+				exact: select === "exact"
+			};
+			return {
+				kind: select,
+				name: this.argumentName(value.name, at)
+			};
+		}
+		throw this.fail(fn.name === "percent" ? "selecting on :percent multiplies the value by 100, which vi18n's plural rules cannot: select on the number itself" : `:${fn.name} cannot select: use :number, :integer or :string`, at, fn.name === "percent" ? "icu-unsupported-type" : "icu-syntax");
+	}
+	/**
+	* The message for selectors `i…` when `groups` holds the variants still
+	* possible, best first: each group's variants agree on the keys of the
+	* selectors before `i`, and a group is only reached when the groups before
+	* it have no variant left that matches.
+	*/
+	expand(selectors, i, groups) {
+		if (++this.steps > MAX_STEPS) throw this.fail("this .match has too many combinations of keys: split it into several messages", this.message.matchAt, "icu-unsupported-type");
+		const live = groups.filter((group) => group.length > 0);
+		if (i === selectors.length) {
+			const variant = live[0][0];
+			let found = this.lowered.get(variant);
+			if (found === void 0) this.lowered.set(variant, found = this.pattern(variant.pattern));
+			return found;
+		}
+		const selector = selectors[i];
+		const keys = [];
+		for (const group of live) for (const variant of group) {
+			const key = variant.keys[i];
+			if (key !== null && !keys.includes(key)) keys.push(key);
+		}
+		const only = (key) => (group) => group.filter((variant) => variant.keys[i] === key);
+		const next = (...picks) => this.expand(selectors, i + 1, live.flatMap((group) => picks.map((pick) => pick(group))));
+		if (selector.kind === "constant") return next(only(selector.text), only(null));
+		if (selector.kind === "string") {
+			for (const key of keys) if (!ICU_IDENTIFIER.test(key)) throw this.fail(`the key ${JSON.stringify(key)} cannot be an ICU select key (no spaces or punctuation)`, this.message.matchAt, "icu-unsupported-type");
+			const options = keys.map((key) => ({
+				key,
+				value: next(only(key), only(null))
+			}));
+			const fallback = next(only(null));
+			const other = options.find((option) => option.key === "other");
+			if (other === void 0) options.push({
+				key: "other",
+				value: fallback
+			});
+			else if (!same(other.value, fallback)) throw this.fail(`a :string key "other" cannot be told apart from * in vi18n's IR: rename the value or merge the two variants`, this.message.matchAt, "icu-unsupported-type");
+			return this.choice({
+				type: "select",
+				name: selector.name,
+				options
+			});
+		}
+		const exact = [];
+		const categories = [];
+		for (const key of keys) if (NUMBER_LITERAL.test(key)) {
+			if (selector.kind === "constant-number") continue;
+			if (!INTEGER_KEY.test(key) || !Number.isSafeInteger(Number(key))) throw this.fail(`the key ${key} is not an integer: vi18n matches exact keys on integers`, this.message.matchAt, "icu-unsupported-type");
+			exact.push(key);
+		} else if (CATEGORIES.includes(key)) {
+			if (selector.kind !== "exact") categories.push(key);
+		} else throw this.fail(`the key ${JSON.stringify(key)} is neither a number nor a plural category (zero, one, two, few, many, other)`, this.message.matchAt);
+		if (selector.kind === "constant-number") {
+			if (categories.length > 0 && !selector.exact) throw this.fail(`the plural category of the literal ${selector.text} depends on the locale: select on a value`, this.message.matchAt, "icu-unsupported-type");
+			return next(only(String(Number(selector.text))), only(null));
+		}
+		const byCategory = (prefix) => {
+			const first = prefix === null ? [] : [only(prefix)];
+			const options = categories.map((category) => ({
+				key: category,
+				value: next(...first, only(category), only(null))
+			}));
+			const fallback = next(...first, only(null));
+			const other = options.find((option) => option.key === "other");
+			if (other === void 0) options.push({
+				key: "other",
+				value: fallback
+			});
+			else if (!same(other.value, fallback)) {
+				for (const category of CATEGORIES) if (!categories.includes(category)) options.push({
+					key: category,
+					value: fallback
+				});
+			}
+			return options;
+		};
+		const plural = (options) => this.choice({
+			type: "plural",
+			pluralType: selector.kind === "ordinal" ? "ordinal" : "cardinal",
+			name: selector.name,
+			offset: 0,
+			options
+		});
+		const options = exact.map((key) => ({
+			key: "=" + String(Number(key)),
+			value: plural(byCategory(key))
+		}));
+		options.push(...byCategory(null));
+		return plural(options);
+	}
+	/** A select or plural, or its one value when every case renders the same. */
+	choice(node) {
+		const [first, ...rest] = node.options;
+		if (first !== void 0 && rest.every((option) => same(option.value, first.value))) return first.value;
+		return [node];
+	}
+	fail(message, offset, code) {
+		return mf2Error(this.source, message, offset, code);
+	}
+};
+function annotation(name, options) {
+	return {
+		name,
+		options,
+		inheritedSelect: false
+	};
+}
+/**
+* MF2 option inheritance: a numeric annotation on a numeric value keeps the
+* value's options it has itself, its own winning; `:integer` drops fraction
+* and minimum significant digits, `:percent` integer digits, increment and
+* `select`.
+*/
+function inherit(name, prev, own) {
+	if (prev === null || !NUMERIC.has(prev.name)) return annotation(name, own);
+	const known = OPTIONS[name];
+	const dropped = name === "integer" ? [
+		"minimumFractionDigits",
+		"maximumFractionDigits",
+		"minimumSignificantDigits"
+	] : name === "percent" ? [
+		"minimumIntegerDigits",
+		"roundingIncrement",
+		"select"
+	] : [];
+	const options = /* @__PURE__ */ new Map();
+	for (const [key, value] of prev.options) if (known.includes(key) && !dropped.includes(key)) options.set(key, value);
+	const inheritedSelect = options.has("select") && !own.has("select");
+	for (const [key, value] of own) options.set(key, value);
+	return {
+		name,
+		options,
+		inheritedSelect
+	};
+}
+function push(nodes, node) {
+	if (node.type !== "literal") {
+		nodes.push(node);
+		return;
+	}
+	if (node.value === "") return;
+	const last = nodes[nodes.length - 1];
+	if (last?.type === "literal") nodes[nodes.length - 1] = {
+		type: "literal",
+		value: last.value + node.value
+	};
+	else nodes.push(node);
+}
+/** Lowered ASTs are built from plain objects in a fixed key order. */
+const same = (a, b) => a === b || JSON.stringify(a) === JSON.stringify(b);
+/** An ASCII letter, then ICU's tag name characters: no namespace. */
+function isTagName(name) {
+	if (!/^[A-Za-z]/.test(name)) return false;
+	for (const char of name.slice(1)) if (!isTagNameChar(char.codePointAt(0))) return false;
+	return true;
+}
+const SIGN = {
+	auto: "sign-auto",
+	always: "sign-always",
+	exceptZero: "sign-except-zero",
+	never: "sign-never"
+};
+const ROUNDING = {
+	ceil: "rounding-mode-ceiling",
+	floor: "rounding-mode-floor",
+	expand: "rounding-mode-up",
+	trunc: "rounding-mode-down",
+	halfExpand: "rounding-mode-half-up",
+	halfTrunc: "rounding-mode-half-down",
+	halfEven: "rounding-mode-half-even"
+};
+/** FormatJS's `unit-width-*` stems, read back to the `currencyDisplay` they give. */
+const CURRENCY_DISPLAY = {
+	narrowSymbol: "unit-width-narrow",
+	code: "unit-width-short",
+	name: "unit-width-full-name"
+};
+const OPTIONS = {
+	number: [
+		"select",
+		"signDisplay",
+		"useGrouping",
+		"minimumIntegerDigits",
+		"minimumFractionDigits",
+		"maximumFractionDigits",
+		"minimumSignificantDigits",
+		"maximumSignificantDigits",
+		"trailingZeroDisplay",
+		"roundingPriority",
+		"roundingIncrement",
+		"roundingMode"
+	],
+	integer: [
+		"select",
+		"signDisplay",
+		"useGrouping",
+		"minimumIntegerDigits",
+		"maximumSignificantDigits"
+	],
+	percent: [
+		"signDisplay",
+		"useGrouping",
+		"minimumFractionDigits",
+		"maximumFractionDigits",
+		"minimumSignificantDigits",
+		"maximumSignificantDigits",
+		"trailingZeroDisplay",
+		"roundingPriority",
+		"roundingMode"
+	],
+	currency: [
+		"currency",
+		"currencySign",
+		"currencyDisplay",
+		"useGrouping",
+		"minimumIntegerDigits",
+		"fractionDigits",
+		"minimumSignificantDigits",
+		"maximumSignificantDigits",
+		"trailingZeroDisplay",
+		"roundingPriority",
+		"roundingIncrement",
+		"roundingMode"
+	]
+};
+/**
+* A numeric annotation as an ICU number skeleton (FormatJS semantics, so the
+* options match what MF2's `Intl.NumberFormat`-named options mean). Keyword
+* styles where one says the same: `integer`, `percent`.
+*/
+function numberStyle(fn) {
+	const o = fn.options;
+	for (const key of o.keys()) if (!OPTIONS[fn.name].includes(key)) throw invalid(`:${fn.name} has no option ${key}`);
+	const digits = (key) => {
+		const value = o.get(key);
+		if (value === void 0) return null;
+		if (!DIGIT_SIZE.test(value)) throw invalid(`${key}=${value} is not a digit count`);
+		return Number(value);
+	};
+	const tokens = [];
+	if (fn.name === "integer") tokens.push(".");
+	if (fn.name === "percent") tokens.push("percent");
+	if (fn.name === "currency") tokens.push("currency/" + o.get("currency").toUpperCase());
+	const minInt = digits("minimumIntegerDigits");
+	const minFrac = digits("minimumFractionDigits");
+	const maxFrac = digits("maximumFractionDigits");
+	const minSig = digits("minimumSignificantDigits");
+	const maxSig = digits("maximumSignificantDigits");
+	if (minInt !== null) tokens.push("integer-width/*" + "0".repeat(minInt));
+	let fraction = null;
+	if (fn.name === "currency") {
+		const value = o.get("fractionDigits");
+		if (value !== void 0 && value !== "auto") {
+			if (!DIGIT_SIZE.test(value)) throw invalid(`fractionDigits=${value} is not a digit count`);
+			fraction = "." + "0".repeat(Number(value));
+		}
+	} else if (minFrac !== null || maxFrac !== null) {
+		const min = minFrac ?? 0;
+		if (maxFrac === null) fraction = min === 0 ? null : "." + "0".repeat(min) + "*";
+		else if (maxFrac < min) throw invalid("maximumFractionDigits is below minimumFractionDigits");
+		else fraction = "." + "0".repeat(min) + "#".repeat(maxFrac - min);
+	}
+	const strip = o.get("trailingZeroDisplay");
+	if (strip === "stripIfInteger") {
+		if (fraction === null || fraction.endsWith("*")) throw new Unsupported("trailingZeroDisplay=stripIfInteger needs both fraction digit counts");
+		if (fraction !== ".") fraction += "/w";
+	} else if (strip !== void 0 && strip !== "auto") throw new Unsupported(`trailingZeroDisplay=${strip} is not supported`);
+	if (fraction !== null) tokens.push(fraction);
+	let significant = null;
+	if (minSig !== null || maxSig !== null) {
+		const min = minSig ?? 1;
+		if (min < 1) throw invalid("minimumSignificantDigits must be at least 1");
+		if (maxSig === null) significant = "@".repeat(min) + "+";
+		else if (maxSig < min) throw invalid("maximumSignificantDigits is below minimumSignificantDigits");
+		else significant = "@".repeat(min) + "#".repeat(maxSig - min);
+	}
+	const priority = o.get("roundingPriority");
+	if (priority !== void 0 && priority !== "auto") {
+		if (significant === null || priority !== "morePrecision" && priority !== "lessPrecision") throw new Unsupported(`roundingPriority=${priority} needs significant digits set here`);
+		significant += priority === "morePrecision" ? "r" : "s";
+	}
+	if (significant !== null) tokens.push(significant);
+	const currencySign = o.get("currencySign");
+	if (currencySign === "accounting") tokens.push("sign-accounting");
+	else if (currencySign !== void 0 && currencySign !== "standard") throw new Unsupported(`currencySign=${currencySign} is not supported`);
+	const sign = o.get("signDisplay");
+	if (sign !== void 0 && sign !== "auto") {
+		const stem = Object.hasOwn(SIGN, sign) ? SIGN[sign] : void 0;
+		if (stem === void 0) throw new Unsupported(`signDisplay=${sign} is not supported`);
+		tokens.push(stem);
+	}
+	const grouping = o.get("useGrouping");
+	if (grouping === "never" || grouping === "false") tokens.push("group-off");
+	else if (grouping !== void 0 && grouping !== "auto") throw new Unsupported(`useGrouping=${grouping} is not supported`);
+	const display = o.get("currencyDisplay");
+	if (display !== void 0 && display !== "symbol") {
+		const stem = Object.hasOwn(CURRENCY_DISPLAY, display) ? CURRENCY_DISPLAY[display] : void 0;
+		if (stem === void 0) throw new Unsupported(`currencyDisplay=${display} is not supported`);
+		tokens.push(stem);
+	}
+	const increment = o.get("roundingIncrement");
+	if (increment !== void 0 && increment !== "1") throw new Unsupported(`roundingIncrement=${increment} is not supported`);
+	const mode = o.get("roundingMode");
+	if (mode !== void 0 && mode !== "halfExpand") {
+		const stem = Object.hasOwn(ROUNDING, mode) ? ROUNDING[mode] : void 0;
+		if (stem === void 0) throw new Unsupported(`roundingMode=${mode} is not supported`);
+		tokens.push(stem);
+	}
+	const select = o.get("select");
+	if (select !== void 0 && select !== "plural" && select !== "ordinal" && select !== "exact") throw invalid(`select=${select}: use plural, ordinal or exact`);
+	if (tokens.length === 0) return null;
+	if (tokens.length === 1 && (tokens[0] === "." || tokens[0] === "percent")) return tokens[0] === "." ? "integer" : "percent";
+	return "::" + tokens.join(" ");
+}
+const DATE_FIELDS = {
+	weekday: ["E"],
+	"day-weekday": ["d", "E"],
+	"month-day": ["M", "d"],
+	"month-day-weekday": [
+		"M",
+		"d",
+		"E"
+	],
+	"year-month-day": [
+		"y",
+		"M",
+		"d"
+	],
+	"year-month-day-weekday": [
+		"y",
+		"M",
+		"d",
+		"E"
+	]
+};
+const MONTH = {
+	short: "M",
+	medium: "MMM",
+	long: "MMMM"
+};
+const TIME = {
+	hour: "j",
+	minute: "jm",
+	second: "jms"
+};
+const ZONE = {
+	short: "z",
+	long: "zzzz"
+};
+/**
+* `:date`, `:time` and `:datetime` (MF2 semantic skeletons, Draft) as ICU
+* date skeletons: fields and length pick the fields and the month and
+* weekday widths, precision the time fields; Intl picks each locale's order.
+*/
+function dateStyle(fn) {
+	const o = fn.options;
+	const known = fn.name === "date" ? ["fields", "length"] : fn.name === "time" ? ["precision", "timeZoneStyle"] : [
+		"dateFields",
+		"dateLength",
+		"timePrecision",
+		"timeZoneStyle"
+	];
+	for (const key of o.keys()) if (!known.includes(key)) throw new Unsupported(`:${fn.name} has no option ${key} vi18n supports (Draft options and overrides are not)`);
+	const pick = (table, key, value) => {
+		if (!Object.hasOwn(table, value)) throw invalid(`${key}=${value} is not a value of ${key}`);
+		return table[value];
+	};
+	const date = (fieldsKey, lengthKey) => {
+		const fields = o.get(fieldsKey) ?? "year-month-day";
+		const length = o.get(lengthKey) ?? "medium";
+		const month = pick(MONTH, lengthKey, length);
+		if (!Object.hasOwn(DATE_FIELDS, fields)) throw invalid(`${fieldsKey}=${fields} is not a value of ${fieldsKey}`);
+		return DATE_FIELDS[fields].map((field) => field === "M" ? month : field === "E" ? length === "long" ? "EEEE" : "EEE" : field).join("");
+	};
+	const time = (precisionKey) => {
+		const zone = o.get("timeZoneStyle");
+		return pick(TIME, precisionKey, o.get(precisionKey) ?? "minute") + (zone === void 0 ? "" : pick(ZONE, "timeZoneStyle", zone));
+	};
+	if (fn.name === "date") return ["date", "::" + date("fields", "length")];
+	if (fn.name === "time") return ["time", "::" + time("precision")];
+	return ["date", "::" + date("dateFields", "dateLength") + time("timePrecision")];
+}
+//#endregion
+//#region src/core/mf2/index.ts
+/**
+* The message front ends (PLAN §4.2, INTERNALS §2.1.4): ICU MessageFormat 1,
+* and MessageFormat 2 lowered into the same ICU AST. `parseSource` is what
+* the codec, the canonical form and `@menapo/vi18n/parse` call.
+*/
+/**
+* Parses an MF2 message (simple or complex, normalised by `normalizeSource`)
+* into the ICU AST.
+*
+* @throws {DiagnosticError} `icu-syntax` or `icu-unsupported-type`.
+*/
+function parseMF2(source) {
+	return lowerMf2(source, parseMf2Syntax(source));
+}
+/**
+* True when the text, after leading whitespace and bidi marks, starts like
+* an MF2 complex message: `.input`, `.local`, `.match` or `{{`. Such a
+* message always holds a `{{…}}` pattern, which ICU rejects, so no valid ICU
+* message reads as MF2.
+*/
+function isMF2Form(source) {
+	const i = bodyStart(source);
+	return source.startsWith("{{", i) || source.startsWith(".input", i) || source.startsWith(".local", i) || source.startsWith(".match", i);
+}
+/** Past MF2's leading `o`: whitespace (with U+3000) and bidi marks. */
+function bodyStart(source) {
+	let i = 0;
+	for (; i < source.length; i++) {
+		const c = source.charCodeAt(i);
+		if (!(c === 32 || c === 9 || c === 10 || c === 13 || c === 12288) && !(c === 1564 || c === 8206 || c === 8207 || c >= 8294 && c <= 8297)) break;
+	}
+	return i;
+}
+/**
+* Parses a normalised message: as ICU, and as MF2 when the ICU parse fails
+* and the text has MF2's complex form (or `syntax` says which). A valid ICU
+* message never changes meaning, and an MF2 message gets MF2's errors.
+*
+* @throws {DiagnosticError} `icu-*` from the parser that applies.
+*/
+function parseSource(source, syntax = "auto") {
+	if (syntax === "mf2") return parseMF2(source);
+	try {
+		return parseICU(source);
+	} catch (error) {
+		if (syntax === "icu" || !isDiagnosticError(error)) throw error;
+		if (isMF2Form(source)) {
+			const message = parseMF2(source);
+			if (!message.every((node) => node.type === "literal") || !source.startsWith("{{", bodyStart(source))) return message;
+			throw hinted(error, "i18next's {{name}} is {name} here, and plain MF2 text needs no {{…}}");
+		}
+		if (!source.includes("{$")) throw error;
+		throw hinted(error, "MessageFormat 2 messages are read as such in their complex form: wrap the pattern in {{…}}");
+	}
+}
+function hinted(error, hint) {
+	const { diagnostic } = error;
+	return diagnosticError({
+		...diagnostic,
+		message: `${diagnostic.message} (${hint})`
+	});
+}
+//#endregion
+//#region src/core/icu/canonical.ts
+const CR = /\r\n?/g;
+/** NFC and LF line ends: what every parser and hash sees. */
+function normalizeSource(source) {
+	const nfc = source.normalize("NFC");
+	return nfc.includes("\r") ? nfc.replace(CR, "\n") : nfc;
+}
+/**
+* True when a normalised string has no character the parser or printer treats
+* specially at the top level (`#` is only special inside plurals).
+*/
+function isPlainText(text) {
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c === 39 || c === 60 || c === 123 || c === 125) return false;
+	}
+	return true;
+}
+//#endregion
+//#region src/core/id/hash.ts
+/**
+* Ids (INTERNALS §2.2.1, §2.2.3, PLAN §5.5). An id depends only on its own
+* canonical text and `ids.length`, so every process computes it alone and
+* nothing is ever recorded. Frozen by the golden vectors: changing anything
+* here re-keys every catalog.
+*/
+/**
+* Lingui's construction with an empty context (`text + "\u001F"`), so a Lingui
+* 6 id of the same canonical text is a prefix of the vi18n id.
+*/
+function sourceHash(canonical) {
+	return hash("sha256", canonical + "", "base64url");
+}
+function idScheme(length) {
+	return `sha256-b64u-${length}-v2`;
+}
+const SCHEME = /^sha256-b64u-(8|9|1[0-6])-v2$/;
+/** The id length a catalog header records, or null for anything vi18n did not write. */
+function parseIdScheme(tag) {
+	const match = SCHEME.exec(tag);
+	return match === null ? null : {
+		length: Number(match[1]),
+		version: 2
+	};
+}
+/** The base64url alphabet has no `.`, so a `.` is what marks a manual id. */
+function isManualId(id) {
+	return id.includes(".");
+}
+/** Characters that need no escaping in JS, JSON, PO, file names or URLs, with at least one `.`. */
+const MANUAL_ID = /^[A-Za-z0-9_:-]+(\.[A-Za-z0-9_:-]+)+$/;
+function isValidManualId(id) {
+	return MANUAL_ID.test(id);
+}
+//#endregion
+//#region src/core/icu/structure.ts
+/**
+* What a translation must keep from its source (INTERNALS §2.1.2).
+*
+* A name has one kind per message, with two exceptions that render the same
+* value with the same meaning: a plain `{x}` goes with any kind, and
+* `{x, number}` goes with a plural or selectordinal of `x` (the count the
+* plural selects on, as in `{count, plural, other {{count, number} items}}`).
+* Everything else changes what the value means and is a mismatch: `date` with
+* `time`, `plural` (cardinal) with `selectordinal`, `number` with `date`.
+*/
+/** Whether two uses of one name can share a value. */
+function compatibleKinds(a, b) {
+	return a === b || a === "argument" || b === "argument" || a === "number" && isPlural(b) || b === "number" && isPlural(a);
+}
+function isPlural(kind) {
+	return kind === "plural" || kind === "selectordinal";
+}
+/**
+* @throws {DiagnosticError} `icu-argument-mismatch` when a name is used with
+*   incompatible kinds, `icu-tag-mismatch` when a tag is both paired and standalone.
+*/
+function structureOf(message) {
+	const structure = {
+		args: /* @__PURE__ */ new Map(),
+		optionalArgs: /* @__PURE__ */ new Set(),
+		tags: /* @__PURE__ */ new Map()
+	};
+	const required = /* @__PURE__ */ new Set();
+	collect(message, false, structure, required);
+	for (const name of structure.args.keys()) if (!required.has(name)) structure.optionalArgs.add(name);
+	return structure;
+}
+function collect(nodes, inPlural, structure, required) {
+	for (const node of nodes) switch (node.type) {
+		case "literal":
+		case "pound": break;
+		case "argument":
+			use(node.name, "argument", inPlural, structure, required);
+			break;
+		case "number":
+		case "date":
+		case "time":
+			use(node.name, node.type, inPlural, structure, required);
+			break;
+		case "select":
+			use(node.name, "select", inPlural, structure, required);
+			for (const option of node.options) collect(option.value, inPlural, structure, required);
+			break;
+		case "plural":
+			use(node.name, node.pluralType === "cardinal" ? "plural" : "selectordinal", inPlural, structure, required);
+			for (const option of node.options) collect(option.value, true, structure, required);
+			break;
+		case "tag": {
+			const kind = node.children === null ? "standalone" : "paired";
+			const seen = structure.tags.get(node.name);
+			if (seen !== void 0 && seen !== kind) throw diagnosticError({
+				code: "icu-tag-mismatch",
+				severity: "error",
+				message: `<${node.name}> is used both as <${node.name}>…</${node.name}> and as <${node.name}/>: use one form`
+			});
+			structure.tags.set(node.name, kind);
+			if (node.children !== null) collect(node.children, inPlural, structure, required);
+			break;
+		}
+	}
+}
+function use(name, kind, inPlural, structure, required) {
+	if (!inPlural) required.add(name);
+	const seen = structure.args.get(name);
+	if (seen === void 0 || seen === "argument" || seen === "number" && isPlural(kind)) structure.args.set(name, kind);
+	else if (!compatibleKinds(seen, kind)) throw diagnosticError({
+		code: "icu-argument-mismatch",
+		severity: "error",
+		message: `{${name}} is used both as ${describe(seen)} and as ${describe(kind)}: rename one of them`
+	});
+}
+function describe(kind) {
+	return kind === "argument" ? "a plain argument" : `{…, ${kind}}`;
+}
+//#endregion
+//#region src/core/icu/validate.ts
+/**
+* Message validation (INTERNALS §2.1.3, PLAN §5.4), run at extract, compile,
+* AI post-check and CI. Parse errors are thrown by the parser; everything
+* here is found on a parsed AST and returned, so one call reports every
+* problem of a message at once.
+*/
+const CLDR_ORDER = [
+	"zero",
+	"one",
+	"two",
+	"few",
+	"many",
+	"other"
+];
+const categoryCache = /* @__PURE__ */ new Map();
+function categoriesOf(locale) {
+	let entry = categoryCache.get(locale);
+	if (entry === void 0) {
+		const sorted = (type) => {
+			const found = new Intl.PluralRules(locale, { type }).resolvedOptions().pluralCategories;
+			return CLDR_ORDER.filter((category) => found.includes(category));
+		};
+		entry = {
+			cardinal: sorted("cardinal"),
+			ordinal: sorted("ordinal")
+		};
+		categoryCache.set(locale, entry);
+	}
+	return entry;
+}
+/** The CLDR plural categories of a locale, in CLDR order (`zero one two few many other`). */
+function pluralCategories(locale) {
+	const { cardinal, ordinal } = categoriesOf(locale);
+	return {
+		cardinal: [...cardinal],
+		ordinal: [...ordinal]
+	};
+}
+function validateSource(message, options) {
+	const diagnostics = [];
+	checkMessage(message, options.locale, options.text, false, diagnostics);
+	return diagnostics;
+}
+function validateTranslation(translation, source, options) {
+	if (options.maxLength === void 0 && isLiteralOnly(translation) && isLiteralOnly(source) && hasQuietText(options.text)) return [];
+	const diagnostics = [];
+	const ai = options.ai === true;
+	const own = checkMessage(translation, options.locale, options.text, ai, diagnostics);
+	const expected = structureOrNull(source);
+	if (own !== null && expected !== null) compareStructure(own, expected, diagnostics);
+	if (options.maxLength !== void 0) {
+		const length = graphemeLength(longestRendering(translation));
+		if (length > options.maxLength) diagnostics.push({
+			code: "icu-max-length",
+			severity: ai ? "error" : "warning",
+			message: `Translation is ${length} characters long at its longest, over the limit of ${options.maxLength}: shorten it`
+		});
+	}
+	return diagnostics;
+}
+function isLiteralOnly(message) {
+	for (const node of message) if (node.type !== "literal") return false;
+	return true;
+}
+/** No apostrophe (the quote lint) and no character `scanLiteral` looks for. */
+function hasQuietText(text) {
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c === 39 || c >= 8234 && c <= 8297) return false;
+	}
+	return true;
+}
+/** Checks shared by sources and translations; returns the structure when it is valid. */
+function checkMessage(message, locale, text, ai, diagnostics) {
+	const state = {
+		locale,
+		ai,
+		diagnostics,
+		isolateDepth: 0,
+		isolateUnderflow: false,
+		bidiControl: -1
+	};
+	walk(message, state);
+	if (state.bidiControl !== -1) {
+		const char = String.fromCharCode(state.bidiControl);
+		diagnostics.push({
+			code: "icu-bidi-control",
+			severity: "error",
+			message: `Literal text contains the bidi control U+${hex(state.bidiControl)}, which can reorder the text around it: remove it (vi18n isolates values itself)`,
+			...positionOf(text, char)
+		});
+	}
+	if (state.isolateUnderflow || state.isolateDepth !== 0) diagnostics.push({
+		code: "icu-unbalanced-isolate",
+		severity: "error",
+		message: state.isolateUnderflow ? "U+2069 (pop directional isolate) closes an isolate that was never opened: remove it" : "A directional isolate (U+2066, U+2067 or U+2068) is never closed: add U+2069"
+	});
+	const structure = structureOrDiagnostic(message, diagnostics);
+	if (text.includes("'") && !isMF2Form(text)) {
+		const normalized = normalizeSource(text);
+		for (const offset of quoteStarts(normalized)) diagnostics.push({
+			code: "icu-apostrophe",
+			severity: "warning",
+			message: `This apostrophe starts quoted text, so what follows is printed literally: write ’ for an apostrophe, or '' if you need a straight one`,
+			...positionAt(normalized, offset)
+		});
+	}
+	return structure;
+}
+/** Bidi controls and isolates in literal text; options; plural categories. */
+function walk(nodes, state) {
+	for (const node of nodes) switch (node.type) {
+		case "literal":
+			scanLiteral(node.value, state);
+			break;
+		case "tag":
+			if (node.children !== null) walk(node.children, state);
+			break;
+		case "select":
+			requireOther(node.name, "select", node.options, state);
+			for (const option of node.options) walk(option.value, state);
+			break;
+		case "plural": {
+			const type = node.pluralType === "cardinal" ? "plural" : "selectordinal";
+			requireOther(node.name, type, node.options, state);
+			checkCategories(node.name, type, node.options, state);
+			for (const option of node.options) walk(option.value, state);
+			break;
+		}
+	}
+}
+function scanLiteral(value, state) {
+	for (let i = 0; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c < 8234 || c > 8297) continue;
+		if (c <= 8238) {
+			if (state.bidiControl === -1) state.bidiControl = c;
+		} else if (c >= 8294 && c <= 8296) state.isolateDepth++;
+		else if (c === 8297) {
+			if (state.isolateDepth === 0) state.isolateUnderflow = true;
+			else state.isolateDepth--;
+		}
+	}
+}
+/** The parser enforces this; hand-built and AI-produced ASTs may not have been parsed. */
+function requireOther(name, type, options, state) {
+	if (!options.some((option) => option.key === "other")) state.diagnostics.push({
+		code: "icu-missing-other",
+		severity: "error",
+		message: `{${name}, ${type}} needs an other {…} option`
+	});
+}
+function checkCategories(name, type, options, state) {
+	const { locale, ai, diagnostics } = state;
+	const categories = type === "plural" ? categoriesOf(locale).cardinal : categoriesOf(locale).ordinal;
+	const missing = categories.filter((category) => category !== "other" && !options.some((o) => o.key === category));
+	if (missing.length > 0) diagnostics.push({
+		code: "icu-plural-missing-category",
+		severity: ai ? "error" : "warning",
+		message: `{${name}, ${type}} has no ${missing.join(", ")} option, which ${locale} needs: add ${missing.length > 1 ? "them" : "it"}`
+	});
+	for (const option of options) {
+		const key = option.key;
+		if (key === "other" || key.startsWith("=")) continue;
+		if (!categories.includes(key)) diagnostics.push({
+			code: "icu-plural-unused-category",
+			severity: ai ? "error" : "warning",
+			message: `{${name}, ${type}} has a ${key} option, which ${locale} never selects: remove it`
+		});
+		else if (key === "one" && /(?<![\d.,])1(?![\d]|[.,]\d)/.test(directText(option.value))) diagnostics.push({
+			code: "icu-plural-one-literal",
+			severity: "warning",
+			message: `The one option of {${name}, ${type}} contains a literal 1, but one also matches other numbers in many languages: write # instead`
+		});
+	}
+}
+/** Literal text of an option, tags included, nested arguments excluded. */
+function directText(nodes) {
+	let text = "";
+	for (const node of nodes) if (node.type === "literal") text += node.value;
+	else if (node.type === "tag" && node.children !== null) text += directText(node.children);
+	else text += " ";
+	return text;
+}
+function structureOrDiagnostic(message, diagnostics) {
+	try {
+		return structureOf(message);
+	} catch (error) {
+		if (!isDiagnosticError(error)) throw error;
+		diagnostics.push(error.diagnostic);
+		return null;
+	}
+}
+function structureOrNull(message) {
+	try {
+		return structureOf(message);
+	} catch (error) {
+		if (!isDiagnosticError(error)) throw error;
+		return null;
+	}
+}
+/**
+* A translation may write any argument plainly (`{n}` for a plural count), a
+* plural's count as `{n, number}` (languages without plurals) and a source
+* `{n, number}` as a plural; any other kind change alters the meaning. It may
+* drop arguments the source uses only inside plural options.
+*/
+function compareStructure(own, source, diagnostics) {
+	const mismatch = (code, message) => diagnostics.push({
+		code,
+		severity: "error",
+		message
+	});
+	for (const [name, kind] of own.args) {
+		const expected = source.args.get(name);
+		if (expected === void 0) mismatch("icu-argument-mismatch", `The translation uses {${name}}, which the source does not have: remove it or use a source argument`);
+		else if (!translationKindFits(expected, kind)) mismatch("icu-argument-mismatch", `The translation uses {${name}} as ${describe(kind)}, but the source uses it as ${describe(expected)}: use the source's kind`);
+	}
+	for (const name of source.args.keys()) if (!own.args.has(name) && !source.optionalArgs.has(name)) mismatch("icu-argument-mismatch", `The translation lacks {${name}}: add it`);
+	for (const [name, kind] of source.tags) {
+		const ownKind = own.tags.get(name);
+		if (ownKind === void 0) mismatch("icu-tag-mismatch", `The translation lacks the tag ${tagForm(name, kind)}: add it`);
+		else if (ownKind !== kind) mismatch("icu-tag-mismatch", `The translation writes ${tagForm(name, ownKind)} where the source has ${tagForm(name, kind)}`);
+	}
+	for (const [name, kind] of own.tags) if (!source.tags.has(name)) mismatch("icu-tag-mismatch", `The translation adds the tag ${tagForm(name, kind)}, which the source does not have: remove it`);
+}
+function translationKindFits(source, translation) {
+	return translation === "argument" || source !== "argument" && compatibleKinds(source, translation);
+}
+function tagForm(name, kind) {
+	return kind === "paired" ? `<${name}>…</${name}>` : `<${name}/>`;
+}
+/**
+* The longest text a message can render, with each argument standing for its
+* name and `#` for one character; select and plural take their longest option.
+*/
+function longestRendering(nodes) {
+	let text = "";
+	for (const node of nodes) text += longestNode(node);
+	return text;
+}
+function longestNode(node) {
+	switch (node.type) {
+		case "literal": return node.value;
+		case "pound": return "#";
+		case "tag": return node.children === null ? "" : longestRendering(node.children);
+		case "select":
+		case "plural": {
+			let best = "";
+			let bestLength = -1;
+			for (const option of node.options) {
+				const text = longestRendering(option.value);
+				const length = graphemeLength(text);
+				if (length > bestLength) {
+					best = text;
+					bestLength = length;
+				}
+			}
+			return best;
+		}
+		default: return node.name;
+	}
+}
+let segmenter;
+/** User-perceived characters; strings below U+0300 without CR need no segmentation. */
+function graphemeLength(text) {
+	let simple = true;
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c >= 768 || c === 13) {
+			simple = false;
+			break;
+		}
+	}
+	if (simple) return text.length;
+	segmenter ??= new Intl.Segmenter(void 0, { granularity: "grapheme" });
+	let count = 0;
+	for (const _ of segmenter.segment(text)) count++;
+	return count;
+}
+function positionOf(text, char) {
+	const normalized = normalizeSource(text);
+	const offset = normalized.indexOf(char);
+	return offset === -1 ? {} : positionAt(normalized, offset);
+}
+function hex(code) {
+	return code.toString(16).toUpperCase().padStart(4, "0");
+}
+//#endregion
+export { isManualId as a, sourceHash as c, parseSource as d, parseICU as f, idScheme as i, isPlainText as l, validateSource as n, isValidManualId as o, quoteStarts as p, validateTranslation as r, parseIdScheme as s, pluralCategories as t, normalizeSource as u };