@ai-react-markdown/engine 2.12.0 → 2.13.0

package/dist/index.dev.js

@@ -172,8 +172,51 @@ var defaultUrlTransform = (value) => {
   return "";
 };
 
-// src/components/incrementalParse/computeFreezeBoundary.ts
-import { htmlBlockNames } from "micromark-util-html-tag-name";
+// src/components/incrementalParse/freezeScanState.ts
+function freshCheckpoint(defListEnabled, mathFlow, referenceTaint) {
+  return {
+    defListEnabled,
+    mathFlow,
+    referenceTaint,
+    confirmedOffset: 0,
+    candidates: [],
+    defs: /* @__PURE__ */ new Map(),
+    footnoteDefs: /* @__PURE__ */ new Map(),
+    unresolvedRefs: [],
+    tagBalance: /* @__PURE__ */ new Map(),
+    openTotal: 0,
+    p5Tok: { kind: "data" },
+    formPointerMaybeSet: false,
+    openStack: [],
+    mdBlock: { kind: "none" },
+    blankRun: 0,
+    lastBlankStart: -1,
+    hazardVerdict: false,
+    prevLineBlank: true,
+    // doc start counts as a block start
+    prevLineWasText: false,
+    prevLineWasValidDef: false,
+    prevLineOpenContent: false,
+    tableMaybeOpen: false,
+    containerMaybeOpen: false,
+    paragraphHasUnpairedRun: false,
+    openBracket: null,
+    p5SealPending: false,
+    defBlockMaybeOpen: false,
+    fnDefResumable: false,
+    phasePoisonedAt: Infinity,
+    pendingTruncatedTags: [],
+    pendingTruncatedCloses: [],
+    pendingTag: null
+  };
+}
+function pendingFenceCloser(checkpoint) {
+  const cp = checkpoint;
+  if (cp.phasePoisonedAt !== Infinity) return "";
+  if (cp.mdBlock.kind === "fence" && cp.mdBlock.indent === 0) return cp.mdBlock.char.repeat(cp.mdBlock.len);
+  if (cp.mdBlock.kind === "math" && cp.mdBlock.indent === 0) return "$".repeat(cp.mdBlock.len);
+  return "";
+}
 
 // src/components/incrementalParse/mdLineText.ts
 var MD_BLANK_RE = /^[ \t\r]*$/;
@@ -181,6 +224,9 @@ var isMdBlank = (text) => MD_BLANK_RE.test(text);
 var mdTrim = (text) => text.replace(/^[ \t\r]+|[ \t\r]+$/g, "");
 var mdTrimStart = (text) => text.replace(/^[ \t\r]+/, "");
 
+// src/components/incrementalParse/freezeLineSyntax.ts
+import { htmlBlockNames } from "micromark-util-html-tag-name";
+
 // src/components/incrementalParse/referenceTaint.ts
 import { normalizeIdentifier } from "micromark-util-normalize-identifier";
 var FOOTNOTE_DEF_RE = /^ {0,3}\[\^[^\]]*\]:/;
@@ -366,7 +412,7 @@ function settleRefsAndEarliestUnresolved(cp) {
   return earliestUnresolved;
 }
 
-// src/components/incrementalParse/computeFreezeBoundary.ts
+// src/components/incrementalParse/freezeLineSyntax.ts
 var TYPE6_NAMES = new Set(htmlBlockNames);
 var TABLE_PART_NAMES = /* @__PURE__ */ new Set(["td", "th", "tr", "tbody", "thead", "tfoot", "caption", "col", "colgroup"]);
 var DOCUMENT_STRUCTURE_NAMES = /* @__PURE__ */ new Set(["html", "head", "body", "frameset"]);
@@ -618,43 +664,6 @@ function maskIntraLineCodeSpans(text, carryOpen) {
   out += text.slice(cursor);
   return { masked: out, unpaired: false };
 }
-function freshCheckpoint(defListEnabled, mathFlow, referenceTaint) {
-  return {
-    defListEnabled,
-    mathFlow,
-    referenceTaint,
-    confirmedOffset: 0,
-    candidates: [],
-    defs: /* @__PURE__ */ new Map(),
-    footnoteDefs: /* @__PURE__ */ new Map(),
-    unresolvedRefs: [],
-    tagBalance: /* @__PURE__ */ new Map(),
-    openTotal: 0,
-    p5Tok: { kind: "data" },
-    formPointerMaybeSet: false,
-    openStack: [],
-    mdBlock: { kind: "none" },
-    blankRun: 0,
-    lastBlankStart: -1,
-    hazardVerdict: false,
-    prevLineBlank: true,
-    // doc start counts as a block start
-    prevLineWasText: false,
-    prevLineWasValidDef: false,
-    prevLineOpenContent: false,
-    tableMaybeOpen: false,
-    containerMaybeOpen: false,
-    paragraphHasUnpairedRun: false,
-    openBracket: null,
-    p5SealPending: false,
-    defBlockMaybeOpen: false,
-    fnDefResumable: false,
-    phasePoisonedAt: Infinity,
-    pendingTruncatedTags: [],
-    pendingTruncatedCloses: [],
-    pendingTag: null
-  };
-}
 function classifyBlockStart(text, indent, defListEnabled) {
   if (indent >= 4) return true;
   if (LIST_MARKER_RE.test(text) || FOOTNOTE_DEF_RE.test(text)) return true;
@@ -662,71 +671,23 @@ function classifyBlockStart(text, indent, defListEnabled) {
   if (indent === 0) return false;
   return null;
 }
-function computeFreezeBoundary(text, options, resume) {
-  const mathFlow = options.mathFlow ?? true;
-  const referenceTaint = options.referenceTaint ?? true;
-  const prev = resume;
-  const cp = prev && prev.defListEnabled === options.defListEnabled && prev.mathFlow === mathFlow && prev.referenceTaint === referenceTaint && prev.confirmedOffset <= text.length ? prev : freshCheckpoint(options.defListEnabled, mathFlow, referenceTaint);
-  let start = cp.confirmedOffset;
-  let tailLine = null;
-  while (start < text.length) {
-    let end = text.length;
-    let textEnd = text.length;
-    {
-      const nl = text.indexOf("\n", start);
-      const cr = text.indexOf("\r", start);
-      if (cr !== -1 && (nl === -1 || cr < nl)) {
-        textEnd = cr;
-        end = text.charCodeAt(cr + 1) === 10 ? cr + 1 : cr;
-      } else if (nl !== -1) {
-        textEnd = nl;
-        end = nl;
-      }
-    }
-    const confirmed = end < text.length && !(end === text.length - 1 && text.charCodeAt(end) === 13);
-    const lineText = text.slice(start, textEnd);
-    const ln = {
-      start,
-      end,
-      text: lineText,
-      blank: confirmed && isMdBlank(lineText),
-      indent: computeIndent(lineText)
-    };
-    if (!confirmed) {
-      tailLine = ln;
-      break;
-    }
-    processConfirmedLine(cp, ln, text);
-    cp.confirmedOffset = end + 1;
-    start = end + 1;
-  }
-  const earliestUnresolved = settleRefsAndEarliestUnresolved(cp);
-  const defListSettled = (c) => {
-    if (!options.defListEnabled || c.blankRun >= 2) return true;
-    if (c.defListSettled !== null) return c.defListSettled;
-    if (tailLine) return !canBecomeDdLine(tailLine.text, false);
-    return false;
-  };
-  const tailRetroactive = tailLine !== null && tailCarriesRetroactive(tailLine.text);
-  let boundary = 0;
-  for (let i = cp.candidates.length - 1; i >= 0 && !tailRetroactive; i--) {
-    const c = cp.candidates[i];
-    if (!c.htmlBalanced || c.hazard || c.seamRisk) continue;
-    if (c.offset > cp.phasePoisonedAt) continue;
-    if (c.offset > earliestUnresolved) continue;
-    if (!defListSettled(c)) continue;
-    boundary = c.offset;
-    break;
-  }
-  return { boundary, checkpoint: cp };
-}
-function pendingFenceCloser(checkpoint) {
-  const cp = checkpoint;
-  if (cp.phasePoisonedAt !== Infinity) return "";
-  if (cp.mdBlock.kind === "fence" && cp.mdBlock.indent === 0) return cp.mdBlock.char.repeat(cp.mdBlock.len);
-  if (cp.mdBlock.kind === "math" && cp.mdBlock.indent === 0) return "$".repeat(cp.mdBlock.len);
-  return "";
-}
+var SCANNER_NAME_LISTS = [
+  ["type1", TYPE1_NAMES],
+  ["rawText", RAW_TEXT_ELEMENTS],
+  ["type6", TYPE6_NAMES],
+  ["void", VOID_TAGS],
+  ["documentStructure", DOCUMENT_STRUCTURE_NAMES],
+  // Added with F28, and it is the list that would have made F28 visible: the
+  // derived census alphabet partitions names by their membership across THIS
+  // table, so before it existed `frame` shared one 39-name class with `div`
+  // and could never be sampled apart from it.
+  ["noElement", NO_ELEMENT_NAMES],
+  ["tablePart", TABLE_PART_NAMES],
+  ["scopeBarrier", SCOPE_BARRIER_NAMES],
+  ["foreignRoot", new Set(FOREIGN_ROOT_NAMES)]
+];
+
+// src/components/incrementalParse/freezeLineTransition.ts
 function floatingResidue(text, commentOpenAtStart) {
   let out = "";
   let open = commentOpenAtStart;
@@ -1376,24 +1337,66 @@ function processConfirmedLine(cp, ln, text) {
     }
   }
 }
-var SCANNER_NAME_LISTS = [
-  ["type1", TYPE1_NAMES],
-  ["rawText", RAW_TEXT_ELEMENTS],
-  ["type6", TYPE6_NAMES],
-  ["void", VOID_TAGS],
-  ["documentStructure", DOCUMENT_STRUCTURE_NAMES],
-  // Added with F28, and it is the list that would have made F28 visible: the
-  // derived census alphabet partitions names by their membership across THIS
-  // table, so before it existed `frame` shared one 39-name class with `div`
-  // and could never be sampled apart from it.
-  ["noElement", NO_ELEMENT_NAMES],
-  ["tablePart", TABLE_PART_NAMES],
-  ["scopeBarrier", SCOPE_BARRIER_NAMES],
-  ["foreignRoot", new Set(FOREIGN_ROOT_NAMES)]
-];
 
-// src/components/incrementalParse/spliceParse.ts
-import { normalizeIdentifier as normalizeIdentifier2 } from "micromark-util-normalize-identifier";
+// src/components/incrementalParse/computeFreezeBoundary.ts
+function computeFreezeBoundary(text, options, resume) {
+  const mathFlow = options.mathFlow ?? true;
+  const referenceTaint = options.referenceTaint ?? true;
+  const prev = resume;
+  const cp = prev && prev.defListEnabled === options.defListEnabled && prev.mathFlow === mathFlow && prev.referenceTaint === referenceTaint && prev.confirmedOffset <= text.length ? prev : freshCheckpoint(options.defListEnabled, mathFlow, referenceTaint);
+  let start = cp.confirmedOffset;
+  let tailLine = null;
+  while (start < text.length) {
+    let end = text.length;
+    let textEnd = text.length;
+    {
+      const nl = text.indexOf("\n", start);
+      const cr = text.indexOf("\r", start);
+      if (cr !== -1 && (nl === -1 || cr < nl)) {
+        textEnd = cr;
+        end = text.charCodeAt(cr + 1) === 10 ? cr + 1 : cr;
+      } else if (nl !== -1) {
+        textEnd = nl;
+        end = nl;
+      }
+    }
+    const confirmed = end < text.length && !(end === text.length - 1 && text.charCodeAt(end) === 13);
+    const lineText = text.slice(start, textEnd);
+    const ln = {
+      start,
+      end,
+      text: lineText,
+      blank: confirmed && isMdBlank(lineText),
+      indent: computeIndent(lineText)
+    };
+    if (!confirmed) {
+      tailLine = ln;
+      break;
+    }
+    processConfirmedLine(cp, ln, text);
+    cp.confirmedOffset = end + 1;
+    start = end + 1;
+  }
+  const earliestUnresolved = settleRefsAndEarliestUnresolved(cp);
+  const defListSettled = (c) => {
+    if (!options.defListEnabled || c.blankRun >= 2) return true;
+    if (c.defListSettled !== null) return c.defListSettled;
+    if (tailLine) return !canBecomeDdLine(tailLine.text, false);
+    return false;
+  };
+  const tailRetroactive = tailLine !== null && tailCarriesRetroactive(tailLine.text);
+  let boundary = 0;
+  for (let i = cp.candidates.length - 1; i >= 0 && !tailRetroactive; i--) {
+    const c = cp.candidates[i];
+    if (!c.htmlBalanced || c.hazard || c.seamRisk) continue;
+    if (c.offset > cp.phasePoisonedAt) continue;
+    if (c.offset > earliestUnresolved) continue;
+    if (!defListSettled(c)) continue;
+    boundary = c.offset;
+    break;
+  }
+  return { boundary, checkpoint: cp };
+}
 
 // src/components/hastPredicates.ts
 function isFootnoteSection(node) {
@@ -1441,121 +1444,7 @@ function attributeHastChildren(mdast, hast, stopAt = Infinity) {
   }
 }
 
-// src/components/incrementalParse/spliceParse.ts
-function collectPrefixInjection(mdast, content, boundary, resume) {
-  const resumeValid = resume != null && resume.boundary <= boundary;
-  if (resumeValid && resume.uninjectable) return { events: resume.events, uninjectable: true };
-  const resumeAt = resumeValid ? resume.boundary : 0;
-  const events = resumeAt > 0 ? cloneEventsForAppend(resume.events) : [];
-  let uninjectable = false;
-  let cacheable = true;
-  const pushRef = (token) => {
-    const last = events[events.length - 1];
-    if (last && last.kind === "refs") last.tokens.push(token);
-    else events.push({ kind: "refs", tokens: [token] });
-  };
-  const visit7 = (node, nested) => {
-    const type = node.type;
-    if (type === "definition") {
-      const start = node.position?.start?.offset;
-      const end = node.position?.end?.offset;
-      if (start !== void 0 && end !== void 0 && start < boundary) {
-        const slice = content.slice(start, end);
-        if (nested && slice.includes("\n")) uninjectable = true;
-        else events.push({ kind: "def", source: slice });
-      }
-      return;
-    }
-    if (type === "footnoteDefinition") {
-      const start = node.position?.start;
-      const end = node.position?.end?.offset;
-      if (start?.offset === void 0 || end === void 0 || start.offset >= boundary) return;
-      if (nested) {
-        uninjectable = true;
-        return;
-      }
-      const lineStart = start.offset - (start.column - 1);
-      events.push({
-        kind: "footnoteDef",
-        source: content.slice(lineStart, end),
-        origStart: lineStart,
-        origLine: start.line
-      });
-      return;
-    }
-    if (type === "footnoteReference") {
-      const start = node.position?.start?.offset;
-      const end = node.position?.end?.offset;
-      if (start === void 0 || end === void 0) {
-        uninjectable = true;
-        return;
-      }
-      pushRef(content.slice(start, end));
-      return;
-    }
-    const children = node.children;
-    if (children) {
-      for (const child of children) visit7(child, true);
-    }
-  };
-  let lastStart = -1;
-  for (const child of mdast.children) {
-    const start = child.position?.start?.offset;
-    if (start !== void 0) {
-      if (start < lastStart) return { events: [], uninjectable: true, cacheable: false };
-      lastStart = start;
-    }
-    if (start === void 0) {
-      if (resumeAt > 0) return collectPrefixInjection(mdast, content, boundary, null);
-      cacheable = false;
-      visit7(child, false);
-      continue;
-    }
-    if (start >= boundary || start < resumeAt) continue;
-    visit7(child, false);
-  }
-  return { events, uninjectable, cacheable };
-}
-function cloneEventsForAppend(events) {
-  const out = events.slice();
-  const last = out[out.length - 1];
-  if (last && last.kind === "refs") out[out.length - 1] = { kind: "refs", tokens: last.tokens.slice() };
-  return out;
-}
-var TERMINATOR_LABEL = "__aimd_injection_terminator__";
-var INJECTION_TERMINATOR = `[${TERMINATOR_LABEL}]: __aimd_sentinel_link__`;
-function tailMentionsTerminator(tailSource) {
-  return normalizeIdentifier2(tailSource).replace(/\[ /g, "[").includes(`[${normalizeIdentifier2(TERMINATOR_LABEL)}`);
-}
-function buildInjectionPrefix(events) {
-  if (events.length === 0) return { text: "", segments: [] };
-  let text = "";
-  let line = 1;
-  const segments = [];
-  for (const event of events) {
-    if (text.length > 0) {
-      text += "\n\n";
-      line += 2;
-    }
-    const injStart = text.length;
-    const source = event.kind === "refs" ? event.tokens.join(" ") : event.source;
-    if (event.kind === "footnoteDef") {
-      segments.push({
-        injStart,
-        injEnd: injStart + source.length,
-        offsetDelta: event.origStart - injStart,
-        lineDelta: event.origLine - line
-      });
-    }
-    text += source;
-    line += countNewlines(source);
-  }
-  return { text: `${text}
-
-${INJECTION_TERMINATOR}
-
-`, segments };
-}
+// src/components/incrementalParse/spliceCoordinates.ts
 function rebaseTree(node, offsetDelta, lineDelta) {
   rebaseTreeDual(node, EMPTY_SEGMENTS, offsetDelta, lineDelta);
 }
@@ -1584,6 +1473,23 @@ function rebaseDualWalk(node, segments, maxEnd, offsetDelta, lineDelta) {
     for (const child of children) rebaseDualWalk(child, segments, maxEnd, offsetDelta, lineDelta);
   }
 }
+function rebasePoint(point, offsetDelta, lineDelta) {
+  return {
+    line: point.line + lineDelta,
+    column: point.column,
+    offset: point.offset !== void 0 ? point.offset + offsetDelta : void 0
+  };
+}
+function countNewlines(text, end = text.length) {
+  let count = 0;
+  for (let i = text.indexOf("\n"); i !== -1 && i < end; i = text.indexOf("\n", i + 1)) count += 1;
+  for (let i = text.indexOf("\r"); i !== -1 && i < end; i = text.indexOf("\r", i + 1)) {
+    if (text.charCodeAt(i + 1) !== 10) count += 1;
+  }
+  return count;
+}
+
+// src/components/incrementalParse/spliceHtmlGuards.ts
 var TABLE_PART_TAG_RE = /<(?:td|th|tr|tbody|thead|tfoot|caption|col|colgroup)\b/i;
 var TABLE_TOKEN_RE = /<(\/?)(table|td|th|tr|tbody|thead|tfoot|caption|col|colgroup)\b/gi;
 function hasStrayTablePart(values) {
@@ -1665,127 +1571,26 @@ function rawTextRegionCrossesOut(values) {
   }
   return false;
 }
-function spliceTrees(input) {
-  const { prevMdast, prevHast, tailMdast, tailHast, content, boundary, injectionPrefix, injectedSegments } = input;
-  const injectedLen = injectionPrefix.length;
-  const injectedLines = countNewlines(injectionPrefix);
-  const prefixLines = countNewlines(content, boundary);
-  const offsetDelta = boundary - injectedLen;
-  const lineDelta = prefixLines - injectedLines;
-  const prefixMdast = [];
-  for (const child of prevMdast.children) {
-    const start = child.position?.start?.offset;
-    if (start !== void 0 && start < boundary) prefixMdast.push(child);
-  }
-  const attrs = attributeHastChildren(prevMdast, prevHast, boundary);
-  const cutRegion = [];
-  for (let i = 0; i < prevHast.children.length; i++) {
-    if (attrs[i] < boundary) {
-      const node2 = prevHast.children[i];
-      const end = node2.position?.end?.offset;
-      if (end !== void 0 && end > boundary) return null;
-      if (isTrailingLiteralText(node2)) {
-        const prev = i > 0 ? prevHast.children[i - 1] : void 0;
-        if (!prev || prev.type !== "element" || prev.position === void 0) return null;
-        if (!ownsTrailingLiteral(prev, node2, prefixMdast))
-          return null;
-      }
-      cutRegion.push(node2);
-      continue;
-    }
-    const node = prevHast.children[i];
-    if (i > 0 && attrs[i - 1] < boundary && prevHast.children[i - 1].type === "element" && isTrailingLiteralText(node) && // …and only when that element really IS an html block's output: a
-    // raw literal can only trail an `html` mdast node. A position-less
-    // text after a `<p>` is the NEXT block's remnant — a stray end tag
-    // (`</t>\na`) parse5 dropped, whose text merged with the wrap
-    // separator — owned by the tail, which re-parses it; freezing it
-    // here duplicated it (v2.4.0 review P3). Falls through to the
-    // remnant look-ahead below, which bails to a full parse. And the
-    // literal must really be THAT block's trailing text: the block's raw
-    // source ends with it. A dropped-tag block right after a frozen html
-    // element (`</details>\n\n</t>\ntext`) puts its remnant in the same
-    // position, and freezing it duplicated it (release soak of the fix).
-    ownsTrailingLiteral(prevHast.children[i - 1], node, prefixMdast)) {
-      cutRegion.push(node);
-      break;
-    }
-    for (let j = i; j < prevHast.children.length; j++) {
-      const look = prevHast.children[j];
-      if (look.type === "element" || look.position !== void 0) break;
-      if (isTrailingLiteralText(look)) return null;
-    }
-    break;
-  }
-  const tailMdastChildren = tailMdast.children.filter((child) => {
-    const start = child.position?.start?.offset;
-    return !(start !== void 0 && start < injectedLen);
-  });
-  const tailWrapVisible = tailMdastChildren.some((child) => !isWrapInvisible(child));
-  const prefixHtmlValues = prefixMdast.flatMap((c) => c.type === "html" ? [c.value] : []);
-  if (hasStrayTablePart(prefixHtmlValues)) return null;
-  if (rawTextRegionCrossesOut(prefixHtmlValues)) return null;
-  const leadingHtml = [];
-  for (const child of tailMdastChildren) {
-    if (isWrapInvisible(child)) continue;
-    if (child.type !== "html") break;
-    if (STRAY_SYNTHESIZED_END_TAG_RE.test(child.value) || TABLE_PART_TAG_RE.test(child.value)) return null;
-    leadingHtml.push(child.value);
+function isSanitizeStrippedConstruct(value) {
+  const v = value.trim();
+  return v.startsWith("<!--") && v.endsWith("-->") || v.startsWith("<?") && v.endsWith("?>") || v.startsWith("<![CDATA[") && v.endsWith("]]>") || /^<![A-Za-z]/.test(v) && !/^<!doctype/i.test(v) && v.endsWith(">");
+}
+function isExactSanitizeStrippedConstruct(value) {
+  if (value.startsWith("<!--")) {
+    if (value.length < 7 || !value.endsWith("-->")) return false;
+    const close = value.indexOf("-->", 4);
+    const bangClose = value.indexOf("--!>", 4);
+    if (close !== value.length - 3) return false;
+    return bangClose === -1 || bangClose > close;
   }
-  if (headRoutedCaptureUnclosed(leadingHtml)) return null;
-  const aligned = alignPrefixCut(prefixMdast, cutRegion, tailWrapVisible);
-  if (aligned === null) return null;
-  const hastChildren = aligned.children;
-  const interiorFinalLiteral = aligned.interiorFinalLiteral;
-  const stripResult = stripInjectedHast(tailMdast, tailHast, injectedLen, tailWrapVisible);
-  if (stripResult === null) return null;
-  const strippedTailHast = stripResult.rest;
-  for (const child of tailMdastChildren) rebaseTree(child, offsetDelta, lineDelta);
-  for (const child of strippedTailHast) rebaseTreeDual(child, injectedSegments, offsetDelta, lineDelta);
-  const mdastChildren = prefixMdast.concat(tailMdastChildren);
-  const seamMergeVerdict = stripResult.remnantMerged ?? tailLeadingTextIsHoist(tailMdastChildren, strippedTailHast);
-  if (seamMergeVerdict === null) return null;
-  const seamMergeAllowed = seamMergeVerdict;
-  let firstTailChild = true;
-  for (const child of strippedTailHast) {
-    const tailEnd = hastChildren[hastChildren.length - 1];
-    if (firstTailChild && child.type === "text" && child.position !== void 0) {
-      return null;
-    }
-    if (firstTailChild && tailEnd && tailEnd.type === "text" && child.type === "text" && child.position === void 0) {
-      if (interiorFinalLiteral && tailEnd.value.trim() !== "") {
-        if (seamMergeAllowed) return null;
-        firstTailChild = false;
-        hastChildren.push(child);
-        continue;
-      }
-      const literalSeam = tailEnd.value.trim() !== "" && !tailWrapVisible;
-      if (seamMergeAllowed || literalSeam) {
-        hastChildren[hastChildren.length - 1] = { type: "text", value: tailEnd.value + child.value };
-        firstTailChild = false;
-        continue;
-      }
-    }
-    firstTailChild = false;
-    hastChildren.push(child);
+  if (/^<!doctype/i.test(value)) return false;
+  if (value.startsWith("<?") || /^<!(?:[A-Za-z]|\[CDATA\[)/.test(value)) {
+    return value.indexOf(">") === value.length - 1;
   }
-  if (!hastChildren.some((child) => child.position !== void 0)) return null;
-  const docStart = { line: 1, column: 1, offset: 0 };
-  const mdastRootPosition = tailMdast.position ? { start: docStart, end: rebasePoint(tailMdast.position.end, offsetDelta, lineDelta) } : prevMdast.position;
-  const hastRootPosition = mdastRootPosition;
-  const mdast = { type: "root", children: mdastChildren };
-  if (mdastRootPosition) mdast.position = mdastRootPosition;
-  const hast = { type: "root", children: hastChildren };
-  if (hastRootPosition) hast.position = hastRootPosition;
-  if (prevHast.data !== void 0) hast.data = prevHast.data;
-  return { mdast, hast };
-}
-function rebasePoint(point, offsetDelta, lineDelta) {
-  return {
-    line: point.line + lineDelta,
-    column: point.column,
-    offset: point.offset !== void 0 ? point.offset + offsetDelta : void 0
-  };
+  return false;
 }
+
+// src/components/incrementalParse/prefixAlignment.ts
 function isWrapInvisible(node) {
   return node.type === "definition" || node.type === "footnoteDefinition";
 }
@@ -1927,96 +1732,303 @@ function stripInjectedHast(tailMdast, tailHast, injectedLen, tailWrapVisible) {
       idx += 1;
       continue;
     }
-    const start = node.position?.start?.offset;
-    if (start === void 0 || start >= injectedLen) return null;
-    consumed += 1;
-    idx += 1;
-  }
-  if (consumed < injectedVisibleCount) return null;
-  let remnant = "";
-  let remnantMerged = null;
-  if (tailWrapVisible) {
-    const gap = children[idx];
-    if (!gap || !isSeparatorText(gap)) return null;
-    remnant = gap.value.slice(1);
-    remnantMerged = remnant !== "";
-    idx += 1;
+    const start = node.position?.start?.offset;
+    if (start === void 0 || start >= injectedLen) return null;
+    consumed += 1;
+    idx += 1;
+  }
+  if (consumed < injectedVisibleCount) return null;
+  let remnant = "";
+  let remnantMerged = null;
+  if (tailWrapVisible) {
+    const gap = children[idx];
+    if (!gap || !isSeparatorText(gap)) return null;
+    remnant = gap.value.slice(1);
+    remnantMerged = remnant !== "";
+    idx += 1;
+  }
+  const rest = children.slice(idx);
+  if (remnant !== "") rest.unshift({ type: "text", value: remnant });
+  return { rest, remnantMerged };
+}
+function tailLeadingTextIsHoist(tailMdastChildren, tailHastChildren) {
+  const firstText = tailHastChildren[0];
+  const firstVisible = tailMdastChildren.find((c) => !isWrapInvisible(c));
+  if (firstVisible?.type === "html" && STRAY_SYNTHESIZED_END_TAG_RE.test(firstVisible.value)) return null;
+  if (!firstText) return false;
+  if (!isSeparatorText(firstText)) {
+    if (firstText.type === "text" && firstText.position === void 0 && firstVisible?.type === "html") {
+      if (/^\s*<\/[A-Za-z][A-Za-z0-9-]*\s*>/.test(firstVisible.value)) return true;
+      if (isSanitizeStrippedConstruct(firstVisible.value)) return false;
+      return null;
+    }
+    return false;
+  }
+  if (!firstVisible) return false;
+  const firstContent = tailHastChildren.find((c) => !isSeparatorText(c));
+  if (firstContent) {
+    const start = firstContent.position?.start?.offset;
+    const vStart = firstVisible.position?.start?.offset;
+    const vEnd = firstVisible.position?.end?.offset;
+    if (start !== void 0 && vStart !== void 0 && vEnd !== void 0) {
+      if (start >= vStart && start < vEnd) return true;
+    }
+  }
+  if (firstVisible.type === "math") return false;
+  if (firstVisible.type === "html" && isSanitizeStrippedConstruct(firstVisible.value)) return false;
+  return null;
+}
+function isSeparatorText(node) {
+  return node.type === "text" && node.position === void 0 && node.value.trim() === "";
+}
+function ownsTrailingLiteral(el, literal, prefixMdast) {
+  const start = el.position?.start?.offset;
+  if (start === void 0) return false;
+  const owner = prefixMdast.find((c) => c.type === "html" && c.position?.start?.offset === start);
+  if (!owner || owner.type !== "html") return false;
+  const text = literal.value.trim();
+  return text !== "" && owner.value.trimEnd().endsWith(text);
+}
+function isTrailingLiteralText(node) {
+  return node.type === "text" && node.position === void 0 && node.value.trim() !== "";
+}
+function countTrailingNewlines(value) {
+  let n = 0;
+  for (let i = value.length - 1; i >= 0 && value[i] === "\n"; i--) n += 1;
+  return n;
+}
+
+// src/components/incrementalParse/prefixInjection.ts
+import { normalizeIdentifier as normalizeIdentifier2 } from "micromark-util-normalize-identifier";
+function collectPrefixInjection(mdast, content, boundary, resume) {
+  const resumeValid = resume != null && resume.boundary <= boundary;
+  if (resumeValid && resume.uninjectable) return { events: resume.events, uninjectable: true };
+  const resumeAt = resumeValid ? resume.boundary : 0;
+  const events = resumeAt > 0 ? cloneEventsForAppend(resume.events) : [];
+  let uninjectable = false;
+  let cacheable = true;
+  const pushRef = (token) => {
+    const last = events[events.length - 1];
+    if (last && last.kind === "refs") last.tokens.push(token);
+    else events.push({ kind: "refs", tokens: [token] });
+  };
+  const visit7 = (node, nested) => {
+    const type = node.type;
+    if (type === "definition") {
+      const start = node.position?.start?.offset;
+      const end = node.position?.end?.offset;
+      if (start !== void 0 && end !== void 0 && start < boundary) {
+        const slice = content.slice(start, end);
+        if (nested && slice.includes("\n")) uninjectable = true;
+        else events.push({ kind: "def", source: slice });
+      }
+      return;
+    }
+    if (type === "footnoteDefinition") {
+      const start = node.position?.start;
+      const end = node.position?.end?.offset;
+      if (start?.offset === void 0 || end === void 0 || start.offset >= boundary) return;
+      if (nested) {
+        uninjectable = true;
+        return;
+      }
+      const lineStart = start.offset - (start.column - 1);
+      events.push({
+        kind: "footnoteDef",
+        source: content.slice(lineStart, end),
+        origStart: lineStart,
+        origLine: start.line
+      });
+      return;
+    }
+    if (type === "footnoteReference") {
+      const start = node.position?.start?.offset;
+      const end = node.position?.end?.offset;
+      if (start === void 0 || end === void 0) {
+        uninjectable = true;
+        return;
+      }
+      pushRef(content.slice(start, end));
+      return;
+    }
+    const children = node.children;
+    if (children) {
+      for (const child of children) visit7(child, true);
+    }
+  };
+  let lastStart = -1;
+  for (const child of mdast.children) {
+    const start = child.position?.start?.offset;
+    if (start !== void 0) {
+      if (start < lastStart) return { events: [], uninjectable: true, cacheable: false };
+      lastStart = start;
+    }
+    if (start === void 0) {
+      if (resumeAt > 0) return collectPrefixInjection(mdast, content, boundary, null);
+      cacheable = false;
+      visit7(child, false);
+      continue;
+    }
+    if (start >= boundary || start < resumeAt) continue;
+    visit7(child, false);
   }
-  const rest = children.slice(idx);
-  if (remnant !== "") rest.unshift({ type: "text", value: remnant });
-  return { rest, remnantMerged };
+  return { events, uninjectable, cacheable };
 }
-function tailLeadingTextIsHoist(tailMdastChildren, tailHastChildren) {
-  const firstText = tailHastChildren[0];
-  const firstVisible = tailMdastChildren.find((c) => !isWrapInvisible(c));
-  if (firstVisible?.type === "html" && STRAY_SYNTHESIZED_END_TAG_RE.test(firstVisible.value)) return null;
-  if (!firstText) return false;
-  if (!isSeparatorText(firstText)) {
-    if (firstText.type === "text" && firstText.position === void 0 && firstVisible?.type === "html") {
-      if (/^\s*<\/[A-Za-z][A-Za-z0-9-]*\s*>/.test(firstVisible.value)) return true;
-      if (isSanitizeStrippedConstruct(firstVisible.value)) return false;
-      return null;
+function cloneEventsForAppend(events) {
+  const out = events.slice();
+  const last = out[out.length - 1];
+  if (last && last.kind === "refs") out[out.length - 1] = { kind: "refs", tokens: last.tokens.slice() };
+  return out;
+}
+var TERMINATOR_LABEL = "__aimd_injection_terminator__";
+var INJECTION_TERMINATOR = `[${TERMINATOR_LABEL}]: __aimd_sentinel_link__`;
+function tailMentionsTerminator(tailSource) {
+  return normalizeIdentifier2(tailSource).replace(/\[ /g, "[").includes(`[${normalizeIdentifier2(TERMINATOR_LABEL)}`);
+}
+function buildInjectionPrefix(events) {
+  if (events.length === 0) return { text: "", segments: [] };
+  let text = "";
+  let line = 1;
+  const segments = [];
+  for (const event of events) {
+    if (text.length > 0) {
+      text += "\n\n";
+      line += 2;
     }
-    return false;
-  }
-  if (!firstVisible) return false;
-  const firstContent = tailHastChildren.find((c) => !isSeparatorText(c));
-  if (firstContent) {
-    const start = firstContent.position?.start?.offset;
-    const vStart = firstVisible.position?.start?.offset;
-    const vEnd = firstVisible.position?.end?.offset;
-    if (start !== void 0 && vStart !== void 0 && vEnd !== void 0) {
-      if (start >= vStart && start < vEnd) return true;
+    const injStart = text.length;
+    const source = event.kind === "refs" ? event.tokens.join(" ") : event.source;
+    if (event.kind === "footnoteDef") {
+      segments.push({
+        injStart,
+        injEnd: injStart + source.length,
+        offsetDelta: event.origStart - injStart,
+        lineDelta: event.origLine - line
+      });
     }
+    text += source;
+    line += countNewlines(source);
   }
-  if (firstVisible.type === "math") return false;
-  if (firstVisible.type === "html" && isSanitizeStrippedConstruct(firstVisible.value)) return false;
-  return null;
-}
-function isSanitizeStrippedConstruct(value) {
-  const v = value.trim();
-  return v.startsWith("<!--") && v.endsWith("-->") || v.startsWith("<?") && v.endsWith("?>") || v.startsWith("<![CDATA[") && v.endsWith("]]>") || /^<![A-Za-z]/.test(v) && !/^<!doctype/i.test(v) && v.endsWith(">");
+  return { text: `${text}
+
+${INJECTION_TERMINATOR}
+
+`, segments };
 }
-function isExactSanitizeStrippedConstruct(value) {
-  if (value.startsWith("<!--")) {
-    if (value.length < 7 || !value.endsWith("-->")) return false;
-    const close = value.indexOf("-->", 4);
-    const bangClose = value.indexOf("--!>", 4);
-    if (close !== value.length - 3) return false;
-    return bangClose === -1 || bangClose > close;
+
+// src/components/incrementalParse/spliceParse.ts
+function spliceTrees(input) {
+  const { prevMdast, prevHast, tailMdast, tailHast, content, boundary, injectionPrefix, injectedSegments } = input;
+  const injectedLen = injectionPrefix.length;
+  const injectedLines = countNewlines(injectionPrefix);
+  const prefixLines = countNewlines(content, boundary);
+  const offsetDelta = boundary - injectedLen;
+  const lineDelta = prefixLines - injectedLines;
+  const prefixMdast = [];
+  for (const child of prevMdast.children) {
+    const start = child.position?.start?.offset;
+    if (start !== void 0 && start < boundary) prefixMdast.push(child);
   }
-  if (/^<!doctype/i.test(value)) return false;
-  if (value.startsWith("<?") || /^<!(?:[A-Za-z]|\[CDATA\[)/.test(value)) {
-    return value.indexOf(">") === value.length - 1;
+  const attrs = attributeHastChildren(prevMdast, prevHast, boundary);
+  const cutRegion = [];
+  for (let i = 0; i < prevHast.children.length; i++) {
+    if (attrs[i] < boundary) {
+      const node2 = prevHast.children[i];
+      const end = node2.position?.end?.offset;
+      if (end !== void 0 && end > boundary) return null;
+      if (isTrailingLiteralText(node2)) {
+        const prev = i > 0 ? prevHast.children[i - 1] : void 0;
+        if (!prev || prev.type !== "element" || prev.position === void 0) return null;
+        if (!ownsTrailingLiteral(prev, node2, prefixMdast))
+          return null;
+      }
+      cutRegion.push(node2);
+      continue;
+    }
+    const node = prevHast.children[i];
+    if (i > 0 && attrs[i - 1] < boundary && prevHast.children[i - 1].type === "element" && isTrailingLiteralText(node) && // …and only when that element really IS an html block's output: a
+    // raw literal can only trail an `html` mdast node. A position-less
+    // text after a `<p>` is the NEXT block's remnant — a stray end tag
+    // (`</t>\na`) parse5 dropped, whose text merged with the wrap
+    // separator — owned by the tail, which re-parses it; freezing it
+    // here duplicated it (v2.4.0 review P3). Falls through to the
+    // remnant look-ahead below, which bails to a full parse. And the
+    // literal must really be THAT block's trailing text: the block's raw
+    // source ends with it. A dropped-tag block right after a frozen html
+    // element (`</details>\n\n</t>\ntext`) puts its remnant in the same
+    // position, and freezing it duplicated it (release soak of the fix).
+    ownsTrailingLiteral(prevHast.children[i - 1], node, prefixMdast)) {
+      cutRegion.push(node);
+      break;
+    }
+    for (let j = i; j < prevHast.children.length; j++) {
+      const look = prevHast.children[j];
+      if (look.type === "element" || look.position !== void 0) break;
+      if (isTrailingLiteralText(look)) return null;
+    }
+    break;
   }
-  return false;
-}
-function isSeparatorText(node) {
-  return node.type === "text" && node.position === void 0 && node.value.trim() === "";
-}
-function ownsTrailingLiteral(el, literal, prefixMdast) {
-  const start = el.position?.start?.offset;
-  if (start === void 0) return false;
-  const owner = prefixMdast.find((c) => c.type === "html" && c.position?.start?.offset === start);
-  if (!owner || owner.type !== "html") return false;
-  const text = literal.value.trim();
-  return text !== "" && owner.value.trimEnd().endsWith(text);
-}
-function isTrailingLiteralText(node) {
-  return node.type === "text" && node.position === void 0 && node.value.trim() !== "";
-}
-function countTrailingNewlines(value) {
-  let n = 0;
-  for (let i = value.length - 1; i >= 0 && value[i] === "\n"; i--) n += 1;
-  return n;
-}
-function countNewlines(text, end = text.length) {
-  let count = 0;
-  for (let i = text.indexOf("\n"); i !== -1 && i < end; i = text.indexOf("\n", i + 1)) count += 1;
-  for (let i = text.indexOf("\r"); i !== -1 && i < end; i = text.indexOf("\r", i + 1)) {
-    if (text.charCodeAt(i + 1) !== 10) count += 1;
+  const tailMdastChildren = tailMdast.children.filter((child) => {
+    const start = child.position?.start?.offset;
+    return !(start !== void 0 && start < injectedLen);
+  });
+  const tailWrapVisible = tailMdastChildren.some((child) => !isWrapInvisible(child));
+  const prefixHtmlValues = prefixMdast.flatMap((c) => c.type === "html" ? [c.value] : []);
+  if (hasStrayTablePart(prefixHtmlValues)) return null;
+  if (rawTextRegionCrossesOut(prefixHtmlValues)) return null;
+  const leadingHtml = [];
+  for (const child of tailMdastChildren) {
+    if (isWrapInvisible(child)) continue;
+    if (child.type !== "html") break;
+    if (STRAY_SYNTHESIZED_END_TAG_RE.test(child.value) || TABLE_PART_TAG_RE.test(child.value)) return null;
+    leadingHtml.push(child.value);
   }
-  return count;
+  if (headRoutedCaptureUnclosed(leadingHtml)) return null;
+  const aligned = alignPrefixCut(prefixMdast, cutRegion, tailWrapVisible);
+  if (aligned === null) return null;
+  const hastChildren = aligned.children;
+  const interiorFinalLiteral = aligned.interiorFinalLiteral;
+  const stripResult = stripInjectedHast(tailMdast, tailHast, injectedLen, tailWrapVisible);
+  if (stripResult === null) return null;
+  const strippedTailHast = stripResult.rest;
+  for (const child of tailMdastChildren) rebaseTree(child, offsetDelta, lineDelta);
+  for (const child of strippedTailHast) rebaseTreeDual(child, injectedSegments, offsetDelta, lineDelta);
+  const mdastChildren = prefixMdast.concat(tailMdastChildren);
+  const seamMergeVerdict = stripResult.remnantMerged ?? tailLeadingTextIsHoist(tailMdastChildren, strippedTailHast);
+  if (seamMergeVerdict === null) return null;
+  const seamMergeAllowed = seamMergeVerdict;
+  let firstTailChild = true;
+  for (const child of strippedTailHast) {
+    const tailEnd = hastChildren[hastChildren.length - 1];
+    if (firstTailChild && child.type === "text" && child.position !== void 0) {
+      return null;
+    }
+    if (firstTailChild && tailEnd && tailEnd.type === "text" && child.type === "text" && child.position === void 0) {
+      if (interiorFinalLiteral && tailEnd.value.trim() !== "") {
+        if (seamMergeAllowed) return null;
+        firstTailChild = false;
+        hastChildren.push(child);
+        continue;
+      }
+      const literalSeam = tailEnd.value.trim() !== "" && !tailWrapVisible;
+      if (seamMergeAllowed || literalSeam) {
+        hastChildren[hastChildren.length - 1] = { type: "text", value: tailEnd.value + child.value };
+        firstTailChild = false;
+        continue;
+      }
+    }
+    firstTailChild = false;
+    hastChildren.push(child);
+  }
+  if (!hastChildren.some((child) => child.position !== void 0)) return null;
+  const docStart = { line: 1, column: 1, offset: 0 };
+  const mdastRootPosition = tailMdast.position ? { start: docStart, end: rebasePoint(tailMdast.position.end, offsetDelta, lineDelta) } : prevMdast.position;
+  const hastRootPosition = mdastRootPosition;
+  const mdast = { type: "root", children: mdastChildren };
+  if (mdastRootPosition) mdast.position = mdastRootPosition;
+  const hast = { type: "root", children: hastChildren };
+  if (hastRootPosition) hast.position = hastRootPosition;
+  if (prevHast.data !== void 0) hast.data = prevHast.data;
+  return { mdast, hast };
 }
 
 // src/components/incrementalParse/advanceIncrementalParse.ts
@@ -2468,7 +2480,8 @@ function buildRegistryIndex(registry) {
     links: /* @__PURE__ */ new Map(),
     numbers: /* @__PURE__ */ new Map(),
     counts: /* @__PURE__ */ new Map(),
-    occurrences: /* @__PURE__ */ new Map()
+    occurrences: /* @__PURE__ */ new Map(),
+    labelOccurrences: /* @__PURE__ */ new Map()
   };
   for (const sym of registry.chunkOrder) {
     const data = registry.chunkData.get(sym);
@@ -2485,12 +2498,78 @@ function buildRegistryIndex(registry) {
       index.counts.set(label, total);
       const prior = local.get(label);
       if (prior) prior.count++;
-      else local.set(label, { start: total, count: 1 });
+      else {
+        const range = { start: total, count: 1 };
+        local.set(label, range);
+        let byChunk = index.labelOccurrences.get(label);
+        if (!byChunk) index.labelOccurrences.set(label, byChunk = /* @__PURE__ */ new Map());
+        byChunk.set(sym, range);
+      }
     }
   }
   return index;
 }
 
+// src/components/registrySubscriptions.ts
+function equal(a, b) {
+  if (a.owner !== b.owner || a.url !== b.url || a.title !== b.title || a.number !== b.number || a.count !== b.count)
+    return false;
+  if (a.occurrences?.size !== b.occurrences?.size) return false;
+  if (a.occurrences) {
+    for (const [chunk, range] of a.occurrences) {
+      const next = b.occurrences?.get(chunk);
+      if (!next || next.start !== range.start || next.count !== range.count) return false;
+    }
+  }
+  return true;
+}
+function createRegistrySubscriptions(read) {
+  const groups = { link: /* @__PURE__ */ new Map(), footnote: /* @__PURE__ */ new Map() };
+  const snapshot = (kind, label, { registry, index }) => {
+    if (kind === "link") {
+      const owner = index.links.get(label);
+      const def = owner ? registry.chunkData.get(owner)?.linkDefs.get(label) : void 0;
+      return { owner, url: def?.url, title: def?.title };
+    }
+    return {
+      owner: index.footnotes.get(label),
+      number: index.numbers.get(label),
+      count: index.counts.get(label),
+      occurrences: index.labelOccurrences.get(label)
+    };
+  };
+  return {
+    subscribe(kind, rawLabel, cb) {
+      const label = normalizeId(rawLabel);
+      const map = groups[kind];
+      let group = map.get(label);
+      if (!group) {
+        group = { snapshot: snapshot(kind, label, read()), listeners: /* @__PURE__ */ new Set() };
+        map.set(label, group);
+      }
+      const listener = () => cb();
+      group.listeners.add(listener);
+      return () => {
+        group.listeners.delete(listener);
+        if (group.listeners.size === 0 && map.get(label) === group) map.delete(label);
+      };
+    },
+    collect() {
+      if (groups.link.size === 0 && groups.footnote.size === 0) return [];
+      const state = read();
+      const callbacks = [];
+      for (const kind of ["link", "footnote"]) {
+        for (const [label, group] of groups[kind]) {
+          const next = snapshot(kind, label, state);
+          if (!equal(group.snapshot, next)) callbacks.push(...group.listeners);
+          group.snapshot = next;
+        }
+      }
+      return callbacks;
+    }
+  };
+}
+
 // src/components/documentRegistry.ts
 function createRegistry(onEmpty) {
   let index;
@@ -2502,6 +2581,7 @@ function createRegistry(onEmpty) {
     }
     return index;
   };
+  const labels = createRegistrySubscriptions(() => ({ registry: reg, index: getIndex() }));
   const reg = {
     chunkOrder: [],
     chunkData: /* @__PURE__ */ new Map(),
@@ -2652,6 +2732,9 @@ function createRegistry(onEmpty) {
         this._subscribers.delete(cb);
       };
     },
+    subscribeLabel(kind, label, cb) {
+      return labels.subscribe(kind, label, cb);
+    },
     canonicalFootnoteFor(label) {
       return getIndex().footnotes.get(normalizeId(label)) ?? null;
     },
@@ -2679,7 +2762,9 @@ function createRegistry(onEmpty) {
       this._notifyScheduled = true;
       queueMicrotask(() => {
         this._notifyScheduled = false;
+        const labelCallbacks = labels.collect();
         for (const cb of [...this._subscribers]) cb();
+        for (const cb of labelCallbacks) cb();
       });
     }
   };