foldkit-richtext-dom 0.1.0

package/dist/html.d.mts

@@ -0,0 +1,19 @@
+import * as RichText from "foldkit-richtext";
+//#region src/html.d.ts
+export interface HtmlDiagnostic {
+  readonly code: 'Dropped' | 'Unwrapped' | 'Undeclared';
+  readonly detail: string;
+}
+export interface ParsedHtml {
+  readonly blocks: ReadonlyArray<RichText.Block>;
+  readonly diagnostics: ReadonlyArray<HtmlDiagnostic>;
+}
+export interface ParseOptions {
+  /** When given, a node kind the Kit does not declare is degraded, not kept. */
+  readonly kit?: RichText.Kit | undefined;
+  readonly mint: () => string;
+}
+/** Parses HTML into semantic blocks, reporting everything it refused. */
+export declare const parseHtml: (html: string, options: ParseOptions) => ParsedHtml;
+//#endregion
+//# sourceMappingURL=html.d.mts.map

package/dist/html.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.mts","names":[],"sources":["../src/html.ts"],"mappings":";;iBAUiB;WACN;WACA;;iBAGM;WACN,QAAQ,cAAc,SAAS;WAC/B,aAAa,cAAc;;iBAGrB;;WAEN,MAAM,SAAS;WACf;;;qBAqSE,YAAa,cAAc,SAAS,iBAAe"}

package/dist/html.mjs

@@ -0,0 +1,234 @@
+import * as RichText from "foldkit-richtext";
+//#region src/html.ts
+/**
+* HTML import, constrained by a Kit (§70). The parser walks a `DOMParser` tree
+* with a whitelist: known block tags become blocks, known inline tags become
+* marks, our own `data-*` attributes round-trip, and everything else is either
+* unwrapped or dropped with a diagnostic. No attribute is ever interpreted, so
+* a pasted `style`, `href`, or `onclick` cannot survive as anything executable —
+* and `script`/`style`/`iframe` content is dropped along with its element.
+*/
+/** Elements whose content must never be imported, not even as text. */
+const DROPPED = /* @__PURE__ */ new Set([
+	"script",
+	"style",
+	"template",
+	"iframe",
+	"object",
+	"embed",
+	"noscript",
+	"svg",
+	"math",
+	"link",
+	"meta",
+	"title"
+]);
+const BLOCK_TAGS = /* @__PURE__ */ new Set([
+	"p",
+	"div",
+	"section",
+	"article",
+	"blockquote",
+	"ul",
+	"ol",
+	"li",
+	"pre",
+	"table",
+	"tr",
+	"td",
+	"th",
+	"figure",
+	"figcaption",
+	"main",
+	"header",
+	"footer",
+	"aside"
+]);
+const MARK_TAGS = {
+	strong: "Bold",
+	b: "Bold",
+	em: "Italic",
+	i: "Italic",
+	code: "Code"
+};
+const headingLevel = (tag) => {
+	const match = /^h([1-6])$/.exec(tag);
+	return match === null ? void 0 : Number(match[1]);
+};
+/** Whether a tag starts a block of its own rather than inline content. */
+const isBlockElement = (tag) => BLOCK_TAGS.has(tag) || headingLevel(tag) !== void 0 || DROPPED.has(tag);
+const mergePiece = (pieces, piece) => {
+	const last = pieces[pieces.length - 1];
+	if (last === void 0 || piece.text.length === 0) return [...pieces, piece];
+	return RichText.sameMarkSet(last.marks, piece.marks) ? [...pieces.slice(0, -1), {
+		text: last.text + piece.text,
+		marks: last.marks
+	}] : [...pieces, piece];
+};
+/** Appends one text node's content to the current line, merging equal marks. */
+const appendText = (lines, text, marks) => {
+	if (text.length === 0) return;
+	const current = lines[lines.length - 1] ?? [];
+	lines[lines.length - 1] = mergePiece(current, {
+		text,
+		marks
+	});
+};
+/**
+* Collects one node's inline content into lines, one line per `<br>`. Text is
+* taken literally; known inline tags add a mark, our own `data-marks` span adds
+* several, and every other element is transparent — its attributes are never
+* read, so nothing in the markup can become behaviour.
+*/
+const collectNode = (node, marks, lines, diagnostics) => {
+	if (node.nodeType === 3) {
+		appendText(lines, node.textContent ?? "", marks);
+		return;
+	}
+	if (node.nodeType !== 1) return;
+	const element = node;
+	const tag = element.tagName.toLowerCase();
+	if (DROPPED.has(tag)) {
+		diagnostics.push({
+			code: "Dropped",
+			detail: tag
+		});
+		return;
+	}
+	if (tag === "br") {
+		lines.push([]);
+		return;
+	}
+	const mark = MARK_TAGS[tag];
+	const declared = element.getAttribute("data-marks");
+	const added = mark !== void 0 ? [mark] : tag === "span" && declared !== null && declared.trim().length > 0 ? declared.trim().split(/\s+/) : [];
+	if (added.length === 0 && (BLOCK_TAGS.has(tag) || headingLevel(tag) !== void 0)) diagnostics.push({
+		code: "Unwrapped",
+		detail: tag
+	});
+	for (const child of Array.from(element.childNodes)) collectNode(child, [...marks, ...added], lines, diagnostics);
+};
+const collectLines = (element, marks, lines, diagnostics) => {
+	for (const child of Array.from(element.childNodes)) collectNode(child, marks, lines, diagnostics);
+};
+const runsFrom = (pieces, mint) => pieces.filter((piece) => piece.text.length > 0).map((piece) => ({
+	type: "Text",
+	id: RichText.NodeId.make(mint()),
+	text: piece.text,
+	marks: [...new Set(piece.marks)]
+}));
+const paragraphBlocks = (lines, mint) => lines.map((line) => ({
+	type: "Paragraph",
+	id: RichText.NodeId.make(mint()),
+	children: runsFrom(line, mint)
+}));
+const headingBlock = (level, lines, mint, diagnostics, kit) => {
+	const [first, ...rest] = lines;
+	if (kit !== void 0 && !kit.nodes.some((node) => node.name === "Heading")) {
+		diagnostics.push({
+			code: "Undeclared",
+			detail: "Heading"
+		});
+		return paragraphBlocks(lines, mint);
+	}
+	return [{
+		type: "Heading",
+		id: RichText.NodeId.make(mint()),
+		level: Math.min(Math.max(level, 1), 6),
+		children: runsFrom(first ?? [], mint)
+	}, ...paragraphBlocks(rest, mint)];
+};
+/** Blocks of one element's children: inline runs group into paragraphs, block children recurse. */
+const childBlocks = (element, mint, diagnostics, kit) => {
+	const blocks = [];
+	let lines = [[]];
+	const flush = () => {
+		if (lines.some((line) => line.length > 0)) blocks.push(...paragraphBlocks(lines, mint));
+		lines = [[]];
+	};
+	for (const child of Array.from(element.childNodes)) {
+		if (child.nodeType === 1) {
+			const childElement = child;
+			const childTag = childElement.tagName.toLowerCase();
+			const level = headingLevel(childTag);
+			if (isBlockElement(childTag)) {
+				flush();
+				if (DROPPED.has(childTag)) {
+					diagnostics.push({
+						code: "Dropped",
+						detail: childTag
+					});
+					continue;
+				}
+				blocks.push(...level === void 0 ? blocksFrom(childElement, mint, diagnostics, kit) : headingBlock(level, linesOf(childElement, diagnostics), mint, diagnostics, kit));
+				continue;
+			}
+		}
+		collectNode(child, [], lines, diagnostics);
+	}
+	flush();
+	return blocks;
+};
+/**
+* A node block for a kind, holding runs or nested blocks as its declaration says
+* (and as its content implies when no declaration settles it). Props are not
+* carried by HTML, so the value starts empty.
+*/
+const nodeBlockFrom = (element, kind, declared, mint, diagnostics, kit) => {
+	return declared?.kind === "node" && declared.children === RichText.blockContent || Array.from(element.children).some((child) => isBlockElement(child.tagName.toLowerCase())) ? {
+		type: "Node",
+		kind,
+		id: RichText.NodeId.make(mint()),
+		props: {},
+		children: [],
+		blocks: childBlocks(element, mint, diagnostics, kit)
+	} : {
+		type: "Node",
+		kind,
+		id: RichText.NodeId.make(mint()),
+		props: {},
+		children: runsFrom(linesOf(element, diagnostics).flat(), mint)
+	};
+};
+/** The kind a list element becomes, so pasted lists stay semantic. */
+const listKindOf = (tag) => tag === "ul" || tag === "ol" ? "List" : tag === "li" ? "ListItem" : void 0;
+/** Blocks of one element, including our own preserved, application-node, and list elements. */
+const blocksFrom = (element, mint, diagnostics, kit) => {
+	const tag = element.tagName.toLowerCase();
+	const preserved = element.getAttribute("data-unknown");
+	if (tag === "div" && preserved !== null && preserved.trim().length > 0) return [{
+		type: "Unknown",
+		id: RichText.NodeId.make(mint()),
+		originalType: preserved.trim(),
+		props: {},
+		children: []
+	}];
+	const kind = element.getAttribute("data-node")?.trim() ?? listKindOf(tag);
+	if (kind !== void 0 && kind.length > 0) {
+		const declaredNode = kit?.nodes.find((candidate) => candidate.name === kind);
+		if (kit === void 0 || declaredNode !== void 0) return [nodeBlockFrom(element, kind, declaredNode, mint, diagnostics, kit)];
+		diagnostics.push({
+			code: "Undeclared",
+			detail: kind
+		});
+	}
+	return childBlocks(element, mint, diagnostics, kit);
+};
+const linesOf = (element, diagnostics) => {
+	const lines = [[]];
+	collectLines(element, [], lines, diagnostics);
+	return lines;
+};
+/** Parses HTML into semantic blocks, reporting everything it refused. */
+const parseHtml = (html, options) => {
+	const owner = new DOMParser().parseFromString(html, "text/html");
+	const diagnostics = [];
+	return {
+		blocks: blocksFrom(owner.body, options.mint, diagnostics, options.kit),
+		diagnostics
+	};
+};
+//#endregion
+export { parseHtml };
+
+//# sourceMappingURL=html.mjs.map

package/dist/html.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.mjs","names":[],"sources":["../src/html.ts"],"sourcesContent":["/**\n * HTML import, constrained by a Kit (§70). The parser walks a `DOMParser` tree\n * with a whitelist: known block tags become blocks, known inline tags become\n * marks, our own `data-*` attributes round-trip, and everything else is either\n * unwrapped or dropped with a diagnostic. No attribute is ever interpreted, so\n * a pasted `style`, `href`, or `onclick` cannot survive as anything executable —\n * and `script`/`style`/`iframe` content is dropped along with its element.\n */\nimport * as RichText from 'foldkit-richtext'\n\nexport interface HtmlDiagnostic {\n  readonly code: 'Dropped' | 'Unwrapped' | 'Undeclared'\n  readonly detail: string\n}\n\nexport interface ParsedHtml {\n  readonly blocks: ReadonlyArray<RichText.Block>\n  readonly diagnostics: ReadonlyArray<HtmlDiagnostic>\n}\n\nexport interface ParseOptions {\n  /** When given, a node kind the Kit does not declare is degraded, not kept. */\n  readonly kit?: RichText.Kit | undefined\n  readonly mint: () => string\n}\n\n/** Elements whose content must never be imported, not even as text. */\nconst DROPPED = new Set([\n  'script',\n  'style',\n  'template',\n  'iframe',\n  'object',\n  'embed',\n  'noscript',\n  'svg',\n  'math',\n  'link',\n  'meta',\n  'title',\n])\n\nconst BLOCK_TAGS = new Set([\n  'p',\n  'div',\n  'section',\n  'article',\n  'blockquote',\n  'ul',\n  'ol',\n  'li',\n  'pre',\n  'table',\n  'tr',\n  'td',\n  'th',\n  'figure',\n  'figcaption',\n  'main',\n  'header',\n  'footer',\n  'aside',\n])\n\nconst MARK_TAGS: Readonly<Record<string, string>> = {\n  strong: 'Bold',\n  b: 'Bold',\n  em: 'Italic',\n  i: 'Italic',\n  code: 'Code',\n}\n\nconst headingLevel = (tag: string): number | undefined => {\n  const match = /^h([1-6])$/.exec(tag)\n  return match === null ? undefined : Number(match[1])\n}\n\n/** Whether a tag starts a block of its own rather than inline content. */\nconst isBlockElement = (tag: string): boolean =>\n  BLOCK_TAGS.has(tag) || headingLevel(tag) !== undefined || DROPPED.has(tag)\n\ninterface Piece {\n  readonly text: string\n  readonly marks: ReadonlyArray<string>\n}\n\ntype Lines = ReadonlyArray<ReadonlyArray<Piece>>\n\nconst mergePiece = (pieces: ReadonlyArray<Piece>, piece: Piece): ReadonlyArray<Piece> => {\n  const last = pieces[pieces.length - 1]\n  if (last === undefined || piece.text.length === 0) return [...pieces, piece]\n  return RichText.sameMarkSet(last.marks, piece.marks)\n    ? [...pieces.slice(0, -1), { text: last.text + piece.text, marks: last.marks }]\n    : [...pieces, piece]\n}\n\n/** Appends one text node's content to the current line, merging equal marks. */\nconst appendText = (\n  lines: Array<ReadonlyArray<Piece>>,\n  text: string,\n  marks: ReadonlyArray<string>,\n): void => {\n  if (text.length === 0) return\n  const current = lines[lines.length - 1] ?? []\n  lines[lines.length - 1] = mergePiece(current, { text, marks })\n}\n\n/**\n * Collects one node's inline content into lines, one line per `<br>`. Text is\n * taken literally; known inline tags add a mark, our own `data-marks` span adds\n * several, and every other element is transparent — its attributes are never\n * read, so nothing in the markup can become behaviour.\n */\nconst collectNode = (\n  node: Node,\n  marks: ReadonlyArray<string>,\n  lines: Array<ReadonlyArray<Piece>>,\n  diagnostics: Array<HtmlDiagnostic>,\n): void => {\n  if (node.nodeType === 3) {\n    appendText(lines, node.textContent ?? '', marks)\n    return\n  }\n  if (node.nodeType !== 1) return\n  const element = node as Element\n  const tag = element.tagName.toLowerCase()\n  if (DROPPED.has(tag)) {\n    diagnostics.push({ code: 'Dropped', detail: tag })\n    return\n  }\n  if (tag === 'br') {\n    lines.push([])\n    return\n  }\n  const mark = MARK_TAGS[tag]\n  const declared = element.getAttribute('data-marks')\n  const added =\n    mark !== undefined\n      ? [mark]\n      : tag === 'span' && declared !== null && declared.trim().length > 0\n        ? declared.trim().split(/\\s+/)\n        : []\n  if (added.length === 0 && (BLOCK_TAGS.has(tag) || headingLevel(tag) !== undefined)) {\n    diagnostics.push({ code: 'Unwrapped', detail: tag })\n  }\n  for (const child of Array.from(element.childNodes)) {\n    collectNode(child, [...marks, ...added], lines, diagnostics)\n  }\n}\n\nconst collectLines = (\n  element: Element,\n  marks: ReadonlyArray<string>,\n  lines: Array<ReadonlyArray<Piece>>,\n  diagnostics: Array<HtmlDiagnostic>,\n): void => {\n  for (const child of Array.from(element.childNodes)) collectNode(child, marks, lines, diagnostics)\n}\n\nconst runsFrom = (pieces: ReadonlyArray<Piece>, mint: () => string): ReadonlyArray<RichText.Text> =>\n  pieces\n    .filter(piece => piece.text.length > 0)\n    .map(piece => ({\n      type: 'Text' as const,\n      id: RichText.NodeId.make(mint()),\n      text: piece.text,\n      marks: [...new Set(piece.marks)],\n    }))\n\nconst paragraphBlocks = (lines: Lines, mint: () => string): ReadonlyArray<RichText.Block> =>\n  lines.map(line => ({\n    type: 'Paragraph' as const,\n    id: RichText.NodeId.make(mint()),\n    children: runsFrom(line, mint),\n  }))\n\nconst headingBlock = (\n  level: number,\n  lines: Lines,\n  mint: () => string,\n  diagnostics: Array<HtmlDiagnostic>,\n  kit: RichText.Kit | undefined,\n): ReadonlyArray<RichText.Block> => {\n  const [first, ...rest] = lines\n  if (kit !== undefined && !kit.nodes.some(node => node.name === 'Heading')) {\n    diagnostics.push({ code: 'Undeclared', detail: 'Heading' })\n    return paragraphBlocks(lines, mint)\n  }\n  return [\n    {\n      type: 'Heading' as const,\n      id: RichText.NodeId.make(mint()),\n      level: Math.min(Math.max(level, 1), 6) as 1 | 2 | 3 | 4 | 5 | 6,\n      children: runsFrom(first ?? [], mint),\n    },\n    ...paragraphBlocks(rest, mint),\n  ]\n}\n\n/** Blocks of one element's children: inline runs group into paragraphs, block children recurse. */\nconst childBlocks = (\n  element: Element,\n  mint: () => string,\n  diagnostics: Array<HtmlDiagnostic>,\n  kit: RichText.Kit | undefined,\n): ReadonlyArray<RichText.Block> => {\n  const blocks: Array<RichText.Block> = []\n  let lines: Array<ReadonlyArray<Piece>> = [[]]\n  const flush = (): void => {\n    if (lines.some(line => line.length > 0)) blocks.push(...paragraphBlocks(lines, mint))\n    lines = [[]]\n  }\n  for (const child of Array.from(element.childNodes)) {\n    if (child.nodeType === 1) {\n      const childElement = child as Element\n      const childTag = childElement.tagName.toLowerCase()\n      const level = headingLevel(childTag)\n      const isBlock = isBlockElement(childTag)\n      if (isBlock) {\n        flush()\n        if (DROPPED.has(childTag)) {\n          diagnostics.push({ code: 'Dropped', detail: childTag })\n          continue\n        }\n        blocks.push(\n          ...(level === undefined\n            ? blocksFrom(childElement, mint, diagnostics, kit)\n            : headingBlock(level, linesOf(childElement, diagnostics), mint, diagnostics, kit)),\n        )\n        continue\n      }\n    }\n    collectNode(child, [], lines, diagnostics)\n  }\n  flush()\n  return blocks\n}\n\n/**\n * A node block for a kind, holding runs or nested blocks as its declaration says\n * (and as its content implies when no declaration settles it). Props are not\n * carried by HTML, so the value starts empty.\n */\nconst nodeBlockFrom = (\n  element: Element,\n  kind: string,\n  declared: RichText.NodeDefinition | undefined,\n  mint: () => string,\n  diagnostics: Array<HtmlDiagnostic>,\n  kit: RichText.Kit | undefined,\n): RichText.Block => {\n  const holdsBlocks =\n    (declared?.kind === 'node' && declared.children === RichText.blockContent) ||\n    Array.from(element.children).some(child => isBlockElement(child.tagName.toLowerCase()))\n  return holdsBlocks\n    ? {\n        type: 'Node',\n        kind,\n        id: RichText.NodeId.make(mint()),\n        props: {},\n        children: [],\n        blocks: childBlocks(element, mint, diagnostics, kit),\n      }\n    : {\n        type: 'Node',\n        kind,\n        id: RichText.NodeId.make(mint()),\n        props: {},\n        children: runsFrom(linesOf(element, diagnostics).flat(), mint),\n      }\n}\n\n/** The kind a list element becomes, so pasted lists stay semantic. */\nconst listKindOf = (tag: string): string | undefined =>\n  tag === 'ul' || tag === 'ol' ? 'List' : tag === 'li' ? 'ListItem' : undefined\n\n/** Blocks of one element, including our own preserved, application-node, and list elements. */\nconst blocksFrom = (\n  element: Element,\n  mint: () => string,\n  diagnostics: Array<HtmlDiagnostic>,\n  kit: RichText.Kit | undefined,\n): ReadonlyArray<RichText.Block> => {\n  const tag = element.tagName.toLowerCase()\n  const preserved = element.getAttribute('data-unknown')\n  if (tag === 'div' && preserved !== null && preserved.trim().length > 0) {\n    // Our own preserved-node placeholder: the payload stays opaque.\n    return [\n      {\n        type: 'Unknown' as const,\n        id: RichText.NodeId.make(mint()),\n        originalType: preserved.trim(),\n        props: {},\n        children: [],\n      },\n    ]\n  }\n  const kind = element.getAttribute('data-node')?.trim() ?? listKindOf(tag)\n  if (kind !== undefined && kind.length > 0) {\n    const declaredNode = kit?.nodes.find(candidate => candidate.name === kind)\n    if (kit === undefined || declaredNode !== undefined) {\n      return [nodeBlockFrom(element, kind, declaredNode, mint, diagnostics, kit)]\n    }\n    diagnostics.push({ code: 'Undeclared', detail: kind })\n    // Degrade to its content rather than keeping a kind the Kit refuses.\n  }\n  return childBlocks(element, mint, diagnostics, kit)\n}\n\nconst linesOf = (element: Element, diagnostics: Array<HtmlDiagnostic>): Lines => {\n  const lines: Array<ReadonlyArray<Piece>> = [[]]\n  collectLines(element, [], lines, diagnostics)\n  return lines\n}\n\n/** Parses HTML into semantic blocks, reporting everything it refused. */\nexport const parseHtml = (html: string, options: ParseOptions): ParsedHtml => {\n  const owner = new DOMParser().parseFromString(html, 'text/html')\n  const diagnostics: Array<HtmlDiagnostic> = []\n  const blocks = blocksFrom(owner.body, options.mint, diagnostics, options.kit)\n  return { blocks, diagnostics }\n}\n"],"mappings":";;;;;;;;;;;AA2BA,MAAM,0BAAU,IAAI,IAAI;CACtB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAED,MAAM,6BAAa,IAAI,IAAI;CACzB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAED,MAAM,YAA8C;CAClD,QAAQ;CACR,GAAG;CACH,IAAI;CACJ,GAAG;CACH,MAAM;AACR;AAEA,MAAM,gBAAgB,QAAoC;CACxD,MAAM,QAAQ,aAAa,KAAK,GAAG;CACnC,OAAO,UAAU,OAAO,KAAA,IAAY,OAAO,MAAM,EAAE;AACrD;;AAGA,MAAM,kBAAkB,QACtB,WAAW,IAAI,GAAG,KAAK,aAAa,GAAG,MAAM,KAAA,KAAa,QAAQ,IAAI,GAAG;AAS3E,MAAM,cAAc,QAA8B,UAAuC;CACvF,MAAM,OAAO,OAAO,OAAO,SAAS;CACpC,IAAI,SAAS,KAAA,KAAa,MAAM,KAAK,WAAW,GAAG,OAAO,CAAC,GAAG,QAAQ,KAAK;CAC3E,OAAO,SAAS,YAAY,KAAK,OAAO,MAAM,KAAK,IAC/C,CAAC,GAAG,OAAO,MAAM,GAAG,EAAE,GAAG;EAAE,MAAM,KAAK,OAAO,MAAM;EAAM,OAAO,KAAK;CAAM,CAAC,IAC5E,CAAC,GAAG,QAAQ,KAAK;AACvB;;AAGA,MAAM,cACJ,OACA,MACA,UACS;CACT,IAAI,KAAK,WAAW,GAAG;CACvB,MAAM,UAAU,MAAM,MAAM,SAAS,MAAM,CAAC;CAC5C,MAAM,MAAM,SAAS,KAAK,WAAW,SAAS;EAAE;EAAM;CAAM,CAAC;AAC/D;;;;;;;AAQA,MAAM,eACJ,MACA,OACA,OACA,gBACS;CACT,IAAI,KAAK,aAAa,GAAG;EACvB,WAAW,OAAO,KAAK,eAAe,IAAI,KAAK;EAC/C;CACF;CACA,IAAI,KAAK,aAAa,GAAG;CACzB,MAAM,UAAU;CAChB,MAAM,MAAM,QAAQ,QAAQ,YAAY;CACxC,IAAI,QAAQ,IAAI,GAAG,GAAG;EACpB,YAAY,KAAK;GAAE,MAAM;GAAW,QAAQ;EAAI,CAAC;EACjD;CACF;CACA,IAAI,QAAQ,MAAM;EAChB,MAAM,KAAK,CAAC,CAAC;EACb;CACF;CACA,MAAM,OAAO,UAAU;CACvB,MAAM,WAAW,QAAQ,aAAa,YAAY;CAClD,MAAM,QACJ,SAAS,KAAA,IACL,CAAC,IAAI,IACL,QAAQ,UAAU,aAAa,QAAQ,SAAS,KAAK,CAAC,CAAC,SAAS,IAC9D,SAAS,KAAK,CAAC,CAAC,MAAM,KAAK,IAC3B,CAAC;CACT,IAAI,MAAM,WAAW,MAAM,WAAW,IAAI,GAAG,KAAK,aAAa,GAAG,MAAM,KAAA,IACtE,YAAY,KAAK;EAAE,MAAM;EAAa,QAAQ;CAAI,CAAC;CAErD,KAAK,MAAM,SAAS,MAAM,KAAK,QAAQ,UAAU,GAC/C,YAAY,OAAO,CAAC,GAAG,OAAO,GAAG,KAAK,GAAG,OAAO,WAAW;AAE/D;AAEA,MAAM,gBACJ,SACA,OACA,OACA,gBACS;CACT,KAAK,MAAM,SAAS,MAAM,KAAK,QAAQ,UAAU,GAAG,YAAY,OAAO,OAAO,OAAO,WAAW;AAClG;AAEA,MAAM,YAAY,QAA8B,SAC9C,OACG,QAAO,UAAS,MAAM,KAAK,SAAS,CAAC,CAAC,CACtC,KAAI,WAAU;CACb,MAAM;CACN,IAAI,SAAS,OAAO,KAAK,KAAK,CAAC;CAC/B,MAAM,MAAM;CACZ,OAAO,CAAC,GAAG,IAAI,IAAI,MAAM,KAAK,CAAC;AACjC,EAAE;AAEN,MAAM,mBAAmB,OAAc,SACrC,MAAM,KAAI,UAAS;CACjB,MAAM;CACN,IAAI,SAAS,OAAO,KAAK,KAAK,CAAC;CAC/B,UAAU,SAAS,MAAM,IAAI;AAC/B,EAAE;AAEJ,MAAM,gBACJ,OACA,OACA,MACA,aACA,QACkC;CAClC,MAAM,CAAC,OAAO,GAAG,QAAQ;CACzB,IAAI,QAAQ,KAAA,KAAa,CAAC,IAAI,MAAM,MAAK,SAAQ,KAAK,SAAS,SAAS,GAAG;EACzE,YAAY,KAAK;GAAE,MAAM;GAAc,QAAQ;EAAU,CAAC;EAC1D,OAAO,gBAAgB,OAAO,IAAI;CACpC;CACA,OAAO,CACL;EACE,MAAM;EACN,IAAI,SAAS,OAAO,KAAK,KAAK,CAAC;EAC/B,OAAO,KAAK,IAAI,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC;EACrC,UAAU,SAAS,SAAS,CAAC,GAAG,IAAI;CACtC,GACA,GAAG,gBAAgB,MAAM,IAAI,CAC/B;AACF;;AAGA,MAAM,eACJ,SACA,MACA,aACA,QACkC;CAClC,MAAM,SAAgC,CAAC;CACvC,IAAI,QAAqC,CAAC,CAAC,CAAC;CAC5C,MAAM,cAAoB;EACxB,IAAI,MAAM,MAAK,SAAQ,KAAK,SAAS,CAAC,GAAG,OAAO,KAAK,GAAG,gBAAgB,OAAO,IAAI,CAAC;EACpF,QAAQ,CAAC,CAAC,CAAC;CACb;CACA,KAAK,MAAM,SAAS,MAAM,KAAK,QAAQ,UAAU,GAAG;EAClD,IAAI,MAAM,aAAa,GAAG;GACxB,MAAM,eAAe;GACrB,MAAM,WAAW,aAAa,QAAQ,YAAY;GAClD,MAAM,QAAQ,aAAa,QAAQ;GAEnC,IADgB,eAAe,QACrB,GAAG;IACX,MAAM;IACN,IAAI,QAAQ,IAAI,QAAQ,GAAG;KACzB,YAAY,KAAK;MAAE,MAAM;MAAW,QAAQ;KAAS,CAAC;KACtD;IACF;IACA,OAAO,KACL,GAAI,UAAU,KAAA,IACV,WAAW,cAAc,MAAM,aAAa,GAAG,IAC/C,aAAa,OAAO,QAAQ,cAAc,WAAW,GAAG,MAAM,aAAa,GAAG,CACpF;IACA;GACF;EACF;EACA,YAAY,OAAO,CAAC,GAAG,OAAO,WAAW;CAC3C;CACA,MAAM;CACN,OAAO;AACT;;;;;;AAOA,MAAM,iBACJ,SACA,MACA,UACA,MACA,aACA,QACmB;CAInB,OAFG,UAAU,SAAS,UAAU,SAAS,aAAa,SAAS,gBAC7D,MAAM,KAAK,QAAQ,QAAQ,CAAC,CAAC,MAAK,UAAS,eAAe,MAAM,QAAQ,YAAY,CAAC,CAAC,IAEpF;EACE,MAAM;EACN;EACA,IAAI,SAAS,OAAO,KAAK,KAAK,CAAC;EAC/B,OAAO,CAAC;EACR,UAAU,CAAC;EACX,QAAQ,YAAY,SAAS,MAAM,aAAa,GAAG;CACrD,IACA;EACE,MAAM;EACN;EACA,IAAI,SAAS,OAAO,KAAK,KAAK,CAAC;EAC/B,OAAO,CAAC;EACR,UAAU,SAAS,QAAQ,SAAS,WAAW,CAAC,CAAC,KAAK,GAAG,IAAI;CAC/D;AACN;;AAGA,MAAM,cAAc,QAClB,QAAQ,QAAQ,QAAQ,OAAO,SAAS,QAAQ,OAAO,aAAa,KAAA;;AAGtE,MAAM,cACJ,SACA,MACA,aACA,QACkC;CAClC,MAAM,MAAM,QAAQ,QAAQ,YAAY;CACxC,MAAM,YAAY,QAAQ,aAAa,cAAc;CACrD,IAAI,QAAQ,SAAS,cAAc,QAAQ,UAAU,KAAK,CAAC,CAAC,SAAS,GAEnE,OAAO,CACL;EACE,MAAM;EACN,IAAI,SAAS,OAAO,KAAK,KAAK,CAAC;EAC/B,cAAc,UAAU,KAAK;EAC7B,OAAO,CAAC;EACR,UAAU,CAAC;CACb,CACF;CAEF,MAAM,OAAO,QAAQ,aAAa,WAAW,CAAC,EAAE,KAAK,KAAK,WAAW,GAAG;CACxE,IAAI,SAAS,KAAA,KAAa,KAAK,SAAS,GAAG;EACzC,MAAM,eAAe,KAAK,MAAM,MAAK,cAAa,UAAU,SAAS,IAAI;EACzE,IAAI,QAAQ,KAAA,KAAa,iBAAiB,KAAA,GACxC,OAAO,CAAC,cAAc,SAAS,MAAM,cAAc,MAAM,aAAa,GAAG,CAAC;EAE5E,YAAY,KAAK;GAAE,MAAM;GAAc,QAAQ;EAAK,CAAC;CAEvD;CACA,OAAO,YAAY,SAAS,MAAM,aAAa,GAAG;AACpD;AAEA,MAAM,WAAW,SAAkB,gBAA8C;CAC/E,MAAM,QAAqC,CAAC,CAAC,CAAC;CAC9C,aAAa,SAAS,CAAC,GAAG,OAAO,WAAW;CAC5C,OAAO;AACT;;AAGA,MAAa,aAAa,MAAc,YAAsC;CAC5E,MAAM,QAAQ,IAAI,UAAU,CAAC,CAAC,gBAAgB,MAAM,WAAW;CAC/D,MAAM,cAAqC,CAAC;CAE5C,OAAO;EAAE,QADM,WAAW,MAAM,MAAM,QAAQ,MAAM,aAAa,QAAQ,GAC3D;EAAG;CAAY;AAC/B"}

package/dist/index-6QEOehXh.d.mts

@@ -0,0 +1,38 @@
+import * as RichText from "foldkit-richtext";
+//#region src/index.d.ts
+interface EditorDom {
+  /** The owned subtree root. Everything inside belongs to this interpreter. */
+  readonly root: HTMLElement;
+  /** Current element per block and run identity. */
+  readonly elements: ReadonlyMap<RichText.NodeId, HTMLElement>;
+  /** The semantic document this subtree currently represents. */
+  readonly content: RichText.Document;
+  /** The registry this subtree was rendered with, and is patched with again. */
+  readonly rendering: RichText.Rendering;
+}
+/** Builds the owned subtree and the identity index it is patched through. */
+declare const mount: (owner: Document, content: RichText.Document, rendering?: RichText.Rendering) => EditorDom;
+declare const patch: (dom: EditorDom, content: RichText.Document, changeSet: RichText.ChangeSet) => EditorDom;
+/** The DOM range for a semantic position, or undefined if it no longer resolves. */
+declare const positionToRange: (dom: EditorDom, position: RichText.Position) => Range | undefined;
+/**
+ * Maps a browser selection endpoint back to a semantic position. Only text-node
+ * containers inside a run are supported; anything else (an element offset, a
+ * range outside the owned subtree) has no semantic position and returns
+ * undefined rather than guessing.
+ */
+declare const rangeToPosition: (dom: EditorDom, node: Node, offset: number) => RichText.Position | undefined;
+/** Plain text of the subtree, one line per text block: for assertions and fallback copy. */
+declare const toText: (dom: EditorDom) => string;
+/**
+ * Recovery, not domain state (§31): makes the subtree match the document again
+ * after something outside the semantic pipeline touched it — a cancelled IME
+ * composition leaves text the document never had, and a browser extension can
+ * mutate anything. Blocks whose rendered text already matches are left alone,
+ * so this costs nothing in the normal case and returns the same `EditorDom`
+ * when nothing was wrong.
+ */
+declare const repair: (dom: EditorDom, content: RichText.Document) => EditorDom;
+//#endregion
+export { rangeToPosition as a, positionToRange as i, mount as n, repair as o, patch as r, toText as s, EditorDom as t };
+//# sourceMappingURL=index-6QEOehXh.d.mts.map

package/dist/index-6QEOehXh.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-6QEOehXh.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;UASiB;;WAEN,MAAM;;WAEN,UAAU,YAAY,SAAS,QAAQ;;WAEvC,SAAS,SAAS;;WAElB,WAAW,SAAS;;;cAuFlB,QACX,OAAO,UACP,SAAS,SAAS,UAClB,YAAW,SAAS,cACnB;cAsBU,QACX,KAAK,WACL,SAAS,SAAS,UAClB,WAAW,SAAS,cACnB;;cAoGU,kBAAmB,KAAK,WAAW,UAAU,SAAS,aAAW;;;;;;;cA8BjE,kBACX,KAAK,WACL,MAAM,MACN,mBACC,SAAS;;cAUC,SAAU,KAAK;;;;;;;;;cAuEf,SAAU,KAAK,WAAW,SAAS,SAAS,aAAW"}

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { a as rangeToPosition, i as positionToRange, n as mount, o as repair, r as patch, s as toText, t as EditorDom } from "./index-6QEOehXh.mjs";
+export { EditorDom, mount, patch, positionToRange, rangeToPosition, repair, toText };

package/dist/index.mjs

@@ -0,0 +1,304 @@
+import * as RichText from "foldkit-richtext";
+//#region src/index.ts
+/**
+* The DOM interpreter for an editable subtree: it renders a semantic Document
+* into an owned subtree, maps positions both ways, and patches only the nodes a
+* ChangeSet names. No Foldkit VDOM reaches inside this subtree, and the semantic
+* document stays authoritative — the DOM is never read as truth beyond mapping a
+* browser selection back to a semantic position.
+*/
+const MARK_ATTRIBUTE = "data-marks";
+/** The element a block's own type implies; a declared node kind is elsewhere. */
+const blockTag = (block) => {
+	if (block.type === "Heading") return `h${block.level}`;
+	if (block.type === "Unknown" || block.type === "Node") return "div";
+	return "p";
+};
+/** The element a renderer entry names, with its attributes; children come later. */
+const renderElement = (owner, entry) => {
+	const element = owner.createElement(entry.tag);
+	for (const [name, value] of Object.entries(entry.attributes)) element.setAttribute(name, value);
+	return element;
+};
+/**
+* A run is one element carrying `data-run`, whatever the renderer wraps its text
+* in. Nesting the mark elements *inside* that element is what keeps a browser
+* selection mappable: `rangeToPosition` finds the run through `closest`, and the
+* text node stays deepest, so an offset is still an offset into the run's text.
+*/
+const renderRun = (owner, run, rendering) => {
+	const element = owner.createElement("span");
+	element.setAttribute("data-run", run.id);
+	const { nest, unrendered } = RichText.runRendering(rendering, run);
+	let content = owner.createTextNode(run.text);
+	for (const entry of nest) {
+		const wrapper = renderElement(owner, entry);
+		wrapper.append(content);
+		content = wrapper;
+	}
+	element.append(content);
+	if (unrendered.length > 0) element.setAttribute(MARK_ATTRIBUTE, unrendered.join(" "));
+	return element;
+};
+const renderBlock = (owner, block, elements, rendering) => {
+	const entry = block.type === "Node" ? RichText.nodeRendering(rendering, block) : void 0;
+	const element = entry === void 0 ? owner.createElement(blockTag(block)) : renderElement(owner, entry);
+	element.setAttribute("data-block", block.id);
+	if (block.type === "Unknown") {
+		element.setAttribute("data-unknown", block.originalType);
+		element.setAttribute("contenteditable", "false");
+		element.textContent = `[${block.originalType}]`;
+		elements.set(block.id, element);
+		return element;
+	}
+	for (const run of block.children) {
+		const runElement = renderRun(owner, run, rendering);
+		element.append(runElement);
+		elements.set(run.id, runElement);
+	}
+	if (block.type === "Node" && block.blocks !== void 0) for (const nested of block.blocks) element.append(renderBlock(owner, nested, elements, rendering));
+	elements.set(block.id, element);
+	return element;
+};
+/** Builds the owned subtree and the identity index it is patched through. */
+const mount = (owner, content, rendering = RichText.noRendering) => {
+	const root = owner.createElement("div");
+	root.setAttribute("contenteditable", "true");
+	const elements = /* @__PURE__ */ new Map();
+	for (const block of content.children) root.append(renderBlock(owner, block, elements, rendering));
+	return {
+		root,
+		elements,
+		content,
+		rendering
+	};
+};
+/**
+* Applies a ChangeSet: removed identities lose their elements, dirty identities
+* are re-rendered in place (or inserted, when they are new), and every
+* untouched element keeps its object identity, so the browser is not handed a
+* rebuilt tree on each keystroke.
+*/
+const childIds = (element, attribute) => Array.from(element.children).map((child) => child.getAttribute(attribute)).filter((id) => id !== null);
+const sameIds = (present, wanted) => present.length === wanted.length && present.every((id, at) => id === wanted[at]);
+const patch = (dom, content, changeSet) => {
+	const elements = new Map(dom.elements);
+	const root = dom.root;
+	for (const id of changeSet.removedNodes) {
+		const element = elements.get(id);
+		if (element === void 0) continue;
+		element.remove();
+		elements.delete(id);
+	}
+	const rebuilt = /* @__PURE__ */ new Set();
+	patchBlocks(root.ownerDocument, root, content.children, elements, dom.rendering, rebuilt);
+	for (const id of changeSet.dirtyNodes) {
+		const located = RichText.locateRun(content, id);
+		if (located === void 0) continue;
+		const block = RichText.blockAtPath(content, located.path);
+		if (block === void 0 || rebuilt.has(block.id)) continue;
+		const parent = elements.get(block.id);
+		if (parent === void 0) continue;
+		const fresh = renderRun(root.ownerDocument, located.run, dom.rendering);
+		elements.get(id)?.remove();
+		elements.set(id, fresh);
+		const next = block.children[located.index + 1];
+		const nextElement = next === void 0 ? void 0 : elements.get(next.id);
+		if (nextElement !== void 0) nextElement.before(fresh);
+		else parent.append(fresh);
+	}
+	return {
+		root,
+		elements,
+		content,
+		rendering: dom.rendering
+	};
+};
+/**
+* Patches one block list into its container. A block is rebuilt only when its
+* run list and its nested blocks are unchanged in shape, or it is new;
+* otherwise its element stays, which keeps every sibling's identity — and a
+* block that merely moved is moved, not re-rendered. A kept container needs no
+* recursion: its nested identities are unchanged, so any change inside them is a
+* run-level change the caller patches directly. Nested structural patching
+* arrives with the operations that can produce it (§116 slice 3).
+*/
+const patchBlocks = (owner, container, blocks, elements, rendering, rebuilt) => {
+	let previousElement;
+	for (const [index, block] of blocks.entries()) {
+		const existing = elements.get(block.id);
+		const nested = block.type === "Node" && block.blocks !== void 0 ? block.blocks : [];
+		const sameStructure = existing !== void 0 && sameIds(childIds(existing, "data-run"), block.children.map((run) => run.id)) && sameIds(childIds(existing, "data-block"), nested.map((child) => child.id));
+		const place = (element) => {
+			if (previousElement !== void 0) previousElement.after(element);
+			else {
+				const nextId = blocks[index + 1]?.id;
+				const next = nextId === void 0 ? void 0 : elements.get(nextId);
+				if (next !== void 0) next.before(element);
+				else container.append(element);
+			}
+		};
+		if (existing !== void 0 && sameStructure) {
+			if (container.children[index] !== existing) place(existing);
+			previousElement = existing;
+			continue;
+		}
+		const fresh = renderBlock(owner, block, elements, rendering);
+		existing?.remove();
+		place(fresh);
+		rebuilt.add(block.id);
+		previousElement = fresh;
+	}
+};
+/**
+* The text node a run's content starts in. Mark elements may wrap it, so this
+* descends rather than taking `firstChild`, and returns nothing when the run
+* holds no text at all.
+*/
+const textNodeOf = (element) => {
+	let node = element.firstChild;
+	while (node instanceof Element) node = node.firstChild;
+	return node instanceof Text ? node : void 0;
+};
+/** The DOM range for a semantic position, or undefined if it no longer resolves. */
+const positionToRange = (dom, position) => {
+	const element = dom.elements.get(position.node);
+	if (element === void 0 || element.hasAttribute("data-unknown")) return void 0;
+	const text = textNodeOf(element);
+	const limit = text?.length ?? 0;
+	if (position.offset > limit) return void 0;
+	const range = dom.root.ownerDocument.createRange();
+	if (text === void 0) {
+		range.setStart(element, 0);
+		range.collapse(true);
+		return range;
+	}
+	range.setStart(text, position.offset);
+	range.collapse(true);
+	return range;
+};
+const runIdFor = (dom, node) => {
+	const id = ((node instanceof Element ? node : node.parentElement)?.closest("[data-run]"))?.getAttribute("data-run");
+	return id === null || id === void 0 ? void 0 : id;
+};
+/**
+* Maps a browser selection endpoint back to a semantic position. Only text-node
+* containers inside a run are supported; anything else (an element offset, a
+* range outside the owned subtree) has no semantic position and returns
+* undefined rather than guessing.
+*/
+const rangeToPosition = (dom, node, offset) => {
+	if (!(node instanceof Text)) return void 0;
+	const id = runIdFor(dom, node);
+	if (id === void 0) return void 0;
+	const located = RichText.locateRun(dom.content, id);
+	if (located === void 0) return void 0;
+	return {
+		node: id,
+		offset,
+		affinity: offset === located.run.text.length ? "after" : "before"
+	};
+};
+/** Plain text of the subtree, one line per text block: for assertions and fallback copy. */
+const toText = (dom) => {
+	const lines = [];
+	const walk = (container) => {
+		for (const element of Array.from(container.children)) {
+			if (!element.hasAttribute("data-block")) continue;
+			if (Array.from(element.children).some((child) => child.hasAttribute("data-block"))) {
+				walk(element);
+				continue;
+			}
+			const line = (element.textContent ?? "").trim();
+			if (line.length > 0) lines.push(line);
+		}
+	};
+	walk(dom.root);
+	return lines.join("\n");
+};
+const renderedText = (block) => {
+	if (block.type === "Unknown") return `[${block.originalType}]`;
+	return block.children.map((run) => run.text).join("") + (block.type === "Node" && block.blocks !== void 0 ? block.blocks.map(renderedText).join("") : "");
+};
+/** The chain of element names a run's text sits under, as `strong>em`. */
+const runShape = (element) => {
+	const tags = [];
+	let node = element.firstChild;
+	while (node instanceof Element) {
+		tags.push(node.tagName.toLowerCase());
+		node = node.firstChild;
+	}
+	return tags.join(">");
+};
+/**
+* Whether a run element still shows what the renderer produces for it: the same
+* mark elements, and `data-marks` carrying exactly the names no entry renders. A
+* browser can split a mark element or drop one without changing the text, and the
+* semantic document stays the authority, so recovery has to see that.
+*/
+const runMatches = (element, rendering, run) => {
+	if (element === void 0) return false;
+	const { nest, unrendered } = RichText.runRendering(rendering, run);
+	const marks = unrendered.join(" ");
+	const carried = element.getAttribute(MARK_ATTRIBUTE);
+	if (marks.length === 0 ? carried !== null : carried !== marks) return false;
+	const expected = nest.map((entry) => entry.tag.toLowerCase()).reverse().join(">");
+	return runShape(element) === expected;
+};
+/**
+* Recovery, not domain state (§31): makes the subtree match the document again
+* after something outside the semantic pipeline touched it — a cancelled IME
+* composition leaves text the document never had, and a browser extension can
+* mutate anything. Blocks whose rendered text already matches are left alone,
+* so this costs nothing in the normal case and returns the same `EditorDom`
+* when nothing was wrong.
+*/
+const repair = (dom, content) => {
+	const present = /* @__PURE__ */ new Set();
+	const dirtyNodes = /* @__PURE__ */ new Set();
+	const removedNodes = /* @__PURE__ */ new Set();
+	const elements = new Map(dom.elements);
+	const inspect = (blocks) => {
+		for (const block of blocks) {
+			present.add(block.id);
+			for (const run of block.children) present.add(run.id);
+			const nested = block.type === "Node" && block.blocks !== void 0 ? block.blocks : [];
+			for (const child of nested) present.add(child.id);
+			const element = elements.get(block.id);
+			const runs = block.type === "Unknown" ? [] : block.children.map((run) => run.id);
+			const marksMatch = block.type === "Unknown" || block.children.every((run) => runMatches(elements.get(run.id), dom.rendering, run));
+			if (!(element !== void 0 && element.textContent === renderedText(block) && marksMatch && sameIds(childIds(element, "data-run"), runs) && sameIds(childIds(element, "data-block"), nested.map((child) => child.id)))) {
+				element?.remove();
+				elements.delete(block.id);
+				for (const run of runs) elements.delete(run);
+				dirtyNodes.add(block.id);
+				for (const run of runs) dirtyNodes.add(run);
+			}
+			inspect(nested);
+		}
+	};
+	inspect(content.children);
+	for (const id of elements.keys()) if (!present.has(id)) removedNodes.add(id);
+	for (const element of Array.from(dom.root.querySelectorAll("[data-block], [data-run]"))) {
+		const identity = element.getAttribute("data-block") ?? element.getAttribute("data-run") ?? "";
+		if (identity.length > 0 && !present.has(identity)) element.remove();
+	}
+	if (dirtyNodes.size === 0 && removedNodes.size === 0) return dom;
+	return patch({
+		root: dom.root,
+		elements,
+		content: dom.content,
+		rendering: dom.rendering
+	}, content, {
+		dirtyNodes,
+		insertedNodes: /* @__PURE__ */ new Set(),
+		removedNodes,
+		textChanged: /* @__PURE__ */ new Set(),
+		structureChanged: false,
+		selectionChanged: false
+	});
+};
+//#endregion
+export { mount, patch, positionToRange, rangeToPosition, repair, toText };
+
+//# sourceMappingURL=index.mjs.map