@x18n/builtins 0.0.12 → 0.0.14

package/dist/angular-templates-DqIOGfzT.mjs

@@ -0,0 +1,8 @@
+//#region src/presets/shared/angular-templates.ts
+const angularTemplates = [
+	"html",
+	"ts",
+	"js"
+];
+//#endregion
+export { angularTemplates as t };

package/dist/checks.mjs

@@ -32,7 +32,7 @@ const missingKey = {
 const missingTranslation = {
 	id: "missing-translation",
 	defaultSeverity: "warning",
-	description: "A source-locale key that target locales lack. One diagnostic per key, at the source entry.",
+	description: "A source-locale key that target locales lack, or a plural form their language needs. One diagnostic per key, at the source entry.",
 	*run(ctx) {
 		const missing = /* @__PURE__ */ new Map();
 		for (const coverage of ctx.coverage()) {
@@ -44,7 +44,8 @@ const missingTranslation = {
 			}
 		}
 		for (const [key, locales] of missing) {
-			const source = ctx.message(key, ctx.sourceLocale);
+			const other = ctx.formOf(key)?.keyOf("other");
+			const source = ctx.message(key, ctx.sourceLocale) ?? (other === void 0 ? void 0 : ctx.message(other, ctx.sourceLocale));
 			yield {
 				key,
 				locale: ctx.sourceLocale,

package/dist/extractors.d.mts

@@ -3,12 +3,12 @@ import { ExtractItem, ExtractOptions, ExtractTemplate, HardString, KeyString, Pr
 export type Score = "must-include" | "should-include" | "none" | "should-exclude" | "must-exclude";
 export interface ExtractionRule {
   readonly id: string;
-  readonly test: (text: string, kind: string) => Score;
+  readonly test: (text: string, kind: string, attribute: string | undefined) => Score;
 }
 /** Built-in rules, applied in order. A `must-*` wins at once; otherwise the last `should-*` decides. */
 export declare const rules: readonly ExtractionRule[];
 /** Folds rule scores the i18n-ally way (`shouldExtract`). */
-export declare function shouldExtract(text: string, kind: string, list?: readonly ExtractionRule[]): boolean;
+export declare function shouldExtract(text: string, kind: string, list?: readonly ExtractionRule[], attribute?: string): boolean;
 export type KeyCase = "camel" | "snake" | "kebab" | "dot";
 /** "Forgot password?" becomes `forgotPassword` (camel), `forgot_password`, `forgot-password` or `forgot.password`. */
 export declare function slugify(text: string, keyCase?: KeyCase, maxLength?: number): string;

package/dist/extractors.mjs

@@ -4,6 +4,7 @@ const textKinds = /* @__PURE__ */ new Set([
 	"jsx-text",
 	"vue-template-text",
 	"svelte-text",
+	"astro-text",
 	"html-text"
 ]);
 /** Built-in rules, applied in order. A `must-*` wins at once; otherwise the last `should-*` decides. */
@@ -43,6 +44,14 @@ const rules = [
 			return tokens.every((t) => /^!?[a-z][\w:/[\].#%!-]*$/.test(t)) && tokens.filter((t) => /[-:!/[\d]/.test(t)).length * 2 > tokens.length ? "must-exclude" : "none";
 		}
 	},
+	{
+		id: "attributify",
+		test: (text, kind, attribute) => kind.endsWith("attribute") && (attribute === "text" || attribute?.includes(":") === true) && text.trim().split(/\s+/).every((t) => /^!?-?[a-z\d$[(][\w:/[\]().,#%!$+~-]*$/.test(t)) ? "must-exclude" : "none"
+	},
+	{
+		id: "css-value",
+		test: (text) => /^-?[a-z][\w-]*\(.*\)$/s.test(text.trim()) || /\bvar\(--/.test(text) ? "must-exclude" : "none"
+	},
 	{
 		id: "non-ascii",
 		test: (text) => /\P{ASCII}/u.test(text) && /\p{L}/u.test(text) ? "must-include" : "none"
@@ -80,10 +89,10 @@ function isExtractableFile(path) {
 	return !nonUiFiles.some((pattern) => pattern.test(path));
 }
 /** Folds rule scores the i18n-ally way (`shouldExtract`). */
-function shouldExtract(text, kind, list = rules) {
+function shouldExtract(text, kind, list = rules, attribute) {
 	let result = "none";
 	for (const rule of list) {
-		const score = rule.test(text, kind);
+		const score = rule.test(text, kind, attribute);
 		if (score === "must-include") return true;
 		if (score === "must-exclude") return false;
 		if (score !== "none") result = score;
@@ -115,11 +124,11 @@ function slugify(text, keyCase = "camel", maxLength = 40) {
 const defaultTemplates = [
 	{
 		template: "{t('{key}'{args})}",
-		kinds: ["jsx-text"]
+		kinds: ["jsx-text", "astro-text"]
 	},
 	{
 		template: "{attr}={t('{key}'{args})}",
-		kinds: ["jsx-attribute"]
+		kinds: ["jsx-attribute", "astro-attribute"]
 	},
 	{
 		template: "{{ $t('{key}'{args}) }}",
@@ -216,7 +225,7 @@ function commentIgnores(text) {
 function* extractableHardStrings(options, hardStrings, textOf) {
 	const ignores = /* @__PURE__ */ new Map();
 	for (const hard of hardStrings) {
-		if (!isExtractableFile(hard.path) || !shouldExtract(hard.text, hard.kind) || ignoredByConfig(options, hard)) continue;
+		if (!isExtractableFile(hard.path) || !shouldExtract(hard.text, hard.kind, rules, hard.attribute) || ignoredByConfig(options, hard)) continue;
 		let ignored = ignores.get(hard.path);
 		if (!ignored) {
 			const text = textOf(hard.path);
@@ -250,7 +259,10 @@ function quoteKey(before, key) {
 	return inAttribute ? out.replace(/&/g, "&").replace(/"/g, """) : out;
 }
 function fillTemplate(template, values) {
-	return template.replace(/\{(key|attr|args)\}/g, (_, name, at) => name === "key" ? quoteKey(template.slice(0, at), values.key) : values[name]);
+	return template.replace(/\{(key|attr|args)\}/g, (_, name, at) => {
+		if (name === "key") return quoteKey(template.slice(0, at), values.key);
+		return name === "args" && template[at - 1] === "(" ? values.args.replace(/^, /, "") : values[name];
+	});
 }
 /** Hard strings worth extracting, with proposed keys, values and replacements. */
 function findCandidates(project, options = {}) {

package/dist/finders.d.mts

@@ -23,7 +23,10 @@ export declare const patternFinder: LocaleFinder;
 export declare function pattern(): Plugin;
 //#endregion
 //#region src/finders/sfc-blocks.d.ts
-/** Vue `<i18n>` blocks: one resource per block and locale (`locale="en"`, or every top-level locale key). */
+/**
+ * Vue `<i18n>` blocks: one resource per block and locale (`locale="en"`, or every top-level locale key).
+ * A block with `src` is a resource in the referenced file, so edits go there.
+ */
 export declare function sfcBlocks(): Plugin;
 /** fluent-vue `<fluent locale="en">` blocks in Vue SFCs, read with the `ftl` format. */
 export declare function sfcFluentBlocks(): Plugin;

package/dist/finders.mjs

@@ -1,3 +1,3 @@
 import { a as patternFinder, i as pattern, n as guessResources, r as namespaceFromPath, t as compilePattern } from "./finders-CqTGh4OJ.mjs";
-import { n as sfcFluentBlocks, t as sfcBlocks } from "./sfc-blocks-BIPqKcvd.mjs";
+import { n as sfcFluentBlocks, t as sfcBlocks } from "./sfc-blocks-DaGKDZsb.mjs";
 export { compilePattern, guessResources, namespaceFromPath, pattern, patternFinder, sfcBlocks, sfcFluentBlocks };

package/dist/formats/ecmascript.d.mts

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

package/dist/formats/ecmascript.mjs

@@ -0,0 +1,211 @@
+import { a as splice } from "../shared-BWaXUmwA.mjs";
+import { applyMessageOps, diffText, errors, isMessageLeaf, pathId } from "@x18n/core";
+import { parseSync } from "oxc-parser";
+//#region src/formats/ecmascript/index.ts
+/** Type-only wrappers, `defineX({ ... })` helpers that return their argument, and loaders that only return an object (`defineI18nLocale(() => ({ ... }))`). */
+function unwrap(node) {
+	if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "ParenthesizedExpression") return unwrap(node.expression);
+	if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") return unwrap(node.body);
+	if ((node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") && node.body?.type === "BlockStatement") {
+		const [only, ...rest] = node.body.body;
+		if (only?.type === "ReturnStatement" && only.argument && rest.length === 0) return unwrap(only.argument);
+	}
+	const argument = node.type === "CallExpression" && node.arguments.length === 1 ? node.arguments[0] : void 0;
+	if (node.type === "CallExpression" && node.callee.type === "Identifier" && /^define[A-Z]/.test(node.callee.name) && argument && argument.type !== "SpreadElement") return unwrap(argument);
+	return node;
+}
+function findRoot(program, fail) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of program.body) {
+		if (statement.type !== "VariableDeclaration") continue;
+		for (const declarator of statement.declarations) if (declarator.id.type === "Identifier" && declarator.init) bindings.set(declarator.id.name, declarator.init);
+	}
+	let exported;
+	for (const statement of program.body) if (statement.type === "ExportDefaultDeclaration" && statement.declaration.type !== "FunctionDeclaration" && statement.declaration.type !== "ClassDeclaration" && statement.declaration.type !== "TSInterfaceDeclaration") exported = statement.declaration;
+	else if (statement.type === "ExpressionStatement" && statement.expression.type === "AssignmentExpression" && isModuleExports(statement.expression.left)) exported = statement.expression.right;
+	else if (statement.type === "ExportDefaultDeclaration") fail("X18N2004", statement, "the default export is not an object literal");
+	if (!exported) return program.body.length === 0 ? void 0 : fail("X18N2004", program, "no `export default { ... }` or `module.exports = { ... }`");
+	let root = unwrap(exported);
+	if (root.type === "Identifier" && bindings.has(root.name)) root = unwrap(bindings.get(root.name));
+	if (root.type === "ObjectExpression") return root;
+	return fail(root.type === "Literal" || root.type === "ArrayExpression" ? "X18N2003" : "X18N2004", root, "the default export is not an object literal");
+}
+function isModuleExports(node) {
+	return node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && node.object.name === "module" && node.property.type === "Identifier" && node.property.name === "exports";
+}
+function readProperty(property, fail) {
+	if (property.type === "SpreadElement" || property.kind !== "init" || property.method || property.shorthand) return fail("X18N2004", property, "only `key: value` properties are static");
+	const { key, value } = property;
+	if (key.type === "Identifier" && !property.computed) return {
+		key: key.name,
+		range: {
+			start: key.start,
+			end: key.end
+		},
+		value: unwrap(value)
+	};
+	if (key.type === "Literal" && (typeof key.value === "string" || typeof key.value === "number")) return {
+		key: String(key.value),
+		range: typeof key.value === "string" ? {
+			start: key.start + 1,
+			end: key.end - 1
+		} : {
+			start: key.start,
+			end: key.end
+		},
+		value: unwrap(value)
+	};
+	return fail("X18N2004", key, "computed keys are not static");
+}
+function readLeaf(node, text) {
+	if (node.type === "Literal" && !("regex" in node) && typeof node.value !== "bigint") return {
+		value: node.value,
+		quote: typeof node.value === "string" ? text[node.start] : void 0
+	};
+	if (node.type === "TemplateLiteral" && node.expressions.length === 0 && node.quasis[0]?.value.cooked != null) return {
+		value: node.quasis[0].value.cooked,
+		quote: "`"
+	};
+	if (node.type === "UnaryExpression" && node.operator === "-" && node.argument.type === "Literal" && typeof node.argument.value === "number") return {
+		value: -node.argument.value,
+		quote: void 0
+	};
+}
+function readObject(node, path, module, text, fail) {
+	const out = {};
+	for (const property of node.properties) {
+		const { key, range, value } = readProperty(property, fail);
+		const childPath = [...path, key];
+		const id = pathId(childPath);
+		if (value.type === "ObjectExpression") {
+			module.ranges.set(id, {
+				key: range,
+				value: {
+					start: value.start,
+					end: value.end
+				}
+			});
+			out[key] = readObject(value, childPath, module, text, fail);
+			continue;
+		}
+		const leaf = readLeaf(value, text);
+		if (!leaf) return fail("X18N2004", value, `${value.type} is not a static value`);
+		const quoted = leaf.quote !== void 0;
+		module.ranges.set(id, {
+			key: range,
+			value: quoted ? {
+				start: value.start + 1,
+				end: value.end - 1
+			} : {
+				start: value.start,
+				end: value.end
+			}
+		});
+		module.scalars.set(id, {
+			range: {
+				start: value.start,
+				end: value.end
+			},
+			quote: leaf.quote
+		});
+		out[key] = leaf.value;
+	}
+	return out;
+}
+function readModule(text, path) {
+	const fail = (code, node, reason) => {
+		throw errors[code]({
+			path,
+			line: text.slice(0, node.start).split("\n").length,
+			reason
+		});
+	};
+	const result = parseSync(path, text, {
+		lang: /\.[mc]?ts$/.test(path) ? "ts" : "js",
+		sourceType: "module"
+	});
+	if (result.errors.length > 0) throw errors.X18N2002({
+		path,
+		reason: result.errors[0].message
+	});
+	const root = findRoot(result.program, fail);
+	const found = {
+		ranges: /* @__PURE__ */ new Map(),
+		scalars: /* @__PURE__ */ new Map()
+	};
+	return {
+		root,
+		tree: root ? readObject(root, [], found, text, fail) : {},
+		...found
+	};
+}
+const singleEncodings = {
+	"\\": "\\\\",
+	"'": "\\'",
+	"\n": "\\n",
+	"\r": "\\r",
+	"\u2028": "\\u2028",
+	"\u2029": "\\u2029"
+};
+function literal(value, quote) {
+	if (typeof value !== "string") return String(value);
+	if (quote === "\"") return JSON.stringify(value);
+	if (quote === "`") return `\`${value.replace(/\\|`|\$\{/g, (match) => `\\${match}`)}\``;
+	return `'${value.replace(/[\\'\n\r\u2028\u2029]/g, (char) => singleEncodings[char])}'`;
+}
+function objectText(tree, unit, depth) {
+	const entries = Object.entries(tree);
+	if (entries.length === 0) return "{}";
+	const pad = unit.repeat(depth + 1);
+	return `{\n${entries.map(([key, child]) => {
+		const name = /^[a-z_$][\w$]*$/i.test(key) ? key : literal(key, "'");
+		return `${pad}${name}: ${isMessageLeaf(child) ? literal(child, "'") : objectText(child, unit, depth + 1)},\n`;
+	}).join("")}${unit.repeat(depth)}}`;
+}
+/** Indent unit: configured, else the file's (first indented line), else 2 spaces. */
+function unitOf(text, indent) {
+	if (indent !== void 0) return indent === "tab" ? "	" : " ".repeat(indent);
+	return /^([ \t]+)\S/m.exec(text)?.[1] ?? "  ";
+}
+function moduleText(tree, path, unit) {
+	return `${path.endsWith(".cjs") ? "module.exports =" : "export default"} ${objectText(tree, unit, 0)}\n`;
+}
+function applyOp(text, op, path, unit) {
+	const module = readModule(text, path);
+	const scalar = module.scalars.get(pathId(op.path));
+	if (op.type === "set" && scalar) return splice(text, scalar.range, literal(op.value, scalar.quote));
+	const tree = applyMessageOps(module.tree, [op]);
+	return module.root ? splice(text, module.root, objectText(tree, unit, 0)) : moduleText(tree, path, unit);
+}
+function ecmascript() {
+	return {
+		name: "x18n:format-js",
+		formats: [{
+			id: "js",
+			extensions: [
+				"js",
+				"mjs",
+				"cjs",
+				"ts",
+				"mts",
+				"cts"
+			],
+			parse(text, ctx) {
+				const { tree, ranges } = readModule(text, ctx.path);
+				return {
+					tree,
+					ranges
+				};
+			},
+			edit(text, ops, ctx) {
+				const unit = unitOf(text, ctx.indent);
+				let next = text;
+				for (const op of ops) next = applyOp(next, op, ctx.path, unit);
+				return diffText(text, next);
+			},
+			serialize: (tree, ctx) => moduleText(tree, ctx.path, unitOf("", ctx.indent))
+		}]
+	};
+}
+//#endregion
+export { ecmascript as default, ecmascript };

package/dist/formats/ftl.d.mts

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

package/dist/formats/ftl.mjs

@@ -0,0 +1,234 @@
+import { a as splice, c as withBlankLines, i as leafText, n as detectEol, o as splitLines, t as appendLines } from "../shared-BWaXUmwA.mjs";
+import { diffText, errors, pathId, walkLeaves } from "@x18n/core";
+//#region src/formats/ftl/index.ts
+const trimmedEnd = (text, line) => line.start + text.slice(line.start, line.end).trimEnd().length;
+const indentOf = (text, line) => /^[ \t]*/.exec(text.slice(line.start, line.end))[0].length;
+function finishPattern(text, draft) {
+	const lines = [...draft.lines];
+	while (lines.length > 0 && text.slice(lines.at(-1).start, lines.at(-1).end).trim() === "") lines.pop();
+	const indent = Math.min(...lines.filter((l) => text.slice(l.start, l.end).trim() !== "").map((l) => indentOf(text, l)));
+	const inline = text.slice(draft.inline.start, draft.inline.end).trimEnd();
+	const parts = [...inline ? [inline] : [], ...lines.map((l) => text.slice(Math.min(l.start + indent, l.end), trimmedEnd(text, l)))];
+	const first = lines[0];
+	if (!inline && !first) return {
+		value: void 0,
+		range: {
+			start: draft.after,
+			end: draft.after
+		},
+		source: {
+			start: draft.after,
+			end: draft.inline.end
+		}
+	};
+	const start = inline ? draft.inline.start : first.start + indent;
+	const end = lines.length > 0 ? trimmedEnd(text, lines.at(-1)) : trimmedEnd(text, draft.inline);
+	return {
+		value: parts.join("\n"),
+		range: {
+			start,
+			end
+		},
+		source: {
+			start: draft.after,
+			end
+		}
+	};
+}
+function read(text, path) {
+	const messages = [];
+	let current;
+	let commentStart;
+	let blanks = [];
+	let lineNumber = 0;
+	for (const line of splitLines(text)) {
+		lineNumber++;
+		const content = text.slice(line.start, line.end);
+		if (content.trim() === "") {
+			blanks.push(line);
+			commentStart = void 0;
+			continue;
+		}
+		if (/^[ \t]/.test(content)) {
+			if (!current) throw errors.X18N2002({
+				path,
+				line: lineNumber,
+				reason: "indented line outside a message"
+			});
+			const attribute = /^[ \t]+\.([a-z][\w-]*)[ \t]*=[ \t]*/i.exec(content);
+			if (attribute) {
+				const nameStart = line.start + attribute[0].indexOf(".") + 1;
+				const after = line.start + attribute[0].trimEnd().length;
+				current.attributes.push({
+					name: attribute[1],
+					nameRange: {
+						start: nameStart,
+						end: nameStart + attribute[1].length
+					},
+					pattern: {
+						after,
+						inline: {
+							start: line.start + attribute[0].length,
+							end: line.end
+						},
+						lines: []
+					},
+					lines: {
+						start: line.start,
+						end: line.next
+					}
+				});
+			} else {
+				const last = current.attributes.at(-1);
+				(last ?? current).pattern.lines.push(...blanks, line);
+				if (last) last.lines.end = line.next;
+			}
+			current.block.end = line.next;
+			blanks = [];
+			continue;
+		}
+		blanks = [];
+		current = void 0;
+		if (content.startsWith("#")) {
+			commentStart = /^#(?: |$)/.test(content) ? commentStart ?? line.start : void 0;
+			continue;
+		}
+		const message = /^(-?[a-z][\w-]*)[ \t]*=[ \t]*/i.exec(content);
+		if (!message) throw errors.X18N2002({
+			path,
+			line: lineNumber,
+			reason: "expected a message, a term or a comment"
+		});
+		current = {
+			id: message[1],
+			idRange: {
+				start: line.start,
+				end: line.start + message[1].length
+			},
+			block: {
+				start: commentStart ?? line.start,
+				end: line.next
+			},
+			pattern: {
+				after: line.start + message[0].trimEnd().length,
+				inline: {
+					start: line.start + message[0].length,
+					end: line.end
+				},
+				lines: []
+			},
+			attributes: []
+		};
+		commentStart = void 0;
+		messages.push(current);
+	}
+	return messages;
+}
+function encode(value, indent, eol) {
+	if (value === "") return " { \"\" }";
+	const lines = value.split("\n");
+	if (lines.length === 1) return ` ${value}`;
+	return lines.map((line) => line === "" ? eol : `${eol}${" ".repeat(indent)}${line}`).join("");
+}
+function splitKey(key) {
+	const dot = key.indexOf(".");
+	return dot === -1 ? {
+		id: key,
+		attribute: void 0
+	} : {
+		id: key.slice(0, dot),
+		attribute: key.slice(dot + 1)
+	};
+}
+function setValue(text, key, value, messages) {
+	const eol = detectEol(text);
+	const { id, attribute } = splitKey(key);
+	const message = messages.findLast((m) => m.id === id);
+	if (!message) return appendLines(text, attribute ? `${id} =\n    .${attribute} =${encode(value, 8, "\n")}\n` : `${id} =${encode(value, 4, "\n")}\n`);
+	if (!attribute) return splice(text, finishPattern(text, message.pattern).source, encode(value, 4, eol));
+	const existing = message.attributes.findLast((a) => a.name === attribute);
+	if (existing) return splice(text, finishPattern(text, existing.pattern).source, encode(value, indentOf(text, existing.lines) + 4, eol));
+	const end = message.block.end;
+	const lead = end === text.length && !text.endsWith("\n") ? eol : "";
+	return splice(text, {
+		start: end,
+		end
+	}, `${lead}    .${attribute} =${encode(value, 8, eol)}${eol}`);
+}
+function remove(text, key, messages) {
+	const { id, attribute } = splitKey(key);
+	const message = messages.findLast((m) => m.id === id);
+	if (!message) return text;
+	const pattern = finishPattern(text, message.pattern);
+	if (!attribute) {
+		if (pattern.value === void 0) return text;
+		return message.attributes.length > 0 ? splice(text, pattern.source, "") : splice(text, withBlankLines(text, message.block), "");
+	}
+	const existing = message.attributes.findLast((a) => a.name === attribute);
+	if (!existing) return text;
+	if (pattern.value === void 0 && message.attributes.length === 1) return splice(text, withBlankLines(text, message.block), "");
+	return splice(text, existing.lines, "");
+}
+function applyOp(text, op, path) {
+	const key = op.path.join(".");
+	const messages = read(text, path);
+	return op.type === "set" ? setValue(text, key, leafText(op.value), messages) : remove(text, key, messages);
+}
+function serialize(tree) {
+	const messages = /* @__PURE__ */ new Map();
+	for (const leaf of walkLeaves(tree)) {
+		const { id, attribute } = splitKey(leaf.path.join("."));
+		const message = messages.get(id) ?? {
+			value: void 0,
+			attributes: []
+		};
+		messages.set(id, message);
+		if (attribute) message.attributes.push(`    .${attribute} =${encode(leafText(leaf.value), 8, "\n")}\n`);
+		else message.value = leafText(leaf.value);
+	}
+	return [...messages].map(([id, m]) => `${id} =${m.value === void 0 ? "" : encode(m.value, 4, "\n")}\n${m.attributes.join("")}`).join("");
+}
+function ftl() {
+	return {
+		name: "x18n:format-ftl",
+		formats: [{
+			id: "ftl",
+			extensions: ["ftl"],
+			parse(text, ctx) {
+				const tree = {};
+				const ranges = /* @__PURE__ */ new Map();
+				for (const message of read(text, ctx.path)) {
+					const pattern = finishPattern(text, message.pattern);
+					if (pattern.value !== void 0) {
+						tree[message.id] = pattern.value;
+						ranges.set(pathId([message.id]), {
+							key: message.idRange,
+							value: pattern.range
+						});
+					}
+					for (const attribute of message.attributes) {
+						const key = `${message.id}.${attribute.name}`;
+						const value = finishPattern(text, attribute.pattern);
+						tree[key] = value.value ?? "";
+						ranges.set(pathId([key]), {
+							key: attribute.nameRange,
+							value: value.range
+						});
+					}
+				}
+				return {
+					tree,
+					ranges
+				};
+			},
+			edit(text, ops, ctx) {
+				let next = text;
+				for (const op of ops) next = applyOp(next, op, ctx.path);
+				return diffText(text, next);
+			},
+			serialize
+		}]
+	};
+}
+//#endregion
+export { ftl as default, ftl };

package/dist/formats/ini.d.mts

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