@codemerge/kernel 2.4.0

package/dist/index.mjs

@@ -0,0 +1,1968 @@
+//#region src/document.ts
+var idCounter = 0;
+function resetIdCounter(n = 0) {
+	idCounter = n;
+}
+function nextId(prefix = "n") {
+	idCounter += 1;
+	return `${prefix}${idCounter}`;
+}
+function createText(text, marks = []) {
+	return {
+		marks: marks.length > 0 ? marks.map((m) => ({ ...m })) : void 0,
+		text,
+		type: "text"
+	};
+}
+function createParagraph(content = [createText("")], attrs) {
+	return {
+		attrs: copyAttrs(attrs),
+		content: [...content],
+		id: nextId("p"),
+		type: "paragraph"
+	};
+}
+function createDoc(content) {
+	return {
+		content: content !== void 0 && content.length > 0 ? [...content] : [createParagraph()],
+		id: nextId("doc"),
+		type: "doc"
+	};
+}
+function isAttrsRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Null-prototype attrs bag (no __proto__ pollution). */
+function emptyAttrsRecord() {
+	const raw = Object.create(null);
+	if (!isAttrsRecord(raw)) return {};
+	return raw;
+}
+/** Copy own enumerable attrs onto a null-prototype bag (no __proto__ pollution). */
+function copyAttrs(src) {
+	if (!src) return;
+	const out = emptyAttrsRecord();
+	for (const key of Object.keys(src)) out[key] = src[key];
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+/** Shallow clone node; children array is new, child refs shared (structural sharing). */
+function cloneNode(node) {
+	return {
+		...node,
+		attrs: copyAttrs(node.attrs),
+		content: node.content ? [...node.content] : void 0,
+		marks: node.marks ? node.marks.map((m) => ({
+			...m,
+			attrs: copyAttrs(m.attrs)
+		})) : void 0,
+		text: node.text
+	};
+}
+/** Deep clone node tree (content recursively cloned). */
+function deepCloneNode(node) {
+	const cloned = cloneNode(node);
+	if (cloned.content) cloned.content = cloned.content.map(deepCloneNode);
+	return cloned;
+}
+/** Assign stable ids to every non-text node missing `id`. */
+function ensureNodeIds(node) {
+	const out = {
+		...node,
+		content: node.content ? node.content.map(ensureNodeIds) : void 0,
+		marks: node.marks ? node.marks.map((m) => ({ ...m })) : void 0
+	};
+	if (out.type !== "text" && !out.id) out.id = nextId(out.type === "doc" ? "doc" : out.type === "paragraph" ? "p" : out.type === "listItem" ? "li" : "n");
+	return out;
+}
+function deepClone(value) {
+	return structuredClone(value);
+}
+/** Document JSON format version — bump when the on-disk shape changes. */
+var JSON_DOC_VERSION = 1;
+function docToJSON(doc) {
+	return {
+		doc: deepClone(doc),
+		version: 1
+	};
+}
+function isJSONDoc(value) {
+	if (!("version" in value) || !("doc" in value)) return false;
+	const doc = Reflect.get(value, "doc");
+	return typeof doc === "object" && doc !== null;
+}
+function isDocNode(value) {
+	return typeof Reflect.get(value, "type") === "string";
+}
+function docFromJSON(json) {
+	if (isJSONDoc(json)) {
+		if (json.version !== 1) throw new Error(`Unsupported JSONDoc version: ${json.version}`);
+		if (json.doc.type !== "doc") throw new Error("Expected root type \"doc\"");
+		assertTreeDepth(json.doc);
+		return ensureNodeIds(deepClone(json.doc));
+	}
+	if (isDocNode(json) && json.type === "doc") {
+		assertTreeDepth(json);
+		return ensureNodeIds(deepClone(json));
+	}
+	throw new Error("Expected root type \"doc\"");
+}
+function assertTreeDepth(node, max = 64) {
+	const stack = [{
+		n: node,
+		d: 0
+	}];
+	while (stack.length > 0) {
+		const { n, d } = stack.pop();
+		if (d > max) throw new Error(`Tree exceeds MAX_TREE_DEPTH (${max})`);
+		for (const child of n.content ?? []) stack.push({
+			n: child,
+			d: d + 1
+		});
+	}
+}
+function getNodeAt(doc, path) {
+	let cur = doc;
+	for (const index of path) {
+		if (!cur.content || index < 0 || index >= cur.content.length) throw new Error(`Invalid path: ${path.join(".")}`);
+		cur = cur.content[index];
+	}
+	return cur;
+}
+function replaceAt(doc, path, next) {
+	if (path.length === 0) return next;
+	const [head, ...rest] = path, cloned = cloneNode(doc);
+	if (!cloned.content) throw new Error("Cannot replace in leaf");
+	cloned.content[head] = replaceAt(cloned.content[head], rest, next);
+	return cloned;
+}
+function textLength(node) {
+	if (node.type === "text") return node.text?.length ?? 0;
+	if (!node.content) return 0;
+	return node.content.reduce((sum, child) => sum + textLength(child), 0);
+}
+//#endregion
+//#region src/selection.ts
+function createSelection(anchor, focus = anchor) {
+	return {
+		anchor: {
+			...anchor,
+			path: [...anchor.path]
+		},
+		focus: {
+			...focus,
+			path: [...focus.path]
+		}
+	};
+}
+function collapsedAt(path, offset) {
+	return createSelection({
+		offset,
+		path: [...path]
+	});
+}
+function isCollapsed(sel) {
+	return sel.anchor.offset === sel.focus.offset && sel.anchor.path.length === sel.focus.path.length && sel.anchor.path.every((v, i) => v === sel.focus.path[i]);
+}
+/** Resolve a point inside a paragraph path to ensure offset is within text bounds. */
+function clampPoint(doc, point) {
+	try {
+		let path = [...point.path];
+		let node = getNodeAt(doc, path);
+		while (node.type === "text" && path.length > 0) {
+			path = path.slice(0, -1);
+			node = path.length === 0 ? doc : getNodeAt(doc, path);
+		}
+		if (path.length === 0 || node.type === "doc") return {
+			offset: 0,
+			path: [0]
+		};
+		const max = textLength(node);
+		return {
+			offset: Math.max(0, Math.min(point.offset, max)),
+			path
+		};
+	} catch {
+		return {
+			offset: 0,
+			path: [0]
+		};
+	}
+}
+function clampSelection(doc, sel) {
+	return {
+		anchor: clampPoint(doc, sel.anchor),
+		focus: clampPoint(doc, sel.focus)
+	};
+}
+/** Compare points: -1 if a < b, 0 equal, 1 if a > b (path then offset). */
+function comparePoints(a, b) {
+	const len = Math.max(a.path.length, b.path.length);
+	for (let i = 0; i < len; i++) {
+		const av = a.path[i] ?? -1, bv = b.path[i] ?? -1;
+		if (av !== bv) return av < bv ? -1 : 1;
+	}
+	if (a.offset !== b.offset) return a.offset < b.offset ? -1 : 1;
+	return 0;
+}
+function orderedRange(sel) {
+	return comparePoints(sel.anchor, sel.focus) <= 0 ? {
+		from: sel.anchor,
+		to: sel.focus
+	} : {
+		from: sel.focus,
+		to: sel.anchor
+	};
+}
+//#endregion
+//#region src/schema.ts
+function createSchema() {
+	const schema = {
+		marks: /* @__PURE__ */ new Map(),
+		nodes: /* @__PURE__ */ new Map(),
+		sealed: false
+	};
+	registerNode(schema, {
+		group: "block",
+		name: "doc"
+	});
+	registerNode(schema, {
+		group: "block",
+		name: "paragraph"
+	});
+	registerNode(schema, {
+		group: "inline",
+		name: "text"
+	});
+	registerNode(schema, {
+		atom: true,
+		group: "inline",
+		name: "hardBreak"
+	});
+	registerMark(schema, { name: "bold" });
+	registerMark(schema, { name: "italic" });
+	registerMark(schema, { name: "underline" });
+	registerMark(schema, { name: "strike" });
+	return schema;
+}
+function registerNode(schema, spec) {
+	if (schema.sealed) throw new Error("Schema is sealed");
+	if (schema.nodes.has(spec.name)) throw new Error(`Node already registered: ${spec.name}`);
+	schema.nodes.set(spec.name, spec);
+}
+function registerMark(schema, spec) {
+	if (schema.sealed) throw new Error("Schema is sealed");
+	if (schema.marks.has(spec.name)) throw new Error(`Mark already registered: ${spec.name}`);
+	schema.marks.set(spec.name, spec);
+}
+function sealSchema(schema) {
+	schema.sealed = true;
+}
+function assertMark(schema, mark) {
+	if (!schema.marks.has(mark.type)) throw new Error(`Unknown mark: ${mark.type}`);
+}
+function assertNodeType(schema, type) {
+	if (!schema.nodes.has(type)) throw new Error(`Unknown node type: ${type}`);
+}
+//#endregion
+//#region src/operations.ts
+var BLOCK_CHILD_TYPES = /* @__PURE__ */ new Set([
+	"paragraph",
+	"heading",
+	"listItem",
+	"blockquote",
+	"codeBlock",
+	"bulletList",
+	"orderedList",
+	"table",
+	"tableRow",
+	"tableCell"
+]);
+function assertIntegerPath(path) {
+	for (const seg of path) if (!Number.isInteger(seg)) throw new TypeError(`Path segments must be integers: ${path.join(".")}`);
+}
+function assertLeafTextBlock(node) {
+	if (node.type === "text") throw new Error("Text ops require a leaf text block");
+	if ((node.content ?? []).some((c) => BLOCK_CHILD_TYPES.has(c.type))) throw new Error("Text ops require a leaf text block");
+}
+function flattenText(paragraph) {
+	const runs = [];
+	const keeps = [];
+	let text = "";
+	for (const child of paragraph.content ?? []) if (child.type === "text") {
+		const start = text.length;
+		const chunk = child.text ?? "";
+		text += chunk;
+		runs.push({
+			start,
+			end: text.length,
+			node: child
+		});
+	} else keeps.push({
+		at: text.length,
+		node: deepCloneNode(child)
+	});
+	return {
+		text,
+		runs,
+		keeps
+	};
+}
+function rebuildParagraph(paragraph, text, markAt, keeps = []) {
+	const keepsSorted = [...keeps].toSorted((a, b) => a.at - b.at);
+	if (text.length === 0) {
+		if (keepsSorted.length === 0) return {
+			...cloneNode(paragraph),
+			content: [createText("")]
+		};
+		return {
+			...cloneNode(paragraph),
+			content: keepsSorted.map((k) => deepCloneNode(k.node))
+		};
+	}
+	const content = [];
+	let keepIdx = 0;
+	let i = 0;
+	while (keepIdx < keepsSorted.length && keepsSorted[keepIdx].at <= 0) {
+		content.push(deepCloneNode(keepsSorted[keepIdx].node));
+		keepIdx++;
+	}
+	while (i < text.length) {
+		const marks = markAt(i);
+		let j = i + 1;
+		const nextKeepAt = keepsSorted[keepIdx]?.at ?? text.length + 1;
+		while (j < text.length && j < nextKeepAt && sameMarks(markAt(j), marks)) j++;
+		const end = Math.min(j, nextKeepAt, text.length);
+		if (end > i) {
+			content.push(createText(text.slice(i, end), marks));
+			i = end;
+		}
+		while (keepIdx < keepsSorted.length && keepsSorted[keepIdx].at === i) {
+			content.push(deepCloneNode(keepsSorted[keepIdx].node));
+			keepIdx++;
+		}
+	}
+	while (keepIdx < keepsSorted.length && keepsSorted[keepIdx].at >= text.length) {
+		content.push(deepCloneNode(keepsSorted[keepIdx].node));
+		keepIdx++;
+	}
+	if (content.length === 0) content.push(createText(""));
+	return {
+		...cloneNode(paragraph),
+		content
+	};
+}
+function shiftKeeps(keeps, offset, delta) {
+	return keeps.map((k) => k.at >= offset ? {
+		...k,
+		at: k.at + delta
+	} : k);
+}
+function deleteKeepsInRange(keeps, offset, length) {
+	const end = offset + length;
+	return keeps.filter((k) => k.at <= offset || k.at >= end).map((k) => k.at >= end ? {
+		...k,
+		at: k.at - length
+	} : k);
+}
+function captureKeepsInRange(keeps, from, to) {
+	return keeps.filter((k) => k.at > from && k.at < to).map((k) => ({
+		at: k.at - from,
+		node: deepCloneNode(k.node)
+	}));
+}
+function mergeSliceKeeps(base, from, sliceKeeps) {
+	if (sliceKeeps === void 0 || sliceKeeps.length === 0) return base;
+	return [...base, ...sliceKeeps.map((k) => ({
+		at: from + k.at,
+		node: deepCloneNode(k.node)
+	}))];
+}
+function assertOpSchema(schema, op) {
+	if (!schema) return;
+	if (op.type === "set_mark") assertMark(schema, op.mark);
+	else if (op.type === "insert_text") {
+		if (op.marks) for (const m of op.marks) assertMark(schema, m);
+		if (op.marksByOffset) for (const ms of op.marksByOffset) for (const m of ms) assertMark(schema, m);
+	} else if (op.type === "replace_slice") {
+		for (const run of op.runs) for (const m of run.marks) assertMark(schema, m);
+		for (const k of op.keeps ?? []) {
+			assertMaxTreeDepth(k.node);
+			assertNodeTree(schema, k.node);
+		}
+	} else if (op.type === "split_paragraph") {
+		if (op.rightNode) {
+			assertMaxTreeDepth(op.rightNode);
+			assertNodeTree(schema, op.rightNode);
+		}
+	} else if (op.type === "insert_node") assertNodeTree(schema, op.node);
+}
+function assertNodeTree(schema, node, depthChecked = false) {
+	if (!depthChecked) assertMaxTreeDepth(node);
+	assertNodeType(schema, node.type);
+	if (node.marks) for (const m of node.marks) assertMark(schema, m);
+	for (const child of node.content ?? []) assertNodeTree(schema, child, true);
+}
+function sameMarks(a, b) {
+	if (a.length !== b.length) return false;
+	return a.every((m, i) => m.type === b[i].type && JSON.stringify(m.attrs ?? {}) === JSON.stringify(b[i].attrs ?? {}));
+}
+function cloneMarks(marks) {
+	return marks.map((m) => ({
+		...m,
+		attrs: m.attrs ? { ...m.attrs } : void 0
+	}));
+}
+function marksAt(runs, index) {
+	for (const run of runs) if (index >= run.start && index < run.end) return run.node.marks ? cloneMarks(run.node.marks) : [];
+	const lastRun = runs.at(-1);
+	if (lastRun && index === lastRun.end) return lastRun.node.marks ? cloneMarks(lastRun.node.marks) : [];
+	return [];
+}
+function captureRuns(text, runs, from, to) {
+	const result = [];
+	let i = from;
+	while (i < to) {
+		const marks = marksAt(runs, i);
+		let j = i + 1;
+		while (j < to && sameMarks(marksAt(runs, j), marks)) j++;
+		result.push({
+			text: text.slice(i, j),
+			marks
+		});
+		i = j;
+	}
+	return result;
+}
+/** True when every offset in `[from, to)` carries `markType`. Empty range → false. */
+function rangeHasMark(paragraph, from, to, markType) {
+	const { text, runs } = flattenText(paragraph);
+	const start = Math.max(0, Math.min(from, text.length));
+	const end = Math.max(start, Math.min(to, text.length));
+	if (start >= end) return false;
+	for (let i = start; i < end; i++) if (!marksAt(runs, i).some((m) => m.type === markType)) return false;
+	return true;
+}
+/** Mark presence at a single offset (caret / left of caret). */
+function offsetHasMark(paragraph, offset, markType) {
+	const { text, runs } = flattenText(paragraph);
+	if (text.length === 0) return false;
+	return marksAt(runs, Math.max(0, Math.min(offset, text.length - 1))).some((m) => m.type === markType);
+}
+/** Merge marks by type — `extra` wins on conflict. */
+function mergeMarksByType(base, extra) {
+	const map = /* @__PURE__ */ new Map();
+	for (const m of base) map.set(m.type, {
+		...m,
+		attrs: m.attrs ? { ...m.attrs } : void 0
+	});
+	for (const m of extra) map.set(m.type, {
+		...m,
+		attrs: m.attrs ? { ...m.attrs } : void 0
+	});
+	return [...map.values()];
+}
+/** Hard cap on a single insert_text / replace_slice payload (paste / programmatic flood). */
+var MAX_INSERT_CHARS = 1e5;
+/** Cap on keep nodes injected via replace_slice (hardBreak floods). */
+var MAX_SLICE_KEEPS = 1e4;
+/** Max nesting depth for op/JSON trees (empty structural bombs). */
+var MAX_TREE_DEPTH = 64;
+/** Iterative depth check — fail closed before recursive clone/walk. */
+function assertMaxTreeDepth(node, max = 64) {
+	const stack = [{
+		n: node,
+		d: 0
+	}];
+	while (stack.length > 0) {
+		const { n, d } = stack.pop();
+		if (d > max) throw new Error(`Tree exceeds MAX_TREE_DEPTH (${max})`);
+		for (const child of n.content ?? []) stack.push({
+			n: child,
+			d: d + 1
+		});
+	}
+}
+function applyOp(doc, op, schema) {
+	if ("path" in op) assertIntegerPath(op.path);
+	assertOpSchema(schema, op);
+	switch (op.type) {
+		case "insert_text": {
+			if (op.text.length > 1e5) throw new Error(`insert_text exceeds MAX_INSERT_CHARS (${MAX_INSERT_CHARS})`);
+			const para = getNodeAt(doc, op.path);
+			assertLeafTextBlock(para);
+			const { text, runs, keeps } = flattenText(para);
+			const offset = Math.max(0, Math.min(op.offset, text.length));
+			const nextPara = rebuildParagraph(para, text.slice(0, offset) + op.text + text.slice(offset), (i) => {
+				if (i >= offset && i < offset + op.text.length) {
+					if (op.marksByOffset) return cloneMarks(op.marksByOffset[i - offset] ?? []);
+					const inherited = marksAt(runs, Math.max(0, offset - 1));
+					return op.marks && op.marks.length > 0 ? mergeMarksByType(inherited, op.marks) : inherited;
+				}
+				const src = i < offset ? i : i - op.text.length;
+				return marksAt(runs, src);
+			}, shiftKeeps(keeps, offset, op.text.length));
+			return {
+				doc: replaceAt(doc, op.path, nextPara),
+				inverse: {
+					type: "delete_text",
+					path: op.path,
+					offset,
+					length: op.text.length
+				}
+			};
+		}
+		case "delete_text": {
+			const para = getNodeAt(doc, op.path);
+			assertLeafTextBlock(para);
+			const { text, runs, keeps } = flattenText(para);
+			const offset = Math.max(0, Math.min(op.offset, text.length));
+			const length = Math.min(op.length, text.length - offset);
+			const deletedKeeps = captureKeepsInRange(keeps, offset, offset + length);
+			const captured = captureRuns(text, runs, offset, offset + length);
+			const nextPara = rebuildParagraph(para, text.slice(0, offset) + text.slice(offset + length), (i) => {
+				const src = i < offset ? i : i + length;
+				return marksAt(runs, src);
+			}, deleteKeepsInRange(keeps, offset, length));
+			return {
+				doc: replaceAt(doc, op.path, nextPara),
+				inverse: {
+					type: "replace_slice",
+					path: op.path,
+					from: offset,
+					to: offset,
+					runs: captured,
+					keeps: deletedKeeps
+				}
+			};
+		}
+		case "split_paragraph": {
+			const parentPath = op.path.slice(0, -1);
+			const index = op.path.at(-1);
+			if (index === void 0) throw new Error("split_paragraph path is empty");
+			assertIntegerPath(parentPath);
+			const parent = parentPath.length > 0 ? getNodeAt(doc, parentPath) : doc;
+			const para = getNodeAt(doc, op.path);
+			assertLeafTextBlock(para);
+			const { text, runs, keeps } = flattenText(para);
+			const offset = Math.max(0, Math.min(op.offset, text.length));
+			const leftKeeps = keeps.filter((k) => k.at < offset);
+			const left = rebuildParagraph(para, text.slice(0, offset), (i) => marksAt(runs, i), leftKeeps);
+			let rightRebuilt;
+			if (op.rightNode) rightRebuilt = deepCloneNode(op.rightNode);
+			else {
+				const rightKeeps = keeps.filter((k) => k.at >= offset).map((k) => ({
+					...k,
+					at: k.at - offset
+				}));
+				rightRebuilt = rebuildParagraph({
+					...cloneNode(para),
+					content: [createText("")],
+					id: nextId(para.type === "listItem" ? "li" : "p")
+				}, text.slice(offset), (i) => marksAt(runs, offset + i), rightKeeps);
+			}
+			const nextParent = cloneNode(parent);
+			if (!nextParent.content) throw new Error("split parent has no content");
+			nextParent.content.splice(index, 1, left, rightRebuilt);
+			return {
+				doc: parentPath.length > 0 ? replaceAt(doc, parentPath, nextParent) : nextParent,
+				inverse: {
+					type: "merge_paragraph",
+					path: [...parentPath, index + 1]
+				}
+			};
+		}
+		case "merge_paragraph": {
+			const parentPath = op.path.slice(0, -1);
+			const index = op.path.at(-1);
+			if (index === void 0 || index <= 0) throw new Error("Cannot merge first paragraph");
+			assertIntegerPath(parentPath);
+			const parent = parentPath.length > 0 ? getNodeAt(doc, parentPath) : doc;
+			const left = getNodeAt(doc, [...parentPath, index - 1]);
+			const right = getNodeAt(doc, op.path);
+			assertLeafTextBlock(left);
+			assertLeafTextBlock(right);
+			const rightSnap = deepCloneNode(right);
+			const leftFlat = flattenText(left);
+			const rightFlat = flattenText(right);
+			const mergedText = leftFlat.text + rightFlat.text;
+			const joinAt = leftFlat.text.length;
+			const merged = rebuildParagraph(left, mergedText, (i) => {
+				if (i < joinAt) return marksAt(leftFlat.runs, i);
+				return marksAt(rightFlat.runs, i - joinAt);
+			}, [...leftFlat.keeps, ...rightFlat.keeps.map((k) => ({
+				...k,
+				at: k.at + joinAt
+			}))]);
+			const nextParent = cloneNode(parent);
+			if (!nextParent.content) throw new Error("merge parent has no content");
+			nextParent.content.splice(index - 1, 2, merged);
+			return {
+				doc: parentPath.length > 0 ? replaceAt(doc, parentPath, nextParent) : nextParent,
+				inverse: {
+					type: "split_paragraph",
+					path: [...parentPath, index - 1],
+					offset: joinAt,
+					rightNode: rightSnap
+				}
+			};
+		}
+		case "set_selection": return {
+			doc,
+			inverse: op
+		};
+		case "set_attrs": {
+			const node = getNodeAt(doc, op.path);
+			const prevSnapshot = copyAttrs(node.attrs) ?? emptyAttrsRecord();
+			let nextAttrs;
+			if (op.replace) nextAttrs = copyAttrs(op.attrs) ?? emptyAttrsRecord();
+			else {
+				nextAttrs = copyAttrs(node.attrs) ?? emptyAttrsRecord();
+				for (const [key, value] of Object.entries(op.attrs)) if (value === null) delete nextAttrs[key];
+				else nextAttrs[key] = value;
+			}
+			const next = {
+				...cloneNode(node),
+				attrs: Object.keys(nextAttrs).length > 0 ? nextAttrs : void 0
+			};
+			return {
+				doc: replaceAt(doc, op.path, next),
+				inverse: {
+					type: "set_attrs",
+					path: op.path,
+					attrs: prevSnapshot,
+					replace: true
+				}
+			};
+		}
+		case "set_mark": {
+			const para = getNodeAt(doc, op.path);
+			assertLeafTextBlock(para);
+			const { text, runs, keeps } = flattenText(para);
+			const from = Math.max(0, Math.min(op.from, text.length));
+			const to = Math.max(from, Math.min(op.to, text.length));
+			const captured = captureRuns(text, runs, from, to);
+			const lostKeeps = captureKeepsInRange(keeps, from, to);
+			const nextPara = rebuildParagraph(para, text, (i) => {
+				const base = marksAt(runs, i);
+				if (i >= from && i < to) return [...base.filter((m) => m.type !== op.mark.type), {
+					...op.mark,
+					attrs: copyAttrs(op.mark.attrs)
+				}];
+				return base;
+			}, keeps);
+			return {
+				doc: replaceAt(doc, op.path, nextPara),
+				inverse: {
+					type: "replace_slice",
+					path: op.path,
+					from,
+					to,
+					runs: captured,
+					keeps: lostKeeps
+				}
+			};
+		}
+		case "remove_mark": {
+			const para = getNodeAt(doc, op.path);
+			assertLeafTextBlock(para);
+			const { text, runs, keeps } = flattenText(para);
+			const from = Math.max(0, Math.min(op.from, text.length));
+			const to = Math.max(from, Math.min(op.to, text.length));
+			const captured = captureRuns(text, runs, from, to);
+			const lostKeeps = captureKeepsInRange(keeps, from, to);
+			const nextPara = rebuildParagraph(para, text, (i) => {
+				const base = marksAt(runs, i);
+				if (i >= from && i < to) return base.filter((m) => m.type !== op.markType);
+				return base;
+			}, keeps);
+			return {
+				doc: replaceAt(doc, op.path, nextPara),
+				inverse: {
+					type: "replace_slice",
+					path: op.path,
+					from,
+					to,
+					runs: captured,
+					keeps: lostKeeps
+				}
+			};
+		}
+		case "replace_slice": {
+			const para = getNodeAt(doc, op.path);
+			assertLeafTextBlock(para);
+			const { text, runs, keeps } = flattenText(para);
+			const from = Math.max(0, Math.min(op.from, text.length));
+			const to = Math.max(from, Math.min(op.to, text.length));
+			const captured = captureRuns(text, runs, from, to);
+			const lostKeeps = captureKeepsInRange(keeps, from, to);
+			const newText = op.runs.map((r) => r.text).join("");
+			if (newText.length > 1e5) throw new Error(`replace_slice exceeds MAX_INSERT_CHARS (${MAX_INSERT_CHARS})`);
+			if ((op.keeps?.length ?? 0) > 1e4) throw new Error(`replace_slice exceeds MAX_SLICE_KEEPS (${MAX_SLICE_KEEPS})`);
+			const insertedMarks = [];
+			for (const run of op.runs) {
+				const marks = cloneMarks(run.marks);
+				for (const _ of run.text) insertedMarks.push(cloneMarks(marks));
+			}
+			const nextText = text.slice(0, from) + newText + text.slice(to);
+			const delta = newText.length - (to - from);
+			const nextPara = rebuildParagraph(para, nextText, (i) => {
+				if (i >= from && i < from + newText.length) return insertedMarks[i - from] ?? [];
+				const src = i < from ? i : i - delta;
+				return marksAt(runs, src);
+			}, mergeSliceKeeps(keeps.filter((k) => k.at <= from || k.at >= to).map((k) => k.at >= to ? {
+				...k,
+				at: k.at + delta
+			} : k), from, op.keeps));
+			return {
+				doc: replaceAt(doc, op.path, nextPara),
+				inverse: {
+					type: "replace_slice",
+					path: op.path,
+					from,
+					to: from + newText.length,
+					runs: captured,
+					keeps: lostKeeps
+				}
+			};
+		}
+		case "insert_node": {
+			assertMaxTreeDepth(op.node);
+			if (textLength(op.node) > 1e5) throw new Error(`insert_node exceeds MAX_INSERT_CHARS (${MAX_INSERT_CHARS})`);
+			const nextParent = cloneNode(op.path.length > 0 ? getNodeAt(doc, op.path) : doc);
+			nextParent.content ?? (nextParent.content = []);
+			const index = Math.max(0, Math.min(op.index, nextParent.content.length));
+			nextParent.content.splice(index, 0, ensureNodeIds(deepCloneNode(op.node)));
+			return {
+				doc: op.path.length > 0 ? replaceAt(doc, op.path, nextParent) : nextParent,
+				inverse: {
+					type: "remove_node",
+					path: op.path,
+					index
+				}
+			};
+		}
+		case "remove_node": {
+			const nextParent = cloneNode(op.path.length > 0 ? getNodeAt(doc, op.path) : doc);
+			if (!nextParent.content || op.index < 0 || op.index >= nextParent.content.length) throw new Error("remove_node out of bounds");
+			const [removed] = nextParent.content.splice(op.index, 1);
+			return {
+				doc: op.path.length > 0 ? replaceAt(doc, op.path, nextParent) : nextParent,
+				inverse: {
+					type: "insert_node",
+					path: op.path,
+					index: op.index,
+					node: removed
+				}
+			};
+		}
+		default: throw new Error(`Unknown op: ${JSON.stringify(op)}`);
+	}
+}
+function applyOps(doc, ops, selection, schema) {
+	let current = doc;
+	let sel = selection;
+	const inverses = [];
+	for (const op of ops) {
+		if (op.type === "set_selection") {
+			inverses.push({
+				type: "set_selection",
+				selection: sel
+			});
+			sel = clampSelection(current, op.selection);
+			continue;
+		}
+		const result = applyOp(current, op, schema);
+		current = result.doc;
+		inverses.push(result.inverse);
+		if (op.type === "insert_text") sel = collapsedAt(op.path, op.offset + op.text.length);
+		else if (op.type === "delete_text") sel = collapsedAt(op.path, op.offset);
+		else if (op.type === "split_paragraph") {
+			const parentPath = op.path.slice(0, -1);
+			const index = op.path.at(-1);
+			if (index === void 0) throw new Error("split_paragraph path is empty");
+			sel = collapsedAt([...parentPath, index + 1], 0);
+		} else if (op.type === "merge_paragraph") {
+			const inv = result.inverse;
+			if (inv.type === "split_paragraph") sel = collapsedAt(inv.path, inv.offset);
+		} else if (op.type === "insert_node") {
+			const index = result.inverse.type === "remove_node" ? result.inverse.index : op.index;
+			sel = {
+				anchor: {
+					offset: sel.anchor.offset,
+					path: remapPathSibling(sel.anchor.path, op.path, index, 1)
+				},
+				focus: {
+					offset: sel.focus.offset,
+					path: remapPathSibling(sel.focus.path, op.path, index, 1)
+				}
+			};
+			sel = clampSelection(current, sel);
+		} else if (op.type === "remove_node") {
+			sel = {
+				anchor: {
+					offset: sel.anchor.offset,
+					path: remapPathSibling(sel.anchor.path, op.path, op.index, -1)
+				},
+				focus: {
+					offset: sel.focus.offset,
+					path: remapPathSibling(sel.focus.path, op.path, op.index, -1)
+				}
+			};
+			sel = clampSelection(current, sel);
+		} else sel = clampSelection(current, sel);
+	}
+	return {
+		doc: current,
+		selection: clampSelection(current, sel),
+		inverses: inverses.toReversed()
+	};
+}
+function remapPathSibling(path, parent, index, delta) {
+	const d = parent.length;
+	if (path.length <= d) return path;
+	for (let i = 0; i < d; i++) if (path[i] !== parent[i]) return path;
+	const at = path[d];
+	if (at === void 0) return path;
+	if (delta < 0 && at === index) return path;
+	if (delta > 0 && at >= index || delta < 0 && at > index) {
+		const next = [...path];
+		next[d] = at + delta;
+		return next;
+	}
+	return path;
+}
+function selectionTextRange(sel) {
+	const { from, to } = orderedRange(sel);
+	if (from.path.join(".") !== to.path.join(".")) return null;
+	return {
+		path: from.path,
+		from: from.offset,
+		to: to.offset
+	};
+}
+//#endregion
+//#region src/transform.ts
+function pathsEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+function pathPrefix(longer, shorter) {
+	if (longer.length < shorter.length) return false;
+	for (let i = 0; i < shorter.length; i++) if (longer[i] !== shorter[i]) return false;
+	return true;
+}
+/** Shift path index at `depth` by `delta` when the path is at/after `index`. */
+function shiftPath(path, parentPath, index, delta) {
+	if (!pathPrefix(path, parentPath) || path.length <= parentPath.length) return path;
+	const at = parentPath.length;
+	const cur = path[at];
+	if (cur === void 0 || cur < index) return path;
+	const next = path.slice();
+	next[at] = cur + delta;
+	return next;
+}
+function mapPath(op, map) {
+	switch (op.type) {
+		case "set_selection": return op;
+		case "insert_text":
+		case "delete_text":
+		case "split_paragraph":
+		case "merge_paragraph":
+		case "set_mark":
+		case "remove_mark":
+		case "replace_slice":
+		case "set_attrs":
+		case "insert_node":
+		case "remove_node": return {
+			...op,
+			path: map(op.path)
+		};
+		default: return op;
+	}
+}
+function mapOffset(op, path, map) {
+	if (!("path" in op) || !pathsEqual(op.path, path)) return op;
+	switch (op.type) {
+		case "insert_text": return {
+			...op,
+			offset: map(op.offset)
+		};
+		case "delete_text": {
+			const start = map(op.offset);
+			const end = map(op.offset + op.length);
+			return {
+				...op,
+				offset: start,
+				length: Math.max(0, end - start)
+			};
+		}
+		case "split_paragraph": return {
+			...op,
+			offset: map(op.offset)
+		};
+		case "set_mark":
+		case "remove_mark":
+		case "replace_slice": {
+			const from = map(op.from);
+			const to = map(op.to);
+			return {
+				...op,
+				from,
+				to: Math.max(from, to)
+			};
+		}
+		case "merge_paragraph":
+		case "insert_node":
+		case "remove_node":
+		case "set_attrs": return op;
+		default: return op;
+	}
+}
+/**
+* Transform `op` so it can be applied after `against` was already applied
+* (ProseMirror-style: rebase client op against server op).
+* Returns null if `op` becomes a no-op.
+*/
+function transformOp(op, against) {
+	if (op.type === "set_selection" || against.type === "set_selection") return op.type === "set_selection" ? null : op;
+	if (against.type === "insert_node") {
+		let next = mapPath(op, (p) => shiftPath(p, against.path, against.index, 1));
+		if ((next.type === "insert_node" || next.type === "remove_node") && pathsEqual(next.path, against.path) && next.index >= against.index) next = {
+			...next,
+			index: next.index + 1
+		};
+		return next;
+	}
+	if (against.type === "remove_node") {
+		if ((op.type === "insert_node" || op.type === "remove_node") && pathsEqual(op.path, against.path)) {
+			if (op.index === against.index && op.type === "remove_node") return null;
+			if (op.index > against.index) return {
+				...op,
+				index: op.index - 1
+			};
+		}
+		const removedPath = [...against.path, against.index];
+		if ("path" in op && pathPrefix(op.path, removedPath) && op.path.length >= removedPath.length && pathsEqual(op.path.slice(0, removedPath.length), removedPath)) return null;
+		let next = mapPath(op, (p) => shiftPath(p, against.path, against.index + 1, -1));
+		if ((next.type === "insert_node" || next.type === "remove_node") && pathsEqual(next.path, against.path) && next.index > against.index) next = {
+			...next,
+			index: next.index - 1
+		};
+		return next;
+	}
+	if (against.type === "split_paragraph") {
+		const parentPath = against.path.slice(0, -1);
+		const index = against.path.at(-1);
+		if (index === void 0) return op;
+		if ("path" in op && pathsEqual(op.path, against.path)) {
+			if (op.type === "insert_text") {
+				if (op.offset <= against.offset) return op;
+				return {
+					...op,
+					path: [...parentPath, index + 1],
+					offset: op.offset - against.offset
+				};
+			}
+			if (op.type === "delete_text") {
+				if (op.offset + op.length <= against.offset) return op;
+				if (op.offset >= against.offset) return {
+					...op,
+					path: [...parentPath, index + 1],
+					offset: op.offset - against.offset
+				};
+				return {
+					...op,
+					length: against.offset - op.offset
+				};
+			}
+			if (op.type === "split_paragraph") {
+				if (op.offset <= against.offset) return op;
+				return {
+					...op,
+					path: [...parentPath, index + 1],
+					offset: op.offset - against.offset
+				};
+			}
+		}
+		return mapPath(op, (p) => shiftPath(p, parentPath, index + 1, 1));
+	}
+	if (against.type === "merge_paragraph") {
+		const parentPath = against.path.slice(0, -1);
+		const index = against.path.at(-1);
+		if (index === void 0 || index <= 0) return op;
+		const leftPath = [...parentPath, index - 1];
+		const rightPath = against.path;
+		if ("path" in op && pathsEqual(op.path, rightPath)) return mapPath(op, () => leftPath);
+		return mapPath(op, (p) => shiftPath(p, parentPath, index, -1));
+	}
+	if (against.type === "insert_text" && "path" in op && pathsEqual(op.path, against.path)) return mapOffset(op, against.path, (o) => o >= against.offset ? o + against.text.length : o);
+	if (against.type === "delete_text" && "path" in op && pathsEqual(op.path, against.path)) {
+		const delStart = against.offset;
+		const delEnd = against.offset + against.length;
+		return mapOffset(op, against.path, (o) => {
+			if (o >= delEnd) return o - against.length;
+			if (o >= delStart) return delStart;
+			return o;
+		});
+	}
+	if (against.type === "replace_slice" && "path" in op && pathsEqual(op.path, against.path)) {
+		const removed = against.to - against.from;
+		const inserted = against.runs.reduce((n, r) => n + r.text.length, 0);
+		const delta = inserted - removed;
+		return mapOffset(op, against.path, (o) => {
+			if (o >= against.to) return o + delta;
+			if (o >= against.from) return against.from + inserted;
+			return o;
+		});
+	}
+	return op;
+}
+/** Transform a sequence of ops against a single already-applied op. */
+function transformOps(ops, against) {
+	const out = [];
+	for (const op of ops) {
+		const next = transformOp(op, against);
+		if (next) out.push(next);
+	}
+	return out;
+}
+/**
+* Rebase client ops that were based on `baseVersion` against server ops
+* that landed since (in order). Returns ops safe to apply on the new tip.
+*/
+function rebaseOps(clientOps, serverOps) {
+	let pending = clientOps.filter((o) => o.type !== "set_selection");
+	for (const serverOp of serverOps) {
+		if (serverOp.type === "set_selection") continue;
+		pending = transformOps(pending, serverOp);
+	}
+	return pending;
+}
+//#endregion
+//#region src/structure.ts
+var TEXT_BLOCKS = /* @__PURE__ */ new Set([
+	"paragraph",
+	"heading",
+	"listItem",
+	"blockquote",
+	"codeBlock"
+]);
+var LIST_TYPES = /* @__PURE__ */ new Set(["bulletList", "orderedList"]);
+function isTextBlock(type) {
+	return TEXT_BLOCKS.has(type);
+}
+function isListType(type) {
+	return LIST_TYPES.has(type);
+}
+/** Flatten text of a text-bearing node (paragraph / heading / listItem). */
+function plainText(node) {
+	if (node.type === "text") return node.text ?? "";
+	let out = "";
+	for (const child of node.content ?? []) if (child.type === "text") out += child.text ?? "";
+	else if (child.content) out += plainText(child);
+	return out;
+}
+/**
+* Resolve selection path to a text-bearing leaf.
+* Lists → first/only item; listItem → nested paragraph; table → first cell paragraph.
+*/
+function resolveTextPath(doc, path) {
+	if (path.length === 0) return [0];
+	let cur = getNodeAt(doc, path);
+	const resolved = [...path];
+	if (isListType(cur.type)) {
+		if ((cur.content?.length ?? 0) === 0) return resolved;
+		resolved.push(0);
+		cur = cur.content[0];
+	}
+	if (cur.type === "table") {
+		const row = cur.content?.[0];
+		const cell = row?.content?.[0];
+		if (row && cell) {
+			resolved.push(0, 0);
+			cur = cell;
+		}
+	}
+	if (cur.type === "tableRow") {
+		const cell = cur.content?.[0];
+		if (cell) {
+			resolved.push(0);
+			cur = cell;
+		}
+	}
+	if (cur.type === "tableCell") {
+		const para = cur.content?.[0];
+		if (para && isTextBlock(para.type)) {
+			resolved.push(0);
+			cur = para;
+		} else if (!para) return resolved;
+	}
+	if (cur.type === "listItem") {
+		const first = cur.content?.[0];
+		if (first && first.type !== "text" && isTextBlock(first.type) && first.type !== "listItem") {
+			resolved.push(0);
+			cur = first;
+		}
+	}
+	if (cur.type === "blockquote" || cur.type === "codeBlock") {
+		const first = cur.content?.[0];
+		if (first && isTextBlock(first.type)) {
+			resolved.push(0);
+			return resolveTextPath(doc, resolved);
+		}
+	}
+	return resolved;
+}
+function createListItem(content = [createText("")]) {
+	return {
+		type: "listItem",
+		content: [...content]
+	};
+}
+function createList(listType, items) {
+	return {
+		type: listType,
+		id: `list_${Date.now()}`,
+		content: items.length > 0 ? items : [createListItem()]
+	};
+}
+/** Extract a paragraph to lift out of a list item. */
+function liftedParagraphFromItem(item) {
+	const content = item.content ?? [];
+	const first = content[0];
+	if (first !== void 0 && first.type === "paragraph") return deepCloneNode(first);
+	if (first !== void 0 && isTextBlock(first.type) && first.type !== "listItem" && !isListType(first.type)) return deepCloneNode(first);
+	return createParagraph(content.length > 0 ? content.map(deepCloneNode) : [createText("")]);
+}
+/**
+* Lift list item `itemIndex` out of the list at `listPath` into the list's parent.
+* Removes the list, reinserts before-list (if any), lifted paragraph, after-list (if any).
+*/
+function liftIntoParent(doc, listPath, itemIndex) {
+	const list = getNodeAt(doc, listPath);
+	const items = list.content ?? [];
+	const listIndex = listPath.at(-1);
+	if (listIndex === void 0) throw new Error("liftIntoParent: empty list path");
+	const parentPath = listPath.slice(0, -1);
+	const item = items[itemIndex];
+	if (item === void 0) throw new Error("liftIntoParent: item out of bounds");
+	const before = items.slice(0, itemIndex);
+	const after = items.slice(itemIndex + 1);
+	const para = liftedParagraphFromItem(item);
+	const ops = [];
+	ops.push({
+		type: "remove_node",
+		path: parentPath,
+		index: listIndex
+	});
+	let insertAt = listIndex;
+	if (before.length > 0) {
+		ops.push({
+			type: "insert_node",
+			path: parentPath,
+			index: insertAt,
+			node: {
+				...list,
+				content: before,
+				id: `list_${Date.now()}_a`
+			}
+		});
+		insertAt += 1;
+	}
+	ops.push({
+		type: "insert_node",
+		path: parentPath,
+		index: insertAt,
+		node: para
+	});
+	const liftedIndex = insertAt;
+	const selectionPath = [...parentPath, insertAt];
+	insertAt += 1;
+	if (after.length > 0) ops.push({
+		type: "insert_node",
+		path: parentPath,
+		index: insertAt,
+		node: {
+			...list,
+			content: after,
+			id: `list_${Date.now()}_b`
+		}
+	});
+	return {
+		ops,
+		selectionPath,
+		liftedIndex
+	};
+}
+/** Exit empty list item: lift to paragraph in the list's parent (any depth). */
+function exitListItemOps(doc, listPath, itemIndex) {
+	const { ops, selectionPath } = liftIntoParent(doc, listPath, itemIndex);
+	return {
+		ops,
+		selectionPath
+	};
+}
+function textBlockLength(doc, path) {
+	try {
+		return textLength(getNodeAt(doc, path));
+	} catch {
+		return 0;
+	}
+}
+//#endregion
+//#region src/normalize.ts
+/** Idempotent normalize: ensure doc has content, text blocks have text leaves, coalesce adjacent same-mark texts. */
+function normalize(doc) {
+	if (doc.type !== "doc") throw new Error("normalize expects doc");
+	const next = cloneNode(doc);
+	if (!next.content || next.content.length === 0) {
+		next.content = [{
+			content: [createText("")],
+			id: "p_empty",
+			type: "paragraph"
+		}];
+		return next;
+	}
+	next.content = next.content.map(normalizeBlock);
+	if (next.content.length === 0) next.content = [{
+		content: [createText("")],
+		id: "p_empty",
+		type: "paragraph"
+	}];
+	return next;
+}
+function normalizeBlock(node) {
+	if (node.type === "text") return node;
+	const cloned = cloneNode(node);
+	if (!cloned.content || cloned.content.length === 0) {
+		if (isListType(node.type)) return {
+			type: "paragraph",
+			id: nextId("p"),
+			content: [createText("")]
+		};
+		if (isTextBlock(node.type)) cloned.content = [createText("")];
+		return cloned;
+	}
+	if (isTextBlock(node.type)) {
+		cloned.content = coalesceText(cloned.content.map(normalizeBlock));
+		if (cloned.content.length === 0) cloned.content = [createText("")];
+	} else {
+		cloned.content = cloned.content.map(normalizeBlock);
+		if (isListType(node.type)) {
+			cloned.content = cloned.content.filter((c) => {
+				if (c.type !== "listItem") return true;
+				return (c.content?.length ?? 0) > 0;
+			});
+			if (cloned.content.length === 0) return {
+				type: "paragraph",
+				id: nextId("p"),
+				content: [createText("")]
+			};
+		}
+	}
+	return cloned;
+}
+function coalesceText(nodes) {
+	const out = [];
+	for (const n of nodes) {
+		if (n.type !== "text") {
+			out.push(n);
+			continue;
+		}
+		const prev = out.at(-1);
+		if (prev?.type === "text" && JSON.stringify(prev.marks ?? []) === JSON.stringify(n.marks ?? [])) out[out.length - 1] = {
+			...prev,
+			text: (prev.text ?? "") + (n.text ?? "")
+		};
+		else out.push(n);
+	}
+	return out;
+}
+function isNormalizeIdempotent(doc) {
+	const a = normalize(doc), b = normalize(a);
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+//#endregion
+//#region src/transaction.ts
+function createState(doc = createDoc(), selection) {
+	const normalized = normalize(doc);
+	return {
+		doc: normalized,
+		selection: clampSelection(normalized, selection ?? collapsedAt([0], 0))
+	};
+}
+function applyTransaction(state, tr, schema) {
+	const { doc, selection, inverses } = applyOps(state.doc, tr.ops, state.selection, schema);
+	return {
+		inverses,
+		state: {
+			doc: normalize(doc),
+			selection
+		}
+	};
+}
+function transaction(...ops) {
+	return { ops };
+}
+//#endregion
+//#region src/history.ts
+function createHistory(options = {}) {
+	const maxDepth = options.maxDepth ?? 100, mergeWindowMs = options.mergeWindowMs ?? 500, maxEntryChars = options.maxEntryChars ?? 1e4, schema = options.schema, undoStack = [], redoStack = [];
+	function push(entry) {
+		const last = undoStack.at(-1);
+		if (last && entry.at - last.at <= mergeWindowMs && isTyping(entry.redo) && isTyping(last.redo) && last.chars + entry.chars <= maxEntryChars) {
+			last.redo = [...last.redo, ...entry.redo];
+			last.inverses = [...entry.inverses, ...last.inverses];
+			last.selection = entry.selection;
+			last.at = entry.at;
+			last.chars += entry.chars;
+		} else undoStack.push(entry);
+		while (undoStack.length > maxDepth) undoStack.shift();
+		redoStack.length = 0;
+	}
+	return {
+		apply(state, tr, now = Date.now()) {
+			const { state: next, inverses } = applyTransaction(state, tr, schema);
+			if (tr.ops.some((op) => op.type !== "set_selection")) {
+				const redo = tr.ops.filter((o) => o.type !== "set_selection");
+				push({
+					inverses,
+					redo,
+					selection: next.selection,
+					at: now,
+					chars: entryCharCount(redo)
+				});
+			}
+			return next;
+		},
+		canRedo: () => redoStack.length > 0,
+		canUndo: () => undoStack.length > 0,
+		clear() {
+			undoStack.length = 0;
+			redoStack.length = 0;
+		},
+		depth: () => undoStack.length,
+		redo(state) {
+			const entry = redoStack.pop();
+			if (!entry) return state;
+			const { state: next, inverses } = applyTransaction(state, transaction(...entry.redo), schema);
+			undoStack.push({
+				inverses,
+				redo: entry.redo,
+				selection: entry.selection,
+				at: Date.now(),
+				chars: entry.chars
+			});
+			return {
+				...next,
+				selection: entry.selection
+			};
+		},
+		undo(state) {
+			const entry = undoStack.pop();
+			if (!entry) return state;
+			const { state: next } = applyTransaction(state, transaction(...entry.inverses), schema);
+			redoStack.push(entry);
+			return next;
+		}
+	};
+}
+function isTyping(ops) {
+	return ops.length > 0 && ops.every((o) => o.type === "insert_text" || o.type === "delete_text");
+}
+function entryCharCount(ops) {
+	let n = 0;
+	for (const op of ops) if (op.type === "insert_text") n += op.text.length;
+	else if (op.type === "delete_text") n += op.length;
+	return n;
+}
+function emptyState() {
+	return createState();
+}
+//#endregion
+//#region src/commands.ts
+function textPath(state) {
+	return resolveTextPath(state.doc, state.selection.anchor.path);
+}
+function samePath(a, b) {
+	return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+function isLeafTextBlock(node) {
+	return isTextBlock(node.type) && !(node.content ?? []).some((c) => c.type !== "text" && (isTextBlock(c.type) || isListType(c.type) || c.type === "table" || c.type === "tableRow" || c.type === "tableCell"));
+}
+/**
+* Ops to delete the current selection — same-path text or cross-block (siblings / root span).
+* Keeps selectAll → deleteBackward/insertText working.
+*/
+function deleteSelectionRangeOps(doc, sel) {
+	const { from, to } = orderedRange(sel);
+	if (samePath(from.path, to.path)) {
+		if (from.offset === to.offset) return null;
+		return [{
+			type: "delete_text",
+			path: resolveTextPath(doc, from.path),
+			offset: from.offset,
+			length: to.offset - from.offset
+		}];
+	}
+	if (from.path.length === to.path.length && from.path.length > 0 && samePath(from.path.slice(0, -1), to.path.slice(0, -1))) return deleteSiblingSpan(doc, from, to);
+	return deleteRootSpan(doc, from, to);
+}
+function deleteSiblingSpan(doc, from, to) {
+	return deleteSpanUnderParent(doc, from, to, from.path.slice(0, -1), from.path.at(-1) ?? 0, to.path.at(-1) ?? 0);
+}
+function deleteSpanUnderParent(doc, from, to, parent, fromIdx, toIdx) {
+	const fromPath = resolveTextPath(doc, from.path);
+	const toPath = resolveTextPath(doc, to.path);
+	const ops = [];
+	const fromLen = textLength(getNodeAt(doc, fromPath));
+	if (from.offset < fromLen) ops.push({
+		type: "delete_text",
+		path: fromPath,
+		offset: from.offset,
+		length: fromLen - from.offset
+	});
+	const fromBlock = getNodeAt(doc, [...parent, fromIdx]);
+	const toBlock = getNodeAt(doc, [...parent, toIdx]);
+	if (isLeafTextBlock(fromBlock) && isLeafTextBlock(toBlock) && toIdx > fromIdx) {
+		if (to.offset > 0) {
+			const remappedTo = [...toPath];
+			if (parent.length < remappedTo.length) remappedTo[parent.length] = toIdx;
+			ops.push({
+				type: "delete_text",
+				path: remappedTo,
+				offset: 0,
+				length: to.offset
+			});
+		}
+		for (let i = toIdx - 1; i > fromIdx; i--) ops.push({
+			type: "remove_node",
+			path: parent,
+			index: i
+		});
+		ops.push({
+			type: "merge_paragraph",
+			path: [...parent, fromIdx + 1]
+		});
+	} else return deleteLeafSpan(doc, from, to);
+	ops.push({
+		type: "set_selection",
+		selection: collapsedAt(fromPath, from.offset)
+	});
+	return ops;
+}
+function collectTextLeaves(node, path, out) {
+	if (isLeafTextBlock(node)) {
+		out.push([...path]);
+		return;
+	}
+	(node.content ?? []).forEach((child, i) => {
+		collectTextLeaves(child, [...path, i], out);
+	});
+}
+function removableAncestor(doc, leafPath) {
+	if (leafPath.length >= 2) {
+		const itemPath = leafPath.slice(0, -1);
+		try {
+			const item = getNodeAt(doc, itemPath);
+			if (item.type === "listItem" || item.type === "tableCell") return {
+				parent: itemPath.slice(0, -1),
+				index: itemPath.at(-1) ?? 0
+			};
+		} catch {}
+	}
+	return {
+		parent: leafPath.slice(0, -1),
+		index: leafPath.at(-1) ?? 0
+	};
+}
+function deleteLeafSpan(doc, from, to) {
+	const fromPath = resolveTextPath(doc, from.path);
+	const toPath = resolveTextPath(doc, to.path);
+	let d = 0;
+	while (d < fromPath.length && d < toPath.length && fromPath[d] === toPath[d]) d++;
+	const rootPath = fromPath.slice(0, d);
+	const rootNode = rootPath.length === 0 ? doc : getNodeAt(doc, rootPath);
+	const leaves = [];
+	collectTextLeaves(rootNode, rootPath, leaves);
+	const i0 = leaves.findIndex((p) => samePath(p, fromPath));
+	const i1 = leaves.findIndex((p) => samePath(p, toPath));
+	if (i0 === -1 || i1 === -1) return [];
+	const start = Math.min(i0, i1);
+	const end = Math.max(i0, i1);
+	const ops = [];
+	const first = leaves[start];
+	if (first === void 0) return [];
+	const firstLen = textLength(getNodeAt(doc, first));
+	const firstFrom = samePath(first, fromPath) ? from.offset : 0;
+	if (firstFrom < firstLen) ops.push({
+		type: "delete_text",
+		path: first,
+		offset: firstFrom,
+		length: firstLen - firstFrom
+	});
+	const removals = [];
+	const startFullyCovered = firstFrom === 0 && (end > start || to.offset >= firstLen);
+	for (let i = end; i >= start; i--) {
+		if (i === start && !startFullyCovered) continue;
+		const leaf = leaves[i];
+		if (leaf === void 0) continue;
+		if (!(i === start ? startFullyCovered : i < end || to.offset >= textLength(getNodeAt(doc, leaf)))) {
+			if (i === end && to.offset > 0) ops.push({
+				type: "delete_text",
+				path: leaf,
+				offset: 0,
+				length: to.offset
+			});
+			continue;
+		}
+		const rem = removableAncestor(doc, leaf);
+		const key = `${rem.parent.join(".")}:${rem.index}`;
+		if (!removals.some((r) => r.key === key)) removals.push({
+			...rem,
+			key
+		});
+	}
+	removals.sort((a, b) => {
+		if (a.parent.length !== b.parent.length) return b.parent.length - a.parent.length;
+		for (let i = 0; i < a.parent.length; i++) if (a.parent[i] !== b.parent[i]) return (b.parent[i] ?? 0) - (a.parent[i] ?? 0);
+		return b.index - a.index;
+	});
+	for (const rem of removals) ops.push({
+		type: "remove_node",
+		path: rem.parent,
+		index: rem.index
+	});
+	ops.push({
+		type: "set_selection",
+		selection: collapsedAt(fromPath, from.offset)
+	});
+	return ops;
+}
+function deleteRootSpan(doc, from, to) {
+	const fromRoot = from.path[0] ?? 0;
+	const toRoot = to.path[0] ?? 0;
+	const fromPath = resolveTextPath(doc, from.path);
+	const ops = [];
+	if (fromRoot === toRoot) {
+		let d = 0;
+		while (d < from.path.length && d < to.path.length && from.path[d] === to.path[d]) d++;
+		if (d < from.path.length && d < to.path.length && from.path.length === to.path.length) return deleteSpanUnderParent(doc, from, to, from.path.slice(0, d), from.path[d] ?? 0, to.path[d] ?? 0);
+		return deleteLeafSpan(doc, from, to);
+	}
+	const fromLen = textLength(getNodeAt(doc, fromPath));
+	if (from.offset < fromLen) ops.push({
+		type: "delete_text",
+		path: fromPath,
+		offset: from.offset,
+		length: fromLen - from.offset
+	});
+	const fromBlock = getNodeAt(doc, [fromRoot]);
+	const toBlock = getNodeAt(doc, [toRoot]);
+	const toPath = resolveTextPath(doc, to.path);
+	if (from.path.length === 1 && to.path.length === 1 && isLeafTextBlock(fromBlock) && isLeafTextBlock(toBlock)) {
+		if (to.offset > 0) ops.push({
+			type: "delete_text",
+			path: toPath,
+			offset: 0,
+			length: to.offset
+		});
+		for (let i = toRoot - 1; i > fromRoot; i--) ops.push({
+			type: "remove_node",
+			path: [],
+			index: i
+		});
+		ops.push({
+			type: "merge_paragraph",
+			path: [fromRoot + 1]
+		});
+	} else return deleteLeafSpan(doc, from, to);
+	ops.push({
+		type: "set_selection",
+		selection: collapsedAt(fromPath, from.offset)
+	});
+	return ops;
+}
+function insertText(text, marks) {
+	return (state) => {
+		const range = selectionTextRange(state.selection);
+		if (!range) {
+			const cross = deleteSelectionRangeOps(state.doc, state.selection);
+			if (cross && !isCollapsedSelection(state.selection)) {
+				const path = resolveTextPath(state.doc, orderedRange(state.selection).from.path);
+				const offset = orderedRange(state.selection).from.offset;
+				const ops = cross.filter((op) => op.type !== "set_selection");
+				ops.push(marks && marks.length > 0 ? {
+					type: "insert_text",
+					path,
+					offset,
+					text,
+					marks
+				} : {
+					type: "insert_text",
+					path,
+					offset,
+					text
+				}, {
+					type: "set_selection",
+					selection: collapsedAt(path, offset + text.length)
+				});
+				return ops;
+			}
+		}
+		const path = resolveTextPath(state.doc, range?.path ?? state.selection.anchor.path);
+		const offset = range ? range.from : state.selection.anchor.offset;
+		const ops = [];
+		if (range && range.from !== range.to) ops.push({
+			type: "delete_text",
+			path,
+			offset: range.from,
+			length: range.to - range.from
+		});
+		ops.push(marks && marks.length > 0 ? {
+			type: "insert_text",
+			path,
+			offset,
+			text,
+			marks
+		} : {
+			type: "insert_text",
+			path,
+			offset,
+			text
+		});
+		return ops;
+	};
+}
+function isCollapsedSelection(sel) {
+	return samePath(sel.anchor.path, sel.focus.path) && sel.anchor.offset === sel.focus.offset;
+}
+/**
+* Track-changes style backspace: mark the previous char as deleted instead of
+* removing it. Hard-deletes own `insertion` marks and already-marked deletions.
+*/
+function softDeleteBackward(deletionMark) {
+	return (state) => {
+		if (!isCollapsedSelection(state.selection)) return deleteBackward(state);
+		const path = textPath(state);
+		const offset = state.selection.anchor.offset;
+		if (offset <= 0) return deleteBackward(state);
+		const { text, runs } = flattenTextForMarks(getNodeAt(state.doc, path));
+		if (text.length === 0) return deleteBackward(state);
+		const from = offset - 1;
+		if (marksAtOffset(runs, from).some((m) => m.type === "insertion" || m.type === deletionMark.type)) return [{
+			type: "delete_text",
+			path,
+			offset: from,
+			length: 1
+		}];
+		return [{
+			type: "set_mark",
+			path,
+			from,
+			to: offset,
+			mark: deletionMark
+		}, {
+			type: "set_selection",
+			selection: collapsedAt(path, from)
+		}];
+	};
+}
+function flattenTextForMarks(paragraph) {
+	let text = "";
+	const runs = [];
+	for (const child of paragraph.content ?? []) {
+		if (child.type !== "text") continue;
+		const start = text.length;
+		const chunk = child.text ?? "";
+		text += chunk;
+		runs.push({
+			start,
+			end: text.length,
+			marks: (child.marks ?? []).map((m) => ({ ...m }))
+		});
+	}
+	return {
+		text,
+		runs
+	};
+}
+function marksAtOffset(runs, index) {
+	for (const run of runs) if (index >= run.start && index < run.end) return run.marks.map((m) => ({ ...m }));
+	return [];
+}
+/** Resolve list-item path when caret is on the item or its first nested text block. */
+function listItemContext(doc, path) {
+	let node;
+	try {
+		node = getNodeAt(doc, path);
+	} catch {
+		return null;
+	}
+	if (node.type === "listItem") {
+		const itemIndex = path.at(-1) ?? 0;
+		return {
+			listItemPath: path,
+			listPath: path.slice(0, -1),
+			itemIndex
+		};
+	}
+	if (path.length < 2) return null;
+	const parentPath = path.slice(0, -1);
+	try {
+		if (getNodeAt(doc, parentPath).type === "listItem" && (path.at(-1) ?? 0) === 0) {
+			const itemIndex = parentPath.at(-1) ?? 0;
+			return {
+				listItemPath: parentPath,
+				listPath: parentPath.slice(0, -1),
+				itemIndex
+			};
+		}
+	} catch {}
+	return null;
+}
+var deleteBackward = (state) => {
+	const crossOrSame = deleteSelectionRangeOps(state.doc, state.selection);
+	if (crossOrSame) {
+		const range = selectionTextRange(state.selection);
+		if (!range || range.from !== range.to) return crossOrSame;
+	}
+	const path = textPath(state);
+	const offset = state.selection.anchor.offset;
+	if (offset > 0) return [{
+		type: "delete_text",
+		path,
+		offset: offset - 1,
+		length: 1
+	}];
+	const listCtx = listItemContext(state.doc, path);
+	if (listCtx) {
+		const { listItemPath, listPath, itemIndex } = listCtx;
+		if (itemIndex > 0) {
+			const prevItemPath = [...listPath, itemIndex - 1];
+			const leftItem = getNodeAt(state.doc, prevItemPath);
+			const rightItem = getNodeAt(state.doc, listItemPath);
+			if (isLeafTextBlock(leftItem) && isLeafTextBlock(rightItem)) return [{
+				type: "merge_paragraph",
+				path: listItemPath
+			}];
+			const ops = [];
+			const leftCount = leftItem.content?.length ?? 0;
+			const rightContent = rightItem.content ?? [];
+			for (let i = 0; i < rightContent.length; i++) {
+				const node = rightContent[i];
+				if (node === void 0) continue;
+				ops.push({
+					type: "insert_node",
+					path: prevItemPath,
+					index: leftCount + i,
+					node
+				});
+			}
+			ops.push({
+				type: "remove_node",
+				path: listPath,
+				index: itemIndex
+			});
+			const leftLast = leftCount > 0 ? leftItem.content?.[leftCount - 1] : void 0;
+			const rightFirst = rightContent[0];
+			if (leftLast !== void 0 && rightFirst !== void 0 && isLeafTextBlock(leftLast) && isLeafTextBlock(rightFirst)) {
+				const joinAt = textLength(leftLast);
+				ops.push({
+					type: "merge_paragraph",
+					path: [...prevItemPath, leftCount]
+				}, {
+					type: "set_selection",
+					selection: collapsedAt([...prevItemPath, leftCount - 1], joinAt)
+				});
+			} else {
+				const selPath = resolveTextPath(state.doc, prevItemPath);
+				ops.push({
+					type: "set_selection",
+					selection: collapsedAt(selPath, textLength(getNodeAt(state.doc, selPath)))
+				});
+			}
+			return ops;
+		}
+		const parentPath = listPath.slice(0, -1);
+		const { ops, selectionPath, liftedIndex } = liftIntoParent(state.doc, listPath, itemIndex);
+		if (liftedIndex > 0) try {
+			const prev = getNodeAt(state.doc, [...parentPath, liftedIndex - 1]);
+			if (isTextBlock(prev.type)) {
+				const joinAt = textLength(prev);
+				return [
+					...ops,
+					{
+						type: "merge_paragraph",
+						path: [...parentPath, liftedIndex]
+					},
+					{
+						type: "set_selection",
+						selection: collapsedAt([...parentPath, liftedIndex - 1], joinAt)
+					}
+				];
+			}
+		} catch {}
+		return [...ops, {
+			type: "set_selection",
+			selection: collapsedAt(selectionPath, 0)
+		}];
+	}
+	if (path.length >= 4) {
+		const cellPath = path.slice(0, 3);
+		try {
+			if (getNodeAt(state.doc, cellPath).type === "tableCell" && (path.at(-1) ?? 0) === 0) return null;
+		} catch {}
+	}
+	if (path.length === 1) {
+		if (path[0] <= 0) return null;
+		return [{
+			type: "merge_paragraph",
+			path
+		}];
+	}
+	const index = path.at(-1);
+	if (index === void 0 || index <= 0) return null;
+	return [{
+		type: "merge_paragraph",
+		path
+	}];
+};
+/** Delete one character forward of the caret (range → delete selection, incl. cross-block). */
+var deleteForward = (state) => {
+	const crossOrSame = deleteSelectionRangeOps(state.doc, state.selection);
+	if (crossOrSame) {
+		const range = selectionTextRange(state.selection);
+		if (!range || range.from !== range.to) return crossOrSame;
+	}
+	const path = textPath(state);
+	const offset = state.selection.anchor.offset;
+	let node;
+	try {
+		node = getNodeAt(state.doc, path);
+	} catch {
+		return null;
+	}
+	if (offset < textLength(node)) return [{
+		type: "delete_text",
+		path,
+		offset,
+		length: 1
+	}];
+	return null;
+};
+var splitBlock = (state) => {
+	const path = textPath(state);
+	const offset = state.selection.anchor.offset;
+	let node;
+	try {
+		node = getNodeAt(state.doc, path);
+	} catch {
+		return null;
+	}
+	if (isListType(node.type) || node.type === "table" || node.type === "tableRow" || node.type === "tableCell") return null;
+	const parentPath = path.slice(0, -1);
+	let parentIsList = false;
+	if (path.length >= 2) try {
+		parentIsList = isListType(getNodeAt(state.doc, parentPath).type);
+	} catch {
+		parentIsList = false;
+	}
+	if (node.type === "listItem" || parentIsList && isTextBlock(node.type)) {
+		if (plainText(node).length === 0) {
+			const listPath = parentIsList ? parentPath : path.slice(0, -1);
+			const itemIndex = path.at(-1) ?? 0;
+			const { ops, selectionPath } = exitListItemOps(state.doc, listPath, itemIndex);
+			return [...ops, {
+				type: "set_selection",
+				selection: collapsedAt(selectionPath, 0)
+			}];
+		}
+		return [{
+			type: "split_paragraph",
+			path,
+			offset
+		}];
+	}
+	if (node.type === "heading" && offset >= plainText(node).length) {
+		const headingParentPath = path.slice(0, -1);
+		const index = (path.at(-1) ?? 0) + 1;
+		return [{
+			type: "insert_node",
+			path: headingParentPath,
+			index,
+			node: createParagraph([createText("")])
+		}, {
+			type: "set_selection",
+			selection: collapsedAt([...headingParentPath, index], 0)
+		}];
+	}
+	if (isTextBlock(node.type)) return [{
+		type: "split_paragraph",
+		path,
+		offset
+	}];
+	return null;
+};
+function toggleMark(markType) {
+	return (state) => {
+		const range = selectionTextRange(state.selection);
+		if (!range || range.from === range.to) return null;
+		if (rangeHasMark(getNodeAt(state.doc, range.path), range.from, range.to, markType)) return [{
+			type: "remove_mark",
+			path: range.path,
+			from: range.from,
+			to: range.to,
+			markType
+		}];
+		return [{
+			type: "set_mark",
+			path: range.path,
+			from: range.from,
+			to: range.to,
+			mark: { type: markType }
+		}];
+	};
+}
+/** Whether the current selection (or caret) carries `markType`. */
+function selectionHasMark(markType) {
+	return (state) => {
+		const range = selectionTextRange(state.selection);
+		if (!range) return false;
+		const para = getNodeAt(state.doc, range.path);
+		if (range.from === range.to) return offsetHasMark(para, range.from > 0 ? range.from - 1 : range.from, markType);
+		return rangeHasMark(para, range.from, range.to, markType);
+	};
+}
+var selectAll = (state) => {
+	const leaves = [];
+	collectTextLeaves(state.doc, [], leaves);
+	if (leaves.length === 0) return null;
+	const first = leaves[0];
+	const last = leaves.at(-1);
+	if (first === void 0 || last === void 0) return null;
+	const len = plainText(getNodeAt(state.doc, last)).length;
+	return [{
+		type: "set_selection",
+		selection: {
+			anchor: {
+				path: first,
+				offset: 0
+			},
+			focus: {
+				path: last,
+				offset: len
+			}
+		}
+	}];
+};
+function runCommand(state, command) {
+	const ops = command(state);
+	if (!ops) return null;
+	return transaction(...ops);
+}
+//#endregion
+export { JSON_DOC_VERSION, MAX_INSERT_CHARS, MAX_SLICE_KEEPS, MAX_TREE_DEPTH, applyOp, applyOps, applyTransaction, assertMark, assertMaxTreeDepth, assertNodeType, clampSelection, cloneNode, collapsedAt, comparePoints, copyAttrs, createDoc, createHistory, createList, createListItem, createParagraph, createSchema, createSelection, createState, createText, deepCloneNode, deleteBackward, deleteForward, deleteSelectionRangeOps, docFromJSON, docToJSON, emptyState, ensureNodeIds, exitListItemOps, getNodeAt, insertText, isCollapsed, isListType, isNormalizeIdempotent, isTextBlock, liftIntoParent, mergeMarksByType, nextId, normalize, offsetHasMark, orderedRange, plainText, rangeHasMark, rebaseOps, registerMark, registerNode, replaceAt, resetIdCounter, resolveTextPath, runCommand, sealSchema, selectAll, selectionHasMark, selectionTextRange, softDeleteBackward, splitBlock, textBlockLength, textLength, toggleMark, transaction, transformOp, transformOps };
+
+//# sourceMappingURL=index.mjs.map