@x18n/builtins 0.0.13 → 0.0.15

package/dist/formats/ini.mjs

@@ -0,0 +1,158 @@
+import { a as splice, i as leafText, n as detectEol, o as splitLines, t as appendLines } from "../shared-C7ceptwi.mjs";
+import { buildTree, diffText, errors, isMessageLeaf, pathId } from "@x18n/core";
+//#region src/formats/ini/index.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(text, path) {
+	const entries = [];
+	const sections = [];
+	let section = "";
+	let lineNumber = 0;
+	const fail = (message) => {
+		throw errors.X18N2002({
+			path,
+			line: lineNumber,
+			reason: 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(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(text, op, path) {
+	const { entries, sections } = read(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(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(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(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(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(next, op, ctx.path);
+				return diffText(text, next);
+			},
+			serialize
+		}]
+	};
+}
+//#endregion
+export { ini as default, ini };

package/dist/formats/json.d.mts

@@ -0,0 +1,6 @@
+import { t as JsonOptions } from "../json-CyjI8bjp.mjs";
+import { Plugin } from "@x18n/core";
+//#region src/formats/json/index.d.ts
+export declare function json(options?: JsonOptions): Plugin;
+//#endregion
+export { type JsonOptions, json as default };

package/dist/formats/json.mjs

@@ -0,0 +1,10 @@
+import { t as createJsonFormat } from "../json-CGNSGS97.mjs";
+//#region src/formats/json/index.ts
+function json(options = {}) {
+	return {
+		name: "x18n:format-json",
+		formats: [createJsonFormat("json", ["json"], true, options.indent)]
+	};
+}
+//#endregion
+export { json as default, json };

package/dist/formats/json5.d.mts

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

package/dist/formats/json5.mjs

@@ -0,0 +1,143 @@
+import { r as indentUnit } from "../shared-C7ceptwi.mjs";
+import { t as editLiteral } from "../literal-gIdB1VGy.mjs";
+import { diffText, errors, isMessageTree, pathId } from "@x18n/core";
+import JSON5 from "json5";
+//#region src/formats/json5/index.ts
+const stringToken = /^(?:"(?:[^"\\]|\\[\s\S])*"|'(?:[^'\\]|\\[\s\S])*')/;
+function parse(text, path) {
+	let data;
+	try {
+		data = JSON5.parse(text);
+	} catch (error) {
+		throw errors.X18N2002({
+			path,
+			reason: error instanceof Error ? error.message : String(error),
+			cause: error
+		});
+	}
+	if (!isMessageTree(data)) throw errors.X18N2003({ path });
+	return data;
+}
+/** Where the keys and values of valid JSON5 that holds a message tree are. */
+function scan(text) {
+	const ranges = /* @__PURE__ */ new Map();
+	let pos = 0;
+	const skip = () => {
+		pos += /^(?:\s|\/\/.*|\/\*[\s\S]*?\*\/)*/.exec(text.slice(pos))[0].length;
+	};
+	const token = (pattern) => {
+		const start = pos;
+		pos += pattern.exec(text.slice(pos))[0].length;
+		return {
+			start,
+			end: pos
+		};
+	};
+	const inner = (range, quoted) => quoted ? {
+		start: range.start + 1,
+		end: range.end - 1
+	} : range;
+	const scalar = () => {
+		const quote = text[pos] === "\"" || text[pos] === "'" ? text[pos] : void 0;
+		return {
+			kind: "scalar",
+			range: token(quote ? stringToken : /^[^\s,}/]+/),
+			quote
+		};
+	};
+	const object = (path) => {
+		const start = pos++;
+		const items = [];
+		skip();
+		while (text[pos] !== "}") {
+			const quoted = text[pos] === "\"" || text[pos] === "'";
+			const keyRange = token(quoted ? stringToken : /^[^\s:/]+/);
+			const key = Object.keys(JSON5.parse(`{${text.slice(keyRange.start, keyRange.end)}:0}`))[0];
+			skip();
+			pos++;
+			skip();
+			const value = text[pos] === "{" ? object([...path, key]) : scalar();
+			ranges.set(pathId([...path, key]), {
+				key: inner(keyRange, quoted),
+				value: inner(value.range, value.kind === "scalar" && value.quote !== void 0)
+			});
+			items.push({
+				key,
+				range: {
+					start: keyRange.start,
+					end: value.range.end
+				},
+				value
+			});
+			skip();
+			if (text[pos] === ",") pos++;
+			skip();
+		}
+		pos++;
+		return {
+			kind: "object",
+			range: {
+				start,
+				end: pos
+			},
+			items
+		};
+	};
+	skip();
+	return {
+		root: object([]),
+		ranges
+	};
+}
+function firstQuote(object) {
+	for (const { value } of object.items) {
+		const quote = value.kind === "scalar" ? value.quote : firstQuote(value);
+		if (quote) return quote;
+	}
+}
+/** New keys and strings follow the file: quoted keys if its first key is quoted, and the quote of its first string. */
+function syntaxOf(text, root, indent) {
+	const first = root.items[0];
+	const keyQuote = first && /^["']/.test(text[first.range.start]) ? text[first.range.start] : void 0;
+	const quote = firstQuote(root) ?? "\"";
+	return {
+		open: "{",
+		close: "}",
+		separator: ": ",
+		key: (key) => keyQuote ? JSON5.stringify(key, { quote: keyQuote }) : /^[a-z_$][\w$]*$/i.test(key) ? key : JSON5.stringify(key, { quote }),
+		leaf: (value, current) => JSON5.stringify(value, { quote: current ?? quote }),
+		unit: indentUnit(text, indent, "  "),
+		trailingComma: false
+	};
+}
+function json5() {
+	return {
+		name: "x18n:format-json5",
+		formats: [{
+			id: "json5",
+			extensions: ["json5"],
+			parse(text, ctx) {
+				if (text.trim() === "") return {
+					tree: {},
+					ranges: /* @__PURE__ */ new Map()
+				};
+				return {
+					tree: parse(text, ctx.path),
+					ranges: scan(text).ranges
+				};
+			},
+			edit(text, ops, ctx) {
+				let next = text.trim() === "" ? "{}\n" : text;
+				for (const op of ops) {
+					parse(next, ctx.path);
+					const { root } = scan(next);
+					next = editLiteral(next, root, op, syntaxOf(next, root, ctx.indent));
+				}
+				return diffText(text, next);
+			},
+			serialize: (tree, ctx) => `${JSON5.stringify(tree, null, ctx.indent === "tab" ? "	" : ctx.indent ?? 2)}\n`
+		}]
+	};
+}
+//#endregion
+export { json5 as default, json5 };

package/dist/formats/jsonc.d.mts

@@ -0,0 +1,6 @@
+import { t as JsonOptions } from "../json-CyjI8bjp.mjs";
+import { Plugin } from "@x18n/core";
+//#region src/formats/jsonc/index.d.ts
+export declare function jsonc(options?: JsonOptions): Plugin;
+//#endregion
+export { jsonc as default };

package/dist/formats/jsonc.mjs

@@ -0,0 +1,10 @@
+import { t as createJsonFormat } from "../json-CGNSGS97.mjs";
+//#region src/formats/jsonc/index.ts
+function jsonc(options = {}) {
+	return {
+		name: "x18n:format-jsonc",
+		formats: [createJsonFormat("jsonc", ["jsonc"], true, options.indent)]
+	};
+}
+//#endregion
+export { jsonc as default, jsonc };

package/dist/formats/php.d.mts

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

package/dist/formats/php.mjs

@@ -0,0 +1,198 @@
+import { n as literalText, t as editLiteral } from "../literal-gIdB1VGy.mjs";
+import { applyMessageOps, diffText, errors, pathId } from "@x18n/core";
+//#region src/formats/php/index.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, reason) => {
+		throw errors[code]({
+			path,
+			line: text.slice(0, pos).split("\n").length,
+			reason
+		});
+	};
+	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");
+			const value = parseValue();
+			items.push({
+				key: String(key.value),
+				range: {
+					start: key.range.start,
+					end: value.range.end
+				},
+				keyRange: key.quote ? {
+					start: key.range.start + 1,
+					end: key.range.end - 1
+				} : key.range,
+				value
+			});
+			if (eat(/^,/)) continue;
+			skip();
+			if (text[pos] !== close) return fail("X18N2004", `expected "," or "${close}"; expressions are not static`);
+		}
+		return {
+			kind: "object",
+			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 !== "object") 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 !== "object") 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 === "object" ? 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, "\\$&")}'`;
+}
+/** The indent unit is the configured one, else the file's (first indented item), else 4 spaces. */
+function syntaxOf(text, indent) {
+	return {
+		open: "[",
+		close: "]",
+		separator: " => ",
+		key: (key) => literal(key, "'"),
+		leaf: (value, quote) => literal(value, quote),
+		unit: indent === void 0 ? /^([ \t]+)['"\]]/m.exec(text)?.[1] ?? "    " : indent === "tab" ? "	" : " ".repeat(indent),
+		trailingComma: true
+	};
+}
+function applyOp(text, op, path, syntax) {
+	const root = parseFile(text, path);
+	return root ? editLiteral(text, root, op, syntax) : `${text.trim() === "" ? "<?php" : text.trimEnd()}\n\nreturn ${literalText(applyMessageOps({}, [op]), syntax)};\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 syntax = syntaxOf(text, ctx.indent);
+				let next = text;
+				for (const op of ops) next = applyOp(next, op, ctx.path, syntax);
+				return diffText(text, next);
+			},
+			serialize: (tree, ctx) => `<?php\n\nreturn ${literalText(tree, syntaxOf("", ctx.indent))};\n`
+		}]
+	};
+}
+//#endregion
+export { php as default, php };

package/dist/formats/po.d.mts

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