@x18n/builtins 0.0.13 → 0.0.15

package/dist/formats.d.mts

@@ -1,34 +1,10 @@
-import { Plugin } from "@x18n/core";
-//#region src/formats/ecmascript.d.ts
-export declare function ecmascript(): Plugin;
-//#endregion
-//#region src/formats/ftl.d.ts
-export declare function ftl(): Plugin;
-//#endregion
-//#region src/formats/ini.d.ts
-export declare function ini(): Plugin;
-//#endregion
-//#region src/formats/json.d.ts
-interface JsonOptions {
-  /** Spaces per level for new files. Existing files keep their indent. */
-  readonly indent?: number;
-}
-export declare function json(options?: JsonOptions): Plugin;
-export declare function jsonc(options?: JsonOptions): Plugin;
-//#endregion
-//#region src/formats/json5.d.ts
-export declare function json5(): Plugin;
-//#endregion
-//#region src/formats/php.d.ts
-export declare function php(): Plugin;
-//#endregion
-//#region src/formats/po.d.ts
-export declare function po(): Plugin;
-//#endregion
-//#region src/formats/properties.d.ts
-export declare function properties(): Plugin;
-//#endregion
-//#region src/formats/yaml.d.ts
-export declare function yaml(): Plugin;
-//#endregion
-export type { JsonOptions };
+import { FormatEntry } from "@x18n/core";
+//#region src/formats/index.d.ts
+/**
+ * Built-in formats by id, in claim order. A format is a folder: `<name>/entry.ts` holds its extensions and a
+ * `load` for `<name>/index.ts`, the format itself, which is imported when a file of that format is first read.
+ */
+export declare const formats: {
+  readonly [id: string]: FormatEntry;
+};
+//#endregion

package/dist/formats.mjs

@@ -1 +1,61 @@
-export { u as ecmascript, l as ftl, c as ini, o as json, a as json5, s as jsonc, i as php, r as po, n as properties, t as yaml } from "./formats-CFkM5co0.mjs";
+//#endregion
+//#region src/formats/index.ts
+/**
+* Built-in formats by id, in claim order. A format is a folder: `<name>/entry.ts` holds its extensions and a
+* `load` for `<name>/index.ts`, the format itself, which is imported when a file of that format is first read.
+*/
+const formats = {
+	json: {
+		extensions: ["json"],
+		load: () => import("./formats/json.mjs")
+	},
+	jsonc: {
+		extensions: ["jsonc"],
+		load: () => import("./formats/jsonc.mjs")
+	},
+	json5: {
+		extensions: ["json5"],
+		load: () => import("./formats/json5.mjs")
+	},
+	yaml: {
+		extensions: ["yml", "yaml"],
+		load: () => import("./formats/yaml.mjs")
+	},
+	po: {
+		extensions: ["po", "pot"],
+		load: () => import("./formats/po.mjs")
+	},
+	properties: {
+		extensions: ["properties"],
+		load: () => import("./formats/properties.mjs")
+	},
+	resx: {
+		extensions: ["resx"],
+		load: () => import("./formats/resx.mjs")
+	},
+	ftl: {
+		extensions: ["ftl"],
+		load: () => import("./formats/ftl.mjs")
+	},
+	ini: {
+		extensions: ["ini"],
+		load: () => import("./formats/ini.mjs")
+	},
+	php: {
+		extensions: ["php"],
+		load: () => import("./formats/php.mjs")
+	},
+	js: {
+		extensions: [
+			"js",
+			"mjs",
+			"cjs",
+			"ts",
+			"mts",
+			"cts"
+		],
+		load: () => import("./formats/ecmascript.mjs")
+	}
+};
+//#endregion
+export { formats };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { Builtins } from "@x18n/core";
 //#region src/index.d.ts
-/** Plugins that are always on, and the presets that `'auto'` detects. */
-export declare function createBuiltins(): Builtins;
+/** Plugins that are always on, and the presets that `'auto'` detects. Formats, scanners and presets load on demand; `regex` and the reporters are always loaded. */
+export declare function createBuiltins(): Promise<Builtins>;
 //#endregion

package/dist/index.mjs

@@ -1,35 +1,43 @@
 import { recommended } from "./checks.mjs";
 import { i as pattern } from "./finders-CqTGh4OJ.mjs";
-import { a as json5, c as ini, i as php, l as ftl, n as properties, o as json, r as po, s as jsonc, t as yaml, u as ecmascript } from "./formats-CFkM5co0.mjs";
-import { a as js, n as vue } from "./vue-CF4pe-Yr.mjs";
 import { manifests } from "./manifests.mjs";
-import { n as regex } from "./regex-AYVhuSb6.mjs";
-import { t as presets } from "./presets-Co5SlnKr.mjs";
-import { reporters } from "./reporters.mjs";
-import { t as svelte } from "./scanners-DhnnVp7s.mjs";
+import { reviews } from "./reviews.mjs";
+import { formats } from "@x18n/builtins/formats";
+import { presets } from "@x18n/builtins/presets";
+import { reporters } from "@x18n/builtins/reporters";
+import { scanners } from "@x18n/builtins/scanners";
+import regex from "@x18n/builtins/scanners/regex";
 //#region src/index.ts
-/** Plugins that are always on, and the presets that `'auto'` detects. */
-function createBuiltins() {
+/** Plugins that are always on, and the presets that `'auto'` detects. Formats, scanners and presets load on demand; `regex` and the reporters are always loaded. */
+async function createBuiltins() {
+	const formatPlugins = Object.entries(formats).map(([id, entry]) => ({
+		name: `x18n:format-${id}`,
+		lazyFormats: [{
+			id,
+			...entry
+		}]
+	}));
+	const scannerPlugins = Object.entries(scanners).map(([id, entry]) => ({
+		name: `x18n:scanner-${id}`,
+		lazyScanners: [{
+			id,
+			...entry
+		}]
+	}));
+	const reporterPlugin = {
+		name: "x18n:reporters",
+		reporters: await Promise.all(Object.values(reporters).map(async (load) => (await load()).default))
+	};
 	return {
 		plugins: [
 			manifests(),
-			json(),
-			jsonc(),
-			json5(),
-			yaml(),
-			po(),
-			properties(),
-			ftl(),
-			ini(),
-			php(),
-			ecmascript(),
+			...formatPlugins,
 			pattern(),
-			js(),
-			vue(),
-			svelte(),
+			...scannerPlugins,
 			regex(),
 			recommended(),
-			reporters()
+			reviews(),
+			reporterPlugin
 		],
 		presets
 	};

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-CGNSGS97.mjs

@@ -0,0 +1,109 @@
+import { r as indentUnit } from "./shared-C7ceptwi.mjs";
+import { t as editLiteral } from "./literal-gIdB1VGy.mjs";
+import { diffText, errors, pathId } from "@x18n/core";
+import { 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 objectOf(node) {
+	const items = [];
+	for (const property of node.children ?? []) {
+		const [keyNode, valueNode] = property.children ?? [];
+		if (!keyNode || !valueNode || typeof keyNode.value !== "string") continue;
+		items.push({
+			key: keyNode.value,
+			range: {
+				start: property.offset,
+				end: property.offset + property.length
+			},
+			value: valueNode.type === "object" ? objectOf(valueNode) : {
+				kind: "scalar",
+				range: {
+					start: valueNode.offset,
+					end: valueNode.offset + valueNode.length
+				},
+				quote: void 0
+			}
+		});
+	}
+	return {
+		kind: "object",
+		range: {
+			start: node.offset,
+			end: node.offset + node.length
+		},
+		items
+	};
+}
+/** The root object, or undefined for an empty file. */
+function parseRoot(text, path, allowComments) {
+	const problems = [];
+	const root = parseTree(text, problems, {
+		allowTrailingComma: true,
+		disallowComments: !allowComments
+	});
+	if (problems.length > 0) {
+		const first = problems[0];
+		throw errors.X18N2002({
+			path,
+			reason: `${printParseErrorCode(first.error)} at offset ${first.offset}`
+		});
+	}
+	if (root?.type === "object") return root;
+	if (text.trim() === "") return void 0;
+	throw errors.X18N2003({ path });
+}
+function createJsonFormat(id, extensions, allowComments, defaultIndent) {
+	return {
+		id,
+		extensions,
+		parse(text, ctx) {
+			const root = parseRoot(text, ctx.path, allowComments);
+			const ranges = /* @__PURE__ */ new Map();
+			return {
+				tree: root ? readTree(root, [], ranges) : {},
+				ranges
+			};
+		},
+		edit(text, ops, ctx) {
+			const syntax = {
+				open: "{",
+				close: "}",
+				separator: ": ",
+				key: (key) => JSON.stringify(key),
+				leaf: (value) => JSON.stringify(value),
+				unit: indentUnit(text, ctx.indent ?? defaultIndent, "  "),
+				trailingComma: false
+			};
+			let next = text.trim() === "" ? "{}\n" : text;
+			for (const op of ops) next = editLiteral(next, objectOf(parseRoot(next, ctx.path, allowComments)), op, syntax);
+			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/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/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 };