@x18n/builtins 0.0.13 → 0.0.14

package/dist/{vue-CF4pe-Yr.mjs → js-CV-ECNJG.mjs}

@@ -1,4 +1,4 @@
-//#region src/scanners/js.ts
+//#region src/scanners/shared/js.ts
 const textAttributeWords = /* @__PURE__ */ new Set([
 	"title",
 	"subtitle",
@@ -83,6 +83,8 @@ var FileScan = class {
 	declared = /* @__PURE__ */ new Map();
 	factories = /* @__PURE__ */ new Map();
 	typed = /* @__PURE__ */ new Map();
+	/** Members of the file's top-level interfaces and object type aliases, for typed props (`({ t }: Props)`). */
+	typeMembers = /* @__PURE__ */ new Map();
 	consumed = /* @__PURE__ */ new Set();
 	/** Render-prop functions of factory components (`<Translation>{t => ...}</Translation>`), by start offset. */
 	renderProps = /* @__PURE__ */ new Map();
@@ -145,6 +147,11 @@ var FileScan = class {
 			return constant && isStringLiteral(constant) ? constant.value : void 0;
 		}
 	}
+	/** A fixed namespace, or the one an argument holds. */
+	namespaceArg(args, source, fallback) {
+		if (typeof source === "string") return source;
+		return source ? this.stringArg(this.argValues(args, source, fallback)[0]) : void 0;
+	}
 	argValues(args, source, fallback) {
 		const arg = args[typeof source === "number" ? source : source?.arg ?? fallback];
 		const property = typeof source === "object" ? source.property : void 0;
@@ -165,13 +172,9 @@ var FileScan = class {
 	}
 	/** ---- Usages ---- */
 	/** `expression` is the call holding `value`, kept only when the key is the call's own literal. */
-	addKey(value, binding, namespace, expression) {
+	addKey(value, base, expression) {
 		if ("props" in value) return;
 		const node = unwrap(value);
-		const base = {
-			namespace: namespace ?? binding.namespace,
-			keyPrefix: binding.keyPrefix
-		};
 		const call = expression ? { expression: this.range(expression) } : {};
 		if (isStringLiteral(node)) {
 			this.consumed.add(node.start);
@@ -187,7 +190,7 @@ var FileScan = class {
 			return;
 		}
 		if (node.type === "JSXExpressionContainer") {
-			if (node.expression.type !== "JSXEmptyExpression") this.addKey(node.expression, binding, namespace);
+			if (node.expression.type !== "JSXEmptyExpression") this.addKey(node.expression, base);
 			return;
 		}
 		if (node.type === "TemplateLiteral") {
@@ -209,8 +212,8 @@ var FileScan = class {
 			return;
 		}
 		if (node.type === "ConditionalExpression") {
-			this.addKey(node.consequent, binding, namespace);
-			this.addKey(node.alternate, binding, namespace);
+			this.addKey(node.consequent, base);
+			this.addKey(node.alternate, base);
 			return;
 		}
 		if (node.type === "ArrowFunctionExpression" && node.params[0]?.type === "Identifier") return this.addSelector(node.params[0].name, node.body, base);
@@ -225,6 +228,10 @@ var FileScan = class {
 			});
 			return;
 		}
+		this.addUnknown(node, base);
+	}
+	addUnknown(node, base) {
+		if (isStringLiteral(node)) this.consumed.add(node.start);
 		this.usages.push({
 			...base,
 			raw: this.text.slice(node.start, node.end),
@@ -267,10 +274,17 @@ var FileScan = class {
 	handleCall(name, args, expression) {
 		const bindings = this.lookupAll(name).filter((binding) => !binding.spec.factory);
 		for (const binding of bindings) {
-			const namespace = binding.spec.namespace ? this.stringArg(this.argValues(args, binding.spec.namespace, 1)[0]) : void 0;
+			const namespace = this.namespaceArg(args, binding.spec.namespace, 1);
+			const keyPrefix = binding.spec.keyPrefix ? this.stringArg(this.argValues(args, binding.spec.keyPrefix, 1)[0]) : void 0;
+			const base = {
+				namespace: namespace ?? binding.namespace,
+				keyPrefix: keyPrefix ?? binding.keyPrefix
+			};
 			for (const value of this.argValues(args, binding.spec.key, 0)) {
-				if (bindings.length > 1 && !("props" in value) && unwrap(value).type === "ObjectExpression") continue;
-				this.addKey(value, binding, namespace, expression);
+				if ("props" in value) continue;
+				if (bindings.length > 1 && unwrap(value).type === "ObjectExpression") continue;
+				if (binding.spec.keyPrefix && keyPrefix === void 0) this.addUnknown(unwrap(value), base);
+				else this.addKey(value, base, expression);
 			}
 		}
 		return bindings.length > 0;
@@ -321,7 +335,7 @@ var FileScan = class {
 	/** The first factory spec whose namespace and prefix sources all resolve, else the first spec. */
 	pickFactory(args, specs) {
 		const resolved = specs.map((spec) => {
-			const namespace = spec.namespace ? this.stringArg(this.argValues(args, spec.namespace, 0)[0]) : void 0;
+			const namespace = this.namespaceArg(args, spec.namespace, 0);
 			const keyPrefix = spec.keyPrefix ? this.stringArg(this.argValues(args, spec.keyPrefix, 0)[0]) : void 0;
 			const complete = (!spec.namespace || namespace !== void 0) && (!spec.keyPrefix || keyPrefix !== void 0);
 			return {
@@ -354,17 +368,49 @@ var FileScan = class {
 			if (key && local.type === "Identifier" && this.declared.has(`${key}.t`)) this.bind(`${local.name}.t`, binding);
 		}
 	}
+	/** Parameters typed as a translate function (`t: TFunction<'ns'>`), also as destructured props. */
 	params(params) {
 		for (const param of params) {
 			const target = param.type === "TSParameterProperty" ? param.parameter : param;
-			if (target.type !== "Identifier" || !target.typeAnnotation) continue;
-			const annotation = target.typeAnnotation.typeAnnotation;
-			const typeName = annotation.type === "TSTypeReference" && annotation.typeName.type === "Identifier" ? annotation.typeName.name : void 0;
-			const spec = typeName ? this.typed.get(typeName) : void 0;
-			if (spec) this.bind(target.name, { spec: {
+			const annotation = target.type === "Identifier" || target.type === "ObjectPattern" ? target.typeAnnotation?.typeAnnotation : void 0;
+			if (!annotation) continue;
+			if (target.type === "Identifier") this.bindTyped(target.name, annotation);
+			else if (target.type === "ObjectPattern") this.props(target, annotation);
+		}
+	}
+	/** `({ t }: { t: TFunction<'ns'> })`, or with an interface or type of the file. */
+	props(pattern, annotation) {
+		const members = annotation.type === "TSTypeLiteral" ? annotation.members : annotation.type === "TSTypeReference" && annotation.typeName.type === "Identifier" ? this.typeMembers.get(annotation.typeName.name) ?? [] : [];
+		for (const property of pattern.properties) {
+			if (property.type !== "Property") continue;
+			const local = unwrap(property.value);
+			const name = propertyName(property.key);
+			const member = members.find((m) => m.type === "TSPropertySignature" && !m.computed && propertyName(m.key) === name);
+			const type = member?.type === "TSPropertySignature" ? member.typeAnnotation?.typeAnnotation : void 0;
+			if (local.type === "Identifier" && type) this.bindTyped(local.name, type);
+		}
+	}
+	/** The namespace is the first type argument: `TFunction<'shared'>` or `TFunction<['shared', 'common']>`. */
+	bindTyped(name, annotation) {
+		if (annotation.type !== "TSTypeReference" || annotation.typeName.type !== "Identifier") return;
+		const spec = this.typed.get(annotation.typeName.name);
+		if (!spec) return;
+		const arg = annotation.typeArguments?.params[0];
+		const first = arg?.type === "TSTupleType" ? arg.elementTypes[0] : arg;
+		const namespace = first?.type === "TSLiteralType" && isStringLiteral(first.literal) ? first.literal.value : void 0;
+		this.bind(name, {
+			spec: {
 				...spec,
 				types: void 0
-			} });
+			},
+			namespace
+		});
+	}
+	types(program) {
+		for (const statement of program.body) {
+			const node = statement.type === "ExportNamedDeclaration" && statement.declaration ? statement.declaration : statement;
+			if (node.type === "TSInterfaceDeclaration") this.typeMembers.set(node.id.name, node.body.body);
+			else if (node.type === "TSTypeAliasDeclaration" && node.typeAnnotation.type === "TSTypeLiteral") this.typeMembers.set(node.id.name, node.typeAnnotation.members);
 		}
 	}
 	importSpecifier(node) {
@@ -532,211 +578,10 @@ function scanSource(parse, text, options) {
 		range: false
 	});
 	const scan = new FileScan(source, (options.offset ?? 0) + shift, options.calls, options.hardStrings !== false, new Set(options.ignoreCallees), options.textAttributes);
+	scan.types(result.program);
 	scan.walk(result.program, void 0, "");
 	scan.markers(result.program, result.comments);
 	return scan.result();
 }
-/** The AST scanner for JS and TS, driven by call specs (`usage.calls`). */
-function js() {
-	return {
-		name: "x18n:scanner-js",
-		scanners: [{
-			id: "js",
-			extensions: [
-				"js",
-				"jsx",
-				"mjs",
-				"cjs",
-				"ts",
-				"tsx",
-				"mts",
-				"cts"
-			],
-			async scan(file, ctx) {
-				return scanSource(await loadParser(), file.text, {
-					calls: ctx.calls,
-					filename: file.path,
-					hardStrings: true,
-					ignoreCallees: ctx.config.extract.ignoreCallees,
-					textAttributes: ctx.config.extract.attributes
-				});
-			}
-		}]
-	};
-}
-//#endregion
-//#region src/scanners/vue.ts
-let compiler;
-function loadVueCompiler() {
-	compiler ??= import("@vue/compiler-sfc");
-	return compiler;
-}
-const ELEMENT = 1;
-const TEXT = 2;
-const SIMPLE_EXPRESSION = 4;
-const INTERPOLATION = 5;
-const ATTRIBUTE = 6;
-/** `keypath` is the vue-i18n prop for a key, on `<i18n-t>` and on the app's own wrappers of it; `path` on the legacy components. */
-function isKeyAttribute(tag, name) {
-	return name === "keypath" || name === "path" && (tag === "i18n" || tag === "i18n-d");
-}
-function merge(into, result) {
-	into.usages.push(...result.usages);
-	into.keySlots.push(...result.keySlots ?? []);
-	into.hardStrings.push(...result.hardStrings ?? []);
-}
-var TemplateScan = class {
-	parse;
-	calls;
-	textAttributes;
-	out = {
-		usages: [],
-		keySlots: [],
-		hardStrings: []
-	};
-	constructor(parse, calls, textAttributes) {
-		this.parse = parse;
-		this.calls = calls;
-		this.textAttributes = textAttributes;
-	}
-	expression(content, offset) {
-		if (!content.trim()) return;
-		try {
-			merge(this.out, scanSource(this.parse, content, {
-				calls: this.calls,
-				offset,
-				filename: "template.ts",
-				expression: true,
-				hardStrings: false
-			}));
-		} catch {}
-	}
-	/** `:keypath="cond ? 'a' : 'b'"`: the expression is read as the key argument of a translate call. */
-	keyExpression(content, offset) {
-		const callee = "__x18nKey(";
-		try {
-			const result = scanSource(this.parse, `${callee}${content})`, {
-				calls: [{ callee: "__x18nKey" }],
-				offset: offset - 10,
-				filename: "template.ts",
-				hardStrings: false
-			});
-			merge(this.out, {
-				...result,
-				usages: result.usages.map(({ expression: _, ...usage }) => usage)
-			});
-		} catch {}
-	}
-	/** `v-t="'key'"` and `v-t="{ path: 'key' }"`. */
-	vt(dir) {
-		const exp = dir.exp;
-		if (!exp || !("content" in exp)) return;
-		const offset = exp.loc.start.offset;
-		const literal = /^\s*(['"`])(.*)\1\s*$/.exec(exp.content) ?? /path\s*:\s*(['"`])(.*?)\1/.exec(exp.content);
-		if (!literal) return;
-		const start = offset + exp.content.indexOf(literal[2], literal.index);
-		const range = {
-			start,
-			end: start + literal[2].length
-		};
-		this.out.usages.push({
-			raw: literal[2],
-			range,
-			kind: "call",
-			dynamic: false
-		});
-		this.out.keySlots.push(range);
-	}
-	attribute(element, prop) {
-		if (prop.type === ATTRIBUTE) {
-			const value = prop.value;
-			if (!value) return;
-			const range = {
-				start: value.loc.start.offset + 1,
-				end: value.loc.end.offset - 1
-			};
-			if (isKeyAttribute(element.tag, prop.name)) {
-				this.out.usages.push({
-					raw: value.content,
-					range,
-					kind: "call",
-					dynamic: false
-				});
-				this.out.keySlots.push(range);
-			} else if (isTextAttribute(prop.name, this.textAttributes) && /\p{L}/u.test(value.content)) this.out.hardStrings.push({
-				text: value.content,
-				range: {
-					start: prop.loc.start.offset,
-					end: prop.loc.end.offset
-				},
-				kind: "vue-attribute",
-				attribute: prop.name
-			});
-			return;
-		}
-		if (prop.name === "t") {
-			this.vt(prop);
-			return;
-		}
-		const exp = prop.exp;
-		if (exp && "content" in exp) {
-			if (prop.name === "bind" && prop.arg && "content" in prop.arg && isKeyAttribute(element.tag, prop.arg.content)) this.keyExpression(exp.content, exp.loc.start.offset);
-			else this.expression(exp.content, exp.loc.start.offset);
-		}
-	}
-	node(node) {
-		if (node.type === INTERPOLATION && "content" in node.content) this.expression(node.content.content, node.content.loc.start.offset);
-		if (node.type === TEXT) {
-			const text = node.content.trim();
-			if (text && /\p{L}/u.test(text)) {
-				const start = node.loc.start.offset + node.content.indexOf(text);
-				this.out.hardStrings.push({
-					text,
-					range: {
-						start,
-						end: start + text.length
-					},
-					kind: "vue-template-text"
-				});
-			}
-		}
-		if (node.type === ELEMENT) for (const prop of node.props) this.attribute(node, prop);
-		if ("children" in node) {
-			for (const child of node.children) if (typeof child === "object" && child.type !== SIMPLE_EXPRESSION) this.node(child);
-		}
-	}
-};
-/** Vue SFCs: `<script>` through the `js` scanner, template expressions, `v-t`, `<i18n-t keypath>`. */
-function vue() {
-	return {
-		name: "x18n:scanner-vue",
-		scanners: [{
-			id: "vue",
-			extensions: ["vue"],
-			async scan(file, ctx) {
-				const [{ parse }, parseJs] = await Promise.all([loadVueCompiler(), loadParser()]);
-				const { descriptor } = parse(file.text, {
-					filename: file.path,
-					sourceMap: false,
-					ignoreEmpty: false
-				});
-				const template = new TemplateScan(parseJs, ctx.calls, ctx.config.extract.attributes);
-				for (const script of [descriptor.script, descriptor.scriptSetup]) {
-					if (!script) continue;
-					const lang = script.lang ?? "js";
-					merge(template.out, scanSource(parseJs, script.content, {
-						calls: ctx.calls,
-						ignoreCallees: ctx.config.extract.ignoreCallees,
-						textAttributes: ctx.config.extract.attributes,
-						offset: script.loc.start.offset,
-						filename: `script.${lang === "tsx" || lang === "jsx" ? lang : lang === "ts" ? "ts" : "js"}`
-					}));
-				}
-				if (descriptor.template?.ast) template.node(descriptor.template.ast);
-				return template.out;
-			}
-		}]
-	};
-}
 //#endregion
-export { js as a, isTextAttribute as i, vue as n, loadParser as o, calleeName as r, scanSource as s, loadVueCompiler as t };
+export { loadParser as n, scanSource as r, isTextAttribute as t };

package/dist/json-CyjI8bjp.d.mts

@@ -0,0 +1,8 @@
+import "@x18n/core";
+//#region src/formats/shared/json.d.ts
+interface JsonOptions {
+  /** Spaces per level for new files. Existing files keep their indent. */
+  readonly indent?: number;
+}
+//#endregion
+export { JsonOptions as t };

package/dist/json-Db-8qSbE.mjs

@@ -0,0 +1,73 @@
+import { n as detectEol, r as detectIndent } from "./shared-BWaXUmwA.mjs";
+import { diffText, errors, pathId } from "@x18n/core";
+import { applyEdits, modify, parseTree, printParseErrorCode } from "jsonc-parser";
+//#region src/formats/shared/json.ts
+function readTree(node, path, ranges) {
+	const out = {};
+	for (const property of node.children ?? []) {
+		const [keyNode, valueNode] = property.children ?? [];
+		if (!keyNode || !valueNode || typeof keyNode.value !== "string") continue;
+		const key = keyNode.value;
+		const childPath = [...path, key];
+		ranges.set(pathId(childPath), {
+			key: {
+				start: keyNode.offset + 1,
+				end: keyNode.offset + keyNode.length - 1
+			},
+			value: {
+				start: valueNode.offset,
+				end: valueNode.offset + valueNode.length
+			}
+		});
+		if (valueNode.type === "object") out[key] = readTree(valueNode, childPath, ranges);
+		else if (valueNode.type === "string" || valueNode.type === "number" || valueNode.type === "boolean" || valueNode.type === "null") out[key] = valueNode.value;
+	}
+	return out;
+}
+function createJsonFormat(id, extensions, allowComments, defaultIndent) {
+	return {
+		id,
+		extensions,
+		parse(text, ctx) {
+			const problems = [];
+			const root = parseTree(text, problems, {
+				allowTrailingComma: true,
+				disallowComments: !allowComments
+			});
+			if (problems.length > 0) {
+				const first = problems[0];
+				throw errors.X18N2002({
+					path: ctx.path,
+					reason: `${printParseErrorCode(first.error)} at offset ${first.offset}`
+				});
+			}
+			if (!root || root.type !== "object") {
+				if (text.trim() === "") return {
+					tree: {},
+					ranges: /* @__PURE__ */ new Map()
+				};
+				throw errors.X18N2003({ path: ctx.path });
+			}
+			const ranges = /* @__PURE__ */ new Map();
+			return {
+				tree: readTree(root, [], ranges),
+				ranges
+			};
+		},
+		edit(text, ops, ctx) {
+			const formattingOptions = {
+				...detectIndent(text, ctx.indent ?? defaultIndent),
+				eol: detectEol(text)
+			};
+			let next = text.trim() === "" ? "{}\n" : text;
+			for (const op of ops) next = applyEdits(next, modify(next, [...op.path], op.type === "set" ? op.value : void 0, { formattingOptions }));
+			return diffText(text, next);
+		},
+		serialize(tree, ctx) {
+			const indent = ctx.indent ?? defaultIndent ?? 2;
+			return `${JSON.stringify(tree, null, indent === "tab" ? "	" : indent)}\n`;
+		}
+	};
+}
+//#endregion
+export { createJsonFormat as t };

package/dist/jsx-templates-B1J0no3i.mjs

@@ -0,0 +1,17 @@
+//#region src/presets/shared/jsx-templates.ts
+const jsxTemplates = [
+	{
+		template: "{t('{key}'{args})}",
+		kinds: ["jsx-text"]
+	},
+	{
+		template: "{attr}={t('{key}'{args})}",
+		kinds: ["jsx-attribute"]
+	},
+	{
+		template: "t('{key}'{args})",
+		kinds: ["js-string", "js-template"]
+	}
+];
+//#endregion
+export { jsxTemplates 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 };