@x18n/builtins 0.0.13 → 0.0.15

package/dist/literal-gIdB1VGy.mjs

@@ -0,0 +1,125 @@
+import { a as splice, n as detectEol } from "./shared-C7ceptwi.mjs";
+import { isMessageLeaf } from "@x18n/core";
+//#region src/formats/shared/literal.ts
+/** Prints a value at `depth`. Objects span lines, one entry per line. */
+function literalText(value, syntax, depth = 0) {
+	if (isMessageLeaf(value)) return syntax.leaf(value, void 0);
+	const entries = Object.entries(value);
+	if (entries.length === 0) return `${syntax.open}${syntax.close}`;
+	const pad = syntax.unit.repeat(depth + 1);
+	const lines = entries.map(([key, child]) => `${pad}${syntax.key(key)}${syntax.separator}${literalText(child, syntax, depth + 1)}`);
+	return `${syntax.open}\n${lines.join(",\n")}${syntax.trailingComma ? "," : ""}\n${syntax.unit.repeat(depth)}${syntax.close}`;
+}
+/** Applies one op to the text of `root` and leaves everything else as it is: comments, quotes, order and layout. */
+function editLiteral(text, root, op, syntax) {
+	const last = root.items.at(-1);
+	const style = last ? {
+		...syntax,
+		trailingComma: commaAfter(text, last.range.end) !== void 0
+	} : syntax;
+	let node = root;
+	let depth = 0;
+	while (depth < op.path.length && node.kind === "object") {
+		const object = node;
+		const item = object.items.findLast((i) => i.key === op.path[depth]);
+		if (!item) break;
+		if (op.type === "delete" && depth === op.path.length - 1) return removeItem(text, object, item);
+		node = item.value;
+		depth++;
+	}
+	if (op.type === "delete") return text;
+	const rest = op.path.slice(depth);
+	if (node.kind === "object" && rest.length > 0) return insertItem(text, node, rest, op.value, style);
+	const value = nest(rest, op.value);
+	return splice(text, node.range, isMessageLeaf(value) ? style.leaf(value, node.kind === "scalar" ? node.quote : void 0) : reindent(literalText(value, style), indentAt(text, node.range.start), detectEol(text)));
+}
+function nest(path, value) {
+	return path.reduceRight((child, segment) => ({ [segment]: child }), value);
+}
+function reindent(text, indent, eol) {
+	return text.replace(/\n/g, `${eol}${indent}`);
+}
+function lineStart(text, pos) {
+	return text.lastIndexOf("\n", pos - 1) + 1;
+}
+function indentAt(text, pos) {
+	return /^[ \t]*/.exec(text.slice(lineStart(text, pos)))[0];
+}
+/** The `,` after a value, past blanks and comments. */
+function commaAfter(text, pos) {
+	const at = pos + /^(?:\s|\/\/[^\n]*|#[^\n]*|\/\*[\s\S]*?\*\/)*/.exec(text.slice(pos))[0].length;
+	return text[at] === "," ? at : void 0;
+}
+/** The end of the line at `pos`, before the line break, when only blanks and a comment follow. */
+function lineEnd(text, pos) {
+	const end = pos + /^[ \t]*(?:(?:\/\/|#).*|\/\*.*?\*\/[ \t]*)?/.exec(text.slice(pos))[0].length;
+	return end === text.length || text.startsWith("\n", end) || text.startsWith("\r\n", end) ? end : void 0;
+}
+function insertItem(text, object, path, value, syntax) {
+	const eol = detectEol(text);
+	const entry = (indent) => `${syntax.key(path[0])}${syntax.separator}${reindent(literalText(nest(path.slice(1), value), syntax), indent, eol)}`;
+	const first = object.items[0];
+	const last = object.items.at(-1);
+	if (!first || !last) {
+		const base = indentAt(text, object.range.start);
+		const indent = base + syntax.unit;
+		const close = object.range.end - 1;
+		const blank = /\s*$/.exec(text.slice(object.range.start, close))[0].length;
+		return splice(text, {
+			start: close - blank,
+			end: close
+		}, `${eol}${indent}${entry(indent)}${syntax.trailingComma ? "," : ""}${eol}${base}`);
+	}
+	const comma = commaAfter(text, last.range.end);
+	const end = comma === void 0 ? last.range.end : comma + 1;
+	if (!text.slice(object.range.start, first.range.start).includes("\n")) {
+		const indent = indentAt(text, object.range.start);
+		return splice(text, {
+			start: end,
+			end
+		}, comma === void 0 ? `, ${entry(indent)}` : ` ${entry(indent)},`);
+	}
+	const indent = indentAt(text, first.range.start);
+	const at = lineEnd(text, end) ?? end;
+	const next = splice(text, {
+		start: at,
+		end: at
+	}, `${eol}${indent}${entry(indent)}${comma === void 0 ? "" : ","}`);
+	return comma === void 0 ? splice(next, {
+		start: end,
+		end
+	}, ",") : next;
+}
+function removeItem(text, object, item) {
+	const comma = commaAfter(text, item.range.end);
+	const end = comma === void 0 ? item.range.end : comma + 1;
+	const previous = object.items[object.items.indexOf(item) - 1];
+	const before = comma === void 0 && previous ? commaAfter(text, previous.range.end) : void 0;
+	const close = lineEnd(text, end);
+	const opening = text.slice(object.range.start, item.range.start);
+	if (object.items.length === 1 && !/\/\/|\/\*|#/.test(opening) && text.slice(close ?? end, object.range.end - 1).trim() === "") return splice(text, {
+		start: object.range.start + opening.trimEnd().length,
+		end: object.range.end - 1
+	}, "");
+	const start = lineStart(text, item.range.start);
+	if (close !== void 0 && /^[ \t]*$/.test(text.slice(start, item.range.start))) {
+		const next = splice(text, {
+			start,
+			end: close + (/^\r?\n/.exec(text.slice(close))?.[0].length ?? 0)
+		}, "");
+		return before === void 0 ? next : splice(next, {
+			start: before,
+			end: before + 1
+		}, "");
+	}
+	if (before !== void 0) return splice(text, {
+		start: before,
+		end
+	}, "");
+	return splice(text, {
+		start: item.range.start,
+		end: end + /^[ \t]*/.exec(text.slice(end))[0].length
+	}, "");
+}
+//#endregion
+export { literalText as n, editLiteral as t };

package/dist/locale-root-C_rch3IQ.mjs

@@ -0,0 +1,15 @@
+import { isMessageLeaf } from "@x18n/core";
+//#region src/presets/shared/locale-root.ts
+/** Files that start with their locale, `en: { users: ... }`, as in Rails and i18nice. */
+function localeRoot(applies) {
+	return {
+		applies,
+		read(tree, ctx) {
+			const root = tree[ctx.locale];
+			return root !== void 0 && !isMessageLeaf(root) ? root : {};
+		},
+		toStored: (path, ctx) => [ctx.locale, ...path]
+	};
+}
+//#endregion
+export { localeRoot as t };

package/dist/manifests.d.mts

@@ -6,5 +6,13 @@ export declare const composerJson: ManifestReader;
 export declare const pubspecYaml: ManifestReader;
 /** Every `gem 'name'` line, not just `rails-i18n` as in i18n-ally. */
 export declare const gemfile: ManifestReader;
+/** Reads the PEP 621, PEP 735 and Poetry dependency tables; dependency names need no full TOML parser. */
+export declare const pyprojectToml: ManifestReader;
+export declare const requirementsTxt: ManifestReader;
+/**
+ * Dependency names from `[dependencies]`, `[dev-dependencies]`, `[build-dependencies]`, `[workspace.dependencies]`
+ * and target tables, and `[dependencies.name]` headers. A renamed dependency reports its alias, not `package`. TOML puts each key on its own line, so a line scan is enough.
+ */
+export declare const cargoToml: ManifestReader;
 export declare function manifests(): Plugin;
 //#endregion

package/dist/manifests.mjs

@@ -34,6 +34,67 @@ const gemfile = {
 	file: "Gemfile",
 	read: (text) => [...text.matchAll(/^\s*gem\s+["']([^"']+)["']/gm)].map((match) => match[1])
 };
+/** The PEP 503 normalized name of a PEP 508 requirement: `Flask_Babel[async]>=4` is `flask-babel`. */
+function requirementName(requirement) {
+	const name = /^\s*([a-z\d][\w.-]*)/i.exec(requirement)?.[1];
+	return name ? [name.toLowerCase().replace(/[-_.]+/g, "-")] : [];
+}
+/** TOML strings outside comments, up to the first `]` outside a string (`"i18nice[YAML]"` has none) when `toClose`. */
+function tomlStrings(text, toClose) {
+	const out = [];
+	for (const match of text.matchAll(/"([^"\n]*)"|'([^'\n]*)'|#.*|(\])/g)) {
+		if (match[3] && toClose) break;
+		const value = match[1] ?? match[2];
+		if (value !== void 0) out.push(value);
+	}
+	return out;
+}
+/** Reads the PEP 621, PEP 735 and Poetry dependency tables; dependency names need no full TOML parser. */
+const pyprojectToml = {
+	id: "pyproject.toml",
+	file: "pyproject.toml",
+	read: (text) => text.replace(/"""[\s\S]*?"""|'''[\s\S]*?'''/g, "\"\"").split(/^[ \t]*\[/m).flatMap((table) => {
+		const header = /^\[?([^\]\n]+)\]/.exec(table)?.[1]?.trim();
+		const body = table.slice(table.indexOf("\n") + 1);
+		if (header === "project") {
+			const start = /^\s*dependencies\s*=\s*\[/m.exec(body);
+			return start ? tomlStrings(body.slice(start.index + start[0].length), true).flatMap(requirementName) : [];
+		}
+		if (header === "project.optional-dependencies" || header === "dependency-groups") return tomlStrings(body, false).flatMap(requirementName);
+		if (header && /^tool\.poetry\.(?:group\.[\w-]+\.)?(?:dev-)?dependencies$/.test(header)) return [...body.matchAll(/^\s*(?:"([^"\n]+)"|'([^'\n]+)'|([\w-]+))\s*[.=]/gm)].flatMap((match) => requirementName(match[1] ?? match[2] ?? match[3])).filter((name) => name !== "python");
+		return [];
+	})
+};
+const requirementsTxt = {
+	id: "requirements.txt",
+	file: "requirements.txt",
+	read: (text) => text.split("\n").flatMap((line) => line.trim().startsWith("-") ? [] : requirementName(line))
+};
+const cargoSection = /^\[\s*((?:workspace\.|target\.[^\]]+\.)?(?:dev-|build-)?dependencies)(?:\.([\w-]+))?\s*\]/;
+const cargoKey = /^\s*"?([\w-]+)"?\s*[.=]/;
+/**
+* Dependency names from `[dependencies]`, `[dev-dependencies]`, `[build-dependencies]`, `[workspace.dependencies]`
+* and target tables, and `[dependencies.name]` headers. A renamed dependency reports its alias, not `package`. TOML puts each key on its own line, so a line scan is enough.
+*/
+const cargoToml = {
+	id: "Cargo.toml",
+	file: "Cargo.toml",
+	read(text) {
+		const names = [];
+		let inDependencies = false;
+		for (const line of text.split("\n")) {
+			if (line.trimStart().startsWith("[")) {
+				const section = cargoSection.exec(line.trim());
+				inDependencies = section !== null && section[2] === void 0;
+				if (section?.[2]) names.push(section[2]);
+				continue;
+			}
+			const name = inDependencies ? cargoKey.exec(line)?.[1] : void 0;
+			if (name) names.push(name);
+		}
+		return names;
+	}
+};
 function manifests() {
 	return {
 		name: "x18n:manifests",
@@ -41,9 +102,12 @@ function manifests() {
 			packageJson,
 			composerJson,
 			pubspecYaml,
-			gemfile
+			gemfile,
+			pyprojectToml,
+			requirementsTxt,
+			cargoToml
 		]
 	};
 }
 //#endregion
-export { composerJson, gemfile, manifests, packageJson, pubspecYaml };
+export { cargoToml, composerJson, gemfile, manifests, packageJson, pubspecYaml, pyprojectToml, requirementsTxt };

package/dist/placeholders.d.mts

@@ -2,12 +2,21 @@ import { PlaceholderSyntax, Plugin } from "@x18n/core";
 //#region src/placeholders/index.d.ts
 /** `{name}`: vue-i18n named interpolation and similar. */
 export declare const braces: PlaceholderSyntax;
+/** `{}`: easy_localization positional arguments. */
+export declare const positionalBraces: PlaceholderSyntax;
+/** `{name}` with an optional type, formatters or switch-case: `{name:string}`, `{date|weekday}`, `{gender|{male: his, *: their}}`. `{{a|b}}` plurals are not placeholders. */
+export declare const typedBraces: PlaceholderSyntax;
 /** `{{name}}`: i18next interpolation, including `{{name, format}}` and `{{- raw}}`. */
 export declare const doubleBraces: PlaceholderSyntax;
 /** `%{name}`: Rails, Polyglot. */
 export declare const percentBraces: PlaceholderSyntax;
 /** `%s`, `%d`, `%1$s`: printf. */
 export declare const printf: PlaceholderSyntax;
+/**
+ * `%(name)s`, `%s`, `%d`: Python percent formatting, as in gettext catalogs. No space flag, so `50% of` is text.
+ * URL escapes are text too: those with an uppercase hex letter (`%2F`), and any `%XX` after `://` in the same word (`%20a`).
+ */
+export declare const pythonPercent: PlaceholderSyntax;
 /** `@:key` and `@.modifier:key`: vue-i18n linked messages. */
 export declare const linked: PlaceholderSyntax;
 /** `{ $name }`: Fluent variables. */
@@ -16,6 +25,8 @@ export declare const fluent: PlaceholderSyntax;
 export declare const colon: PlaceholderSyntax;
 /** `$name$`: Chrome extension messages. */
 export declare const dollars: PlaceholderSyntax;
+/** `{0}`, `{0:C}`, `{0,-10}`, `{name}`: .NET composite format items. `{{` and `}}` are literal braces. */
+export declare const dotnet: PlaceholderSyntax;
 /** `$t(key)` nesting in i18next. */
 export declare const nesting: PlaceholderSyntax;
 /** ICU MessageFormat arguments: `{name}`, `{count, plural, ...}`. Nested sub-messages are scanned too. */

package/dist/placeholders.mjs

@@ -20,12 +20,21 @@ function byRegex(id, regex, example) {
 }
 /** `{name}`: vue-i18n named interpolation and similar. */
 const braces = byRegex("braces", /(?<![{$])\{\s*([\w.-]+)\s*\}(?!\})/g, "{name}");
+/** `{}`: easy_localization positional arguments. */
+const positionalBraces = byRegex("positional-braces", /\{\}/g, "{}");
+/** `{name}` with an optional type, formatters or switch-case: `{name:string}`, `{date|weekday}`, `{gender|{male: his, *: their}}`. `{{a|b}}` plurals are not placeholders. */
+const typedBraces = byRegex("typed-braces", /(?<![{$])\{\s*(\w+)\??\s*(?::[^{}|]*)?(?:\|(?:\{[^{}]*\}|[^{}]*))?\}(?!\})/g, "{name}");
 /** `{{name}}`: i18next interpolation, including `{{name, format}}` and `{{- raw}}`. */
 const doubleBraces = byRegex("double-braces", /\{\{-?\s*([\w.]+)\s*(?:,[^}]*)?\}\}/g, "{{name}}");
 /** `%{name}`: Rails, Polyglot. */
 const percentBraces = byRegex("percent-braces", /%\{(\w+)\}/g, "%{name}");
 /** `%s`, `%d`, `%1$s`: printf. */
 const printf = byRegex("printf", /%(?:(\d+)\$)?[-+ 0#]*(?:[1-9]\d*)?(?:\.\d+)?[sdifoxXeEgGc@]/g, "%s");
+/**
+* `%(name)s`, `%s`, `%d`: Python percent formatting, as in gettext catalogs. No space flag, so `50% of` is text.
+* URL escapes are text too: those with an uppercase hex letter (`%2F`), and any `%XX` after `://` in the same word (`%20a`).
+*/
+const pythonPercent = byRegex("python-percent", /(?<!%)%(?![\dA-F][A-F])(?!(?<=:\/\/\S*%)[\dA-Fa-f]{2})(?:\((\w+)\))?[-#0+]*(?:[1-9]\d*|\*)?(?:\.\d+)?[c-giouxXEFGrsa]/g, "%(name)s");
 /** `@:key` and `@.modifier:key`: vue-i18n linked messages. */
 const linked = {
 	...byRegex("linked", /@(?:\.\w+)?:\(?([\w.-]+)\)?/g, "@:key"),
@@ -37,6 +46,24 @@ const fluent = byRegex("fluent", /\{\s*\$([\w-]+)(?:\s[^}]*)?\}/g, "{ $name }");
 const colon = byRegex("colon", /(?<![\w:]):([a-z_]\w*)/gi, ":name");
 /** `$name$`: Chrome extension messages. */
 const dollars = byRegex("dollars", /\$(\w+)\$/g, "$name$");
+/** `{0}`, `{0:C}`, `{0,-10}`, `{name}`: .NET composite format items. `{{` and `}}` are literal braces. */
+const dotnet = {
+	id: "dotnet",
+	example: "{0}",
+	find(value) {
+		const out = [];
+		for (const match of value.matchAll(/\{\{|\}\}|\{\s*(\w+)\s*(?:,\s*-?\d+\s*)?(?::[^{}]*)?\}/g)) if (match[1] !== void 0) out.push({
+			syntax: "dotnet",
+			text: match[0],
+			name: match[1],
+			range: {
+				start: match.index,
+				end: match.index + match[0].length
+			}
+		});
+		return out;
+	}
+};
 /** `$t(key)` nesting in i18next. */
 const nesting = {
 	...byRegex("nesting", /\$t\(([\w.:-]+)(?:,[^)]*)?\)/g, "$t(key)"),
@@ -128,4 +155,4 @@ function placeholderFromShape(shape) {
 	return byRegex(`shape:${shape}`, new RegExp(`${escape(before ?? "")}\\s*([\\w.-]+)\\s*${escape(after ?? "")}`, "g"), shape);
 }
 //#endregion
-export { braces, colon, dollars, doubleBraces, fluent, icu, linked, nesting, percentBraces, placeholderFromShape, placeholders, printf };
+export { braces, colon, dollars, dotnet, doubleBraces, fluent, icu, linked, nesting, percentBraces, placeholderFromShape, placeholders, positionalBraces, printf, pythonPercent, typedBraces };

package/dist/plugin-Cb1b0axD.mjs

@@ -0,0 +1,83 @@
+import { doubleBraces, nesting } from "./placeholders.mjs";
+import { createLibraryPlugin } from "@x18n/core";
+//#region src/presets/i18next/plugin.ts
+/** `defaultNS` and `fallbackNS` from the i18next init code (`i18n.ts`, `next-i18next.config.js`), as keys without a namespace use them. */
+async function findNamespaces(host) {
+	const files = await host.glob(["**/*i18n*.{js,mjs,cjs,ts,mts,cts}", "**/i18n/index.{js,ts}"], {
+		ignore: ["**/node_modules/**", "**/dist/**"],
+		gitignore: true
+	});
+	const found = {
+		default: void 0,
+		fallback: void 0
+	};
+	for (const file of files.slice(0, 20)) {
+		const text = await host.readFile(file) ?? "";
+		found.default ??= /\bdefaultNS\s*:\s*['"`]([^'"`]+)['"`]/.exec(text)?.[1];
+		const fallback = /\bfallbackNS\s*:\s*(\[[^\]]*\]|['"`][^'"`]+['"`])/.exec(text)?.[1];
+		found.fallback ??= fallback ? [...fallback.matchAll(/['"`]([^'"`]+)['"`]/g)].map((m) => m[1]) : void 0;
+	}
+	return found;
+}
+const i18nextPlugin = createLibraryPlugin({
+	name: "x18n:i18next",
+	namespace: {
+		separator: ":",
+		default: "translation",
+		fromPath: "slash"
+	},
+	extra: async (draft, ctx) => {
+		const user = ctx.user.namespace;
+		if (user?.default && user.fallback) return;
+		const found = await findNamespaces(ctx.host);
+		draft.namespace = {
+			...draft.namespace,
+			default: user?.default ?? found.default ?? draft.namespace.default,
+			fallback: user?.fallback ?? found.fallback ?? draft.namespace.fallback
+		};
+	},
+	calls: [
+		{
+			callee: [
+				"t",
+				"i18next.t",
+				"i18n.t"
+			],
+			namespace: {
+				arg: 1,
+				property: "ns"
+			}
+		},
+		{
+			callee: [
+				"getFixedT",
+				"i18next.getFixedT",
+				"i18n.getFixedT"
+			],
+			factory: true,
+			returns: ["t"],
+			namespace: { arg: 1 },
+			keyPrefix: { arg: 2 }
+		},
+		{
+			callee: "tr",
+			types: ["TFunction"]
+		}
+	],
+	placeholders: [doubleBraces, nesting],
+	derivedKeys: [
+		"{key}_ordinal_{ordinal}",
+		"{key}_{plural}",
+		"{key}_*"
+	],
+	translatePrompt: (draft, ctx) => {
+		draft.notes.push(`i18next plural keys end in _${ctx.localeInfo.pluralCategories.join(", _")} for ${ctx.targetLocale}; write one key per category.`);
+	},
+	templates: [{
+		template: "i18next.t('{key}'{args})",
+		kinds: ["js-string", "js-template"],
+		imports: ["import i18next from 'i18next'"]
+	}]
+});
+//#endregion
+export { i18nextPlugin as t };

package/dist/plural-forms-B7_QX4nG.mjs

@@ -0,0 +1,12 @@
+//#region src/presets/shared/plural-forms.ts
+/** Not `{plural}`: easy_localization ignores CLDR plural rules by default, and both libraries fall back to `other`. */
+const pluralForms = [
+	"zero",
+	"one",
+	"two",
+	"few",
+	"many",
+	"other"
+];
+//#endregion
+export { pluralForms as t };

package/dist/presets/cargo-i18n.d.mts

@@ -0,0 +1,6 @@
+import { Preset } from "@x18n/core";
+//#region src/presets/cargo-i18n/index.d.ts
+/** cargo-i18n with the Fluent system: `i18n.toml`, `{assets_dir}/{locale}/{crate}.ftl` and the `fl!` macro of `i18n-embed-fl`. */
+export declare function cargoI18n(): Preset;
+//#endregion
+export { cargoI18n as default };

package/dist/presets/cargo-i18n.mjs

@@ -0,0 +1,28 @@
+import { fluent } from "../placeholders.mjs";
+import { createLibraryPlugin } from "@x18n/core";
+//#region src/presets/cargo-i18n/index.ts
+/** cargo-i18n with the Fluent system: `i18n.toml`, `{assets_dir}/{locale}/{crate}.ftl` and the `fl!` macro of `i18n-embed-fl`. */
+function cargoI18n() {
+	return {
+		name: "cargo-i18n",
+		plugins: [createLibraryPlugin({
+			name: "x18n:cargo-i18n",
+			regex: [{
+				extensions: ["rs"],
+				patterns: ["\\bfl!\\(\\s*(?:[^,\"]+,\\s*)?\"({key})\""]
+			}],
+			derivedKeys: ["{key}.*"],
+			extra: async (draft, ctx) => {
+				const toml = await ctx.host.readFile("i18n.toml") ?? "";
+				const fallback = /^\s*fallback_language\s*=\s*["']([^"']+)["']/m.exec(toml)?.[1];
+				if (fallback) draft.sourceLocale = fallback;
+				const assetsDir = /^\s*assets_dir\s*=\s*["']([^"']+)["']/m.exec(toml)?.[1]?.replace(/^\.\/|\/$/g, "") ?? "i18n";
+				draft.resources = [...draft.resources, { pattern: `${assetsDir}/{locale}/*.ftl` }];
+			},
+			templates: [{ template: "fl!(LANGUAGE_LOADER, \"{key}\")" }],
+			placeholders: [fluent]
+		})]
+	};
+}
+//#endregion
+export { cargoI18n, cargoI18n as default };

package/dist/presets/chrome-extension.d.mts

@@ -0,0 +1,6 @@
+import { Preset } from "@x18n/core";
+//#region src/presets/chrome-extension/index.d.ts
+/** Chrome and WebExtension `_locales/{locale}/messages.json`: `{ "name": { "message": "..." } }` reads as `name`. */
+export declare function chromeExtension(): Preset;
+//#endregion
+export { chromeExtension as default };

package/dist/presets/chrome-extension.mjs

@@ -0,0 +1,52 @@
+import { dollars } from "../placeholders.mjs";
+import { createLibraryPlugin, isMessageLeaf } from "@x18n/core";
+//#region src/presets/chrome-extension/index.ts
+/** Chrome and WebExtension `_locales/{locale}/messages.json`: `{ "name": { "message": "..." } }` reads as `name`. */
+function chromeExtension() {
+	return {
+		name: "chrome-extension",
+		plugins: [createLibraryPlugin({
+			name: "x18n:chrome-extension",
+			calls: [{ callee: [
+				"chrome.i18n.getMessage",
+				"browser.i18n.getMessage",
+				"i18n.getMessage"
+			] }],
+			regex: [{
+				extensions: [
+					"json",
+					"html",
+					"css"
+				],
+				patterns: ["__MSG_({key})__"]
+			}],
+			resources: [{ pattern: "_locales/{locale}/messages.json" }, { pattern: "{src,public,extension}/_locales/{locale}/messages.json" }],
+			transformResource: {
+				applies: (ctx) => /(?:^|\/)_locales\/[^/]+\/messages\.json$/.test(ctx.path),
+				read(tree) {
+					const out = {};
+					for (const [name, entry] of Object.entries(tree)) {
+						const message = isMessageLeaf(entry) ? void 0 : entry.message;
+						if (message !== void 0 && isMessageLeaf(message)) out[name] = message;
+					}
+					return out;
+				},
+				toStored: (path) => [path.join("."), "message"]
+			},
+			templates: [{
+				template: "chrome.i18n.getMessage('{key}')",
+				kinds: ["js-string", "js-template"]
+			}],
+			placeholders: [dollars]
+		}), {
+			name: "x18n:chrome-extension-source-locale",
+			async config(draft, ctx) {
+				const manifest = await ctx.host.readFile("manifest.json") ?? await ctx.host.readFile("src/manifest.json") ?? await ctx.host.readFile("public/manifest.json");
+				const locale = manifest ? /"default_locale"\s*:\s*"([^"]+)"/.exec(manifest)?.[1] : void 0;
+				if (locale) draft.sourceLocale = locale;
+			}
+		}]
+	};
+}
+//#endregion
+export { chromeExtension, chromeExtension as default };

package/dist/presets/dotnet-resx.d.mts

@@ -0,0 +1,6 @@
+import { Preset } from "@x18n/core";
+//#region src/presets/dotnet-resx/index.d.ts
+/** .NET `IStringLocalizer` and strongly typed resources over `.resx` files: `Strings.resx` holds the source locale, `Strings.de.resx` German. */
+export declare function dotnetResx(): Preset;
+//#endregion
+export { dotnetResx as default };

package/dist/presets/dotnet-resx.mjs

@@ -0,0 +1,64 @@
+import { dotnet } from "../placeholders.mjs";
+import { createLibraryPlugin } from "@x18n/core";
+//#region src/presets/dotnet-resx/index.ts
+/** .NET satellite assemblies: `X.<culture>.resx` translates `X.resx`, so `Views.Shared.Nav.resx` alone is a source file. */
+const resxFinder = {
+	id: "dotnet-resx",
+	async find(ctx) {
+		const paths = new Set(await ctx.host.glob(["**/*.resx"], {
+			ignore: [
+				"**/node_modules/**",
+				"**/bin/**",
+				"**/obj/**"
+			],
+			gitignore: false
+		}));
+		return [...paths].map((path) => {
+			const satellite = /^(.+)\.([^./]+)\.resx$/.exec(path);
+			return {
+				path,
+				locale: satellite && paths.has(`${satellite[1]}.resx`) ? satellite[2] : ctx.config.sourceLocale,
+				namespace: void 0
+			};
+		});
+	},
+	resolveNew({ locale, model }, ctx) {
+		if (model?.finder !== "dotnet-resx") return void 0;
+		const suffix = model.path.endsWith(`.${model.locale}.resx`) ? `.${model.locale}.resx` : ".resx";
+		const base = model.path.slice(0, -suffix.length);
+		return locale === ctx.config.sourceLocale ? `${base}.resx` : `${base}.${locale}.resx`;
+	}
+};
+/** .NET `IStringLocalizer` and strongly typed resources over `.resx` files: `Strings.resx` holds the source locale, `Strings.de.resx` German. */
+function dotnetResx() {
+	return {
+		name: "dotnet-resx",
+		plugins: [createLibraryPlugin({
+			name: "x18n:dotnet-resx",
+			regex: [{
+				extensions: [
+					"cs",
+					"cshtml",
+					"razor"
+				],
+				patterns: [
+					"\\b(?:\\w*[Ll]ocali[sz]er|L|Loc)\\[\\s*\"([^\"]+)\"",
+					"\\b\\w*[Ll]ocali[sz]er\\.Get(?:String|Html)\\(\\s*\"([^\"]+)\"",
+					"(?<![\\w.])(?:Properties\\.)?Resources\\.(?!ResourceManager\\b|Culture\\b)([A-Za-z_]\\w*)\\b(?![.(<])"
+				]
+			}],
+			finders: [resxFinder],
+			keyStyle: "flat",
+			templates: [{
+				template: "@Localizer[\"{key}\"]",
+				files: ["**/*.cshtml", "**/*.razor"]
+			}, {
+				template: "_localizer[\"{key}\"]",
+				files: ["**/*.cs"]
+			}],
+			placeholders: [dotnet]
+		})]
+	};
+}
+//#endregion
+export { dotnetResx as default, dotnetResx };

package/dist/presets/easy-localization.d.mts

@@ -0,0 +1,6 @@
+import { Preset } from "@x18n/core";
+//#region src/presets/easy-localization/index.d.ts
+/** `easy_localization`: `'key'.tr()`, `tr('key')`, `context.tr('key')`, plural and gender forms as nested keys. */
+export declare function easyLocalization(): Preset;
+//#endregion
+export { easyLocalization as default };

package/dist/presets/easy-localization.mjs

@@ -0,0 +1,36 @@
+import { braces, linked, positionalBraces } from "../placeholders.mjs";
+import { t as pluralForms } from "../plural-forms-B7_QX4nG.mjs";
+import { createLibraryPlugin } from "@x18n/core";
+//#region src/presets/easy-localization/index.ts
+/** `easy_localization`: `'key'.tr()`, `tr('key')`, `context.tr('key')`, plural and gender forms as nested keys. */
+function easyLocalization() {
+	return {
+		name: "easy-localization",
+		plugins: [createLibraryPlugin({
+			name: "x18n:easy-localization",
+			regex: [{
+				extensions: ["dart"],
+				patterns: [
+					"['\"]({key})['\"]\\s*\\.(?:tr|plural)\\(",
+					"(?<![\\w$])Text\\(\\s*['\"]({key})['\"]\\s*\\)\\s*\\.(?:tr|plural)\\(",
+					"(?<![\\w$.])(?:context\\.)?(?:tr|plural)\\(\\s*['\"]({key})['\"]"
+				]
+			}],
+			derivedKeys: [
+				...pluralForms,
+				"male",
+				"female"
+			].map((form) => `{key}.${form}`),
+			resources: [{ pattern: "assets/translations/{locale}.{ext}" }],
+			keyStyle: "nested",
+			templates: [{ template: "'{key}'.tr()" }],
+			placeholders: [
+				positionalBraces,
+				braces,
+				linked
+			]
+		})]
+	};
+}
+//#endregion
+export { easyLocalization as default, easyLocalization };

package/dist/presets/ember-intl.d.mts

@@ -0,0 +1,5 @@
+import { Preset } from "@x18n/core";
+//#region src/presets/ember-intl/index.d.ts
+export declare function emberIntl(): Preset;
+//#endregion
+export { emberIntl as default };