@x18n/builtins 0.0.2 → 0.0.3

package/dist/formats-BAogSrvw.mjs

@@ -0,0 +1,1331 @@
+import { X18nError, applyMessageOps, applyTextEdits, buildTree, diffText, isMessageLeaf, isMessageTree, pathId, walkLeaves } from "@x18n/core";
+import { parseSync } from "oxc-parser";
+import { applyEdits, modify, parseTree, printParseErrorCode } from "jsonc-parser";
+import JSON5 from "json5";
+import { Document, Scalar, isMap, isNode, isScalar, parseDocument, stringify } from "yaml";
+//#region src/formats/shared.ts
+/** Indent of the first indented line, so edits keep the file's style. */
+function detectIndent(text, fallback) {
+	if (fallback === "tab") return {
+		insertSpaces: false,
+		tabSize: 1
+	};
+	if (typeof fallback === "number") return {
+		insertSpaces: true,
+		tabSize: fallback
+	};
+	const match = /^([ \t]+)\S/m.exec(text);
+	if (match?.[1]?.startsWith("	")) return {
+		insertSpaces: false,
+		tabSize: 1
+	};
+	return {
+		insertSpaces: true,
+		tabSize: match?.[1]?.length ?? 2
+	};
+}
+function detectEol(text) {
+	return text.includes("\r\n") ? "\r\n" : "\n";
+}
+function toLeaf(value) {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (value instanceof Date) return value.toISOString();
+}
+function leafText(value) {
+	return value === null ? "" : String(value);
+}
+function splice(text, range, insert) {
+	return text.slice(0, range.start) + insert + text.slice(range.end);
+}
+/** Appends `chunk` on a line of its own, in the file's line endings. */
+function appendLines(text, chunk) {
+	const eol = detectEol(text);
+	return (text === "" || text.endsWith("\n") ? text : text + eol) + chunk.replace(/\n/g, eol);
+}
+function splitLines(text) {
+	const out = [];
+	let start = 0;
+	while (start < text.length) {
+		const lf = text.indexOf("\n", start);
+		const next = lf === -1 ? text.length : lf + 1;
+		const end = lf === -1 ? text.length : lf > start && text[lf - 1] === "\r" ? lf - 1 : lf;
+		out.push({
+			start,
+			end,
+			next
+		});
+		start = next;
+	}
+	return out;
+}
+/** An entry's range widened to swallow the blank lines that separate it, so deleting it leaves one separator. */
+function withBlankLines(text, range) {
+	const after = /^(?:[ \t]*\r?\n)*(?:[ \t]*$)?/.exec(text.slice(range.end))[0].length;
+	if (range.end + after < text.length) return {
+		start: range.start,
+		end: range.end + after
+	};
+	const before = /(?<=\n)(?:[ \t]*\r?\n)+$/.exec(text.slice(0, range.start))?.[0].length ?? 0;
+	return {
+		start: range.start - before,
+		end: text.length
+	};
+}
+//#endregion
+//#region src/formats/ecmascript.ts
+/** Type-only wrappers and `defineX({ ... })` helpers that return their argument. */
+function unwrap(node) {
+	if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "ParenthesizedExpression") return unwrap(node.expression);
+	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, message) => {
+		throw new X18nError(code, `${path}:${text.slice(0, node.start).split("\n").length}: ${message}`);
+	};
+	const result = parseSync(path, text, {
+		lang: /\.[mc]?ts$/.test(path) ? "ts" : "js",
+		sourceType: "module"
+	});
+	if (result.errors.length > 0) throw new X18nError("X18N2002", `${path}: ${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$1(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$1(key, "'");
+		return `${pad}${name}: ${isMessageLeaf(child) ? literal$1(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$1(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$5(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$1(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$1(text, ctx.indent);
+				let next = text;
+				for (const op of ops) next = applyOp$5(next, op, ctx.path, unit);
+				return diffText(text, next);
+			},
+			serialize: (tree, ctx) => moduleText(tree, ctx.path, unitOf$1("", ctx.indent))
+		}]
+	};
+}
+//#endregion
+//#region src/formats/ftl.ts
+const trimmedEnd = (text, line) => line.start + text.slice(line.start, line.end).trimEnd().length;
+const indentOf$1 = (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$1(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$3(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 new X18nError("X18N2002", `${path}:${lineNumber}: 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 new X18nError("X18N2002", `${path}:${lineNumber}: 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$2(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$2(value, 8, "\n")}\n` : `${id} =${encode$2(value, 4, "\n")}\n`);
+	if (!attribute) return splice(text, finishPattern(text, message.pattern).source, encode$2(value, 4, eol));
+	const existing = message.attributes.findLast((a) => a.name === attribute);
+	if (existing) return splice(text, finishPattern(text, existing.pattern).source, encode$2(value, indentOf$1(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$2(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$4(text, op, path) {
+	const key = op.path.join(".");
+	const messages = read$3(text, path);
+	return op.type === "set" ? setValue(text, key, leafText(op.value), messages) : remove(text, key, messages);
+}
+function serialize$1(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$2(leafText(leaf.value), 8, "\n")}\n`);
+		else message.value = leafText(leaf.value);
+	}
+	return [...messages].map(([id, m]) => `${id} =${m.value === void 0 ? "" : encode$2(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$3(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$4(next, op, ctx.path);
+				return diffText(text, next);
+			},
+			serialize: serialize$1
+		}]
+	};
+}
+//#endregion
+//#region src/formats/ini.ts
+/** Reads the value after `=`; `start` is its first non-blank offset. */
+function readValue(text, start, end, fail) {
+	const quote = text[start];
+	if (quote === "\"" || quote === "'") {
+		const close = quote === "\"" ? /^"(?:[^"\\]|\\.)*"/.exec(text.slice(start, end)) : /^'[^']*'/.exec(text.slice(start, end));
+		if (!close || !/^\s*(?:[;#].*)?$/.test(text.slice(start + close[0].length, end))) fail("unterminated or malformed quoted value");
+		const raw = close[0];
+		let value = raw.slice(1, -1);
+		if (quote === "\"") try {
+			value = JSON.parse(raw);
+		} catch {
+			fail(`invalid escape in ${raw}`);
+		}
+		return {
+			value,
+			source: {
+				start,
+				end: start + raw.length
+			},
+			inner: {
+				start: start + 1,
+				end: start + raw.length - 1
+			}
+		};
+	}
+	const comment = /\s[;#]/.exec(text.slice(start, end));
+	const valueEnd = start + text.slice(start, comment ? start + comment.index : end).trimEnd().length;
+	const range = {
+		start,
+		end: valueEnd
+	};
+	return {
+		value: text.slice(start, valueEnd),
+		source: range,
+		inner: range
+	};
+}
+function read$2(text, path) {
+	const entries = [];
+	const sections = [];
+	let section = "";
+	let lineNumber = 0;
+	const fail = (message) => {
+		throw new X18nError("X18N2002", `${path}:${lineNumber}: ${message}`);
+	};
+	for (const line of splitLines(text)) {
+		lineNumber++;
+		const content = text.slice(line.start, line.end);
+		const trimmed = content.trim();
+		if (trimmed === "" || trimmed.startsWith(";") || trimmed.startsWith("#")) continue;
+		const header = /^\s*\[([^\]]+)\]\s*(?:[;#].*)?$/.exec(content);
+		if (header) {
+			section = header[1].trim();
+			sections.push({
+				name: section,
+				line
+			});
+			continue;
+		}
+		const eq = content.indexOf("=");
+		if (eq === -1) fail(`expected "key = value", got "${trimmed.slice(0, 20)}"`);
+		const key = content.slice(0, eq).trim();
+		if (key === "") fail("empty key");
+		const keyStart = line.start + content.indexOf(key);
+		const { value, source, inner } = readValue(text, line.start + eq + 1 + /^\s*/.exec(content.slice(eq + 1))[0].length, line.end, fail);
+		entries.push({
+			path: [...section ? section.split(".") : [], key],
+			section,
+			value,
+			range: {
+				key: {
+					start: keyStart,
+					end: keyStart + key.length
+				},
+				value: inner
+			},
+			source,
+			line
+		});
+	}
+	return {
+		entries,
+		sections
+	};
+}
+function encode$1(value, quote) {
+	if (quote === "'" && !/['\r\n]/.test(value)) return `'${value}'`;
+	return quote === "\"" || quote === "'" || /^\s|\s$|[\r\n"';#]|^\[/.test(value) ? JSON.stringify(value) : value;
+}
+function insertLine(text, at, line) {
+	const eol = detectEol(text);
+	const lead = at === text.length && text !== "" && !text.endsWith("\n") ? eol : "";
+	return splice(text, {
+		start: at,
+		end: at
+	}, `${lead}${line}${eol}`);
+}
+function applyOp$3(text, op, path) {
+	const { entries, sections } = read$2(text, path);
+	const id = pathId(op.path);
+	const entry = entries.findLast((e) => pathId(e.path) === id);
+	if (op.type === "delete") return entry ? splice(text, {
+		start: entry.line.start,
+		end: entry.line.next
+	}, "") : text;
+	const value = leafText(op.value);
+	if (entry) return splice(text, entry.source, encode$1(value, text[entry.source.start]));
+	const section = op.path.slice(0, -1).join(".");
+	const last = entries.findLast((e) => e.source.end > e.source.start);
+	const line = `${op.path.at(-1)}${last ? text.slice(last.range.key.end, last.source.start) : " = "}${encode$1(value, void 0)}`;
+	const anchor = entries.findLast((e) => e.section === section)?.line ?? sections.find((s) => s.name === section)?.line;
+	if (anchor) return insertLine(text, anchor.next, line);
+	if (section === "") return insertLine(text, sections[0]?.line.start ?? text.length, line);
+	return appendLines(text, `${text.trim() === "" ? "" : "\n"}[${section}]\n${line}\n`);
+}
+function serialize(tree) {
+	const blocks = [];
+	const visit = (node, path) => {
+		const children = Object.entries(node);
+		const leaves = children.filter((child) => isMessageLeaf(child[1]));
+		if (leaves.length > 0) blocks.push(`${path.length > 0 ? `[${path.join(".")}]\n` : ""}${leaves.map(([key, value]) => `${key} = ${encode$1(leafText(value), void 0)}\n`).join("")}`);
+		for (const [key, child] of children) if (!isMessageLeaf(child)) visit(child, [...path, key]);
+	};
+	visit(tree, []);
+	return blocks.join("\n");
+}
+function ini() {
+	return {
+		name: "x18n:format-ini",
+		formats: [{
+			id: "ini",
+			extensions: ["ini"],
+			parse(text, ctx) {
+				const { entries } = read$2(text, ctx.path);
+				const ranges = new Map(entries.map((e) => [pathId(e.path), e.range]));
+				return {
+					tree: buildTree(entries),
+					ranges
+				};
+			},
+			edit(text, ops, ctx) {
+				let next = text;
+				for (const op of ops) next = applyOp$3(next, op, ctx.path);
+				return diffText(text, next);
+			},
+			serialize
+		}]
+	};
+}
+//#endregion
+//#region src/formats/json.ts
+function readTree$1(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$1(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 errors = [];
+			const root = parseTree(text, errors, {
+				allowTrailingComma: true,
+				disallowComments: !allowComments
+			});
+			if (errors.length > 0) {
+				const first = errors[0];
+				throw new X18nError("X18N2002", `${ctx.path}: ${printParseErrorCode(first.error)} at offset ${first.offset}`);
+			}
+			if (!root || root.type !== "object") {
+				if (text.trim() === "") return {
+					tree: {},
+					ranges: /* @__PURE__ */ new Map()
+				};
+				throw new X18nError("X18N2003", ctx.path);
+			}
+			const ranges = /* @__PURE__ */ new Map();
+			return {
+				tree: readTree$1(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`;
+		}
+	};
+}
+function json(options = {}) {
+	return {
+		name: "x18n:format-json",
+		formats: [createJsonFormat("json", ["json"], true, options.indent)]
+	};
+}
+function jsonc(options = {}) {
+	return {
+		name: "x18n:format-jsonc",
+		formats: [createJsonFormat("jsonc", ["jsonc"], true, options.indent)]
+	};
+}
+//#endregion
+//#region src/formats/json5.ts
+function json5() {
+	return {
+		name: "x18n:format-json5",
+		formats: [{
+			id: "json5",
+			extensions: ["json5"],
+			parse(text, ctx) {
+				if (text.trim() === "") return { tree: {} };
+				let data;
+				try {
+					data = JSON5.parse(text);
+				} catch (error) {
+					throw new X18nError("X18N2002", `${ctx.path}: ${error instanceof Error ? error.message : String(error)}`);
+				}
+				if (!isMessageTree(data)) throw new X18nError("X18N2003", ctx.path);
+				return { tree: data };
+			},
+			serialize: (tree, ctx) => `${JSON5.stringify(tree, null, ctx.indent === "tab" ? "	" : ctx.indent ?? 2)}\n`
+		}]
+	};
+}
+//#endregion
+//#region src/formats/php.ts
+const doubleEscapes = {
+	"n": "\n",
+	"t": "	",
+	"r": "\r",
+	"v": "\v",
+	"e": "\x1B",
+	"f": "\f",
+	"\\": "\\",
+	"$": "$",
+	"\"": "\""
+};
+function decodeDouble(raw, fail) {
+	if (/(?:^|[^\\])(?:\\\\)*(?:\$[a-z_{]|\{\$)/i.test(raw)) fail("X18N2004", "variable interpolation in a string");
+	return raw.replace(/\\(u\{[0-9a-f]+\}|x[0-9a-f]{1,2}|[0-7]{1,3}|[\s\S])/gi, (match, escape) => {
+		if (/^u\{/i.test(escape)) return String.fromCodePoint(Number.parseInt(escape.slice(2, -1), 16));
+		if (/^x[0-9a-f]/i.test(escape)) return String.fromCharCode(Number.parseInt(escape.slice(1), 16));
+		if (/^[0-7]/.test(escape)) return String.fromCharCode(Number.parseInt(escape, 8));
+		return doubleEscapes[escape] ?? match;
+	});
+}
+function parseFile(text, path) {
+	let pos = 0;
+	const fail = (code, message) => {
+		const line = text.slice(0, pos).split("\n").length;
+		throw new X18nError(code, `${path}:${line}: ${message}`);
+	};
+	const skip = () => {
+		for (;;) {
+			const rest = text.slice(pos);
+			const blank = /^(?:\s+|\/\/[^\n]*|#(?!\[)[^\n]*|\/\*[\s\S]*?\*\/)/.exec(rest);
+			if (!blank) return;
+			pos += blank[0].length;
+		}
+	};
+	const eat = (pattern) => {
+		skip();
+		const match = pattern.exec(text.slice(pos));
+		if (match) pos += match[0].length;
+		return match?.[0];
+	};
+	const parseString = (quote) => {
+		const start = pos;
+		const match = (quote === "'" ? /^'(?:[^'\\]|\\[\s\S])*'/ : /^"(?:[^"\\]|\\[\s\S])*"/).exec(text.slice(pos));
+		if (!match) return fail("X18N2002", "unterminated string");
+		pos += match[0].length;
+		const raw = match[0].slice(1, -1);
+		const value = quote === "'" ? raw.replace(/\\([\\'])/g, "$1") : decodeDouble(raw, fail);
+		return {
+			kind: "scalar",
+			range: {
+				start,
+				end: pos
+			},
+			value,
+			quote
+		};
+	};
+	const parseArray = (start, close) => {
+		const closing = close === "]" ? /^\]/ : /^\)/;
+		const items = [];
+		while (!eat(closing)) {
+			const key = parseValue();
+			if (!eat(/^=>/)) return fail("X18N2003", "array item without a key");
+			if (key.kind !== "scalar" || typeof key.value !== "string" && typeof key.value !== "number") return fail("X18N2004", "array keys must be strings or integers");
+			items.push({
+				key: String(key.value),
+				keyRange: key.quote ? {
+					start: key.range.start + 1,
+					end: key.range.end - 1
+				} : key.range,
+				value: parseValue()
+			});
+			if (eat(/^,/)) continue;
+			skip();
+			if (text[pos] !== close) return fail("X18N2004", `expected "," or "${close}"; expressions are not static`);
+		}
+		return {
+			kind: "array",
+			range: {
+				start,
+				end: pos
+			},
+			items
+		};
+	};
+	function parseValue() {
+		skip();
+		const start = pos;
+		if (eat(/^\[/)) return parseArray(start, "]");
+		if (eat(/^array\s*\(/i)) return parseArray(start, ")");
+		if (text[pos] === "'" || text[pos] === "\"") return parseString(text[pos]);
+		const literal = eat(/^(?:-?\d+(?:\.\d+)?(?:e[+-]?\d+)?|true|false|null)\b/i);
+		if (literal === void 0) return fail("X18N2004", `"${text.slice(pos, pos + 20).split("\n")[0]}" is not a static value`);
+		const lower = literal.toLowerCase();
+		const value = lower === "null" ? null : lower === "true" ? true : lower === "false" ? false : Number(literal);
+		return {
+			kind: "scalar",
+			range: {
+				start,
+				end: pos
+			},
+			value,
+			quote: void 0
+		};
+	}
+	eat(/^<\?php\b/i);
+	if (eat(/^$/) !== void 0) return void 0;
+	eat(/^declare\s*\([^)]*\)\s*;/i);
+	if (!eat(/^return\b/i)) fail("X18N2004", "expected `return [ ... ];`");
+	const root = parseValue();
+	if (root.kind !== "array") fail("X18N2003", "the file must return an array");
+	if (!eat(/^;/)) fail("X18N2004", "expected \";\" after the array; expressions are not static");
+	eat(/^\?>/);
+	if (eat(/^$/) === void 0) fail("X18N2002", "unexpected text after the array");
+	return root;
+}
+function readTree(value, path, ranges) {
+	const out = {};
+	if (value.kind !== "array") return out;
+	for (const item of value.items) {
+		const childPath = [...path, item.key];
+		const inner = item.value.kind === "scalar" && item.value.quote ? {
+			start: item.value.range.start + 1,
+			end: item.value.range.end - 1
+		} : item.value.range;
+		ranges.set(pathId(childPath), {
+			key: item.keyRange,
+			value: inner
+		});
+		out[item.key] = item.value.kind === "array" ? readTree(item.value, childPath, ranges) : item.value.value;
+	}
+	return out;
+}
+const doubleEncodings = {
+	"\n": "\\n",
+	"	": "\\t",
+	"\r": "\\r",
+	"\v": "\\v",
+	"\f": "\\f"
+};
+function literal(value, quote) {
+	if (typeof value !== "string") return String(value);
+	if (quote === "\"" || /[\n\r\t\v\f]/.test(value)) return `"${value.replace(/[\\"$\n\t\r\v\f]/g, (char) => doubleEncodings[char] ?? `\\${char}`)}"`;
+	return `'${value.replace(/[\\']/g, "\\$&")}'`;
+}
+function arrayText(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]) => `${pad}${literal(key, "'")} => ${isMessageLeaf(child) ? literal(child, "'") : arrayText(child, unit, depth + 1)},\n`).join("")}${unit.repeat(depth)}]`;
+}
+function find(root, path) {
+	let node = root;
+	for (const segment of path) node = node?.kind === "array" ? node.items.findLast((item) => item.key === segment)?.value : void 0;
+	return node;
+}
+/** Indent unit: configured, else the file's (first indented item), else 4 spaces. */
+function unitOf(text, indent) {
+	if (indent !== void 0) return indent === "tab" ? "	" : " ".repeat(indent);
+	return /^([ \t]+)['"\]]/m.exec(text)?.[1] ?? "    ";
+}
+function applyOp$2(text, op, path, unit) {
+	const root = parseFile(text, path);
+	const node = root && find(root, op.path);
+	if (op.type === "set" && node?.kind === "scalar") return splice(text, node.range, literal(op.value, node.quote));
+	const tree = applyMessageOps(root ? readTree(root, [], /* @__PURE__ */ new Map()) : {}, [op]);
+	return root ? splice(text, root.range, arrayText(tree, unit, 0)) : `${text.trim() === "" ? "<?php" : text.trimEnd()}\n\nreturn ${arrayText(tree, unit, 0)};\n`;
+}
+function php() {
+	return {
+		name: "x18n:format-php",
+		formats: [{
+			id: "php",
+			extensions: ["php"],
+			parse(text, ctx) {
+				const root = parseFile(text, ctx.path);
+				const ranges = /* @__PURE__ */ new Map();
+				return {
+					tree: root ? readTree(root, [], ranges) : {},
+					ranges
+				};
+			},
+			edit(text, ops, ctx) {
+				const unit = unitOf(text, ctx.indent);
+				let next = text;
+				for (const op of ops) next = applyOp$2(next, op, ctx.path, unit);
+				return diffText(text, next);
+			},
+			serialize: (tree, ctx) => `<?php\n\nreturn ${arrayText(tree, unitOf("", ctx.indent), 0)};\n`
+		}]
+	};
+}
+//#endregion
+//#region src/formats/po.ts
+/** gettext joins msgctxt and msgid with EOT. */
+const CONTEXT_SEPARATOR = "";
+const decodings = {
+	n: "\n",
+	t: "	",
+	r: "\r",
+	a: "\x07",
+	b: "\b",
+	f: "\f",
+	v: "\v"
+};
+const encodings$1 = {
+	"\\": "\\\\",
+	"\"": "\\\"",
+	"\n": "\\n",
+	"	": "\\t",
+	"\r": "\\r"
+};
+/** Reads one `"..."` string starting at `start`; returns its value and the offset after the closing quote. */
+function readString(text, start, end, fail) {
+	if (text[start] !== "\"") fail("expected a string");
+	let value = "";
+	for (let i = start + 1; i < end; i++) {
+		const char = text[i];
+		if (char === "\"") {
+			if (text.slice(i + 1, end).trim() !== "") fail("unexpected text after string");
+			return {
+				value,
+				end: i + 1
+			};
+		}
+		if (char !== "\\") {
+			value += char;
+			continue;
+		}
+		const escape = /^(?:[0-7]{1,3}|x[0-9a-f]{1,2}|[\s\S])/i.exec(text.slice(i + 1, end))?.[0] ?? "";
+		value += /^[0-7]/.test(escape) ? String.fromCharCode(Number.parseInt(escape, 8)) : escape.length > 1 ? String.fromCharCode(Number.parseInt(escape.slice(1), 16)) : decodings[escape] ?? escape;
+		i += escape.length;
+	}
+	return fail("unterminated string");
+}
+function toEntry(text, draft, fail) {
+	const field = (name) => draft.fields.find((f) => f.name === name);
+	const msgid = field("msgid");
+	if (!msgid) return draft.fields.length > 0 ? fail("entry without msgid") : void 0;
+	const msgctxt = field("msgctxt");
+	const msgstr = field("msgstr") ?? field("msgstr[0]");
+	if (!msgstr) return fail(`msgid "${msgid.value}" without msgstr`);
+	if (msgid.value === "" && !msgctxt) return void 0;
+	const inner = (f) => ({
+		start: f.range.start + 1,
+		end: f.range.end - 1
+	});
+	return {
+		key: msgctxt ? `${msgctxt.value}${CONTEXT_SEPARATOR}${msgid.value}` : msgid.value,
+		value: msgstr.value,
+		range: {
+			key: inner(msgid),
+			value: inner(msgstr)
+		},
+		source: msgstr.range,
+		block: withBlankLines(text, {
+			start: draft.start,
+			end: draft.end
+		})
+	};
+}
+function read$1(text, path) {
+	const entries = [];
+	let lineNumber = 0;
+	const fail = (message) => {
+		throw new X18nError("X18N2002", `${path}:${lineNumber}: ${message}`);
+	};
+	let draft;
+	let field;
+	const flush = () => {
+		const entry = draft && toEntry(text, draft, fail);
+		if (entry) entries.push(entry);
+		draft = void 0;
+		field = void 0;
+	};
+	for (const line of splitLines(text)) {
+		lineNumber++;
+		const offset = line.start + /^\s*/.exec(text.slice(line.start, line.end))[0].length;
+		const content = text.slice(offset, line.end);
+		const keyword = /^(msgctxt|msgid_plural|msgid|msgstr(?:\[\d+\])?)\s*/.exec(content);
+		if (content === "" || content.startsWith("#") && draft?.fields.some((f) => f.name.startsWith("msgstr"))) flush();
+		if (content === "") continue;
+		if (keyword && (keyword[1] === "msgctxt" || keyword[1] === "msgid") && draft?.fields.some((f) => f.name !== "msgctxt")) flush();
+		draft ??= {
+			start: line.start,
+			end: line.next,
+			fields: []
+		};
+		draft.end = line.next;
+		if (content.startsWith("#")) {
+			field = void 0;
+			continue;
+		}
+		const stringStart = keyword ? offset + keyword[0].length : offset;
+		if (!keyword && (!field || !content.startsWith("\""))) fail(`unexpected "${content.slice(0, 20)}"`);
+		const string = readString(text, stringStart, line.end, fail);
+		if (keyword) {
+			field = {
+				name: keyword[1],
+				range: {
+					start: stringStart,
+					end: string.end
+				},
+				value: string.value
+			};
+			draft.fields.push(field);
+		} else {
+			field.range.end = string.end;
+			field.value += string.value;
+		}
+	}
+	flush();
+	return entries;
+}
+const quote = (value) => `"${value.replace(/[\\"\n\t\r]/g, (char) => encodings$1[char])}"`;
+/** One string, or gettext's style of an empty first string and one string per line. */
+function encode(value, eol) {
+	if (!value.slice(0, -1).includes("\n")) return quote(value);
+	return ["\"\"", ...value.split(/(?<=\n)/).map(quote)].join(eol);
+}
+function entryText(key, value) {
+	const index = key.indexOf(CONTEXT_SEPARATOR);
+	return `${index === -1 ? "" : `msgctxt ${quote(key.slice(0, index))}\n`}msgid ${encode(key.slice(index + 1), "\n")}\nmsgstr ${encode(value, "\n")}\n`;
+}
+function applyOp$1(text, op, path) {
+	const key = op.path.join(".");
+	const entry = read$1(text, path).findLast((e) => e.key === key);
+	if (op.type === "delete") return entry ? splice(text, entry.block, "") : text;
+	const value = leafText(op.value);
+	if (entry) return splice(text, entry.source, encode(value, detectEol(text)));
+	return appendLines(text, `${text.trim() === "" || /\n[ \t]*\r?\n$/.test(text) ? "" : "\n"}${entryText(key, value)}`);
+}
+function po() {
+	return {
+		name: "x18n:format-po",
+		formats: [{
+			id: "po",
+			extensions: ["po", "pot"],
+			parse(text, ctx) {
+				const tree = {};
+				const ranges = /* @__PURE__ */ new Map();
+				for (const entry of read$1(text, ctx.path)) {
+					tree[entry.key] = entry.value;
+					ranges.set(pathId([entry.key]), entry.range);
+				}
+				return {
+					tree,
+					ranges
+				};
+			},
+			edit(text, ops, ctx) {
+				let next = text;
+				for (const op of ops) next = applyOp$1(next, op, ctx.path);
+				return diffText(text, next);
+			},
+			serialize(tree, ctx) {
+				return [`msgid ""\nmsgstr ""\n"Language: ${ctx.locale}\\n"\n"MIME-Version: 1.0\\n"\n"Content-Type: text/plain; charset=UTF-8\\n"\n"Content-Transfer-Encoding: 8bit\\n"\n`, ...[...walkLeaves(tree)].map((leaf) => entryText(leaf.path.join("."), leafText(leaf.value)))].join("\n");
+			}
+		}]
+	};
+}
+//#endregion
+//#region src/formats/properties.ts
+const escapes = {
+	t: "	",
+	n: "\n",
+	r: "\r",
+	f: "\f"
+};
+const isSpace = (char) => char === " " || char === "	" || char === "\f";
+function unescape(raw, path) {
+	let out = "";
+	for (let i = 0; i < raw.length; i++) {
+		const char = raw[i];
+		if (char !== "\\") {
+			out += char;
+			continue;
+		}
+		const next = raw[++i];
+		if (next === void 0) break;
+		if (next === "\r" || next === "\n") {
+			if (next === "\r" && raw[i + 1] === "\n") i++;
+			while (isSpace(raw[i + 1])) i++;
+		} else if (next === "u") {
+			const hex = raw.slice(i + 1, i + 5);
+			if (!/^[0-9a-f]{4}$/i.test(hex)) throw new X18nError("X18N2002", `${path}: malformed \\u escape "\\u${hex}"`);
+			out += String.fromCharCode(Number.parseInt(hex, 16));
+			i += 4;
+		} else out += escapes[next] ?? next;
+	}
+	return out;
+}
+function read(text, path) {
+	const entries = [];
+	const lines = splitLines(text);
+	for (let i = 0; i < lines.length; i++) {
+		let p = lines[i].start;
+		const lineStart = p;
+		while (isSpace(text[p])) p++;
+		if (p >= lines[i].end || text[p] === "#" || text[p] === "!") continue;
+		while (i < lines.length - 1 && /(?:^|[^\\])(?:\\\\)*\\$/.test(text.slice(lines[i].start, lines[i].end))) i++;
+		const end = lines[i].end;
+		const keyStart = p;
+		while (p < end && !"=: 	\f".includes(text[p])) p += text[p] === "\\" ? 2 : 1;
+		const keyEnd = Math.min(p, end);
+		while (isSpace(text[p])) p++;
+		if (text[p] === "=" || text[p] === ":") p++;
+		while (isSpace(text[p])) p++;
+		const valueStart = Math.min(p, end);
+		entries.push({
+			key: unescape(text.slice(keyStart, keyEnd), path),
+			value: unescape(text.slice(valueStart, end), path),
+			range: {
+				key: {
+					start: keyStart,
+					end: keyEnd
+				},
+				value: {
+					start: valueStart,
+					end
+				}
+			},
+			line: {
+				start: lineStart,
+				end: lines[i].next
+			}
+		});
+	}
+	return entries;
+}
+const encodings = {
+	"\\": "\\\\",
+	"	": "\\t",
+	"\n": "\\n",
+	"\r": "\\r",
+	"\f": "\\f"
+};
+const escapeText = (text) => text.replace(/[\\\n\r\t\f]/g, (char) => encodings[char]);
+const escapeKey = (key) => escapeText(key).replace(/[=: #!]/g, "\\$&");
+const escapeValue = (value) => escapeText(value).replace(/^ /, "\\ ");
+function applyOp(text, op, path) {
+	const key = op.path.join(".");
+	const entries = read(text, path);
+	const entry = entries.findLast((e) => e.key === key);
+	if (op.type === "delete") return entry ? splice(text, entry.line, "") : text;
+	const value = escapeValue(leafText(op.value));
+	if (entry) return splice(text, entry.range.value, value);
+	const last = entries.findLast((e) => e.value !== "");
+	const separator = last ? text.slice(last.range.key.end, last.range.value.start) : "";
+	return appendLines(text, `${escapeKey(key)}${/[=:\s]/.test(separator) ? separator : "="}${value}\n`);
+}
+function properties() {
+	return {
+		name: "x18n:format-properties",
+		formats: [{
+			id: "properties",
+			extensions: ["properties"],
+			parse(text, ctx) {
+				const tree = {};
+				const ranges = /* @__PURE__ */ new Map();
+				for (const entry of read(text, ctx.path)) {
+					tree[entry.key] = entry.value;
+					ranges.set(pathId([entry.key]), entry.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: (tree) => [...walkLeaves(tree)].map((leaf) => `${escapeKey(leaf.path.join("."))}=${escapeValue(leafText(leaf.value))}\n`).join("")
+		}]
+	};
+}
+//#endregion
+//#region src/formats/yaml.ts
+function scalarTextRange(node) {
+	const range = node.range;
+	if (!range) return void 0;
+	if (isScalar(node) && (node.type === Scalar.QUOTE_DOUBLE || node.type === Scalar.QUOTE_SINGLE)) return {
+		start: range[0] + 1,
+		end: range[1] - 1
+	};
+	return {
+		start: range[0],
+		end: range[1]
+	};
+}
+function readMap(node, path, ranges) {
+	const out = {};
+	if (!isMap(node)) return out;
+	for (const pair of node.items) {
+		const keyNode = pair.key;
+		if (!isScalar(keyNode)) continue;
+		const key = String(keyNode.value);
+		const childPath = [...path, key];
+		const keyRange = scalarTextRange(keyNode);
+		const value = isNode(pair.value) ? pair.value : void 0;
+		const valueRange = value && value.range ? {
+			start: value.range[0],
+			end: value.range[1]
+		} : void 0;
+		if (keyRange) ranges.set(pathId(childPath), {
+			key: keyRange,
+			value: valueRange ?? keyRange
+		});
+		if (value === void 0) out[key] = null;
+		else if (isMap(value)) out[key] = readMap(value, childPath, ranges);
+		else if (isScalar(value)) {
+			const leaf = toLeaf(value.value);
+			if (leaf !== void 0) out[key] = leaf;
+		}
+	}
+	return out;
+}
+function parse$1(text, path) {
+	const doc = parseDocument(text, {
+		keepSourceTokens: true,
+		uniqueKeys: false
+	});
+	if (doc.errors.length > 0) throw new X18nError("X18N2002", `${path}: ${doc.errors[0].message}`);
+	return doc;
+}
+function scalarText(value, type) {
+	if (typeof value !== "string") return stringify(value).trimEnd();
+	if (type === Scalar.QUOTE_DOUBLE) return JSON.stringify(value);
+	if (type === Scalar.QUOTE_SINGLE) return `'${value.replace(/'/g, "''")}'`;
+	return stringify(value, { lineWidth: 0 }).trimEnd();
+}
+function indentOf(text) {
+	return /^( +)\S/m.exec(text)?.[1]?.length ?? 2;
+}
+function yaml() {
+	return {
+		name: "x18n:format-yaml",
+		formats: [{
+			id: "yaml",
+			extensions: ["yml", "yaml"],
+			parse(text, ctx) {
+				const doc = parse$1(text, ctx.path);
+				const ranges = /* @__PURE__ */ new Map();
+				if (doc.contents === null) return {
+					tree: {},
+					ranges
+				};
+				if (!isMap(doc.contents)) throw new X18nError("X18N2003", ctx.path);
+				return {
+					tree: readMap(doc.contents, [], ranges),
+					ranges
+				};
+			},
+			edit(text, ops, ctx) {
+				let next = text;
+				for (const op of ops) {
+					let doc = parse$1(next, ctx.path);
+					const current = doc.getIn(op.path, true);
+					if (op.type === "set" && isScalar(current) && current.range && current.type !== Scalar.BLOCK_FOLDED && current.type !== Scalar.BLOCK_LITERAL) {
+						next = applyTextEdits(next, [{
+							range: {
+								start: current.range[0],
+								end: current.range[1]
+							},
+							text: scalarText(op.value, current.type)
+						}]);
+						continue;
+					}
+					if (doc.contents === null) doc = new Document({});
+					if (op.type === "set") doc.setIn(op.path, op.value);
+					else doc.deleteIn(op.path);
+					next = doc.toString({
+						indent: indentOf(text),
+						lineWidth: 0
+					});
+				}
+				return diffText(text, next);
+			},
+			serialize: (tree) => Object.keys(tree).length === 0 ? "{}\n" : stringify(tree, { lineWidth: 0 })
+		}]
+	};
+}
+//#endregion
+export { json5 as a, ini as c, php as i, ftl as l, properties as n, json as o, po as r, jsonc as s, yaml as t, ecmascript as u };