@x18n/builtins 0.0.13 → 0.0.15

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-C7ceptwi.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-C7ceptwi.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 };

package/dist/formats/resx.mjs

@@ -0,0 +1,202 @@
+import { a as splice, i as leafText, n as detectEol } from "../shared-C7ceptwi.mjs";
+import { diffText, errors, pathId, walkLeaves } from "@x18n/core";
+//#region src/formats/resx/index.ts
+const entities = {
+	lt: "<",
+	gt: ">",
+	amp: "&",
+	quot: "\"",
+	apos: "'"
+};
+function decode(raw) {
+	return raw.replace(/\r\n?/g, "\n").replace(/<!\[CDATA\[([\s\S]*?)\]\]>|&(#x[\da-f]+|#\d+|\w+);/gi, (match, cdata, name) => {
+		if (name === void 0) return cdata ?? match;
+		if (name.startsWith("#")) {
+			const code = name[1] === "x" ? Number.parseInt(name.slice(2), 16) : Number.parseInt(name.slice(1), 10);
+			return code <= 1114111 ? String.fromCodePoint(code) : match;
+		}
+		return entities[name] ?? match;
+	});
+}
+const escapeText = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const escapeAttribute = (text) => escapeText(text).replace(/"/g, "&quot;");
+const isSpace = (char) => char === " " || char === "	";
+/** The range with its indent and line break when it stands on a line of its own. */
+function lineOf(text, range) {
+	let start = range.start;
+	while (isSpace(text[start - 1])) start--;
+	let end = range.end;
+	while (isSpace(text[end])) end++;
+	if (text[end] === "\r") end++;
+	if (text[end] === "\n") end++;
+	return (start === 0 || text[start - 1] === "\n") && (end === text.length || text[end - 1] === "\n") ? {
+		start,
+		end
+	} : range;
+}
+/** Comments and CDATA are skipped so the schema sample in the standard header is not read as data. */
+const tokens = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<data\b((?:[^>"']|"[^"]*"|'[^']*')*)>/g;
+/** The `<value>` inside a `<data>` whose content starts at `offset`. */
+function valueIn(inner, offset) {
+	const match = /<value\s*\/>|<value\s*>([\s\S]*?)<\/value\s*>/d.exec(inner);
+	if (!match) return {
+		value: "",
+		body: void 0,
+		emptyValue: void 0
+	};
+	const [start, end] = match.indices[0];
+	const body = match.indices[1];
+	if (!body) return {
+		value: "",
+		body: void 0,
+		emptyValue: {
+			start: offset + start,
+			end: offset + end
+		}
+	};
+	return {
+		value: decode(match[1]),
+		body: {
+			start: offset + body[0],
+			end: offset + body[1]
+		},
+		emptyValue: void 0
+	};
+}
+function read(text, path) {
+	const entries = [];
+	const objects = /* @__PURE__ */ new Set();
+	const closing = /<\/data\s*>/g;
+	tokens.lastIndex = 0;
+	for (let match = tokens.exec(text); match; match = tokens.exec(text)) {
+		const attributes = match[1];
+		if (attributes === void 0) continue;
+		const start = match.index;
+		const open = start + match[0].length;
+		const selfClosing = attributes.endsWith("/");
+		closing.lastIndex = open;
+		const close = selfClosing ? void 0 : closing.exec(text);
+		if (close === null) throw errors.X18N2002({
+			path,
+			reason: "unclosed <data> element"
+		});
+		const end = close ? close.index + close[0].length : open;
+		tokens.lastIndex = end;
+		const name = /\sname\s*=\s*(?:"([^"]*)"|'([^']*)')/d.exec(attributes);
+		if (!name) continue;
+		const key = decode(name[1] ?? name[2]);
+		if (/\s(?:type|mimetype)\s*=/.test(attributes)) {
+			objects.add(key);
+			continue;
+		}
+		const nameAt = name.indices[1] ?? name.indices[2];
+		const inner = close ? text.slice(open, close.index) : "";
+		const { value, body, emptyValue } = valueIn(inner, open);
+		const line = lineOf(text, {
+			start,
+			end
+		});
+		const keyOffset = start + 5;
+		entries.push({
+			key,
+			value,
+			range: {
+				key: {
+					start: keyOffset + nameAt[0],
+					end: keyOffset + nameAt[1]
+				},
+				value: body ?? emptyValue ?? {
+					start: open,
+					end: open
+				}
+			},
+			body,
+			emptyValue,
+			content: close && inner.trim() ? {
+				start: open,
+				end: close.index
+			} : void 0,
+			element: {
+				start,
+				end
+			},
+			line,
+			indent: line.start < start ? text.slice(line.start, start) : ""
+		});
+	}
+	return {
+		entries,
+		objects
+	};
+}
+function dataElement(key, value, indent, eol) {
+	return `<data name="${escapeAttribute(key)}" xml:space="preserve">${eol}${indent.repeat(2)}<value>${value}</value>${eol}${indent}</data>`;
+}
+function applyOp(text, op, path) {
+	const key = op.path.join(".");
+	const { entries, objects } = read(text, path);
+	const entry = entries.findLast((e) => e.key === key);
+	if (op.type === "delete") return entry ? splice(text, entry.line, "") : text;
+	if (!entry && objects.has(key)) throw errors.X18N4008({ reason: `"${key}" in ${path} holds a file or object, not a string` });
+	const eol = detectEol(text);
+	const value = escapeText(leafText(op.value)).replace(/\n/g, eol);
+	if (entry?.body) return splice(text, entry.body, value);
+	if (entry?.emptyValue) return splice(text, entry.emptyValue, `<value>${value}</value>`);
+	if (entry?.content) {
+		const lead = /^\s*/.exec(text.slice(entry.content.start, entry.content.end))[0];
+		return splice(text, {
+			start: entry.content.start,
+			end: entry.content.start
+		}, `${lead}<value>${value}</value>`);
+	}
+	if (entry) return splice(text, entry.element, dataElement(key, value, entry.indent, eol));
+	const root = text.lastIndexOf("</root>");
+	if (root === -1) throw errors.X18N2002({
+		path,
+		reason: "missing </root>"
+	});
+	const indent = entries.at(-1)?.indent ?? [...text.matchAll(/^([ \t]*)<resheader\b/gm)].at(-1)?.[1] ?? "  ";
+	let at = root;
+	while (isSpace(text[at - 1])) at--;
+	const lead = at === 0 || text[at - 1] === "\n" ? "" : eol;
+	return splice(text, {
+		start: at,
+		end: at
+	}, `${lead}${indent}${dataElement(key, value, indent, eol)}${eol}`);
+}
+const head = `<?xml version="1.0" encoding="utf-8"?>\n<root>\n${[
+	["resmimetype", "text/microsoft-resx"],
+	["version", "2.0"],
+	["reader", "System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"],
+	["writer", "System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"]
+].map(([name, value]) => `  <resheader name="${name}">\n    <value>${value}</value>\n  </resheader>\n`).join("")}`;
+/** .NET `.resx` files: `<data name="key"><value>text</value></data>` inside `<root>`. */
+function resx() {
+	return {
+		name: "x18n:format-resx",
+		formats: [{
+			id: "resx",
+			extensions: ["resx"],
+			parse(text, ctx) {
+				const tree = {};
+				const ranges = /* @__PURE__ */ new Map();
+				for (const entry of read(text, ctx.path).entries) {
+					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) => `${head}${[...walkLeaves(tree)].map((leaf) => `  ${dataElement(leaf.path.join("."), escapeText(leafText(leaf.value)), "  ", "\n")}\n`).join("")}</root>\n`
+		}]
+	};
+}
+//#endregion
+export { resx as default, resx };

package/dist/formats/yaml.d.mts

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

package/dist/formats/yaml.mjs

@@ -0,0 +1,140 @@
+import { a as splice, s as toLeaf } from "../shared-C7ceptwi.mjs";
+import { applyTextEdits, diffText, errors, pathId } from "@x18n/core";
+import { Document, Scalar, isMap, isNode, isScalar, parseDocument, stringify } from "yaml";
+//#region src/formats/yaml/index.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 errors.X18N2002({
+		path,
+		reason: 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();
+}
+/**
+* Deletes a pair of a block map by its lines, so the comments around it stay where they are. The comment at the end of
+* its last line goes with it. Undefined when the Document API must do it.
+*/
+function removePair(text, doc, path) {
+	const map = path.length === 1 ? doc.contents : doc.getIn(path.slice(0, -1), true);
+	if (!isMap(map)) return text;
+	const pair = map.items.findLast((item) => isScalar(item.key) && String(item.key.value) === path.at(-1));
+	const key = pair?.key;
+	if (!pair || !isScalar(key)) return text;
+	if (map.flow || !key.range || map.items.length === 1 && path.length > 1) return void 0;
+	const start = text.lastIndexOf("\n", key.range[0] - 1) + 1;
+	if (!/^[ \t]*$/.test(text.slice(start, key.range[0]))) return void 0;
+	const valueEnd = isNode(pair.value) && pair.value.range ? pair.value.range[1] : key.range[1];
+	const end = text[valueEnd - 1] === "\n" ? valueEnd : valueEnd + /^[ \t]*(?:#.*)?(?:\r?\n)?/.exec(text.slice(valueEnd))[0].length;
+	return splice(text, {
+		start,
+		end
+	}, "");
+}
+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 errors.X18N2003({ path: 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 (op.type === "delete") {
+						const removed = removePair(next, doc, op.path);
+						if (removed !== void 0) {
+							next = removed;
+							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 { yaml as default, yaml };