prosebook 0.0.1 → 0.2.0

package/dist/sarif-CI8HOokm.js

@@ -0,0 +1,1033 @@
+import { n as flatten, t as createHelpers } from "./helpers-BPuPGjQP.js";
+import { E as tagsOf, g as singularOf, w as parseMessage, y as argsOf } from "./config-D--RITk2.js";
+import { E as localeExpression, I as readMessage, L as writeMessage, M as loadCatalog, O as CatalogError, T as compileLocale, a as looksLikeCode, k as KEY_PATTERN } from "./scan-Ch2BfIUD.js";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { Scalar, isMap, parseDocument, stringify } from "yaml";
+import { parseSync } from "oxc-parser";
+// src/tools/types.ts
+/**
+* What kind of value an expression in JSX holds, so `extract` can write `{n, number}` for a number and
+* `{d, date, medium}` for a date instead of a bare `{x}`, which is text and prints a number unformatted.
+*
+* The project's own TypeScript (7 or later, through its `unstable/async` API) answers where it can; the
+* syntax of the expression answers where it can't: a JavaScript project, a file outside any tsconfig,
+* or no TypeScript installed. Not the `unstable/sync` API: on Linux and macOS it reads the compiler's
+* pipes through a Node internal (`stdout._handle.fd`) that Bun doesn't have, so under Bun it throws.
+*/
+/** The nearest `tsconfig.json` at or above the file's folder. */
+function tsconfigFor(file) {
+	for (let dir = dirname(resolve(file));; dir = dirname(dir)) {
+		const candidate = join(dir, "tsconfig.json");
+		if (existsSync(candidate)) return candidate;
+		if (dirname(dir) === dir) return void 0;
+	}
+}
+const ANY_OR_UNKNOWN = 3;
+const NUMBER_LIKE = 71872;
+const STRING_LIKE = 12583968;
+const UNION = 134217728;
+const OBJECT = 1048576;
+/**
+* An oracle over the projects the files belong to, or nothing where TypeScript 7 isn't installed or
+* none of the files has a tsconfig. One compiler process serves every project and is closed by `close`.
+*/
+async function typescriptOracle(root, files) {
+	const configs = [...new Set(files.map(tsconfigFor).filter((c) => c !== void 0))];
+	if (configs.length === 0) return void 0;
+	let ts;
+	try {
+		ts = await import("typescript/unstable/async");
+	} catch {
+		return;
+	}
+	let api;
+	let snapshot;
+	try {
+		api = new ts.API({ cwd: root });
+		snapshot = await api.updateSnapshot({ openProjects: configs });
+	} catch {
+		return;
+	}
+	const classify = async (checker, type) => {
+		if (type === void 0) return void 0;
+		const t = await checker.getNonNullableType(type) ?? type;
+		if ((t.flags & ANY_OR_UNKNOWN) !== 0) return "unknown";
+		if ((t.flags & UNION) !== 0) {
+			const members = await t.getTypes() ?? [];
+			const kinds = new Set(await Promise.all(members.map((m) => classify(checker, m))));
+			if (kinds.size === 1) return [...kinds][0];
+			return kinds.has("node") ? "node" : "unknown";
+		}
+		if ((t.flags & NUMBER_LIKE) !== 0) return "number";
+		if ((t.flags & STRING_LIKE) !== 0) return "string";
+		if (await checker.typeToString(t) === "Date") return "date";
+		if ((t.flags & OBJECT) !== 0) return "node";
+		return "unknown";
+	};
+	return {
+		source: "TypeScript",
+		async kinds(file, spans) {
+			const project = await snapshot.getDefaultProjectForFile(resolve(file));
+			const sourceFile = await project?.program.getSourceFile(resolve(file));
+			if (project === void 0 || sourceFile === void 0) return spans.map(() => void 0);
+			const nodes = spans.map(({ start, end }) => {
+				let node = sourceFile;
+				for (;;) {
+					let next;
+					node.forEachChild((child) => {
+						if (next === void 0 && child.pos <= start && child.end >= end) next = child;
+					});
+					if (next === void 0) return node;
+					node = next;
+				}
+			});
+			const types = await project.checker.getTypeAtLocation(nodes);
+			return Promise.all(types.map((type) => classify(project.checker, type)));
+		},
+		close() {
+			return api.close();
+		}
+	};
+}
+/** The kind an expression's syntax gives away, where it does: `items.length`, `a * b`, `new Date()`. */
+function syntaxKind(expr) {
+	switch (expr.type) {
+		case "Literal": return typeof expr.value === "number" ? "number" : typeof expr.value === "string" ? "string" : void 0;
+		case "TemplateLiteral": return "string";
+		case "MemberExpression": return !expr.computed && [
+			"length",
+			"size",
+			"count"
+		].includes(expr.property?.name) ? "number" : void 0;
+		case "BinaryExpression": return [
+			"-",
+			"*",
+			"/",
+			"%",
+			"**"
+		].includes(expr.operator) ? "number" : void 0;
+		case "NewExpression": return expr.callee?.type === "Identifier" && expr.callee.name === "Date" ? "date" : void 0;
+		case "CallExpression": return expr.callee?.type === "MemberExpression" && expr.callee.object?.name === "Math" ? "number" : void 0;
+		default: return;
+	}
+}
+// src/tools/extract.ts
+/**
+* `prosebook extract`: moves hardcoded JSX text into the catalog and rewrites the code to read it.
+*
+* It works on runs, not fragments. The children of an element that together make one sentence, text,
+* simple expressions and inline elements holding only text, become one message: `Hi {user.name}, <a
+* href="/x">go</a>!` is `Hi {name}, <a>go</a>!`, so a translator can reorder the whole sentence. A run
+* becomes `<Text id=… />`, which needs no hook; a readable attribute becomes `t('…')`, with `useCopy()`
+* added to its component. Keys, kinds, surfaces and contexts are suggestions, marked for review.
+*/
+const MODULE = "prosebook/react";
+const NON_PROSE = /* @__PURE__ */ new Set([
+	"code",
+	"pre",
+	"kbd",
+	"samp",
+	"script",
+	"style",
+	"svg",
+	"path",
+	"Text"
+]);
+const LETTER = /\p{L}/u;
+/** Elements that sit inside a sentence, and so become a tag in its message rather than ending it. */
+const INLINE = /* @__PURE__ */ new Set([
+	"a",
+	"abbr",
+	"b",
+	"bdi",
+	"cite",
+	"del",
+	"dfn",
+	"em",
+	"i",
+	"ins",
+	"kbd",
+	"mark",
+	"q",
+	"s",
+	"small",
+	"span",
+	"strong",
+	"sub",
+	"sup",
+	"time",
+	"u",
+	"var"
+]);
+const isInline = (name) => INLINE.has(name) || /^[A-Z]\w*Link$|^Link$/.test(name);
+/** Elements whose text has an obvious kind and surface. */
+const ROLES = {
+	button: ["action", "action"],
+	h1: ["name", "heading"],
+	h2: ["name", "heading"],
+	h3: ["name", "heading"],
+	h4: ["name", "heading"],
+	h5: ["name", "heading"],
+	h6: ["name", "heading"],
+	th: ["name", "heading"],
+	legend: ["name", "heading"],
+	caption: ["name", "heading"],
+	label: ["name", "label"],
+	option: ["name", "choice"],
+	title: ["name", "title"]
+};
+/** Readable attributes: the kind and surface their value has, and the key suffix that says which it is. */
+const ATTRIBUTE_ROLES = {
+	placeholder: [
+		void 0,
+		"placeholder",
+		"placeholder"
+	],
+	title: [
+		"name",
+		"tooltip",
+		"tooltip"
+	],
+	"aria-label": [
+		"name",
+		"aria",
+		"aria"
+	],
+	"aria-description": [
+		"description",
+		"aria",
+		"aria-description"
+	],
+	"aria-placeholder": [
+		void 0,
+		"aria",
+		"aria-placeholder"
+	],
+	alt: [
+		void 0,
+		"aria",
+		"alt"
+	],
+	label: [
+		"name",
+		"label",
+		"label"
+	]
+};
+/** The area a file's strings go in: its name in kebab case, or its folder's for an `index`. */
+function areaOf(file) {
+	let name = basename(file, extname(file));
+	if ([
+		"index",
+		"page",
+		"layout",
+		"route",
+		"main"
+	].includes(name)) name = basename(dirname(file));
+	const kebab = name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+	return kebab === "" ? "app" : kebab;
+}
+/** A key segment from the words of a message: its first four, plain ASCII, lowercase. */
+function slugOf(message) {
+	const words = message.replace(/<\/?[\w-]+>|\{[^}]*\}/g, " ").replace(/ı/g, "i").normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().split(" ").filter(Boolean).slice(0, 4);
+	return words.length === 0 ? "text" : words.join("-");
+}
+/**
+* A count followed by a plural noun, `{n, number} files`, as the plural it needs: `{n, plural, one {#
+* file} other {# files}}`. English only, and a draft: the TODO above the entry asks for a look.
+*/
+function draftPlurals(message) {
+	return message.replace(/\{(\w+), number\} (\p{L}+)(?![\p{L}'])/gu, (whole, name, word) => {
+		const one = singularOf(word);
+		return one === void 0 ? whole : `{${name}, plural, one {# ${one}} other {# ${word}}}`;
+	});
+}
+/** A message built as MF1, as the catalog writes messages: an MF2 catalog gets it in MF2. */
+function inSyntax(config, mf1) {
+	return config.messageFormat === 2 ? writeMessage(2, parseMessage(mf1), config.source) : mf1;
+}
+/** Text written literally inside an ICU message. */
+function escapeIcu(text) {
+	return text.replace(/[{}<]/g, (c) => `'${c}'`);
+}
+/** JSX text as React renders it: lines trimmed where they meet a line break, blank lines dropped. */
+function jsxText(value) {
+	const lines = value.split(/\r\n|\n|\r/);
+	let lastNonEmpty = 0;
+	lines.forEach((line, i) => {
+		if (/[^ \t]/.test(line)) lastNonEmpty = i;
+	});
+	let out = "";
+	lines.forEach((line, i) => {
+		let trimmed = line.replace(/\t/g, " ");
+		if (i !== 0) trimmed = trimmed.replace(/^ +/, "");
+		if (i !== lines.length - 1) trimmed = trimmed.replace(/ +$/, "");
+		if (trimmed === "") return;
+		out += i === lastNonEmpty ? trimmed : `${trimmed} `;
+	});
+	return out;
+}
+const SIMPLE_EXPRESSIONS = /* @__PURE__ */ new Set([
+	"Identifier",
+	"MemberExpression",
+	"CallExpression",
+	"TemplateLiteral",
+	"Literal",
+	"BinaryExpression",
+	"TSNonNullExpression",
+	"ChainExpression"
+]);
+/** A value that reads as a placeholder: no JSX and no functions inside it, which would be markup or logic. */
+function simple(expr) {
+	if (!SIMPLE_EXPRESSIONS.has(expr.type)) return false;
+	let found = false;
+	const walk = (node) => {
+		if (found) return;
+		if (/^JSX|FunctionExpression$/.test(node.type)) found = true;
+		for (const value of Object.values(node)) if (Array.isArray(value)) value.forEach((v) => isNode(v) && walk(v));
+		else if (isNode(value)) walk(value);
+	};
+	walk(expr);
+	return !found;
+}
+/** Every name bound inside a node: declarations, parameters, catch clauses, imports. With `deep` false, only its own scope's. */
+function bindingsIn(root, deep = true) {
+	const names = /* @__PURE__ */ new Set();
+	const pattern = (p) => {
+		if (!p) return;
+		if (p.type === "Identifier") names.add(p.name);
+		else if (p.type === "ObjectPattern") for (const prop of p.properties) pattern(prop.type === "RestElement" ? prop : prop.value);
+		else if (p.type === "ArrayPattern") for (const el of p.elements) pattern(el);
+		else if (p.type === "AssignmentPattern") pattern(p.left);
+		else if (p.type === "RestElement") pattern(p.argument);
+	};
+	const walk = (node, top) => {
+		if (node.type === "VariableDeclarator") pattern(node.id);
+		if (node.type === "ImportSpecifier" || node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier") pattern(node.local);
+		if ((node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") && node.id) pattern(node.id);
+		if (node.type === "CatchClause") pattern(node.param);
+		const isFunction = /Function(?:Declaration|Expression)$|^ArrowFunctionExpression$/.test(node.type);
+		if (isFunction && (deep || top)) for (const param of node.params) pattern(param);
+		if (isFunction && !deep && !top) return;
+		for (const value of Object.values(node)) if (Array.isArray(value)) {
+			for (const child of value) if (isNode(child)) walk(child, false);
+		} else if (isNode(value)) walk(value, false);
+	};
+	walk(root, true);
+	return names;
+}
+function elementName(el) {
+	const name = el.openingElement?.name;
+	return name?.type === "JSXIdentifier" ? name.name : void 0;
+}
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+/** Plans the extraction from one file: the edits and the entries, without writing anything. */
+function planFile(path, ctx) {
+	const code = readFileSync(path, "utf8");
+	const file = relative(ctx.config.root, path).replaceAll("\\", "/");
+	const plan = {
+		path,
+		file,
+		code,
+		edits: [],
+		extractions: [],
+		warnings: []
+	};
+	const { program } = parseSync(file, code);
+	const topLevel = bindingsIn(program, false);
+	const lines = code.split("\n");
+	const lineStarts = [];
+	let offset = 0;
+	for (const line of lines) {
+		lineStarts.push(offset);
+		offset += line.length + 1;
+	}
+	const position = (at) => {
+		let line = lineStarts.findIndex((s) => s > at);
+		line = line === -1 ? lineStarts.length : line;
+		return {
+			line,
+			column: at - lineStarts[line - 1] + 1
+		};
+	};
+	const ignored = (at) => {
+		const { line } = position(at);
+		return (lines[line - 1] ?? "").includes("prosebook-ignore") || (lines[line - 2] ?? "").includes("prosebook-ignore");
+	};
+	let needText = false;
+	let needUseCopy = false;
+	/** Per component, by where it starts: the call that reads the catalog there. */
+	const hooked = /* @__PURE__ */ new Map();
+	/** Children now inside a `<Text>`, which the walk does not enter. */
+	const consumed = /* @__PURE__ */ new Set();
+	/** Enclosing functions, innermost last: the component each belongs to, and whether it is one. */
+	const components = [];
+	const componentName = (fn, parent) => {
+		if (fn.id?.name) return fn.id.name;
+		if (parent?.type === "VariableDeclarator" && parent.id?.type === "Identifier") return parent.id.name;
+	};
+	const entryFor = (message, args, role, context, suffix) => {
+		for (const [key, text] of ctx.known) if (text === message && key.startsWith(`${ctx.area}.`)) return {
+			key,
+			reused: true
+		};
+		const base = `${ctx.area}.${slugOf(message)}${suffix ? `-${suffix}` : ""}`;
+		let key = base;
+		for (let n = 2; ctx.known.has(key); n++) key = `${base}-${n}`;
+		ctx.known.set(key, message);
+		const [kind, surface] = role;
+		ctx.entries.push({
+			key,
+			area: ctx.area,
+			message,
+			...kind !== void 0 && kind in ctx.config.kinds ? { kind } : {},
+			...surface !== void 0 && surface in ctx.config.surfaces ? { surface } : {},
+			context,
+			args
+		});
+		return {
+			key,
+			reused: false
+		};
+	};
+	const where = (element) => {
+		const component = components.at(-1)?.name;
+		return `${component ? `In ${component}` : `In ${file}`}${element ? `, the text of a <${element}>` : ""}.`;
+	};
+	/** The children of one element, split into runs at anything that cannot sit inside a sentence. */
+	const extractChildren = (parent, children) => {
+		const parentName = parent.type === "JSXElement" ? elementName(parent) : void 0;
+		let run = [];
+		const flush = () => {
+			if (run.length > 0) extractRun(run, parentName);
+			run = [];
+		};
+		for (const child of children) if (inlineable(child)) run.push(child);
+		else flush();
+		flush();
+	};
+	const inlineable = (child) => {
+		if (child.type === "JSXText") return true;
+		if (child.type === "JSXExpressionContainer") return simple(child.expression);
+		if (child.type === "JSXElement") {
+			const name = elementName(child);
+			if (name === void 0 || child.openingElement.selfClosing || !isInline(name)) return false;
+			return child.children.every(inlineable);
+		}
+		return false;
+	};
+	const extractRun = (run, parentName) => {
+		const blank = (n) => n.type === "JSXText" && jsxText(n.value).trim() === "";
+		const from = run.findIndex((n) => !blank(n));
+		if (from === -1) return;
+		const nodes = run.slice(from, run.findLastIndex((n) => !blank(n)) + 1);
+		if (nodes.every((n) => n.type === "JSXElement" || blank(n))) return;
+		const first = nodes[0];
+		const last = nodes.at(-1);
+		const values = /* @__PURE__ */ new Map();
+		const argDocs = {};
+		const names = /* @__PURE__ */ new Map();
+		const tags = /* @__PURE__ */ new Set();
+		const argName = (expr) => {
+			const source = code.slice(expr.start, expr.end);
+			const known = names.get(source);
+			if (known !== void 0) return known;
+			let inner = expr;
+			while (inner.type === "TSNonNullExpression" || inner.type === "ChainExpression") inner = inner.expression;
+			let name = inner.type === "Identifier" ? inner.name : inner.type === "MemberExpression" && !inner.computed && inner.property?.type === "Identifier" ? inner.property.name : "value";
+			const base = name;
+			for (let n = 2; values.has(name) || tags.has(name); n++) name = `${base}${n}`;
+			names.set(source, name);
+			values.set(name, source);
+			argDocs[name] = `TODO: what \`${source}\` holds`;
+			return name;
+		};
+		const piece = (node) => {
+			if (node.type === "JSXText") return escapeIcu(jsxText(node.value));
+			if (node.type === "JSXElement") {
+				let tag = elementName(node).toLowerCase();
+				const base = tag;
+				for (let n = 2; tags.has(tag) || values.has(tag); n++) tag = `${base}${n}`;
+				tags.add(tag);
+				const open = code.slice(node.openingElement.start, node.openingElement.end);
+				const close = code.slice(node.closingElement.start, node.closingElement.end);
+				values.set(tag, `(chunks) => ${open}{chunks}${close}`);
+				return `<${tag}>${node.children.map(piece).join("")}</${tag}>`;
+			}
+			const expr = node.expression;
+			if (expr.type === "Literal" && typeof expr.value === "string") return escapeIcu(expr.value);
+			if (expr.type === "TemplateLiteral" && expr.expressions.length === 0) return escapeIcu(expr.quasis[0].value.cooked);
+			const kind = ctx.kinds.get(`${expr.start}:${expr.end}`) ?? syntaxKind(expr);
+			if (kind === "node") markup.push(code.slice(expr.start, expr.end));
+			return `{${argName(expr)}${kind === "number" ? ", number" : kind === "date" ? ", date, medium" : ""}}`;
+		};
+		const markup = [];
+		let message = nodes.map(piece).join("").trim();
+		if (markup.length > 0) {
+			const at = position(first.start);
+			plan.warnings.push(`${file}:${at.line}:${at.column} {${markup.join("}, {")}} holds markup, not text, so this sentence was left as it is: make it a tag, or give the text around it entries of its own`);
+			return;
+		}
+		if (/^en\b/.test(ctx.config.source)) message = draftPlurals(message);
+		const words = message.replace(/\{[^}]*\}|<\/?[\w-]+>|'[{}<]'/g, "");
+		if (!LETTER.test(words) || values.size === 0 && looksLikeCode(message)) return;
+		const start = first.type === "JSXText" ? first.start + (/^\s*/.exec(first.value)?.[0].length ?? 0) : first.start;
+		const end = last.type === "JSXText" ? last.end - (/\s*$/.exec(last.value)?.[0].length ?? 0) : last.end;
+		if (ignored(start)) return;
+		message = inSyntax(ctx.config, message);
+		const role = parentName !== void 0 ? ROLES[parentName] : void 0;
+		const { key, reused } = entryFor(message, argDocs, role ?? [void 0, void 0], where(parentName));
+		const props = [...values].map(([name, source]) => `${/^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name)}: ${source}`);
+		const replacement = `<Text id=${JSON.stringify(key)}${props.length > 0 ? ` values={{ ${props.join(", ")} }}` : ""} />`;
+		plan.edits.push({
+			start,
+			end,
+			text: replacement
+		});
+		for (const n of nodes) consumed.add(n);
+		plan.extractions.push({
+			file,
+			...position(start),
+			key,
+			message,
+			reused,
+			where: "text",
+			replacement
+		});
+		needText = true;
+	};
+	const extractAttribute = (attr, element) => {
+		const name = attr.name?.type === "JSXIdentifier" ? attr.name.name : "";
+		if (!ctx.config.scan.attributes.includes(name) || attr.value === null) return;
+		const value = attr.value;
+		let text;
+		if (value.type === "Literal" && typeof value.value === "string") text = value.value;
+		else if (value.type === "JSXExpressionContainer") {
+			const expr = value.expression;
+			if (expr.type === "Literal" && typeof expr.value === "string") text = expr.value;
+			if (expr.type === "TemplateLiteral" && expr.expressions.length === 0) text = expr.quasis[0].value.cooked;
+		}
+		if (text === void 0 || !LETTER.test(text) || looksLikeCode(text) || ignored(attr.start)) return;
+		const at = position(value.start);
+		const fn = components.findLast((c) => c.isComponent)?.fn;
+		if (fn === void 0 || fn.body?.type !== "BlockStatement") {
+			plan.warnings.push(`${file}:${at.line}:${at.column} ${name}="${text}" is not inside a component with a body, so it has no t() to read; left as it is`);
+			return;
+		}
+		const call = hookFor(fn);
+		if (call === void 0) {
+			plan.warnings.push(`${file}:${at.line}:${at.column} ${name}="${text}": its component binds both \`t\` and \`copy\` already; left as it is`);
+			return;
+		}
+		const [kind, surface, suffix] = ATTRIBUTE_ROLES[name] ?? [
+			void 0,
+			void 0,
+			name
+		];
+		const tag = elementName(element) ?? "element";
+		const component = components.at(-1)?.name;
+		const context = `${component ? `In ${component}` : `In ${file}`}, the ${name} of a <${tag}>.`;
+		const message = inSyntax(ctx.config, escapeIcu(text));
+		const { key, reused } = entryFor(message, {}, [kind, surface], context, suffix);
+		const replacement = `{${call}(${JSON.stringify(key)})}`;
+		plan.edits.push({
+			start: value.start,
+			end: value.end,
+			text: replacement
+		});
+		plan.extractions.push({
+			file,
+			...at,
+			key,
+			message,
+			reused,
+			where: name,
+			replacement
+		});
+	};
+	/**
+	* Makes sure the component can read the catalog, and returns the call that does: `t` from
+	* `useCopy()`, or `copy.t` where the component or the module already binds a `t` of its own.
+	*/
+	const hookFor = (fn) => {
+		const chosen = hooked.get(fn.start);
+		if (chosen !== void 0) return chosen;
+		const taken = /* @__PURE__ */ new Set([...topLevel, ...bindingsIn(fn)]);
+		const body = code.slice(fn.body.start, fn.body.end);
+		const insert = (text) => plan.edits.push({
+			start: fn.body.start + 1,
+			end: fn.body.start + 1,
+			text
+		});
+		const firstStatement = fn.body.body[0];
+		const indent = firstStatement ? " ".repeat(position(firstStatement.start).column - 1) : "  ";
+		let call;
+		const destructured = /\{([^{}]*)\}\s*=\s*useCopy\(\)/.exec(body);
+		const whole = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*useCopy\(\)/.exec(body);
+		if (destructured !== null && /(^|[\s,])t(\s*[,}]|\s*$)/.test(destructured[1])) call = "t";
+		else if (whole !== null) call = `${whole[1]}.t`;
+		else if (destructured !== null && !taken.has("t")) {
+			const at = fn.body.start + destructured.index + 1;
+			plan.edits.push({
+				start: at,
+				end: at,
+				text: " t,"
+			});
+			call = "t";
+		} else if (!taken.has("t")) {
+			insert(`
+${indent}const { t } = useCopy();`);
+			call = "t";
+		} else if (!taken.has("copy")) {
+			insert(`
+${indent}const copy = useCopy();`);
+			call = "copy.t";
+		}
+		if (call !== void 0 && destructured === null && whole === null) needUseCopy = true;
+		if (call !== void 0) hooked.set(fn.start, call);
+		return call;
+	};
+	const visit = (node, parent) => {
+		const isFunction = node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+		if (isFunction) {
+			const own = componentName(node, parent);
+			const isComponent = own !== void 0 && /^(?:[A-Z]|use[A-Z])/.test(own);
+			components.push({
+				fn: node,
+				name: isComponent ? own : components.at(-1)?.name,
+				isComponent
+			});
+		}
+		if (node.type === "JSXElement" || node.type === "JSXFragment") {
+			const name = node.type === "JSXElement" ? elementName(node) : void 0;
+			if (node.type === "JSXElement") for (const attr of node.openingElement.attributes) {
+				if (attr.type !== "JSXAttribute") continue;
+				extractAttribute(attr, node);
+				if (attr.value?.type === "JSXExpressionContainer") visit(attr.value, attr);
+			}
+			if (name === void 0 || !NON_PROSE.has(name)) {
+				extractChildren(node, node.children);
+				for (const child of node.children) if (!consumed.has(child)) visit(child, node);
+			}
+			return;
+		}
+		for (const value of Object.values(node)) if (Array.isArray(value)) {
+			for (const child of value) if (isNode(child)) visit(child, node);
+		} else if (isNode(value)) visit(value, node);
+		if (isFunction) components.pop();
+	};
+	visit(program, void 0);
+	plan.extractions.sort((a, b) => a.line !== b.line ? a.line - b.line : a.column - b.column);
+	if (needText || needUseCopy) importEdit(program, code, plan, [...needText ? ["Text"] : [], ...needUseCopy ? ["useCopy"] : []]);
+	return plan;
+}
+/** Adds the names to an existing `prosebook/react` import, or a new import after the last one. */
+function importEdit(program, code, plan, wanted) {
+	const imports = program.body.filter((s) => s.type === "ImportDeclaration");
+	const existing = imports.find((s) => s.source.value === MODULE && s.importKind !== "type");
+	if (existing) {
+		const named = existing.specifiers.filter((s) => s.type === "ImportSpecifier");
+		const have = new Set(named.map((s) => s.local.name));
+		const missing = wanted.filter((w) => !have.has(w));
+		if (missing.length === 0) return;
+		if (named.length > 0) {
+			plan.edits.push({
+				start: named.at(-1).end,
+				end: named.at(-1).end,
+				text: `, ${missing.join(", ")}`
+			});
+			return;
+		}
+	}
+	const line = `import { ${wanted.join(", ")} } from '${MODULE}';`;
+	const last = imports.at(-1);
+	if (last) plan.edits.push({
+		start: last.end,
+		end: last.end,
+		text: `\n${line}`
+	});
+	else {
+		const directive = /^(?:\s*(['"])use \w+\1;?\s*\n)*/.exec(code)?.[0] ?? "";
+		plan.edits.push({
+			start: directive.length,
+			end: directive.length,
+			text: `${line}\n${directive === "" ? "\n" : ""}`
+		});
+	}
+}
+/** The spans of every expression inside JSX, which are the ones that may become placeholders. */
+function jsxExpressions(file, code) {
+	const spans = [];
+	const walk = (node) => {
+		if (node.type === "JSXExpressionContainer" && node.expression.type !== "JSXEmptyExpression") spans.push({
+			start: node.expression.start,
+			end: node.expression.end
+		});
+		for (const value of Object.values(node)) if (Array.isArray(value)) {
+			for (const child of value) if (isNode(child)) walk(child);
+		} else if (isNode(value)) walk(value);
+	};
+	walk(parseSync(file, code).program);
+	return spans;
+}
+/**
+* Plans an extraction over the files in `paths` against the current catalog. With `types` (the
+* default), the project's TypeScript says which placeholders are numbers and dates.
+*/
+async function planExtract(config, paths, options = {}) {
+	if (options.area !== void 0 && !KEY_PATTERN.test(`${options.area}.x`)) throw new Error(`prosebook: "${options.area}" is not an area: lowercase words joined by -`);
+	const known = /* @__PURE__ */ new Map();
+	if (existsSync(config.catalog)) try {
+		for (const m of loadCatalog(config).messages) known.set(m.key, m.text);
+	} catch (e) {
+		if (!(e instanceof CatalogError)) throw e;
+		throw new Error(`prosebook: fix the catalog before extracting into it:\n${e.message}`, { cause: e });
+	}
+	const entries = [];
+	const oracle = options.types === false ? void 0 : await typescriptOracle(config.root, paths);
+	try {
+		const files = [];
+		for (const path of paths) {
+			const kinds = /* @__PURE__ */ new Map();
+			if (oracle) {
+				const spans = jsxExpressions(path, readFileSync(path, "utf8"));
+				(await oracle.kinds(path, spans)).forEach((kind, i) => {
+					if (kind !== void 0 && kind !== "unknown") kinds.set(`${spans[i].start}:${spans[i].end}`, kind);
+				});
+			}
+			files.push(planFile(path, {
+				config,
+				area: options.area ?? areaOf(path),
+				known,
+				entries,
+				kinds
+			}));
+		}
+		return {
+			files,
+			entries,
+			types: oracle?.source ?? "syntax"
+		};
+	} finally {
+		await oracle?.close();
+	}
+}
+/** Applies a plan: rewrites the files and appends the new entries to their area's catalog file. */
+function applyExtract(config, plan) {
+	const written = [];
+	for (const file of plan.files) {
+		if (file.edits.length === 0) continue;
+		let code = file.code;
+		for (const edit of [...file.edits].sort((a, b) => a.start !== b.start ? b.start - a.start : b.end - a.end)) code = code.slice(0, edit.start) + edit.text + code.slice(edit.end);
+		writeFileSync(file.path, code);
+		written.push(file.path);
+	}
+	const byArea = /* @__PURE__ */ new Map();
+	for (const entry of plan.entries) byArea.set(entry.area, [...byArea.get(entry.area) ?? [], entry]);
+	for (const [area, entries] of byArea) {
+		const path = join(config.catalog, `${area}.yaml`);
+		const blocks = entries.map((e) => {
+			const body = {};
+			if (e.kind) body.kind = e.kind;
+			if (e.surface) body.surface = e.surface;
+			body.context = e.context;
+			if (Object.keys(e.args).length > 0) body.args = e.args;
+			body[config.source] = e.message;
+			return `# TODO(prosebook extract): check the key, kind and context.\n${stringify({ [e.key]: body }, {
+				lineWidth: 0,
+				version: "1.1"
+			})}`;
+		});
+		mkdirSync(config.catalog, { recursive: true });
+		const current = existsSync(path) ? readFileSync(path, "utf8") : "# yaml-language-server: $schema=./catalog.schema.json\n";
+		writeFileSync(path, `${current.replace(/\n*$/, "\n")}\n${blocks.join("\n")}`);
+		written.push(path);
+	}
+	return written;
+}
+// src/tools/diff.ts
+const TOKEN = /\s+|[\p{L}\p{N}_'’]+|[^\s\p{L}\p{N}_]/gu;
+/** Past this many cells the table costs more than the diff is worth: show the whole change instead. */
+const MAX_CELLS = 25e4;
+function wordDiff(before, after) {
+	const a = before.match(TOKEN) ?? [];
+	const b = after.match(TOKEN) ?? [];
+	if (a.length * b.length > MAX_CELLS) return merge([{
+		op: "del",
+		text: before
+	}, {
+		op: "add",
+		text: after
+	}]);
+	const lcs = Array.from({ length: a.length + 1 }, () => Array.from({ length: b.length + 1 }, () => 0));
+	for (let i = a.length - 1; i >= 0; i--) for (let j = b.length - 1; j >= 0; j--) lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+	const parts = [];
+	let i = 0;
+	let j = 0;
+	while (i < a.length && j < b.length) if (a[i] === b[j]) {
+		parts.push({
+			op: "same",
+			text: a[i]
+		});
+		i++;
+		j++;
+	} else if (lcs[i + 1][j] >= lcs[i][j + 1]) parts.push({
+		op: "del",
+		text: a[i++]
+	});
+	else parts.push({
+		op: "add",
+		text: b[j++]
+	});
+	while (i < a.length) parts.push({
+		op: "del",
+		text: a[i++]
+	});
+	while (j < b.length) parts.push({
+		op: "add",
+		text: b[j++]
+	});
+	return merge(parts);
+}
+/**
+* Adjacent parts of one kind joined, and a space shared by two changes folded into them, so a
+* replaced phrase reads `[-old words-]{+new words+}` rather than alternating word by word.
+*/
+function merge(parts) {
+	const out = [];
+	for (let k = 0; k < parts.length; k++) {
+		const part = parts[k];
+		const prev = out.at(-1);
+		const next = parts[k + 1];
+		if (part.op === "same" && /^\s+$/.test(part.text) && prev && prev.op !== "same" && next && next.op !== "same") {
+			out.push({
+				op: "del",
+				text: part.text
+			}, {
+				op: "add",
+				text: part.text
+			});
+			continue;
+		}
+		out.push({ ...part });
+	}
+	const joined = [];
+	for (const part of out.filter((p) => p.text !== "")) {
+		const last = joined.at(-1);
+		if (last && last.op === part.op) last.text += part.text;
+		else if (part.op === "del" && last?.op === "add" && joined.at(-2)?.op === "del") joined.at(-2).text += part.text;
+		else joined.push({ ...part });
+	}
+	return joined;
+}
+/** The diff as one line: `Save [-the-]{+a+} draft`, the notation of `git diff --word-diff`. */
+function formatDiff(parts) {
+	return parts.map((p) => p.op === "same" ? p.text : p.op === "del" ? `[-${p.text}-]` : `{+${p.text}+}`).join("");
+}
+// src/tools/migrate.ts
+/**
+* `prosebook migrate`: a catalog and its translations rewritten from one syntax to the other. Each
+* message is written in the target syntax, read back, and rendered both ways over sample values, so
+* one that can't be written, or would come out different, is reported before anything changes.
+*/
+function planMigrate(config, to) {
+	const catalog = loadCatalog(config);
+	const plan = {
+		to,
+		rewrites: [],
+		blocked: [],
+		changed: []
+	};
+	for (const m of catalog.messages) {
+		const versions = [{
+			locale: config.source,
+			text: m.text,
+			ast: m.ast,
+			file: m.file
+		}, ...[...m.translations].map(([locale, t]) => ({
+			locale,
+			text: t.text,
+			ast: t.ast,
+			file: t.file
+		}))];
+		for (const { locale, text, ast, file } of versions) {
+			const at = {
+				key: m.key,
+				locale,
+				file
+			};
+			let after;
+			let back;
+			try {
+				after = writeMessage(to, ast, locale);
+				back = readMessage(to, after, locale);
+			} catch (e) {
+				plan.blocked.push({
+					...at,
+					reason: e.message
+				});
+				continue;
+			}
+			const difference = firstDifference(ast, back, locale);
+			if (difference !== void 0) plan.changed.push({
+				...at,
+				...difference
+			});
+			if (after !== text) plan.rewrites.push({
+				...at,
+				before: text,
+				after
+			});
+		}
+	}
+	return plan;
+}
+/** Writes the plan's rewrites into the YAML files, keeping their comments and layout. Returns the files written. */
+function applyMigrate(config, plan) {
+	if (plan.blocked.length > 0) throw new Error("prosebook: some messages have no equivalent in the target syntax; nothing was written");
+	const byFile = Map.groupBy(plan.rewrites, (r) => r.file);
+	for (const [file, rewrites] of byFile) {
+		const path = join(config.root, file);
+		const doc = parseDocument(readFileSync(path, "utf8"), { version: "1.1" });
+		for (const r of rewrites) {
+			const value = doc.createNode(r.after);
+			if (r.after.includes("\n")) value.type = Scalar.BLOCK_LITERAL;
+			const entry = doc.get(r.key, true);
+			if (isMap(entry)) entry.set(config.source, value);
+			else doc.set(r.key, value);
+		}
+		writeFileSync(path, doc.toString({ lineWidth: 0 }));
+	}
+	return [...byFile.keys()];
+}
+const NUMBERS = [
+	0,
+	1,
+	2,
+	3,
+	5,
+	11,
+	21,
+	101,
+	1.5,
+	1234.5
+];
+const DATE = new Date(Date.UTC(2026, 0, 5, 14, 30, 15));
+function samplesOf(type) {
+	if (type === "number") return NUMBERS;
+	if (type === "Date | number") return [DATE];
+	const named = [...type.matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((m) => JSON.parse(`"${m[1]}"`));
+	return named.length > 0 ? [...named, "zzz"] : ["Ada"];
+}
+/** Every combination of sample values, or each argument varied alone where there are too many. */
+function* samples(a, b) {
+	const types = /* @__PURE__ */ new Map();
+	for (const [name, type] of [...argsOf(a), ...argsOf(b)]) {
+		const set = types.get(name) ?? /* @__PURE__ */ new Set();
+		for (const value of samplesOf(type)) set.add(value);
+		types.set(name, set);
+	}
+	const tags = Object.fromEntries([.../* @__PURE__ */ new Set([...tagsOf(a), ...tagsOf(b)])].map((t) => [t, (c) => `<${t}>${c.join("")}</${t}>`]));
+	const names = [...types.keys()];
+	const lists = names.map((n) => [...types.get(n)]);
+	if (lists.reduce((n, l) => n * l.length, 1) <= 1e3) {
+		let combos = [[]];
+		for (const list of lists) combos = combos.flatMap((c) => list.map((v) => [...c, v]));
+		for (const combo of combos) yield {
+			...tags,
+			...Object.fromEntries(names.map((n, i) => [n, combo[i]]))
+		};
+		return;
+	}
+	const base = Object.fromEntries(names.map((n, i) => [n, lists[i][0]]));
+	for (const [i, n] of names.entries()) for (const value of lists[i]) yield {
+		...tags,
+		...base,
+		[n]: value
+	};
+}
+function renderer(ast, locale) {
+	const message = new Function(`return ${localeExpression(compileLocale([["m", ast]]))};`)().m;
+	const h = createHelpers(locale);
+	return (values) => typeof message === "string" ? message : flatten(message(values, h)).join("");
+}
+function firstDifference(a, b, locale) {
+	const before = renderer(a, locale);
+	const after = renderer(b, locale);
+	for (const values of samples(a, b)) {
+		const x = before(values);
+		const y = after(values);
+		if (x !== y) return {
+			values: `{ ${Object.entries(values).filter(([, v]) => typeof v !== "function").map(([k, v]) => `${k}: ${v instanceof Date ? v.toISOString() : JSON.stringify(v)}`).join(", ")} }`,
+			before: x,
+			after: y
+		};
+	}
+}
+// src/tools/sarif.ts
+/**
+* Findings as SARIF 2.1.0, the static-analysis format code scanning reads (GitHub's among them), so
+* `lint`, `scan`, `status` and `check` can annotate a pull request on the line the string is written.
+*
+* Paths are relative to the project root under `%SRCROOT%`, which the log maps to the root itself:
+* a project that isn't at the top of its repository still resolves to the right files.
+*/
+/** Collects what a command found, then writes it as one SARIF run. */
+var SarifReport = class {
+	results = [];
+	rules = /* @__PURE__ */ new Map();
+	/** Describes a rule in one sentence; the first description given for an id stands. */
+	rule(id, description) {
+		if (this.rules.get(id) === void 0) this.rules.set(id, description);
+	}
+	add(result) {
+		if (!this.rules.has(result.rule)) this.rules.set(result.rule, void 0);
+		this.results.push(result);
+	}
+	toJSON(root, tool) {
+		const ids = [...this.rules.keys()];
+		return {
+			$schema: "https://json.schemastore.org/sarif-2.1.0.json",
+			version: "2.1.0",
+			runs: [{
+				tool: { driver: {
+					...tool,
+					rules: ids.map((id) => {
+						const description = this.rules.get(id);
+						return description === void 0 ? { id } : {
+							id,
+							shortDescription: { text: description }
+						};
+					})
+				} },
+				originalUriBaseIds: { "%SRCROOT%": { uri: pathToFileURL(root).href.replace(/\/?$/, "/") } },
+				results: this.results.map((r) => ({
+					ruleId: r.rule,
+					ruleIndex: ids.indexOf(r.rule),
+					level: r.level,
+					message: { text: r.message },
+					locations: r.file === void 0 ? [] : [location(r.file, r.line, r.column)]
+				}))
+			}]
+		};
+	}
+};
+function location(file, line, column) {
+	return { physicalLocation: {
+		artifactLocation: {
+			uri: encodeURI(file),
+			uriBaseId: "%SRCROOT%"
+		},
+		...line === void 0 ? {} : { region: {
+			startLine: line,
+			startColumn: column ?? 1
+		} }
+	} };
+}
+export { wordDiff as a, draftPlurals as c, syntaxKind as d, typescriptOracle as f, formatDiff as i, planExtract as l, applyMigrate as n, applyExtract as o, planMigrate as r, areaOf as s, SarifReport as t, slugOf as u };
+
+//# sourceMappingURL=sarif-CI8HOokm.js.map