@linloir/limr 1.0.0 → 1.0.1

package/dist/{chunk-TTISGBST.js → chunk-BG5QUQFR.js}

@@ -1,3 +1,13 @@
+import {
+  intersects,
+  lineStarts,
+  rangeOf,
+  slugify,
+  sourcePoint,
+  textContent,
+  walk
+} from "./chunk-FJZCQY2S.js";
+
 // src/core/parser.ts
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { mdxJsx } from "micromark-extension-mdx-jsx";
@@ -5,49 +15,240 @@ import { mdxJsxFromMarkdown } from "mdast-util-mdx-jsx";
 import { directive } from "micromark-extension-directive";
 import { directiveFromMarkdown } from "mdast-util-directive";
 
-// src/core/tree.ts
-function walk(node, visit, parent) {
-  visit(node, parent);
-  for (const child of node.children ?? []) walk(child, visit, node);
-}
-function textContent(node) {
-  if (node.type === "image") return String(node.alt ?? "");
-  return node.value ?? node.children?.map(textContent).join("") ?? "";
-}
-function rangeOf(node) {
-  return { start: node.position?.start.offset ?? 0, end: node.position?.end.offset ?? 0 };
-}
-function intersects(a, b) {
-  return a.start < b.end && b.start < a.end;
-}
-function lineStarts(source) {
-  const result = [0];
-  for (let i = 0; i < source.length; i++) {
-    if (source[i] === "\r") {
-      if (source[i + 1] === "\n") i++;
-      result.push(i + 1);
-    } else if (source[i] === "\n") result.push(i + 1);
+// src/core/streaming.ts
+import { decodeString } from "micromark-util-decode-string";
+function insertions(source, edits) {
+  edits.sort((a, b) => a.at - b.at || (a.order ?? 0) - (b.order ?? 0));
+  const parts = [], points = [];
+  let at = 0, delta = 0;
+  for (const edit of edits) {
+    parts.push(source.slice(at, edit.at), edit.insert);
+    points.push({ from: edit.at + delta, to: edit.at + delta + edit.insert.length, at: edit.at, delta: delta + edit.insert.length });
+    at = edit.at;
+    delta += edit.insert.length;
   }
-  return result;
+  parts.push(source.slice(at));
+  return {
+    value: parts.join(""),
+    original(offset) {
+      let lo = 0, hi = points.length;
+      while (lo < hi) {
+        const mid = lo + hi >>> 1;
+        if (points[mid].from <= offset) lo = mid + 1;
+        else hi = mid;
+      }
+      const point = points[lo - 1];
+      return Math.min(source.length, point ? offset < point.to ? point.at : offset - point.delta : offset);
+    }
+  };
 }
-function sourcePoint(offset, lines) {
-  let lo = 0, hi = lines.length;
-  while (lo + 1 < hi) {
-    const mid = lo + hi >>> 1;
-    if (lines[mid] <= offset) lo = mid;
-    else hi = mid;
+function prepareSource(source, names, tags, streaming, literals = /* @__PURE__ */ new Set()) {
+  if (!streaming && (!names.size || !source.includes("::")) || !/[<:`~$]/.test(source)) return { value: source, original: (at) => at, incomplete: /* @__PURE__ */ new Set() };
+  const edits = [], protectedRegions = [];
+  const incomplete = /* @__PURE__ */ new Set();
+  const containers = [], stack = [];
+  let fence;
+  let hidden;
+  let literal;
+  let maxDepth = 0;
+  const lines = /[^\r\n]*(?:\r\n|\r|\n|$)/g;
+  for (const match of source.matchAll(lines)) {
+    if (!match[0]) continue;
+    const line = match[0].replace(/[\r\n]+$/, ""), at = match.index;
+    const prefix = /^(?: {0,3}>[ \t]?)*(?: {0,3}(?:[-+*]|\d+[.)])[ \t]+)? {0,3}/.exec(line)[0];
+    const body = line.slice(prefix.length), start = at + prefix.length;
+    if (literal && !/^:{2,}[ \t]*$/.test(body)) continue;
+    if (literal) {
+      protectedRegions.push({ start: literal.content, end: at });
+      literal = void 0;
+    }
+    if (fence) {
+      if (new RegExp(`^${fence.marker}{${fence.size},}[ \\t]*$`).test(body)) {
+        protectedRegions.push({ start: fence.start, end: at + match[0].length });
+        fence = void 0;
+      }
+      continue;
+    }
+    const openingFence = /^(`{3,}|~{3,}|\${2,})(.*)$/.exec(body);
+    if (openingFence && !(openingFence[1][0] === "`" && openingFence[2].includes("`"))) {
+      fence = { start, marker: openingFence[1][0] === "$" ? "\\$" : openingFence[1][0], size: openingFence[1].length };
+      if (streaming && !/[\r\n]$/.test(match[0])) hidden = { start };
+      continue;
+    }
+    if (/^[ \t]/.test(body)) {
+      protectedRegions.push({ start: at, end: at + match[0].length });
+      continue;
+    }
+    const open = /^(:{2,})([a-zA-Z][\w-]*)(.*)$/.exec(body);
+    if (open && names.has(open[2])) {
+      const rest = open[3].trim();
+      const validHeader = /^(?:\[(?:\\.|[^\]])*\])?(?:\{(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^{}"'])*\})?$/.test(rest);
+      if (!validHeader) {
+        if (streaming && at + match[0].length === source.length) hidden = { start, name: open[2] };
+        continue;
+      }
+      const item = { start, marker: start, size: open[1].length, depth: stack.length };
+      containers.push(item);
+      stack.push(item);
+      maxDepth = Math.max(maxDepth, item.depth);
+      if (literals.has(open[2]) && /[\r\n]$/.test(match[0])) {
+        item.content = at + match[0].length;
+        item.prefix = prefix.replace(/[-+*]|\d+[.)]/g, (value) => " ".repeat(value.length));
+        literal = item;
+      }
+      continue;
+    }
+    const closing = /^(:{2,})[ \t]*$/.exec(body);
+    if (closing && stack.length) {
+      if (closing[1].length > 2) {
+        let ancestor = -1;
+        for (let index = stack.length - 1; index >= 0; index--) if (stack[index].size > 2 && stack[index].size <= closing[1].length) {
+          ancestor = index;
+          break;
+        }
+        if (ancestor >= 0) for (const leaf of stack.splice(ancestor + 1)) leaf.leaf = true;
+      }
+      const item = stack[stack.length - 1];
+      if (closing[1].length >= item.size) {
+        item.close = start;
+        item.end = at + line.length;
+        stack.pop();
+      }
+    } else if (streaming && /^::[\w-]*$/.test(body) && at + match[0].length === source.length) hidden = { start };
   }
-  return { offset, line: lo + 1, column: offset - lines[lo] + 1 };
-}
-function slugify(text) {
-  return text.toLowerCase().trim().replace(/[^\p{L}\p{N}\s_-]/gu, "").replace(/[\s_]+/g, "-").replace(/^-+|-+$/g, "") || "section";
+  if (fence) {
+    protectedRegions.push({ start: fence.start, end: source.length });
+    if (streaming) incomplete.add(fence.start);
+  }
+  if (literal) protectedRegions.push({ start: literal.content, end: source.length });
+  const active = containers.filter((item) => !item.leaf && (item.close !== void 0 || streaming));
+  const hasDouble = active.some((item) => item.size === 2);
+  const maxSize = Math.max(3, ...active.map((value) => value.size));
+  if (hasDouble) for (const item of active) {
+    const width = maxSize + maxDepth - item.depth;
+    if (width > item.size) edits.push({ at: item.marker, insert: ":".repeat(width - item.size) });
+    if (item.close !== void 0) {
+      const size = /^:+/.exec(source.slice(item.close))[0].length;
+      if (width > size) edits.push({ at: item.close, insert: ":".repeat(width - size) });
+    }
+  }
+  for (const item of active) if (item.content !== void 0) {
+    const payload = source.slice(item.content, item.close ?? source.length);
+    const fence2 = "~".repeat(Math.max(3, ...[...payload.matchAll(/~+/g)].map((match) => match[0].length + 1)));
+    edits.push({ at: item.content, insert: `${item.prefix}${fence2}
+`, order: -2 });
+    if (item.close !== void 0) edits.push({ at: item.close, insert: `${fence2}
+${item.prefix}`, order: -1 });
+  }
+  if (streaming) for (const item of stack) incomplete.add(item.start);
+  const openTags = [];
+  if (streaming && tags.size && source.includes("<")) {
+    let region = 0, codeTicks = 0, codeStart = 0;
+    for (let i = 0; i < (hidden?.start ?? source.length); i++) {
+      while (protectedRegions[region] && protectedRegions[region].end <= i) region++;
+      if (protectedRegions[region]?.start <= i) {
+        i = protectedRegions[region].end - 1;
+        continue;
+      }
+      if (source[i] === "\\") {
+        i++;
+        continue;
+      }
+      if (!codeTicks && names.has("math") && source[i] === "$") {
+        const size = /^\$+/.exec(source.slice(i))[0].length;
+        const close = source.indexOf("$".repeat(size), i + size);
+        if (close < 0) {
+          hidden = { start: i };
+          break;
+        }
+        i = close + size - 1;
+        continue;
+      }
+      if (source[i] === "`") {
+        const size = /^`+/.exec(source.slice(i))[0].length;
+        if (!codeTicks) {
+          codeTicks = size;
+          codeStart = i;
+        } else if (codeTicks === size) codeTicks = 0;
+        i += size - 1;
+        continue;
+      }
+      if (codeTicks || source[i] !== "<") continue;
+      const head = /^<(\/?)([a-zA-Z][\w-]*)/.exec(source.slice(i));
+      if (!head) {
+        if (/^<\/?$/.test(source.slice(i))) hidden = { start: i };
+        continue;
+      }
+      const name = head[2];
+      if (!tags.has(name)) {
+        if ([...tags].some((tag) => tag.startsWith(name)) && i + head[0].length === source.length) hidden = { start: i };
+        continue;
+      }
+      let end = i + head[0].length, quote = "";
+      for (; end < source.length; end++) {
+        const char = source[end];
+        if (quote) {
+          if (char === quote) quote = "";
+        } else if (char === '"' || char === "'") quote = char;
+        else if (char === ">") break;
+      }
+      if (end === source.length) {
+        hidden = { start: i, name: head[1] ? void 0 : name };
+        break;
+      }
+      if (head[1]) {
+        if (openTags.at(-1)?.name === name) openTags.pop();
+      } else if (source[end - 1] !== "/") openTags.push({ name, start: i, block: /^(?: {0,3}> ?)*\s*$/.test(source.slice(source.lastIndexOf("\n", i - 1) + 1, i)) && /^[ \t]*(?:\r?\n|$)/.test(source.slice(end + 1)) });
+      i = end;
+    }
+    if (codeTicks) hidden = { start: Math.min(codeStart, hidden?.start ?? source.length) };
+  }
+  for (const tag of openTags) incomplete.add(tag.start);
+  const cutoff = hidden?.start ?? source.length;
+  const mapped = insertions(source.slice(0, cutoff), edits.filter((edit) => edit.at < cutoff));
+  const suffix = openTags.reverse().map((tag) => `${tag.block ? "\n\n" : ""}</${tag.name}>`).join("");
+  return {
+    ...mapped,
+    value: mapped.value + suffix,
+    incomplete,
+    hidden,
+    recoveryOffset: incomplete.size || hidden ? Math.min(...incomplete, hidden?.start ?? Infinity) : void 0
+  };
 }
-function safeUrl(value, image = false) {
-  if (typeof value !== "string") return void 0;
-  const normalized = value.trim().replace(/[\u0000-\u0020\u007f]/g, "");
-  if (/^(?:https?:|mailto:|tel:)/i.test(normalized) || !/^[a-z][a-z\d+.-]*:/i.test(normalized)) return value;
-  if (image && /^data:image\/(?:png|gif|jpe?g|webp|avif);base64,/i.test(normalized)) return value;
-  return void 0;
+function concealIncomplete(root, source, lines) {
+  const tail = root.children?.at(-1);
+  if (tail?.type === "paragraph" && tail.position) {
+    const raw = source.slice(tail.position.start.offset);
+    if (/^ {0,3}\|[^\r\n]*(?:(?:\r\n|\r|\n)[|:\- \t]*)?$/.test(raw)) {
+      tail.children = [];
+      return;
+    }
+  }
+  let cutoff = source.length;
+  walk(root.children?.at(-1) ?? root, (node) => {
+    if (node.type !== "text" || !node.position) return;
+    const { start, end } = node.position;
+    const raw = source.slice(start.offset);
+    for (const candidate of raw.slice(0, end.offset - start.offset).matchAll(/[!\[`*_~\$&^]/g)) {
+      const at = candidate.index;
+      let escapes = 0;
+      for (let before = at - 1; before >= 0 && raw[before] === "\\"; before--) escapes++;
+      if (escapes % 2) continue;
+      if (raw[at] === "_" && /[\p{L}\p{N}]/u.test(raw[at - 1] ?? "") && /[\p{L}\p{N}]/u.test(raw[at + 1] ?? "")) continue;
+      const tail2 = raw.slice(at).trimEnd();
+      if (/^(?:\^\[[^\]]*$|!?(?:\[[^\]]*$|\[[^\]]*\]\([^)]*$)|`+[^`]*$|\*{1,3}(?:\S[^*]*)?$|_{1,3}(?:\S[^_]*)?$|~{1,2}(?:\S[^~]*)?$|\$[^$]*$|&(?:#x?[\da-f]*|[a-z]*)$)/i.test(tail2)) {
+        cutoff = Math.min(cutoff, start.offset + at);
+        break;
+      }
+    }
+  });
+  if (cutoff === source.length) return;
+  walk(root, (node) => {
+    if (node.children) node.children = node.children.filter((child) => (child.position?.start.offset ?? 0) < cutoff);
+    if (node.type !== "text" || !node.position || node.position.end.offset <= cutoff) return;
+    node.value = decodeString(source.slice(node.position.start.offset, cutoff));
+    node.position = { start: node.position.start, end: sourcePoint(cutoff, lines) };
+  });
 }
 
 // src/core/parser.ts
@@ -55,6 +256,7 @@ function validateExtensions(extensions) {
   const names = /* @__PURE__ */ new Set();
   const tags = /* @__PURE__ */ new Set();
   const directives = /* @__PURE__ */ new Set();
+  const owners = /* @__PURE__ */ new Map();
   for (const extension of extensions) {
     if (names.has(extension.name)) throw new Error(`Duplicate LiMR extension: ${extension.name}. Use replaceExtension() to replace it explicitly.`);
     names.add(extension.name);
@@ -64,46 +266,72 @@ function validateExtensions(extensions) {
         known.add(name);
       }
     }
+    for (const name of [...extension.tags ?? [], ...extension.directives ?? []]) {
+      if (owners.has(name) && owners.get(name) !== extension) throw new Error(`Duplicate LiMR component syntax: ${name}`);
+      owners.set(name, extension);
+    }
   }
 }
 function createParser(extensions) {
   validateExtensions(extensions);
   const tagDefinitions = new Map(extensions.flatMap((ext) => (ext.tags ?? []).map((name) => [name, ext])));
-  const directiveDefinitions = new Map(extensions.flatMap((ext) => (ext.directives ?? []).map((name) => [name, ext])));
+  const directiveDefinitions = new Map(extensions.flatMap((ext) => [.../* @__PURE__ */ new Set([...ext.tags ?? [], ...ext.directives ?? []])].map((name) => [name, ext])));
+  const names = new Set(directiveDefinitions.keys()), tags = new Set(tagDefinitions.keys());
+  const literals = new Set([...directiveDefinitions].filter(([, definition]) => definition.literal).map(([name]) => name));
   const syntax = extensions.flatMap((ext) => [...ext.micromark ?? []]);
   const mdast = extensions.flatMap((ext) => [...ext.mdast ?? []]);
+  const plainSyntax = [...syntax], plainMdast = [...mdast];
   if (directiveDefinitions.size) {
     syntax.push(directive());
     mdast.push(directiveFromMarkdown());
   }
   const jsxSyntax = tagDefinitions.size ? [...syntax, { disable: { null: ["htmlFlow", "htmlText"] } }, mdxJsx()] : syntax;
   const jsxMdast = tagDefinitions.size ? [...mdast, mdxJsxFromMarkdown()] : mdast;
+  const plainJsxSyntax = [...plainSyntax, { disable: { null: ["htmlFlow", "htmlText"] } }, mdxJsx()];
+  const plainJsxMdast = [...plainMdast, mdxJsxFromMarkdown()];
+  let literalCache;
   return (fragment, offset, context, lines, environment = "") => {
     const prefix = environment ? `${environment}
 
 limr-definition-boundary
 
 ` : "";
-    const input = prefix + fragment;
+    const cached = literalCache;
+    const canAppendLiteral = context.streaming && cached && !prefix && cached.offset === offset && fragment.startsWith(cached.fragment) && !new RegExp(`(?:^|[\\r\\n]) {0,3}${cached.fence[0]}{${cached.fence.length},}[ \\t]*(?=[\\r\\n]|$)`).test(fragment.slice(Math.max(cached.content, cached.fragment.lastIndexOf("\n") + 1, cached.fragment.lastIndexOf("\r") + 1)));
+    const prepared = canAppendLiteral ? { value: fragment, original: (at) => at, incomplete: /* @__PURE__ */ new Set([0]), recoveryOffset: 0, hidden: void 0 } : prepareSource(fragment, names, tags, context.streaming, literals);
+    const input = prefix + prepared.value;
+    const hasDirectives = directiveDefinitions.size > 0 && /:[a-zA-Z]/.test(input);
+    const hasJsx = tagDefinitions.size > 0 && input.includes("<");
+    const activeSyntax = hasDirectives ? syntax : plainSyntax, activeMdast = hasDirectives ? mdast : plainMdast;
+    const mappedOffset = (at) => offset + prepared.original(Math.max(0, at - prefix.length));
+    const mappedLines = lines.length ? lines : lineStarts(context.source);
     const diagnostics = [];
     let attributeLines;
     const attributePoint = (at) => sourcePoint(at, lines.length ? lines : attributeLines ??= lineStarts(context.source));
-    let recoveryOffset;
+    let recoveryOffset = prepared.recoveryOffset === void 0 ? void 0 : offset + prepared.recoveryOffset;
     let root;
     try {
-      root = fromMarkdown(input, { extensions: jsxSyntax, mdastExtensions: jsxMdast });
+      root = canAppendLiteral ? { type: "root", children: [{
+        ...cached.node,
+        value: fragment.slice(cached.content).replace(/(?:\r\n|\r|\n)$/, ""),
+        position: { start: { offset: 0, line: 1, column: 1 }, end: { offset: fragment.length, line: 0, column: 0 } }
+      }] } : fromMarkdown(input, { extensions: hasJsx ? hasDirectives ? jsxSyntax : plainJsxSyntax : activeSyntax, mdastExtensions: hasJsx ? hasDirectives ? jsxMdast : plainJsxMdast : activeMdast });
     } catch (error) {
-      root = fromMarkdown(input, { extensions: syntax, mdastExtensions: mdast });
+      root = fromMarkdown(input, { extensions: activeSyntax, mdastExtensions: activeMdast });
       recoveryOffset = offset;
       diagnostics.push({ message: error instanceof Error ? error.message : String(error), offset });
     }
     root.children = root.children?.filter((node) => (node.position?.start.offset ?? 0) >= prefix.length);
-    if (offset || prefix.length || tagDefinitions.size || directiveDefinitions.size) walk(root, (node) => {
-      if (node.position && (offset || prefix.length)) {
-        const start = Math.max(0, node.position.start.offset - prefix.length + offset);
-        const end = Math.max(start, node.position.end.offset - prefix.length + offset);
-        node.position = { start: sourcePoint(start, lines), end: sourcePoint(end, lines) };
+    const only = root.children?.length === 1 ? root.children[0] : void 0;
+    const fence = !prefix && only?.type === "code" && prepared.incomplete.has(0) && /^(`{3,}|~{3,})[^\r\n]*(?:\r\n|\r|\n)/.exec(fragment);
+    literalCache = fence ? { fragment, offset, node: { ...only }, fence: fence[1], content: fence[0].length } : void 0;
+    if (offset || prefix.length || tagDefinitions.size || directiveDefinitions.size || context.streaming) walk(root, (node) => {
+      if (node.position && (offset || prefix.length || prepared.value !== fragment || canAppendLiteral)) {
+        const start = mappedOffset(node.position.start.offset);
+        const end = Math.max(start, mappedOffset(node.position.end.offset));
+        node.position = { start: sourcePoint(start, mappedLines), end: sourcePoint(end, mappedLines) };
       }
+      if (node.position && prepared.incomplete.has(node.position.start.offset - offset)) node.incomplete = true;
       if (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") {
         const definition = tagDefinitions.get(node.name ?? "");
         const rawAttributes = node.attributes;
@@ -113,8 +341,8 @@ limr-definition-boundary
           if (attr.type === "mdxJsxAttribute" && (typeof attr.value === "string" || attr.value === null)) {
             attributes[attr.name] = attr.value ?? true;
             if (definition && typeof attr.value === "string" && attr.position) {
-              const start = attr.position.start.offset - prefix.length + offset;
-              const end = attr.position.end.offset - prefix.length + offset;
+              const start = mappedOffset(attr.position.start.offset);
+              const end = mappedOffset(attr.position.end.offset);
               const raw = context.source.slice(start, end), opening = raw.search(/["']/);
               if (opening >= 0) attributeNodes[attr.name] = { type: "text", value: attr.value, verbatimEscapes: true, position: { start: attributePoint(start + opening + 1), end: attributePoint(end - 1) } };
             }
@@ -156,7 +384,20 @@ limr-definition-boundary
         }
       }
     });
-    if (offset || prefix.length) root.position = { start: sourcePoint(offset, lines), end: sourcePoint(offset + fragment.length, lines) };
+    if (prepared.hidden) {
+      const start = offset + prepared.hidden.start;
+      recoveryOffset = Math.min(recoveryOffset ?? start, root.children?.at(-1)?.position?.start.offset ?? start);
+      root.children?.push({
+        type: prepared.hidden.name ? "component" : "streamPending",
+        name: prepared.hidden.name,
+        incomplete: true,
+        position: { start: sourcePoint(start, mappedLines), end: sourcePoint(offset + fragment.length, mappedLines) },
+        children: [],
+        attributes: {}
+      });
+    }
+    if (context.streaming) concealIncomplete(root, context.source, mappedLines);
+    if (offset || prefix.length) root.position = { start: sourcePoint(offset, mappedLines), end: sourcePoint(offset + fragment.length, mappedLines) };
     for (const extension of extensions) {
       try {
         extension.transform?.(root, context);
@@ -179,6 +420,19 @@ var DocumentEngine = class {
   listeners = /* @__PURE__ */ new Set();
   definitionSignature = "";
   recoveryOffset;
+  lines = [0];
+  facts = /* @__PURE__ */ new WeakMap();
+  relevant(node) {
+    let result = this.facts.get(node);
+    if (!result) {
+      const nodes = [];
+      walk(node, (child) => {
+        if (child.annotation || ["heading", "definition", "footnoteDefinition", "footnoteReference", "annotationDefinition", "annotationReference"].includes(child.type)) nodes.push(child);
+      });
+      this.facts.set(node, result = nodes);
+    }
+    return result;
+  }
   constructor(source = "", options = {}) {
     this.id = options.id ?? `limr-${++sequence}`;
     this.extensions = options.extensions ?? [];
@@ -210,29 +464,34 @@ var DocumentEngine = class {
     const globalTransform = this.extensions.some((ext) => ext.transform && ext.scope !== "local");
     const append = !force && previous?.streaming && source.startsWith(previous.source) && !globalTransform;
     const finalizing = !!previous?.streaming && !streaming;
-    let start = append && streaming && previous.blocks.length ? previous.blocks[previous.blocks.length - 1].range.start : 0;
+    let start = append && previous.blocks.length ? previous.blocks[previous.blocks.length - 1].range.start : 0;
     const recovering = this.recoveryOffset !== void 0;
     if (append && recovering) start = Math.min(start, this.recoveryOffset);
     let reason = force || globalTransform ? "extension" : !previous ? "initial" : finalizing ? "finalize" : append ? "append" : "replace";
-    const lines = start ? lineStarts(source) : [];
+    if (append && previous) {
+      const from = Math.max(0, previous.source.length - 1);
+      while (this.lines.length > 1 && this.lines.at(-1) > from) this.lines.pop();
+      for (const at of lineStarts(source.slice(from)).slice(1)) this.lines.push(from + at);
+    } else this.lines = lineStarts(source);
+    const lines = this.lines;
     const context = { source, streaming, documentId: this.id };
     let retained = start ? previous.blocks.filter((block) => block.range.end <= start) : [];
     const environment = [];
-    for (const block of retained) walk(block.node, (node) => {
+    for (const block of retained) for (const node of this.relevant(block.node)) {
       if (node.type === "definition" || node.type === "footnoteDefinition") {
         const range = rangeOf(node);
         environment.push(source.slice(range.start, range.end));
       }
-    });
+    }
     let parsed = this.parse(source.slice(start), start, context, lines, environment.join("\n\n"));
     const getSignature = (nodes) => {
       const entries = [];
-      for (const node of nodes) walk(node, (child) => {
+      for (const node of nodes) for (const child of this.relevant(node)) {
         if (child.type === "definition" || child.type === "footnoteDefinition") {
           const range = rangeOf(child);
           entries.push(source.slice(range.start, range.end));
         }
-      });
+      }
       return entries.join("\0");
     };
     let signature = getSignature([...retained.map((block) => block.node), ...parsed.nodes]);
@@ -248,7 +507,7 @@ var DocumentEngine = class {
     }
     this.definitionSignature = signature;
     this.recoveryOffset = parsed.recoveryOffset;
-    const oldAt = new Map(previous?.blocks.map((block) => [block.range.start, block]));
+    const oldAt = new Map(previous?.blocks.slice(retained.length).map((block) => [block.range.start, block]));
     let reused = retained.length;
     const blocks = [...retained];
     for (let index = 0; index < parsed.nodes.length; index++) {
@@ -269,7 +528,7 @@ var DocumentEngine = class {
     const annotations = /* @__PURE__ */ new Map();
     const occurrences = [];
     const slugCounts = /* @__PURE__ */ new Map();
-    for (const block of blocks) walk(block.node, (node) => {
+    for (const block of blocks) for (const node of this.relevant(block.node)) {
       if (node.type === "heading") {
         const text = textContent(node);
         const base = slugify(text);
@@ -280,15 +539,15 @@ var DocumentEngine = class {
       if (node.type === "definition" && !definitions.has(String(node.identifier))) definitions.set(String(node.identifier), node);
       if (node.type === "footnoteDefinition" && !footnotes.has(String(node.identifier))) footnotes.set(String(node.identifier), node);
       if (node.type === "footnoteReference" && !footnoteOrder.includes(String(node.identifier))) footnoteOrder.push(String(node.identifier));
-      if (node.type === "annotationDefinition") {
+      if (node.annotation) {
         const annotation = node.annotation;
-        annotations.set(annotation.id, annotation);
+        if (node.type !== "footnoteDefinition" || !annotations.has(annotation.id)) annotations.set(annotation.id, annotation);
       }
       if (node.type === "annotationReference") {
         const range = rangeOf(node);
-        occurrences.push({ id: `${this.id}-ref-${range.start}`, range, annotationIds: node.annotationIds, embedded: true });
+        occurrences.push({ id: `${this.id}-ref-${range.start}`, range, annotationIds: node.annotationIds, embedded: true, ...node.referenceRange ? { referenceRange: node.referenceRange } : {} });
       }
-    });
+    }
     this.snapshot = {
       id: this.id,
       revision: (previous?.revision ?? -1) + 1,
@@ -320,7 +579,7 @@ function replaceExtension(extensions, replacement) {
 }
 
 // src/core/selection.ts
-import { decodeString } from "micromark-util-decode-string";
+import { decodeString as decodeString2 } from "micromark-util-decode-string";
 function mapText(source, value, range, options = {}) {
   const raw = source.slice(range.start, range.end);
   const starts = [], ends = [];
@@ -333,7 +592,7 @@ function mapText(source, value, range, options = {}) {
     } else if (raw[at] === "&") {
       const entity = /^&(?:#x[\da-f]+|#\d+|[a-z][\da-z]+);/i.exec(raw.slice(at));
       if (entity) {
-        const result = decodeString(entity[0]);
+        const result = decodeString2(entity[0]);
         if (result !== entity[0]) {
           length = entity[0].length;
           decoded = result;
@@ -435,6 +694,7 @@ function selectionFromRange(document, raw, options = {}) {
 var defaultHighlight = { color: "#F2C744", style: "background" };
 var sameRange = (a, b) => a.start === b.start && a.end === b.end;
 function annotationReferenceRange(document, occurrence) {
+  if (occurrence.referenceRange) return occurrence.referenceRange;
   if (!occurrence.embedded) return occurrence.range;
   let reference = occurrence.range;
   const visit = (node) => {
@@ -460,11 +720,6 @@ function resolveAnnotationAnchors(annotation, document) {
 }
 
 export {
-  walk,
-  textContent,
-  rangeOf,
-  intersects,
-  safeUrl,
   DocumentEngine,
   createDocument,
   replaceExtension,
@@ -475,4 +730,4 @@ export {
   annotationReferenceRange,
   resolveAnnotationAnchors
 };
-//# sourceMappingURL=chunk-TTISGBST.js.map
+//# sourceMappingURL=chunk-BG5QUQFR.js.map