prosebook 0.1.0 → 0.3.0

package/dist/scan-B0tZ7y-D.js

@@ -1,2447 +0,0 @@
-import { C as numberOptions, D as walk, E as tagsOf, S as formatsOf, T as staticLiteral, b as dateOptions, p as lint, u as applyEdits, v as TYPE$1, w as parseMessage$1, x as formatProblems, y as argsOf } from "./config-CxVMn19f.js";
-import { dirname, extname, join, relative, resolve } from "node:path";
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { LineCounter, Scalar, isMap, isScalar, parse, parseDocument } from "yaml";
-import { SKELETON_TYPE, TYPE, isDateElement, isNumberElement, isTimeElement, parse as parse$1 } from "@formatjs/icu-messageformat-parser";
-import { MessageSyntaxError, parseMessage, stringifyMessage, validate } from "messageformat";
-import { createHash } from "node:crypto";
-import { parseSync } from "oxc-parser";
-// src/tools/mf1.ts
-/**
-* The element tree written as MF1 (ICU MessageFormat) text, for `migrate`. A tree read from MF2 holds
-* `Intl` options where MF1 holds skeletons, so each is written as the skeleton that parses back to the
-* same options, or as the named style MF2's function was mapped from; where neither exists the
-* message is reported rather than changed.
-*/
-function toMf1(ast) {
-	return print$1(native(ast, void 0), false);
-}
-const CATEGORY_ORDER = [
-	"zero",
-	"one",
-	"two",
-	"few",
-	"many",
-	"other"
-];
-/**
-* Printed as a person would write it: `{n, plural, =0 {…} one {…} other {…}}`, exact arms first and
-* `other` last. (formatjs's printer packs and reorders arms.)
-*/
-function print$1(elements, inPlural) {
-	return elements.map((el, i) => {
-		switch (el.type) {
-			case TYPE.literal: return escape(el.value, inPlural, elements[i + 1] === void 0);
-			case TYPE.argument: return `{${el.value}}`;
-			case TYPE.number:
-			case TYPE.date:
-			case TYPE.time: {
-				const kind = el.type === TYPE.number ? "number" : el.type === TYPE.date ? "date" : "time";
-				const style = el.style;
-				if (style === null || style === void 0) return `{${el.value}, ${kind}}`;
-				if (typeof style === "string") return `{${el.value}, ${kind}, ${style}}`;
-				const skeleton = "tokens" in style ? style.tokens.map((t) => [t.stem, ...t.options].join("/")).join(" ") : style.pattern;
-				return `{${el.value}, ${kind}, ::${skeleton}}`;
-			}
-			case TYPE.pound: return "#";
-			case TYPE.tag: return `<${el.value}>${print$1(el.children, inPlural)}</${el.value}>`;
-			case TYPE.select:
-			case TYPE.plural: {
-				const arms = Object.entries(el.options);
-				const rank = (arm) => arm.startsWith("=") ? -1 : arm === "other" ? 99 : Math.max(0, CATEGORY_ORDER.indexOf(arm));
-				if (el.type === TYPE.plural) arms.sort(([a], [b]) => rank(a) !== rank(b) ? rank(a) - rank(b) : Number(a.slice(1)) - Number(b.slice(1)));
-				else arms.sort(([a], [b]) => (a === "other" ? 1 : 0) - (b === "other" ? 1 : 0));
-				const head = el.type === TYPE.select ? "select" : el.pluralType === "ordinal" ? "selectordinal" : "plural";
-				const offset = el.type === TYPE.plural && el.offset !== 0 ? ` offset:${el.offset}` : "";
-				const body = arms.map(([arm, o]) => `${arm} {${print$1(o.value, el.type === TYPE.plural)}}`).join(" ");
-				return `{${el.value}, ${head},${offset} ${body}}`;
-			}
-			default: return "";
-		}
-	}).join("");
-}
-/**
-* Literal text, quoted where ICU would read it as syntax. An apostrophe starts a quote only before a
-* special character, so one before ordinary text (`don't`) stays single.
-*/
-function escape(text, inPlural, last) {
-	const special = (c) => c === "{" || c === "}" || c === "<" || inPlural && c === "#";
-	let out = "";
-	for (let i = 0; i < text.length; i++) {
-		const c = text[i];
-		if (special(c)) out += `'${c}'`;
-		else if (c === "'") out += special(text[i + 1]) || text[i + 1] === "'" || !last && i === text.length - 1 ? "''" : "'";
-		else out += c;
-	}
-	return out;
-}
-/** The tree with MF2 styles replaced by MF1 ones, and `#` where a plural prints its own value. */
-function native(elements, plural) {
-	return elements.map((el) => {
-		if (isNumberElement(el)) {
-			if (plural?.offset === 0 && el.value === plural.value && plainNumber(el)) return { type: TYPE.pound };
-			return {
-				...el,
-				style: numberStyle$1(el)
-			};
-		}
-		if (isDateElement(el) || isTimeElement(el)) return dateElement(el);
-		if (el.type === TYPE.plural) {
-			const inner = {
-				value: el.value,
-				offset: el.offset
-			};
-			return {
-				...el,
-				options: Object.fromEntries(Object.entries(el.options).map(([k, o]) => [k, { value: native(o.value, inner) }]))
-			};
-		}
-		if (el.type === TYPE.select) return {
-			...el,
-			options: Object.fromEntries(Object.entries(el.options).map(([k, o]) => [k, { value: native(o.value, void 0) }]))
-		};
-		if (el.type === TYPE.tag) return {
-			...el,
-			children: native(el.children, plural)
-		};
-		return el;
-	});
-}
-function plainNumber(el) {
-	const style = el.style;
-	return style === null || style === void 0 || "mf2" in Object(style) && Object.keys(style.parsedOptions).length === 0;
-}
-function same(a, b) {
-	const norm = (o) => JSON.stringify(Object.entries(o).filter(([, v]) => v !== void 0).sort(([x], [y]) => x.localeCompare(y)));
-	return norm(a) === norm(b);
-}
-function numberStyle$1(el) {
-	const style = el.style;
-	if (style === null || style === void 0 || typeof style === "string" || !("mf2" in style)) return style;
-	const options = style.parsedOptions;
-	if (Object.keys(options).length === 0) return null;
-	if (same(options, { maximumFractionDigits: 0 })) return "integer";
-	if (same(options, { style: "percent" })) return "percent";
-	const skeleton = numberSkeleton(options);
-	const parsed = skeleton === void 0 ? void 0 : skeletonStyle(`{n, number, ::${skeleton}}`);
-	const relevant = (o) => {
-		const { currencyDisplay, unitDisplay, ...rest } = o;
-		return {
-			...rest,
-			...o.style === "currency" ? { currencyDisplay } : {},
-			...o.style === "unit" ? { unitDisplay } : {}
-		};
-	};
-	if (parsed === void 0 || !same(relevant(parsed.parsedOptions), relevant(options))) throw new Error(`{${el.value} ${mf2Text(style.mf2)}} formats in a way no MF1 skeleton says`);
-	return parsed;
-}
-function skeletonStyle(source) {
-	try {
-		const el = parse$1(source, { shouldParseSkeletons: true })[0];
-		return el !== void 0 && "style" in el && typeof el.style === "object" && el.style !== null ? el.style : void 0;
-	} catch {
-		return;
-	}
-}
-/** The ICU number skeleton for `Intl` options, as far as formatjs reads skeletons back. */
-function numberSkeleton(o) {
-	const tokens = [];
-	if (o.style === "percent") tokens.push("percent");
-	if (o.style === "currency") tokens.push(`currency/${String(o.currency)}`);
-	if (o.style === "unit") tokens.push(`unit/${String(o.unit)}`);
-	const width = o.style === "currency" ? {
-		narrowSymbol: "unit-width-narrow",
-		code: "unit-width-short",
-		name: "unit-width-full-name"
-	}[String(o.currencyDisplay)] : o.style === "unit" ? {
-		narrow: "unit-width-narrow",
-		short: "unit-width-short",
-		long: "unit-width-full-name"
-	}[String(o.unitDisplay)] : void 0;
-	if (width !== void 0) tokens.push(width);
-	if (o.currencySign === "accounting") tokens.push("sign-accounting");
-	const sign = {
-		always: "sign-always",
-		exceptZero: "sign-except-zero",
-		never: "sign-never"
-	}[String(o.signDisplay)];
-	if (sign !== void 0) tokens.push(sign);
-	if (o.useGrouping === false) tokens.push("group-off");
-	if (typeof o.minimumIntegerDigits === "number") tokens.push(`integer-width/*${"0".repeat(o.minimumIntegerDigits)}`);
-	const minF = o.minimumFractionDigits;
-	const maxF = o.maximumFractionDigits;
-	let fraction;
-	if (minF !== void 0 && maxF !== void 0) fraction = `.${"0".repeat(minF)}${"#".repeat(maxF - minF)}`;
-	else if (maxF !== void 0) fraction = maxF === 0 ? "." : `.${"#".repeat(maxF)}`;
-	else if (minF !== void 0) fraction = `.${"0".repeat(minF)}*`;
-	const minS = o.minimumSignificantDigits;
-	const maxS = o.maximumSignificantDigits;
-	let significant;
-	if (minS !== void 0 && maxS !== void 0) significant = `${"@".repeat(minS)}${"#".repeat(maxS - minS)}`;
-	else if (maxS !== void 0) significant = `@${"#".repeat(maxS - 1)}`;
-	else if (minS !== void 0) significant = `${"@".repeat(minS)}+`;
-	if (significant !== void 0) significant += o.roundingPriority === "morePrecision" ? "r" : o.roundingPriority === "lessPrecision" ? "s" : "";
-	if (fraction !== void 0) tokens.push(fraction + (o.trailingZeroDisplay === "stripIfInteger" ? "/w" : significant !== void 0 ? `/${significant}` : ""));
-	else if (significant !== void 0) tokens.push(significant);
-	const mode = {
-		floor: "rounding-mode-floor",
-		ceil: "rounding-mode-ceiling",
-		trunc: "rounding-mode-down",
-		expand: "rounding-mode-up",
-		halfEven: "rounding-mode-half-even",
-		halfTrunc: "rounding-mode-half-down",
-		halfExpand: "rounding-mode-half-up"
-	}[String(o.roundingMode)];
-	if (mode !== void 0) tokens.push(mode);
-	return tokens.length > 0 ? tokens.join(" ") : void 0;
-}
-/** MF2 date and time functions as the MF1 named style they were mapped from (see `dateFunction` in mf2.ts). */
-const NAMED = {
-	"date length=short": [TYPE.date, "short"],
-	date: [TYPE.date, "medium"],
-	"date length=long": [TYPE.date, "long"],
-	"date fields=year-month-day-weekday length=long": [TYPE.date, "full"],
-	time: [TYPE.time, "short"],
-	"time precision=second": [TYPE.time, "medium"],
-	"time precision=second timeZoneStyle=short": [TYPE.time, "long"],
-	"time precision=second timeZoneStyle=long": [TYPE.time, "full"]
-};
-function dateElement(el) {
-	const style = el.style;
-	if (typeof style !== "object" || style === null || !("mf2" in style)) return el;
-	const fn = style.mf2;
-	const named = NAMED[mf2Text(fn, true).slice(1)];
-	if (named !== void 0) return {
-		type: named[0],
-		value: el.value,
-		style: named[1]
-	};
-	const skeleton = dateSkeleton(style.parsedOptions);
-	const parsed = skeleton === void 0 ? void 0 : skeletonStyle(`{d, date, ::${skeleton}}`);
-	if (parsed === void 0 || !same(parsed.parsedOptions, style.parsedOptions)) throw new Error(`{${el.value} ${mf2Text(fn)}} formats in a way no MF1 date skeleton says: use :date or :time with a length`);
-	return {
-		type: TYPE.date,
-		value: el.value,
-		style: parsed
-	};
-}
-function dateSkeleton(o) {
-	if (o.hour !== void 0 || o.timeZone !== void 0 || o.calendar !== void 0 || o.hour12 !== void 0) return void 0;
-	const letters = {
-		weekday: {
-			short: "EEE",
-			long: "EEEE",
-			narrow: "EEEEE"
-		},
-		year: {
-			numeric: "y",
-			"2-digit": "yy"
-		},
-		month: {
-			numeric: "M",
-			"2-digit": "MM",
-			short: "MMM",
-			long: "MMMM",
-			narrow: "MMMMM"
-		},
-		day: {
-			numeric: "d",
-			"2-digit": "dd"
-		}
-	};
-	let out = "";
-	for (const [field, forms] of Object.entries(letters)) {
-		const value = o[field];
-		if (value === void 0) continue;
-		const letter = forms[String(value)];
-		if (letter === void 0) return void 0;
-		out += letter;
-	}
-	return out === "" ? void 0 : out;
-}
-function mf2Text(fn, sortOptions = false) {
-	const options = Object.entries(fn.options);
-	if (sortOptions) options.sort(([a], [b]) => a.localeCompare(b));
-	return [`:${fn.name}`, ...options.map(([k, v]) => `${k}=${v}`)].join(" ");
-}
-// src/tools/mf2.ts
-/**
-* Unicode MessageFormat 2, read into the element tree MF1 messages parse to, so the compiler, the
-* types, the lint and the pseudo-locale treat both syntaxes alike; and written back from that tree,
-* for `extract` and `migrate`.
-*
-* The tree holds what a message does, not how it was written. `.input {$n :number}` becomes a number
-* element at each `{$n}`, and `.match` becomes plural and select elements, one level per selector,
-* built so the runtime's ICU-style selection picks the variant MF2's would (see `matchTree`). Option
-* values are literals, resolved here into `Intl` options, so the runtime is the same for both.
-*/
-const NUMBER_LITERAL = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][-+]?\d+)?$/;
-const CATEGORIES = /* @__PURE__ */ new Set([
-	"zero",
-	"one",
-	"two",
-	"few",
-	"many",
-	"other"
-]);
-const NAME = /^[\p{L}_][\p{L}\p{N}_.-]*$/u;
-const DIGITS = [
-	"minimumIntegerDigits",
-	"minimumFractionDigits",
-	"maximumFractionDigits",
-	"minimumSignificantDigits",
-	"maximumSignificantDigits",
-	"roundingIncrement"
-];
-const ROUNDING = [
-	"trailingZeroDisplay",
-	"roundingPriority",
-	"roundingMode"
-];
-const SIGNIFICANT = ["minimumSignificantDigits", "maximumSignificantDigits"];
-/** The options each default function takes, from the MF2 spec. */
-const OPTIONS = {
-	string: [],
-	number: [
-		"select",
-		"signDisplay",
-		"useGrouping",
-		...DIGITS,
-		...ROUNDING
-	],
-	integer: [
-		"select",
-		"signDisplay",
-		"useGrouping",
-		"minimumIntegerDigits",
-		"maximumSignificantDigits"
-	],
-	currency: [
-		"currency",
-		"currencySign",
-		"currencyDisplay",
-		"useGrouping",
-		"minimumIntegerDigits",
-		"fractionDigits",
-		...SIGNIFICANT,
-		...ROUNDING,
-		"roundingIncrement"
-	],
-	percent: [
-		"signDisplay",
-		"useGrouping",
-		"minimumFractionDigits",
-		"maximumFractionDigits",
-		...SIGNIFICANT,
-		...ROUNDING
-	],
-	unit: [
-		"unit",
-		"unitDisplay",
-		"signDisplay",
-		"useGrouping",
-		...DIGITS,
-		...ROUNDING
-	],
-	offset: ["add", "subtract"],
-	date: [
-		"fields",
-		"length",
-		"calendar",
-		"timeZone"
-	],
-	time: [
-		"precision",
-		"timeZoneStyle",
-		"hour12",
-		"calendar",
-		"timeZone"
-	],
-	datetime: [
-		"dateFields",
-		"dateLength",
-		"timePrecision",
-		"timeZoneStyle",
-		"hour12",
-		"calendar",
-		"timeZone"
-	]
-};
-/** Options whose values are a fixed set, checked here because MF2's names differ from `Intl`'s. */
-const DATE_FIELDS = [
-	"weekday",
-	"day-weekday",
-	"month-day",
-	"month-day-weekday",
-	"year-month-day",
-	"year-month-day-weekday"
-];
-const ENUMS = {
-	select: [
-		"plural",
-		"ordinal",
-		"exact"
-	],
-	useGrouping: [
-		"auto",
-		"always",
-		"never",
-		"min2"
-	],
-	currencyDisplay: [
-		"narrowSymbol",
-		"symbol",
-		"name",
-		"code"
-	],
-	fields: DATE_FIELDS,
-	dateFields: DATE_FIELDS,
-	length: [
-		"long",
-		"medium",
-		"short"
-	],
-	dateLength: [
-		"long",
-		"medium",
-		"short"
-	],
-	precision: [
-		"hour",
-		"minute",
-		"second"
-	],
-	timePrecision: [
-		"hour",
-		"minute",
-		"second"
-	],
-	timeZoneStyle: ["long", "short"],
-	hour12: ["true", "false"]
-};
-/** Options an operand's function doesn't pass on to these, per the spec. */
-const DISCARDED = {
-	integer: [
-		"minimumFractionDigits",
-		"maximumFractionDigits",
-		"minimumSignificantDigits"
-	],
-	percent: [
-		"minimumIntegerDigits",
-		"roundingIncrement",
-		"select"
-	]
-};
-const NUMERIC = /* @__PURE__ */ new Set([
-	"number",
-	"integer",
-	"currency",
-	"percent",
-	"unit"
-]);
-const TEMPORAL = /* @__PURE__ */ new Set([
-	"date",
-	"time",
-	"datetime"
-]);
-const family = (name) => NUMERIC.has(name) ? "number" : TEMPORAL.has(name) ? "date" : name;
-const HINTS = {
-	"missing-selector-annotation": "a .match variable needs a function that selects, declared first: .input {$count :number}",
-	"missing-fallback": "a .match needs a variant whose keys are all *",
-	"key-mismatch": "each variant has one key per .match variable",
-	"duplicate-variant": "two variants have the same keys",
-	"duplicate-declaration": "a variable is declared twice, or declared after a use",
-	"duplicate-option-name": "an option is given twice",
-	"duplicate-attribute": "an attribute is given twice",
-	"bad-escape": "only \\\\, \\{, \\} and \\| are escapes",
-	"bad-input-expression": ".input takes a variable: .input {$count :number}",
-	"extra-content": "something follows the end of the message: a message with .match ends with its last variant",
-	"empty-token": "a name or value is missing"
-};
-/** Thrown from `validate`'s callback, which reports a data-model error without throwing. */
-var ModelError = class extends Error {
-	type;
-	constructor(type) {
-		super(type);
-		this.type = type;
-	}
-};
-function syntaxProblem(text, e) {
-	const type = e instanceof MessageSyntaxError || e instanceof ModelError ? e.type : void 0;
-	const hint = type === void 0 ? void 0 : HINTS[type];
-	let where = "";
-	if (e instanceof MessageSyntaxError) {
-		const before = text.slice(0, e.start).split("\n");
-		const near = text.slice(e.start, e.start + 16).split("\n")[0];
-		where = ` at line ${before.length}, column ${before.at(-1).length + 1}${near ? ` (near "${near}")` : ""}`;
-	}
-	const reason = hint ?? (e instanceof Error ? e.message.replace(/ at \d+$/, "") : String(e));
-	return `is not valid MessageFormat 2${where}: ${reason}`;
-}
-/** An MF2 message as the element tree. Throws, with the fix, where it can't be read or compiled. */
-function parseMf2(text, locale) {
-	let message;
-	try {
-		message = parseMessage(text);
-		validate(message, (type) => {
-			throw new ModelError(type);
-		});
-	} catch (e) {
-		throw new Error(syntaxProblem(text, e), { cause: e });
-	}
-	const scope = /* @__PURE__ */ new Map();
-	for (const declaration of message.declarations) scope.set(declaration.name, resolve$1(declaration.value, declaration.type === "input" ? /* @__PURE__ */ new Map() : scope));
-	if (message.type === "message") return pattern(message.pattern, scope, locale);
-	const selectors = message.selectors.map((s) => selectorOf(s.name, scope));
-	return matchTree(selectors, message.variants.map((variant) => {
-		const keys = variant.keys.map((k) => k.type === "*" ? null : k.value);
-		keys.forEach((key, i) => checkKey(selectors[i], key, message.selectors[i].name));
-		return {
-			keys,
-			prefs: [],
-			value: pattern(variant.value, scope, locale)
-		};
-	}), 0, locale);
-}
-function functionOf(ref) {
-	const allowed = OPTIONS[ref.name];
-	if (allowed === void 0) {
-		const known = Object.keys(OPTIONS).map((n) => `:${n}`);
-		throw new Error(`:${ref.name} is not a function prosebook knows: ${known.join(", ")}`);
-	}
-	const options = {};
-	for (const [key, value] of Object.entries(ref.options ?? {})) {
-		if (key === "u:id" || key === "u:dir") continue;
-		if (value.type === "variable") throw new Error(`:${ref.name} ${key}=$${value.name}: option values are literals here, since formatting is fixed at build time`);
-		if (!allowed.includes(key)) throw new Error(`:${ref.name} has no option "${key}"${allowed.length > 0 ? `: ${allowed.join(", ")}` : ""}`);
-		const values = ENUMS[key];
-		if (values !== void 0 && !values.includes(value.value)) throw new Error(`:${ref.name} ${key}=${value.value} is not a value it takes: ${values.join(", ")}`);
-		if (DIGITS.includes(key) && !/^\d+$/.test(value.value)) throw new Error(`:${ref.name} ${key}=${value.value} is not a whole number`);
-		options[key] = value.value;
-	}
-	if (ref.name === "currency" && options.currency === void 0) throw new Error(":currency needs its currency named: {$price :currency currency=EUR}");
-	if (ref.name === "unit" && options.unit === void 0) throw new Error(":unit needs its unit named: {$distance :unit unit=kilometer}");
-	if (ref.name === "unit" && ref.options?.usage !== void 0) throw new Error(":unit usage converts between units, which `Intl` can't do: convert the value before passing it");
-	if (options.timeZone === "input") throw new Error(`:${ref.name} timeZone=input needs a zoned value, which a JavaScript Date isn't`);
-	if (ref.name === "offset") {
-		const given = ["add", "subtract"].filter((k) => options[k] !== void 0);
-		if (given.length !== 1 || !/^\d+$/.test(options[given[0]])) throw new Error(":offset takes one of add or subtract, as a whole number: {$count :offset subtract=1}");
-	}
-	return {
-		name: ref.name,
-		options
-	};
-}
-function resolve$1(expr, scope) {
-	const fn = expr.functionRef === void 0 ? void 0 : functionOf(expr.functionRef);
-	if (expr.arg === void 0) throw new Error(`{:${fn.name}} has nothing to format: give it a value, {$value :${fn.name}}`);
-	if (expr.arg.type === "literal") return apply({
-		kind: "literal",
-		value: expr.arg.value
-	}, fn);
-	return apply(scope.get(expr.arg.name) ?? {
-		kind: "variable",
-		name: expr.arg.name,
-		offset: 0
-	}, fn);
-}
-/** `fn` applied to a value that may already carry one: options carry over within a family, as the spec has it. */
-function apply(base, fn) {
-	if (fn === void 0) return base;
-	if (fn.name === "offset") {
-		const by = Number(fn.options.subtract ?? 0) - Number(fn.options.add ?? 0);
-		const numeric = base.fn ?? {
-			name: "number",
-			options: {}
-		};
-		if (base.kind === "literal") return {
-			...base,
-			value: String(Number(literalNumber(base.value)) - by),
-			fn: numeric
-		};
-		return {
-			...base,
-			offset: base.offset + by,
-			fn: numeric
-		};
-	}
-	if (base.fn === void 0 || family(base.fn.name) !== family(fn.name)) return {
-		...base,
-		fn
-	};
-	const inherited = { ...base.fn.options };
-	for (const key of DISCARDED[fn.name] ?? []) delete inherited[key];
-	return {
-		...base,
-		fn: {
-			name: fn.name,
-			options: {
-				...inherited,
-				...fn.options
-			}
-		}
-	};
-}
-function literalNumber(value) {
-	if (!NUMBER_LITERAL.test(value)) throw new Error(`|${value}| is not a number: write it as one, like 42 or 1.5`);
-	return value;
-}
-function selectorOf(name, scope) {
-	const value = scope.get(name);
-	if (value === void 0 || value.fn === void 0) throw new Error(`.match $${name} needs a function: .input {$${name} :number}`);
-	if (value.kind === "literal") throw new Error(`.match $${name} selects on a literal, which always picks the same variant: use that variant's text`);
-	const { fn } = value;
-	if (fn.name === "string") return {
-		name: value.name,
-		kind: "string",
-		offset: 0
-	};
-	if (fn.name === "number" || fn.name === "integer") {
-		const kind = fn.options.select ?? "plural";
-		return {
-			name: value.name,
-			kind,
-			offset: value.offset
-		};
-	}
-	throw new Error(`.match $${name} selects with :${fn.name}, which prosebook can't select on: use :number, :integer or :string`);
-}
-function checkKey(selector, key, name) {
-	if (key === null) return;
-	if (selector.kind === "string") {
-		if (key === "other") throw new Error(`.match $${name} has a key "other", which can't be told from *: name it something else`);
-		return;
-	}
-	if (NUMBER_LITERAL.test(key)) {
-		if (String(Number(key)) !== key) throw new Error(`.match $${name} has the key ${key}: write it as ${Number(key)}, as values print`);
-		return;
-	}
-	if (selector.kind === "exact") throw new Error(`.match $${name} selects exactly, so its keys are numbers, not "${key}"`);
-	if (!CATEGORIES.has(key)) throw new Error(`.match $${name} has the key "${key}": a number key is a number or one of ${[...CATEGORIES].join(", ")}`);
-}
-/**
-* `.match` as nested plural and select elements. MF2 picks, among the variants whose every key
-* matches, the one whose keys match best, the first selector deciding first; an exact number beats
-* a plural category, which beats `*`. The runtime picks an arm per selector instead, so each arm
-* here holds every variant that can still match a value reaching it, and the leaf takes the best.
-* An exact arm `=1` holds the variants keyed `one` as well, since 1 is also in that category: which
-* category is the locale's, which is why this runs per locale.
-*/
-function matchTree(selectors, candidates, i, locale) {
-	if (i === selectors.length) return candidates.reduce((a, b) => compare(b.prefs, a.prefs) < 0 ? b : a).value;
-	const s = selectors[i];
-	const keys = [...new Set(candidates.map((c) => c.keys[i]).filter((k) => k !== null && k !== void 0))];
-	const options = {};
-	const arm = (name, preference) => {
-		const next = candidates.flatMap((c) => {
-			const p = preference(c.keys[i]);
-			return p === void 0 ? [] : [{
-				...c,
-				prefs: [...c.prefs, p]
-			}];
-		});
-		options[name] = { value: matchTree(selectors, next, i + 1, locale) };
-	};
-	if (s.kind === "string") {
-		for (const k of keys) arm(k, (key) => key === k ? 0 : key === null ? 1 : void 0);
-		arm("other", (key) => key === null ? 1 : void 0);
-		return [{
-			type: TYPE.select,
-			value: s.name,
-			options
-		}];
-	}
-	const rules = new Intl.PluralRules(locale, { type: s.kind === "ordinal" ? "ordinal" : "cardinal" });
-	for (const k of keys.filter((key) => NUMBER_LITERAL.test(key))) {
-		const category = s.kind === "exact" ? void 0 : rules.select(Number(k));
-		arm(`=${Number(k) + s.offset}`, (key) => key === k ? 0 : key === category ? 1 : key === null ? 2 : void 0);
-	}
-	if (s.kind !== "exact") {
-		const categories = keys.includes("other") ? rules.resolvedOptions().pluralCategories : keys.filter((k) => CATEGORIES.has(k));
-		for (const c of categories) arm(c, (key) => key === c ? 1 : key === null ? 2 : void 0);
-	}
-	if (!("other" in options)) arm("other", (key) => key === null ? 2 : void 0);
-	return [{
-		type: TYPE.plural,
-		value: s.name,
-		offset: s.offset,
-		pluralType: s.kind === "ordinal" ? "ordinal" : "cardinal",
-		options
-	}];
-}
-function compare(a, b) {
-	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return a[i] - b[i];
-	return 0;
-}
-function pattern(parts, scope, locale) {
-	const root = [];
-	const open = [];
-	const push = (el) => {
-		const into = open.at(-1)?.children ?? root;
-		const last = into.at(-1);
-		if (el.type === TYPE.literal && last?.type === TYPE.literal) last.value += el.value;
-		else into.push(el);
-	};
-	for (const part of parts) if (typeof part === "string") push({
-		type: TYPE.literal,
-		value: part
-	});
-	else if (part.type === "expression") push(element(resolve$1(part, scope), locale));
-	else if (part.kind === "close") {
-		const top = open.pop();
-		if (top?.name !== part.name) throw new Error(top ? `{/${part.name}} closes {#${top.name}}: close tags in the order they opened` : `{/${part.name}} closes nothing: open it with {#${part.name}}`);
-		push({
-			type: TYPE.tag,
-			value: top.name,
-			children: top.children
-		});
-	} else {
-		const options = Object.keys(part.options ?? {}).filter((k) => k !== "u:id");
-		if (options.length > 0) throw new Error(`{#${part.name}} has options (${options.join(", ")}): tags take none here, so give them to its function`);
-		if (part.kind === "open") open.push({
-			name: part.name,
-			children: []
-		});
-		else push({
-			type: TYPE.tag,
-			value: part.name,
-			children: []
-		});
-	}
-	if (open.length > 0) throw new Error(`{#${open.at(-1).name}} is never closed: end it with {/${open.at(-1).name}}`);
-	return root;
-}
-function element(value, locale) {
-	if (value.kind === "literal") return {
-		type: TYPE.literal,
-		value: formatLiteral(value, locale)
-	};
-	const { name, fn, offset } = value;
-	if (offset !== 0) return {
-		type: TYPE.plural,
-		value: name,
-		offset,
-		pluralType: "cardinal",
-		options: { other: { value: [{ type: TYPE.pound }] } }
-	};
-	if (fn === void 0 || fn.name === "string") return {
-		type: TYPE.argument,
-		value: name
-	};
-	if (NUMERIC.has(fn.name)) return {
-		type: TYPE.number,
-		value: name,
-		style: numberStyle(fn)
-	};
-	return {
-		type: TYPE.date,
-		value: name,
-		style: dateStyle(fn)
-	};
-}
-/** A literal with a function is the same in every render, so it is formatted now. */
-function formatLiteral(value, locale) {
-	const { fn } = value;
-	if (fn === void 0 || fn.name === "string") return value.value;
-	if (NUMERIC.has(fn.name)) return new Intl.NumberFormat(locale, intlNumber(fn)).format(Number(literalNumber(value.value)));
-	const date = new Date(value.value);
-	if (Number.isNaN(date.getTime())) throw new Error(`|${value.value}| is not a date: write it as an ISO 8601 date, like 2026-01-05`);
-	return new Intl.DateTimeFormat(locale, intlDate(fn)).format(date);
-}
-function numberStyle(fn) {
-	return {
-		type: SKELETON_TYPE.number,
-		tokens: [],
-		parsedOptions: intlNumber(fn),
-		mf2: fn
-	};
-}
-function dateStyle(fn) {
-	return {
-		type: SKELETON_TYPE.dateTime,
-		pattern: "",
-		parsedOptions: intlDate(fn),
-		mf2: fn
-	};
-}
-/** The `Intl.NumberFormat` options a numeric function formats with. */
-function intlNumber(fn) {
-	const allowed = OPTIONS[fn.name] ?? [];
-	const out = {};
-	for (const [key, value] of Object.entries(fn.options)) {
-		if (!allowed.includes(key) || key === "select") continue;
-		if (key === "useGrouping") out.useGrouping = value === "never" ? false : value;
-		else if (key === "fractionDigits") {
-			if (value !== "auto") out.minimumFractionDigits = out.maximumFractionDigits = Number(value);
-		} else if (DIGITS.includes(key)) out[key] = Number(value);
-		else out[key] = value;
-	}
-	if (fn.name === "integer") out.maximumFractionDigits = 0;
-	if (fn.name === "percent" || fn.name === "currency" || fn.name === "unit") out.style = fn.name;
-	return out;
-}
-/**
-* The `Intl.DateTimeFormat` options a date or time function formats with. MF2's date and time
-* functions are still a draft; this follows the spec's semantic options as the `messageformat`
-* package does, so a message reads the same in both.
-*/
-function intlDate(fn) {
-	const o = fn.options;
-	const out = {};
-	if (o.calendar !== void 0) out.calendar = o.calendar;
-	if (fn.name !== "date" && o.hour12 !== void 0) out.hour12 = o.hour12 === "true";
-	if (o.timeZone !== void 0) out.timeZone = o.timeZone;
-	if (fn.name !== "time") {
-		const fields = new Set((o[fn.name === "date" ? "fields" : "dateFields"] ?? "year-month-day").split("-"));
-		const length = o[fn.name === "date" ? "length" : "dateLength"];
-		if (fields.has("year")) out.year = "numeric";
-		if (fields.has("month")) out.month = length === "long" ? "long" : length === "short" ? "numeric" : "short";
-		if (fields.has("day")) out.day = "numeric";
-		if (fields.has("weekday")) out.weekday = length === "long" ? "long" : "short";
-	}
-	if (fn.name !== "date") {
-		const precision = o[fn.name === "time" ? "precision" : "timePrecision"];
-		out.hour = "numeric";
-		if (precision !== "hour") out.minute = "numeric";
-		if (precision === "second") out.second = "numeric";
-		if (o.timeZoneStyle !== void 0) out.timeZoneName = o.timeZoneStyle;
-	}
-	return out;
-}
-/** A message tree as MF2 text. Throws, saying what has no MF2 equivalent, where it can't be written. */
-function toMf2(ast, locale) {
-	const found = selectorsOf(ast);
-	if (found.length === 0) {
-		const pattern = toPattern(ast, {
-			choice: /* @__PURE__ */ new Map(),
-			variables: /* @__PURE__ */ new Map(),
-			numeric: /* @__PURE__ */ new Set(),
-			locale
-		});
-		return stringifyMessage({
-			type: "message",
-			declarations: [],
-			pattern
-		});
-	}
-	const declarations = [];
-	for (const s of found) {
-		const fn = s.kind === "string" ? functionRef("string") : functionRef("number", s.kind === "ordinal" ? { select: "ordinal" } : {});
-		declarations.push({
-			type: "input",
-			name: s.arg,
-			value: {
-				type: "expression",
-				arg: variable(s.arg),
-				functionRef: fn
-			}
-		});
-		if (s.offset !== 0) declarations.push({
-			type: "local",
-			name: s.variable,
-			value: {
-				type: "expression",
-				arg: variable(s.arg),
-				functionRef: functionRef("offset", { subtract: String(s.offset) })
-			}
-		});
-	}
-	let combos = [[]];
-	for (const s of found) combos = combos.flatMap((c) => [...s.keys, null].map((k) => [...c, k]));
-	const variables = new Map(found.map((s) => [s.arg, s.variable]));
-	const numeric = new Set(found.filter((s) => s.kind !== "string").map((s) => s.arg));
-	const render = (keys) => toPattern(ast, {
-		choice: new Map(found.map((s, i) => [s.arg, keys[i]])),
-		variables,
-		numeric,
-		locale
-	});
-	const variants = combos.map((keys) => ({
-		keys,
-		pattern: render(keys),
-		text: ""
-	}));
-	for (const v of variants) v.text = JSON.stringify(v.pattern);
-	const kept = prune(variants, found, locale);
-	return stringifyMessage({
-		type: "select",
-		declarations,
-		selectors: found.map((s) => variable(s.variable)),
-		variants: kept.map((v) => ({
-			keys: v.keys.map((k) => k === null ? { type: "*" } : {
-				type: "literal",
-				value: k
-			}),
-			value: v.pattern
-		}))
-	});
-}
-function selectorsOf(ast) {
-	const found = /* @__PURE__ */ new Map();
-	const names = /* @__PURE__ */ new Set();
-	walk(ast, (el) => {
-		if ("value" in el && typeof el.value === "string" && el.type !== TYPE.literal) names.add(el.value);
-	});
-	walk(ast, (el) => {
-		if (el.type !== TYPE.plural && el.type !== TYPE.select) return;
-		const kind = el.type === TYPE.select ? "string" : el.pluralType === "ordinal" ? "ordinal" : "plural";
-		const offset = el.type === TYPE.plural ? el.offset : 0;
-		let s = found.get(el.value);
-		if (s === void 0) {
-			checkName(el.value);
-			let local = `${el.value}_minus_${offset}`;
-			while (names.has(local)) local += "_";
-			s = {
-				arg: el.value,
-				variable: offset === 0 ? el.value : local,
-				kind,
-				offset,
-				keys: []
-			};
-			found.set(el.value, s);
-		} else if (s.kind !== kind || s.offset !== offset) throw new Error(`{${el.value}} is selected on in two ways (${s.kind}, ${kind}${offset !== s.offset ? ", with different offsets" : ""}), which one .match can't say: make them the same`);
-		for (const arm of Object.keys(el.options)) {
-			if (arm === "other") continue;
-			const key = el.type === TYPE.plural && arm.startsWith("=") ? String(Number(arm.slice(1)) - offset) : arm;
-			if (!s.keys.includes(key)) s.keys.push(key);
-		}
-	});
-	return [...found.values()];
-}
-/**
-* The variants a reader needs: one that renders like the variant it would fall back to is dropped,
-* as long as every combination of values still lands on a variant rendering what it should.
-*/
-function prune(variants, found, locale) {
-	const rules = found.map((s) => s.kind === "string" ? void 0 : new Intl.PluralRules(locale, { type: s.kind === "ordinal" ? "ordinal" : "cardinal" }));
-	const preference = (i, key, value) => {
-		if (key === null) return 2;
-		if (value === null) return void 0;
-		if (key === value) return NUMBER_LITERAL.test(key) || rules[i] === void 0 ? 0 : 1;
-		if (rules[i] !== void 0 && NUMBER_LITERAL.test(value) && rules[i].select(Number(value)) === key) return 1;
-	};
-	const pick = (kept, values) => {
-		let best;
-		for (const v of kept) {
-			const prefs = values.map((value, i) => preference(i, v.keys[i], value));
-			if (prefs.some((p) => p === void 0)) continue;
-			if (best === void 0 || compare(prefs, best.prefs) < 0) best = {
-				v,
-				prefs
-			};
-		}
-		return best?.v;
-	};
-	let kept = [...variants];
-	const specificFirst = [...variants].sort((a, b) => b.keys.filter((k) => k !== null).length - a.keys.filter((k) => k !== null).length);
-	for (const candidate of specificFirst) {
-		if (candidate.keys.every((k) => k === null)) continue;
-		const without = kept.filter((v) => v !== candidate);
-		if (variants.every((v) => pick(without, v.keys)?.text === v.text)) kept = without;
-	}
-	return kept;
-}
-function toPattern(elements, w, pound) {
-	const out = [];
-	const text = (value) => {
-		const last = out.at(-1);
-		if (typeof last === "string") out[out.length - 1] = last + value;
-		else if (value !== "") out.push(value);
-	};
-	for (const el of elements) switch (el.type) {
-		case TYPE.literal:
-			text(el.value);
-			break;
-		case TYPE.argument:
-			checkName(el.value);
-			out.push({
-				type: "expression",
-				arg: variable(el.value)
-			});
-			break;
-		case TYPE.number: {
-			checkName(el.value);
-			const fn = numberFunction(el);
-			const declared = w.numeric.has(el.value) && fn.name === "number" && fn.options === void 0;
-			out.push(declared ? {
-				type: "expression",
-				arg: variable(el.value)
-			} : {
-				type: "expression",
-				arg: variable(el.value),
-				functionRef: fn
-			});
-			break;
-		}
-		case TYPE.date:
-		case TYPE.time:
-			checkName(el.value);
-			out.push({
-				type: "expression",
-				arg: variable(el.value),
-				functionRef: dateFunction(el)
-			});
-			break;
-		case TYPE.pound:
-			out.push({
-				type: "expression",
-				arg: variable(pound ?? "")
-			});
-			break;
-		case TYPE.plural:
-		case TYPE.select: {
-			const arm = armFor(el, w.choice.get(el.value) ?? null, w.locale);
-			const own = w.variables.get(el.value) ?? el.value;
-			for (const part of toPattern(arm, w, el.type === TYPE.plural ? own : pound)) if (typeof part === "string") text(part);
-			else out.push(part);
-			break;
-		}
-		case TYPE.tag:
-			checkName(el.value);
-			out.push({
-				type: "markup",
-				kind: "open",
-				name: el.value
-			});
-			for (const part of toPattern(el.children, w, pound)) if (typeof part === "string") text(part);
-			else out.push(part);
-			out.push({
-				type: "markup",
-				kind: "close",
-				name: el.value
-			});
-	}
-	return out;
-}
-function armFor(el, key, locale) {
-	const other = el.options.other.value;
-	if (key === null) return other;
-	if (el.type === TYPE.plural && NUMBER_LITERAL.test(key)) {
-		const exact = el.options[`=${Number(key) + el.offset}`];
-		if (exact !== void 0) return exact.value;
-		const category = new Intl.PluralRules(locale, { type: el.pluralType }).select(Number(key));
-		return el.options[category]?.value ?? other;
-	}
-	return el.options[key]?.value ?? other;
-}
-function checkName(name) {
-	if (!NAME.test(name)) throw new Error(`"${name}" can't be a MessageFormat 2 name: start it with a letter`);
-}
-function variable(name) {
-	return {
-		type: "variable",
-		name
-	};
-}
-function functionRef(name, options = {}) {
-	const entries = Object.entries(options);
-	if (entries.length === 0) return {
-		type: "function",
-		name
-	};
-	return {
-		type: "function",
-		name,
-		options: Object.fromEntries(entries.map(([k, v]) => [k, {
-			type: "literal",
-			value: v
-		}]))
-	};
-}
-function numberFunction(el) {
-	const style = el.style;
-	if (style === null || style === void 0) return functionRef("number");
-	if (typeof style === "string") {
-		if (style === "integer" || style === "percent") return functionRef(style);
-		throw new Error(`{${el.value}, number, ${style}} has no MessageFormat 2 equivalent`);
-	}
-	if ("mf2" in style) return functionRef(style.mf2.name, style.mf2.options);
-	const { style: kind, currency, currencyDisplay, currencySign, unit, unitDisplay, ...rest } = style.parsedOptions;
-	const name = kind === "percent" || kind === "currency" || kind === "unit" ? kind : "number";
-	const options = {};
-	const own = name === "currency" ? {
-		currency,
-		currencyDisplay,
-		currencySign
-	} : name === "unit" ? {
-		unit,
-		unitDisplay
-	} : {};
-	for (const [key, value] of Object.entries(own)) if (value !== void 0) options[key] = String(value);
-	if (name === "currency" && rest.minimumFractionDigits !== void 0 && rest.minimumFractionDigits === rest.maximumFractionDigits) {
-		options.fractionDigits = String(rest.minimumFractionDigits);
-		delete rest.minimumFractionDigits;
-		delete rest.maximumFractionDigits;
-	}
-	for (const [key, value] of Object.entries(rest)) {
-		if (value === void 0) continue;
-		if (key === "useGrouping") options.useGrouping = value === false ? "never" : String(value);
-		else if (OPTIONS[name].includes(key) && key !== "select") options[key] = String(value);
-		else throw new Error(`{${el.value}}'s ${key}: ${String(value)} has no MessageFormat 2 equivalent`);
-	}
-	return functionRef(name, options);
-}
-/**
-* The MF2 function for a date or time element. MF1's named styles have no exact counterpart, so they
-* map to the nearest; `migrate` renders both and reports any that come out different.
-*/
-function dateFunction(el) {
-	const style = el.style;
-	if (typeof style === "object" && style !== null && "mf2" in style) return functionRef(style.mf2.name, style.mf2.options);
-	if (el.type === TYPE.time && (style === null || style === void 0 || typeof style === "string")) return functionRef("time", {
-		short: {},
-		medium: { precision: "second" },
-		long: {
-			precision: "second",
-			timeZoneStyle: "short"
-		},
-		full: {
-			precision: "second",
-			timeZoneStyle: "long"
-		}
-	}[style ?? "short"] ?? {});
-	if (style === null || style === void 0 || typeof style === "string") return functionRef("date", {
-		default: { length: "short" },
-		short: { length: "short" },
-		medium: {},
-		long: { length: "long" },
-		full: {
-			fields: "year-month-day-weekday",
-			length: "long"
-		}
-	}[style ?? "default"] ?? {});
-	const { calendar, timeZone, hour12, ...fields } = style.parsedOptions;
-	const overrides = {};
-	if (calendar !== void 0) overrides.calendar = calendar;
-	if (timeZone !== void 0) overrides.timeZone = timeZone;
-	if (hour12 !== void 0) overrides.hour12 = String(hour12);
-	const wanted = JSON.stringify(sorted(fields));
-	for (const candidate of dateCandidates()) {
-		const { calendar: _c, timeZone: _t, hour12: _h, ...got } = intlDate(candidate);
-		if (JSON.stringify(sorted(got)) === wanted) return functionRef(candidate.name, {
-			...candidate.options,
-			...overrides
-		});
-	}
-	throw new Error(`{${el.value}}'s date skeleton "${style.pattern}" has no MessageFormat 2 equivalent: use a named style`);
-}
-function sorted(o) {
-	return Object.entries(o).filter(([, v]) => v !== void 0).sort(([a], [b]) => a.localeCompare(b));
-}
-function* dateCandidates() {
-	const lengths = [
-		void 0,
-		"long",
-		"short"
-	];
-	const precisions = [
-		void 0,
-		"hour",
-		"second"
-	];
-	const zones = [
-		void 0,
-		"long",
-		"short"
-	];
-	const defined = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
-	const dates = [void 0, ...DATE_FIELDS.filter((f) => f !== "year-month-day")].flatMap((fields) => lengths.map((length) => ({
-		fields,
-		length
-	})));
-	const times = precisions.flatMap((precision) => zones.map((timeZoneStyle) => ({
-		precision,
-		timeZoneStyle
-	})));
-	for (const d of dates) yield {
-		name: "date",
-		options: defined(d)
-	};
-	for (const t of times) yield {
-		name: "time",
-		options: defined(t)
-	};
-	for (const d of dates) for (const t of times) yield {
-		name: "datetime",
-		options: defined({
-			dateFields: d.fields,
-			dateLength: d.length,
-			timePrecision: t.precision,
-			timeZoneStyle: t.timeZoneStyle
-		})
-	};
-}
-// src/tools/syntax.ts
-/**
-* The two syntaxes a catalog can be written in, behind one pair of calls: read a message into the
-* element tree, and write a tree back out. Everything past reading works on the tree alone.
-*/
-const SYNTAX_NAME = {
-	1: "ICU MessageFormat",
-	2: "MessageFormat 2"
-};
-/**
-* A message as the element tree. MF2 is read per locale: which variants a value can reach depends
-* on the locale's plural rules (see `matchTree` in mf2.ts).
-*/
-function readMessage(version, text, locale) {
-	return version === 2 ? parseMf2(text, locale) : parseMessage$1(text);
-}
-/** A tree as text in the given syntax. Throws, saying what the syntax can't express, where it can't. */
-function writeMessage(version, ast, locale) {
-	return version === 2 ? toMf2(ast, locale) : toMf1(ast);
-}
-// src/tools/catalog.ts
-/**
-* Reads the catalog and its translations into one checked model.
-*
-* Every message is parsed as ICU here rather than at runtime, which is what lets the generator hand
-* TypeScript exact argument types, compile messages to plain functions, and fail the build where a
-* translation's placeholders drifted from the source instead of dropping a value off the screen.
-*/
-/** `file key`, as the CLI names where a problem is. */
-function whereOf(problem) {
-	return [problem.file, problem.key].filter((s) => s !== void 0).join(" ");
-}
-var CatalogError = class extends Error {
-	problems;
-	constructor(problems) {
-		super(`the catalog has ${problems.length} problem(s):\n  ${problems.map((p) => `${whereOf(p)}: ${p.message}`).join("\n  ")}`);
-		this.problems = problems;
-	}
-};
-/**
-* A key is dotted lowercase, two segments at least, and its first segment names the file it lives
-* in. Keys are read at every call site, so they say what the string is for: `cart.checkout.title`.
-*/
-const KEY_PATTERN = /^[a-z0-9]+(?:[-_][a-z0-9]+)*(?:\.[a-z0-9]+(?:[-_][a-z0-9]+)*)+$/;
-const FIELDS = /* @__PURE__ */ new Set([
-	"kind",
-	"surface",
-	"context",
-	"args",
-	"fragment",
-	"allow",
-	"comment",
-	"remove"
-]);
-/**
-* Loads and checks the catalog. Throws a `CatalogError` when anything is an error; warnings ride along.
-* `unsaved` holds file contents by absolute path to read in place of what is on disk, so an edit can be
-* checked before it is written; a translation file in it that isn't on disk yet is read too.
-*/
-function loadCatalog(config, unsaved) {
-	const read = (path) => unsaved?.get(resolve(path)) ?? readFileSync(path, "utf8");
-	const problems = [];
-	const error = (message, file, key) => problems.push({
-		severity: "error",
-		file,
-		key,
-		message
-	});
-	const byKey = /* @__PURE__ */ new Map();
-	const rel = (path) => relative(config.root, path).replaceAll("\\", "/");
-	if (!existsSync(config.catalog)) {
-		error("no catalog folder here: run `prosebook init`, or set `catalog` in the config", rel(config.catalog));
-		throw new CatalogError(problems);
-	}
-	for (const file of yamlFiles(config.catalog)) {
-		const area = file.slice(0, -5);
-		const path = join(config.catalog, file);
-		const at = rel(path);
-		for (const [key, value] of Object.entries(readEntries(read(path), (m) => error(m, at)))) {
-			if (!KEY_PATTERN.test(key)) {
-				error("a key is dotted lowercase with two segments at least: `area.thing`", at, key);
-				continue;
-			}
-			if (key.slice(0, key.indexOf(".")) !== area) {
-				error(`a key in ${file} starts with "${area}."`, at, key);
-				continue;
-			}
-			if (byKey.has(key)) {
-				error("duplicate key", at, key);
-				continue;
-			}
-			const message = readEntry$1(key, area, at, value, config, (m) => error(m, at, key));
-			if (!message) continue;
-			byKey.set(key, message);
-			const warn = (m) => problems.push({
-				severity: "warn",
-				file: at,
-				key,
-				message: m
-			});
-			if (message.remove) warn("marked for removal: delete the entry, its translations and the code that reads it");
-			if (message.comment !== void 0) warn(`a comment to act on, then delete: ${message.comment}`);
-		}
-	}
-	const locales = readLocales(config, byKey, problems, rel, read, [...unsaved?.keys() ?? []].filter((path) => !existsSync(path)));
-	if (problems.some((p) => p.severity === "error")) throw new CatalogError(problems);
-	return {
-		messages: [...byKey.values()].sort((a, b) => a.key < b.key ? -1 : 1),
-		locales,
-		problems
-	};
-}
-function readEntry$1(key, area, file, value, config, error) {
-	const entry = typeof value === "string" ? { [config.source]: value } : value;
-	if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
-		error(`an entry is a message, or a mapping holding \`${config.source}\` and what the string is`);
-		return;
-	}
-	let ok = true;
-	const fail = (message) => {
-		error(message);
-		ok = false;
-	};
-	for (const field of Object.keys(entry)) if (!FIELDS.has(field) && field !== config.source) fail(`"${field}" is not a field: ${[...FIELDS, config.source].join(", ")}`);
-	const text = entry[config.source];
-	if (typeof text !== "string" || text === "") {
-		fail(`${config.source} is the message, and it is missing`);
-		return;
-	}
-	for (const field of config.require) if (entry[field] === void 0) fail(`${field} is required (\`require\` in the config)`);
-	const kind = optionalString(entry, "kind", fail);
-	if (kind !== void 0 && !(kind in config.kinds)) fail(`kind is one of ${Object.keys(config.kinds).join(", ")}`);
-	const surface = optionalString(entry, "surface", fail);
-	if (surface !== void 0 && !(surface in config.surfaces)) fail(`surface is one of ${Object.keys(config.surfaces).join(", ")}`);
-	const context = optionalString(entry, "context", fail);
-	if (entry.fragment !== void 0 && typeof entry.fragment !== "boolean") fail("fragment is true or false");
-	const comment = optionalString(entry, "comment", fail);
-	if (entry.remove !== void 0 && typeof entry.remove !== "boolean") fail("remove is true or false");
-	let ast;
-	try {
-		ast = readMessage(config.messageFormat, text, config.source);
-	} catch (e) {
-		fail(syntaxError(config, text, e));
-		return;
-	}
-	for (const problem of formatProblems(ast)) fail(problem);
-	const args = argsOf(ast, (name) => fail(`"${name}" is used as two different types`));
-	const argDocs = stringMap(entry, "args", fail);
-	if (config.require.includes("context")) {
-		for (const name of args.keys()) if (!argDocs.has(name)) fail(`args.${name} is missing: say what the placeholder holds`);
-	}
-	for (const name of argDocs.keys()) if (!args.has(name)) fail(`args.${name} is not an argument of this message`);
-	if (!ok) return void 0;
-	return {
-		key,
-		area,
-		file,
-		kind,
-		surface,
-		context,
-		argDocs,
-		fragment: entry.fragment === true,
-		allow: stringMap(entry, "allow", fail),
-		comment,
-		remove: entry.remove === true,
-		text,
-		ast,
-		args,
-		argFormats: formatsOf(ast),
-		tags: tagsOf(ast),
-		translations: /* @__PURE__ */ new Map()
-	};
-}
-function readLocales(config, byKey, problems, rel, read, created) {
-	if (!existsSync(config.locales)) return [];
-	const files = /* @__PURE__ */ new Map();
-	for (const name of readdirSync(config.locales).sort()) {
-		const path = join(config.locales, name);
-		const isDir = statSync(path).isDirectory();
-		if (!isDir && !name.endsWith(".yaml")) continue;
-		const locale = isDir ? name : name.slice(0, -5);
-		const found = isDir ? yamlFiles(path).map((f) => join(path, f)) : [path];
-		files.set(locale, [...files.get(locale) ?? [], ...found]);
-	}
-	for (const path of created) {
-		const inside = relative(config.locales, path).replaceAll("\\", "/");
-		if (inside.startsWith("..") || !inside.endsWith(".yaml")) continue;
-		const [first = "", second] = inside.split("/");
-		const locale = second === void 0 ? first.slice(0, -5) : first;
-		files.set(locale, [...files.get(locale) ?? [], path]);
-	}
-	files.delete(config.source);
-	for (const [locale, paths] of files) for (const path of paths) {
-		const file = rel(path);
-		const error = (message, key) => problems.push({
-			severity: "error",
-			file,
-			key,
-			message
-		});
-		for (const [key, value] of Object.entries(readEntries(read(path), error))) {
-			const message = byKey.get(key);
-			if (message === void 0) {
-				problems.push({
-					severity: "warn",
-					file,
-					key,
-					message: "no such key in the catalog, so this translation is unused"
-				});
-				continue;
-			}
-			if (typeof value !== "string" || value === "") {
-				error("a translation is the message, as a string", key);
-				continue;
-			}
-			let ast;
-			try {
-				ast = readMessage(config.messageFormat, value, locale);
-			} catch (e) {
-				error(syntaxError(config, value, e), key);
-				continue;
-			}
-			const drift = driftFrom(message, ast);
-			if (drift !== void 0) {
-				error(drift, key);
-				continue;
-			}
-			for (const problem of formatProblems(ast)) error(problem, key);
-			message.translations.set(locale, {
-				text: value,
-				ast,
-				file
-			});
-		}
-	}
-	return [...files.keys()];
-}
-/** How a translation's placeholders or tags differ from the source, or nothing. */
-function driftFrom(message, ast) {
-	const args = argsOf(ast);
-	const missing = [...message.args.keys()].filter((a) => !args.has(a));
-	const extra = [...args.keys()].filter((a) => !message.args.has(a));
-	const retyped = [...args].filter(([a, type]) => message.args.has(a) && message.args.get(a) !== type && !type.includes("string &")).map(([a]) => a);
-	const tags = tagsOf(ast);
-	const parts = [
-		missing.length > 0 ? `missing {${missing.join("}, {")}}` : "",
-		extra.length > 0 ? `unknown {${extra.join("}, {")}}` : "",
-		retyped.length > 0 ? `{${retyped.join("}, {")}} used as another type` : "",
-		tags.join() === message.tags.join() ? "" : `tags are <${tags.join(">, <") || "none"}>, the source has <${message.tags.join(">, <") || "none"}>`
-	].filter(Boolean);
-	return parts.length > 0 ? `differs from the source: ${parts.join("; ")}` : void 0;
-}
-function syntaxError(config, text, e) {
-	if (config.messageFormat === 2) return e.message;
-	return icuError(text, e);
-}
-function icuError(text, e) {
-	const hyphenated = /select\s*,/.test(text) ? /[,{]\s*([a-z0-9]+(?:-[a-z0-9]+)+)\s*\{/.exec(text) : null;
-	if (hyphenated) return `names a select arm "${hyphenated[1]}": an arm's name takes no hyphen, so write it with an underscore`;
-	const reason = e.message;
-	if (/TAG/.test(reason)) return `is not valid ICU (${reason}): a literal < is written '<'`;
-	return `is not valid ICU MessageFormat: ${reason}`;
-}
-function yamlFiles(dir) {
-	return readdirSync(dir).filter((f) => f.endsWith(".yaml")).sort();
-}
-/**
-* The file's entries. YAML 1.1 and 1.2 disagree about bare scalars: 1.1 reads `n`, `on` and `yes` as
-* booleans and `12:30` as a number. Translation tools are often 1.1, so a file that reads differently
-* under each fails here, naming the value to quote, rather than corrupting quietly in the next tool.
-*/
-function readEntries(text, error) {
-	let raw;
-	try {
-		raw = parse(text);
-	} catch (e) {
-		error(`is not valid YAML: ${e.message}`);
-		return {};
-	}
-	if (raw === null || raw === void 0) return {};
-	if (typeof raw !== "object" || Array.isArray(raw)) {
-		error("a catalog file is a mapping of key to entry");
-		return {};
-	}
-	try {
-		const found = divergence(raw, parse(text, { version: "1.1" }), "");
-		if (found !== void 0) error(found);
-	} catch (e) {
-		error(`does not parse as YAML 1.1, which another tool may well be: ${e.message}`);
-	}
-	return raw;
-}
-function divergence(a, b, path) {
-	if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
-		if (Object.is(a, b)) return void 0;
-		return `${path} reads as ${JSON.stringify(a)} under YAML 1.2 and ${JSON.stringify(b)} under YAML 1.1: quote it`;
-	}
-	const left = a;
-	const right = b;
-	for (const key of /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])) {
-		const here = path === "" ? key : `${path}.${key}`;
-		if (key in left !== key in right) return `${here} is a key under YAML ${key in left ? "1.2" : "1.1"} only: quote it`;
-		const found = divergence(left[key], right[key], here);
-		if (found !== void 0) return found;
-	}
-}
-function optionalString(entry, field, fail) {
-	const value = entry[field];
-	if (value === void 0) return void 0;
-	if (typeof value !== "string" || value.trim() === "") {
-		fail(`${field} is a non-empty string`);
-		return;
-	}
-	return value.trim();
-}
-function stringMap(entry, field, fail) {
-	const out = /* @__PURE__ */ new Map();
-	const value = entry[field];
-	if (value === void 0) return out;
-	if (value === null || typeof value !== "object" || Array.isArray(value)) {
-		fail(`${field} is a mapping of name to sentence`);
-		return out;
-	}
-	for (const [name, said] of Object.entries(value)) if (typeof said !== "string" || said.trim() === "") fail(`${field}.${name} is a sentence`);
-	else out.set(name, said.trim());
-	return out;
-}
-/**
-* Where a message's entry is written: its translation in `locale` when there is one, else the catalog.
-* Read from the file as it is now, so an entry moved since the catalog was loaded is still found.
-*/
-function entryLocation(config, message, locale) {
-	const file = (locale === void 0 ? void 0 : message.translations.get(locale)?.file) ?? message.file;
-	return {
-		file: join(config.root, file),
-		...entryLocator(config.root)(file, message.key)
-	};
-}
-/**
-* Finds a key's line and column in a catalog or translation file, given relative to `root`. Each file
-* is read once, so a report that places many entries parses each file once. A key it can't find, or no
-* key, is the top of the file.
-*
-* Given an `offset` into the message (under `field`, in an entry that is a mapping), it is that
-* character, when the value is written in the file as it reads up to there: plain, or quoted on one
-* line with nothing escaped before it. Otherwise it is the key.
-*/
-function entryLocator(root) {
-	const read = /* @__PURE__ */ new Map();
-	return (file, key, offset, field) => {
-		let parsed = read.get(file);
-		if (parsed === void 0) {
-			const path = join(root, file);
-			const lines = new LineCounter();
-			const source = existsSync(path) ? readFileSync(path, "utf8") : "";
-			parsed = {
-				doc: parseDocument(source, { lineCounter: lines }),
-				lines,
-				source
-			};
-			read.set(file, parsed);
-		}
-		const { doc, lines, source } = parsed;
-		const pair = key !== void 0 && isMap(doc.contents) ? doc.contents.items.find((p) => isScalar(p.key) && p.key.value === key) : void 0;
-		const value = isMap(pair?.value) && field !== void 0 ? pair.value.get(field, true) : pair?.value;
-		if (offset !== void 0 && isScalar(value) && typeof value.value === "string" && value.range) {
-			const quoted = value.type === Scalar.QUOTE_DOUBLE || value.type === Scalar.QUOTE_SINGLE;
-			const content = value.range[0] + (quoted ? 1 : 0);
-			if (source.slice(content, content + offset) === value.value.slice(0, offset)) {
-				const { line, col } = lines.linePos(content + offset);
-				return {
-					line,
-					column: col
-				};
-			}
-		}
-		const start = isScalar(pair?.key) ? pair.key.range?.[0] : void 0;
-		if (start === void 0) return {
-			line: 1,
-			column: 1
-		};
-		const { line, col } = lines.linePos(start);
-		return {
-			line,
-			column: col
-		};
-	};
-}
-/** The source message as a reader sees it with no placeholders filled: for docs and reports. */
-function previewOf(message) {
-	return staticLiteral(message.ast) ?? message.text;
-}
-// src/tools/compile.ts
-/**
-* Compiles ICU ASTs to JavaScript.
-*
-* A message with no placeholders becomes its string. Any other becomes `(a, h) => …`, where `a` holds
-* the arguments and `h` the locale's helpers (see `runtime/helpers.ts`): a plural is a call picking an
-* arm, a number is a call to a cached `Intl.NumberFormat`. Formatting options are resolved here and
-* hoisted to module constants, so a skeleton costs nothing at runtime and its formatter is built once.
-*/
-/** Module-level constants for formatting options, one per distinct object. */
-var Hoisted = class {
-	byJson = /* @__PURE__ */ new Map();
-	/** `, oN` naming the hoisted options, or nothing when there are none. */
-	arg(options) {
-		if (options === void 0 || Object.keys(options).length === 0) return "";
-		const json = JSON.stringify(options);
-		let name = this.byJson.get(json);
-		if (name === void 0) this.byJson.set(json, name = `o${this.byJson.size}`);
-		return `, ${name}`;
-	}
-	declarations() {
-		return [...this.byJson].map(([json, name]) => `const ${name} = ${json};`);
-	}
-};
-function access(name) {
-	return /^[A-Za-z_$][\w$]*$/.test(name) ? `a.${name}` : `a[${JSON.stringify(name)}]`;
-}
-function nodes(elements, hoisted, pound) {
-	if (elements.length === 0) return "\"\"";
-	const parts = elements.map((el) => node(el, hoisted, pound));
-	return parts.length === 1 ? parts[0] : `[${parts.join(", ")}]`;
-}
-function arms(options, hoisted, pound) {
-	return `{ ${Object.entries(options).map(([arm, option]) => `${JSON.stringify(arm)}: () => ${nodes(option.value, hoisted, pound)}`).join(", ")} }`;
-}
-function node(el, hoisted, pound) {
-	if (isNumberElement(el)) return `h.n(${access(el.value)}${hoisted.arg(numberOptions(el))})`;
-	if (isDateElement(el) || isTimeElement(el)) return `h.d(${access(el.value)}${hoisted.arg(dateOptions(el))})`;
-	switch (el.type) {
-		case TYPE$1.literal: return JSON.stringify(el.value);
-		case TYPE$1.argument: return access(el.value);
-		case TYPE$1.pound: return pound ?? "\"#\"";
-		case TYPE$1.select: return `h.s(${access(el.value)}, ${arms(el.options, hoisted, pound)})`;
-		case TYPE$1.plural: {
-			const value = access(el.value);
-			const hash = `h.n(${value}${el.offset !== 0 ? ` - ${el.offset}` : ""})`;
-			return `h.p(${value}, ${el.offset}, ${el.pluralType === "ordinal"}, ${arms(el.options, hoisted, hash)})`;
-		}
-		case TYPE$1.tag: return `h.t(a, ${JSON.stringify(el.value)}, ${nodes(el.children, hoisted, pound)})`;
-		default: throw new Error(`prosebook: no compiler for ICU element type ${el.type}`);
-	}
-}
-function message(ast, hoisted) {
-	const literal = staticLiteral(ast);
-	return literal === void 0 ? `(a, h) => ${nodes(ast, hoisted, null)}` : JSON.stringify(literal);
-}
-/** One locale's messages as code, keeping only `keep` when given. */
-function compileLocale(entries, keep) {
-	const hoisted = new Hoisted();
-	const rows = [];
-	for (const [key, ast] of entries) {
-		if (keep && !keep(key)) continue;
-		rows.push(`  ${JSON.stringify(key)}: ${message(ast, hoisted)},`);
-	}
-	return {
-		declarations: hoisted.declarations(),
-		rows
-	};
-}
-/** The locale as an ES module whose default export is its messages. */
-function localeModule(compiled, banner, ts) {
-	const head = ts ? `${banner}\nimport type { CompiledMessages } from 'prosebook';\n` : `${banner}\n`;
-	const declarations = ts ? compiled.declarations.map((d) => d.replace(/;$/, " as const;")) : compiled.declarations;
-	const consts = declarations.length > 0 ? `\n${declarations.join("\n")}\n` : "";
-	const close = ts ? "} satisfies CompiledMessages;" : "};";
-	return `${head}${consts}\nexport default {\n${compiled.rows.join("\n")}\n${close}\n`;
-}
-/** The locale as one expression, for a bundler to inline in place of the module. */
-function localeExpression(compiled) {
-	return `(() => {\n${compiled.declarations.join("\n")}\nreturn {\n${compiled.rows.join("\n")}\n};\n})()`;
-}
-// src/tools/entry.ts
-/**
-* One entry as the dev inspector's dialog edits it, in every locale: as fields, or as the YAML written
-* in its files.
-*
-* An edit is checked as the whole catalog, with the edited files read from memory, before anything is
-* written: a save that would break the build comes back as problems instead, and the dev server never
-* sees it. Fields are written into the parsed document, so comments, order and quoting elsewhere in the
-* file stay as they were; YAML replaces the entry's text as typed. A translation left empty is no
-* translation: one that was there is removed, and the locale falls back.
-*/
-/** The entry for `key`, with its translation in every locale. */
-function readEntry(config, key) {
-	return viewOf(config, loadCatalog(config), key, /* @__PURE__ */ new Map());
-}
-/**
-* Applies an edit and checks the catalog with it. With `write`, a clean edit is written; without, it
-* only comes back as the view, which is how the dialog turns fields into YAML and back.
-*/
-function editEntry(config, key, edit, write) {
-	const current = viewOf(config, loadCatalog(config), key, /* @__PURE__ */ new Map());
-	const unsaved = /* @__PURE__ */ new Map();
-	const text = (file) => contentOf(config, file, unsaved);
-	const put = (file, content) => unsaved.set(resolve(config.root, file), content);
-	const translated = [];
-	if ("yaml" in edit) {
-		put(current.files.catalog, withSnippet(text(current.files.catalog), key, edit.yaml.catalog));
-		for (const locale of current.locales) {
-			const yaml = edit.yaml.translations?.[locale]?.trim() ?? current.yaml.translations[locale];
-			if (yaml !== "") translated.push(locale);
-			if (yaml === current.yaml.translations[locale]) continue;
-			put(current.files.translations[locale], withSnippet(text(current.files.translations[locale]), key, yaml));
-		}
-	} else {
-		put(current.files.catalog, withFields(text(current.files.catalog), key, edit.fields, config.source));
-		for (const locale of current.locales) {
-			const next = edit.fields.translations[locale] ?? "";
-			if (next.trim() !== "") translated.push(locale);
-			if (next === current.fields.translations[locale]) continue;
-			put(current.files.translations[locale], withTranslation(text(current.files.translations[locale]), key, next));
-		}
-	}
-	let catalog;
-	try {
-		catalog = loadCatalog(config, unsaved);
-	} catch (e) {
-		if (!(e instanceof CatalogError)) throw e;
-		return { problems: e.problems.filter((p) => p.severity === "error") };
-	}
-	const message = catalog.messages.find((m) => m.key === key);
-	const renamed = [...message === void 0 ? [current.files.catalog] : [], ...translated.filter((l) => message?.translations.has(l) !== true).map((l) => current.files.translations[l])];
-	if (renamed.length > 0) {
-		const problem = `the entry is still ${key}: rename a key in the code and the catalog together`;
-		return { problems: renamed.map((file) => ({
-			severity: "error",
-			file,
-			key,
-			message: problem
-		})) };
-	}
-	if (write) for (const [path, content] of unsaved) {
-		if (existsSync(path) && readFileSync(path, "utf8") === content) continue;
-		mkdirSync(dirname(path), { recursive: true });
-		writeFileSync(path, content);
-	}
-	return {
-		view: viewOf(config, catalog, key, unsaved),
-		problems: []
-	};
-}
-/**
-* Makes the edits that lint's findings carry, each message in its own file, and writes them only if
-* the catalog they make loads clean: the problems come back instead, and nothing is written.
-*/
-function applyFixes(config, catalog, findings) {
-	const unsaved = /* @__PURE__ */ new Map();
-	const entries = /* @__PURE__ */ new Map();
-	for (const f of findings) {
-		if (f.fix === void 0) continue;
-		const id = `${f.locale}\u0000${f.key}`;
-		const entry = entries.get(id) ?? {
-			file: f.file,
-			key: f.key,
-			locale: f.locale,
-			edits: [],
-			count: 0
-		};
-		entry.edits.push(...f.fix);
-		entry.count += 1;
-		entries.set(id, entry);
-	}
-	let fixed = 0;
-	for (const { file, key, locale, edits, count } of entries.values()) {
-		const message = catalog.messages.find((m) => m.key === key);
-		const written = locale === config.source ? message?.text : message?.translations.get(locale)?.text;
-		if (written === void 0) continue;
-		const next = applyEdits(written, edits);
-		if (next === written) continue;
-		const content = contentOf(config, file, unsaved);
-		unsaved.set(resolve(config.root, file), locale === config.source ? withMessage(content, key, next, config.source) : withTranslation(content, key, next));
-		fixed += count;
-	}
-	try {
-		loadCatalog(config, unsaved);
-	} catch (e) {
-		if (!(e instanceof CatalogError)) throw e;
-		return {
-			fixed: 0,
-			problems: e.problems.filter((p) => p.severity === "error")
-		};
-	}
-	for (const [path, content] of unsaved) writeFileSync(path, content);
-	return {
-		fixed,
-		problems: []
-	};
-}
-/** A file as the edit has it, as it is on disk, or empty when it is still to be made. */
-function contentOf(config, file, unsaved) {
-	const path = resolve(config.root, file);
-	return unsaved.get(path) ?? (existsSync(path) ? readFileSync(path, "utf8") : "");
-}
-/** The file a translation goes in: beside the locale's others, in its folder or its one file. */
-function translationFile(config, message, locale) {
-	const existing = message.translations.get(locale)?.file;
-	if (existing !== void 0) return existing;
-	const folder = join(config.locales, locale);
-	const path = existsSync(folder) && statSync(folder).isDirectory() ? join(folder, `${message.area}.yaml`) : `${folder}.yaml`;
-	return relative(config.root, path).replaceAll("\\", "/");
-}
-function viewOf(config, catalog, key, unsaved) {
-	const message = catalog.messages.find((m) => m.key === key);
-	if (message === void 0) throw new Error(`no entry for "${key}" in the catalog: has it been renamed since the page loaded?`);
-	const files = Object.fromEntries(catalog.locales.map((l) => [l, translationFile(config, message, l)]));
-	return {
-		key,
-		source: config.source,
-		locales: catalog.locales,
-		files: {
-			catalog: message.file,
-			translations: files
-		},
-		fields: {
-			message: message.text,
-			translations: Object.fromEntries(catalog.locales.map((l) => [l, message.translations.get(l)?.text ?? ""])),
-			context: message.context ?? "",
-			kind: message.kind ?? "",
-			surface: message.surface ?? "",
-			fragment: message.fragment,
-			args: Object.fromEntries(message.argDocs),
-			comment: message.comment ?? "",
-			remove: message.remove
-		},
-		yaml: {
-			catalog: snippetOf(contentOf(config, message.file, unsaved), key)?.text ?? "",
-			translations: Object.fromEntries(catalog.locales.map((l) => [l, snippetOf(contentOf(config, files[l], unsaved), key)?.text ?? ""]))
-		},
-		argNames: [...message.args.keys()],
-		kinds: Object.keys(config.kinds),
-		surfaces: Object.keys(config.surfaces),
-		findings: lint([message], config).map((f) => {
-			const written = f.locale === config.source ? message.text : message.translations.get(f.locale)?.text;
-			return f.fix === void 0 || written === void 0 ? f : {
-				...f,
-				fixed: applyEdits(written, f.fix)
-			};
-		})
-	};
-}
-/** Where an entry is written: from the start of its key's line to the end of its value. */
-function snippetOf(file, key) {
-	const doc = parseDocument(file);
-	if (!isMap(doc.contents)) return void 0;
-	const pair = doc.contents.items.find((p) => isScalar(p.key) && p.key.value === key);
-	const keyStart = isScalar(pair?.key) ? pair.key.range?.[0] : void 0;
-	const valueEnd = (pair?.value)?.range?.[1];
-	if (keyStart === void 0 || valueEnd === void 0) return void 0;
-	const start = file.lastIndexOf("\n", keyStart - 1) + 1;
-	const end = start + file.slice(start, valueEnd).trimEnd().length;
-	return {
-		start,
-		end,
-		text: file.slice(start, end)
-	};
-}
-/** The file with the entry's text replaced, removed when `yaml` is empty, or added at the end. */
-function withSnippet(file, key, yaml) {
-	const text = yaml.replace(/\n+$/, "");
-	const at = snippetOf(file, key);
-	if (at !== void 0) {
-		if (text.trim() === "") return file.slice(0, at.start) + file.slice(at.end).replace(/^\n/, "");
-		return file.slice(0, at.start) + text + file.slice(at.end);
-	}
-	if (text.trim() === "") return file;
-	return file.trim() === "" ? `${text}\n` : `${file.replace(/\n*$/, "\n")}${text}\n`;
-}
-function parse$2(file) {
-	const doc = parseDocument(file, { version: "1.1" });
-	if (doc.contents === null) doc.contents = doc.createNode({});
-	return doc;
-}
-const print = (doc) => doc.toString({
-	lineWidth: 0,
-	singleQuote: true
-});
-/** A value written where one was, keeping how it was quoted; text over several lines as a block. */
-function setValue(doc, map, name, value) {
-	const node = map.get(name, true);
-	if (isScalar(node) && typeof value === "string") {
-		node.value = value;
-		if (value.includes("\n")) node.type = Scalar.BLOCK_LITERAL;
-		return;
-	}
-	map.set(name, doc.createNode(value));
-}
-function withFields(file, key, fields, source) {
-	const doc = parse$2(file);
-	let entry = doc.get(key, true);
-	if (!isMap(entry)) {
-		entry = doc.createNode({ [source]: fields.message });
-		doc.set(key, entry);
-	}
-	const map = entry;
-	const args = Object.fromEntries(Object.entries(fields.args).filter(([, v]) => v.trim() !== ""));
-	const wanted = [
-		["kind", fields.kind.trim() || void 0],
-		["surface", fields.surface.trim() || void 0],
-		["context", fields.context.trim() || void 0],
-		["args", Object.keys(args).length > 0 ? args : void 0],
-		["fragment", fields.fragment || void 0],
-		["comment", fields.comment.trim() || void 0],
-		["remove", fields.remove || void 0]
-	];
-	for (const [name, value] of wanted) {
-		if (value === void 0) {
-			map.delete(name);
-			continue;
-		}
-		if (map.has(name)) {
-			setValue(doc, map, name, value);
-			continue;
-		}
-		const at = map.items.findIndex((p) => isScalar(p.key) && p.key.value === source);
-		map.items.splice(at === -1 ? map.items.length : at, 0, doc.createPair(name, value));
-	}
-	setValue(doc, map, source, fields.message);
-	return print(doc);
-}
-/** The source message replaced, and nothing else: a `key: message` entry stays one. */
-function withMessage(file, key, message, source) {
-	const doc = parse$2(file);
-	const entry = doc.get(key, true);
-	if (!isMap(entry)) return withTranslation(file, key, message);
-	setValue(doc, entry, source, message);
-	return print(doc);
-}
-function withTranslation(file, key, translation) {
-	const doc = parse$2(file);
-	const node = doc.get(key, true);
-	if (translation.trim() === "") doc.delete(key);
-	else if (isScalar(node)) {
-		node.value = translation;
-		if (translation.includes("\n")) node.type = Scalar.BLOCK_LITERAL;
-	} else doc.set(key, translation);
-	return isMap(doc.contents) && doc.contents.items.length === 0 ? "" : print(doc);
-}
-// src/tools/lock.ts
-/**
-* Stale translations: a translation made from source text that has since changed.
-*
-* The lock records, per translation, a hash of the source it was made from and a hash of the
-* translation itself. Editing the translation re-anchors it to the current source; editing only
-* the source leaves the old anchor in place, which is what marks it stale. Nobody has to remember
-* to flag anything: `prosebook status` lists what is stale, and `prosebook accept` re-anchors a
-* translation that was still right.
-*
-* The lock also keeps the text behind each anchor, once per distinct text, so a stale translation
-* can show its translator what changed rather than only what the source says now.
-*/
-function hash(text) {
-	return createHash("sha256").update(text).digest("hex").slice(0, 10);
-}
-function emptyLock() {
-	return {
-		version: 2,
-		sources: {},
-		translations: {}
-	};
-}
-/** The lock at `path`. A version 1 lock, which held only the translations, reads with no source texts. */
-function readLock(path) {
-	if (!existsSync(path)) return emptyLock();
-	const raw = JSON.parse(readFileSync(path, "utf8"));
-	if (raw.version === 2) return {
-		...emptyLock(),
-		...raw
-	};
-	return {
-		version: 2,
-		sources: {},
-		translations: raw
-	};
-}
-const sortedEntries = (record) => Object.fromEntries(Object.entries(record).sort(([a], [b]) => a < b ? -1 : 1));
-function serializeLock(lock) {
-	const translations = Object.fromEntries(Object.keys(lock.translations).sort().map((locale) => [locale, sortedEntries(lock.translations[locale])]));
-	return `${JSON.stringify({
-		version: 2,
-		sources: sortedEntries(lock.sources),
-		translations
-	}, null, 2)}\n`;
-}
-/**
-* The lock brought up to date with the catalog, and what is stale. `accept` re-anchors the given
-* translations (per locale, keys, or `true` for all of them) to the current source.
-*/
-function reconcile(catalog, previous, accept = /* @__PURE__ */ new Map()) {
-	const lock = emptyLock();
-	const stale = /* @__PURE__ */ new Map();
-	for (const message of catalog.messages) {
-		const source = hash(message.text);
-		for (const [locale, translation] of message.translations) {
-			const text = hash(translation.text);
-			const [anchor, recorded] = (previous.translations[locale]?.[message.key] ?? "").split(":");
-			const accepted = accept.get(locale);
-			const reanchor = anchor === void 0 || anchor === "" || recorded !== text || accepted === true || accepted?.has(message.key) === true;
-			const kept = reanchor ? source : anchor;
-			(lock.translations[locale] ??= {})[message.key] = `${kept}:${text}`;
-			const keptText = kept === source ? message.text : previous.sources[kept];
-			if (keptText !== void 0) lock.sources[kept] = keptText;
-			if (!reanchor && anchor !== source) {
-				let keys = stale.get(locale);
-				if (keys === void 0) stale.set(locale, keys = /* @__PURE__ */ new Map());
-				keys.set(message.key, {
-					was: keptText,
-					now: message.text,
-					translation: translation.text
-				});
-			}
-		}
-	}
-	return {
-		lock,
-		stale
-	};
-}
-// src/tools/pseudo.ts
-/**
-* Pseudo-localization: the source with every letter accented, vowels doubled for the length a
-* translation usually adds, and brackets around the whole. A screen in the pseudo-locale shows at a
-* glance which text is hardcoded (it is plain), which is clipped (a bracket is missing), and which
-* splices fragments together (brackets inside brackets).
-*/
-const PLAIN = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-const ACCENTED = Array.from("áƀçðéƒĝĥíĵķļɱñóþǫŕšţúṽŵẋýžÁƁÇÐÉƑĜĤÍĴĶĻṀÑÓÞǪŔŠŢÚṼŴẊÝŽ");
-function pseudoText(text) {
-	return text.replace(/[A-Za-z]/g, (c) => {
-		const accented = ACCENTED[PLAIN.indexOf(c)];
-		return /[aeiou]/i.test(c) ? accented.repeat(2) : accented;
-	});
-}
-function transform(elements) {
-	return elements.map((el) => {
-		if (el.type === TYPE$1.literal) return {
-			...el,
-			value: pseudoText(el.value)
-		};
-		if (el.type === TYPE$1.tag) return {
-			...el,
-			children: transform(el.children)
-		};
-		if (el.type === TYPE$1.select || el.type === TYPE$1.plural) {
-			const options = Object.fromEntries(Object.entries(el.options).map(([arm, o]) => [arm, {
-				...o,
-				value: transform(o.value)
-			}]));
-			return {
-				...el,
-				options
-			};
-		}
-		return el;
-	});
-}
-function pseudoAst(ast) {
-	const out = [];
-	for (const el of [
-		{
-			type: TYPE$1.literal,
-			value: "⟦"
-		},
-		...transform(ast),
-		{
-			type: TYPE$1.literal,
-			value: "⟧"
-		}
-	]) {
-		const last = out.at(-1);
-		if (el.type === TYPE$1.literal && last?.type === TYPE$1.literal) out[out.length - 1] = {
-			...last,
-			value: last.value + el.value
-		};
-		else out.push(el);
-	}
-	return out;
-}
-// src/tools/generate.ts
-/**
-* Turns the catalog into the modules an app imports.
-*
-* Generated rather than loaded so that a missing key, a misspelled key or a missing argument is a type
-* error, and so the runtime needs neither a YAML nor an ICU parser. The index carries each key's source
-* text and context as a doc comment, so hovering a key at its call site shows what the screen says.
-*/
-const quote = (s) => JSON.stringify(s);
-const prop = (name) => /^[A-Za-z_$][\w$]*$/.test(name) ? name : quote(name);
-function banner(config) {
-	return `// Generated by prosebook from ${relative(config.root, config.catalog).replaceAll("\\", "/")}. Do not edit: change the catalog and run \`prosebook generate\`.`;
-}
-/** Every locale the app can switch to, in order: the source, the translations, the pseudo-locale. */
-function localesOf(catalog, config) {
-	return [
-		config.source,
-		...catalog.locales,
-		...config.pseudo !== false ? [config.pseudo] : []
-	];
-}
-/** Per locale, the messages its module holds. A translated locale holds only what it translates. */
-function localeEntries(catalog, config, stale) {
-	const out = /* @__PURE__ */ new Map();
-	out.set(config.source, catalog.messages.map((m) => [m.key, m.ast]));
-	for (const locale of catalog.locales) {
-		const skip = config.stale === "fallback" ? stale.get(locale) : void 0;
-		out.set(locale, catalog.messages.flatMap((m) => {
-			const t = m.translations.get(locale);
-			return t === void 0 || skip?.has(m.key) === true ? [] : [[m.key, t.ast]];
-		}));
-	}
-	if (config.pseudo !== false) out.set(config.pseudo, catalog.messages.map((m) => [m.key, pseudoAst(m.ast)]));
-	return out;
-}
-function doc(lines, indent) {
-	const safe = lines.map((l) => l.replaceAll("*/", "*\\/"));
-	if (safe.length === 1) return `${indent}/** ${safe[0]} */\n`;
-	return `${indent}/**\n${safe.map((l) => l === "" ? `${indent} *` : `${indent} * ${l}`).join("\n")}\n${indent} */\n`;
-}
-/** A doc written as a phrase (`the person's name`) reads as a sentence in a doc comment. */
-function sentence(text) {
-	const capital = text.charAt(0).toUpperCase() + text.slice(1);
-	return /[.!?]$/.test(capital) ? capital : `${capital}.`;
-}
-function shapeOf(m) {
-	const tags = m.tags.length > 0 ? m.tags.map(quote).join(" | ") : "never";
-	if (m.args.size === 0) return `{ args: {}; tags: ${tags} }`;
-	return `{\n    args: {\n${[...m.args].map(([name, type]) => {
-		const held = m.argDocs.get(name);
-		const said = [held === void 0 ? void 0 : sentence(held), m.argFormats.has(name) ? `Formatted as ${m.argFormats.get(name)}.` : void 0].filter(Boolean);
-		return `${said.length > 0 ? doc([said.join(" ")], "      ") : ""}      readonly ${prop(name)}: ${type};`;
-	}).join("\n")}\n    };\n    tags: ${tags};\n  }`;
-}
-function typesBlock(catalog, locales) {
-	const rows = catalog.messages.map((m) => {
-		const lines = (m.text.length > 400 ? `${m.text.slice(0, 397)}...` : m.text).split("\n");
-		if (m.context) lines.push("", m.context);
-		if (m.remove) lines.push("", "Marked for removal in the catalog.");
-		if (m.comment) lines.push("", `Comment: ${m.comment}`);
-		return `${doc(lines, "  ")}  ${quote(m.key)}: ${shapeOf(m)};`;
-	});
-	return [
-		`export type Locale = ${locales.map(quote).join(" | ")};`,
-		"",
-		"/** Every message in the catalog: the arguments it takes and the tags it wraps text in. */",
-		`export type Messages = {\n${rows.join("\n")}\n};`
-	].join("\n");
-}
-const REGISTER = `declare module 'prosebook' {
-  interface Register {
-    messages: Messages;
-    locale: Locale;
-  }
-}`;
-function catalogLiteral(config, locales, ext) {
-	const eager = locales.filter((l) => l === config.source || config.bundled.includes(l));
-	const lazy = locales.filter((l) => !eager.includes(l));
-	const ident = (l) => `m_${l.replace(/\W/g, "_")}`;
-	return {
-		imports: eager.map((l) => `import ${ident(l)} from './${l}${ext}';`),
-		literal: [
-			"{",
-			`  source: ${quote(config.source)},`,
-			`  locales: [${locales.map(quote).join(", ")}],`,
-			`  messages: { ${eager.map((l) => `${prop(l)}: ${ident(l)}`).join(", ")} },`,
-			`  loaders: { ${lazy.map((l) => `${prop(l)}: () => import('./${l}${ext}')`).join(", ")} },`,
-			"}"
-		].join("\n")
-	};
-}
-/** The JSON Schema an editor reads to complete and explain catalog entries. */
-function catalogSchema(config) {
-	return {
-		$schema: "https://json-schema.org/draft/2020-12/schema",
-		title: "prosebook catalog",
-		description: "Generated by `prosebook generate` from the config. Do not edit.",
-		type: "object",
-		propertyNames: { pattern: "^[a-z0-9]+(?:[-_][a-z0-9]+)*(?:\\.[a-z0-9]+(?:[-_][a-z0-9]+)*)+$" },
-		additionalProperties: { oneOf: [{
-			type: "string",
-			description: `The message, in ${SYNTAX_NAME[config.messageFormat]}, with nothing said about it.`
-		}, {
-			type: "object",
-			required: [config.source, ...config.require],
-			additionalProperties: false,
-			properties: {
-				[config.source]: {
-					type: "string",
-					description: `The message, in ${SYNTAX_NAME[config.messageFormat]}.`
-				},
-				kind: {
-					description: "What sort of string it is.",
-					oneOf: Object.entries(config.kinds).map(([k, r]) => ({
-						const: k,
-						description: r.doc
-					}))
-				},
-				surface: {
-					description: "Where the string sits.",
-					oneOf: Object.entries(config.surfaces).map(([k, d]) => ({
-						const: k,
-						description: d
-					}))
-				},
-				context: {
-					type: "string",
-					description: "One sentence telling a translator where the string appears and what it answers to."
-				},
-				args: {
-					type: "object",
-					description: "What each placeholder holds.",
-					additionalProperties: { type: "string" }
-				},
-				fragment: {
-					type: "boolean",
-					description: "Completes something beside it rather than standing as a sentence."
-				},
-				comment: {
-					type: "string",
-					description: "A change asked of whoever edits the entry next. Make it, then delete the comment."
-				},
-				remove: {
-					type: "boolean",
-					description: "Asks for the entry to go: delete it, its translations and the code that reads it."
-				},
-				allow: {
-					type: "object",
-					description: "Lint rules this entry is exempt from, each with the reason.",
-					propertyNames: { enum: Object.keys(config.lint.rules) },
-					additionalProperties: { type: "string" }
-				}
-			}
-		}] }
-	};
-}
-/** Everything `generate` writes, in memory. */
-function render(config, accept) {
-	const catalog = loadCatalog(config);
-	const { lock, stale } = reconcile(catalog, readLock(config.lock), accept);
-	const locales = localesOf(catalog, config);
-	const entries = localeEntries(catalog, config, stale);
-	const ts = config.language === "ts";
-	const head = banner(config);
-	const files = /* @__PURE__ */ new Map();
-	for (const [locale, list] of entries) files.set(join(config.out, `${locale}.${ts ? "ts" : "js"}`), localeModule(compileLocale(list), head, ts));
-	const { imports, literal } = catalogLiteral(config, locales, config.importExtension);
-	const types = typesBlock(catalog, locales);
-	if (ts) files.set(join(config.out, "index.ts"), [
-		head,
-		"import { defineCatalog } from 'prosebook';",
-		...imports,
-		"",
-		types,
-		"",
-		`export const catalog = defineCatalog<Messages, Locale>(${literal});`,
-		"",
-		REGISTER,
-		""
-	].join("\n"));
-	else {
-		files.set(join(config.out, "index.js"), [
-			head,
-			"import { defineCatalog } from 'prosebook';",
-			...imports,
-			"",
-			`export const catalog = defineCatalog(${literal});`,
-			""
-		].join("\n"));
-		files.set(join(config.out, "index.d.ts"), [
-			head,
-			"import type { Catalog } from 'prosebook';",
-			"",
-			types,
-			"",
-			"export declare const catalog: Catalog<Messages, Locale>;",
-			"",
-			REGISTER,
-			""
-		].join("\n"));
-	}
-	files.set(join(config.catalog, "catalog.schema.json"), `${JSON.stringify(catalogSchema(config), null, 2)}\n`);
-	if (Object.keys(lock.translations).length > 0 || existsSync(config.lock)) files.set(config.lock, serializeLock(lock));
-	return {
-		catalog,
-		files,
-		lock,
-		stale,
-		entries
-	};
-}
-/** Writes what changed. With `check`, writes nothing and returns what would have changed. */
-function writeFiles(files, check = false) {
-	const changed = [];
-	for (const [path, content] of files) {
-		if ((existsSync(path) ? readFileSync(path, "utf8") : void 0) === content) continue;
-		changed.push(path);
-		if (check) continue;
-		mkdirSync(dirname(path), { recursive: true });
-		writeFileSync(path, content);
-	}
-	return changed;
-}
-function generate(config, options = {}) {
-	const generated = render(config, options.accept);
-	return {
-		...generated,
-		changed: writeFiles(generated.files, options.check)
-	};
-}
-// src/tools/scan.ts
-/**
-* What the code says: text a person reads that is still written in a component, and which catalog
-* keys the code names.
-*
-* Key references are found by reading string literals, not by tracing calls, so a key kept in an
-* array or a map still counts, and `nav.${id}` or `'nav.' + id` keeps every key under `nav.`. That
-* errs towards keeping a key, which is the safe direction both for `unused` and for pruning a bundle.
-*/
-const SKIP_DIRS = /* @__PURE__ */ new Set([
-	"node_modules",
-	"dist",
-	"build",
-	"out",
-	"coverage",
-	".git"
-]);
-function sourceFiles(dirs, extensions, skip = []) {
-	const files = [];
-	const visit = (dir) => {
-		let names;
-		try {
-			names = readdirSync(dir);
-		} catch {
-			return;
-		}
-		for (const name of names) {
-			const path = join(dir, name);
-			if (skip.some((s) => path === s || path.startsWith(`${s}/`) || path.startsWith(`${s}\\`))) continue;
-			if (statSync(path).isDirectory()) {
-				if (!SKIP_DIRS.has(name) && !name.startsWith(".")) visit(path);
-			} else if (extensions.includes(extname(name)) && !name.endsWith(".d.ts")) files.push(path);
-		}
-	};
-	for (const dir of dirs) visit(dir);
-	return files.sort();
-}
-const LITERAL_KEY = /(['"`])([a-z0-9][\w-]*(?:\.[\w-]+)+)\1/g;
-const KEY_PREFIX = /(['"`])([a-z0-9][\w-]*(?:\.[\w-]+)*\.)(?:\1|\$\{)/g;
-function keyRefs(code, into = {
-	exact: /* @__PURE__ */ new Set(),
-	prefixes: /* @__PURE__ */ new Set()
-}) {
-	for (const m of code.matchAll(LITERAL_KEY)) into.exact.add(m[2]);
-	for (const m of code.matchAll(KEY_PREFIX)) into.prefixes.add(m[2]);
-	return into;
-}
-function isReferenced(key, refs) {
-	if (refs.exact.has(key)) return true;
-	for (const prefix of refs.prefixes) if (key.startsWith(prefix)) return true;
-	return false;
-}
-/**
-* Text that reads as code rather than prose: one token holding a path, a call, an identifier with an
-* underscore or a dotted name, as in `form.json()` or `src/index.ts`. Trailing punctuation doesn't
-* count, so `Done.` is still prose.
-*/
-function looksLikeCode(text) {
-	const token = text.trim().replace(/[.!?:,…]+$/, "");
-	return token !== "" && !/\s/.test(token) && /[/()_=<>{}[\].]|::/.test(token);
-}
-const NON_PROSE_ELEMENTS = /* @__PURE__ */ new Set([
-	"code",
-	"pre",
-	"kbd",
-	"samp",
-	"script",
-	"style",
-	"svg",
-	"path"
-]);
-const LETTER = /\p{L}/u;
-/** Literal text in JSX that a person reads, where it should be a catalog entry. */
-function hardcodedText(file, code, attributes) {
-	const { program } = parseSync(file, code);
-	const found = [];
-	const lines = code.split("\n");
-	const lineStarts = [];
-	let offset = 0;
-	for (const line of lines) {
-		lineStarts.push(offset);
-		offset += line.length + 1;
-	}
-	const position = (at) => {
-		let lo = 0;
-		let hi = lineStarts.length - 1;
-		while (lo < hi) {
-			const mid = lo + hi + 1 >> 1;
-			if (lineStarts[mid] <= at) lo = mid;
-			else hi = mid - 1;
-		}
-		return {
-			line: lo + 1,
-			column: at - lineStarts[lo] + 1
-		};
-	};
-	const ignored = (line) => (lines[line - 1] ?? "").includes("prosebook-ignore") || (lines[line - 2] ?? "").includes("prosebook-ignore");
-	const report = (node, text, where) => {
-		const trimmed = text.replace(/\s+/g, " ").trim();
-		if (!LETTER.test(trimmed) || looksLikeCode(trimmed)) return;
-		const at = position(node.start + Math.max(0, code.slice(node.start, node.end).search(/\S/)));
-		if (ignored(at.line)) return;
-		found.push({
-			file,
-			...at,
-			text: trimmed,
-			where
-		});
-	};
-	const visit = (node, inProse) => {
-		let prose = inProse;
-		if (node.type === "JSXElement") {
-			const opening = node.openingElement;
-			if (opening.name.type === "JSXIdentifier" && NON_PROSE_ELEMENTS.has(opening.name.name ?? "")) prose = false;
-		}
-		if (node.type === "JSXText" && prose) report(node, node.value, "text");
-		if (node.type === "JSXExpressionContainer" && prose) {
-			const expr = node.expression;
-			if (expr.type === "Literal" && typeof expr.value === "string") report(expr, expr.value, "text");
-			if (expr.type === "TemplateLiteral" && expr.expressions.length === 0) report(expr, String(expr.quasis[0]?.value.cooked), "text");
-		}
-		if (node.type === "JSXAttribute") {
-			const name = node.name;
-			const value = node.value;
-			const attr = name.type === "JSXIdentifier" ? name.name ?? "" : "";
-			if (attributes.includes(attr) && value !== null) {
-				if (value.type === "Literal" && typeof value.value === "string") report(value, value.value, attr);
-				if (value.type === "JSXExpressionContainer") {
-					const expr = value.expression;
-					if (expr.type === "Literal" && typeof expr.value === "string") report(expr, expr.value, attr);
-				}
-			}
-			return;
-		}
-		for (const value of Object.values(node)) if (Array.isArray(value)) {
-			for (const child of value) if (isNode(child)) visit(child, prose);
-		} else if (isNode(value)) visit(value, prose);
-	};
-	visit(program, true);
-	return found;
-}
-function isNode(value) {
-	return typeof value === "object" && value !== null && typeof value.type === "string";
-}
-function scan(dirs, extensions, attributes, root, skip = []) {
-	const refs = {
-		exact: /* @__PURE__ */ new Set(),
-		prefixes: /* @__PURE__ */ new Set()
-	};
-	const hardcoded = [];
-	const files = sourceFiles(dirs, extensions, skip);
-	for (const path of files) {
-		const code = readFileSync(path, "utf8");
-		keyRefs(code, refs);
-		if (/\.[jt]sx$/.test(path)) hardcoded.push(...hardcodedText(relative(root, path).replaceAll("\\", "/"), code, attributes));
-	}
-	return {
-		hardcoded,
-		refs,
-		files: files.length
-	};
-}
-export { loadCatalog as A, toMf1 as B, compileLocale as C, KEY_PATTERN as D, CatalogError as E, writeMessage as F, intlDate as I, intlNumber as L, whereOf as M, SYNTAX_NAME as N, entryLocation as O, readMessage as P, parseMf2 as R, readEntry as S, localeModule as T, readLock as _, scan as a, applyFixes as b, generate as c, render as d, writeFiles as f, hash as g, emptyLock as h, looksLikeCode as i, previewOf as j, entryLocator as k, localeEntries as l, pseudoText as m, isReferenced as n, sourceFiles as o, pseudoAst as p, keyRefs as r, catalogSchema as s, hardcodedText as t, localesOf as u, reconcile as v, localeExpression as w, editEntry as x, serializeLock as y, toMf2 as z };
-
-//# sourceMappingURL=scan-B0tZ7y-D.js.map