prosebook 0.0.1 → 0.2.0

package/dist/config-D--RITk2.js

@@ -0,0 +1,1208 @@
+import { isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { existsSync, readFileSync } from "node:fs";
+import { TYPE as TYPE$1, isDateElement, isNumberElement, isTimeElement, parse } from "@formatjs/icu-messageformat-parser";
+// src/tools/icu.ts
+/**
+* What an ICU message declares, read off its AST: argument types, tags, and whether each number and
+* date style is one the formatter honors. Shared by the loader, the compiler and the lint.
+*/
+function parseMessage(text) {
+	const ast = parse(text, {
+		shouldParseSkeletons: true,
+		requiresOtherClause: true
+	});
+	walk(ast, (el) => {
+		if ((isDateElement(el) || isTimeElement(el)) && typeof el.style === "object" && el.style !== null && el.style.pattern.includes("j")) el.style.parsedOptions = localHour(el.style.pattern);
+	});
+	return ast;
+}
+/**
+* A skeleton's `j` is the hour as the locale writes it, 12 or 24. The parser resolves it only when
+* given a locale and drops it otherwise, so `::yMMMdjmm` showed the minute alone. Read here as an
+* hour with no cycle, which `Intl` gives the cycle of whatever locale formats it: "2:05 PM", "14:05".
+*/
+function localHour(pattern) {
+	const run = /j+/.exec(pattern)[0];
+	const rest = pattern.replaceAll("j", "");
+	return {
+		...rest === "" ? {} : dateFields(rest),
+		hour: run.length % 2 === 0 ? "2-digit" : "numeric"
+	};
+}
+/** What the parser reads from a date skeleton on its own; nothing where it can't parse it. */
+function dateFields(skeleton) {
+	try {
+		const el = parse(`{d, date, ::${skeleton}}`, { shouldParseSkeletons: true })[0];
+		return el !== void 0 && isDateElement(el) && typeof el.style === "object" && el.style !== null ? el.style.parsedOptions : {};
+	} catch {
+		return {};
+	}
+}
+/**
+* ICU argument types, as TypeScript. A bare `{x}` is a string: a number spliced in raw is printed by
+* `String()`, which knows no locale, so a quantity says `{x, number}` and the type is what asks for it.
+* A `select` narrows to the arms it names, and still takes any string, since `other` catches the rest.
+*/
+function argType(el) {
+	switch (el.type) {
+		case TYPE$1.argument: return "string";
+		case TYPE$1.number:
+		case TYPE$1.plural: return "number";
+		case TYPE$1.date:
+		case TYPE$1.time: return "Date | number";
+		case TYPE$1.select: {
+			const named = Object.keys(el.options).filter((o) => o !== "other");
+			return named.length > 0 ? `${named.map((o) => JSON.stringify(o)).join(" | ")} | (string & {})` : "string";
+		}
+		case TYPE$1.literal:
+		case TYPE$1.pound:
+		case TYPE$1.tag:
+		default: return;
+	}
+}
+/** Calls `visit` on every element, inside plural and select arms and tags too. */
+function walk(elements, visit) {
+	for (const el of elements) {
+		visit(el);
+		if (el.type === TYPE$1.select || el.type === TYPE$1.plural) for (const option of Object.values(el.options)) walk(option.value, visit);
+		if (el.type === TYPE$1.tag) walk(el.children, visit);
+	}
+}
+function argsOf(elements, clash = () => {}) {
+	const args = /* @__PURE__ */ new Map();
+	walk(elements, (el) => {
+		const type = argType(el);
+		if (type === void 0 || !("value" in el) || typeof el.value !== "string") return;
+		const seen = args.get(el.value);
+		if (seen !== void 0 && seen !== type) clash(el.value);
+		else args.set(el.value, type);
+	});
+	return args;
+}
+function tagsOf(elements) {
+	const tags = /* @__PURE__ */ new Set();
+	walk(elements, (el) => {
+		if (el.type === TYPE$1.tag) tags.add(el.value);
+	});
+	return [...tags].sort();
+}
+/** A message with no placeholders and no tags renders to one literal, which ships as a plain string. */
+function staticLiteral(ast) {
+	if (ast.length === 0) return "";
+	if (ast.length === 1 && ast[0].type === TYPE$1.literal) return ast[0].value;
+}
+const NUMBER_STYLES = {
+	integer: { maximumFractionDigits: 0 },
+	percent: { style: "percent" }
+};
+const DATE_STYLES = [
+	"short",
+	"medium",
+	"long",
+	"full"
+];
+/** The `Intl` options a number element formats with. Throws, with the fix, where the style is wrong. */
+function numberOptions(el) {
+	const style = el.style;
+	if (style === null || style === void 0) return void 0;
+	if (typeof style === "string") {
+		if (style === "currency") throw new Error(`{${el.value}} needs its currency named: {${el.value}, number, ::currency/EUR}`);
+		const named = NUMBER_STYLES[style];
+		if (named === void 0) throw new Error(`{${el.value}} asks for number style "${style}": integer, percent, or a ::skeleton`);
+		return named;
+	}
+	const unknown = style.tokens.filter((t) => !stemIsKnown(t.stem, t.options)).map((t) => t.stem);
+	if (unknown.length > 0) throw new Error(`{${el.value}} has skeleton stems the formatter drops without a word: ${unknown.join(", ")}`);
+	const options = style.parsedOptions;
+	try {
+		new Intl.NumberFormat("en", options).resolvedOptions();
+	} catch (e) {
+		throw new Error(`{${el.value}} has a skeleton Intl refuses: ${e.message}`, { cause: e });
+	}
+	return options;
+}
+/** The `Intl` options a date or time element formats with. Throws, with the fix, where the style is wrong. */
+function dateOptions(el) {
+	const style = el.style;
+	const field = el.type === TYPE$1.time ? "timeStyle" : "dateStyle";
+	if (style === null || style === void 0) return el.type === TYPE$1.time ? { timeStyle: "short" } : void 0;
+	if (typeof style === "string") {
+		if (!DATE_STYLES.includes(style)) {
+			const kind = el.type === TYPE$1.time ? "time" : "date";
+			throw new Error(`{${el.value}} asks for ${kind} style "${style}": ${DATE_STYLES.join(", ")}, or a ::skeleton`);
+		}
+		return { [field]: style };
+	}
+	const dropped = (style.pattern.match(/([A-Za-z])
*/g) ?? []).filter((f) => !f.startsWith("j") && Object.keys(dateFields(f)).length === 0);
+	if (dropped.length > 0) throw new Error(`{${el.value}} has date fields the formatter drops without a word: ${dropped.join(", ")}`);
+	if (Object.keys(style.parsedOptions).length === 0) throw new Error(`{${el.value}} has a date skeleton the formatter reads nothing from: "${style.pattern}"`);
+	try {
+		new Intl.DateTimeFormat("en", style.parsedOptions).resolvedOptions();
+	} catch (e) {
+		throw new Error(`{${el.value}} has a skeleton Intl refuses: ${e.message}`, { cause: e });
+	}
+	return style.parsedOptions;
+}
+/**
+* Whether the formatter understands a skeleton stem. One it does not is dropped without a word, so
+* `::compact-shortt` reaches the screen as `5` where `5K` was written. Every stem it understands sets
+* at least one option, so an empty result is the answer.
+*/
+function stemIsKnown(stem, options) {
+	try {
+		const el = parse(`{n, number, ::${[stem, ...options].join("/")}}`, { shouldParseSkeletons: true })[0];
+		if (el === void 0 || !isNumberElement(el) || typeof el.style !== "object" || el.style === null) return false;
+		return Object.keys(el.style.parsedOptions).length > 0;
+	} catch {
+		return false;
+	}
+}
+/** Every format problem in a message, as sentences. */
+function formatProblems(ast) {
+	const found = [];
+	walk(ast, (el) => {
+		try {
+			if (isNumberElement(el)) numberOptions(el);
+			if (isDateElement(el) || isTimeElement(el)) dateOptions(el);
+		} catch (e) {
+			found.push(e.message);
+		}
+	});
+	return found;
+}
+/** How each number or date argument is formatted, for the generated doc comment: `date medium, time short`. */
+function formatsOf(ast) {
+	const formats = /* @__PURE__ */ new Map();
+	walk(ast, (el) => {
+		if (!isNumberElement(el) && !isDateElement(el) && !isTimeElement(el)) return;
+		const style = el.style;
+		if (style === null || style === void 0) return;
+		const kind = el.type === TYPE$1.number ? "number" : el.type === TYPE$1.date ? "date" : "time";
+		let said;
+		if (typeof style === "string") said = `${kind} \`${style}\``;
+		else if ("mf2" in style) {
+			const { name, options } = style.mf2;
+			said = `\`${[`:${name}`, ...Object.entries(options).map(([k, v]) => `${k}=${v}`)].join(" ")}\``;
+		} else if ("tokens" in style) said = `${kind} \`::${style.tokens.map((t) => [t.stem, ...t.options].join("/")).join(" ")}\``;
+		else said = `${kind} \`::${style.pattern}\``;
+		const list = formats.get(el.value) ?? [];
+		if (!list.includes(said)) list.push(said);
+		formats.set(el.value, list);
+	});
+	return new Map([...formats].map(([name, list]) => [name, list.join(", ")]));
+}
+// src/tools/lint.ts
+/** Typed plugin, for `lint.plugins`. */
+function definePlugin(plugin) {
+	return plugin;
+}
+/** Stands in for a placeholder in a reading, which no prose rule reads. */
+const HOLE = "⁣";
+/** Tags whose content is code or a literal the reader types, not prose. */
+const VERBATIM_TAGS = /* @__PURE__ */ new Set([
+	"code",
+	"mono",
+	"kbd",
+	"keycap",
+	"nums"
+]);
+function renderAs(elements, arm) {
+	let out = "";
+	for (const el of elements) if (el.type === TYPE$1.literal) out += el.value;
+	else if (el.type === TYPE$1.tag) out += VERBATIM_TAGS.has(el.value) ? "⁣" : renderAs(el.children, arm);
+	else if (el.type === TYPE$1.plural || el.type === TYPE$1.select) {
+		const option = arm === null ? void 0 : el.options[arm] ?? el.options["other"];
+		out += option === void 0 ? "⁣" : renderAs(option.value, arm);
+	} else out += "⁣";
+	return out;
+}
+function readings(message) {
+	const literal = staticLiteral(message);
+	const ast = literal === void 0 ? message : [{
+		type: TYPE$1.literal,
+		value: literal
+	}];
+	const arms = /* @__PURE__ */ new Set();
+	const collect = (els) => {
+		for (const el of els) {
+			if (el.type === TYPE$1.plural || el.type === TYPE$1.select) for (const [name, option] of Object.entries(el.options)) {
+				arms.add(name);
+				collect(option.value);
+			}
+			if (el.type === TYPE$1.tag) collect(el.children);
+		}
+	};
+	collect(ast);
+	const primary = renderAs(ast, "other");
+	return {
+		primary,
+		variants: [.../* @__PURE__ */ new Set([primary, ...[...arms].map((arm) => renderAs(ast, arm))])].map((v) => v.replace(/\u2019/g, "'")),
+		skeleton: renderAs(ast, null)
+	};
+}
+/** What a reader sees end to end, less a placeholder appended at the very end. */
+const prose = (text) => text.replace(new RegExp(`[\\s⁣]+$`), "");
+const FREE = new Set("a an the this that these those it its them your and or to of for by in on at from with".split(" "));
+const tokens = (text) => text.split(/\s+/).filter((w) => /[\p{L}\p{N}]/u.test(w) || w.includes("⁣"));
+/** The words a budget counts: articles, short prepositions and asides in parentheses are free. */
+function words(text) {
+	return tokens(text.replace(/\s*\([^)]*\)/g, "")).filter((w) => !FREE.has(w.toLowerCase().replace(/[^\p{L}]/gu, "")));
+}
+const ABBREVIATIONS = /\b(?:e\.g|i\.e|vs|etc)\.$/i;
+function sentences(text) {
+	let count = 1;
+	const boundary = /[.!?…]+["')\]]*\s+(?=\S)/g;
+	for (let m = boundary.exec(text); m !== null; m = boundary.exec(text)) if (!ABBREVIATIONS.test(text.slice(0, m.index + m[0].trimEnd().length))) count += 1;
+	return count;
+}
+/** A word or phrase on its own, not inside a longer word or a hyphenated compound. */
+function phrase(p) {
+	const escaped = p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/ /g, "\\s+");
+	return new RegExp(`(?<![\\p{L}\\p{N}'-])${escaped}(?![\\p{L}\\p{N}'-])`, "iu");
+}
+/** The words and phrases of `list` that some reading carries. */
+const listed = (variants, list) => list.filter((w) => variants.some((v) => phrase(w).test(v)));
+const unquoted = (token) => token.replace(/^[("'“‘]+|[)"'”’.,:;!?]+$/g, "");
+function capitalizedWord(text, proper) {
+	const parts = text.split(/\s+/).filter(Boolean);
+	for (let i = 1; i < parts.length; i++) {
+		const word = unquoted(parts[i]);
+		if (!/^\p{Lu}\p{Ll}/u.test(word) || proper.has(word)) continue;
+		if (/[.:?!]["')]*$/.test(parts[i - 1])) continue;
+		return word;
+	}
+}
+/** Words a count is followed by that are not plural nouns, though they end in s. */
+const NOT_PLURAL = /* @__PURE__ */ new Set([
+	"is",
+	"was",
+	"has",
+	"does",
+	"this",
+	"its",
+	"plus",
+	"minus",
+	"less",
+	"yes",
+	"us",
+	"as",
+	"bus",
+	"gas",
+	"news",
+	"series"
+]);
+/**
+* The singular of an English plural noun, or nothing where it doesn't look like one. A word with no
+* vowel is a unit or an abbreviation (`kbps`, `fps`, `hrs`), which reads the same after 1.
+*/
+function singularOf(word) {
+	const lower = word.toLowerCase();
+	if (word.length < 3 || !lower.endsWith("s") || lower.endsWith("ss") || NOT_PLURAL.has(lower)) return void 0;
+	if (!/[aeiouy]/.test(lower)) return void 0;
+	if (/[^aeiou]ies$/.test(lower)) return `${word.slice(0, -3)}y`;
+	if (/(?:s|x|z|ch|sh)es$/.test(lower)) return word.slice(0, -2);
+	return word.slice(0, -1);
+}
+const MINOR = new Set("a an the and but or nor for so yet as at by in of off on per to up via with".split(" "));
+/** The first word out of `style` case, less those in `keep`. */
+function outOfCase(text, style, keep) {
+	if (style === "sentence") return capitalizedWord(text, keep);
+	return text.split(/\s+/).map(unquoted).filter((w) => /\p{L}/u.test(w) && !keep.has(w)).find((w, i) => {
+		if (style === "lower") return /\p{Lu}/u.test(w);
+		if (style === "upper") return /\p{Ll}/u.test(w);
+		return /^\p{Ll}/u.test(w) && (i === 0 || !MINOR.has(w));
+	});
+}
+const CONTRACTIONS = [
+	[/\bcannot\b/i, "can't"],
+	[/\bcan not\b/i, "can't"],
+	[/\bwill not\b/i, "won't"],
+	[/\b(could|would|should|is|are|was|were|do|does|did|has|have|had|must|need) not\b/i, "n't"]
+];
+/** Calls `visit` on every run of elements that sit side by side, with the arguments a plural around it counts. */
+function eachRun(elements, visit, counted = /* @__PURE__ */ new Set()) {
+	visit(elements, counted);
+	for (const el of elements) {
+		if (el.type === TYPE$1.plural) for (const o of Object.values(el.options)) eachRun(o.value, visit, /* @__PURE__ */ new Set([...counted, el.value]));
+		if (el.type === TYPE$1.select) for (const o of Object.values(el.options)) eachRun(o.value, visit, counted);
+		if (el.type === TYPE$1.tag) eachRun(el.children, visit, counted);
+	}
+}
+/** A plain placeholder named as a count. A number placeholder is one whatever its name. */
+const COUNT_NAME = /^(?:n|num|count|total|amount|quantity)$|(?:count|total)$/i;
+/**
+* Whether an arm ends with a stop; nothing for an arm with no words, or one that trails off in an
+* ellipsis (`Saving…`, `Save as…`), which is neither. Which stop is the arm's own: a question in
+* `one` and a second sentence after it in `other` both end well.
+*/
+function endsWithStop(arm) {
+	const text = prose(renderAs(arm, "other")).trim();
+	if (text.replaceAll("⁣", "").trim() === "" || /(?:…|\.{3})["')”»」』]*$/u.test(text)) return void 0;
+	return hasStop(text);
+}
+/** Ends with a stop in any script (`。`, `؟`, `;` as Greek writes `?`), though not a comma. */
+const hasStop = (text) => /(?![,，、،])[\p{Terminal_Punctuation}…]["')”»」』]*$/u.test(prose(text).trim());
+const CURRENCY_BEFORE = /[$€£¥₹]\s?$/;
+/**
+* The ways a path through menus is written, the separator in a group: an arrow or `›` however
+* spaced, and `>` or `/` only spaced between words or placeholders, with a capital after a slash,
+* since "2 > 1" and "and / or" are no paths. The match takes the spaces around, so the fix spaces
+* the separator.
+*/
+const PATH_SEPARATORS = new RegExp(String.raw`\s*(→|->|›)\s*|(?<=[\p{L}${"⁣"}])\s+(>)\s+(?=[\p{L}${"⁣"}])|(?<=\p{L})\s+(\/)\s+(?=\p{Lu})`, "gu");
+const OFF_SCREEN = /* @__PURE__ */ new Set(["aria"]);
+const an = (word = "string") => `${/^[aeiou]/i.test(word) ? "an" : "a"} ${word}`;
+const CORE_RULES = {
+	whitespace: {
+		description: "No leading, trailing or doubled spaces.",
+		recommended: "error",
+		on: { locale: "all" },
+		check: ({ text }) => {
+			const message = "no leading, trailing or doubled spaces";
+			if (text.variants.some((v) => v.includes("  "))) return [{
+				message,
+				match: "  ",
+				fix: " "
+			}];
+			return text.variants.some((v) => /^\s|\s$/.test(v.replaceAll("⁣", "x"))) ? [message] : [];
+		}
+	},
+	"word-budget": {
+		description: "A kind with `maxWords` stays within it. Articles, short prepositions and asides in parentheses don't count.",
+		recommended: "warn",
+		check: ({ message: m, kind, text }) => {
+			if (kind?.maxWords === void 0 || OFF_SCREEN.has(m.surface ?? "")) return [];
+			const n = words(text.primary).length;
+			return n > kind.maxWords ? [`${an(m.kind)} is ${kind.maxWords} words at most, and this is ${n}`] : [];
+		}
+	},
+	"sentence-budget": {
+		description: "A kind with `maxSentences` stays within it.",
+		recommended: "warn",
+		check: ({ message: m, kind, text }) => {
+			const most = (m.surface !== void 0 ? kind?.maxSentencesOn?.[m.surface] : void 0) ?? kind?.maxSentences;
+			if (most === void 0) return [];
+			const n = sentences(prose(text.primary));
+			return n > most ? [`${an(m.kind)}${kind?.maxSentencesOn?.[m.surface ?? ""] !== void 0 ? ` on ${m.surface}` : ""} is ${most} sentence(s) at most, and this is ${n}`] : [];
+		}
+	},
+	period: {
+		description: "A kind with `period: always` (or on a listed surface) ends with a period, unless the entry is a fragment.",
+		recommended: "warn",
+		check: ({ message: m, kind, text }) => {
+			const rule = kind?.period;
+			return (rule === "always" || Array.isArray(rule) && rule.includes(m.surface ?? "")) && !m.fragment && !/[.?!…:]["')”]*$/.test(prose(text.primary)) ? [`${an(m.kind)} ends with a period, or is marked fragment: true`] : [];
+		}
+	},
+	"no-period": {
+		description: "A kind with `period: never` ends without one.",
+		recommended: "warn",
+		check: ({ message: m, kind, text }) => kind?.period === "never" && /[^.]\.$/.test(prose(text.primary)) ? [`${an(m.kind)} ends without a period`] : []
+	},
+	"bare-name": {
+		description: "A kind with `bare: true` carries no explanation after a dash or a colon.",
+		recommended: "warn",
+		check: ({ message: m, kind, text }) => kind?.bare === true && new RegExp(`\\s[—–-]\\s|\\p{L}:\\s(?!⁣)`, "u").test(text.skeleton) ? [`${an(m.kind)} carries no explanation after a dash or a colon`] : []
+	},
+	"sentence-case": {
+		description: "A kind with `sentenceCase: true` capitalizes only its first word and proper nouns.",
+		check: ({ message: m, kind, text, config }) => {
+			if (kind?.sentenceCase !== true) return [];
+			const word = outOfCase(text.primary, "sentence", new Set(config.lint.properNouns));
+			if (word === void 0) return [];
+			return [{
+				message: `"${word}" is capitalized in a sentence-case ${m.kind}: add it to lint.properNouns if it is a name`,
+				match: word
+			}];
+		}
+	},
+	"banned-word": {
+		description: "A word or phrase from the banned lists.",
+		recommended: "warn",
+		check: ({ text, config }) => config.lint.banned.flatMap(({ words: list, why }) => listed(text.variants, list).map((w) => ({
+			message: `"${w}" ${why}`,
+			match: w
+		})))
+	},
+	spelling: {
+		description: "A spelling the product writes another way.",
+		recommended: "warn",
+		check: ({ text, config: { lint } }) => listed(text.variants, Object.keys(lint.spelling)).map((w) => ({
+			message: `"${w}" is spelled "${lint.spelling[w]}"`,
+			match: w,
+			fix: lint.spelling[w]
+		}))
+	},
+	"one-word": {
+		description: "A near-synonym for a concept the product has one word for.",
+		recommended: "warn",
+		check: ({ text, config: { lint } }) => listed(text.variants, Object.keys(lint.concepts)).map((w) => ({
+			message: `"${w}" is "${lint.concepts[w]}" everywhere in the product`,
+			match: w,
+			fix: lint.concepts[w]
+		}))
+	},
+	"no-em-dash": {
+		description: "No em-dashes, and no spaced hyphen standing in for one.",
+		check: ({ text }) => {
+			const match = text.variants.map((v) => /—|\s[–-]\s/.exec(v)?.[0]).find((m) => m !== void 0);
+			return match === void 0 ? [] : [{
+				message: "no em-dash: a comma, a period or a colon does the job",
+				match
+			}];
+		}
+	},
+	path: {
+		description: "A path through menus or settings is written with `lint.pathSeparator`, spaced: Settings › General.",
+		check: ({ text, config }) => {
+			const use = config.lint.pathSeparator;
+			for (const v of text.variants) for (const m of v.matchAll(PATH_SEPARATORS)) {
+				if ((m[1] ?? m[2] ?? m[3]) === use) continue;
+				return [{
+					message: `a path is written with a spaced ${use}`,
+					match: m[0],
+					fix: ` ${use} `
+				}];
+			}
+			return [];
+		}
+	},
+	contractions: {
+		description: "`could not`, `is not` and `cannot` are written as contractions.",
+		check: ({ text }) => CONTRACTIONS.flatMap(([pattern, short]) => {
+			const found = text.variants.map((v) => pattern.exec(v)).find((f) => f !== null);
+			if (found === void 0 || found === null) return [];
+			const fix = short === "n't" ? `${found[1]}n't` : short;
+			return [{
+				message: `"${found[0]}" is written as a contraction (${short})`,
+				match: found[0],
+				fix
+			}];
+		})
+	},
+	ellipsis: {
+		description: "An ellipsis is one character, `…`, not three periods.",
+		on: { locale: "all" },
+		check: ({ text }) => text.variants.some((v) => v.includes("...")) ? [{
+			message: "an ellipsis is one character: …",
+			match: "...",
+			fix: "…"
+		}] : []
+	},
+	"plural-count": {
+		description: "A count followed by a plural noun, `{count} files`, is a plural, or it reads \"1 files\". English.",
+		recommended: "warn",
+		check: ({ ast }) => {
+			const said = [];
+			eachRun(ast, (run, counted) => run.forEach((el, i) => {
+				if (el.type !== TYPE$1.number && el.type !== TYPE$1.argument) return;
+				if (counted.has(el.value) || el.type === TYPE$1.argument && !COUNT_NAME.test(el.value)) return;
+				const next = run[i + 1];
+				const word = next?.type === TYPE$1.literal ? /^\s+(\p{L}+)(?![\p{L}'])/u.exec(next.value)?.[1] : void 0;
+				const one = word === void 0 ? void 0 : singularOf(word);
+				if (word !== void 0 && one !== void 0) said.push({
+					message: `${el.value} is followed by "${word}", which reads "1 ${word}": make it a plural with a "# ${one}" arm`,
+					match: word
+				});
+			}));
+			return said;
+		}
+	},
+	"plural-one": {
+		description: "A plural's `one` arm says something other than `other`, and says `#` rather than `1`.",
+		recommended: "warn",
+		on: { locale: "all" },
+		check: ({ ast, locale, config }) => {
+			const said = [];
+			walk(ast, (el) => {
+				if (el.type !== TYPE$1.plural || el.pluralType !== "cardinal") return;
+				const { one, other } = el.options;
+				if (one === void 0) return;
+				if (locale === config.source && other !== void 0 && renderAs(one.value, "other") === renderAs(other.value, "other")) said.push({ message: `the one and other arms of ${el.value} say the same: write the singular in one` });
+				let literalOne = false;
+				walk(one.value, (inner) => {
+					if (inner.type === TYPE$1.literal && /(?<![\d.,])1(?![\d.,])/.test(inner.value)) literalOne = true;
+				});
+				if (!literalOne) return;
+				const message = `the one arm of ${el.value} writes 1, which one is not in every language: write #, or make the arm =1`;
+				said.push({
+					message,
+					match: "1"
+				});
+			});
+			return said;
+		}
+	},
+	"arm-endings": {
+		description: "The arms of a plural or select end alike: all with a stop, or all without one.",
+		recommended: "warn",
+		on: { locale: "all" },
+		check: ({ ast }) => {
+			const said = [];
+			walk(ast, (el) => {
+				if (el.type !== TYPE$1.plural && el.type !== TYPE$1.select) return;
+				if (new Set(Object.values(el.options).flatMap((o) => endsWithStop(o.value) ?? [])).size > 1) said.push(`some arms of ${el.value} end with a stop and some without: end them alike`);
+			});
+			return said;
+		}
+	},
+	"formatted-by-hand": {
+		description: "A currency symbol or `%` typed beside a placeholder, or digits grouped by hand, which only suit one locale.",
+		recommended: "warn",
+		on: { locale: "all" },
+		check: ({ ast, text }) => {
+			const said = /* @__PURE__ */ new Map();
+			const say = (message, match) => said.set(message, {
+				message,
+				match
+			});
+			eachRun(ast, (run) => run.forEach((el, i) => {
+				if (el.type !== TYPE$1.number && el.type !== TYPE$1.argument) return;
+				const before = run[i - 1];
+				const after = run[i + 1];
+				const symbol = before?.type === TYPE$1.literal ? CURRENCY_BEFORE.exec(before.value)?.[0].trim() : void 0;
+				if (symbol !== void 0) say(`"${symbol}" is typed before ${el.value}: format it as a currency, which puts the symbol where the locale does`, symbol);
+				if (after?.type === TYPE$1.literal && /^\s?%/.test(after.value)) say(`"%" is typed after ${el.value}: format it as a percent, which takes the fraction (0.5 for 50%)`, "%");
+			}));
+			const grouped = text.variants.map((v) => /\d{1,3}(?:,\d{3})+(?!\d)/.exec(v)?.[0]).find((g) => g !== void 0);
+			if (grouped !== void 0) say(`"${grouped}" groups its digits the English way: make it a placeholder formatted as a number`, grouped);
+			return [...said.values()];
+		}
+	},
+	"source-ending": {
+		description: "A translation ends with a stop where its source does, and without one where it does not.",
+		recommended: "warn",
+		on: { locale: "all" },
+		check: ({ text, source }) => {
+			const ends = hasStop(text.primary);
+			if (ends === hasStop(source.primary)) return [];
+			return [ends ? "ends with a stop, and the source does not: drop it" : "the source ends with a stop, and this does not: end it as the source does"];
+		}
+	}
+};
+const fill = (message, values) => message.replace(/\{(\w+)\}/g, (all, name) => values[name] === void 0 ? all : String(values[name]));
+const graphemes = new Intl.Segmenter();
+const COUNTERS = {
+	words: (text) => tokens(text).length,
+	sentences: (text) => sentences(prose(text)),
+	characters: (text) => [...graphemes.segment(text.replaceAll("⁣", ""))].length
+};
+/** A rule as code, checked once when the config loads: a JSON config is not type-checked. */
+function compileRule(name, rule) {
+	const fail = (problem) => {
+		throw new Error(`lint rule ${name} ${problem}`);
+	};
+	const pattern = (source, field, ignoreCase) => {
+		if (typeof source !== "string") return fail(`${field} is not a string: write the pattern as one`);
+		try {
+			return new RegExp(source, ignoreCase === true ? "iu" : "u");
+		} catch (e) {
+			return fail(`${field} is not a regular expression: ${e instanceof Error ? e.message : String(e)}`);
+		}
+	};
+	const said = (message) => typeof message === "string" && message !== "" ? message : fail("has no message: say what to write instead");
+	if (typeof rule.description !== "string" || rule.description === "") fail("has no description: say what it holds a string to");
+	if ("check" in rule) return typeof rule.check === "function" ? rule : fail("has a check that is not a function");
+	const { description, recommended, strict, on } = rule;
+	const base = {
+		description,
+		recommended,
+		strict,
+		on
+	};
+	switch (rule.type) {
+		case "existence": {
+			const list = rule.words ?? [];
+			const patterns = (rule.patterns ?? []).map((p, i) => pattern(p, `patterns[${i}]`, rule.ignoreCase));
+			if (list.length + patterns.length === 0) fail("has no words or patterns: list what a string never says");
+			const message = said(rule.message);
+			return {
+				...base,
+				check: ({ text }) => {
+					const matched = patterns.flatMap((p) => text.variants.map((v) => p.exec(v)?.[0]).find((m) => m !== void 0) ?? []);
+					return [.../* @__PURE__ */ new Set([...listed(text.variants, list), ...matched])].map((match) => ({
+						message: fill(message, { match }),
+						match
+					}));
+				}
+			};
+		}
+		case "substitution": {
+			const swap = rule.swap ?? {};
+			if (Object.keys(swap).length === 0) fail("has nothing in swap: map a word to the one written instead");
+			const message = rule.message === void 0 ? "\"{match}\" is written \"{use}\"" : said(rule.message);
+			return {
+				...base,
+				check: ({ text }) => listed(text.variants, Object.keys(swap)).map((match) => ({
+					message: fill(message, {
+						match,
+						use: swap[match]
+					}),
+					match,
+					fix: swap[match]
+				}))
+			};
+		}
+		case "occurrence": {
+			const { count: unit, max, min, relative } = rule;
+			const counter = Object.hasOwn(COUNTERS, unit) ? COUNTERS[unit] : fail(`counts ${unit}: count words, sentences or characters`);
+			if (max === void 0 && min === void 0) fail("has no max or min: give it one");
+			if (rule.message !== void 0) said(rule.message);
+			return {
+				...base,
+				check: ({ text, source }) => {
+					const count = counter(text.primary);
+					const of = relative === true ? counter(source.primary) : 1;
+					const over = max !== void 0 && count > max * of;
+					const under = min !== void 0 && count < min * of;
+					if (!over && !under) return [];
+					const limit = over && max !== void 0 ? Math.floor(max * of) : Math.ceil((min ?? 0) * of);
+					const bound = over ? "at most" : "at least";
+					const fallback = relative === true ? `{limit} ${unit} ${bound} ({${over ? "max" : "min"}} times the source's {source}), and this is {count}` : `{${over ? "max" : "min"}} ${unit} ${bound}, and this is {count}`;
+					return [fill(rule.message ?? fallback, {
+						count,
+						max,
+						min,
+						source: relative === true ? of : void 0,
+						limit
+					})];
+				}
+			};
+		}
+		case "capitalization": {
+			const style = rule.case;
+			if (![
+				"sentence",
+				"title",
+				"lower",
+				"upper"
+			].includes(style)) fail(`has case ${style}: use sentence, title, lower or upper`);
+			const message = rule.message === void 0 ? `"{match}" is out of ${style} case: change it, or add it to exceptions if it is a name` : said(rule.message);
+			const exceptions = rule.exceptions ?? [];
+			return {
+				...base,
+				check: ({ text, config }) => {
+					const match = outOfCase(text.primary, style, /* @__PURE__ */ new Set([...config.lint.properNouns, ...exceptions]));
+					return match === void 0 ? [] : [{
+						message: fill(message, { match }),
+						match
+					}];
+				}
+			};
+		}
+		case "conditional": {
+			const when = rule.when === void 0 ? void 0 : pattern(rule.when, "when", rule.ignoreCase);
+			const required = pattern(rule.require, "require", rule.ignoreCase);
+			const message = said(rule.message);
+			return {
+				...base,
+				check: ({ text }) => {
+					for (const v of text.variants) {
+						const match = when === void 0 ? "" : when.exec(v)?.[0];
+						if (match !== void 0 && !required.test(v)) return [fill(message, { match })];
+					}
+					return [];
+				}
+			};
+		}
+		default: return fail(`has type ${String(rule.type)}: use existence, substitution, occurrence, capitalization or conditional, or give it a check`);
+	}
+}
+/** A reason is a sentence a reviewer can check, not a shrug. */
+function reasonProblem(why) {
+	if (why.split(/\s+/).length < 4) return "is four words at least: say why the rule is wrong here";
+	if (/^(?:intentional|needed|required|ok|fine|false positive|by design|legacy|todo)\b/i.test(why)) return "names the reason, not that there is one";
+}
+/** A locale is one a rule reads when it names its language, or the locale and a region of it. */
+const readsLocale = (locales, locale, sourceLocale) => locales === void 0 ? locale === sourceLocale : locales === "all" || locales.some((l) => locale.toLowerCase() === l.toLowerCase() || locale.toLowerCase().startsWith(`${l.toLowerCase()}-`));
+function applies(rule, message, locale, sourceLocale) {
+	const { kind, surface, area, locale: locales } = rule.on ?? {};
+	return readsLocale(locales, locale, sourceLocale) && (kind === void 0 || message.kind !== void 0 && kind.includes(message.kind)) && (surface === void 0 || message.surface !== void 0 && surface.includes(message.surface)) && (area === void 0 || area.includes(message.area));
+}
+/** A rule's severity for an entry: its area's, where `lint.areas` sets one. */
+const severityOf = (config, name, message) => config.lint.areas[message.area]?.[name] ?? config.lint.rules[name]?.severity;
+/**
+* Where the message's literals are written in its text, each looked for after the one before. A
+* literal escaped in the text (`''`, `\{`) isn't written as read, so it has no place, and nor does a
+* finding in it.
+*/
+function literalsIn(ast, text) {
+	const found = [];
+	let from = 0;
+	walk(ast, (el) => {
+		if (el.type !== TYPE$1.literal || el.value === "") return;
+		const next = text.indexOf(el.value, from);
+		const start = next === -1 ? text.indexOf(el.value) : next;
+		if (start === -1) return;
+		found.push({
+			start,
+			value: el.value
+		});
+		from = start + el.value.length;
+	});
+	return found;
+}
+/** Every place `match` stands in the literals, in any case, whole where it starts or ends with a letter. */
+function placesOf(match, literals) {
+	const body = match.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/ /g, "\\s+").replace(/'/g, "['’]");
+	const before = /^[\p{L}\p{N}]/u.test(match) ? "(?<![\\p{L}\\p{N}])" : "";
+	const after = /[\p{L}\p{N}]$/u.test(match) ? "(?![\\p{L}\\p{N}])" : "";
+	const pattern = new RegExp(`${before}${body}${after}`, "giu");
+	const places = /* @__PURE__ */ new Map();
+	for (const { start, value } of literals) for (const m of value.matchAll(pattern)) places.set(start + m.index, start + m.index + m[0].length);
+	return [...places].sort(([a], [b]) => a - b).map(([start, end]) => ({
+		start,
+		end
+	}));
+}
+/** A fix in the case of what it replaces: "Colour" becomes "Color". */
+const inCaseOf = (found, fix) => /^\p{Lu}/u.test(found) && /^\p{Ll}/u.test(fix) ? fix.charAt(0).toUpperCase() + fix.slice(1) : fix;
+/** `text` with the edits made, leaving out any that overlaps one before it. */
+function applyEdits(text, edits) {
+	let out = "";
+	let at = 0;
+	for (const edit of [...edits].sort((a, b) => a.start - b.start)) {
+		if (edit.start < at) continue;
+		out += text.slice(at, edit.start) + edit.text;
+		at = edit.end;
+	}
+	return out + text.slice(at);
+}
+function lint(messages, config) {
+	const findings = [];
+	const rules = Object.entries(config.lint.rules);
+	for (const message of messages) {
+		const kind = message.kind === void 0 ? void 0 : config.kinds[message.kind];
+		const source = readings(message.ast);
+		const locales = [{
+			locale: config.source,
+			ast: message.ast,
+			written: message.text,
+			file: message.file
+		}, ...[...message.translations].map(([locale, t]) => ({
+			locale,
+			ast: t.ast,
+			written: t.text,
+			file: t.file
+		}))];
+		const fired = /* @__PURE__ */ new Set();
+		for (const { locale, ast, written, file } of locales) {
+			const context = {
+				message,
+				locale,
+				ast,
+				kind,
+				text: locale === config.source ? source : readings(ast),
+				source,
+				config
+			};
+			let literals;
+			for (const [name, { rule }] of rules) {
+				const severity = severityOf(config, name, message);
+				if (severity === "off" || !applies(rule, message, locale, config.source)) continue;
+				let said;
+				try {
+					said = rule.check(context);
+				} catch (cause) {
+					throw new Error(`lint rule ${name} failed on ${message.key} in ${locale}: fix or turn off the rule`, { cause });
+				}
+				if (said.length === 0) continue;
+				fired.add(name);
+				if (message.allow.has(name)) continue;
+				for (const s of said) {
+					const { message: text, match, fix } = typeof s === "string" ? { message: s } : s;
+					const finding = {
+						key: message.key,
+						file,
+						locale,
+						rule: name,
+						severity,
+						message: text
+					};
+					if (match !== void 0 && match !== "") {
+						literals ??= literalsIn(ast, written);
+						const places = placesOf(match, literals);
+						if (places.length > 0) finding.at = places[0];
+						if (places.length > 0 && fix !== void 0) finding.fix = places.map((p) => ({
+							...p,
+							text: inCaseOf(written.slice(p.start, p.end), fix)
+						}));
+					}
+					findings.push(finding);
+				}
+			}
+		}
+		for (const [name, why] of message.allow) {
+			const at = {
+				key: message.key,
+				file: message.file,
+				locale: config.source,
+				rule: "allow",
+				severity: "error"
+			};
+			if (config.lint.rules[name] === void 0) findings.push({
+				...at,
+				message: `allow.${name} is not a rule: ${rules.map(([n]) => n).join(", ")}`
+			});
+			else if (severityOf(config, name, message) === "off") continue;
+			else if (!fired.has(name)) findings.push({
+				...at,
+				message: `allow.${name} exempts the entry from a rule it passes: remove it`
+			});
+			else {
+				const problem = reasonProblem(why);
+				if (problem !== void 0) findings.push({
+					...at,
+					message: `allow.${name} ${problem}`
+				});
+			}
+		}
+	}
+	return findings;
+}
+// src/tools/presets.ts
+const DEFAULT_KINDS = {
+	name: {
+		doc: "Identifies a thing so it can be found again. One to four words, a noun phrase, no period.",
+		maxWords: 4,
+		period: "never",
+		sentenceCase: true,
+		bare: true
+	},
+	action: {
+		doc: "Says what pressing it does. One to three words, verb first, no period.",
+		maxWords: 3,
+		period: "never",
+		sentenceCase: true
+	},
+	description: {
+		doc: "Adds only what the name cannot carry. One sentence, two at most, with a period.",
+		maxSentences: 2,
+		period: "always"
+	},
+	state: {
+		doc: "Reports what is true right now. One sentence, present tense; on an error or empty state, one more saying what to do.",
+		maxSentences: 1,
+		maxSentencesOn: {
+			error: 2,
+			empty: 2,
+			hint: 2,
+			status: 2
+		},
+		period: [
+			"hint",
+			"status",
+			"error",
+			"empty",
+			"confirm"
+		]
+	}
+};
+const DEFAULT_SURFACES = {
+	action: "The text of a button or a menu entry.",
+	aria: "Reached only by a screen reader, so nothing on screen carries it.",
+	choice: "One option among a set offered together.",
+	confirm: "The question of a confirmation, or the verb that answers it.",
+	empty: "Fills a list or a panel that has nothing in it.",
+	error: "Says what failed.",
+	heading: "Heads a section, group, dialog or list.",
+	hint: "A subordinate line under the thing it qualifies.",
+	label: "Names a control, a field, a section or a destination.",
+	placeholder: "Sits inside an empty field, and goes when typing starts.",
+	status: "Reports what is true right now, on a badge or beside a row.",
+	title: "The title of a page, window or document.",
+	toast: "A notification that comes and goes.",
+	tooltip: "Appears on hover."
+};
+/** The word lists of the strict preset: filler, marketing and reassurance, and American spelling. */
+const STRICT_LISTS = {
+	banned: [
+		{
+			words: [
+				"seamless",
+				"seamlessly",
+				"effortless",
+				"effortlessly",
+				"hassle-free",
+				"frictionless"
+			],
+			why: "promises a feeling rather than saying what happens"
+		},
+		{
+			words: [
+				"leverage",
+				"leverages",
+				"leveraging",
+				"utilize",
+				"utilizes",
+				"utilizing",
+				"harness",
+				"take advantage of"
+			],
+			why: "is a long way to say use"
+		},
+		{
+			words: [
+				"delve",
+				"dive into",
+				"deep dive",
+				"embark",
+				"journey",
+				"tapestry",
+				"realm",
+				"landscape",
+				"testament",
+				"synergy",
+				"paradigm",
+				"holistic"
+			],
+			why: "is filler, not a thing on the screen"
+		},
+		{
+			words: [
+				"robust",
+				"powerful",
+				"cutting-edge",
+				"state-of-the-art",
+				"best-in-class",
+				"world-class",
+				"next-generation",
+				"revolutionary",
+				"game-changing"
+			],
+			why: "is marketing: say what it does"
+		},
+		{
+			words: [
+				"streamline",
+				"streamlined",
+				"empower",
+				"unlock",
+				"unleash",
+				"elevate",
+				"supercharge",
+				"boost",
+				"enhance",
+				"enhanced"
+			],
+			why: "claims an improvement without naming it"
+		},
+		{
+			words: [
+				"meticulous",
+				"crucial",
+				"pivotal",
+				"vital",
+				"paramount"
+			],
+			why: "tells the reader how to feel instead of what it is"
+		},
+		{
+			words: [
+				"comprehensive",
+				"myriad",
+				"plethora",
+				"a variety of",
+				"a wide range of"
+			],
+			why: "is padding: name the things, or say how many"
+		},
+		{
+			words: [
+				"furthermore",
+				"moreover",
+				"additionally",
+				"in order to",
+				"please note",
+				"note that",
+				"keep in mind",
+				"rest assured"
+			],
+			why: "is a connective a short string has no room for"
+		},
+		{
+			words: [
+				"intuitive",
+				"sleek",
+				"stunning",
+				"beautiful",
+				"delightful",
+				"magical"
+			],
+			why: "grades the product instead of describing it"
+		},
+		{
+			words: [
+				"simply",
+				"just",
+				"easily",
+				"easy",
+				"quickly"
+			],
+			why: "says it is easy, which helps nobody it is not easy for"
+		},
+		{
+			words: [
+				"so you can",
+				"allows you to",
+				"lets you",
+				"enables you to",
+				"don't worry"
+			],
+			why: "justifies or reassures: state the fact"
+		},
+		{
+			words: [
+				"please",
+				"oops",
+				"whoops",
+				"sorry"
+			],
+			why: "pleads or apologizes: say what failed and what to do"
+		},
+		{
+			words: [
+				"etc",
+				"and more",
+				"and so on"
+			],
+			why: "trails off: name the things or stop"
+		}
+	],
+	spelling: {
+		colour: "color",
+		colours: "colors",
+		behaviour: "behavior",
+		favourite: "favorite",
+		cancelled: "canceled",
+		cancelling: "canceling",
+		labelled: "labeled",
+		centre: "center",
+		licence: "license",
+		grey: "gray",
+		organise: "organize",
+		recognise: "recognize",
+		customise: "customize",
+		optimise: "optimize",
+		minimise: "minimize",
+		maximise: "maximize",
+		synchronise: "synchronize",
+		authorise: "authorize",
+		initialise: "initialize",
+		analyse: "analyze",
+		catalogue: "catalog",
+		dialogue: "dialog",
+		artefact: "artifact",
+		judgement: "judgment",
+		whilst: "while",
+		amongst: "among"
+	}
+};
+// src/tools/config.ts
+/**
+* `prosebook/config`: where the catalog lives, what an entry may say about itself, and how strictly
+* its words are checked. Written as `prosebook.config.ts` (or `.js`, `.mjs`, `.json`) at the project root.
+*/
+/** Typed config, for `prosebook.config.ts`. */
+function defineConfig(config) {
+	return config;
+}
+const CONFIG_FILES = [
+	"prosebook.config.ts",
+	"prosebook.config.mts",
+	"prosebook.config.js",
+	"prosebook.config.mjs",
+	"prosebook.config.json"
+];
+/** Finds and reads the config at `root`, or the defaults when there is none. */
+async function loadConfig(root, inline) {
+	if (inline) return resolveConfig(root, inline);
+	for (const name of CONFIG_FILES) {
+		const path = join(root, name);
+		if (!existsSync(path)) continue;
+		if (name.endsWith(".json")) return resolveConfig(root, JSON.parse(readFileSync(path, "utf8")));
+		return resolveConfig(root, (await import(pathToFileURL(path).href)).default ?? {});
+	}
+	return resolveConfig(root, {});
+}
+function resolveConfig(root, config) {
+	const at = (path) => isAbsolute(path) ? path : resolve(root, path);
+	const lint = config.lint ?? {};
+	const strict = (lint.extends ?? "recommended") === "strict";
+	const rules = lintRules(lint);
+	for (const [area, severities] of Object.entries(lint.areas ?? {})) for (const name of Object.keys(severities)) if (!(name in rules)) throw new Error(`lint.areas.${area}.${name} is not a rule: name one of ${Object.keys(rules).join(", ")}`);
+	return {
+		root,
+		catalog: at(config.catalog ?? "copy/catalog"),
+		locales: at(config.locales ?? "copy/locales"),
+		out: at(config.out ?? "src/copy"),
+		lock: at(config.lock ?? "copy/lock.json"),
+		source: config.source ?? "en",
+		messageFormat: config.messageFormat ?? 1,
+		bundled: config.bundled ?? [],
+		pseudo: config.pseudo ?? false,
+		stale: config.stale ?? "use",
+		language: config.language ?? "ts",
+		importExtension: config.importExtension ?? ".js",
+		require: config.require ?? ["context"],
+		kinds: config.kinds ?? DEFAULT_KINDS,
+		surfaces: config.surfaces ?? DEFAULT_SURFACES,
+		lint: {
+			rules,
+			areas: lint.areas ?? {},
+			banned: [...strict ? STRICT_LISTS.banned : [], ...lint.banned ?? []],
+			spelling: {
+				...strict ? STRICT_LISTS.spelling : {},
+				...lint.spelling
+			},
+			concepts: { ...lint.concepts },
+			properNouns: lint.properNouns ?? [],
+			pathSeparator: lint.pathSeparator ?? "›"
+		},
+		scan: {
+			dirs: (config.scan?.dirs ?? ["src"]).map(at),
+			extensions: config.scan?.extensions ?? [
+				".ts",
+				".tsx",
+				".js",
+				".jsx",
+				".mts",
+				".mjs"
+			],
+			attributes: config.scan?.attributes ?? [
+				"alt",
+				"title",
+				"placeholder",
+				"label",
+				"aria-label",
+				"aria-description",
+				"aria-placeholder"
+			]
+		}
+	};
+}
+function lintRules(lint) {
+	const base = lint.extends ?? "recommended";
+	const all = Object.entries(CORE_RULES);
+	const seen = /* @__PURE__ */ new Set();
+	for (const plugin of lint.plugins ?? []) {
+		if (!/^[a-z][a-z0-9-]*$/i.test(plugin.name)) throw new Error(`lint.plugins: "${plugin.name}" is not a plugin name: use letters, digits and dashes`);
+		if (seen.has(plugin.name)) throw new Error(`lint.plugins: "${plugin.name}" is added twice: remove one`);
+		seen.add(plugin.name);
+		for (const [name, rule] of Object.entries(plugin.rules)) {
+			const full = `${plugin.name}/${name}`;
+			all.push([full, compileRule(full, rule)]);
+		}
+	}
+	const preset = (rule) => base === "none" ? "off" : base === "strict" ? rule.strict ?? "error" : rule.recommended ?? "off";
+	const rules = Object.fromEntries(all.map(([name, rule]) => [name, {
+		rule,
+		severity: lint.rules?.[name] ?? preset(rule)
+	}]));
+	for (const name of Object.keys(lint.rules ?? {})) if (!(name in rules)) throw new Error(`lint.rules.${name} is not a rule: name one of ${Object.keys(rules).join(", ")}`);
+	return rules;
+}
+export { numberOptions as C, walk as D, tagsOf as E, formatsOf as S, staticLiteral as T, words as _, DEFAULT_KINDS as a, dateOptions as b, CORE_RULES as c, compileRule as d, definePlugin as f, singularOf as g, sentences as h, resolveConfig as i, HOLE as l, phrase as m, defineConfig as n, DEFAULT_SURFACES as o, lint as p, loadConfig as r, STRICT_LISTS as s, CONFIG_FILES as t, applyEdits as u, TYPE$1 as v, parseMessage as w, formatProblems as x, argsOf as y };
+
+//# sourceMappingURL=config-D--RITk2.js.map