@x18n/builtins 0.0.13 → 0.0.14

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-Db-8qSbE.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,30 @@
+import { errors, isMessageTree } from "@x18n/core";
+import JSON5 from "json5";
+//#region src/formats/json5/index.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 errors.X18N2002({
+						path: ctx.path,
+						reason: error instanceof Error ? error.message : String(error),
+						cause: error
+					});
+				}
+				if (!isMessageTree(data)) throw errors.X18N2003({ path: ctx.path });
+				return { tree: data };
+			},
+			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-Db-8qSbE.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,200 @@
+import { a as splice } from "../shared-BWaXUmwA.mjs";
+import { applyMessageOps, diffText, errors, isMessageLeaf, 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");
+			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(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(next, op, ctx.path, unit);
+				return diffText(text, next);
+			},
+			serialize: (tree, ctx) => `<?php\n\nreturn ${arrayText(tree, unitOf("", ctx.indent), 0)};\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 };

package/dist/formats/po.mjs

@@ -0,0 +1,177 @@
+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/po/index.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 = {
+	"\\": "\\\\",
+	"\"": "\\\"",
+	"\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(text, path) {
+	const entries = [];
+	let lineNumber = 0;
+	const fail = (message) => {
+		throw errors.X18N2002({
+			path,
+			line: lineNumber,
+			reason: 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[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(text, op, path) {
+	const key = op.path.join(".");
+	const entry = read(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)));
+	const separated = text.trim() === "" || /\n[ \t]*\r?\n$/.test(text);
+	return appendLines(text, `${separated ? "" : "\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(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, 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
+export { po as default, po };

package/dist/formats/properties.d.mts

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

package/dist/formats/properties.mjs

@@ -0,0 +1,123 @@
+import { a as splice, i as leafText, o as splitLines, t as appendLines } from "../shared-BWaXUmwA.mjs";
+import { diffText, errors, pathId, walkLeaves } from "@x18n/core";
+//#region src/formats/properties/index.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 errors.X18N2002({
+				path,
+				reason: `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
+export { properties as default, properties };

package/dist/formats/resx.d.mts

@@ -0,0 +1,6 @@
+import { Plugin } from "@x18n/core";
+//#region src/formats/resx/index.d.ts
+/** .NET `.resx` files: `<data name="key"><value>text</value></data>` inside `<root>`. */
+export declare function resx(): Plugin;
+//#endregion
+export { resx as default };