@x18n/builtins 0.0.12 → 0.0.14

package/dist/{vue-5GFR5hft.mjs → js-CV-ECNJG.mjs}

@@ -1,30 +1,30 @@
-//#region src/scanners/js.ts
-const hardStringIgnoredAttributes = /* @__PURE__ */ new Set([
-	"class",
-	"className",
-	"style",
-	"key",
-	"ref",
-	"id",
-	"href",
-	"src",
-	"type",
-	"name",
-	"for",
-	"htmlFor",
-	"role",
-	"slot",
-	"as",
-	"to",
-	"target",
-	"rel",
-	"lang",
-	"xmlns",
-	"viewBox",
-	"d",
-	"fill",
-	"stroke"
+//#region src/scanners/shared/js.ts
+const textAttributeWords = /* @__PURE__ */ new Set([
+	"title",
+	"subtitle",
+	"label",
+	"text",
+	"placeholder",
+	"alt",
+	"content",
+	"description",
+	"caption",
+	"message",
+	"tooltip",
+	"hint",
+	"summary",
+	"heading",
+	"headline"
 ]);
+/**
+* Markup attributes whose values users read: those whose last word is a text word (`title`, `aria-label`,
+* `confirmText`, `empty-message`), plus `extract.attributes`. Every other attribute holds code: classes,
+* URLs, ids, SVG geometry, attributify utilities.
+*/
+function isTextAttribute(name, extra = []) {
+	const last = name.replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase().split(/[-_:.]/).at(-1);
+	return textAttributeWords.has(last) || extra.includes(name);
+}
 function isNode(value) {
 	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string" && "start" in value;
 }
@@ -73,6 +73,7 @@ var FileScan = class {
 	offset;
 	collectHardStrings;
 	ignoredCallees;
+	textAttributes;
 	usages = [];
 	keySlots = [];
 	hardStrings = [];
@@ -82,12 +83,17 @@ 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();
-	constructor(text, offset, calls, collectHardStrings, ignoredCallees = /* @__PURE__ */ new Set()) {
+	/** Render-prop functions of factory components (`<Translation>{t => ...}</Translation>`), by start offset. */
+	renderProps = /* @__PURE__ */ new Map();
+	constructor(text, offset, calls, collectHardStrings, ignoredCallees = /* @__PURE__ */ new Set(), textAttributes = []) {
 		this.text = text;
 		this.offset = offset;
 		this.collectHardStrings = collectHardStrings;
 		this.ignoredCallees = ignoredCallees;
+		this.textAttributes = textAttributes;
 		for (const spec of calls) for (const name of [spec.callee].flat()) if (spec.factory) {
 			const list = this.factories.get(name) ?? [];
 			this.factories.set(name, list);
@@ -141,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;
@@ -160,18 +171,17 @@ var FileScan = class {
 		return object.properties.flatMap((p) => p.type === "Property" ? [p.value] : []);
 	}
 	/** ---- Usages ---- */
-	addKey(value, binding, namespace) {
+	/** `expression` is the call holding `value`, kept only when the key is the call's own literal. */
+	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);
 			this.keySlots.push(this.range(innerRange(node)));
 			this.usages.push({
 				...base,
+				...call,
 				raw: node.value,
 				range: this.range(innerRange(node)),
 				kind: "call",
@@ -180,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") {
@@ -193,6 +203,7 @@ var FileScan = class {
 			});
 			this.usages.push({
 				...base,
+				...call,
 				raw,
 				range,
 				kind: "call",
@@ -201,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);
@@ -217,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),
@@ -256,30 +271,49 @@ var FileScan = class {
 		const object = this.constants.get(node.object.name);
 		return object && object.type === "ObjectExpression" ? objectProperty(object, node.property.name) : void 0;
 	}
-	handleCall(name, args) {
+	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);
+				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;
 	}
 	call(node) {
 		const name = calleeName(node.callee);
-		if (name !== void 0) this.handleCall(name, node.arguments);
+		if (name !== void 0) this.handleCall(name, node.arguments, {
+			start: node.start,
+			end: node.end
+		});
 	}
-	jsx(node) {
-		const name = jsxName(node.name);
-		if (!name || !this.lookup(name)) return;
+	jsxProps(node) {
 		const props = /* @__PURE__ */ new Map();
 		for (const attribute of node.attributes) if (attribute.type === "JSXAttribute" && attribute.value && attribute.name.type === "JSXIdentifier") {
 			props.set(attribute.name.name, attribute.value);
 			if (isStringLiteral(attribute.value)) this.consumed.add(attribute.value.start);
 		}
-		this.handleCall(name, [{ props }]);
+		return { props };
+	}
+	jsx(node) {
+		const name = jsxName(node.name);
+		if (name && this.lookup(name)) this.handleCall(name, [this.jsxProps(node)]);
+	}
+	jsxElement(node) {
+		const name = jsxName(node.openingElement.name);
+		const specs = name ? this.factories.get(name) : void 0;
+		if (!specs) return;
+		const binding = this.pickFactory([this.jsxProps(node.openingElement)], specs);
+		for (const child of node.children) if (child.type === "JSXExpressionContainer" && (child.expression.type === "ArrowFunctionExpression" || child.expression.type === "FunctionExpression")) this.renderProps.set(child.expression.start, binding);
 	}
 	/** ---- Bindings ---- */
 	declarator(id, init) {
@@ -289,7 +323,7 @@ var FileScan = class {
 		if (value.type === "CallExpression") {
 			const factory = calleeName(value.callee);
 			const specs = factory ? this.factories.get(factory) : void 0;
-			if (specs) this.bindFactory(id, value, specs);
+			if (specs) this.bindFactory(id, value.arguments, specs);
 			return;
 		}
 		if (id.type === "Identifier" && (value.type === "Identifier" || value.type === "MemberExpression")) {
@@ -299,10 +333,10 @@ var FileScan = class {
 		}
 	}
 	/** The first factory spec whose namespace and prefix sources all resolve, else the first spec. */
-	pickFactory(call, specs) {
+	pickFactory(args, specs) {
 		const resolved = specs.map((spec) => {
-			const namespace = spec.namespace ? this.stringArg(this.argValues(call.arguments, spec.namespace, 0)[0]) : void 0;
-			const keyPrefix = spec.keyPrefix ? this.stringArg(this.argValues(call.arguments, spec.keyPrefix, 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 {
 				binding: {
@@ -318,8 +352,8 @@ var FileScan = class {
 		});
 		return (resolved.find((r) => r.complete) ?? resolved[0]).binding;
 	}
-	bindFactory(id, call, specs) {
-		const binding = this.pickFactory(call, specs);
+	bindFactory(id, args, specs) {
+		const binding = this.pickFactory(args, specs);
 		const returns = (binding.spec.returns ?? ["t"]).filter((name) => !name.includes("."));
 		if (id.type === "Identifier") {
 			this.bind(id.name, binding);
@@ -334,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) {
@@ -383,6 +449,9 @@ var FileScan = class {
 			case "CallExpression":
 				this.call(node);
 				break;
+			case "JSXElement":
+				this.jsxElement(node);
+				break;
 			case "JSXOpeningElement":
 				this.jsx(node);
 				break;
@@ -391,9 +460,12 @@ var FileScan = class {
 				break;
 			case "FunctionDeclaration":
 			case "FunctionExpression":
-			case "ArrowFunctionExpression":
+			case "ArrowFunctionExpression": {
 				this.params(node.params);
+				const binding = this.renderProps.get(node.start);
+				if (binding && node.params[0]?.type === "Identifier") this.bind(node.params[0].name, binding);
 				break;
+			}
 			case "ImportSpecifier":
 				this.importSpecifier(node);
 				break;
@@ -413,7 +485,7 @@ var FileScan = class {
 		if (this.consumed.has(node.start) || !parent) return;
 		if (parent.type === "JSXAttribute") {
 			const name = parent.name.type === "JSXIdentifier" ? parent.name.name : "";
-			if (isStringLiteral(node) && !hardStringIgnoredAttributes.has(name) && !name.startsWith("data-") && !name.startsWith("aria-")) this.hard(node.value, {
+			if (isStringLiteral(node) && isTextAttribute(name, this.textAttributes)) this.hard(node.value, {
 				start: parent.start,
 				end: parent.end
 			}, "jsx-attribute", name);
@@ -505,223 +577,11 @@ function scanSource(parse, text, options) {
 		sourceType: "module",
 		range: false
 	});
-	const scan = new FileScan(source, (options.offset ?? 0) + shift, options.calls, options.hardStrings !== false, new Set(options.ignoreCallees));
+	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
-				});
-			}
-		}]
-	};
-}
-//#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");
-}
-const ignoredAttributes = /* @__PURE__ */ new Set([
-	"class",
-	"style",
-	"key",
-	"ref",
-	"id",
-	"name",
-	"type",
-	"href",
-	"src",
-	"to",
-	"for",
-	"role",
-	"lang",
-	"target",
-	"rel",
-	"is",
-	"slot"
-]);
-function merge(into, result) {
-	into.usages.push(...result.usages);
-	into.keySlots.push(...result.keySlots ?? []);
-	into.hardStrings.push(...result.hardStrings ?? []);
-}
-var TemplateScan = class {
-	parse;
-	calls;
-	out = {
-		usages: [],
-		keySlots: [],
-		hardStrings: []
-	};
-	constructor(parse, calls) {
-		this.parse = parse;
-		this.calls = calls;
-	}
-	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 {
-			merge(this.out, scanSource(this.parse, `${callee}${content})`, {
-				calls: [{ callee: "__x18nKey" }],
-				offset: offset - 10,
-				filename: "template.ts",
-				hardStrings: false
-			}));
-		} 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 (!ignoredAttributes.has(prop.name) && !prop.name.startsWith("data-") && /\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);
-				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,
-						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 { loadParser as a, js as i, vue as n, scanSource as o, calleeName as r, 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 };