@moku-labs/game 0.0.1 → 0.0.2

package/dist/assets.mjs

@@ -0,0 +1,4729 @@
+import path from "node:path";
+import { createBrandConsole } from "@moku-labs/common/cli";
+import { mkdir, open, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+//#region src/plugins/assets/scan/emit.ts
+const HEADER$1 = "// generated by @moku-labs/game/assets, do not edit";
+/** How the generated table ends, so the keys stay literal types for the game. */
+const FROZEN = " as const;";
+/**
+* Compares two names, so every list the scanner writes has one order.
+*
+* @param left - First name.
+* @param right - Second name.
+* @returns The sort order.
+*/
+function byName$2(left, right) {
+	return left.localeCompare(right);
+}
+/**
+* Writes one file entry with a fixed field order. A texture says nothing about its kind, which
+* is what keeps a manifest written before fonts and audio readable. The reserved `atlas` field
+* is dropped: this version never packs an atlas.
+*
+* @param file - The file.
+* @returns The entry as JSON data.
+*/
+function plainFile(file) {
+	const kind = file.kind ?? "texture";
+	if (kind !== "texture") return {
+		key: file.key,
+		path: file.path,
+		kind,
+		mb: file.mb,
+		...file.pages === void 0 ? {} : { pages: file.pages.map((page) => ({ ...page })) }
+	};
+	return {
+		key: file.key,
+		path: file.path,
+		width: file.width,
+		height: file.height,
+		mb: file.mb,
+		...file.nine === void 0 ? {} : { nine: file.nine }
+	};
+}
+/**
+* Writes one bundle with a fixed field order and its files sorted by key.
+*
+* @param bundle - The bundle.
+* @returns The bundle as JSON data.
+*/
+function plainBundle(bundle) {
+	return {
+		feature: bundle.feature,
+		tier: bundle.tier,
+		mb: bundle.mb,
+		files: bundle.files.toSorted((left, right) => byName$2(left.key, right.key)).map((file) => plainFile(file))
+	};
+}
+/**
+* Lists the bundle names of a manifest, sorted.
+*
+* @param manifest - The manifest.
+* @returns The names.
+*/
+function bundleNames(manifest) {
+	return Object.keys(manifest.bundles).toSorted(byName$2);
+}
+/**
+* Lists the bundles of a manifest with their names, sorted by name.
+*
+* @param manifest - The manifest.
+* @returns The pairs.
+*/
+function sortedBundles(manifest) {
+	return Object.entries(manifest.bundles).toSorted((left, right) => byName$2(left[0], right[0]));
+}
+/**
+* Lists every file of a manifest, bundle by bundle in name order.
+*
+* @param manifest - The manifest.
+* @returns The files.
+*/
+function allFiles(manifest) {
+	const files = [];
+	for (const [, bundle] of sortedBundles(manifest)) files.push(...bundle.files);
+	return files;
+}
+/**
+* Writes one union type, or `never` when the game has no key of that kind yet.
+*
+* @param name - Name of the type.
+* @param values - The members, in any order.
+* @returns The declaration.
+*/
+function union(name, values) {
+	const members = [...new Set(values)].toSorted(byName$2);
+	if (members.length === 0) return `export type ${name} = never;`;
+	return `export type ${name} =\n${members.map((member) => `  | "${member}"`).join("\n")};`;
+}
+/**
+* Lists the keys of one kind. They are the narrow unions a text style and a sound are typed by,
+* so a texture key does not compile where a font is meant.
+*
+* @param files - Every file of the manifest.
+* @param kind - The kind to collect.
+* @returns The asset keys of that kind.
+* @example
+* ```ts
+* keysOfKind([{ key: "ui.body", path: "b.fnt", kind: "font", width: 0, height: 0, mb: 0 }], "font");
+* // ["ui.body"]
+* ```
+*/
+function keysOfKind(files, kind) {
+	return files.filter((file) => file.kind === kind).map((file) => file.key);
+}
+/**
+* Writes the nine-slice table the kit reads when it builds a nine-slice sprite.
+*
+* @param entries - The keys that carry borders.
+* @returns The declaration.
+*/
+function nineTable(entries) {
+	if (entries.length === 0) return `export const nineSlice = {}${FROZEN}`;
+	return `export const nineSlice = {\n${entries.toSorted((left, right) => byName$2(left.key, right.key)).map(({ key, nine }) => `  "${key}": { left: ${nine.left}, top: ${nine.top}, right: ${nine.right}, bottom: ${nine.bottom} }`).join(",\n")}\n}${FROZEN}`;
+}
+/**
+* Writes `manifest.json`: two-space JSON with a trailing newline, bundles sorted by name and
+* files sorted by key.
+*
+* @param manifest - What the scan produced.
+* @returns The text of the file.
+* @example
+* ```ts
+* emitManifest({ version: 1, bundles: {} }); // '{\n  "version": 1,\n  "bundles": {}\n}\n'
+* ```
+*/
+function emitManifest(manifest) {
+	const bundles = {};
+	for (const [name, bundle] of sortedBundles(manifest)) bundles[name] = plainBundle(bundle);
+	return `${JSON.stringify({
+		version: manifest.version,
+		bundles
+	}, void 0, 2)}\n`;
+}
+/**
+* Writes `generated/assets.ts`: `AssetKey` over every kind, the narrower `FontKey` and `AudioKey`
+* next to it, `BundleKey`, and the nine-slice table. A game commits this file, so `defineGame` can
+* type `Sprite`, a text style, a sound, `defineBundles` and the `load` effect from it.
+*
+* @param manifest - What the scan produced.
+* @returns The text of the module.
+* @example
+* ```ts
+* emitKeys({ version: 1, bundles: {} });
+* // the header, four unions that are all "never" and an empty nine-slice table
+* ```
+*/
+function emitKeys(manifest) {
+	const files = allFiles(manifest);
+	const nine = [];
+	for (const file of files) if (file.nine !== void 0) nine.push({
+		key: file.key,
+		nine: file.nine
+	});
+	return `${[
+		HEADER$1,
+		union("AssetKey", files.map((file) => file.key)),
+		union("FontKey", keysOfKind(files, "font")),
+		union("AudioKey", keysOfKind(files, "audio")),
+		union("BundleKey", bundleNames(manifest)),
+		nineTable(nine)
+	].join("\n\n")}\n`;
+}
+//#endregion
+//#region src/plugins/assets/scan/fonts.ts
+/**
+* @file assets plugin, build time — the page images a BMFont file names. A `.fnt` and its pages
+* are one asset, so the scanner has to read the file to know which images belong to it. Pure and
+* free of the file system: the three formats a font exporter writes are all text.
+*/
+/** `page id=0 file="body_0.png"` in the text format, `<page id="0" file="body_0.png"/>` in XML. */
+const PAGE_FILE = /\bpage\b[^\n>]*?\bfile\s*=\s*"([^"]+)"/g;
+/**
+* Wraps a scanner problem in the message shape of the framework.
+*
+* @param message - One sentence naming the file.
+* @returns The error to throw.
+*/
+function problem$5(message) {
+	return /* @__PURE__ */ new Error(`[game] assets: ${message}`);
+}
+/**
+* Reads the page names of a BMFont JSON file. A page is a file name, or an object with one.
+*
+* @param source - The file contents.
+* @param file - Path of the file, for the message.
+* @returns The page file names, in the order the font declares them.
+* @throws {Error} When the JSON cannot be read.
+*/
+function jsonPages(source, file) {
+	let parsed;
+	try {
+		parsed = JSON.parse(source);
+	} catch {
+		throw problem$5(`the font "${file}" is not readable BMFont JSON.`);
+	}
+	const pages = parsed.pages;
+	if (!Array.isArray(pages)) return [];
+	return pages.map((page) => typeof page === "string" ? page : page.file).filter((page) => typeof page === "string");
+}
+/**
+* Reads the page images one `.fnt` file names, whichever of the three BMFont formats it is in.
+*
+* @param source - The file contents.
+* @param file - Path of the file from the scan root, for the messages.
+* @returns The page file names, relative to the folder of the font, in declaration order.
+* @throws {Error} When the file names no page, or its JSON cannot be read.
+* @example
+* ```ts
+* pagesOfFont('page id=0 file="body_0.png"', "features/ui/assets/body.fnt"); // ["body_0.png"]
+* ```
+*/
+function pagesOfFont(source, file) {
+	const text = source.trimStart();
+	const pages = text.startsWith("{") ? jsonPages(text, file) : [...source.matchAll(PAGE_FILE)].map((match) => match[1] ?? "");
+	if (pages.length === 0) throw problem$5(`the font "${file}" declares no page.`);
+	return pages;
+}
+const PNG_SIGNATURE = [
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+];
+const VP8_SYNC = [
+	157,
+	1,
+	42
+];
+const VP8L_SIGNATURE = 47;
+/** Both WebP frame headers carry the width and the height in 14 bits each. */
+const SIZE_MASK = 16383;
+const BYTES_PER_PIXEL = 4;
+const BYTES_PER_MB = 1048576;
+/**
+* Wraps a scanner problem in the message shape of the framework.
+*
+* @param message - One sentence naming the file.
+* @returns The error to throw.
+*/
+function problem$4(message) {
+	return /* @__PURE__ */ new Error(`[game] assets: ${message}`);
+}
+/**
+* Reads the bytes as a data view.
+*
+* @param head - The first bytes of the file.
+* @returns A view over exactly those bytes.
+*/
+function viewOf(head) {
+	return new DataView(head.buffer, head.byteOffset, head.byteLength);
+}
+/**
+* Tells whether a run of bytes stands at an offset.
+*
+* @param head - The first bytes of the file.
+* @param offset - Where to look.
+* @param bytes - What to find.
+* @returns True when every byte matches.
+*/
+function hasBytes(head, offset, bytes) {
+	return bytes.every((byte, index) => head[offset + index] === byte);
+}
+/**
+* Reads a run of bytes as ASCII, which is what the chunk names of these formats are.
+*
+* @param head - The first bytes of the file.
+* @param offset - Where to start.
+* @param length - How many bytes to read.
+* @returns The text.
+*/
+function ascii(head, offset, length) {
+	return String.fromCodePoint(...head.subarray(offset, offset + length));
+}
+/**
+* Reads a 24-bit little-endian number, the shape the `VP8X` canvas size uses.
+*
+* @param view - A view over the header bytes.
+* @param offset - Where the number starts.
+* @returns The number.
+*/
+function uint24Le(view, offset) {
+	return view.getUint16(offset, true) | view.getUint8(offset + 2) << 16;
+}
+/**
+* Reads the size out of the IHDR chunk of a PNG.
+*
+* @param head - The first bytes of the file.
+* @returns The size.
+*/
+function readPng(head) {
+	const view = viewOf(head);
+	return {
+		width: view.getUint32(16),
+		height: view.getUint32(20)
+	};
+}
+/**
+* Reads the size out of the frame header of a WebP, whichever of the three chunks it carries.
+*
+* @param head - The first bytes of the file.
+* @param file - Path of the file, for the messages.
+* @returns The size.
+* @throws {Error} When the chunk is unknown or its frame header is damaged.
+*/
+function readWebp(head, file) {
+	const view = viewOf(head);
+	const chunk = ascii(head, 12, 4);
+	if (chunk === "VP8 ") {
+		if (!hasBytes(head, 23, VP8_SYNC)) throw problem$4(`the VP8 frame of "${file}" is damaged.`);
+		return {
+			width: view.getUint16(26, true) & SIZE_MASK,
+			height: view.getUint16(28, true) & SIZE_MASK
+		};
+	}
+	if (chunk === "VP8L") {
+		if (head[20] !== VP8L_SIGNATURE) throw problem$4(`the VP8L frame of "${file}" is damaged.`);
+		const bits = view.getUint32(21, true);
+		return {
+			width: (bits & SIZE_MASK) + 1,
+			height: (bits >>> 14 & SIZE_MASK) + 1
+		};
+	}
+	if (chunk === "VP8X") return {
+		width: uint24Le(view, 24) + 1,
+		height: uint24Le(view, 27) + 1
+	};
+	throw problem$4(`"${file}" carries the WebP chunk "${chunk}", which this version cannot read.`);
+}
+/**
+* Reads the pixel size of an image out of its header bytes.
+*
+* @param head - The first `HEADER_BYTES` bytes of the file.
+* @param file - Path of the file, for the messages.
+* @returns The size.
+* @throws {Error} When the bytes are neither a PNG nor a WebP the scanner reads.
+* @example
+* ```ts
+* readImageSize(await readHead("panel.png"), "features/ui/assets/panel.png");
+* // { width: 256, height: 128 }
+* ```
+*/
+function readImageSize(head, file) {
+	if (head.length >= 30) {
+		if (hasBytes(head, 0, PNG_SIGNATURE) && ascii(head, 12, 4) === "IHDR") return readPng(head);
+		if (ascii(head, 0, 4) === "RIFF" && ascii(head, 8, 4) === "WEBP") return readWebp(head, file);
+	}
+	throw problem$4(`"${file}" is not a PNG or a WebP file.`);
+}
+/**
+* Estimates what one image costs on the GPU: four bytes per pixel, no mipmaps, rounded to three
+* decimals so two scans of the same tree write the same bytes.
+*
+* @param width - Width in pixels.
+* @param height - Height in pixels.
+* @returns The estimated texture memory in MB.
+* @example
+* ```ts
+* textureMb(256, 128); // 0.125
+* ```
+*/
+function textureMb(width, height) {
+	return Math.round(width * height * BYTES_PER_PIXEL / BYTES_PER_MB * 1e3) / 1e3;
+}
+/**
+* What a file costs in memory when it is kept as it is: an audio file is held undecoded, so its
+* bytes are the estimate. Rounded to three decimals, like every other number of the manifest.
+*
+* @param bytes - Size of the file in bytes.
+* @returns The size in MB.
+* @example
+* ```ts
+* bytesMb(8192); // 0.008
+* ```
+*/
+function bytesMb(bytes) {
+	return Math.round(bytes / BYTES_PER_MB * 1e3) / 1e3;
+}
+//#endregion
+//#region src/plugins/assets/scan/keys.ts
+const TEXTURE = /\.(?:png|webp)$/i;
+const FONT = /\.fnt$/i;
+const AUDIO = /\.mp3$/i;
+const TAG_GROUPS = /^(?:\{[^{}]*\})*$/;
+const WHOLE_NUMBER = /^\d+$/;
+/**
+* Which number of a nine tag each side takes, in the order left, top, right, bottom, by how many
+* numbers the tag carries: `{nine=N}`, `{nine=H,V}` and `{nine=L,T,R,B}`.
+*/
+const NINE_SIDES = {
+	1: [
+		0,
+		0,
+		0,
+		0
+	],
+	2: [
+		0,
+		1,
+		0,
+		1
+	],
+	4: [
+		0,
+		1,
+		2,
+		3
+	]
+};
+/**
+* Wraps a scanner problem in the message shape of the framework.
+*
+* @param message - One sentence naming the file.
+* @returns The error to throw.
+*/
+function problem$3(message) {
+	return /* @__PURE__ */ new Error(`[game] assets: ${message}`);
+}
+/**
+* Tells what the scanner makes of a file: one texture per PNG or WebP, one font per `.fnt` with
+* the pages it names, one sound per MP3. Everything else is left out with a note.
+*
+* @param fileName - Name of the file, with its extension.
+* @returns The kind of the asset, or `undefined` when the scanner reads no such file.
+* @example
+* ```ts
+* assetKindOf("body.fnt"); // "font"
+* assetKindOf("theme.ogg"); // undefined
+* ```
+*/
+function assetKindOf(fileName) {
+	if (TEXTURE.test(fileName)) return "texture";
+	if (FONT.test(fileName)) return "font";
+	if (AUDIO.test(fileName)) return "audio";
+}
+/**
+* Tells whether the scanner reads this file.
+*
+* @param fileName - Name of the file, with its extension.
+* @returns True for a PNG, a WebP, a `.fnt` or an MP3.
+* @example
+* ```ts
+* isAssetFile("star-on.webp"); // true
+* isAssetFile("notes.md"); // false
+* ```
+*/
+function isAssetFile(fileName) {
+	return assetKindOf(fileName) !== void 0;
+}
+/**
+* Reads the borders of a nine tag: one number for every side, two for the horizontal and the
+* vertical sides, or four in the order left, top, right, bottom.
+*
+* @param value - What stood behind the `=`.
+* @returns The four borders, or `undefined` when the value is none of the three forms.
+* @example
+* ```ts
+* readNine("24,12"); // { left: 24, top: 12, right: 24, bottom: 12 }
+* ```
+*/
+function readNine(value) {
+	const numbers = value.split(",");
+	const sides = NINE_SIDES[numbers.length];
+	if (sides === void 0 || !numbers.every((number) => WHOLE_NUMBER.test(number))) return void 0;
+	const side = (at) => Number(numbers[at]);
+	return {
+		left: side(sides[0]),
+		top: side(sides[1]),
+		right: side(sides[2]),
+		bottom: side(sides[3])
+	};
+}
+/**
+* Reads one tag group.
+*
+* @param content - What stood between the braces.
+* @param file - Path of the file, for the message.
+* @returns The borders the group describes, or `undefined` when the group is malformed: not
+*   `name=value`, or a nine value of none of the three forms.
+* @throws {Error} When the tag is `name=value` but its name is not `nine`.
+*/
+function readTag(content, file) {
+	const equals = content.indexOf("=");
+	if (equals <= 0) return void 0;
+	const name = content.slice(0, equals);
+	if (name !== "nine") throw problem$3(`"${file}" has the unknown tag "${name}".`);
+	return readNine(content.slice(equals + 1));
+}
+/**
+* Says in one line why a file keeps its whole name.
+*
+* @param file - Path of the file.
+* @param content - What stood between the braces of the malformed group.
+* @returns The note.
+* @example
+* ```ts
+* malformedNote("features/ui/assets/bar{nine=1,2,3}.png", "nine=1,2,3");
+* // 'kept the whole name of "features/ui/assets/bar{nine=1,2,3}.png": the tag "{nine=1,2,3}" is not {nine=N}, {nine=H,V} or {nine=L,T,R,B}.'
+* ```
+*/
+function malformedNote(file, content) {
+	return `kept the whole name of "${file}": the tag "{${content}}" is not {nine=N}, {nine=H,V} or {nine=L,T,R,B}.`;
+}
+/**
+* Splits a file name into the name the key is built from and the metadata its tags carry. A
+* malformed tag is not a problem: the name stays whole, so the key shows the mistake, and one note
+* says why.
+*
+* @param fileName - Name of the file, with its extension.
+* @param file - Path of the file, for the messages.
+* @returns The stem, the nine-slice borders and the note of a malformed tag.
+* @throws {Error} When a brace is not a trailing tag group, a tag is unknown, the name is only
+*   tags, the name before the tags carries a "." that would fake a folder, or a malformed tag
+*   carries a "." that cannot stay in the whole name.
+* @example
+* ```ts
+* parseTags("panel{nine=48}.png", "features/ui/assets/panel{nine=48}.png");
+* // { stem: "panel", nine: { left: 48, top: 48, right: 48, bottom: 48 }, note: undefined }
+* parseTags("sign{nine=30,10,40,20}.png", "features/ui/assets/sign{nine=30,10,40,20}.png").nine;
+* // { left: 30, top: 10, right: 40, bottom: 20 }
+* ```
+*/
+function parseTags(fileName, file) {
+	const dot = fileName.lastIndexOf(".");
+	const base = dot > 0 ? fileName.slice(0, dot) : fileName;
+	const open = base.indexOf("{");
+	const stem = open === -1 ? base : base.slice(0, open);
+	const tags = open === -1 ? "" : base.slice(open);
+	if (stem.includes("}") || !TAG_GROUPS.test(tags)) throw problem$3(`the name of "${file}" has a brace that is not a tag group.`);
+	if (stem === "") throw problem$3(`"${file}" has no name before its tags.`);
+	if (stem.includes(".")) throw problem$3(`"${file}" has a "." in "${stem}", which would fake a folder.`);
+	const contents = tags === "" ? [] : tags.slice(1, -1).split("}{");
+	const borders = contents.map((content) => readTag(content, file));
+	const malformed = contents.find((_content, at) => borders[at] === void 0);
+	if (malformed === void 0) return {
+		stem,
+		nine: borders.at(-1),
+		note: void 0
+	};
+	const dotted = contents.find((content) => content.includes("."));
+	if (dotted !== void 0) throw problem$3(`"${file}" has the malformed tag "{${dotted}}", whose "." cannot stay in a key. Use {nine=N}, {nine=H,V} or {nine=L,T,R,B} with whole numbers.`);
+	return {
+		stem: base,
+		nine: void 0,
+		note: malformedNote(file, malformed)
+	};
+}
+/**
+* Builds the asset key of one file.
+*
+* @param feature - Name of the feature folder.
+* @param relative - POSIX path of the file inside the feature's `assets/`.
+* @param file - Path of the file from the scan root, for the messages.
+* @returns The asset key.
+* @throws {Error} When a folder or the file name carries a "." that would fake a folder, or a tag
+*   is unknown.
+* @example
+* ```ts
+* keyOf("ui", "button/primary.png", "features/ui/assets/button/primary.png"); // "ui.button.primary"
+* ```
+*/
+function keyOf(feature, relative, file) {
+	const cut = relative.lastIndexOf("/");
+	const folders = cut === -1 ? [] : relative.slice(0, cut).split("/");
+	for (const folder of folders) if (folder.includes(".")) throw problem$3(`"${file}" has a "." in "${folder}", which would fake a folder.`);
+	return [
+		feature,
+		...folders,
+		parseTags(relative.slice(cut + 1), file).stem
+	].join(".");
+}
+//#endregion
+//#region src/plugins/assets/scan/scan.ts
+/**
+* @file assets plugin, build time — the walk. `features/*` with an `assets/` folder becomes the
+* manifest: one bundle per feature, split by the optional `assets.ts` that feature exports.
+* Node and Bun only. Nothing under `src/` outside `scan/` imports it, so no game bundles it.
+*/
+const TIERS = [
+	"boot",
+	"core",
+	"scene",
+	"feature",
+	"lazy"
+];
+const PREFIX$1 = "[game] assets: ";
+const ESCAPE = /[.+^${}()|[\]\\]/g;
+/** The formats a game brings instead of an MP3. One format decodes everywhere, so MP3 it is. */
+const OTHER_AUDIO = /\.(?:ogg|wav|m4a|aac|opus|flac)$/i;
+/** A vector font. The engine draws bitmap text, so a font arrives as a `.fnt` with its pages. */
+const OTHER_FONT = /\.(?:ttf|otf|woff2?)$/i;
+/** A page name that says "this folder". */
+const HERE = /^\.\//;
+/**
+* Wraps a scanner problem in the message shape of the framework.
+*
+* @param message - One sentence naming the file or the bundle.
+* @returns The error to throw.
+*/
+function problem$2(message) {
+	return /* @__PURE__ */ new Error(`${PREFIX$1}${message}`);
+}
+/**
+* Reads the message of anything that was thrown.
+*
+* @param failure - What the `catch` caught.
+* @returns The message, without the framework prefix.
+*/
+function detailOf$2(failure) {
+	const message = failure instanceof Error ? failure.message : String(failure);
+	return message.startsWith(PREFIX$1) ? message.slice(15) : message;
+}
+/**
+* Creates the state of one scan. It is its own function because lint rule L5 refuses a collection
+* built inside an exported declaration.
+*
+* @param root - Absolute or relative path of the game source root.
+* @param features - Name of the features folder.
+* @returns The empty state.
+*/
+function createState(root, features) {
+	return {
+		root,
+		featuresFolder: path.join(root, features),
+		drafts: /* @__PURE__ */ new Map(),
+		keyOwner: /* @__PURE__ */ new Map(),
+		problems: [],
+		notes: []
+	};
+}
+/**
+* Turns a path of this machine into the POSIX path the manifest carries.
+*
+* @param value - A path as `node:path` built it.
+* @returns The same path with forward slashes.
+*/
+function toPosix(value) {
+	return value.split(path.sep).join("/");
+}
+/**
+* Compares two names, so every list the scanner writes has one order.
+*
+* @param left - First name.
+* @param right - Second name.
+* @returns The sort order.
+*/
+function byName$1(left, right) {
+	return left.localeCompare(right);
+}
+/**
+* Lists the feature folders, sorted. A missing features folder is an empty game, not a problem.
+*
+* @param dir - The features folder.
+* @returns The folder names.
+*/
+async function listFeatures(dir) {
+	return (await readdir(dir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map((entry) => entry.name).toSorted(byName$1);
+}
+/**
+* Walks one `assets/` folder.
+*
+* @param dir - The folder to read.
+* @param prefix - POSIX path of that folder inside `assets/`.
+* @returns The POSIX paths of every file below it, sorted.
+*/
+async function walkAssets(dir, prefix) {
+	const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+	const files = [];
+	for (const entry of entries.toSorted((left, right) => byName$1(left.name, right.name))) {
+		const relative = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+		if (entry.isDirectory()) files.push(...await walkAssets(path.join(dir, entry.name), relative));
+		else files.push(relative);
+	}
+	return files;
+}
+/**
+* Reads the first bytes of a file, which is all the size needs.
+*
+* @param file - Absolute path of the file.
+* @returns The header bytes, fewer when the file is shorter.
+*/
+async function readHead(file) {
+	const handle = await open(file, "r");
+	try {
+		const head = /* @__PURE__ */ new Uint8Array(30);
+		const { bytesRead } = await handle.read(head, 0, 30, 0);
+		return head.subarray(0, bytesRead);
+	} finally {
+		await handle.close();
+	}
+}
+/**
+* Tells whether a value is a plain object.
+*
+* @param value - Anything a description exported.
+* @returns True for an object that is not an array.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Imports the optional `assets.ts` of a feature. Node strips the types of a `.ts` file, so the
+* description a game writes runs as it stands.
+*
+* @param file - Absolute path of the description.
+* @returns Its exports, or `undefined` when the feature brought none.
+* @throws {Error} When the file exists but cannot be imported.
+*/
+async function importDescription(file) {
+	if (!await stat(file).then((entry) => entry.isFile(), () => false)) return void 0;
+	return await import(
+		/* @vite-ignore */
+		pathToFileURL(file).href
+);
+}
+/**
+* Reads one declared bundle into the specs of its feature.
+*
+* @param scan - State of the scan.
+* @param feature - Name of the feature.
+* @param name - Name of the bundle.
+* @param raw - What the description carried under that name.
+* @param specs - Where a valid bundle goes.
+*/
+function readSpec(scan, feature, name, raw, specs) {
+	if (name !== feature && !name.startsWith(`${feature}.`)) {
+		scan.problems.push(`the feature "${feature}" declares the bundle "${name}", which is neither "${feature}" nor a name starting with "${feature}.".`);
+		return;
+	}
+	const tier = isRecord(raw) ? raw.tier : void 0;
+	if (typeof tier !== "string" || !TIERS.includes(tier)) {
+		scan.problems.push(`the bundle "${name}" has the unknown tier "${String(tier)}". Use one of ${TIERS.join(", ")}.`);
+		return;
+	}
+	const files = isRecord(raw) && Array.isArray(raw.files) ? raw.files.map(String) : void 0;
+	specs.set(name, files === void 0 ? { tier } : {
+		tier,
+		files
+	});
+}
+/**
+* Reads the bundles a feature declares. Every export that is a `defineBundles` result counts.
+*
+* @param scan - State of the scan.
+* @param feature - Name of the feature.
+* @returns The declared bundles, empty when the feature brought no description.
+*/
+async function readBundleSpecs(scan, feature) {
+	const specs = /* @__PURE__ */ new Map();
+	const file = path.join(scan.featuresFolder, feature, "assets.ts");
+	try {
+		const loaded = await importDescription(file);
+		for (const value of Object.values(loaded ?? {})) {
+			if (!isRecord(value) || value.kind !== "bundles" || !isRecord(value.map)) continue;
+			for (const [name, raw] of Object.entries(value.map)) readSpec(scan, feature, name, raw, specs);
+		}
+	} catch (error) {
+		const relative = toPosix(path.relative(scan.root, file));
+		scan.problems.push(`the description "${relative}" could not be read: ${detailOf$2(error)}`);
+	}
+	return specs;
+}
+/**
+* Turns one glob of a declared bundle into a matcher. `**` crosses folders, `*` and `?` do not.
+*
+* @param glob - The glob, relative to the feature's `assets/`.
+* @returns The matcher.
+*/
+function globToRegExp(glob) {
+	const parts = [];
+	let index = 0;
+	while (index < glob.length) {
+		const rest = glob.slice(index);
+		if (rest.startsWith("**/")) {
+			parts.push("(?:.*/)?");
+			index += 3;
+		} else if (rest.startsWith("**")) {
+			parts.push(".*");
+			index += 2;
+		} else if (rest.startsWith("*")) {
+			parts.push("[^/]*");
+			index += 1;
+		} else if (rest.startsWith("?")) {
+			parts.push("[^/]");
+			index += 1;
+		} else {
+			parts.push(rest.slice(0, 1).replaceAll(ESCAPE, String.raw`\$&`));
+			index += 1;
+		}
+	}
+	return new RegExp(`^${parts.join("")}$`);
+}
+/**
+* Builds the matchers of the declared bundles that take files out of the default bundle.
+*
+* @param specs - The declared bundles of one feature.
+* @returns The splits, sorted by bundle name.
+*/
+function splitsOf(specs) {
+	const splits = [];
+	for (const [name, spec] of [...specs].toSorted((left, right) => byName$1(left[0], right[0]))) {
+		if (spec.files === void 0 || spec.files.length === 0) continue;
+		splits.push({
+			name,
+			patterns: spec.files.map((glob) => globToRegExp(glob))
+		});
+	}
+	return splits;
+}
+/**
+* Works out which declared bundle claims a file.
+*
+* @param splits - The splits of the feature.
+* @param relative - POSIX path of the file inside `assets/`.
+* @param file - Path of the file from the scan root, for the message.
+* @returns The bundle name, or `undefined` when the file stays in the default bundle.
+* @throws {Error} When two bundles claim the same file.
+*/
+function ownerOf(splits, relative, file) {
+	const matched = splits.filter((split) => split.patterns.some((pattern) => pattern.test(relative))).map((split) => split.name);
+	if (matched.length > 1) {
+		const [first, second] = matched;
+		throw problem$2(`file "${file}" is claimed by the bundles "${String(first)}" and "${String(second)}".`);
+	}
+	return matched[0];
+}
+/**
+* Refuses nine-slice borders that leave no centre: left and right together, and top and bottom
+* together, must stay below the sides of the image.
+*
+* @param nine - The borders of the file, when it carries a tag.
+* @param size - The pixel size of the file.
+* @param file - Path of the file, for the message.
+* @throws {Error} When the borders of one axis reach its side.
+*/
+function checkNine(nine, size, file) {
+	if (nine === void 0) return;
+	const { left, top, right, bottom } = nine;
+	if (left + right < size.width && top + bottom < size.height) return;
+	throw problem$2(`the nine-slice ${left === top && top === right && right === bottom ? `${left} of "${file}" must be smaller than half of` : `${left},${top},${right},${bottom} of "${file}" must leave a centre inside`} ${size.width}×${size.height}.`);
+}
+/**
+* Finds or starts the draft of one bundle.
+*
+* @param scan - State of the scan.
+* @param name - Name of the bundle.
+* @param feature - Feature that owns it.
+* @param tier - When it loads.
+* @returns The draft.
+*/
+function draftOf(scan, name, feature, tier) {
+	const found = scan.drafts.get(name);
+	if (found !== void 0) return found;
+	const draft = {
+		feature,
+		tier,
+		files: []
+	};
+	scan.drafts.set(name, draft);
+	return draft;
+}
+/**
+* Says in one line why a file of an `assets/` folder is not in the manifest. Nothing here stops
+* a build: the note is read once, when the file was meant to be an asset.
+*
+* @param file - Path of the file from the scan root.
+* @returns The note.
+* @example
+* ```ts
+* ignoredNote("features/ui/assets/click.wav");
+* // 'ignored "features/ui/assets/click.wav": audio is .mp3 only.'
+* ```
+*/
+function ignoredNote(file) {
+	if (OTHER_AUDIO.test(file)) return `ignored "${file}": audio is .mp3 only.`;
+	if (OTHER_FONT.test(file)) return `ignored "${file}": a font is a .fnt file with its .png pages.`;
+	return `ignored "${file}": the scanner reads .png, .webp, .fnt and .mp3 only.`;
+}
+/**
+* Works out where a page of a font lives: page names are relative to the `.fnt` file.
+*
+* @param font - POSIX path of the `.fnt` file inside `assets/`.
+* @param page - The page name the font declared.
+* @returns The POSIX path of the page inside `assets/`.
+* @example
+* ```ts
+* resolvePage("fonts/body.fnt", "body_0.png"); // "fonts/body_0.png"
+* ```
+*/
+function resolvePage(font, page) {
+	const cut = font.lastIndexOf("/");
+	return `${cut === -1 ? "" : font.slice(0, cut + 1)}${page.replace(HERE, "")}`;
+}
+/**
+* Reads every `.fnt` of a feature before its files are described: a page image belongs to its
+* font and never becomes an asset key of its own, so the walk has to know the pages first.
+*
+* @param scan - State of the scan.
+* @param assetsFolder - Absolute path of the feature's `assets/`.
+* @param files - Every file of that folder, as POSIX paths inside it.
+* @returns The pages of each font, in declaration order.
+*/
+async function readFonts(scan, assetsFolder, files) {
+	const fonts = /* @__PURE__ */ new Map();
+	const known = new Set(files);
+	for (const relative of files) {
+		if (assetKindOf(relative) !== "font") continue;
+		const absolute = path.join(assetsFolder, ...relative.split("/"));
+		const file = toPosix(path.relative(scan.root, absolute));
+		try {
+			const pages = [];
+			for (const declared of pagesOfFont(await readFile(absolute, "utf8"), file)) {
+				const page = resolvePage(relative, declared);
+				if (known.has(page)) pages.push(page);
+				else scan.problems.push(`the font "${file}" names the page "${declared}", which is not next to it.`);
+			}
+			fonts.set(relative, pages);
+		} catch (error) {
+			scan.problems.push(detailOf$2(error));
+		}
+	}
+	return fonts;
+}
+/**
+* Reads the pages of one font into manifest entries. The pages carry no key: they are listed
+* under the `.fnt` file and loaded with it.
+*
+* @param scan - State of the scan.
+* @param pass - What this feature is read with.
+* @param relative - POSIX path of the `.fnt` file inside `assets/`.
+* @returns The pages, in the order the font declares them.
+* @throws {Error} When a page is not a PNG or a WebP the scanner reads.
+*/
+async function describePages(scan, pass, relative) {
+	const pages = [];
+	for (const page of pass.fonts.get(relative) ?? []) {
+		const absolute = path.join(pass.assetsFolder, ...page.split("/"));
+		const file = toPosix(path.relative(scan.root, absolute));
+		const size = readImageSize(await readHead(absolute), file);
+		pages.push({
+			path: file,
+			width: size.width,
+			height: size.height,
+			mb: textureMb(size.width, size.height)
+		});
+	}
+	return pages;
+}
+/**
+* Reads one asset file into a manifest entry: a texture by its pixels, a font with its pages, an
+* audio file by its bytes.
+*
+* @param scan - State of the scan.
+* @param pass - What this feature is read with.
+* @param relative - POSIX path of the file inside `assets/`.
+* @returns The entry.
+* @throws {Error} When the key, the tags, the header bytes or the nine-slice are wrong.
+*/
+async function describeFile(scan, pass, relative) {
+	const absolute = path.join(pass.assetsFolder, ...relative.split("/"));
+	const file = toPosix(path.relative(scan.root, absolute));
+	const fileName = relative.slice(relative.lastIndexOf("/") + 1);
+	const key = keyOf(pass.feature, relative, file);
+	const owner = scan.keyOwner.get(key);
+	if (owner !== void 0) throw problem$2(`key "${key}" comes from two files: ${owner} and ${file}.`);
+	const kind = assetKindOf(fileName);
+	const { nine, note } = parseTags(fileName, file);
+	if (note !== void 0) scan.notes.push(note);
+	if (kind === "font") {
+		const pages = await describePages(scan, pass, relative);
+		scan.keyOwner.set(key, file);
+		return {
+			key,
+			path: file,
+			kind,
+			width: 0,
+			height: 0,
+			mb: sumMb(pages),
+			pages
+		};
+	}
+	if (kind === "audio") {
+		const { size } = await stat(absolute);
+		scan.keyOwner.set(key, file);
+		return {
+			key,
+			path: file,
+			kind,
+			width: 0,
+			height: 0,
+			mb: bytesMb(size)
+		};
+	}
+	const size = readImageSize(await readHead(absolute), file);
+	checkNine(nine, size, file);
+	scan.keyOwner.set(key, file);
+	return {
+		key,
+		path: file,
+		width: size.width,
+		height: size.height,
+		mb: textureMb(size.width, size.height),
+		...nine === void 0 ? {} : { nine }
+	};
+}
+/**
+* Reads one file of a feature into the bundle that claims it.
+*
+* @param scan - State of the scan.
+* @param pass - What this feature is read with.
+* @param relative - POSIX path of the file inside `assets/`.
+*/
+async function addFile(scan, pass, relative) {
+	const absolute = path.join(pass.assetsFolder, ...relative.split("/"));
+	const file = toPosix(path.relative(scan.root, absolute));
+	if (!isAssetFile(relative)) {
+		scan.notes.push(ignoredNote(file));
+		return;
+	}
+	try {
+		const name = ownerOf(pass.splits, relative, file) ?? pass.feature;
+		const entry = await describeFile(scan, pass, relative);
+		draftOf(scan, name, pass.feature, pass.defaultTier).files.push(entry);
+	} catch (error) {
+		scan.problems.push(detailOf$2(error));
+	}
+}
+/**
+* Reads one feature: its description first, then its fonts, then every file of its `assets/`.
+*
+* @param scan - State of the scan.
+* @param feature - Name of the feature folder.
+*/
+async function scanFeature(scan, feature) {
+	const specs = await readBundleSpecs(scan, feature);
+	const assetsFolder = path.join(scan.featuresFolder, feature, "assets");
+	for (const [name, spec] of specs) draftOf(scan, name, feature, spec.tier);
+	const files = await walkAssets(assetsFolder, "");
+	const fonts = await readFonts(scan, assetsFolder, files);
+	const pages = new Set([...fonts.values()].flat());
+	const pass = {
+		feature,
+		assetsFolder,
+		splits: splitsOf(specs),
+		defaultTier: specs.get(feature)?.tier ?? "feature",
+		fonts
+	};
+	for (const relative of files) {
+		if (pages.has(relative)) continue;
+		await addFile(scan, pass, relative);
+	}
+}
+/**
+* Adds up what a list of files costs: the files of a bundle, or the pages of a font.
+*
+* @param files - Anything that carries an `mb`.
+* @returns The sum in MB, rounded to three decimals.
+*/
+function sumMb(files) {
+	let total = 0;
+	for (const file of files) total += file.mb;
+	return Math.round(total * 1e3) / 1e3;
+}
+/**
+* Turns the drafts into the manifest, sorted for byte-identical output.
+*
+* @param scan - State of the scan.
+* @returns The manifest.
+*/
+function toManifest(scan) {
+	const bundles = {};
+	for (const [name, draft] of [...scan.drafts].toSorted((left, right) => byName$1(left[0], right[0]))) {
+		const files = draft.files.toSorted((left, right) => byName$1(left.key, right.key));
+		bundles[name] = {
+			feature: draft.feature,
+			tier: draft.tier,
+			mb: sumMb(files),
+			files
+		};
+	}
+	return {
+		version: 1,
+		bundles
+	};
+}
+/**
+* Collects every problem of a scan into one error, so a game fixes its assets in one round.
+*
+* @param problems - The problems, in scan order.
+* @returns The error to reject with.
+*/
+function collected$1(problems) {
+	const count = problems.length;
+	const lines = problems.map((text) => `  ${text}`).join("\n");
+	return /* @__PURE__ */ new Error(`${PREFIX$1}the scan found ${count} problem${count === 1 ? "" : "s"}.\n${lines}\n  Fix them and run "bun run assets:keys" again.`);
+}
+/**
+* Reads an output file that may not exist yet.
+*
+* @param file - Path of the file.
+* @returns Its text, or `undefined` when it is not there.
+*/
+async function readCurrent$1(file) {
+	try {
+		return await readFile(file, "utf8");
+	} catch {
+		return;
+	}
+}
+/**
+* Writes the outputs whose text changed, and tells whether any of them differed.
+*
+* @param outputs - Where each output goes and what it should contain.
+* @param write - False for a check run: nothing is written.
+* @returns True when an output on disk differs from what the scan produced.
+*/
+async function applyOutputs(outputs, write) {
+	let changed = false;
+	for (const output of outputs) {
+		if (await readCurrent$1(output.file) === output.text) continue;
+		changed = true;
+		if (!write) continue;
+		await mkdir(path.dirname(output.file), { recursive: true });
+		await writeFile(output.file, output.text);
+	}
+	return changed;
+}
+/**
+* Walks the features of a game and writes its two generated files: one bundle per feature, split
+* by the optional `assets.ts` of that feature, every file keyed by the key rule. A check run
+* (`write: false`) writes nothing and only reports whether something would change.
+*
+* @param options - The game source root, the two output paths and whether to write.
+* @returns The manifest, the text of the key module and whether an output differed.
+* @throws {Error} One error that lists every problem the scan found.
+* @example
+* ```ts
+* const { manifest, changed } = await scanAssets({
+*   root: "src",
+*   manifest: "public/assets/manifest.json",
+*   keys: "src/generated/assets.ts"
+* });
+* // manifest.bundles.ui.files[0].key: "ui.button.primary", changed: true on the first run
+* ```
+*/
+async function scanAssets(options) {
+	const scan = createState(options.root, options.features ?? "features");
+	for (const feature of await listFeatures(scan.featuresFolder)) await scanFeature(scan, feature);
+	if (scan.problems.length > 0) throw collected$1(scan.problems);
+	const manifest = toManifest(scan);
+	const manifestSource = emitManifest(manifest);
+	const keysSource = emitKeys(manifest);
+	return {
+		manifest,
+		keysSource,
+		changed: await applyOutputs([{
+			file: options.manifest,
+			text: manifestSource
+		}, {
+			file: options.keys,
+			text: keysSource
+		}], options.write !== false),
+		notes: scan.notes
+	};
+}
+//#endregion
+//#region src/plugins/assets/scan/cli.ts
+/**
+* @file assets plugin, build time — the command line of the scanner. It is the only file here
+* that touches the terminal: the scan, the emitters and the key rule are pure. Output goes
+* through the branded console of `@moku-labs/common`, and `runCli` returns the exit code
+* instead of taking it. The string compiler of i18n comes in as a parameter: i18n sits above
+* assets, so the door `src/assets.ts` hands it over instead of this file importing it.
+*/
+const MANIFEST_FILE = "manifest.json";
+const KEYS_FILE = path.join("generated", "assets.ts");
+/**
+* Wraps a command line problem in the message shape of the framework.
+*
+* @param message - One sentence naming the option.
+* @returns The error to throw.
+*/
+function problem$1(message) {
+	return /* @__PURE__ */ new Error(`[game] assets: ${message}`);
+}
+/**
+* Reads the message of anything that was thrown.
+*
+* @param failure - What the `catch` caught.
+* @returns The message.
+*/
+function messageOf(failure) {
+	return failure instanceof Error ? failure.message : String(failure);
+}
+/**
+* Tells whether an argument is one of the flags that take a path.
+*
+* @param flag - The argument.
+* @returns True for `--root`, `--manifest` and `--keys`.
+*/
+function isPathFlag(flag) {
+	return flag === "--root" || flag === "--manifest" || flag === "--keys";
+}
+/**
+* Reads the flags. `--manifest` and `--keys` default to `manifest.json` and `generated/assets.ts`
+* inside the root.
+*
+* @param argv - The arguments after the script name.
+* @returns The resolved paths and whether this is a check run.
+* @throws {Error} When an option is unknown or misses its value.
+*/
+function parseArgv(argv) {
+	const given = {
+		"--root": void 0,
+		"--manifest": void 0,
+		"--keys": void 0
+	};
+	let check = false;
+	let index = 0;
+	while (index < argv.length) {
+		const flag = argv[index];
+		if (flag === "--check") {
+			check = true;
+			index += 1;
+			continue;
+		}
+		if (!isPathFlag(flag)) throw problem$1(`unknown option "${String(flag)}".`);
+		const value = argv[index + 1];
+		if (value === void 0 || value.startsWith("--")) throw problem$1(`"${flag}" needs a path.`);
+		given[flag] = value;
+		index += 2;
+	}
+	const root = path.resolve(given["--root"] ?? ".");
+	return {
+		root,
+		manifest: path.resolve(given["--manifest"] ?? path.join(root, MANIFEST_FILE)),
+		keys: path.resolve(given["--keys"] ?? path.join(root, KEYS_FILE)),
+		check
+	};
+}
+/**
+* Counts a thing in words, so the summary reads as a sentence.
+*
+* @param count - How many.
+* @param word - The singular.
+* @returns The count and the word.
+*/
+function plural(count, word) {
+	return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
+/**
+* Sums up what the scan found, for the closing line.
+*
+* @param manifest - What the scan produced.
+* @returns The summary line.
+*/
+function summary(manifest) {
+	const bundles = Object.values(manifest.bundles);
+	let files = 0;
+	let mb = 0;
+	for (const bundle of bundles) {
+		files += bundle.files.length;
+		mb += bundle.mb;
+	}
+	return `${plural(bundles.length, "bundle")}, ${plural(files, "file")}, ${Math.round(mb * 1e3) / 1e3} MB of textures.`;
+}
+/**
+* Names both output files, for the lines about them.
+*
+* @param options - The resolved paths.
+* @returns The two paths in one phrase.
+*/
+function outputNames(options) {
+	return `"${options.manifest}" and "${options.keys}"`;
+}
+/**
+* One line about the compiled strings.
+*
+* @param report - What the compile produced.
+* @returns The line for the console.
+* @example
+* ```ts
+* stringsSummary({ changed: false, locales: ["en", "ru"], keys: ["a", "b"], notes: [] }); // "2 strings in 2 locales (en, ru)."
+* ```
+*/
+function stringsSummary(report) {
+	return `${report.keys.length} strings in ${report.locales.length} locales (${report.locales.join(", ")}).`;
+}
+/**
+* Runs the asset key scanner: walk the features, write the manifest and the key module, then
+* compile the feature strings next to the key module, or check that all of it is current.
+* Nothing here calls `process.exit`; the caller does.
+*
+* @param argv - The arguments after the script name.
+* @param compile - The strings compiler, `compileStrings` of i18n.
+* @param ui - Where the lines go. The branded console by default.
+* @returns The exit code: `1` when the scan or the compile failed or `--check` found a difference, else `0`.
+* @example
+* ```ts
+* await runCli(["--root", "src", "--manifest", "public/assets/manifest.json", "--check"], compileStrings);
+* // 1 when public/assets/manifest.json is older than the files in src/features
+* ```
+*/
+async function runCli(argv, compile, ui = createBrandConsole()) {
+	try {
+		const options = parseArgv(argv);
+		const { manifest, changed, notes } = await scanAssets({
+			root: options.root,
+			manifest: options.manifest,
+			keys: options.keys,
+			write: !options.check
+		});
+		const strings = await compile(options.root, path.dirname(options.keys), { check: options.check });
+		for (const note of [...notes, ...strings.notes]) ui.warn(note);
+		if ((changed || strings.changed) && options.check) {
+			ui.error(`${changed ? outputNames(options) : "the generated strings"} are out of date.\n  Run "bun run assets:keys" and commit the result.`);
+			return 1;
+		}
+		ui.info(changed ? `wrote ${outputNames(options)}.` : `${outputNames(options)} are up to date.`);
+		ui.info(summary(manifest));
+		if (strings.keys.length > 0) ui.info(stringsSummary(strings));
+		return 0;
+	} catch (error) {
+		ui.error(messageOf(error));
+		return 1;
+	}
+}
+//#endregion
+//#region src/plugins/i18n/compile/emit.ts
+/**
+* @file i18n plugin, build time — the two output kinds: the compiled module of one locale and
+* the types module a game's `defineGame` reads. Both are sorted and carry no timestamp and no
+* absolute path, so two compiles of the same files write the same bytes.
+*/
+/** How every generated file starts. */
+const HEADER = "// generated by @moku-labs/game/assets, do not edit";
+/** The TypeScript cast keyword, kept apart so this file writes one and holds none. */
+const CAST$1 = "as";
+/** How a key with no parameters is typed, so `tr` takes it with no second argument. */
+const NO_PARAMS = "Record<string, never>";
+/** The name of the union a plain argument is typed by. */
+const ARGUMENT = "Argument";
+/**
+* The helper a compiled message calls for a plain argument: an element node keeps its place, a
+* list and a number go through `Intl`, everything else is read as text.
+*
+* @returns The helper as source.
+*/
+function argumentHelper() {
+	return [
+		"/** One plain argument: an element stays an element, a list and a number go through Intl. */",
+		"function argument(value: unknown, intl: I18n.IntlKit): I18n.Part {",
+		"  if (Array.isArray(value)) {",
+		`    return { kind: "text", text: intl.list().format(value ${CAST$1} readonly string[]) };`,
+		"  }",
+		"",
+		"  if (typeof value === \"number\") return { kind: \"text\", text: intl.number().format(value) };",
+		"",
+		"  if (",
+		"    typeof value === \"object\" &&",
+		"    value !== null &&",
+		"    \"type\" in value &&",
+		"    \"props\" in value &&",
+		"    \"children\" in value",
+		"  ) {",
+		`    return { kind: "element", node: value ${CAST$1} I18n.ElementNode };`,
+		"  }",
+		"",
+		"  return { kind: \"text\", text: String(value) };",
+		"}"
+	].join("\n");
+}
+/**
+* Compares two keys, so every list the compiler writes has one order.
+*
+* @param left - First key.
+* @param right - Second key.
+* @returns The sort order.
+*/
+function byName(left, right) {
+	if (left === right) return 0;
+	return left < right ? -1 : 1;
+}
+/**
+* Writes `generated/strings.<locale>.ts`: one arrow per key, keys sorted, the helper only when a
+* message needs it.
+*
+* @param entries - The keys of the locale, in any order.
+* @returns The text of the module.
+* @example
+* ```ts
+* emitLocale([{ key: "home.play", compiled: compileMessage("Играть") }]);
+* // the header, the import type and one key whose arrow returns one text part
+* ```
+*/
+function emitLocale(entries) {
+	const sorted = [...entries].toSorted((left, right) => byName(left.key, right.key));
+	const rows = sorted.map((entry) => `  ${JSON.stringify(entry.key)}: ${entry.compiled.source}`);
+	const blocks = [`${HEADER}\nimport type { I18n } from "@moku-labs/game";`];
+	if (sorted.some((entry) => entry.compiled.usesArgument)) blocks.push(argumentHelper());
+	blocks.push(`export default {\n${rows.join(",\n")}\n} satisfies I18n.CompiledMessages;`);
+	return `${blocks.join("\n\n")}\n`;
+}
+/**
+* Writes the type of one parameter.
+*
+* @param type - What the compiler read for it.
+* @returns The TypeScript type.
+* @example
+* ```ts
+* typeOf({ kind: "select", options: ["audio"] }); // '"audio"'
+* ```
+*/
+function typeOf(type) {
+	if (type.kind === "argument") return ARGUMENT;
+	if (type.kind === "number") return "number";
+	if (type.kind === "date") return "Date | number";
+	return type.options.map((option) => JSON.stringify(option)).join(" | ");
+}
+/**
+* A parameter name as a type field: quoted when it is not a plain identifier, so the types module
+* compiles for the same names the locale module escapes.
+*
+* @param name - The parameter name of the message.
+* @returns The field name text.
+* @example
+* ```ts
+* fieldName("n"); // "n"
+* fieldName("a-b"); // "\"a-b\""
+* ```
+*/
+function fieldName(name) {
+	return /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+}
+/**
+* Writes the parameters object of one key.
+*
+* @param params - The parameters the key declares.
+* @returns The TypeScript type of the parameters.
+*/
+function paramsOf(params) {
+	const names = Object.keys(params).toSorted(byName);
+	if (names.length === 0) return NO_PARAMS;
+	return `{ ${names.map((name) => `${fieldName(name)}: ${typeOf(params[name])}`).join("; ")} }`;
+}
+/**
+* Writes `generated/strings.ts`: the key-to-parameters table a game passes to `defineGame`, and
+* the key union next to it. A key with a plain argument pulls in `DescriptionNode`, so an icon
+* may be passed where the message expects one.
+*
+* @param entries - Every key of the game, in any order.
+* @returns The text of the module.
+* @example
+* ```ts
+* emitTypes([{ key: "hud.orders", params: { n: { kind: "number" } } }]);
+* // the header and `export type Strings = { "hud.orders": { n: number } };`
+* ```
+*/
+function emitTypes(entries) {
+	const sorted = [...entries].toSorted((left, right) => byName(left.key, right.key));
+	const rows = sorted.map((entry) => `  ${JSON.stringify(entry.key)}: ${paramsOf(entry.params)};`);
+	const blocks = sorted.some((entry) => Object.values(entry.params).some((entry) => entry.kind === "argument")) ? [`${HEADER}\nimport type { DescriptionNode } from "@moku-labs/game";`, `type ${ARGUMENT} = string | number | readonly string[] | DescriptionNode;`] : [HEADER];
+	blocks.push(`export type Strings = {\n${rows.join("\n")}\n};`, "export type StringKey = keyof Strings;");
+	return `${blocks.join("\n\n")}\n`;
+}
+/**
+* Reads an output file that may not exist yet.
+*
+* @param file - Path of the file.
+* @returns Its text, or `undefined` when it is not there.
+*/
+async function readCurrent(file) {
+	try {
+		return await readFile(file, "utf8");
+	} catch {
+		return;
+	}
+}
+/**
+* Writes one output file when its text changed, and tells whether it differed.
+*
+* @param file - Path of the file.
+* @param text - What it should contain.
+* @param write - False for a check run: nothing is written.
+* @returns True when the file on disk differs from the text.
+* @example
+* ```ts
+* await writeIfChanged("src/generated/strings.ts", "// generated\n", true); // true on the first run
+* ```
+*/
+async function writeIfChanged(file, text, write) {
+	if (await readCurrent(file) === text) return false;
+	if (write) {
+		await mkdir(path.dirname(file), { recursive: true });
+		await writeFile(file, text);
+	}
+	return true;
+}
+//#endregion
+//#region node_modules/@formatjs/icu-skeleton-parser/index.js
+/**
+* https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+* Credit: https://github.com/caridy/intl-datetimeformat-pattern/blob/master/index.js
+* with some tweaks
+*/
+const DATE_TIME_REGEX = /(?:[Eec]{1,6}|G{1,5}|[Qq]{1,5}|(?:[yYur]+|U{1,5})|[ML]{1,5}|d{1,2}|D{1,3}|F{1}|[abB]{1,5}|[hkHK]{1,2}|w{1,2}|W{1}|m{1,2}|s{1,2}|[zZOvVxX]{1,4})(?=([^']*'[^']*')*[^']*$)/g;
+/**
+* Parse Date time skeleton into Intl.DateTimeFormatOptions
+* Ref: https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+* @public
+* @param skeleton skeleton string
+*/
+function parseDateTimeSkeleton(skeleton) {
+	const result = {};
+	skeleton.replace(DATE_TIME_REGEX, (match) => {
+		const len = match.length;
+		switch (match[0]) {
+			case "G":
+				result.era = len === 4 ? "long" : len === 5 ? "narrow" : "short";
+				break;
+			case "y":
+				result.year = len === 2 ? "2-digit" : "numeric";
+				break;
+			case "Y":
+			case "u":
+			case "U":
+			case "r": throw new RangeError("`Y/u/U/r` (year) patterns are not supported, use `y` instead");
+			case "q":
+			case "Q": throw new RangeError("`q/Q` (quarter) patterns are not supported");
+			case "M":
+			case "L":
+				result.month = [
+					"numeric",
+					"2-digit",
+					"short",
+					"long",
+					"narrow"
+				][len - 1];
+				break;
+			case "w":
+			case "W": throw new RangeError("`w/W` (week) patterns are not supported");
+			case "d":
+				result.day = ["numeric", "2-digit"][len - 1];
+				break;
+			case "D":
+			case "F":
+			case "g": throw new RangeError("`D/F/g` (day) patterns are not supported, use `d` instead");
+			case "E":
+				result.weekday = len === 4 ? "long" : len === 5 ? "narrow" : "short";
+				break;
+			case "e":
+				if (len < 4) throw new RangeError("`e..eee` (weekday) patterns are not supported");
+				result.weekday = [
+					"short",
+					"long",
+					"narrow",
+					"short"
+				][len - 3];
+				break;
+			case "c":
+				if (len < 4) throw new RangeError("`c..ccc` (weekday) patterns are not supported");
+				result.weekday = [
+					"short",
+					"long",
+					"narrow",
+					"short"
+				][len - 3];
+				break;
+			case "a":
+				result.hour12 = true;
+				break;
+			case "b":
+			case "B": throw new RangeError("`b/B` (period) patterns are not supported, use `a` instead");
+			case "h":
+				result.hourCycle = "h12";
+				result.hour = ["numeric", "2-digit"][len - 1];
+				break;
+			case "H":
+				result.hourCycle = "h23";
+				result.hour = ["numeric", "2-digit"][len - 1];
+				break;
+			case "K":
+				result.hourCycle = "h11";
+				result.hour = ["numeric", "2-digit"][len - 1];
+				break;
+			case "k":
+				result.hourCycle = "h24";
+				result.hour = ["numeric", "2-digit"][len - 1];
+				break;
+			case "j":
+			case "J":
+			case "C": throw new RangeError("`j/J/C` (hour) patterns are not supported, use `h/H/K/k` instead");
+			case "m":
+				result.minute = ["numeric", "2-digit"][len - 1];
+				break;
+			case "s":
+				result.second = ["numeric", "2-digit"][len - 1];
+				break;
+			case "S":
+			case "A": throw new RangeError("`S/A` (second) patterns are not supported, use `s` instead");
+			case "z":
+				result.timeZoneName = len < 4 ? "short" : "long";
+				break;
+			case "Z":
+			case "O":
+			case "v":
+			case "V":
+			case "X":
+			case "x": throw new RangeError("`Z/O/v/V/X/x` (timeZone) patterns are not supported, use `z` instead");
+		}
+		return "";
+	});
+	return result;
+}
+const WHITE_SPACE_REGEX = /[\t-\r \x85\u200E\u200F\u2028\u2029]/i;
+function parseNumberSkeletonFromString(skeleton) {
+	if (skeleton.length === 0) throw new Error("Number skeleton cannot be empty");
+	const stringTokens = skeleton.split(WHITE_SPACE_REGEX).filter((x) => x.length > 0);
+	const tokens = [];
+	for (const stringToken of stringTokens) {
+		let stemAndOptions = stringToken.split("/");
+		if (stemAndOptions.length === 0) throw new Error("Invalid number skeleton");
+		const [stem, ...options] = stemAndOptions;
+		for (const option of options) if (option.length === 0) throw new Error("Invalid number skeleton");
+		tokens.push({
+			stem,
+			options
+		});
+	}
+	return tokens;
+}
+function icuUnitToEcma(unit) {
+	return unit.replace(/^(.*?)-/, "");
+}
+const FRACTION_PRECISION_REGEX = /^\.(?:(0+)(\*)?|(#+)|(0+)(#+))$/g;
+const SIGNIFICANT_PRECISION_REGEX = /^(@+)?(\+|#+)?[rs]?$/g;
+const INTEGER_WIDTH_REGEX = /(\*)(0+)|(#+)(0+)|(0+)/g;
+const CONCISE_INTEGER_WIDTH_REGEX = /^(0+)$/;
+function parseSignificantPrecision(str) {
+	const result = {};
+	if (str[str.length - 1] === "r") result.roundingPriority = "morePrecision";
+	else if (str[str.length - 1] === "s") result.roundingPriority = "lessPrecision";
+	str.replace(SIGNIFICANT_PRECISION_REGEX, function(_, g1, g2) {
+		if (typeof g2 !== "string") {
+			result.minimumSignificantDigits = g1.length;
+			result.maximumSignificantDigits = g1.length;
+		} else if (g2 === "+") result.minimumSignificantDigits = g1.length;
+		else if (g1[0] === "#") result.maximumSignificantDigits = g1.length;
+		else {
+			result.minimumSignificantDigits = g1.length;
+			result.maximumSignificantDigits = g1.length + (typeof g2 === "string" ? g2.length : 0);
+		}
+		return "";
+	});
+	return result;
+}
+function parseSign(str) {
+	switch (str) {
+		case "sign-auto": return { signDisplay: "auto" };
+		case "sign-accounting":
+		case "()": return { currencySign: "accounting" };
+		case "sign-always":
+		case "+!": return { signDisplay: "always" };
+		case "sign-accounting-always":
+		case "()!": return {
+			signDisplay: "always",
+			currencySign: "accounting"
+		};
+		case "sign-except-zero":
+		case "+?": return { signDisplay: "exceptZero" };
+		case "sign-accounting-except-zero":
+		case "()?": return {
+			signDisplay: "exceptZero",
+			currencySign: "accounting"
+		};
+		case "sign-never":
+		case "+_": return { signDisplay: "never" };
+	}
+}
+function parseConciseScientificAndEngineeringStem(stem) {
+	let result;
+	if (stem[0] === "E" && stem[1] === "E") {
+		result = { notation: "engineering" };
+		stem = stem.slice(2);
+	} else if (stem[0] === "E") {
+		result = { notation: "scientific" };
+		stem = stem.slice(1);
+	}
+	if (result) {
+		const signDisplay = stem.slice(0, 2);
+		if (signDisplay === "+!") {
+			result.signDisplay = "always";
+			stem = stem.slice(2);
+		} else if (signDisplay === "+?") {
+			result.signDisplay = "exceptZero";
+			stem = stem.slice(2);
+		}
+		if (!CONCISE_INTEGER_WIDTH_REGEX.test(stem)) throw new Error("Malformed concise eng/scientific notation");
+		result.minimumIntegerDigits = stem.length;
+	}
+	return result;
+}
+function parseNotationOptions(opt) {
+	const result = {};
+	const signOpts = parseSign(opt);
+	if (signOpts) return signOpts;
+	return result;
+}
+/**
+* https://github.com/unicode-org/icu/blob/master/docs/userguide/format_parse/numbers/skeletons.md#skeleton-stems-and-options
+*/
+function parseNumberSkeleton(tokens) {
+	let result = {};
+	for (const token of tokens) {
+		switch (token.stem) {
+			case "percent":
+			case "%":
+				result.style = "percent";
+				continue;
+			case "%x100":
+				result.style = "percent";
+				result.scale = 100;
+				continue;
+			case "currency":
+				result.style = "currency";
+				result.currency = token.options[0];
+				continue;
+			case "group-off":
+			case ",_":
+				result.useGrouping = false;
+				continue;
+			case "precision-integer":
+			case ".":
+				result.maximumFractionDigits = 0;
+				continue;
+			case "measure-unit":
+			case "unit":
+				result.style = "unit";
+				result.unit = icuUnitToEcma(token.options[0]);
+				continue;
+			case "compact-short":
+			case "K":
+				result.notation = "compact";
+				result.compactDisplay = "short";
+				continue;
+			case "compact-long":
+			case "KK":
+				result.notation = "compact";
+				result.compactDisplay = "long";
+				continue;
+			case "scientific":
+				result = {
+					...result,
+					notation: "scientific",
+					...token.options.reduce((all, opt) => ({
+						...all,
+						...parseNotationOptions(opt)
+					}), {})
+				};
+				continue;
+			case "engineering":
+				result = {
+					...result,
+					notation: "engineering",
+					...token.options.reduce((all, opt) => ({
+						...all,
+						...parseNotationOptions(opt)
+					}), {})
+				};
+				continue;
+			case "notation-simple":
+				result.notation = "standard";
+				continue;
+			case "unit-width-narrow":
+				result.currencyDisplay = "narrowSymbol";
+				result.unitDisplay = "narrow";
+				continue;
+			case "unit-width-short":
+				result.currencyDisplay = "code";
+				result.unitDisplay = "short";
+				continue;
+			case "unit-width-full-name":
+				result.currencyDisplay = "name";
+				result.unitDisplay = "long";
+				continue;
+			case "unit-width-iso-code":
+				result.currencyDisplay = "symbol";
+				continue;
+			case "scale":
+				result.scale = parseFloat(token.options[0]);
+				continue;
+			case "rounding-mode-floor":
+				result.roundingMode = "floor";
+				continue;
+			case "rounding-mode-ceiling":
+				result.roundingMode = "ceil";
+				continue;
+			case "rounding-mode-down":
+				result.roundingMode = "trunc";
+				continue;
+			case "rounding-mode-up":
+				result.roundingMode = "expand";
+				continue;
+			case "rounding-mode-half-even":
+				result.roundingMode = "halfEven";
+				continue;
+			case "rounding-mode-half-down":
+				result.roundingMode = "halfTrunc";
+				continue;
+			case "rounding-mode-half-up":
+				result.roundingMode = "halfExpand";
+				continue;
+			case "integer-width":
+				if (token.options.length > 1) throw new RangeError("integer-width stems only accept a single optional option");
+				token.options[0].replace(INTEGER_WIDTH_REGEX, function(_, g1, g2, g3, g4, g5) {
+					if (g1) result.minimumIntegerDigits = g2.length;
+					else if (g3 && g4) throw new Error("We currently do not support maximum integer digits");
+					else if (g5) throw new Error("We currently do not support exact integer digits");
+					return "";
+				});
+				continue;
+		}
+		if (CONCISE_INTEGER_WIDTH_REGEX.test(token.stem)) {
+			result.minimumIntegerDigits = token.stem.length;
+			continue;
+		}
+		if (FRACTION_PRECISION_REGEX.test(token.stem)) {
+			if (token.options.length > 1) throw new RangeError("Fraction-precision stems only accept a single optional option");
+			token.stem.replace(FRACTION_PRECISION_REGEX, function(_, g1, g2, g3, g4, g5) {
+				if (g2 === "*") result.minimumFractionDigits = g1.length;
+				else if (g3 && g3[0] === "#") result.maximumFractionDigits = g3.length;
+				else if (g4 && g5) {
+					result.minimumFractionDigits = g4.length;
+					result.maximumFractionDigits = g4.length + g5.length;
+				} else {
+					result.minimumFractionDigits = g1.length;
+					result.maximumFractionDigits = g1.length;
+				}
+				return "";
+			});
+			const opt = token.options[0];
+			if (opt === "w") result = {
+				...result,
+				trailingZeroDisplay: "stripIfInteger"
+			};
+			else if (opt) result = {
+				...result,
+				...parseSignificantPrecision(opt)
+			};
+			continue;
+		}
+		if (SIGNIFICANT_PRECISION_REGEX.test(token.stem)) {
+			result = {
+				...result,
+				...parseSignificantPrecision(token.stem)
+			};
+			continue;
+		}
+		const signOpts = parseSign(token.stem);
+		if (signOpts) result = {
+			...result,
+			...signOpts
+		};
+		const conciseScientificAndEngineeringOpts = parseConciseScientificAndEngineeringStem(token.stem);
+		if (conciseScientificAndEngineeringOpts) result = {
+			...result,
+			...conciseScientificAndEngineeringOpts
+		};
+	}
+	return result;
+}
+//#endregion
+//#region node_modules/@formatjs/icu-messageformat-parser/index.js
+let ErrorKind = /* @__PURE__ */ function(ErrorKind) {
+	/** Argument is unclosed (e.g. `{0`) */
+	ErrorKind[ErrorKind["EXPECT_ARGUMENT_CLOSING_BRACE"] = 1] = "EXPECT_ARGUMENT_CLOSING_BRACE";
+	/** Argument is empty (e.g. `{}`). */
+	ErrorKind[ErrorKind["EMPTY_ARGUMENT"] = 2] = "EMPTY_ARGUMENT";
+	/** Argument is malformed (e.g. `{foo!}``) */
+	ErrorKind[ErrorKind["MALFORMED_ARGUMENT"] = 3] = "MALFORMED_ARGUMENT";
+	/** Expect an argument type (e.g. `{foo,}`) */
+	ErrorKind[ErrorKind["EXPECT_ARGUMENT_TYPE"] = 4] = "EXPECT_ARGUMENT_TYPE";
+	/** Unsupported argument type (e.g. `{foo,foo}`) */
+	ErrorKind[ErrorKind["INVALID_ARGUMENT_TYPE"] = 5] = "INVALID_ARGUMENT_TYPE";
+	/** Expect an argument style (e.g. `{foo, number, }`) */
+	ErrorKind[ErrorKind["EXPECT_ARGUMENT_STYLE"] = 6] = "EXPECT_ARGUMENT_STYLE";
+	/** The number skeleton is invalid. */
+	ErrorKind[ErrorKind["INVALID_NUMBER_SKELETON"] = 7] = "INVALID_NUMBER_SKELETON";
+	/** The date time skeleton is invalid. */
+	ErrorKind[ErrorKind["INVALID_DATE_TIME_SKELETON"] = 8] = "INVALID_DATE_TIME_SKELETON";
+	/** Exepct a number skeleton following the `::` (e.g. `{foo, number, ::}`) */
+	ErrorKind[ErrorKind["EXPECT_NUMBER_SKELETON"] = 9] = "EXPECT_NUMBER_SKELETON";
+	/** Exepct a date time skeleton following the `::` (e.g. `{foo, date, ::}`) */
+	ErrorKind[ErrorKind["EXPECT_DATE_TIME_SKELETON"] = 10] = "EXPECT_DATE_TIME_SKELETON";
+	/** Unmatched apostrophes in the argument style (e.g. `{foo, number, 'test`) */
+	ErrorKind[ErrorKind["UNCLOSED_QUOTE_IN_ARGUMENT_STYLE"] = 11] = "UNCLOSED_QUOTE_IN_ARGUMENT_STYLE";
+	/** Missing select argument options (e.g. `{foo, select}`) */
+	ErrorKind[ErrorKind["EXPECT_SELECT_ARGUMENT_OPTIONS"] = 12] = "EXPECT_SELECT_ARGUMENT_OPTIONS";
+	/** Expecting an offset value in `plural` or `selectordinal` argument (e.g `{foo, plural, offset}`) */
+	ErrorKind[ErrorKind["EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE"] = 13] = "EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE";
+	/** Offset value in `plural` or `selectordinal` is invalid (e.g. `{foo, plural, offset: x}`) */
+	ErrorKind[ErrorKind["INVALID_PLURAL_ARGUMENT_OFFSET_VALUE"] = 14] = "INVALID_PLURAL_ARGUMENT_OFFSET_VALUE";
+	/** Expecting a selector in `select` argument (e.g `{foo, select}`) */
+	ErrorKind[ErrorKind["EXPECT_SELECT_ARGUMENT_SELECTOR"] = 15] = "EXPECT_SELECT_ARGUMENT_SELECTOR";
+	/** Expecting a selector in `plural` or `selectordinal` argument (e.g `{foo, plural}`) */
+	ErrorKind[ErrorKind["EXPECT_PLURAL_ARGUMENT_SELECTOR"] = 16] = "EXPECT_PLURAL_ARGUMENT_SELECTOR";
+	/** Expecting a message fragment after the `select` selector (e.g. `{foo, select, apple}`) */
+	ErrorKind[ErrorKind["EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT"] = 17] = "EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT";
+	/**
+	* Expecting a message fragment after the `plural` or `selectordinal` selector
+	* (e.g. `{foo, plural, one}`)
+	*/
+	ErrorKind[ErrorKind["EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT"] = 18] = "EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT";
+	/** Selector in `plural` or `selectordinal` is malformed (e.g. `{foo, plural, =x {#}}`) */
+	ErrorKind[ErrorKind["INVALID_PLURAL_ARGUMENT_SELECTOR"] = 19] = "INVALID_PLURAL_ARGUMENT_SELECTOR";
+	/**
+	* Duplicate selectors in `plural` or `selectordinal` argument.
+	* (e.g. {foo, plural, one {#} one {#}})
+	*/
+	ErrorKind[ErrorKind["DUPLICATE_PLURAL_ARGUMENT_SELECTOR"] = 20] = "DUPLICATE_PLURAL_ARGUMENT_SELECTOR";
+	/** Duplicate selectors in `select` argument.
+	* (e.g. {foo, select, apple {apple} apple {apple}})
+	*/
+	ErrorKind[ErrorKind["DUPLICATE_SELECT_ARGUMENT_SELECTOR"] = 21] = "DUPLICATE_SELECT_ARGUMENT_SELECTOR";
+	/** Plural or select argument option must have `other` clause. */
+	ErrorKind[ErrorKind["MISSING_OTHER_CLAUSE"] = 22] = "MISSING_OTHER_CLAUSE";
+	/** The tag is malformed. (e.g. `<bold!>foo</bold!>) */
+	ErrorKind[ErrorKind["INVALID_TAG"] = 23] = "INVALID_TAG";
+	/** The tag name is invalid. (e.g. `<123>foo</123>`) */
+	ErrorKind[ErrorKind["INVALID_TAG_NAME"] = 25] = "INVALID_TAG_NAME";
+	/** The closing tag does not match the opening tag. (e.g. `<bold>foo</italic>`) */
+	ErrorKind[ErrorKind["UNMATCHED_CLOSING_TAG"] = 26] = "UNMATCHED_CLOSING_TAG";
+	/** The opening tag has unmatched closing tag. (e.g. `<bold>foo`) */
+	ErrorKind[ErrorKind["UNCLOSED_TAG"] = 27] = "UNCLOSED_TAG";
+	return ErrorKind;
+}({});
+let TYPE = /* @__PURE__ */ function(TYPE) {
+	/**
+	* Raw text
+	*/
+	TYPE[TYPE["literal"] = 0] = "literal";
+	/**
+	* Variable w/o any format, e.g `var` in `this is a {var}`
+	*/
+	TYPE[TYPE["argument"] = 1] = "argument";
+	/**
+	* Variable w/ number format
+	*/
+	TYPE[TYPE["number"] = 2] = "number";
+	/**
+	* Variable w/ date format
+	*/
+	TYPE[TYPE["date"] = 3] = "date";
+	/**
+	* Variable w/ time format
+	*/
+	TYPE[TYPE["time"] = 4] = "time";
+	/**
+	* Variable w/ select format
+	*/
+	TYPE[TYPE["select"] = 5] = "select";
+	/**
+	* Variable w/ plural format
+	*/
+	TYPE[TYPE["plural"] = 6] = "plural";
+	/**
+	* Only possible within plural argument.
+	* This is the `#` symbol that will be substituted with the count.
+	*/
+	TYPE[TYPE["pound"] = 7] = "pound";
+	/**
+	* XML-like tag
+	*/
+	TYPE[TYPE["tag"] = 8] = "tag";
+	return TYPE;
+}({});
+function isNumberElement(el) {
+	return el.type === 2;
+}
+function isDateElement(el) {
+	return el.type === 3;
+}
+function isTimeElement(el) {
+	return el.type === 4;
+}
+function isSelectElement(el) {
+	return el.type === 5;
+}
+function isPluralElement(el) {
+	return el.type === 6;
+}
+function isTagElement(el) {
+	return el.type === 8;
+}
+function isNumberSkeleton(el) {
+	return !!(el && typeof el === "object" && el.type === 0);
+}
+function isDateTimeSkeleton(el) {
+	return !!(el && typeof el === "object" && el.type === 1);
+}
+const SPACE_SEPARATOR_REGEX = /[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/;
+const IDENTIFIER_PREFIX_REGEX = /([^\t-\r -\/:-@\[-\^`\{-~\x85\xA0-\xA7\xA9\xAB\xAC\xAE\xB0\xB1\xB6\xBB\xBF\xD7\xF7\u1680\u2000-\u200A\u2010-\u2029\u202F-\u203E\u2041-\u2053\u2055-\u205F\u2190-\u245F\u2500-\u2775\u2794-\u2BFF\u2E00-\u2E7F\u3000-\u3003\u3008-\u3020\u3030\uFD3E\uFD3F\uFE45\uFE46]*)/g;
+const timeData = {
+	"001": ["H", "h"],
+	"419": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"AC": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"AD": ["H", "hB"],
+	"AE": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"AF": [
+		"H",
+		"hb",
+		"hB",
+		"h"
+	],
+	"AG": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"AI": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"AL": [
+		"h",
+		"H",
+		"hB"
+	],
+	"AM": ["H", "hB"],
+	"AO": ["H", "hB"],
+	"AR": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"AS": ["h", "H"],
+	"AT": ["H", "hB"],
+	"AU": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"AW": ["H", "hB"],
+	"AX": ["H"],
+	"AZ": [
+		"H",
+		"hB",
+		"h"
+	],
+	"BA": [
+		"H",
+		"hB",
+		"h"
+	],
+	"BB": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"BD": [
+		"h",
+		"hB",
+		"H"
+	],
+	"BE": ["H", "hB"],
+	"BF": ["H", "hB"],
+	"BG": [
+		"H",
+		"hB",
+		"h"
+	],
+	"BH": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"BI": ["H", "h"],
+	"BJ": ["H", "hB"],
+	"BL": ["H", "hB"],
+	"BM": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"BN": [
+		"hb",
+		"hB",
+		"h",
+		"H"
+	],
+	"BO": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"BQ": ["H"],
+	"BR": ["H", "hB"],
+	"BS": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"BT": ["h", "H"],
+	"BW": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"BY": ["H", "h"],
+	"BZ": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"CA": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"CC": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"CD": ["hB", "H"],
+	"CF": [
+		"H",
+		"h",
+		"hB"
+	],
+	"CG": ["H", "hB"],
+	"CH": [
+		"H",
+		"hB",
+		"h"
+	],
+	"CI": ["H", "hB"],
+	"CK": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"CL": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"CM": [
+		"H",
+		"h",
+		"hB"
+	],
+	"CN": [
+		"H",
+		"hB",
+		"hb",
+		"h"
+	],
+	"CO": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"CP": ["H"],
+	"CR": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"CU": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"CV": ["H", "hB"],
+	"CW": ["H", "hB"],
+	"CX": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"CY": [
+		"h",
+		"H",
+		"hb",
+		"hB"
+	],
+	"CZ": ["H"],
+	"DE": ["H", "hB"],
+	"DG": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"DJ": ["h", "H"],
+	"DK": ["H"],
+	"DM": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"DO": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"DZ": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"EA": [
+		"H",
+		"h",
+		"hB",
+		"hb"
+	],
+	"EC": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"EE": ["H", "hB"],
+	"EG": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"EH": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"ER": ["h", "H"],
+	"ES": [
+		"H",
+		"hB",
+		"h",
+		"hb"
+	],
+	"ET": [
+		"hB",
+		"hb",
+		"h",
+		"H"
+	],
+	"FI": ["H"],
+	"FJ": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"FK": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"FM": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"FO": ["H", "h"],
+	"FR": ["H", "hB"],
+	"GA": ["H", "hB"],
+	"GB": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"GD": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"GE": [
+		"H",
+		"hB",
+		"h"
+	],
+	"GF": ["H", "hB"],
+	"GG": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"GH": ["h", "H"],
+	"GI": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"GL": ["H", "h"],
+	"GM": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"GN": ["H", "hB"],
+	"GP": ["H", "hB"],
+	"GQ": [
+		"H",
+		"hB",
+		"h",
+		"hb"
+	],
+	"GR": [
+		"h",
+		"H",
+		"hb",
+		"hB"
+	],
+	"GS": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"GT": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"GU": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"GW": ["H", "hB"],
+	"GY": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"HK": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"HN": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"HR": ["H", "hB"],
+	"HU": ["H", "h"],
+	"IC": [
+		"H",
+		"h",
+		"hB",
+		"hb"
+	],
+	"ID": ["H"],
+	"IE": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"IL": ["H", "hB"],
+	"IM": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"IN": ["h", "H"],
+	"IO": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"IQ": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"IR": ["hB", "H"],
+	"IS": ["H"],
+	"IT": ["H", "hB"],
+	"JE": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"JM": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"JO": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"JP": [
+		"H",
+		"K",
+		"h"
+	],
+	"KE": [
+		"hB",
+		"hb",
+		"H",
+		"h"
+	],
+	"KG": [
+		"H",
+		"h",
+		"hB",
+		"hb"
+	],
+	"KH": [
+		"hB",
+		"h",
+		"H",
+		"hb"
+	],
+	"KI": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"KM": [
+		"H",
+		"h",
+		"hB",
+		"hb"
+	],
+	"KN": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"KP": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"KR": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"KW": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"KY": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"KZ": ["H", "hB"],
+	"LA": [
+		"H",
+		"hb",
+		"hB",
+		"h"
+	],
+	"LB": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"LC": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"LI": [
+		"H",
+		"hB",
+		"h"
+	],
+	"LK": [
+		"H",
+		"h",
+		"hB",
+		"hb"
+	],
+	"LR": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"LS": ["h", "H"],
+	"LT": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"LU": [
+		"H",
+		"h",
+		"hB"
+	],
+	"LV": [
+		"H",
+		"hB",
+		"hb",
+		"h"
+	],
+	"LY": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"MA": [
+		"H",
+		"h",
+		"hB",
+		"hb"
+	],
+	"MC": ["H", "hB"],
+	"MD": ["H", "hB"],
+	"ME": [
+		"H",
+		"hB",
+		"h"
+	],
+	"MF": ["H", "hB"],
+	"MG": ["H", "h"],
+	"MH": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"MK": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"ML": ["H"],
+	"MM": [
+		"hB",
+		"hb",
+		"H",
+		"h"
+	],
+	"MN": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"MO": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"MP": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"MQ": ["H", "hB"],
+	"MR": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"MS": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"MT": ["H", "h"],
+	"MU": ["H", "h"],
+	"MV": ["H", "h"],
+	"MW": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"MX": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"MY": [
+		"hb",
+		"hB",
+		"h",
+		"H"
+	],
+	"MZ": ["H", "hB"],
+	"NA": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"NC": ["H", "hB"],
+	"NE": ["H"],
+	"NF": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"NG": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"NI": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"NL": ["H", "hB"],
+	"NO": ["H", "h"],
+	"NP": [
+		"H",
+		"h",
+		"hB"
+	],
+	"NR": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"NU": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"NZ": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"OM": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"PA": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"PE": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"PF": [
+		"H",
+		"h",
+		"hB"
+	],
+	"PG": ["h", "H"],
+	"PH": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"PK": [
+		"h",
+		"hB",
+		"H"
+	],
+	"PL": ["H", "h"],
+	"PM": ["H", "hB"],
+	"PN": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"PR": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"PS": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"PT": ["H", "hB"],
+	"PW": ["h", "H"],
+	"PY": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"QA": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"RE": ["H", "hB"],
+	"RO": ["H", "hB"],
+	"RS": [
+		"H",
+		"hB",
+		"h"
+	],
+	"RU": ["H"],
+	"RW": ["H", "h"],
+	"SA": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"SB": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"SC": [
+		"H",
+		"h",
+		"hB"
+	],
+	"SD": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"SE": ["H"],
+	"SG": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"SH": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"SI": ["H", "hB"],
+	"SJ": ["H"],
+	"SK": ["H"],
+	"SL": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"SM": [
+		"H",
+		"h",
+		"hB"
+	],
+	"SN": [
+		"H",
+		"h",
+		"hB"
+	],
+	"SO": ["h", "H"],
+	"SR": ["H", "hB"],
+	"SS": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"ST": ["H", "hB"],
+	"SV": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"SX": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"SY": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"SZ": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"TA": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"TC": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"TD": [
+		"h",
+		"H",
+		"hB"
+	],
+	"TF": [
+		"H",
+		"h",
+		"hB"
+	],
+	"TG": ["H", "hB"],
+	"TH": ["H", "h"],
+	"TJ": ["H", "h"],
+	"TL": [
+		"H",
+		"hB",
+		"hb",
+		"h"
+	],
+	"TM": ["H", "h"],
+	"TN": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"TO": ["h", "H"],
+	"TR": ["H", "hB"],
+	"TT": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"TW": [
+		"hB",
+		"hb",
+		"h",
+		"H"
+	],
+	"TZ": [
+		"hB",
+		"hb",
+		"H",
+		"h"
+	],
+	"UA": [
+		"H",
+		"hB",
+		"h"
+	],
+	"UG": [
+		"hB",
+		"hb",
+		"H",
+		"h"
+	],
+	"UM": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"US": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"UY": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"UZ": [
+		"H",
+		"hB",
+		"h"
+	],
+	"VA": [
+		"H",
+		"h",
+		"hB"
+	],
+	"VC": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"VE": [
+		"h",
+		"H",
+		"hB",
+		"hb"
+	],
+	"VG": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"VI": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"VN": ["H", "h"],
+	"VU": ["h", "H"],
+	"WF": ["H", "hB"],
+	"WS": ["h", "H"],
+	"XK": [
+		"H",
+		"hB",
+		"h"
+	],
+	"YE": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"YT": ["H", "hB"],
+	"ZA": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"ZM": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"ZW": ["H", "h"],
+	"af-ZA": [
+		"H",
+		"h",
+		"hB",
+		"hb"
+	],
+	"ar-001": [
+		"h",
+		"hB",
+		"hb",
+		"H"
+	],
+	"ca-ES": [
+		"H",
+		"h",
+		"hB"
+	],
+	"en-001": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"en-HK": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"en-IL": [
+		"H",
+		"h",
+		"hb",
+		"hB"
+	],
+	"en-MY": [
+		"h",
+		"hb",
+		"H",
+		"hB"
+	],
+	"es-BR": [
+		"H",
+		"h",
+		"hB",
+		"hb"
+	],
+	"es-ES": [
+		"H",
+		"h",
+		"hB",
+		"hb"
+	],
+	"es-GQ": [
+		"H",
+		"h",
+		"hB",
+		"hb"
+	],
+	"fr-CA": [
+		"H",
+		"h",
+		"hB"
+	],
+	"gl-ES": [
+		"H",
+		"h",
+		"hB"
+	],
+	"gu-IN": [
+		"hB",
+		"hb",
+		"h",
+		"H"
+	],
+	"hi-IN": [
+		"hB",
+		"h",
+		"H"
+	],
+	"it-CH": [
+		"H",
+		"h",
+		"hB"
+	],
+	"it-IT": [
+		"H",
+		"h",
+		"hB"
+	],
+	"kn-IN": [
+		"hB",
+		"h",
+		"H"
+	],
+	"ku-SY": ["H", "hB"],
+	"ml-IN": [
+		"hB",
+		"h",
+		"H"
+	],
+	"mr-IN": [
+		"hB",
+		"hb",
+		"h",
+		"H"
+	],
+	"pa-IN": [
+		"hB",
+		"hb",
+		"h",
+		"H"
+	],
+	"ta-IN": [
+		"hB",
+		"h",
+		"hb",
+		"H"
+	],
+	"te-IN": [
+		"hB",
+		"h",
+		"H"
+	],
+	"zu-ZA": [
+		"H",
+		"hB",
+		"hb",
+		"h"
+	]
+};
+/**
+* Returns the best matching date time pattern if a date time skeleton
+* pattern is provided with a locale. Follows the Unicode specification:
+* https://www.unicode.org/reports/tr35/tr35-dates.html#table-mapping-requested-time-skeletons-to-patterns
+* @param skeleton date time skeleton pattern that possibly includes j, J or C
+* @param locale
+*/
+function getBestPattern(skeleton, locale) {
+	let skeletonCopy = "";
+	for (let patternPos = 0; patternPos < skeleton.length; patternPos++) {
+		const patternChar = skeleton.charAt(patternPos);
+		if (patternChar === "j") {
+			let extraLength = 0;
+			while (patternPos + 1 < skeleton.length && skeleton.charAt(patternPos + 1) === patternChar) {
+				extraLength++;
+				patternPos++;
+			}
+			let hourLen = 1 + (extraLength & 1);
+			let dayPeriodLen = extraLength < 2 ? 1 : 3 + (extraLength >> 1);
+			let dayPeriodChar = "a";
+			let hourChar = getDefaultHourSymbolFromLocale(locale);
+			if (hourChar == "H" || hourChar == "k") dayPeriodLen = 0;
+			while (dayPeriodLen-- > 0) skeletonCopy += dayPeriodChar;
+			while (hourLen-- > 0) skeletonCopy = hourChar + skeletonCopy;
+		} else if (patternChar === "J") skeletonCopy += "H";
+		else skeletonCopy += patternChar;
+	}
+	return skeletonCopy;
+}
+/**
+* Maps the [hour cycle type](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/hourCycle)
+* of the given `locale` to the corresponding time pattern.
+* @param locale
+*/
+function getDefaultHourSymbolFromLocale(locale) {
+	let hourCycle = locale.hourCycle;
+	if (hourCycle === void 0) {
+		const localeWithHourCycles = locale;
+		hourCycle = localeWithHourCycles.getHourCycles?.()[0] ?? localeWithHourCycles.hourCycles?.[0];
+	}
+	if (hourCycle) switch (hourCycle) {
+		case "h24": return "k";
+		case "h23": return "H";
+		case "h12": return "h";
+		case "h11": return "K";
+		default: throw new Error("Invalid hourCycle");
+	}
+	const languageTag = locale.language;
+	let regionTag;
+	if (languageTag !== "root") regionTag = locale.maximize().region;
+	return (timeData[`${languageTag}-${regionTag}`] || timeData[regionTag || ""] || timeData[languageTag || ""] || timeData[`${languageTag}-001`] || timeData["001"])[0].charAt(0);
+}
+const SPACE_SEPARATOR_START_REGEX = new RegExp(`^${SPACE_SEPARATOR_REGEX.source}*`);
+const SPACE_SEPARATOR_END_REGEX = new RegExp(`${SPACE_SEPARATOR_REGEX.source}*$`);
+function createLocation(start, end) {
+	return {
+		start,
+		end
+	};
+}
+const hasNativeFromEntries = !!Object.fromEntries;
+const hasTrimStart = !!String.prototype.trimStart;
+const hasTrimEnd = !!String.prototype.trimEnd;
+const fromEntries = hasNativeFromEntries ? Object.fromEntries : function fromEntries(entries) {
+	const obj = {};
+	for (const [k, v] of entries) obj[k] = v;
+	return obj;
+};
+const trimStart = hasTrimStart ? function trimStart(s) {
+	return s.trimStart();
+} : function trimStart(s) {
+	return s.replace(SPACE_SEPARATOR_START_REGEX, "");
+};
+const trimEnd = hasTrimEnd ? function trimEnd(s) {
+	return s.trimEnd();
+} : function trimEnd(s) {
+	return s.replace(SPACE_SEPARATOR_END_REGEX, "");
+};
+let IDENTIFIER_PREFIX_RE = createIdentifierPrefixRegex();
+function createIdentifierPrefixRegex() {
+	try {
+		const regex = /* @__PURE__ */ new RegExp("([^\\p{White_Space}\\p{Pattern_Syntax}]*)", "yu");
+		if (regex.exec("a ")?.[1] === "a") return regex;
+	} catch {}
+	return IDENTIFIER_PREFIX_REGEX;
+}
+function matchIdentifierAtIndex(s, index) {
+	IDENTIFIER_PREFIX_RE.lastIndex = index;
+	return IDENTIFIER_PREFIX_RE.exec(s)[1] ?? "";
+}
+function plainTopLevelEndPosition(message) {
+	if (message.length === 0) return null;
+	let line = 1;
+	let column = 1;
+	for (let offset = 0; offset < message.length;) {
+		const code = message.charCodeAt(offset);
+		switch (code) {
+			case 35:
+			case 39:
+			case 60:
+			case 123:
+			case 125: return null;
+		}
+		if (code === 10) {
+			line++;
+			column = 1;
+			offset++;
+		} else {
+			column++;
+			if (code >= 55296 && code <= 56319 && offset + 1 < message.length) {
+				const next = message.charCodeAt(offset + 1);
+				offset += next >= 56320 && next <= 57343 ? 2 : 1;
+			} else offset++;
+		}
+	}
+	return {
+		offset: message.length,
+		line,
+		column
+	};
+}
+var Parser = class {
+	constructor(message, options = {}) {
+		this.message = message;
+		this.position = {
+			offset: 0,
+			line: 1,
+			column: 1
+		};
+		this.ignoreTag = !!options.ignoreTag;
+		this.locale = options.locale;
+		this.requiresOtherClause = !!options.requiresOtherClause;
+		this.shouldParseSkeletons = !!options.shouldParseSkeletons;
+	}
+	parse() {
+		if (this.offset() !== 0) throw Error("parser can only be used once");
+		if (this.message.length > 0) {
+			const firstCode = this.message.charCodeAt(0);
+			if (firstCode !== 35 && firstCode !== 39 && firstCode !== 60 && firstCode !== 123 && firstCode !== 125) {
+				const plainEndPosition = plainTopLevelEndPosition(this.message);
+				if (plainEndPosition) {
+					const start = this.clonePosition();
+					this.position = plainEndPosition;
+					return {
+						val: [{
+							type: 0,
+							value: this.message,
+							location: createLocation(start, this.clonePosition())
+						}],
+						err: null
+					};
+				}
+			}
+		}
+		return this.parseMessage(0, "", false);
+	}
+	parseMessage(nestingLevel, parentArgType, expectingCloseTag) {
+		let elements = [];
+		while (!this.isEOF()) {
+			const char = this.char();
+			if (char === 123) {
+				const result = this.parseArgument(nestingLevel, expectingCloseTag);
+				if (result.err) return result;
+				elements.push(result.val);
+			} else if (char === 125 && nestingLevel > 0) break;
+			else if (char === 35 && (parentArgType === "plural" || parentArgType === "selectordinal")) {
+				const position = this.clonePosition();
+				this.bump();
+				elements.push({
+					type: 7,
+					location: createLocation(position, this.clonePosition())
+				});
+			} else if (char === 60 && !this.ignoreTag && this.peek() === 47) {
+				if (expectingCloseTag) break;
+				else return this.error(26, createLocation(this.clonePosition(), this.clonePosition()));
+			} else if (char === 60 && !this.ignoreTag && _isAlpha(this.peek() || 0)) {
+				const result = this.parseTag(nestingLevel, parentArgType);
+				if (result.err) return result;
+				elements.push(result.val);
+			} else {
+				const result = this.parseLiteral(nestingLevel, parentArgType);
+				if (result.err) return result;
+				elements.push(result.val);
+			}
+		}
+		return {
+			val: elements,
+			err: null
+		};
+	}
+	/**
+	* A tag name must start with an ASCII lower/upper case letter. The grammar is based on the
+	* [custom element name][] except that a dash is NOT always mandatory and uppercase letters
+	* are accepted:
+	*
+	* ```
+	* tag ::= "<" tagName (whitespace)* "/>" | "<" tagName (whitespace)* ">" message "</" tagName (whitespace)* ">"
+	* tagName ::= [a-z] (PENChar)*
+	* PENChar ::=
+	*     "-" | "." | [0-9] | "_" | [a-z] | [A-Z] | #xB7 | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x37D] |
+	*     [#x37F-#x1FFF] | [#x200C-#x200D] | [#x203F-#x2040] | [#x2070-#x218F] | [#x2C00-#x2FEF] |
+	*     [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
+	* ```
+	*
+	* [custom element name]: https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
+	* NOTE: We're a bit more lax here since HTML technically does not allow uppercase HTML element but we do
+	* since other tag-based engines like React allow it
+	*/
+	parseTag(nestingLevel, parentArgType) {
+		const startPosition = this.clonePosition();
+		this.bump();
+		const tagName = this.parseTagName();
+		this.bumpSpace();
+		if (this.bumpIf("/>")) return {
+			val: {
+				type: 0,
+				value: `<${tagName}/>`,
+				location: createLocation(startPosition, this.clonePosition())
+			},
+			err: null
+		};
+		else if (this.bumpIf(">")) {
+			const childrenResult = this.parseMessage(nestingLevel + 1, parentArgType, true);
+			if (childrenResult.err) return childrenResult;
+			const children = childrenResult.val;
+			const endTagStartPosition = this.clonePosition();
+			if (this.bumpIf("</")) {
+				if (this.isEOF() || !_isAlpha(this.char())) return this.error(23, createLocation(endTagStartPosition, this.clonePosition()));
+				const closingTagNameStartPosition = this.clonePosition();
+				if (tagName !== this.parseTagName()) return this.error(26, createLocation(closingTagNameStartPosition, this.clonePosition()));
+				this.bumpSpace();
+				if (!this.bumpIf(">")) return this.error(23, createLocation(endTagStartPosition, this.clonePosition()));
+				return {
+					val: {
+						type: 8,
+						value: tagName,
+						children,
+						location: createLocation(startPosition, this.clonePosition())
+					},
+					err: null
+				};
+			} else return this.error(27, createLocation(startPosition, this.clonePosition()));
+		} else return this.error(23, createLocation(startPosition, this.clonePosition()));
+	}
+	/**
+	* This method assumes that the caller has peeked ahead for the first tag character.
+	*/
+	parseTagName() {
+		const startOffset = this.offset();
+		this.bump();
+		while (!this.isEOF() && _isPotentialElementNameChar(this.char())) this.bump();
+		return this.message.slice(startOffset, this.offset());
+	}
+	parseLiteral(nestingLevel, parentArgType) {
+		const start = this.clonePosition();
+		let value = "";
+		while (true) {
+			const parseQuoteResult = this.tryParseQuote(parentArgType);
+			if (parseQuoteResult) {
+				value += parseQuoteResult;
+				continue;
+			}
+			const parseUnquotedResult = this.tryParseUnquoted(nestingLevel, parentArgType);
+			if (parseUnquotedResult) {
+				value += parseUnquotedResult;
+				continue;
+			}
+			const parseLeftAngleResult = this.tryParseLeftAngleBracket();
+			if (parseLeftAngleResult) {
+				value += parseLeftAngleResult;
+				continue;
+			}
+			break;
+		}
+		const location = createLocation(start, this.clonePosition());
+		return {
+			val: {
+				type: 0,
+				value,
+				location
+			},
+			err: null
+		};
+	}
+	tryParseLeftAngleBracket() {
+		if (!this.isEOF() && this.char() === 60 && (this.ignoreTag || !_isAlphaOrSlash(this.peek() || 0))) {
+			this.bump();
+			return "<";
+		}
+		return null;
+	}
+	/**
+	* Starting with ICU 4.8, an ASCII apostrophe only starts quoted text if it immediately precedes
+	* a character that requires quoting (that is, "only where needed"), and works the same in
+	* nested messages as on the top level of the pattern. The new behavior is otherwise compatible.
+	*/
+	tryParseQuote(parentArgType) {
+		if (this.isEOF() || this.char() !== 39) return null;
+		switch (this.peek()) {
+			case 39:
+				this.bump();
+				this.bump();
+				return "'";
+			case 123:
+			case 60:
+			case 62:
+			case 125: break;
+			case 35:
+				if (parentArgType === "plural" || parentArgType === "selectordinal") break;
+				return null;
+			default: return null;
+		}
+		this.bump();
+		const codePoints = [this.char()];
+		this.bump();
+		while (!this.isEOF()) {
+			const ch = this.char();
+			if (ch === 39) {
+				if (this.peek() === 39) {
+					codePoints.push(39);
+					this.bump();
+				} else {
+					this.bump();
+					break;
+				}
+			} else codePoints.push(ch);
+			this.bump();
+		}
+		return String.fromCodePoint(...codePoints);
+	}
+	tryParseUnquoted(nestingLevel, parentArgType) {
+		if (this.isEOF()) return null;
+		const ch = this.char();
+		if (ch === 60 || ch === 123 || ch === 35 && (parentArgType === "plural" || parentArgType === "selectordinal") || ch === 125 && nestingLevel > 0) return null;
+		else {
+			this.bump();
+			return String.fromCodePoint(ch);
+		}
+	}
+	parseArgument(nestingLevel, expectingCloseTag) {
+		const openingBracePosition = this.clonePosition();
+		this.bump();
+		this.bumpSpace();
+		if (this.isEOF()) return this.error(1, createLocation(openingBracePosition, this.clonePosition()));
+		if (this.char() === 125) {
+			this.bump();
+			return this.error(2, createLocation(openingBracePosition, this.clonePosition()));
+		}
+		let value = this.parseIdentifierIfPossible().value;
+		if (!value) return this.error(3, createLocation(openingBracePosition, this.clonePosition()));
+		this.bumpSpace();
+		if (this.isEOF()) return this.error(1, createLocation(openingBracePosition, this.clonePosition()));
+		switch (this.char()) {
+			case 125:
+				this.bump();
+				return {
+					val: {
+						type: 1,
+						value,
+						location: createLocation(openingBracePosition, this.clonePosition())
+					},
+					err: null
+				};
+			case 44:
+				this.bump();
+				this.bumpSpace();
+				if (this.isEOF()) return this.error(1, createLocation(openingBracePosition, this.clonePosition()));
+				return this.parseArgumentOptions(nestingLevel, expectingCloseTag, value, openingBracePosition);
+			default: return this.error(3, createLocation(openingBracePosition, this.clonePosition()));
+		}
+	}
+	/**
+	* Advance the parser until the end of the identifier, if it is currently on
+	* an identifier character. Return an empty string otherwise.
+	*/
+	parseIdentifierIfPossible() {
+		const startingPosition = this.clonePosition();
+		const startOffset = this.offset();
+		const value = matchIdentifierAtIndex(this.message, startOffset);
+		const endOffset = startOffset + value.length;
+		this.bumpTo(endOffset);
+		return {
+			value,
+			location: createLocation(startingPosition, this.clonePosition())
+		};
+	}
+	parseArgumentOptions(nestingLevel, expectingCloseTag, value, openingBracePosition) {
+		let typeStartPosition = this.clonePosition();
+		let argType = this.parseIdentifierIfPossible().value;
+		let typeEndPosition = this.clonePosition();
+		switch (argType) {
+			case "": return this.error(4, createLocation(typeStartPosition, typeEndPosition));
+			case "number":
+			case "date":
+			case "time": {
+				this.bumpSpace();
+				let styleAndLocation = null;
+				if (this.bumpIf(",")) {
+					this.bumpSpace();
+					const styleStartPosition = this.clonePosition();
+					const result = this.parseSimpleArgStyleIfPossible();
+					if (result.err) return result;
+					const style = trimEnd(result.val);
+					if (style.length === 0) return this.error(6, createLocation(this.clonePosition(), this.clonePosition()));
+					styleAndLocation = {
+						style,
+						styleLocation: createLocation(styleStartPosition, this.clonePosition())
+					};
+				}
+				const argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+				if (argCloseResult.err) return argCloseResult;
+				const location = createLocation(openingBracePosition, this.clonePosition());
+				if (styleAndLocation && styleAndLocation.style.startsWith("::")) {
+					let skeleton = trimStart(styleAndLocation.style.slice(2));
+					if (argType === "number") {
+						const result = this.parseNumberSkeletonFromString(skeleton, styleAndLocation.styleLocation);
+						if (result.err) return result;
+						return {
+							val: {
+								type: 2,
+								value,
+								location,
+								style: result.val
+							},
+							err: null
+						};
+					} else {
+						if (skeleton.length === 0) return this.error(10, location);
+						let dateTimePattern = skeleton;
+						if (this.locale) dateTimePattern = getBestPattern(skeleton, this.locale);
+						const style = {
+							type: 1,
+							pattern: dateTimePattern,
+							location: styleAndLocation.styleLocation,
+							parsedOptions: this.shouldParseSkeletons ? parseDateTimeSkeleton(dateTimePattern) : {}
+						};
+						return {
+							val: {
+								type: argType === "date" ? 3 : 4,
+								value,
+								location,
+								style
+							},
+							err: null
+						};
+					}
+				}
+				return {
+					val: {
+						type: argType === "number" ? 2 : argType === "date" ? 3 : 4,
+						value,
+						location,
+						style: styleAndLocation?.style ?? null
+					},
+					err: null
+				};
+			}
+			case "plural":
+			case "selectordinal":
+			case "select": {
+				const typeEndPosition = this.clonePosition();
+				this.bumpSpace();
+				if (!this.bumpIf(",")) return this.error(12, createLocation(typeEndPosition, { ...typeEndPosition }));
+				this.bumpSpace();
+				let identifierAndLocation = this.parseIdentifierIfPossible();
+				let pluralOffset = 0;
+				if (argType !== "select" && identifierAndLocation.value === "offset") {
+					if (!this.bumpIf(":")) return this.error(13, createLocation(this.clonePosition(), this.clonePosition()));
+					this.bumpSpace();
+					const result = this.tryParseDecimalInteger(13, 14);
+					if (result.err) return result;
+					this.bumpSpace();
+					identifierAndLocation = this.parseIdentifierIfPossible();
+					pluralOffset = result.val;
+				}
+				const optionsResult = this.tryParsePluralOrSelectOptions(nestingLevel, argType, expectingCloseTag, identifierAndLocation);
+				if (optionsResult.err) return optionsResult;
+				const argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+				if (argCloseResult.err) return argCloseResult;
+				const location = createLocation(openingBracePosition, this.clonePosition());
+				if (argType === "select") return {
+					val: {
+						type: 5,
+						value,
+						options: fromEntries(optionsResult.val),
+						location
+					},
+					err: null
+				};
+				else return {
+					val: {
+						type: 6,
+						value,
+						options: fromEntries(optionsResult.val),
+						offset: pluralOffset,
+						pluralType: argType === "plural" ? "cardinal" : "ordinal",
+						location
+					},
+					err: null
+				};
+			}
+			default: return this.error(5, createLocation(typeStartPosition, typeEndPosition));
+		}
+	}
+	tryParseArgumentClose(openingBracePosition) {
+		if (this.isEOF() || this.char() !== 125) return this.error(1, createLocation(openingBracePosition, this.clonePosition()));
+		this.bump();
+		return {
+			val: true,
+			err: null
+		};
+	}
+	/**
+	* See: https://github.com/unicode-org/icu/blob/af7ed1f6d2298013dc303628438ec4abe1f16479/icu4c/source/common/messagepattern.cpp#L659
+	*/
+	parseSimpleArgStyleIfPossible() {
+		let nestedBraces = 0;
+		const startPosition = this.clonePosition();
+		while (!this.isEOF()) switch (this.char()) {
+			case 39: {
+				this.bump();
+				let apostrophePosition = this.clonePosition();
+				if (!this.bumpUntil("'")) return this.error(11, createLocation(apostrophePosition, this.clonePosition()));
+				this.bump();
+				break;
+			}
+			case 123:
+				nestedBraces += 1;
+				this.bump();
+				break;
+			case 125:
+				if (nestedBraces > 0) nestedBraces -= 1;
+				else return {
+					val: this.message.slice(startPosition.offset, this.offset()),
+					err: null
+				};
+				break;
+			default: this.bump();
+		}
+		return {
+			val: this.message.slice(startPosition.offset, this.offset()),
+			err: null
+		};
+	}
+	parseNumberSkeletonFromString(skeleton, location) {
+		let tokens = [];
+		try {
+			tokens = parseNumberSkeletonFromString(skeleton);
+		} catch {
+			return this.error(7, location);
+		}
+		return {
+			val: {
+				type: 0,
+				tokens,
+				location,
+				parsedOptions: this.shouldParseSkeletons ? parseNumberSkeleton(tokens) : {}
+			},
+			err: null
+		};
+	}
+	/**
+	* @param nesting_level The current nesting level of messages.
+	*     This can be positive when parsing message fragment in select or plural argument options.
+	* @param parent_arg_type The parent argument's type.
+	* @param parsed_first_identifier If provided, this is the first identifier-like selector of
+	*     the argument. It is a by-product of a previous parsing attempt.
+	* @param expecting_close_tag If true, this message is directly or indirectly nested inside
+	*     between a pair of opening and closing tags. The nested message will not parse beyond
+	*     the closing tag boundary.
+	*/
+	tryParsePluralOrSelectOptions(nestingLevel, parentArgType, expectCloseTag, parsedFirstIdentifier) {
+		let hasOtherClause = false;
+		const options = [];
+		const parsedSelectors = /* @__PURE__ */ new Set();
+		let { value: selector, location: selectorLocation } = parsedFirstIdentifier;
+		while (true) {
+			if (selector.length === 0) {
+				const startPosition = this.clonePosition();
+				if (parentArgType !== "select" && this.bumpIf("=")) {
+					const result = this.tryParseDecimalInteger(16, 19);
+					if (result.err) return result;
+					selectorLocation = createLocation(startPosition, this.clonePosition());
+					selector = this.message.slice(startPosition.offset, this.offset());
+				} else break;
+			}
+			if (parsedSelectors.has(selector)) return this.error(parentArgType === "select" ? 21 : 20, selectorLocation);
+			if (selector === "other") hasOtherClause = true;
+			this.bumpSpace();
+			const openingBracePosition = this.clonePosition();
+			if (!this.bumpIf("{")) return this.error(parentArgType === "select" ? 17 : 18, createLocation(this.clonePosition(), this.clonePosition()));
+			const fragmentResult = this.parseMessage(nestingLevel + 1, parentArgType, expectCloseTag);
+			if (fragmentResult.err) return fragmentResult;
+			const argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+			if (argCloseResult.err) return argCloseResult;
+			options.push([selector, {
+				value: fragmentResult.val,
+				location: createLocation(openingBracePosition, this.clonePosition())
+			}]);
+			parsedSelectors.add(selector);
+			this.bumpSpace();
+			({value: selector, location: selectorLocation} = this.parseIdentifierIfPossible());
+		}
+		if (options.length === 0) return this.error(parentArgType === "select" ? 15 : 16, createLocation(this.clonePosition(), this.clonePosition()));
+		if (this.requiresOtherClause && !hasOtherClause) return this.error(22, createLocation(this.clonePosition(), this.clonePosition()));
+		return {
+			val: options,
+			err: null
+		};
+	}
+	tryParseDecimalInteger(expectNumberError, invalidNumberError) {
+		let sign = 1;
+		const startingPosition = this.clonePosition();
+		if (this.bumpIf("+")) {} else if (this.bumpIf("-")) sign = -1;
+		let hasDigits = false;
+		let decimal = 0;
+		while (!this.isEOF()) {
+			const ch = this.char();
+			if (ch >= 48 && ch <= 57) {
+				hasDigits = true;
+				decimal = decimal * 10 + (ch - 48);
+				this.bump();
+			} else break;
+		}
+		const location = createLocation(startingPosition, this.clonePosition());
+		if (!hasDigits) return this.error(expectNumberError, location);
+		decimal *= sign;
+		if (!Number.isSafeInteger(decimal)) return this.error(invalidNumberError, location);
+		return {
+			val: decimal,
+			err: null
+		};
+	}
+	offset() {
+		return this.position.offset;
+	}
+	isEOF() {
+		return this.offset() === this.message.length;
+	}
+	clonePosition() {
+		return {
+			offset: this.position.offset,
+			line: this.position.line,
+			column: this.position.column
+		};
+	}
+	/**
+	* Return the code point at the current position of the parser.
+	* Throws if the index is out of bound.
+	*/
+	char() {
+		const offset = this.position.offset;
+		if (offset >= this.message.length) throw Error("out of bound");
+		const code = this.message.codePointAt(offset);
+		if (code === void 0) throw Error(`Offset ${offset} is at invalid UTF-16 code unit boundary`);
+		return code;
+	}
+	error(kind, location) {
+		return {
+			val: null,
+			err: {
+				kind,
+				message: this.message,
+				location
+			}
+		};
+	}
+	/** Bump the parser to the next UTF-16 code unit. */
+	bump() {
+		if (this.isEOF()) return;
+		const code = this.char();
+		if (code === 10) {
+			this.position.line += 1;
+			this.position.column = 1;
+			this.position.offset += 1;
+		} else {
+			this.position.column += 1;
+			this.position.offset += code < 65536 ? 1 : 2;
+		}
+	}
+	/**
+	* If the substring starting at the current position of the parser has
+	* the given prefix, then bump the parser to the character immediately
+	* following the prefix and return true. Otherwise, don't bump the parser
+	* and return false.
+	*/
+	bumpIf(prefix) {
+		if (this.message.startsWith(prefix, this.offset())) {
+			for (let i = 0; i < prefix.length; i++) this.bump();
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Bump the parser until the pattern character is found and return `true`.
+	* Otherwise bump to the end of the file and return `false`.
+	*/
+	bumpUntil(pattern) {
+		const currentOffset = this.offset();
+		const index = this.message.indexOf(pattern, currentOffset);
+		if (index >= 0) {
+			this.bumpTo(index);
+			return true;
+		} else {
+			this.bumpTo(this.message.length);
+			return false;
+		}
+	}
+	/**
+	* Bump the parser to the target offset.
+	* If target offset is beyond the end of the input, bump the parser to the end of the input.
+	*/
+	bumpTo(targetOffset) {
+		if (this.offset() > targetOffset) throw Error(`targetOffset ${targetOffset} must be greater than or equal to the current offset ${this.offset()}`);
+		targetOffset = Math.min(targetOffset, this.message.length);
+		while (true) {
+			const offset = this.offset();
+			if (offset === targetOffset) break;
+			if (offset > targetOffset) throw Error(`targetOffset ${targetOffset} is at invalid UTF-16 code unit boundary`);
+			this.bump();
+			if (this.isEOF()) break;
+		}
+	}
+	/** advance the parser through all whitespace to the next non-whitespace code unit. */
+	bumpSpace() {
+		while (!this.isEOF() && _isWhiteSpace(this.char())) this.bump();
+	}
+	/**
+	* Peek at the *next* Unicode codepoint in the input without advancing the parser.
+	* If the input has been exhausted, then this returns null.
+	*/
+	peek() {
+		if (this.isEOF()) return null;
+		const code = this.char();
+		const offset = this.offset();
+		return this.message.charCodeAt(offset + (code >= 65536 ? 2 : 1)) ?? null;
+	}
+};
+/**
+* This check if codepoint is alphabet (lower & uppercase)
+* @param codepoint
+* @returns
+*/
+function _isAlpha(codepoint) {
+	return codepoint >= 97 && codepoint <= 122 || codepoint >= 65 && codepoint <= 90;
+}
+function _isAlphaOrSlash(codepoint) {
+	return _isAlpha(codepoint) || codepoint === 47;
+}
+/** See `parseTag` function docs. */
+function _isPotentialElementNameChar(c) {
+	return c === 45 || c === 46 || c >= 48 && c <= 57 || c === 95 || c >= 97 && c <= 122 || c >= 65 && c <= 90 || c == 183 || c >= 192 && c <= 214 || c >= 216 && c <= 246 || c >= 248 && c <= 893 || c >= 895 && c <= 8191 || c >= 8204 && c <= 8205 || c >= 8255 && c <= 8256 || c >= 8304 && c <= 8591 || c >= 11264 && c <= 12271 || c >= 12289 && c <= 55295 || c >= 63744 && c <= 64975 || c >= 65008 && c <= 65533 || c >= 65536 && c <= 983039;
+}
+/**
+* Code point equivalent of regex `\p{White_Space}`.
+* From: https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt
+*/
+function _isWhiteSpace(c) {
+	return c >= 9 && c <= 13 || c === 32 || c === 133 || c >= 8206 && c <= 8207 || c === 8232 || c === 8233;
+}
+function pruneLocation(els) {
+	els.forEach((el) => {
+		delete el.location;
+		if (isSelectElement(el) || isPluralElement(el)) for (const k in el.options) {
+			delete el.options[k].location;
+			pruneLocation(el.options[k].value);
+		}
+		else if (isNumberElement(el) && isNumberSkeleton(el.style)) delete el.style.location;
+		else if ((isDateElement(el) || isTimeElement(el)) && isDateTimeSkeleton(el.style)) delete el.style.location;
+		else if (isTagElement(el)) pruneLocation(el.children);
+	});
+}
+function parse(message, opts = {}) {
+	opts = {
+		shouldParseSkeletons: true,
+		requiresOtherClause: true,
+		...opts
+	};
+	const result = new Parser(message, opts).parse();
+	if (result.err) {
+		const error = SyntaxError(ErrorKind[result.err.kind]);
+		error.location = result.err.location;
+		error.originalMessage = result.err.message;
+		throw error;
+	}
+	if (!opts?.captureLocation) pruneLocation(result.val);
+	return result.val;
+}
+//#endregion
+//#region src/plugins/i18n/compile/message.ts
+/**
+* @file i18n plugin, build time — one ICU MessageFormat 1 message into one function source and
+* the types of its parameters. The parser runs here and nowhere else: what ships to the browser
+* is the function this file writes. Node and Bun only.
+*/
+/** The style a `{d, date}` with no style means. */
+const DEFAULT_DATE_STYLE = "medium";
+/** A parameter name that can be read with a dot. */
+const PLAIN_NAME = /^[A-Za-z_$][\w$]*$/;
+/** The TypeScript cast keyword, kept apart so this file writes one and holds none. */
+const CAST = "as";
+/**
+* Writes a cast into the generated source.
+*
+* @param expression - What is being cast.
+* @param type - The type it is cast to.
+* @returns The expression with its cast.
+*/
+function cast(expression, type) {
+	return `${expression} ${CAST} ${type}`;
+}
+/**
+* Wraps a compile problem. The caller adds the key and the file.
+*
+* @param reason - One sentence naming what the message asked for.
+* @returns The error to throw.
+*/
+function problem(reason) {
+	return new Error(reason);
+}
+/**
+* Reads the message of anything the parser threw.
+*
+* @param error - What the `catch` caught.
+* @returns The message.
+*/
+function detailOf$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Parses one message, turning a parser failure into a compile problem.
+*
+* @param text - The message as the game wrote it.
+* @returns The elements of the message.
+* @throws {Error} When the message does not parse.
+*/
+function parseMessage(text) {
+	try {
+		return parse(text, { ignoreTag: true });
+	} catch (error) {
+		throw problem(detailOf$1(error));
+	}
+}
+/**
+* Tells whether a style is one of the four ICU date and time names.
+*
+* @param style - The style the message asked for.
+* @returns True for "short", "medium", "long" and "full".
+*/
+function isDateStyle(style) {
+	return style === "short" || style === "medium" || style === "long" || style === "full";
+}
+/**
+* Names one style for a problem message, whether it arrived as text or as a parsed skeleton.
+*
+* @param style - What the parser read after the argument type.
+* @returns The style as the game wrote it.
+*/
+function styleName(style) {
+	if (typeof style === "string") return style;
+	if (style === null || style === void 0) return "";
+	if ("pattern" in style) return style.pattern;
+	return style.tokens.map((token) => token.stem).join(" ");
+}
+/**
+* Reads one parameter of `p`.
+*
+* @param name - The parameter name.
+* @returns The access expression.
+*/
+function access(name) {
+	return PLAIN_NAME.test(name) ? `p.${name}` : `p[${JSON.stringify(name)}]`;
+}
+/**
+* Records the type of one parameter, refusing a name used with two argument kinds.
+*
+* @param scan - What the walk collects.
+* @param name - The parameter name.
+* @param type - What this use of the parameter needs.
+* @throws {Error} When the same name is used with two kinds in one message.
+*/
+function addParameter(scan, name, type) {
+	const known = scan.params[name];
+	scan.usesParams = true;
+	if (known === void 0) {
+		scan.params[name] = type;
+		return;
+	}
+	if (known.kind !== type.kind) throw problem(`the parameter "${name}" is used as ${known.kind} and as ${type.kind}`);
+	if (known.kind === "select" && type.kind === "select") scan.params[name] = {
+		kind: "select",
+		options: unique$1([...known.options, ...type.options])
+	};
+}
+/**
+* Sorts option names and drops the repeats. Its own function because lint rule L5 refuses a
+* collection built inside an exported declaration.
+*
+* @param options - The option names of one select, from any number of uses.
+* @returns The names, unique and sorted.
+* @example
+* ```ts
+* unique(["language", "audio", "audio"]); // ["audio", "language"]
+* ```
+*/
+function unique$1(options) {
+	return [...new Set(options)].toSorted();
+}
+/**
+* Escapes a literal so it is safe between backticks.
+*
+* @param text - The literal.
+* @returns The literal, escaped.
+*/
+function escapeTemplate(text) {
+	return text.replaceAll("\\", String.raw`\\`).replaceAll("`", String.raw`\``).replaceAll("${", "\\${");
+}
+/**
+* Reads the code of one piece.
+*
+* @param piece - The piece.
+* @returns Its expression.
+*/
+function codeOf(piece) {
+	return piece.kind === "literal" ? JSON.stringify(piece.text) : piece.code;
+}
+/**
+* Tells whether a piece is text rather than an element.
+*
+* @param piece - The piece.
+* @returns True for a literal or a string expression.
+*/
+function isText(piece) {
+	return piece.kind === "literal" || piece.kind === "expr";
+}
+/**
+* Joins text pieces into one string expression: a quoted literal when nothing varies, else a
+* template literal.
+*
+* @param pieces - The pieces, all of them text.
+* @returns The string expression.
+*/
+function joinText(pieces) {
+	const only = pieces.length === 1 ? pieces[0] : void 0;
+	if (pieces.length === 0) return "\"\"";
+	if (only !== void 0) return codeOf(only);
+	return `\`${pieces.map((piece) => piece.kind === "literal" ? escapeTemplate(piece.text) : `\${${codeOf(piece)}}`).join("")}\``;
+}
+/**
+* Turns the pieces of a message into a `Part[]` expression. Runs of text become one text part;
+* an element keeps its place.
+*
+* @param pieces - The pieces of the message.
+* @returns The array expression.
+*/
+function toParts(pieces) {
+	if (pieces.every((piece) => isText(piece))) return `[{ kind: "text", text: ${joinText(pieces)} }]`;
+	const items = [];
+	const run = [];
+	const flush = () => {
+		if (run.length > 0) items.push(`{ kind: "text", text: ${joinText(run)} }`);
+		run.length = 0;
+	};
+	for (const piece of pieces) {
+		if (isText(piece)) {
+			run.push(piece);
+			continue;
+		}
+		flush();
+		items.push(piece.kind === "parts" ? `...${piece.code}` : piece.code);
+	}
+	flush();
+	return `[${items.join(", ")}]`;
+}
+/**
+* Writes a chain of conditions, parenthesised so it nests safely.
+*
+* @param tests - The condition and the value of each branch, in order.
+* @param otherwise - The value of the last branch.
+* @returns The chain expression.
+*/
+function chain(tests, otherwise) {
+	if (tests.length === 0) return otherwise;
+	return `(${tests.map((entry) => `${entry.test} ? ${entry.value} : `).join("")}${otherwise})`;
+}
+/**
+* Compiles the branches of a plural or a select. When every branch is text the whole argument is
+* one string expression; as soon as one branch holds an element it becomes a `Part[]` expression.
+*
+* @param options - The branches the parser read.
+* @param scan - What the walk collects.
+* @param pound - What `#` stands for inside these branches.
+* @returns The code of each branch and whether they are all text.
+*/
+function branchesOf(options, scan, pound) {
+	const pieces = {};
+	for (const [name, option] of Object.entries(options)) pieces[name] = piecesOf(option.value, scan, pound);
+	const allText = Object.values(pieces).every((list) => list.every((piece) => isText(piece)));
+	const code = {};
+	for (const [name, list] of Object.entries(pieces)) code[name] = allText ? joinText(list) : toParts(list);
+	return {
+		code,
+		allText
+	};
+}
+/**
+* Builds the piece one plural or select argument becomes.
+*
+* @param tests - The condition and the value of each branch.
+* @param otherwise - The value of the `other` branch, when the argument declared one.
+* @param allText - Whether every branch is text.
+* @returns The piece.
+* @throws {Error} When the argument has no `other` branch.
+*/
+function branchPiece(tests, otherwise, allText) {
+	if (otherwise === void 0) throw problem("MISSING_OTHER_CLAUSE");
+	const code = chain(tests, otherwise);
+	if (allText) return {
+		kind: "expr",
+		code
+	};
+	return {
+		kind: "parts",
+		code: `(${code} satisfies I18n.Part[])`
+	};
+}
+/**
+* Compiles a `plural` or `selectordinal` argument. The exact matches are tested first, then the
+* plural category of the value minus the offset.
+*
+* @param element - The argument the parser read.
+* @param scan - What the walk collects.
+* @returns The piece it becomes.
+* @throws {Error} When the argument has no `other` branch.
+*/
+function pluralPiece(element, scan) {
+	addParameter(scan, element.value, { kind: "number" });
+	scan.usesIntl = true;
+	const number = `(${cast(access(element.value), "number")})`;
+	const value = element.offset === 0 ? number : `(${number} - ${element.offset})`;
+	const rules = element.pluralType === "ordinal" ? "intl.plural({ type: \"ordinal\" })" : "intl.plural()";
+	const { code, allText } = branchesOf(element.options, scan, `intl.number().format(${value})`);
+	const exact = [];
+	const categories = [];
+	for (const [name, branch] of Object.entries(code)) {
+		if (name === "other") continue;
+		if (name.startsWith("=")) exact.push({
+			test: `${value} === ${name.slice(1)}`,
+			value: branch
+		});
+		else categories.push({
+			test: `${rules}.select(${value}) === ${JSON.stringify(name)}`,
+			value: branch
+		});
+	}
+	return branchPiece([...exact, ...categories], code.other, allText);
+}
+/**
+* Compiles a `select` argument.
+*
+* @param element - The argument the parser read.
+* @param scan - What the walk collects.
+* @param pound - What `#` stands for inside these branches.
+* @returns The piece it becomes.
+* @throws {Error} When the argument has no `other` branch.
+*/
+function selectPiece(element, scan, pound) {
+	addParameter(scan, element.value, {
+		kind: "select",
+		options: Object.keys(element.options).filter((name) => name !== "other").toSorted()
+	});
+	const subject = `String(${access(element.value)})`;
+	const { code, allText } = branchesOf(element.options, scan, pound);
+	const tests = [];
+	for (const [name, branch] of Object.entries(code)) {
+		if (name === "other") continue;
+		tests.push({
+			test: `${subject} === ${JSON.stringify(name)}`,
+			value: branch
+		});
+	}
+	return branchPiece(tests, code.other, allText);
+}
+/**
+* Writes the `Intl.NumberFormat` options one ICU number style asks for.
+*
+* @param style - The style the message named, empty for none.
+* @returns The options as source, empty for the plain format.
+* @example
+* ```ts
+* numberOptions("percent"); // '{ style: "percent" }'
+* ```
+*/
+function numberOptions(style) {
+	if (style === "integer") return "{ maximumFractionDigits: 0 }";
+	if (style === "percent") return "{ style: \"percent\" }";
+	return "";
+}
+/**
+* Compiles a `number` argument.
+*
+* @param element - The argument the parser read.
+* @param scan - What the walk collects.
+* @returns The piece it becomes.
+* @throws {Error} When the style is not one this engine supports.
+*/
+function numberPiece(element, scan) {
+	const style = styleName(element.style);
+	if (style !== "" && style !== "integer" && style !== "percent") throw problem(`the number style "${style}" is not supported`);
+	addParameter(scan, element.value, { kind: "number" });
+	scan.usesIntl = true;
+	return {
+		kind: "expr",
+		code: `intl.number(${numberOptions(style)}).format(${cast(access(element.value), "number")})`
+	};
+}
+/**
+* Compiles a `date` or a `time` argument.
+*
+* @param element - The argument the parser read.
+* @param scan - What the walk collects.
+* @param field - Which half of `Intl.DateTimeFormat` the argument names.
+* @returns The piece it becomes.
+* @throws {Error} When the style is not one of the four ICU names.
+*/
+function datePiece(element, scan, field) {
+	const named = styleName(element.style);
+	const style = named === "" ? DEFAULT_DATE_STYLE : named;
+	if (!isDateStyle(style)) throw problem(`the ${field} "${named}" is not supported`);
+	addParameter(scan, element.value, { kind: "date" });
+	scan.usesIntl = true;
+	return {
+		kind: "expr",
+		code: `intl.date({ ${field}: "${style}" }).format(${cast(access(element.value), "Date | number")})`
+	};
+}
+/**
+* Compiles one run of message elements into pieces.
+*
+* @param elements - What the parser read.
+* @param scan - What the walk collects.
+* @param pound - What `#` stands for here, when a plural is open.
+* @returns The pieces, in order.
+* @throws {Error} When the run holds a feature this engine does not support.
+*/
+function piecesOf(elements, scan, pound) {
+	const pieces = [];
+	for (const element of elements) switch (element.type) {
+		case TYPE.literal:
+			pieces.push({
+				kind: "literal",
+				text: element.value
+			});
+			break;
+		case TYPE.argument:
+			addParameter(scan, element.value, { kind: "argument" });
+			scan.usesArgument = true;
+			scan.usesIntl = true;
+			pieces.push({
+				kind: "part",
+				code: `argument(${access(element.value)}, intl)`
+			});
+			break;
+		case TYPE.number:
+			pieces.push(numberPiece(element, scan));
+			break;
+		case TYPE.date:
+			pieces.push(datePiece(element, scan, "dateStyle"));
+			break;
+		case TYPE.time:
+			pieces.push(datePiece(element, scan, "timeStyle"));
+			break;
+		case TYPE.select:
+			pieces.push(selectPiece(element, scan, pound));
+			break;
+		case TYPE.plural:
+			pieces.push(pluralPiece(element, scan));
+			break;
+		case TYPE.pound:
+			if (pound === void 0) throw problem("\"#\" is only allowed inside a plural");
+			pieces.push({
+				kind: "expr",
+				code: pound
+			});
+			break;
+		default: throw problem("the message holds an element this engine cannot read");
+	}
+	return pieces;
+}
+/**
+* Writes the head of the arrow, naming only the arguments the body reads.
+*
+* @param scan - What the walk collected.
+* @returns The parameter list.
+*/
+function headOf(scan) {
+	if (scan.usesIntl) return "(p, intl)";
+	return scan.usesParams ? "p" : "()";
+}
+/**
+* Compiles one ICU message into the arrow the build writes into `generated/strings.<locale>.ts`.
+*
+* @param text - The message as the game wrote it.
+* @returns The arrow source, the parameter types and whether the module needs the helper.
+* @throws {Error} When the message does not parse or uses an unsupported ICU feature.
+* @example
+* ```ts
+* compileMessage("Заказы").source; // '() => [{ kind: "text", text: "Заказы" }]'
+* ```
+*/
+function compileMessage(text) {
+	const scan = {
+		params: {},
+		usesArgument: false,
+		usesParams: false,
+		usesIntl: false
+	};
+	const pieces = piecesOf(parseMessage(text), scan);
+	return {
+		source: `${headOf(scan)} => ${toParts(pieces)}`,
+		params: scan.params,
+		usesArgument: scan.usesArgument
+	};
+}
+//#endregion
+//#region src/plugins/i18n/compile/compile.ts
+/**
+* @file i18n plugin, build time — the walk over `features/*​/strings/<locale>.json` and the two
+* generated modules it writes. Every problem of a run is collected and reported in one error, so
+* a game fixes its messages in one round. Node and Bun only: nothing under `src/` outside this
+* folder and `src/assets.ts` imports it, so no game bundles the ICU parser.
+*/
+/** How every problem of this compiler is prefixed. */
+const PREFIX = "[game] i18n: ";
+/**
+* Creates the table of compiled messages per locale. Its own function because lint rule L5
+* refuses a collection built inside an exported declaration.
+*
+* @returns An empty table.
+*/
+function emptyLocales() {
+	return /* @__PURE__ */ new Map();
+}
+/**
+* Creates the table of which feature owns which key.
+*
+* @returns An empty table.
+*/
+function emptyOwners() {
+	return /* @__PURE__ */ new Map();
+}
+/**
+* Creates the table of merged parameters per key.
+*
+* @returns An empty table.
+*/
+function emptyParameters() {
+	return /* @__PURE__ */ new Map();
+}
+/**
+* Reads the message of anything that was thrown.
+*
+* @param error - What the `catch` caught.
+* @returns The message.
+*/
+function detailOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Collects every problem of a compile into one error.
+*
+* @param problems - The problems, in walk order.
+* @returns The error to reject with.
+*/
+function collected(problems) {
+	const only = problems[0];
+	if (problems.length === 1 && only !== void 0) return /* @__PURE__ */ new Error(`${PREFIX}${only}\n  Fix the message or use a supported ICU feature.`);
+	const lines = problems.map((text) => `  ${text}`).join("\n");
+	return /* @__PURE__ */ new Error(`${PREFIX}the compile found ${problems.length} problems.\n${lines}\n  Fix them and run "bun run assets:keys" again.`);
+}
+/**
+* Lists the sub-folders of a folder that may not exist.
+*
+* @param folder - Path of the folder.
+* @returns The names, sorted.
+*/
+async function listFolders(folder) {
+	try {
+		return (await readdir(folder, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).toSorted();
+	} catch {
+		return [];
+	}
+}
+/**
+* Lists the locales one feature brought, by the names of its string files.
+*
+* @param folder - Path of the `strings` folder.
+* @returns The locale names, sorted.
+*/
+async function listLocales(folder) {
+	try {
+		return (await readdir(folder, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -5)).toSorted();
+	} catch {
+		return [];
+	}
+}
+/**
+* Reads one string file as a flat table of key to message.
+*
+* @param file - Path of the file.
+* @param relative - The path a problem names it by.
+* @param walk - What the compile collects.
+* @returns The table, or `undefined` when the file is a problem.
+*/
+async function readTable(file, relative, walk) {
+	try {
+		const parsed = JSON.parse(await readFile(file, "utf8"));
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+			walk.problems.push(`${relative}: a string file is an object of key to message.`);
+			return;
+		}
+		return parsed;
+	} catch (error) {
+		walk.problems.push(`${relative} could not be read: ${detailOf(error)}.`);
+		return;
+	}
+}
+/**
+* Records which feature owns a key, refusing the same key in two features.
+*
+* @param walk - What the compile collects.
+* @param key - The message key.
+* @param source - Where this message came from.
+* @returns True when the key belongs to this feature.
+*/
+function claim(walk, key, source) {
+	const known = walk.owner.get(key);
+	if (known === void 0) {
+		walk.owner.set(key, source);
+		return true;
+	}
+	if (known.feature === source.feature) return true;
+	walk.problems.push(`the key "${key}" is in ${known.relative} and ${source.relative}.`);
+	return false;
+}
+/**
+* Sorts option names and drops the repeats.
+*
+* @param options - The option names of one select, from any number of locales.
+* @returns The names, unique and sorted.
+* @example
+* ```ts
+* unique(["language", "audio", "audio"]); // ["audio", "language"]
+* ```
+*/
+function unique(options) {
+	return [...new Set(options)].toSorted();
+}
+/**
+* Creates the parameter table of one key.
+*
+* @returns An empty table.
+*/
+function emptyOrigins() {
+	return /* @__PURE__ */ new Map();
+}
+/**
+* Merges the parameters one locale read for a key into what the other locales read.
+*
+* @param walk - What the compile collects.
+* @param key - The message key.
+* @param params - What this locale read.
+* @param relative - The file this locale came from.
+*/
+function mergeParameters(walk, key, params, relative) {
+	const merged = walk.params.get(key) ?? emptyOrigins();
+	walk.params.set(key, merged);
+	for (const [name, type] of Object.entries(params)) {
+		const known = merged.get(name);
+		if (known === void 0) {
+			merged.set(name, {
+				type,
+				relative
+			});
+			continue;
+		}
+		if (known.type.kind !== type.kind) {
+			walk.problems.push(`"${key}": the parameter "${name}" is a ${known.type.kind} in ${known.relative} and a ${type.kind} in ${relative}.`);
+			continue;
+		}
+		if (known.type.kind === "select" && type.kind === "select") merged.set(name, {
+			type: {
+				kind: "select",
+				options: unique([...known.type.options, ...type.options])
+			},
+			relative: known.relative
+		});
+	}
+}
+/**
+* Compiles one message into the locale it belongs to.
+*
+* @param walk - What the compile collects.
+* @param key - The message key.
+* @param text - The message.
+* @param source - Where this message came from.
+*/
+function compileOne(walk, key, text, source) {
+	if (typeof text !== "string") {
+		walk.problems.push(`"${key}" in ${source.relative}: a message must be a string.`);
+		return;
+	}
+	if (!claim(walk, key, source)) return;
+	try {
+		const compiled = compileMessage(text);
+		const entries = walk.byLocale.get(source.locale) ?? [];
+		entries.push({
+			key,
+			compiled
+		});
+		walk.byLocale.set(source.locale, entries);
+		mergeParameters(walk, key, compiled.params, source.relative);
+	} catch (error) {
+		walk.problems.push(`"${key}" in ${source.relative}: ${detailOf(error)}.`);
+	}
+}
+/**
+* Lists the keys a locale is missing, so a translator sees the gap without the build stopping.
+*
+* @param walk - What the compile collects.
+* @param locales - Every locale of the game.
+* @returns One note per missing key, sorted.
+*/
+function missingNotes(walk, locales) {
+	const notes = [];
+	for (const [key, source] of [...walk.owner].toSorted((left, right) => left[0] < right[0] ? -1 : 1)) for (const locale of locales) {
+		if ((walk.byLocale.get(locale) ?? []).some((entry) => entry.key === key)) continue;
+		notes.push(`the key "${key}" is missing from features/${source.feature}/strings/${locale}.json.`);
+	}
+	return notes;
+}
+/**
+* Builds the types module out of the merged parameters.
+*
+* @param walk - What the compile collects.
+* @returns One entry per key.
+*/
+function typeEntries(walk) {
+	const entries = [];
+	for (const [key, params] of walk.params) {
+		const merged = {};
+		for (const [name, origin] of params) merged[name] = origin.type;
+		entries.push({
+			key,
+			params: merged
+		});
+	}
+	return entries;
+}
+/**
+* Walks `features/*​/strings/<locale>.json` of a game, compiles every message and writes the
+* generated modules: the types module `strings.ts` and one `strings.<locale>.ts` per locale. A
+* check run writes nothing and only reports whether something would change.
+*
+* @param root - Game source root, the folder that holds the features.
+* @param out - The generated directory the modules are written into.
+* @param options - Whether this is a check run, and what the features folder is called.
+* @returns Whether an output differed, the locales, the keys and the notes.
+* @throws {Error} One error that lists every problem the compile found.
+* @example
+* ```ts
+* const report = await compileStrings("src", "src/generated");
+* // report.locales: ["en", "ru"], report.changed: true on the first run
+* ```
+*/
+async function compileStrings(root, out, options = {}) {
+	const walk = {
+		byLocale: emptyLocales(),
+		owner: emptyOwners(),
+		params: emptyParameters(),
+		problems: []
+	};
+	const featuresFolder = path.join(root, options.features ?? "features");
+	for (const feature of await listFolders(featuresFolder)) {
+		const stringsFolder = path.join(featuresFolder, feature, "strings");
+		for (const locale of await listLocales(stringsFolder)) {
+			const relative = `features/${feature}/strings/${locale}.json`;
+			const table = await readTable(path.join(stringsFolder, `${locale}.json`), relative, walk);
+			if (table === void 0) continue;
+			for (const [key, text] of Object.entries(table)) compileOne(walk, key, text, {
+				feature,
+				locale,
+				relative
+			});
+		}
+	}
+	if (walk.problems.length > 0) throw collected(walk.problems);
+	const locales = [...walk.byLocale.keys()].toSorted();
+	const keys = [...walk.owner.keys()].toSorted();
+	if (locales.length === 0) return {
+		changed: false,
+		locales,
+		keys,
+		notes: []
+	};
+	const write = options.check !== true;
+	const outputs = [{
+		file: path.join(out, "strings.ts"),
+		text: emitTypes(typeEntries(walk))
+	}, ...locales.map((locale) => ({
+		file: path.join(out, `strings.${locale}.ts`),
+		text: emitLocale(walk.byLocale.get(locale) ?? [])
+	}))];
+	let changed = false;
+	for (const output of outputs) changed = await writeIfChanged(output.file, output.text, write) || changed;
+	return {
+		changed,
+		locales,
+		keys,
+		notes: missingNotes(walk, locales)
+	};
+}
+/**
+* Tells whether the generated modules of a game are current, without writing anything. The
+* `--check` run of `bun run assets:keys` covers the strings with it.
+*
+* @param root - Game source root, the folder that holds the features.
+* @param out - The generated directory the modules live in.
+* @returns True when nothing would change.
+* @throws {Error} One error that lists every problem the compile found.
+* @example
+* ```ts
+* await checkStrings("src", "src/generated"); // false when a message changed since the last run
+* ```
+*/
+async function checkStrings(root, out) {
+	return !(await compileStrings(root, out, { check: true })).changed;
+}
+//#endregion
+//#region src/assets.ts
+/**
+* @file The node-side door of the engine (subpath `./assets`, node and bun only): asset and file
+* work that has no place in a browser bundle. It holds the asset key scanner and the string
+* compiler; a game runs both as `bun run assets:keys`, the editor imports the same functions later.
+* Re-exports only: the code lives in `plugins/assets/scan/` and `plugins/i18n/compile/`, and this is
+* the one door to them in `src/`.
+*/
+if (import.meta.main) process.exitCode = await runCli(process.argv.slice(2), compileStrings);
+//#endregion
+export { checkStrings, compileStrings, emitKeys, emitManifest, runCli, scanAssets };