@50arms/ui 0.0.0-stage → 35.2.0

package/dist/lib/markdown/position.js

@@ -0,0 +1,111 @@
+import { rangeOf as u } from "./reconcile.js";
+import { SYNTAX_ATTR as b } from "./dom.js";
+function m(r) {
+  const n = [], e = (t) => {
+    if (t.nodeType === 3) {
+      u(t) && n.push(t);
+      return;
+    }
+    for (let i = t.firstChild; i; i = i.nextSibling) e(i);
+  };
+  return e(r), n;
+}
+function h(r) {
+  for (let n = r.parentNode; n; n = n.parentNode)
+    if (n.nodeType === 1 && n.hasAttribute(b)) return !0;
+  return !1;
+}
+function d(r, n) {
+  if (!h(n.node)) return n;
+  let e = n.node.parentNode;
+  for (; e?.parentElement?.hasAttribute(b); ) e = e.parentElement;
+  const t = e?.parentNode;
+  if (!e || !t) return n;
+  const i = Array.prototype.indexOf.call(t.childNodes, e);
+  if (i < 0) return n;
+  const l = c(e), o = l !== null && r >= u(l).end;
+  return { node: t, offset: o ? i + 1 : i };
+}
+function g(r, n, e = "after") {
+  const t = m(r);
+  if (!t.length) return null;
+  let i = null;
+  for (let s = 0; s < t.length; s++) {
+    const f = t[s], a = u(f);
+    if (n < a.start) break;
+    if (n < a.end)
+      return h(f) && i ? i : d(n, { node: f, offset: n - a.start });
+    if (n === a.end && !h(f) && (i = { node: f, offset: f.data.length }, e === "before"))
+      return i;
+  }
+  if (i) return i;
+  const l = t.length - 1, o = u(t[l]);
+  return n >= o.end ? d(n, { node: t[l], offset: t[l].data.length }) : d(n, { node: t[0], offset: 0 });
+}
+function N(r, n, e) {
+  if (n.nodeType === 3) {
+    const l = u(n);
+    return l ? l.start + Math.min(e, n.data.length) : null;
+  }
+  const t = n.childNodes[e] ?? null;
+  if (t) {
+    const l = p(t);
+    if (l) return u(l).start;
+  }
+  const i = n.childNodes[e - 1] ?? null;
+  if (i) {
+    const l = c(i);
+    if (l) return u(l).end;
+  }
+  return S(r, n);
+}
+function p(r) {
+  if (r.nodeType === 3) return u(r) ? r : null;
+  for (let n = r.firstChild; n; n = n.nextSibling) {
+    const e = p(n);
+    if (e) return e;
+  }
+  return null;
+}
+function c(r) {
+  if (r.nodeType === 3) return u(r) ? r : null;
+  for (let n = r.lastChild; n; n = n.previousSibling) {
+    const e = c(n);
+    if (e) return e;
+  }
+  return null;
+}
+function S(r, n) {
+  for (let e = n; e && e !== r.parentNode; e = e.parentNode) {
+    for (let t = e.previousSibling; t; t = t.previousSibling) {
+      const i = c(t);
+      if (i) return u(i).end;
+    }
+    for (let t = e.nextSibling; t; t = t.nextSibling) {
+      const i = p(t);
+      if (i) return u(i).start;
+    }
+  }
+  return null;
+}
+function x(r) {
+  const n = r.ownerDocument.getSelection();
+  if (!n || n.rangeCount === 0 || !n.anchorNode || !r.contains(n.anchorNode)) return null;
+  const e = N(r, n.anchorNode, n.anchorOffset), t = n.focusNode && r.contains(n.focusNode) ? N(r, n.focusNode, n.focusOffset) : e;
+  return e === null || t === null ? null : { anchor: e, head: t };
+}
+function y(r, n, e = "after") {
+  const t = x(r);
+  if (t && t.anchor === n.anchor && t.head === n.head) return !1;
+  const i = g(r, n.anchor, e), l = n.head === n.anchor ? i : g(r, n.head, e);
+  if (!i || !l) return !1;
+  const o = r.ownerDocument.getSelection();
+  return o ? (o.setBaseAndExtent(i.node, i.offset, l.node, l.offset), !0) : !1;
+}
+export {
+  g as domPointAt,
+  x as readSelection,
+  N as sourceOffsetAt,
+  y as writeSelection
+};
+//# sourceMappingURL=position.js.map

package/dist/lib/markdown/position.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"position.js","sources":["../../../src/lib/markdown/position.ts"],"sourcesContent":["/* ============================================================================\n   POSITIONS — a source offset and a place in the DOM, in both directions.\n\n   THIS IS THE COST CENTRE, and the research is unambiguous about it. The\n   author of both CodeMirror and ProseMirror published on exactly this in\n   September 2025: flat offsets are the right choice — moving to them in\n   CodeMirror 6 was \"a huge relief\" — but every position you hold must be\n   mapped through every change, which \"demands quite a lot of discipline\" and\n   \"can get expensive when you're tracking a lot of positions.\"\n\n   THE PROJECTION MAKES THIS CHEAP, AND THAT IS ITS WHOLE POINT. Because every\n   source character appears in the DOM exactly once and every text node carries\n   the range it came from, the mapping is a lookup rather than a model. Nothing\n   is maintained between edits, so nothing can drift: after a re-projection the\n   stamps are simply correct again. The expensive discipline the article warns\n   about is the discipline of keeping a SEPARATE structure in step, and there\n   is no separate structure here.\n\n   ASSOCIATION. One offset can be two places — the end of one run and the start\n   of the next — and which one the caret takes changes what typing does. That is\n   a per-node-type product decision (the caret contract), and it is phase 3.\n   What this module guarantees is that the choice is EXPLICIT and total: every\n   offset resolves, deterministically, to exactly one point.\n   ========================================================================= */\n\nimport { rangeOf } from \"./reconcile\";\nimport { SYNTAX_ATTR } from \"./dom\";\n\nexport interface DomPoint {\n  /**\n   * Usually a text node. It is an ELEMENT when the position has no text of its\n   * own to sit in — beside a picture, say, where every character of the\n   * construct is markup and every markup node is zero-width. An element point\n   * names a place BETWEEN children, which is a position the browser renders a\n   * caret for and `sourceOffsetAt` already knows how to read back.\n   */\n  node: Node;\n  offset: number;\n}\n\n/** Which side of a boundary an offset belongs to when two runs meet there. */\nexport type Association = \"before\" | \"after\";\n\n/** Every stamped text node under `root`, in document order. */\nfunction stampedTextNodes(root: Node): Text[] {\n  const out: Text[] = [];\n  const walk = (node: Node) => {\n    if (node.nodeType === 3) {\n      if (rangeOf(node)) out.push(node as Text);\n      return;\n    }\n    for (let child = node.firstChild; child; child = child.nextSibling) walk(child);\n  };\n  walk(root);\n  return out;\n}\n\n/**\n * The DOM point for a source offset.\n *\n * Returns null only when the tree holds no stamped text at all — an empty\n * document. Every other offset resolves, including one past the last character,\n * because a caret at the end of a document is the most ordinary thing there is.\n *\n * `association` decides a boundary. \"after\" (the default) puts the caret at the\n * START of the following run, which is where an insertion should land; \"before\"\n * keeps it at the END of the preceding one, which is what a leftward arrow key\n * wants so the caret appears to move rather than to stand still.\n */\n/** True when a text node sits inside a collapsed run of markup. */\nfunction inMarkup(node: Node): boolean {\n  for (let at: Node | null = node.parentNode; at; at = at.parentNode) {\n    if (at.nodeType === 1 && (at as Element).hasAttribute(SYNTAX_ATTR)) return true;\n  }\n  return false;\n}\n\n/**\n * The DOM point for a source offset, resolved onto text the caret can occupy.\n *\n * A LEGAL OFFSET CAN STILL LAND IN A ZERO-WIDTH NODE, and the browser will not\n * leave the caret there — it silently moves it to the nearest position with\n * geometry, which is a different offset than the one that was asked for. That\n * is the same failure the old contract's reveal existed to prevent, arriving by\n * a different route: a caret STOP at the very start of `![alt](src)` is the\n * right place to stand, and the node at that offset is the collapsed `![`.\n * Found by the browser probe pressing Delete there and watching it eat the last\n * newline of the document instead of the first letter of the alt text.\n *\n * Every offset in a collapsed run is the same PLACE as the offsets either side\n * of it, so any of them may be used — this walks to the nearest text the caret\n * can actually sit in, forwards first, since a marker is nearly always a prefix\n * of the text it introduces.\n */\nfunction visible(offset: number, point: DomPoint): DomPoint {\n  if (!inMarkup(point.node)) return point;\n\n  /* BESIDE THE MARKUP, NOT PAST IT. The first version walked to the nearest\n     text node instead, which is right whenever the markup is a delimiter — the\n     start of `**bold**` and the start of \"bold\" are the same pixel. It is wrong\n     the moment the markup is a WIDGET: walking forward out of a footnote\n     reference `[^1]` lands past it, so the one caret position in front of it\n     resolved to the one behind it, and the arrow keys could not stop there.\n     An element point sits between two children and belongs to neither, which is\n     exactly what \"beside\" means and what the browser will hold a caret at. */\n  let element = point.node.parentNode as Element | null;\n  while (element?.parentElement?.hasAttribute(SYNTAX_ATTR)) element = element.parentElement;\n  const parent = element?.parentNode;\n  if (!element || !parent) return point;\n\n  const index = Array.prototype.indexOf.call(parent.childNodes, element);\n  if (index < 0) return point;\n\n  /* WHICH SIDE IS DECIDED BY THE OFFSET, not by the association. The\n     association answers \"which run does a boundary belong to\"; here the\n     question is \"is this offset at the front of this widget or the back of\n     it\", and only the widget's own range can say. Using the association put\n     the caret behind a widget when the LEFT arrow arrived at the position in\n     front of it, so Left could not stop there at all. */\n  const last = lastStamped(element);\n  const after = last !== null && offset >= rangeOf(last)!.end;\n  return { node: parent, offset: after ? index + 1 : index };\n}\n\nexport function domPointAt(root: Node, offset: number, association: Association = \"after\"): DomPoint | null {\n  const nodes = stampedTextNodes(root);\n  if (!nodes.length) return null;\n\n  /* A MARKUP NODE IS NEVER A CANDIDATE, at either end of the search. It has no\n     geometry, so the browser will not leave a caret in one — it moves it to the\n     nearest position that does have geometry, silently, and the model then\n     believes the caret is somewhere it is not.\n\n     The two directions fail differently and both were caught by the probe.\n     Settling on markup for \"after\" at the end of a table cell redirected\n     FORWARD into the next cell, so Right skipped the position between them.\n     Settling on it for \"before\" at the start of a cell redirected BACKWARD into\n     the previous one, so Left skipped it going the other way. Refusing markup\n     outright, and letting the loop find the real text on the correct side, is\n     one rule instead of two special cases. */\n  let last: DomPoint | null = null;\n  for (let i = 0; i < nodes.length; i++) {\n    const node = nodes[i];\n    const range = rangeOf(node)!;\n    if (offset < range.start) break;\n    if (offset < range.end) {\n      /* Strictly inside. Content is unambiguous and is the common case; markup\n         yields to whatever content is adjacent, on the association's side —\n         unless content already ended exactly here, which is a place to stand. */\n      if (inMarkup(node) && last) return last;\n      return visible(offset, { node, offset: offset - range.start });\n    }\n    if (offset === range.end && !inMarkup(node)) {\n      /* On the boundary. \"before\" settles here; \"after\" keeps looking, and\n         falls back to here if nothing usable follows. */\n      last = { node, offset: node.data.length };\n      if (association === \"before\") return last;\n    }\n  }\n  if (last) return last;\n\n  /* Offset past everything stamped, or inside a gap the reconciler did not\n     stamp — clamp to the nearest end rather than returning nothing, because a\n     caret that cannot be placed is worse than one placed a character away. */\n  const tail = nodes.length - 1;\n  const range = rangeOf(nodes[tail])!;\n  return offset >= range.end\n    ? visible(offset, { node: nodes[tail], offset: nodes[tail].data.length })\n    : visible(offset, { node: nodes[0], offset: 0 });\n}\n\n/**\n * The source offset for a DOM point.\n *\n * Accepts an ELEMENT container as well as a text node, because that is what a\n * browser hands back: a selection at the start of an empty paragraph, or one\n * that landed between two children, is reported as `(element, childIndex)`.\n * Resolving it here rather than at each call site is the difference between one\n * correct conversion and six approximate ones.\n *\n * Returns null for a point in a subtree this module did not build, which is a\n * REAL event — the browser creates nodes during composition and on paste — and\n * the caller must handle it as one rather than substitute a plausible number.\n */\nexport function sourceOffsetAt(root: Node, node: Node, offset: number): number | null {\n  if (node.nodeType === 3) {\n    const range = rangeOf(node);\n    if (!range) return null;\n    return range.start + Math.min(offset, (node as Text).data.length);\n  }\n\n  /* An element point names a position BETWEEN children. Everything before it in\n     document order has been passed; the offset is the end of the last stamped\n     text node in that region, or the start of the first one after it. */\n  const child = node.childNodes[offset] ?? null;\n  if (child) {\n    const first = firstStamped(child);\n    if (first) return rangeOf(first)!.start;\n  }\n  const before = node.childNodes[offset - 1] ?? null;\n  if (before) {\n    const last = lastStamped(before);\n    if (last) return rangeOf(last)!.end;\n  }\n  /* An empty element: fall back to the nearest stamped node in the whole tree\n     by walking outward, which is what a caret in an empty paragraph needs. */\n  return nearestOutward(root, node);\n}\n\nfunction firstStamped(node: Node): Text | null {\n  if (node.nodeType === 3) return rangeOf(node) ? (node as Text) : null;\n  for (let child = node.firstChild; child; child = child.nextSibling) {\n    const found = firstStamped(child);\n    if (found) return found;\n  }\n  return null;\n}\n\nfunction lastStamped(node: Node): Text | null {\n  if (node.nodeType === 3) return rangeOf(node) ? (node as Text) : null;\n  for (let child = node.lastChild; child; child = child.previousSibling) {\n    const found = lastStamped(child);\n    if (found) return found;\n  }\n  return null;\n}\n\nfunction nearestOutward(root: Node, node: Node): number | null {\n  for (let at: Node | null = node; at && at !== root.parentNode; at = at.parentNode) {\n    for (let sibling = at.previousSibling; sibling; sibling = sibling.previousSibling) {\n      const found = lastStamped(sibling);\n      if (found) return rangeOf(found)!.end;\n    }\n    for (let sibling = at.nextSibling; sibling; sibling = sibling.nextSibling) {\n      const found = firstStamped(sibling);\n      if (found) return rangeOf(found)!.start;\n    }\n  }\n  return null;\n}\n\n/* --- Selection ------------------------------------------------------------ */\n\nexport interface SourceSelection {\n  anchor: number;\n  head: number;\n}\n\n/** The current selection as source offsets, or null if it is not in `root`. */\nexport function readSelection(root: HTMLElement): SourceSelection | null {\n  const selection = root.ownerDocument.getSelection();\n  if (!selection || selection.rangeCount === 0) return null;\n  if (!selection.anchorNode || !root.contains(selection.anchorNode)) return null;\n  const anchor = sourceOffsetAt(root, selection.anchorNode, selection.anchorOffset);\n  const head =\n    selection.focusNode && root.contains(selection.focusNode)\n      ? sourceOffsetAt(root, selection.focusNode, selection.focusOffset)\n      : anchor;\n  if (anchor === null || head === null) return null;\n  return { anchor, head };\n}\n\n/**\n * Puts the selection at the given source offsets.\n *\n * DOES NOTHING IF IT ALREADY MATCHES. That is the first of the three rules both\n * ProseMirror and CodeMirror carry verbatim: writing a selection that is already\n * correct is itself a source of caret jumps, because some engines scroll,\n * collapse or re-anchor on assignment even when nothing moved.\n */\nexport function writeSelection(root: HTMLElement, selection: SourceSelection, association: Association = \"after\"): boolean {\n  const current = readSelection(root);\n  if (current && current.anchor === selection.anchor && current.head === selection.head) return false;\n\n  const anchor = domPointAt(root, selection.anchor, association);\n  const head = selection.head === selection.anchor ? anchor : domPointAt(root, selection.head, association);\n  if (!anchor || !head) return false;\n\n  const domSelection = root.ownerDocument.getSelection();\n  if (!domSelection) return false;\n  domSelection.setBaseAndExtent(anchor.node, anchor.offset, head.node, head.offset);\n  return true;\n}\n"],"names":["stampedTextNodes","root","out","walk","node","rangeOf","child","inMarkup","at","SYNTAX_ATTR","visible","offset","point","element","parent","index","last","lastStamped","after","domPointAt","association","nodes","i","range","tail","sourceOffsetAt","first","firstStamped","before","nearestOutward","found","sibling","readSelection","selection","anchor","head","writeSelection","current","domSelection"],"mappings":"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"}

package/dist/lib/markdown/project.js

@@ -0,0 +1,108 @@
+import { parseDocument as E } from "../syntax/markdown/parse.js";
+class j extends Error {
+  constructor(n) {
+    super(n), this.name = "ProjectionError";
+  }
+}
+function b(s) {
+  const n = [], e = [];
+  let f = 0;
+  if (E(s, {
+    /* Spans are the HIGHLIGHTER's answer, and the projector deliberately does
+       not consult them: it classifies from frames, which is the parser saying
+       what it MEANT rather than what colour it chose. Two sources of truth for
+       the same question is how they drift. */
+    span() {
+    },
+    /* A fenced block's inner grammar is resolved by the VIEW, from the frame's
+       own `language` field and content range. Tokenizing here would make a pure
+       function depend on grammar-registration order. */
+    embed() {
+    },
+    open(l, o, i) {
+      const g = { frame: l, start: o, end: o, content: i ?? [], seq: f++ };
+      e.push(g), n.push(g);
+    },
+    close(l, o) {
+      const i = e.pop();
+      if (!i) throw new j(`close() with no open frame at ${l}`);
+      if (l < i.start)
+        throw new j(`frame ${i.frame.kind} closes at ${l}, before its start ${i.start}`);
+      i.end = l, o?.length && (i.content = [...i.content, ...o]);
+    }
+  }), e.length)
+    throw new j(`${e.length} frame(s) left open: ${e.map((l) => l.frame.kind).join(", ")}`);
+  return n;
+}
+function v(s, n) {
+  for (const e of s) if (n >= e.start && n < e.end) return !0;
+  return !1;
+}
+function P(s, n, e) {
+  let f = e;
+  for (const d of s)
+    d.start > n && d.start < f && (f = d.start), d.end > n && d.end < f && (f = d.end);
+  return f;
+}
+function D(s, n = {}) {
+  const e = b(s), f = /* @__PURE__ */ new Map();
+  if (n.highlight)
+    for (const r of e) {
+      if (r.frame.kind !== "codeBody" || !r.content.length) continue;
+      const c = r.content[0].start, h = r.content[r.content.length - 1].end;
+      f.set(r, n.highlight(s.slice(c, h), r.frame.language, c));
+    }
+  const d = [...e].sort((r, c) => r.start - c.start || r.seq - c.seq);
+  let l = 0, o = 0;
+  function i(r, c, h, t) {
+    let a = c;
+    for (; a < h; ) {
+      const u = t ? t.content : null, M = t !== null && t.frame.kind === "image" && u !== null && u.every((p) => p.end === p.start), w = u !== null && !M && !v(u, a);
+      let m = u === null ? h : Math.min(P(u, a, h), h);
+      const k = t ? f.get(t) : void 0;
+      let $;
+      if (k && !w) {
+        const p = k.find((x) => a >= x.start && a < x.end);
+        if (p)
+          $ = p.type, m = Math.min(m, p.end);
+        else {
+          const x = k.find((q) => q.start > a);
+          x && (m = Math.min(m, x.start));
+        }
+      }
+      r.push({
+        type: "text",
+        start: a,
+        end: m,
+        text: s.slice(a, m),
+        syntax: w,
+        ...$ ? { token: $ } : {}
+      }), a = m;
+    }
+  }
+  function g(r, c, h) {
+    for (; o < c; ) {
+      const t = d[l];
+      if (!t || t.start >= c) {
+        i(r, o, c, h), o = c;
+        return;
+      }
+      t.start > o && (i(r, o, t.start, h), o = t.start), l++;
+      const a = { type: "element", frame: t.frame, start: t.start, end: t.end, children: [] };
+      r.push(a), t.end > t.start && g(a.children, t.end, t), a.children.length || a.children.push({ type: "text", start: t.start, end: t.start, text: "", syntax: !1 }), o = Math.max(o, t.end);
+    }
+  }
+  const y = [];
+  return g(y, s.length, null), y.length || y.push({ type: "text", start: 0, end: 0, text: "", syntax: !1 }), { source: s, children: y, frames: e };
+}
+function T(s) {
+  let n = "";
+  for (const e of s) n += e.type === "text" ? e.text : T(e.children);
+  return n;
+}
+export {
+  j as ProjectionError,
+  D as project,
+  T as projectedText
+};
+//# sourceMappingURL=project.js.map

package/dist/lib/markdown/project.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.js","sources":["../../../src/lib/markdown/project.ts"],"sourcesContent":["/* ============================================================================\n   THE PROJECTION — one markdown string becomes one tree of elements and text\n   runs, and reading its text back reproduces the string BYTE FOR BYTE.\n\n   THIS IS THE SPINE OF THE EDITOR, and the invariant is the whole reason it is\n   built this way. A WYSIWYG markdown editor has exactly one hard problem:\n   knowing, at every moment, which source characters the thing under the caret\n   came from. Every published approach to that problem is a mapping maintained\n   alongside the document — and the documented failure of all of them is the\n   mapping drifting out of step with what is on screen.\n\n   So there is no mapping. Every character of the source appears in the\n   projection exactly once, in order, including the `**`, the `#`, the `> ` and\n   the fence lines. Syntax is not deleted and not replaced; it is MARKED, and\n   the view collapses it to zero width until the caret enters it. That is\n   Obsidian's mechanism, and it buys four things at once:\n\n     - Round-trip is byte-identical BY CONSTRUCTION. Open a document, touch\n       nothing, and the bytes cannot move, because nothing serialises anything.\n     - Caret to offset is exact and TOTAL. Every source offset is a distinct\n       place in the projection, so position 2 of `**bold**` is somewhere the\n       caret can genuinely be — and the (offset, association) ambiguity that\n       every tree-model editor carries never arises for markers.\n     - The \"it reformatted my document\" bug class is structurally impossible.\n     - The gate is one assertion over any corpus, and it needs no browser.\n\n   WHAT DECIDES SYNTAX FROM CONTENT. Not a token type, and not a table of node\n   kinds — the parser says so directly, through the frames it opens. See\n   ../syntax/markdown/frames.ts for the rule; this module only applies it.\n\n   WHAT THIS MODULE IS NOT. It builds no DOM, imports no React, and reads no\n   clock. It is a pure function of a string, in the same shape as the calendar's\n   layout core, and for the same reason: an interaction layer sitting on top of\n   a testable pure core is the only arrangement in which either can be trusted.\n   ========================================================================= */\n\nimport type { Frame, FrameRecord, Range } from \"../syntax/markdown/frames\";\nimport { parseDocument } from \"../syntax/markdown/parse\";\nimport type { Sink } from \"../syntax/markdown/spans\";\n\n/* --- The projected tree --------------------------------------------------- */\n\n/**\n * A run of literal source characters.\n *\n * `syntax` is what the view collapses. It is not a rendering hint — it is the\n * parser's own answer to \"did any frame claim this as its text\", so a run that\n * says `syntax: false` is genuinely editable prose and one that says true is\n * genuinely markup.\n */\nexport interface PText {\n  type: \"text\";\n  start: number;\n  end: number;\n  text: string;\n  syntax: boolean;\n  /**\n   * The highlight class this run carries, inside a fenced block.\n   *\n   * Only ever set for code, and only when a tokenizer was supplied. Prose stays\n   * untyped so it stays a BARE text node — see ../markdown/dom.ts, constraint 3:\n   * every wrapper around prose is another reason to replace a node, and a\n   * replaced node is a cancelled composition.\n   */\n  token?: string;\n}\n\n/** How a fenced block's body is highlighted, if the caller wants it. */\nexport interface ProjectOptions {\n  /**\n   * Returns tokens with ABSOLUTE offsets into `source`, exactly as\n   * `lib/syntax`'s `tokenize` does.\n   *\n   * Injected rather than imported, and the reason is the same one the module\n   * header gives for not tokenizing at all before: reaching for the grammar\n   * REGISTRY from here would make a pure function's output depend on which\n   * languages happened to be registered when it ran. Passing it in keeps the\n   * projection reproducible and keeps this module's tests grammar-free.\n   */\n  highlight?: (code: string, language: string | null, at: number) => Array<{ start: number; end: number; type: string }>;\n}\n\n/** A frame with its projected children, in source order. */\nexport interface PElement {\n  type: \"element\";\n  frame: Frame;\n  start: number;\n  end: number;\n  children: PNode[];\n}\n\nexport type PNode = PText | PElement;\n\n/** The document root. `source` is kept so consumers never re-derive it. */\nexport interface Projection {\n  source: string;\n  children: PNode[];\n  /** Every frame, in the order the parser opened them. */\n  frames: readonly FrameRecord[];\n}\n\n/* --- Collecting the parser's report --------------------------------------- */\n\n/**\n * Thrown when the parser's frames do not nest, which would make the projection\n * ambiguous.\n *\n * This is a FAIL-LOUD, not a repair. A projector that silently reordered\n * overlapping frames would produce a tree that reads correctly and maps the\n * caret to the wrong character — the exact defect this whole design exists to\n * make impossible, reintroduced by the code meant to prevent it.\n */\nexport class ProjectionError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"ProjectionError\";\n  }\n}\n\nfunction collect(source: string): FrameRecord[] {\n  const frames: FrameRecord[] = [];\n  /* Open frames, innermost last. `close` pops, so nesting comes from the\n     parser's own call order rather than from comparing intervals — which is\n     what makes two frames sharing a start unambiguous. */\n  const stack: FrameRecord[] = [];\n  let seq = 0;\n\n  const sink: Sink = {\n    /* Spans are the HIGHLIGHTER's answer, and the projector deliberately does\n       not consult them: it classifies from frames, which is the parser saying\n       what it MEANT rather than what colour it chose. Two sources of truth for\n       the same question is how they drift. */\n    span() {},\n    /* A fenced block's inner grammar is resolved by the VIEW, from the frame's\n       own `language` field and content range. Tokenizing here would make a pure\n       function depend on grammar-registration order. */\n    embed() {},\n    open(frame, start, content) {\n      const record: FrameRecord = { frame, start, end: start, content: content ?? [], seq: seq++ };\n      stack.push(record);\n      frames.push(record);\n    },\n    close(end, content) {\n      const record = stack.pop();\n      if (!record) throw new ProjectionError(`close() with no open frame at ${end}`);\n      if (end < record.start) {\n        throw new ProjectionError(`frame ${record.frame.kind} closes at ${end}, before its start ${record.start}`);\n      }\n      record.end = end;\n      if (content?.length) record.content = [...record.content, ...content];\n    },\n  };\n\n  parseDocument(source, sink);\n  if (stack.length) {\n    throw new ProjectionError(`${stack.length} frame(s) left open: ${stack.map((f) => f.frame.kind).join(\", \")}`);\n  }\n  return frames;\n}\n\n/* --- Classification ------------------------------------------------------- */\n\nfunction inRanges(ranges: readonly Range[], at: number): boolean {\n  for (const range of ranges) if (at >= range.start && at < range.end) return true;\n  return false;\n}\n\n/**\n * The next offset at or after `at` where classification could change, bounded\n * by `limit`.\n *\n * Walking character by character would be correct and is what the first version\n * did; this exists because the projection is rebuilt on every keystroke and a\n * long document has hundreds of thousands of characters that cannot possibly\n * change class. Only a range EDGE can change the answer.\n */\nfunction nextEdge(ranges: readonly Range[], at: number, limit: number): number {\n  let edge = limit;\n  for (const range of ranges) {\n    if (range.start > at && range.start < edge) edge = range.start;\n    if (range.end > at && range.end < edge) edge = range.end;\n  }\n  return edge;\n}\n\n/* --- The walk ------------------------------------------------------------- */\n\n/**\n * Projects a markdown string.\n *\n * The walk is linear over the SOURCE, descending into a frame when it starts\n * and leaving when it ends. Every character is emitted exactly once, by\n * exactly one of the two paths — inside a frame or at the document level —\n * which is the invariant stated as an algorithm rather than as a test.\n */\nexport function project(source: string, options: ProjectOptions = {}): Projection {\n  const frames = collect(source);\n\n  /**\n   * Highlight tokens for every fenced block, keyed by the frame that owns them.\n   *\n   * Computed once per projection rather than per run: a fence's body is one\n   * tokenizer call, and calling it again for each line would re-parse the block\n   * as many times as it has lines.\n   */\n  const highlights = new Map<FrameRecord, Array<{ start: number; end: number; type: string }>>();\n  if (options.highlight) {\n    for (const record of frames) {\n      /* Keyed on the BODY frame, never on the block. The block's own content\n         is the newline it claims as its terminator (see `endBlock`), so keying\n         it there hands the tokenizer a lone \"\n\" and types nothing that is\n         actually code — which is exactly what the first version did. */\n      if (record.frame.kind !== \"codeBody\" || !record.content.length) continue;\n      const from = record.content[0].start;\n      const to = record.content[record.content.length - 1].end;\n      highlights.set(record, options.highlight(source.slice(from, to), record.frame.language, from));\n    }\n  }\n\n  /* Sorted by start, then by EMISSION ORDER (`seq`) — never by width.\n     `collect()`'s own comment already states the reason: the parser's stack\n     opens a frame before any frame nested inside it, so when two frames share\n     a start, the one opened FIRST is always the outer one — by construction,\n     not by comparing intervals.\n\n     A width-based tie-break (\"the wider frame is the parent\") looks\n     equivalent and is not: it also fires for two SIBLINGS that merely touch\n     at a point, which happens whenever a piece trims down to zero\n     characters — an empty table cell, notably, since `toCell()` opens and\n     closes it at the same offset when its trimmed text is \"\". The very next\n     call in `readRow()` opens that cell's trailing `tableGutter` at that same\n     offset, wider by construction (it spans to the next cell). Sorting the\n     wider gutter first made `walk()` descend into it BEFORE the zero-width\n     cell was consumed, so the cell was appended as the gutter's CHILD instead\n     of the row's next sibling — an invalid `<td>` nested inside a `<td>` once\n     `dom.ts` tags it, which the browser's own table column algorithm then\n     cannot count as a real column. `overflow-wrap: anywhere` (authored.css)\n     was left to wrap the header text of whichever column shared that index\n     one character per line, since the column had nothing left to size it by.\n\n     `seq` alone resolves both cases correctly: a genuine parent is always\n     opened (pushed) before anything nested inside it, so it already has the\n     lower `seq`; a zero-width cell is opened and closed before its own\n     trailing gutter is ever opened, so it also has the lower `seq` — meaning\n     `walk()` consumes the empty cell first, adds it as a normal (empty) leaf\n     since a zero-width frame never recurses into a child walk, and only then\n     reaches the gutter as what it actually is: the next sibling in the same\n     row. */\n  const ordered = [...frames].sort((a, b) => a.start - b.start || a.seq - b.seq);\n\n  let index = 0;\n  let cursor = 0;\n\n  /** Emits source `[from, to)` as text runs, split at classification edges. */\n  function emitText(out: PNode[], from: number, to: number, owner: FrameRecord | null): void {\n    let at = from;\n    while (at < to) {\n      /* MARKUP IS A PROPERTY OF BEING INSIDE A CONSTRUCT AND NOT BEING ITS\n         TEXT. Outside every frame there is no construct, so there is nothing\n         for a character to be the markup OF — the blank line between two blocks\n         is the document's own vertical space, not a marker like `#` or `**`.\n\n         An earlier version \"unified\" this to markup for tidiness and the\n         browser probe found what that costs: collapse the newline that ends a\n         line and the line stops existing, so the caret cannot be put after it\n         and Enter appears to do nothing. Every source line is a line on screen;\n         that is what makes every offset addressable, and it is the same\n         one-to-one model Obsidian's Live Preview uses.\n\n         Note what this does NOT loosen: a newline between two table rows is\n         inside the table frame, unclaimed, and therefore still markup — which\n         is correct, because the `<tr>` provides that break itself. The rule\n         gets both cases right without knowing about either. */\n      const ranges = owner ? owner.content : null;\n      /* An IMAGE with an EMPTY label (`![]()`) would collapse to nothing at all, and its author could neither see nor\n         fix it (DX-3134). Its source stays visible instead. A link with no label is unchanged. */\n      const unlabelled = owner !== null && owner.frame.kind === \"image\" && ranges !== null && ranges.every((range) => range.end === range.start);\n      const syntax = ranges !== null && !unlabelled && !inRanges(ranges, at);\n      let edge = ranges === null ? to : Math.min(nextEdge(ranges, at, to), to);\n\n      /* A fenced block's BODY splits further, at token boundaries, so each run\n         can carry a highlight class. Only the body — the fence lines are markup\n         and are already their own runs. The extra boundaries change no\n         characters, so the invariant does not notice them. */\n      const tokens = owner ? highlights.get(owner) : undefined;\n      let token: string | undefined;\n      if (tokens && !syntax) {\n        const inside = tokens.find((t) => at >= t.start && at < t.end);\n        if (inside) {\n          token = inside.type;\n          edge = Math.min(edge, inside.end);\n        } else {\n          const after = tokens.find((t) => t.start > at);\n          if (after) edge = Math.min(edge, after.start);\n        }\n      }\n\n      out.push({\n        type: \"text\",\n        start: at,\n        end: edge,\n        text: source.slice(at, edge),\n        syntax,\n        ...(token ? { token } : {}),\n      });\n      at = edge;\n    }\n  }\n\n  function walk(out: PNode[], until: number, owner: FrameRecord | null): void {\n    while (cursor < until) {\n      const next = ordered[index];\n      if (!next || next.start >= until) {\n        emitText(out, cursor, until, owner);\n        cursor = until;\n        return;\n      }\n      if (next.start > cursor) {\n        emitText(out, cursor, next.start, owner);\n        cursor = next.start;\n      }\n      /* A zero-width frame consumes nothing and would spin the loop forever if\n         it were not stepped over explicitly. They are legal — an empty table\n         cell is one — and they still carry structure. */\n      index++;\n      const element: PElement = { type: \"element\", frame: next.frame, start: next.start, end: next.end, children: [] };\n      out.push(element);\n      if (next.end > next.start) walk(element.children, next.end, next);\n      /* An element holding no characters still needs a place the caret can BE —\n         an empty table cell, a list item with no text yet. A zero-length run is\n         that place: it contributes nothing to the projected text, so the\n         invariant is untouched, and it gives position mapping something to\n         resolve to. Without it the caret cannot enter the element at all, which\n         reads as \"the editor ignores my click\". */\n      if (!element.children.length) {\n        element.children.push({ type: \"text\", start: next.start, end: next.start, text: \"\", syntax: false });\n      }\n      cursor = Math.max(cursor, next.end);\n    }\n  }\n\n  const children: PNode[] = [];\n  walk(children, source.length, null);\n  /* THE EMPTY DOCUMENT, which is where every editor starts and which the first\n     browser probe found immediately: with no nodes at all there is no position,\n     so the caret cannot be placed and the surface reads as inert. Same fix as\n     an empty element above, at the document level. */\n  if (!children.length) children.push({ type: \"text\", start: 0, end: 0, text: \"\", syntax: false });\n  /* No document-tail branch below this line. `walk` does not return until its\n     `until` is reached, so a top-level call with `source.length` has by\n     definition emitted every character — and the guard harness proved it: a\n     deliberate break that deleted the tail handling stayed GREEN across the\n     whole corpus, because the branch was unreachable. An unreachable repair\n     path is worse than none; it reads as insurance nobody has to think about. */\n\n  return { source, children, frames };\n}\n\n/* --- The invariant, as a function ----------------------------------------- */\n\n/**\n * Reads a projection's text back, in document order.\n *\n * Deliberately dumb — no knowledge of frames, no special cases. The moment this\n * function needs to know what a table is, the invariant has stopped being an\n * invariant.\n */\nexport function projectedText(nodes: readonly PNode[]): string {\n  let out = \"\";\n  for (const node of nodes) out += node.type === \"text\" ? node.text : projectedText(node.children);\n  return out;\n}\n"],"names":["ProjectionError","message","collect","source","frames","stack","seq","parseDocument","frame","start","content","record","end","f","inRanges","ranges","at","range","nextEdge","limit","edge","project","options","highlights","from","to","ordered","a","b","index","cursor","emitText","out","owner","unlabelled","syntax","tokens","token","inside","t","after","walk","until","next","element","children","projectedText","nodes","node"],"mappings":"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"}

package/dist/lib/markdown/reconcile.js

@@ -0,0 +1,127 @@
+import { SYNTAX_ATTR as x, sameElement as E, tagFor as N, FRAME_ATTR as w } from "./dom.js";
+const a = "__mdFrame", d = "__mdRange";
+class p extends Error {
+  constructor(e) {
+    super(e), this.name = "CompositionConflictError";
+  }
+}
+function b(t, e) {
+  const r = t.createTextNode(e.text);
+  if (r[d] = { start: e.start, end: e.end }, !e.syntax && !e.token) return r;
+  const n = t.createElement("span");
+  return e.syntax && n.setAttribute(x, ""), e.token && n.setAttribute(g, e.token), n.appendChild(r), n;
+}
+const g = "data-t";
+function R(t, e) {
+  const r = N(e.frame), n = t.createElement(r.tag);
+  n.setAttribute(w, e.frame.kind);
+  for (const [i, l] of Object.entries(r.attrs ?? {})) n.setAttribute(i, l);
+  return n[a] = e.frame, n;
+}
+function f(t, e) {
+  if (e.type === "text") return b(t, e);
+  const r = R(t, e);
+  for (const n of e.children) r.appendChild(f(t, n));
+  return r;
+}
+function _(t, e) {
+  if (!t) return null;
+  if (!(e.syntax || !!e.token)) return t.nodeType === 3 ? t : null;
+  if (t.nodeType !== 1) return null;
+  const n = t;
+  if (n.hasAttribute(x) !== e.syntax || n.getAttribute(g) !== (e.token ?? null)) return null;
+  const i = n.firstChild;
+  return n.childNodes.length === 1 && i && i.nodeType === 3 ? i : null;
+}
+function F(t, e) {
+  if (!t || t.nodeType !== 1) return null;
+  const r = t, n = r[a];
+  return n && E(n, e.frame) ? r : null;
+}
+function K(t, e, r) {
+  const n = { textUpdated: 0, textUntouched: 0, elementsReused: 0, created: 0, removed: 0 }, i = t.lastChild && O(t.lastChild) ? t.lastChild : null;
+  if (i && t.removeChild(i), C(t, e, { protect: r.protect ?? null, stats: n }), v(e)) {
+    const l = i ?? k(t.ownerDocument);
+    i || n.created++, t.appendChild(l);
+  }
+  return n;
+}
+const A = "data-md-filler";
+function k(t) {
+  const e = t.createElement("br");
+  return e.setAttribute(A, ""), e;
+}
+function O(t) {
+  return t.nodeType === 1 && t.hasAttribute(A);
+}
+function T(t) {
+  for (let e = t.length - 1; e >= 0; e--) {
+    const r = t[e];
+    if (r.type === "text") {
+      if (r.text.length) return r.text[r.text.length - 1];
+      continue;
+    }
+    const n = T(r.children);
+    if (n !== null) return n;
+  }
+  return null;
+}
+function v(t) {
+  return T(t) === `
+`;
+}
+function C(t, e, r) {
+  const n = t.ownerDocument, { protect: i, stats: l } = r;
+  for (let c = 0; c < e.length; c++) {
+    const o = e[c], h = t.childNodes[c] ?? null;
+    if (o.type === "text") {
+      const s = _(h, o);
+      if (s) {
+        if (s.data === o.text)
+          l.textUntouched++;
+        else {
+          if (s === i)
+            throw new p(
+              `a patch would rewrite the composing text node (${JSON.stringify(s.data)} to ${JSON.stringify(o.text)})`
+            );
+          s.data = o.text, l.textUpdated++;
+        }
+        s[d] = { start: o.start, end: o.end };
+        continue;
+      }
+      m(t, c, f(n, o), i, l);
+      continue;
+    }
+    const u = F(h, o);
+    if (u) {
+      u[a] = o.frame, l.elementsReused++, C(u, o.children, r);
+      continue;
+    }
+    m(t, c, f(n, o), i, l);
+  }
+  for (; t.childNodes.length > e.length; ) {
+    const c = t.childNodes[t.childNodes.length - 1];
+    y(c, i, "removed"), t.removeChild(c), l.removed++;
+  }
+}
+function m(t, e, r, n, i) {
+  const l = t.childNodes[e] ?? null;
+  if (i.created++, !l) {
+    t.appendChild(r);
+    return;
+  }
+  y(l, n, "replaced"), t.replaceChild(r, l);
+}
+function y(t, e, r) {
+  if (e && (t === e || t.contains(e)))
+    throw new p(`a patch would have ${r} the composing text node`);
+}
+function S(t) {
+  return t[d] ?? null;
+}
+export {
+  p as CompositionConflictError,
+  K as patch,
+  S as rangeOf
+};
+//# sourceMappingURL=reconcile.js.map

package/dist/lib/markdown/reconcile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.js","sources":["../../../src/lib/markdown/reconcile.ts"],"sourcesContent":["/* ============================================================================\n   THE RECONCILER — patches the editable DOM in place, preserving node identity.\n\n   THIS IS THE PART THAT KILLS EDITORS, so it is built first and on purpose.\n   Slate shipped a from-scratch re-render of a contenteditable and closed the\n   resulting bug as unfixable, in their own words: \"There are composition bugs\n   that cannot be fixed… IME has a reference of a specific text node during\n   composition. However, when react re-renders the editor, the text node no\n   longer exists.\"\n\n   All three mature editors carry dedicated machinery for exactly one thing —\n   keeping ONE Text node's OBJECT IDENTITY alive across an update. ProseMirror\n   orphans it out of the reconciler and destroys its siblings; CodeMirror marks\n   its tile reused and bails out entirely if the node is multi-line or not\n   byte-identical to the document slice; Lexical never assigns `nodeValue` while\n   composing and diffs with `deleteData`/`insertData` on the same object.\n\n   So this module has three rules, and they are the whole design:\n\n     1. NEVER REPLACE WHAT CAN BE UPDATED. A text node whose data changed keeps\n        its object and takes a new `data`. An element whose frame still\n        describes the same element keeps its object and is patched in place.\n     2. NEVER WRITE WHAT DID NOT CHANGE. Assigning identical `data` to a Text\n        node still resets the selection in some engines, so an unchanged node is\n        not touched at all. This is CodeMirror's rule, verbatim.\n     3. NEVER TOUCH THE PROTECTED NODE. During composition the browser owns one\n        text node. It is passed in, and this module will not write it, will not\n        move it, and will not remove it — it refuses the patch instead, loudly.\n\n   WHY THIS IS NOT REACT. React owns the DOM it renders and reconciles on its\n   own schedule; a contenteditable is owned by the browser, which mutates it\n   mid-keystroke. The two cannot both be in charge. React renders the chrome —\n   toolbar, popovers, footer — and the editable surface is plain DOM, patched\n   here. That also disposes of the `dangerouslySetInnerHTML` question rather\n   than answering it: no HTML string is ever produced.\n   ========================================================================= */\n\nimport type { PElement, PNode, PText } from \"./project\";\nimport { FRAME_ATTR, SYNTAX_ATTR, sameElement, tagFor } from \"./dom\";\n\n/** Where the reconciler stashes the frame it built an element from. */\nconst FRAME_KEY = \"__mdFrame\";\n/** Where it stashes the source range of a text node's owning run. */\nconst RANGE_KEY = \"__mdRange\";\n\ninterface Tagged {\n  [FRAME_KEY]?: PElement[\"frame\"];\n  [RANGE_KEY]?: { start: number; end: number };\n}\n\n/**\n * Thrown when a patch would have had to disturb the node the browser is\n * composing into.\n *\n * Loud rather than silent because the caller's contract is to DEFER the patch\n * until `compositionend`, and a reconciler that quietly skipped the change\n * would leave the DOM disagreeing with the model — which is the same corruption\n * one step later, with nothing pointing at the cause.\n */\nexport class CompositionConflictError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"CompositionConflictError\";\n  }\n}\n\nexport interface PatchOptions {\n  /**\n   * The text node the browser is composing into. Never written, moved or\n   * removed; a patch that would need to do any of those throws.\n   */\n  protect?: Text | null;\n}\n\nexport interface PatchStats {\n  /** Text nodes whose `data` was assigned. */\n  textUpdated: number;\n  /** Text nodes left alone because their data already matched. */\n  textUntouched: number;\n  /** Elements reused in place. */\n  elementsReused: number;\n  /** Nodes created, which is the number the caret can be disturbed by. */\n  created: number;\n  removed: number;\n}\n\n/* --- Node construction ---------------------------------------------------- */\n\nfunction createText(doc: Document, node: PText): Node {\n  const text = doc.createTextNode(node.text);\n  (text as Text & Tagged)[RANGE_KEY] = { start: node.start, end: node.end };\n\n  /* PROSE STAYS A BARE TEXT NODE — see ./dom.ts, constraint 3. Two things get a\n     wrapper and both earn it: markup, because collapsing it needs a styling\n     hook, and a highlighted run inside a fenced block, because a colour needs\n     an element to sit on. Nothing else. */\n  if (!node.syntax && !node.token) return text;\n\n  const span = doc.createElement(\"span\");\n  if (node.syntax) span.setAttribute(SYNTAX_ATTR, \"\");\n  if (node.token) span.setAttribute(TOKEN_ATTR, node.token);\n  span.appendChild(text);\n  return span;\n}\n\n/** Carries a fenced block's highlight class; matches the CodeEditor's own. */\nconst TOKEN_ATTR = \"data-t\";\n\nfunction createElement(doc: Document, node: PElement): HTMLElement {\n  const spec = tagFor(node.frame);\n  const element = doc.createElement(spec.tag);\n  element.setAttribute(FRAME_ATTR, node.frame.kind);\n  for (const [key, value] of Object.entries(spec.attrs ?? {})) element.setAttribute(key, value);\n  (element as HTMLElement & Tagged)[FRAME_KEY] = node.frame;\n  return element;\n}\n\n/** What one patch needs to carry down the tree, beyond the nodes themselves. */\ninterface PatchContext {\n  protect: Text | null;\n  stats: PatchStats;\n}\n\nfunction build(doc: Document, node: PNode): Node {\n  if (node.type === \"text\") return createText(doc, node);\n  const element = createElement(doc, node);\n  for (const child of node.children) element.appendChild(build(doc, child));\n  return element;\n}\n\n/* --- Matching ------------------------------------------------------------- */\n\n/** The Text node a projected run would occupy, if `have` can serve it. */\nfunction textNodeFor(have: Node | null, node: PText): Text | null {\n  if (!have) return null;\n  const wrapped = node.syntax || !!node.token;\n  if (!wrapped) return have.nodeType === 3 ? (have as Text) : null;\n  if (have.nodeType !== 1) return null;\n  const element = have as HTMLElement;\n  /* The wrapper has to be the RIGHT wrapper. A run whose highlight class\n     changed — code edited until a keyword became an identifier — needs a new\n     span, and reusing the old one would leave the colour stale forever. */\n  if (element.hasAttribute(SYNTAX_ATTR) !== node.syntax) return null;\n  if (element.getAttribute(TOKEN_ATTR) !== (node.token ?? null)) return null;\n  const first = element.firstChild;\n  return element.childNodes.length === 1 && first && first.nodeType === 3 ? (first as Text) : null;\n}\n\nfunction elementFor(have: Node | null, node: PElement): HTMLElement | null {\n  if (!have || have.nodeType !== 1) return null;\n  const element = have as HTMLElement & Tagged;\n  const previous = element[FRAME_KEY];\n  if (!previous) return null;\n  return sameElement(previous, node.frame) ? element : null;\n}\n\n/* --- The patch ------------------------------------------------------------ */\n\n/**\n * Brings `parent`'s children into agreement with `nodes`.\n *\n * Positional rather than keyed, deliberately. A keyed diff by source offset\n * looks more sophisticated and is worse here: every offset after an edit shifts\n * by the length of that edit, so keys change for the whole rest of the document\n * on every keystroke and the diff replaces everything the user has not touched.\n * Position is stable under exactly the edits that matter — a change in the\n * middle of a paragraph leaves the paragraph at the same index.\n */\nexport function patch(parent: HTMLElement, nodes: readonly PNode[], options: PatchOptions): PatchStats {\n  const stats: PatchStats = { textUpdated: 0, textUntouched: 0, elementsReused: 0, created: 0, removed: 0 };\n  /* Detached before the patch and re-attached after, rather than left for the\n     surplus-child loop to delete and rebuild: the SAME element comes back, so\n     a document that ends with a newline does not churn one node per keystroke. */\n  const existing = parent.lastChild && isFiller(parent.lastChild) ? (parent.lastChild as HTMLElement) : null;\n  if (existing) parent.removeChild(existing);\n\n  patchInto(parent, nodes, { protect: options.protect ?? null, stats });\n\n  if (endsWithNewline(nodes)) {\n    const filler = existing ?? makeFiller(parent.ownerDocument);\n    if (!existing) stats.created++;\n    parent.appendChild(filler);\n  }\n  return stats;\n}\n\n/** Marks the trailing line affordance, so it is recognised and never mapped. */\nconst FILLER_ATTR = \"data-md-filler\";\n\n/**\n * A `<br>` after a document that ends with a newline.\n *\n * NOT COSMETIC. CSS does not render a line box for a trailing line break — the\n * last one is dropped, by specification — so the empty final line of a document\n * does not exist as a place, and a caret written there is relocated by the\n * browser to the end of the previous line. The browser probe found this as\n * Enter putting its newline in the right place and then the NEXT keystroke\n * landing before it: the model said offset 4 and `getTargetRanges` said 3.\n *\n * Every editor carries this affordance, and `<textarea>` gets it from the\n * engine for free. It holds no text, so the projection invariant does not see\n * it, and it carries no source range, so position mapping skips it.\n */\nfunction makeFiller(doc: Document): HTMLElement {\n  const br = doc.createElement(\"br\");\n  br.setAttribute(FILLER_ATTR, \"\");\n  return br;\n}\n\nfunction isFiller(node: Node): boolean {\n  return node.nodeType === 1 && (node as HTMLElement).hasAttribute(FILLER_ATTR);\n}\n\n/**\n * Whether the projected text ends with a newline, without rebuilding it.\n *\n * `null` means \"this subtree holds no characters at all\", which is distinct\n * from \"it ends with something other than a newline\" — an empty element must\n * not stop the search, or a zero-length anchor before the real last run would\n * answer for it.\n */\nfunction lastCharacter(nodes: readonly PNode[]): string | null {\n  for (let i = nodes.length - 1; i >= 0; i--) {\n    const node = nodes[i];\n    if (node.type === \"text\") {\n      if (node.text.length) return node.text[node.text.length - 1];\n      continue;\n    }\n    const inner = lastCharacter(node.children);\n    if (inner !== null) return inner;\n  }\n  return null;\n}\n\nfunction endsWithNewline(nodes: readonly PNode[]): boolean {\n  return lastCharacter(nodes) === \"\\n\";\n}\n\nfunction patchInto(parent: HTMLElement, nodes: readonly PNode[], context: PatchContext): void {\n  const doc = parent.ownerDocument;\n  const { protect, stats } = context;\n\n  for (let i = 0; i < nodes.length; i++) {\n    const node = nodes[i];\n    const have = parent.childNodes[i] ?? null;\n\n    if (node.type === \"text\") {\n      const text = textNodeFor(have, node);\n      if (text) {\n        if (text.data === node.text) {\n          stats.textUntouched++;\n        } else if (text === protect) {\n          throw new CompositionConflictError(\n            `a patch would rewrite the composing text node (${JSON.stringify(text.data)} to ${JSON.stringify(node.text)})`,\n          );\n        } else {\n          text.data = node.text;\n          stats.textUpdated++;\n        }\n        (text as Text & Tagged)[RANGE_KEY] = { start: node.start, end: node.end };\n        continue;\n      }\n      replaceAt(parent, i, build(doc, node), protect, stats);\n      continue;\n    }\n\n    const element = elementFor(have, node);\n    if (element) {\n      (element as HTMLElement & Tagged)[FRAME_KEY] = node.frame;\n      stats.elementsReused++;\n      patchInto(element, node.children, context);\n      continue;\n    }\n    replaceAt(parent, i, build(doc, node), protect, stats);\n  }\n\n  while (parent.childNodes.length > nodes.length) {\n    const last = parent.childNodes[parent.childNodes.length - 1];\n    guard(last, protect, \"removed\");\n    parent.removeChild(last);\n    stats.removed++;\n  }\n}\n\nfunction replaceAt(parent: HTMLElement, index: number, fresh: Node, protect: Text | null, stats: PatchStats): void {\n  const have = parent.childNodes[index] ?? null;\n  stats.created++;\n  if (!have) {\n    parent.appendChild(fresh);\n    return;\n  }\n  guard(have, protect, \"replaced\");\n  parent.replaceChild(fresh, have);\n}\n\n/** Refuses any structural change that would take the composing node with it. */\nfunction guard(node: Node, protect: Text | null, what: string): void {\n  if (!protect) return;\n  if (node === protect || node.contains(protect)) {\n    throw new CompositionConflictError(`a patch would have ${what} the composing text node`);\n  }\n}\n\n/* --- Reading the DOM back ------------------------------------------------- */\n\n/**\n * The source range a text node carries, or null if it was not built here.\n *\n * The range is stamped on the node rather than looked up in a side table on\n * purpose: a WeakMap keyed by node is the same information one indirection\n * away, and the indirection is where a stale entry hides. A node that has no\n * stamp is a node the browser created — which is a real event during\n * composition, and the caller must treat it as one rather than guess.\n */\nexport function rangeOf(node: Node): { start: number; end: number } | null {\n  return (node as Node & Tagged)[RANGE_KEY] ?? null;\n}\n\n/**\n * Reads every text node under `root` in document order and joins it.\n *\n * This is the projection invariant, asserted against the REAL DOM rather than\n * against the projection tree — which is a different claim and the one that\n * actually matters. The tree can be right while the reconciler drops a node.\n */\nexport function domText(root: Node): string {\n  let out = \"\";\n  const walk = (node: Node) => {\n    if (node.nodeType === 3) {\n      out += (node as Text).data;\n      return;\n    }\n    for (let child = node.firstChild; child; child = child.nextSibling) walk(child);\n  };\n  walk(root);\n  return out;\n}\n"],"names":["FRAME_KEY","RANGE_KEY","CompositionConflictError","message","createText","doc","node","text","span","SYNTAX_ATTR","TOKEN_ATTR","createElement","spec","tagFor","element","FRAME_ATTR","key","value","build","child","textNodeFor","have","first","elementFor","previous","sameElement","patch","parent","nodes","options","stats","existing","isFiller","patchInto","endsWithNewline","filler","makeFiller","FILLER_ATTR","br","lastCharacter","i","inner","context","protect","replaceAt","last","guard","index","fresh","what","rangeOf"],"mappings":"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"}