@menapo/vi18n 0.0.0-stage → 0.1.1

package/dist/lint.js

@@ -0,0 +1,971 @@
+import { r as DEFAULT_IMPORT_SOURCES } from "./types-D3QGM8XO.js";
+import { f as parseICU, p as quoteStarts, u as normalizeSource } from "./validate-BxpupdAf.js";
+import { t as createCodec } from "./codec-DuvU2VQy.js";
+import { t as VERSION } from "./version-Byqi2guX.js";
+import { a as isIgnored, i as findMarkers, n as sourceSpecifiers, r as scanModule } from "./sources-D19czDSA.js";
+import { t as findCapturedValues } from "./captured-Bj8bO6vd.js";
+import { extname } from "node:path";
+//#region src/lint/analysis.ts
+/**
+* What every `/lint` rule reads of a file, computed once per file: the
+* settings, the marker comments, and the extraction scan itself, run on the
+* linter's tree. Rules that mirror build errors and warnings therefore agree
+* with `vite build` and `vi18n extract` on which calls are messages (import
+* bindings, wrappers, aliases, globals, shadowing, descriptors).
+*/
+const FRAMEWORKS = /* @__PURE__ */ new Set([
+	"react",
+	"preact",
+	"vue",
+	"svelte",
+	"solid"
+]);
+const SETTINGS_KEYS = /* @__PURE__ */ new Set([
+	"importSources",
+	"aliases",
+	"globals",
+	"sourceLocale",
+	"root",
+	"framework"
+]);
+/** Callee kinds whose result is text (as `src/core/extract/captured.ts` counts them). */
+const TRANSLATING = /* @__PURE__ */ new Set([
+	"t",
+	"rich",
+	"richHtml",
+	"richParts",
+	"alias",
+	"global",
+	"translator"
+]);
+const codec = createCodec(12);
+function strings$1(value, key) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new Error(`vi18n lint: settings.vi18n.${key} must be an array of strings`);
+	return value;
+}
+const settingsCache = /* @__PURE__ */ new Map();
+function settingsOf(context) {
+	const raw = context.settings?.vi18n ?? {};
+	const cwd = context.cwd ?? process.cwd();
+	const key = `${cwd}\0${JSON.stringify(raw)}`;
+	const known = settingsCache.get(key);
+	if (known !== void 0) return known;
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new Error("vi18n lint: settings.vi18n must be an object");
+	const input = raw;
+	for (const name of Object.keys(input)) if (!SETTINGS_KEYS.has(name)) throw new Error(`vi18n lint: unknown setting settings.vi18n.${name}; expected one of ${[...SETTINGS_KEYS].join(", ")}`);
+	for (const name of [
+		"sourceLocale",
+		"root",
+		"framework"
+	]) if (input[name] !== void 0 && typeof input[name] !== "string") throw new Error(`vi18n lint: settings.vi18n.${name} must be a string`);
+	const framework = input.framework ?? null;
+	if (framework !== null && !FRAMEWORKS.has(framework)) throw new Error(`vi18n lint: settings.vi18n.framework must be one of ${[...FRAMEWORKS].join(", ")}`);
+	const settings = {
+		importSources: strings$1(input.importSources, "importSources"),
+		aliases: strings$1(input.aliases, "aliases"),
+		globals: strings$1(input.globals, "globals"),
+		sourceLocale: input.sourceLocale ?? "en",
+		root: input.root ?? cwd,
+		framework
+	};
+	settingsCache.set(key, settings);
+	return settings;
+}
+const sourceConfigs = /* @__PURE__ */ new WeakMap();
+/** The config slice `sourceSpecifiers` reads (it caches per object, so one per settings). */
+function sourceConfig(settings) {
+	let config = sourceConfigs.get(settings);
+	if (config === void 0) {
+		config = {
+			root: settings.root,
+			extraction: {
+				importSources: [...DEFAULT_IMPORT_SOURCES, ...settings.importSources],
+				aliases: settings.aliases,
+				globals: settings.globals,
+				keep: [],
+				dependencies: []
+			}
+		};
+		sourceConfigs.set(settings, config);
+	}
+	return config;
+}
+/** Keys of linter nodes that the scan must not walk: back links and positions it re-reads as `start`/`end`. */
+const DROPPED = /* @__PURE__ */ new Set([
+	"parent",
+	"loc",
+	"range",
+	"start",
+	"end",
+	"tokens",
+	"comments"
+]);
+/**
+* The linter's tree as the scan reads Oxc's: `start`/`end` from `range`, no
+* `parent` (the scan walks every key of node types it does not list).
+* Iterative, since `a + b + …` nests deeply. String literals are indexed on
+* the way.
+*/
+function scanTree(root, literals) {
+	const copy = (node) => ({
+		type: node.type,
+		start: node.range[0],
+		end: node.range[1]
+	});
+	const out = copy(root);
+	const stack = [[root, out]];
+	for (let entry = stack.pop(); entry !== void 0; entry = stack.pop()) {
+		const [node, target] = entry;
+		if (node.type === "Literal" && typeof node.value === "string" || node.type === "TemplateLiteral" && node.expressions.length === 0) literals.set(node.range[0], node);
+		for (const key in node) {
+			if (key === "type" || DROPPED.has(key)) continue;
+			const value = node[key];
+			if (Array.isArray(value)) target[key] = value.map((item) => {
+				if (!isNode(item)) return item;
+				const child = copy(item);
+				stack.push([item, child]);
+				return child;
+			});
+			else if (isNode(value)) {
+				const child = copy(value);
+				stack.push([value, child]);
+				target[key] = child;
+			} else target[key] = value;
+		}
+	}
+	return out;
+}
+function isNode(value) {
+	return value !== null && typeof value === "object" && typeof value.type === "string" && Array.isArray(value.range);
+}
+function langOf(filename) {
+	switch (extname(filename).toLowerCase()) {
+		case ".ts":
+		case ".mts":
+		case ".cts": return "ts";
+		case ".tsx": return "tsx";
+		case ".jsx": return "jsx";
+		default: return "js";
+	}
+}
+function commentsOf(context) {
+	return context.sourceCode.getAllComments().map((comment) => {
+		const range = comment.range ?? [comment.start ?? 0, comment.end ?? 0];
+		return {
+			type: comment.type,
+			value: comment.value,
+			start: range[0],
+			end: range[1]
+		};
+	});
+}
+function lineStartsOf(code) {
+	const starts = [0];
+	for (let i = code.indexOf("\n"); i !== -1; i = code.indexOf("\n", i + 1)) starts.push(i + 1);
+	return starts;
+}
+/** Whether a module's top level is module code: an export in an SFC script means `<script>` or `<script module>`. */
+function exports(ast) {
+	return ast.body.some((statement) => statement.type === "ExportDefaultDeclaration" || statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration");
+}
+function frameworkOf(settings, extension, specifiers) {
+	if (extension === ".astro") return "astro";
+	if (extension === ".vue") return "vue";
+	if (extension === ".svelte") return "svelte";
+	if (settings.framework !== null) return settings.framework;
+	const from = (name) => specifiers.some((s) => s === name || s.startsWith(`${name}/`));
+	if (from("solid-js")) return "solid";
+	if (from("vue")) return "vue";
+	if (from("preact")) return "preact";
+	return "react";
+}
+const cache = /* @__PURE__ */ new WeakMap();
+function analyse(context) {
+	const { sourceCode } = context;
+	const known = cache.get(sourceCode.ast);
+	if (known !== void 0) return known;
+	const code = sourceCode.text;
+	const settings = settingsOf(context);
+	const comments = code.includes("vi18n-") ? commentsOf(context) : [];
+	const markers = findMarkers(code, sourceCode.ast, comments);
+	const extension = extname(context.filename).toLowerCase();
+	const literals = /* @__PURE__ */ new Map();
+	const imports = [];
+	for (const statement of sourceCode.ast.body) {
+		if (statement.type !== "ImportDeclaration") continue;
+		const specifier = statement.source.value;
+		if (typeof specifier === "string") imports.push({
+			specifier,
+			start: 0,
+			end: 0,
+			bindings: []
+		});
+	}
+	const specifiers = sourceSpecifiers(imports, context.filename, sourceConfig(settings));
+	const sfc = extension === ".vue" || extension === ".svelte" || extension === ".astro";
+	let scan = null;
+	let parsed = null;
+	if (specifiers.size > 0 || settings.globals.length > 0) {
+		const program = scanTree(sourceCode.ast, literals);
+		parsed = {
+			code,
+			lang: langOf(context.filename),
+			program,
+			comments
+		};
+		scan = scanModule(parsed, {
+			codec,
+			refFile: context.filename,
+			sourceSpecifiers: specifiers,
+			aliases: settings.aliases,
+			globals: settings.globals,
+			moduleScope: "warn",
+			warnings: true,
+			exactPositions: true,
+			sourceLocale: settings.sourceLocale,
+			ranges: true
+		});
+	}
+	const translating = /* @__PURE__ */ new Map();
+	for (const call of scan?.calls ?? []) if (TRANSLATING.has(call.kind) && call.callStart !== void 0 && call.callEnd !== void 0) translating.set(call.callStart, call.callEnd);
+	const analysis = {
+		code,
+		settings,
+		markers,
+		scan,
+		parsed,
+		literals,
+		translating,
+		component: extension === ".astro" || sfc && !exports(sourceCode.ast),
+		framework: frameworkOf(settings, extension, imports.map((record) => record.specifier)),
+		lineStarts: lineStartsOf(code)
+	};
+	cache.set(sourceCode.ast, analysis);
+	return analysis;
+}
+/** Whether `vi18n-ignore` covers the node. */
+function ignored(analysis, node) {
+	return analysis.markers.ignored.length > 0 && isIgnored(analysis.markers, node.range[0]);
+}
+const WRAPPERS = /* @__PURE__ */ new Set([
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSNonNullExpression",
+	"TSTypeAssertion",
+	"ChainExpression"
+]);
+/** The expression under TypeScript-only wrappers and `?.` chains. */
+function unwrap(node) {
+	let current = node;
+	while (WRAPPERS.has(current.type)) current = current.expression;
+	return current;
+}
+/** Whether the node is a call that renders a message (`t`, `rich*`, a translator's or an alias). */
+function isTranslating(analysis, node) {
+	const call = unwrap(node);
+	return call.type === "CallExpression" && analysis.translating.get(call.range[0]) === call.range[1];
+}
+/** The offset of a 1-based line and column of `analysis.code`. */
+function offsetOf(analysis, line, column) {
+	return (analysis.lineStarts[line - 1] ?? 0) + column - 1;
+}
+/** Reports at an offset range of the file. */
+function reportRange(context, range, messageId, data, fix) {
+	const { sourceCode } = context;
+	context.report({
+		loc: {
+			start: sourceCode.getLocFromIndex(range[0]),
+			end: sourceCode.getLocFromIndex(range[1])
+		},
+		messageId,
+		...data === void 0 ? {} : { data },
+		...fix === void 0 ? {} : { fix }
+	});
+}
+const DOCS = "https://github.com/menapo/kit/blob/main/packages/vi18n/docs/guide/lint.md";
+/** Rule docs link: the guide's section of that rule. */
+function docs(rule, description, recommended = true) {
+	return {
+		description,
+		recommended,
+		url: `${DOCS}#${rule}`
+	};
+}
+//#endregion
+//#region src/lint/rules/no-concatenation.ts
+/**
+* `no-concatenation`: translated text joined with other text in code, which
+* fixes the word order for every language and splits one sentence into
+* pieces a translator sees apart (PLAN §5.21). Covers `+`, template
+* literals, `concat()`, `[…].join()`, and a translation next to text or
+* another translation in JSX. Tagged templates (`html\`…\``) build markup,
+* not sentences, and are left alone.
+*/
+function report(context, analysis, node) {
+	if (!ignored(analysis, node)) context.report({
+		node,
+		messageId: "concatenated"
+	});
+}
+/** The operands of a `+` chain. */
+function operands(node, into) {
+	const stack = [node];
+	for (let next = stack.pop(); next !== void 0; next = stack.pop()) {
+		const current = unwrap(next);
+		if (current.type === "BinaryExpression" && current.operator === "+") stack.push(current.right, current.left);
+		else into.push(current);
+	}
+}
+function isPlus(node) {
+	return node?.type === "BinaryExpression" && node.operator === "+";
+}
+/** A JSX child that renders as text: non-blank text, or blank text on one line (a space). */
+function textual(child) {
+	if (child.type !== "JSXText") return false;
+	const value = child.value;
+	return value.trim() !== "" || value !== "" && !value.includes("\n");
+}
+function isTranslationChild(analysis, child) {
+	return child.type === "JSXExpressionContainer" && child.expression.type !== "JSXEmptyExpression" && isTranslating(analysis, child.expression);
+}
+const noConcatenation = {
+	meta: {
+		type: "suggestion",
+		docs: docs("no-concatenation", "Do not join translated text with other text"),
+		schema: [],
+		messages: { concatenated: "Translated text is joined with other text here, which fixes the word order for every language: make it one message with ICU arguments, such as t(\"{name} joined {team}\", { name, team })" }
+	},
+	create(context) {
+		const analysis = analyse(context);
+		if (analysis.translating.size === 0) return {};
+		return {
+			BinaryExpression(node) {
+				if (node.operator !== "+") return;
+				let parent = node.parent;
+				while (parent && parent.type.startsWith("TS") && parent.type.endsWith("Expression")) parent = parent.parent;
+				if (isPlus(parent)) return;
+				const parts = [];
+				operands(node, parts);
+				if (parts.some((part) => isTranslating(analysis, part))) report(context, analysis, node);
+			},
+			TemplateLiteral(node) {
+				if (node.parent?.type === "TaggedTemplateExpression") return;
+				const expressions = node.expressions;
+				if (!expressions.some((expression) => isTranslating(analysis, expression))) return;
+				const quasis = node.quasis;
+				if (expressions.length > 1 || quasis.some((quasi) => quasi.value.raw.trim() !== "")) report(context, analysis, node);
+			},
+			CallExpression(node) {
+				const callee = unwrap(node.callee);
+				if (callee.type !== "MemberExpression" || callee.computed === true) return;
+				const name = callee.property.name;
+				const object = unwrap(callee.object);
+				const args = node.arguments;
+				if (name === "concat") {
+					if ([object, ...args].some((part) => isTranslating(analysis, part))) report(context, analysis, node);
+				} else if (name === "join" && object.type === "ArrayExpression") {
+					const elements = object.elements.filter((element) => element !== null);
+					if (elements.length > 1 && elements.some((element) => isTranslating(analysis, element))) report(context, analysis, node);
+				}
+			},
+			"JSXElement, JSXFragment"(node) {
+				const children = node.children.filter((child) => child.type !== "JSXText" || textual(child));
+				const joins = (at, step) => {
+					const next = children[at + step];
+					if (next === void 0) return false;
+					if (isTranslationChild(analysis, next)) return true;
+					if (next.type !== "JSXText") return false;
+					if (next.value.trim() !== "") return true;
+					const beyond = children[at + 2 * step];
+					return beyond !== void 0 && isTranslationChild(analysis, beyond);
+				};
+				for (let i = 0; i < children.length; i++) {
+					const child = children[i];
+					if (isTranslationChild(analysis, child) && (joins(i, -1) || joins(i, 1))) {
+						report(context, analysis, child);
+						return;
+					}
+				}
+			}
+		};
+	}
+};
+//#endregion
+//#region src/lint/rules/no-dynamic-message.ts
+const CODES = /* @__PURE__ */ new Set([
+	"extract-dynamic-message",
+	"extract-non-literal-option",
+	"extract-invalid-manual-id"
+]);
+const noDynamicMessage = {
+	meta: {
+		type: "problem",
+		docs: docs("no-dynamic-message", "Messages must be literals extraction can read"),
+		schema: [],
+		messages: { dynamic: "{{message}}" }
+	},
+	create(context) {
+		return { Program() {
+			for (const diagnostic of analyse(context).scan?.diagnostics ?? []) {
+				if (!CODES.has(diagnostic.code) || diagnostic.range === void 0) continue;
+				reportRange(context, diagnostic.range, "dynamic", { message: diagnostic.message });
+			}
+		} };
+	}
+};
+//#endregion
+//#region src/lint/jsx.ts
+/** Attributes assistive technology reads or browsers show as text (`translate-a11y-attrs`). */
+const A11Y_ATTRIBUTES = [
+	"alt",
+	"aria-description",
+	"aria-label",
+	"aria-placeholder",
+	"aria-roledescription",
+	"aria-valuetext",
+	"placeholder",
+	"title"
+];
+/** Elements whose text is code or markup, not prose (`no-literal-string`). */
+const IGNORED_ELEMENTS = [
+	"code",
+	"kbd",
+	"pre",
+	"samp",
+	"script",
+	"style"
+];
+/** `<input type="…">` whose `value` is the button's label. */
+const BUTTON_TYPES = /* @__PURE__ */ new Set([
+	"button",
+	"reset",
+	"submit"
+]);
+const ENTITY = /&(?:#\d+|#x[\da-f]+|[a-z][a-z\d]*);/gi;
+const LETTER = /\p{L}/u;
+/** Whether text holds a letter: punctuation, digits, symbols and entities alone need no translation. */
+function hasLetters(text) {
+	return LETTER.test(text.replace(ENTITY, ""));
+}
+/** `name`, `ns:name` or `A.B`. */
+function jsxName(name) {
+	if (!name) return null;
+	switch (name.type) {
+		case "JSXIdentifier": return name.name;
+		case "JSXNamespacedName": return `${jsxName(name.namespace)}:${jsxName(name.name)}`;
+		case "JSXMemberExpression": return `${jsxName(name.object)}.${jsxName(name.property)}`;
+		default: return null;
+	}
+}
+/** The string literal value of an attribute (`a="x"`, `a={"x"}`), or null. */
+function attributeText(opening, name) {
+	for (const attribute of opening.attributes) {
+		if (attribute.type !== "JSXAttribute" || jsxName(attribute.name) !== name) continue;
+		let value = attribute.value;
+		if (value?.type === "JSXExpressionContainer") value = value.expression;
+		return value?.type === "Literal" && typeof value.value === "string" ? value.value : null;
+	}
+	return null;
+}
+/**
+* Whether the node sits in text that is not for translators: inside an
+* ignored element, or an element (its own included) with HTML's
+* `translate="no"`.
+*/
+function untranslatable(node, ignoredElements) {
+	for (let current = node.parent; current; current = current.parent) {
+		if (current.type !== "JSXElement") continue;
+		const opening = current.openingElement;
+		const name = jsxName(opening.name);
+		if (name !== null && ignoredElements.has(name)) return true;
+		if (attributeText(opening, "translate") === "no") return true;
+	}
+	return false;
+}
+/**
+* The string literals an expression renders as they are: the literal
+* itself, the branches of `? :`, and what `&&`, `||` and `??` can yield as
+* text.
+*/
+function renderedStrings(expression) {
+	const out = [];
+	const stack = [expression];
+	for (let next = stack.pop(); next !== void 0; next = stack.pop()) switch (next.type) {
+		case "JSXExpressionContainer":
+			stack.push(next.expression);
+			break;
+		case "Literal":
+			if (typeof next.value === "string") out.push(next);
+			break;
+		case "TemplateLiteral":
+			if (next.expressions.length === 0) out.push(next);
+			break;
+		case "ConditionalExpression":
+			stack.push(next.alternate, next.consequent);
+			break;
+		case "LogicalExpression":
+			stack.push(next.right);
+			if (next.operator !== "&&") stack.push(next.left);
+			break;
+		case "TSAsExpression":
+		case "TSSatisfiesExpression":
+		case "TSNonNullExpression": stack.push(next.expression);
+	}
+	return out;
+}
+/** The text of a literal `renderedStrings` returned. */
+function literalText(node) {
+	if (node.type === "Literal") return node.value;
+	const quasi = node.quasis[0];
+	return quasi?.value.cooked ?? quasi?.value.raw ?? "";
+}
+/** Whether the attribute is the label of an `<input type="button|reset|submit">`. */
+function isButtonValue(attribute) {
+	if (jsxName(attribute.name) !== "value") return false;
+	const opening = attribute.parent;
+	if (!opening || jsxName(opening.name) !== "input") return false;
+	const type = attributeText(opening, "type");
+	return type !== null && BUTTON_TYPES.has(type.toLowerCase());
+}
+/** Text shortened for a message. */
+function quote(text) {
+	const flat = text.trim().replace(/\s+/g, " ");
+	return flat.length > 40 ? `${flat.slice(0, 39)}…` : flat;
+}
+//#endregion
+//#region src/lint/rules/no-literal-string.ts
+/**
+* `no-literal-string` (PLAN §4.13): text a JSX component renders without a
+* translation call: JSX text, string children (`{"…"}`, either branch of a
+* `? :`), and the attributes in `attributes` (`label` by default, and the
+* `value` of a button `<input>`). Text without a letter, text inside
+* `ignoreElements` (code, kbd, pre, samp, script, style) or under HTML's
+* `translate="no"`, text matching an `ignore` pattern, and code under
+* `vi18n-ignore` are left alone. The accessibility attributes are
+* `translate-a11y-attrs`'s, so the two rules never report one string twice.
+*/
+const strings = {
+	type: "array",
+	items: { type: "string" },
+	uniqueItems: true
+};
+const noLiteralString = {
+	meta: {
+		type: "suggestion",
+		docs: docs("no-literal-string", "Translate the text components render"),
+		schema: [{
+			type: "object",
+			properties: {
+				attributes: strings,
+				ignoreElements: strings,
+				ignore: strings
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			text: "Text \"{{text}}\" is not translated: render t(\"…\") instead",
+			attribute: "Attribute {{name}}=\"{{text}}\" is not translated: pass t(\"…\") instead"
+		}
+	},
+	create(context) {
+		const options = context.options[0] ?? {};
+		const attributes = new Set(options.attributes ?? ["label"]);
+		const elements = new Set(options.ignoreElements ?? IGNORED_ELEMENTS);
+		const patterns = (options.ignore ?? []).map((source) => new RegExp(source, "u"));
+		const analysis = analyse(context);
+		const skip = (node, text) => !hasLetters(text) || patterns.some((pattern) => pattern.test(text.trim())) || ignored(analysis, node) || untranslatable(node, elements);
+		return {
+			JSXText(node) {
+				const text = node.value;
+				if (skip(node, text)) return;
+				const [start, end] = node.range;
+				reportRange(context, [start + (text.length - text.trimStart().length), end - (text.length - text.trimEnd().length)], "text", { text: quote(text) });
+			},
+			JSXExpressionContainer(node) {
+				const parent = node.parent?.type;
+				if (parent !== "JSXElement" && parent !== "JSXFragment") return;
+				for (const literal of renderedStrings(node)) {
+					const text = literalText(literal);
+					if (!skip(literal, text)) context.report({
+						node: literal,
+						messageId: "text",
+						data: { text: quote(text) }
+					});
+				}
+			},
+			JSXAttribute(node) {
+				const name = jsxName(node.name);
+				if (name === null || node.value === null) return;
+				if (!attributes.has(name) && !isButtonValue(node)) return;
+				for (const literal of renderedStrings(node.value)) {
+					const text = literalText(literal);
+					if (!skip(literal, text)) context.report({
+						node: literal,
+						messageId: "attribute",
+						data: {
+							name,
+							text: quote(text)
+						}
+					});
+				}
+			}
+		};
+	}
+};
+//#endregion
+//#region src/lint/rules/no-module-scope-t.ts
+/**
+* `no-module-scope-t`: `extract-module-scope`, a `t()` call that runs when
+* the module is imported (PLAN §5.3). The top level of a Vue or Svelte
+* component script and of Astro frontmatter runs per instance or request, so
+* it is not module scope there, as in the compiled code the build scans.
+*/
+const noModuleScopeT = {
+	meta: {
+		type: "problem",
+		docs: docs("no-module-scope-t", "Translate inside functions and components, or declare module-level messages with msg()"),
+		schema: [],
+		messages: { moduleScope: "{{message}}" }
+	},
+	create(context) {
+		return { Program() {
+			const analysis = analyse(context);
+			if (analysis.component) return;
+			for (const diagnostic of analysis.scan?.diagnostics ?? []) {
+				if (diagnostic.code !== "extract-module-scope" || diagnostic.range === void 0) continue;
+				reportRange(context, diagnostic.range, "moduleScope", { message: diagnostic.message });
+			}
+		} };
+	}
+};
+//#endregion
+//#region src/lint/rules/prefer-full-sentence.ts
+/**
+* `prefer-full-sentence`: a message that reads as part of a sentence, which
+* code then completes with other text or another message. Translators need
+* the whole sentence: word order, agreement and punctuation change around
+* the pieces. Whitespace at either end shows it in any language; for an
+* English `sourceLocale`, so does a message ending on an article,
+* conjunction or preposition, or starting on a lowercase conjunction.
+*/
+/** Words a complete English UI string does not end on. Particles of phrasal verbs ("Sign in", "Log out") are left out. */
+const ENDS = /* @__PURE__ */ new Set([
+	"a",
+	"an",
+	"the",
+	"and",
+	"or",
+	"but",
+	"nor",
+	"of",
+	"to",
+	"for",
+	"with",
+	"from",
+	"than",
+	"as",
+	"at",
+	"via",
+	"per",
+	"into",
+	"your",
+	"my",
+	"our",
+	"their",
+	"its"
+]);
+/** Lowercase words that continue a sentence begun elsewhere. */
+const STARTS = /* @__PURE__ */ new Set([
+	"and",
+	"or",
+	"but",
+	"nor",
+	"of",
+	"to",
+	"than",
+	"with",
+	"from"
+]);
+const LAST_WORD = /(?:^|[^\p{L}\p{M}'’-])(\p{L}[\p{L}\p{M}]*)\s*$/u;
+const FIRST_WORD = /^\s*(\p{L}[\p{L}\p{M}]*)(?![\p{L}\p{M}'’-])/u;
+/** The reason a message reads as a fragment, or null. */
+function fragmentOf(source, english) {
+	if (source.trim() === "") return null;
+	if (source !== source.trim()) return { reason: /^\s/.test(source) ? "starts with whitespace" : "ends with whitespace" };
+	if (!english) return null;
+	const last = LAST_WORD.exec(source)?.[1];
+	if (last !== void 0 && ENDS.has(last.toLowerCase())) return { reason: `ends with "${last}"` };
+	const first = FIRST_WORD.exec(source)?.[1];
+	if (first !== void 0 && STARTS.has(first)) return { reason: `starts with "${first}"` };
+	return null;
+}
+const preferFullSentence = {
+	meta: {
+		type: "suggestion",
+		docs: docs("prefer-full-sentence", "Write whole sentences as one message"),
+		schema: [],
+		messages: { fragment: "This message {{reason}}, so it reads as part of a sentence: make the whole sentence one message, with ICU arguments for what changes" }
+	},
+	create(context) {
+		return { Program() {
+			const analysis = analyse(context);
+			const english = /^en(?:-|$)/i.test(analysis.settings.sourceLocale);
+			const seen = /* @__PURE__ */ new Set();
+			for (const occurrence of analysis.scan?.occurrences ?? []) {
+				const data = fragmentOf(occurrence.source, english);
+				if (data === null) continue;
+				const offset = offsetOf(analysis, occurrence.line, occurrence.column);
+				const literal = analysis.literals.get(offset);
+				if (literal === void 0 || seen.has(offset) || ignored(analysis, literal)) continue;
+				seen.add(offset);
+				context.report({
+					node: literal,
+					messageId: "fragment",
+					data
+				});
+			}
+		} };
+	}
+};
+//#endregion
+//#region src/lint/rules/t-result-captured.ts
+/**
+* `t-result-captured`: a translation computed once and kept, which an
+* in-place locale switch leaves in the old locale (PLAN §5.15). The same
+* finder as the plugin's dev warning (`extract-captured-value`), on the
+* source: React and Preact hook initialisers, Vue `setup()` and `<script
+* setup>`, Svelte component scripts, Solid component bodies.
+*/
+const tResultCaptured = {
+	meta: {
+		type: "problem",
+		docs: docs("t-result-captured", "Do not keep a translation where a locale switch cannot update it"),
+		schema: [],
+		messages: { captured: "{{message}}" }
+	},
+	create(context) {
+		return { Program() {
+			const analysis = analyse(context);
+			if (analysis.scan === null || analysis.parsed === null) return;
+			const found = findCapturedValues(analysis.parsed, analysis.scan, analysis.framework, {
+				topLevel: analysis.component,
+				ranges: true
+			});
+			for (const diagnostic of found) {
+				if (diagnostic.range === void 0) continue;
+				reportRange(context, diagnostic.range, "captured", { message: diagnostic.message });
+			}
+		} };
+	}
+};
+//#endregion
+//#region src/lint/rules/translate-a11y-attrs.ts
+/**
+* `translate-a11y-attrs` (PLAN §4.16): literal text in the attributes
+* screen readers announce and browsers show (`alt`, `aria-label`,
+* `aria-description`, `aria-placeholder`, `aria-roledescription`,
+* `aria-valuetext`, `placeholder`, `title`, and any in `attributes`).
+* Untranslated, they are the strings a pseudo-locale pass misses, since no
+* one sees them. An empty `alt=""` (a decorative image), text without a
+* letter, HTML's `translate="no"` and `vi18n-ignore` are left alone.
+*/
+const NO_ELEMENTS = /* @__PURE__ */ new Set();
+const translateA11yAttrs = {
+	meta: {
+		type: "suggestion",
+		docs: docs("translate-a11y-attrs", "Translate alt, aria-label, title, placeholder and other text attributes"),
+		schema: [{
+			type: "object",
+			properties: { attributes: {
+				type: "array",
+				items: { type: "string" },
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}],
+		messages: { attribute: "Attribute {{name}}=\"{{text}}\" is read by assistive technology but not translated: pass t(\"…\") instead" }
+	},
+	create(context) {
+		const extra = context.options[0]?.attributes ?? [];
+		const attributes = /* @__PURE__ */ new Set([...A11Y_ATTRIBUTES, ...extra]);
+		const analysis = analyse(context);
+		return { JSXAttribute(node) {
+			const name = jsxName(node.name);
+			if (name === null || node.value === null || !attributes.has(name)) return;
+			for (const literal of renderedStrings(node.value)) {
+				const text = literalText(literal);
+				if (!hasLetters(text) || ignored(analysis, literal) || untranslatable(literal, NO_ELEMENTS)) continue;
+				context.report({
+					node: literal,
+					messageId: "attribute",
+					data: {
+						name,
+						text: quote(text)
+					}
+				});
+			}
+		} };
+	}
+};
+//#endregion
+//#region src/lint/rules/valid-icu.ts
+/**
+* `valid-icu`: the ICU checks `vite build` and `vi18n extract` run on every
+* extracted message (INTERNALS §2.1.3): syntax, argument styles and
+* skeletons, bidi controls, plural categories of `sourceLocale`, and the
+* apostrophe lint (`icu-apostrophe`, PLAN §4.2), which this rule fixes by
+* doubling the apostrophe: `''` prints the straight apostrophe the author
+* typed, and what follows it stays a placeholder or tag.
+*/
+/** The value of a string literal or a template literal without expressions, or null. */
+function valueOf(node) {
+	if (node.type === "Literal") return typeof node.value === "string" ? node.value : null;
+	const quasi = node.quasis?.[0];
+	return typeof quasi?.value.cooked === "string" ? quasi.value.cooked : null;
+}
+/**
+* For each UTF-16 unit of a literal's value, the offset in its body (the
+* text between the quotes) where the unit's character starts, plus the
+* body's length. Escapes it does not follow (legacy octal) make the list
+* longer or shorter than the value, which the caller checks.
+*/
+function bodyOffsets(body) {
+	const offsets = [];
+	for (let i = 0; i < body.length;) {
+		if (body[i] !== "\\") {
+			offsets.push(i++);
+			continue;
+		}
+		const next = body[i + 1];
+		if (next === "\n" || next === "\r" || next === "\u2028" || next === "\u2029") i += next === "\r" && body[i + 2] === "\n" ? 3 : 2;
+		else if (next === "x") {
+			offsets.push(i);
+			i += 4;
+		} else if (next === "u" && body[i + 2] === "{") {
+			const close = body.indexOf("}", i);
+			const code = Number.parseInt(body.slice(i + 3, close), 16);
+			offsets.push(i);
+			if (code > 65535) offsets.push(i);
+			i = close + 1;
+		} else if (next === "u") {
+			offsets.push(i);
+			i += 6;
+		} else {
+			offsets.push(i);
+			i += 2;
+		}
+	}
+	offsets.push(body.length);
+	return offsets;
+}
+/**
+* The literal rewritten with every apostrophe that starts quoted text
+* doubled, or null when that would not leave valid ICU without quoted text,
+* or the value's offsets cannot be mapped to the source (NFC or CRLF
+* changes, escapes that do not decode one to one).
+*/
+function apostropheFix(node, code) {
+	const value = valueOf(node);
+	if (value === null || normalizeSource(value) !== value) return null;
+	const starts = quoteStarts(value);
+	if (starts.length === 0) return null;
+	let fixed = value;
+	for (let i = starts.length - 1; i >= 0; i--) {
+		const at = starts[i];
+		fixed = `${fixed.slice(0, at)}'${fixed.slice(at)}`;
+	}
+	try {
+		parseICU(fixed);
+	} catch {
+		return null;
+	}
+	if (quoteStarts(fixed).length > 0) return null;
+	const raw = code.slice(node.range[0], node.range[1]);
+	const quote = raw[0];
+	let body = raw.slice(1, -1);
+	const offsets = bodyOffsets(body);
+	if (offsets.length !== value.length + 1) return null;
+	const insert = quote === "'" ? "\\'" : "'";
+	for (let i = starts.length - 1; i >= 0; i--) {
+		const at = offsets[starts[i]];
+		body = `${body.slice(0, at)}${insert}${body.slice(at)}`;
+	}
+	return `${quote}${body}${quote}`;
+}
+//#endregion
+//#region src/lint/plugin.ts
+/**
+* The `@menapo/vi18n/lint` plugin (PLAN §4.13, §5.21; INTERNALS §3.7): ESLint
+* v9 rules that oxlint loads through `jsPlugins`, so they run inside `vp
+* check`. The rules that mirror build errors are errors in `recommended`;
+* the rest are warnings.
+*/
+const rules = {
+	"no-literal-string": noLiteralString,
+	"no-dynamic-message": noDynamicMessage,
+	"no-concatenation": noConcatenation,
+	"no-module-scope-t": noModuleScopeT,
+	"t-result-captured": tResultCaptured,
+	"prefer-full-sentence": preferFullSentence,
+	"translate-a11y-attrs": translateA11yAttrs,
+	"valid-icu": {
+		meta: {
+			type: "problem",
+			docs: docs("valid-icu", "Messages must be valid ICU, without apostrophes that quote text"),
+			fixable: "code",
+			schema: [],
+			messages: { icu: "{{message}}" }
+		},
+		create(context) {
+			return { Program() {
+				const analysis = analyse(context);
+				const apostrophes = /* @__PURE__ */ new Map();
+				for (const diagnostic of analysis.scan?.diagnostics ?? []) {
+					const { range } = diagnostic;
+					if (!diagnostic.code.startsWith("icu-") || range === void 0) continue;
+					if (diagnostic.code !== "icu-apostrophe") reportRange(context, range, "icu", { message: diagnostic.message });
+					else if (!apostrophes.has(range[0])) apostrophes.set(range[0], diagnostic);
+				}
+				for (const [start, diagnostic] of apostrophes) {
+					const literal = analysis.literals.get(start);
+					const fixed = literal === void 0 ? null : apostropheFix(literal, analysis.code);
+					reportRange(context, diagnostic.range, "icu", { message: diagnostic.message }, fixed === null || literal === void 0 ? void 0 : (fixer) => fixer.replaceTextRange(literal.range, fixed));
+				}
+			} };
+		}
+	}
+};
+const recommended = {
+	name: "vi18n/recommended",
+	plugins: {},
+	rules: Object.fromEntries(Object.entries({
+		"no-literal-string": "warn",
+		"no-dynamic-message": "error",
+		"no-concatenation": "warn",
+		"no-module-scope-t": "warn",
+		"t-result-captured": "warn",
+		"prefer-full-sentence": "warn",
+		"translate-a11y-attrs": "warn",
+		"valid-icu": "error"
+	}).map(([rule, severity]) => [`vi18n/${rule}`, severity]))
+};
+const plugin = {
+	meta: {
+		name: "vi18n",
+		version: VERSION
+	},
+	rules,
+	configs: { recommended }
+};
+recommended.plugins.vi18n = plugin;
+//#endregion
+//#region src/lint.ts
+/**
+* `@menapo/vi18n/lint` (INTERNALS §3.7): the lint plugin, as the module's
+* default export because ESLint flat configs and oxlint's `jsPlugins` both
+* load a plugin that way.
+*/
+var lint_default = plugin;
+//#endregion
+export { lint_default as default };