@ai-matrx/content-ir 0.11.7 → 0.13.0

package/dist/source.js

@@ -0,0 +1,1653 @@
+// source/offsets.ts
+function isHigh(code) {
+  return code >= 55296 && code <= 56319;
+}
+function isLow(code) {
+  return code >= 56320 && code <= 57343;
+}
+function splitsSurrogatePair(text, offset) {
+  if (offset <= 0 || offset >= text.length) return false;
+  return isHigh(text.charCodeAt(offset - 1)) && isLow(text.charCodeAt(offset));
+}
+function buildCodePointIndex(text) {
+  const pairStarts = [];
+  for (let i = 0; i < text.length - 1; i++) {
+    if (isHigh(text.charCodeAt(i)) && isLow(text.charCodeAt(i + 1))) {
+      pairStarts.push(i);
+      i++;
+    }
+  }
+  const countBelow = (limit) => {
+    let lo = 0;
+    let hi = pairStarts.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (pairStarts[mid] < limit) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo;
+  };
+  const toCodePoint = (utf16) => {
+    return utf16 - countBelow(utf16 - 1);
+  };
+  const toUtf16 = (codePoint) => {
+    let lo = 0;
+    let hi = pairStarts.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      const start = pairStarts[mid];
+      if (start - mid < codePoint) lo = mid + 1;
+      else hi = mid;
+    }
+    return codePoint + lo;
+  };
+  return {
+    toCodePoint,
+    toUtf16,
+    lengthCp: text.length - pairStarts.length
+  };
+}
+function toCodePointOffset(text, utf16) {
+  return buildCodePointIndex(text).toCodePoint(utf16);
+}
+function toUtf16Offset(text, codePoint) {
+  return buildCodePointIndex(text).toUtf16(codePoint);
+}
+
+// source/constants.ts
+var XML_TAG_BLOCK_NAMES = [
+  "thinking",
+  "think",
+  "reasoning",
+  "info",
+  "task",
+  "database",
+  "private",
+  "plan",
+  "event",
+  "tool",
+  "questionnaire",
+  "flashcards",
+  "cooking_recipe",
+  "timeline",
+  "progress_tracker",
+  "troubleshooting",
+  "resources",
+  "research"
+];
+var THINKING_FAMILY = ["thinking", "think", "reasoning"];
+var ATTRIBUTE_XML_NAMES = [
+  "decision",
+  "artifact",
+  "editor_error",
+  "editor_code_snippet",
+  "audiocite"
+];
+var KNOWN_XML_TAG_NAMES = /* @__PURE__ */ new Set([
+  ...XML_TAG_BLOCK_NAMES,
+  ...ATTRIBUTE_XML_NAMES
+]);
+var ALLOWED_RAW_HTML_TAGS = /* @__PURE__ */ new Set([
+  "img",
+  "a",
+  "br",
+  "hr",
+  "span",
+  "p",
+  "strong",
+  "b",
+  "em",
+  "i",
+  "u",
+  "s",
+  "del",
+  "ins",
+  "sup",
+  "sub",
+  "mark",
+  "kbd",
+  "abbr",
+  "small",
+  "code",
+  "pre",
+  "ul",
+  "ol",
+  "li",
+  "blockquote",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "th",
+  "td",
+  "caption",
+  "colgroup",
+  "col",
+  "figure",
+  "figcaption"
+]);
+var HTML_BLOCK_LEVEL_TAGS = /* @__PURE__ */ new Set([
+  "p",
+  "hr",
+  "ul",
+  "ol",
+  "li",
+  "blockquote",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "th",
+  "td",
+  "caption",
+  "colgroup",
+  "col",
+  "figure",
+  "figcaption"
+]);
+var SPECIAL_CODE_LANGUAGES = /* @__PURE__ */ new Set([
+  "transcript",
+  "tasks",
+  "structured_info",
+  "questionnaire",
+  "flashcards",
+  "cooking_recipe",
+  "mermaid",
+  "svg",
+  "chart",
+  "map",
+  "stats",
+  "diff",
+  "html",
+  "react",
+  "matrx"
+]);
+var CODE_LANGUAGE_ALIASES = {
+  mmd: "mermaid",
+  jsx: "react",
+  tsx: "react"
+};
+var TYPED_JSON_ROOT_KEYS = {
+  quiz_title: "quiz",
+  presentation: "presentation",
+  decision_tree: "decision_tree",
+  comparison: "comparison_table",
+  diagram: "diagram",
+  math_problem: "math_problem",
+  item_presentation: "item_presentation",
+  name: "schema_proposal"
+};
+var TREE_GLYPHS = /[├└│┌┐┘┬┴┤┼─]/;
+var PINNED_ANCHOR_RE = /^<!--@a:([A-Za-z0-9_-]+)-->$/;
+var STRICT_VARIABLE_RE = /^\{\{([a-zA-Z_][a-zA-Z0-9_.]*)\}\}$/;
+var CITE_RE = /^<matrxcite\s+n="(\d+)"\s*\/>/;
+function normalizeFenceLanguage(language) {
+  const lower = language.toLowerCase();
+  return CODE_LANGUAGE_ALIASES[lower] ?? lower;
+}
+
+// source/fence-nesting.ts
+var NESTING_FENCE_LANGUAGES = /* @__PURE__ */ new Set([
+  "markdown",
+  "md",
+  "mdx"
+]);
+function fenceNestsInnerFences(language) {
+  return !!language && NESTING_FENCE_LANGUAGES.has(language.toLowerCase());
+}
+function classifyInnerFenceLine(trimmed, openTicks, nests, nestedDepth) {
+  let ticks = 0;
+  while (ticks < trimmed.length && trimmed[ticks] === "`") ticks++;
+  if (ticks < 3) return "content";
+  const info = trimmed.slice(ticks).trim();
+  if (info === "") {
+    if (ticks < openTicks) return "content";
+    if (nests && nestedDepth > 0) return "close-nested";
+    return "close-outer";
+  }
+  if (nests && ticks >= openTicks && !info.includes("`")) return "open-nested";
+  return "content";
+}
+
+// source/math.ts
+var TEX_SIGNAL = /\\[A-Za-z]+|[\\^_{}=<>+]/;
+var LONE_VARIABLE = /^[A-Za-z](?:'|[0-9])?$/;
+function isSingleDollarMath(content, after) {
+  if (!content || content.length > 400) return false;
+  if (/^\s/.test(content) || /\s$/.test(content)) return false;
+  if (after !== void 0 && /[0-9]/.test(after)) return false;
+  if (LONE_VARIABLE.test(content)) return true;
+  if (/^[0-9]/.test(content)) return /\\[A-Za-z]+|[\\^_{}]/.test(content);
+  return TEX_SIGNAL.test(content);
+}
+function singleDollarMathEnd(text, open, limit = text.length) {
+  const bound = Math.min(limit, open + 403);
+  let close = -1;
+  for (let k = open + 1; k < bound; k += 1) {
+    const c = text[k];
+    if (c === "\n") break;
+    if (c === "\\") {
+      k += 1;
+      continue;
+    }
+    if (c === "$") {
+      close = k;
+      break;
+    }
+  }
+  if (close === -1 || text[close + 1] === "$") return -1;
+  const content = text.slice(open + 1, close);
+  return isSingleDollarMath(content, text[close + 1]) ? close + 1 : -1;
+}
+
+// source/math-pairs.ts
+var MAX_MATH_SPAN = 600;
+var STRUCTURAL_MARKDOWN = /\]\(|https?:\/\/|\*\*|(?:^|\n)[ \t]{0,3}#{1,6}[ \t]|(?:^|\n)[ \t]*[-*+][ \t]+|(?:^|\n)[ \t]*\d+[.)][ \t]/;
+var LATEX_COMMAND = /\\[a-zA-Z]/;
+var PROSE_WORD = /[A-Za-z]{3,}/g;
+var PROSE_WORD_LIMIT = 6;
+function looksLikeDisplayMath(inner) {
+  const s = inner.trim();
+  if (!s) return false;
+  if (STRUCTURAL_MARKDOWN.test(s)) return false;
+  if (s.length > MAX_MATH_SPAN) return false;
+  if (LATEX_COMMAND.test(s)) {
+    return (s.match(PROSE_WORD) ?? []).length < PROSE_WORD_LIMIT * 3;
+  }
+  if (/\n[ \t]*\n/.test(s)) return false;
+  return (s.match(PROSE_WORD) ?? []).length < PROSE_WORD_LIMIT;
+}
+function codeRanges(text) {
+  const ranges = [];
+  for (const re of [/```[\s\S]*?(?:```|$)/g, /~~~[\s\S]*?(?:~~~|$)/g, /`[^`\n]*`/g]) {
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      ranges.push([m.index, m.index + m[0].length]);
+      if (m[0].length === 0) re.lastIndex++;
+    }
+  }
+  return ranges.sort((a, b) => a[0] - b[0]);
+}
+function pairDisplayMath(text) {
+  const pairs = /* @__PURE__ */ new Map();
+  if (!text.includes("$$")) return pairs;
+  const ranges = codeRanges(text);
+  const tokens = [];
+  let r = 0;
+  let maxEnd = -1;
+  for (let i = text.indexOf("$$"); i !== -1 && i < text.length - 1; i = text.indexOf("$$", i)) {
+    while (r < ranges.length && ranges[r][0] <= i) {
+      maxEnd = Math.max(maxEnd, ranges[r][1]);
+      r++;
+    }
+    if (maxEnd <= i) tokens.push(i);
+    i += 2;
+  }
+  let j = 0;
+  while (j < tokens.length) {
+    const open = tokens[j];
+    const close = tokens[j + 1];
+    if (close === void 0) break;
+    if (looksLikeDisplayMath(text.slice(open + 2, close))) {
+      pairs.set(open, close);
+      j += 2;
+      continue;
+    }
+    j += 1;
+  }
+  return pairs;
+}
+
+// source/xml-tag.ts
+var XML_NAME_START = /[A-Za-z_]/;
+var XML_NAME_CHARACTER = /[\w.:-]/;
+var WHITESPACE = /\s/;
+function readXmlTag(content, start, find = (needle, from) => content.indexOf(needle, from)) {
+  let cursor = start + 1;
+  const isClosing = content[cursor] === "/";
+  if (isClosing) cursor++;
+  if (!XML_NAME_START.test(content[cursor] ?? "")) return null;
+  const nameStart = cursor;
+  while (XML_NAME_CHARACTER.test(content[cursor] ?? "")) cursor++;
+  const tagName = content.slice(nameStart, cursor);
+  const attributes = [];
+  if (isClosing) {
+    while (WHITESPACE.test(content[cursor] ?? "")) cursor++;
+    if (content[cursor] !== ">") return null;
+    return {
+      tagName,
+      raw: content.slice(start, cursor + 1),
+      isClosing,
+      isSelfClosing: false,
+      attributes
+    };
+  }
+  while (cursor < content.length) {
+    while (WHITESPACE.test(content[cursor] ?? "")) cursor++;
+    if (content[cursor] === ">")
+      return {
+        tagName,
+        raw: content.slice(start, cursor + 1),
+        isClosing,
+        isSelfClosing: false,
+        attributes
+      };
+    if (content[cursor] === "/") {
+      cursor++;
+      while (WHITESPACE.test(content[cursor] ?? "")) cursor++;
+      if (content[cursor] !== ">") return null;
+      return {
+        tagName,
+        raw: content.slice(start, cursor + 1),
+        isClosing,
+        isSelfClosing: true,
+        attributes
+      };
+    }
+    if (!XML_NAME_START.test(content[cursor] ?? "")) return null;
+    const attributeStart = cursor;
+    while (XML_NAME_CHARACTER.test(content[cursor] ?? "")) cursor++;
+    const name = content.slice(attributeStart, cursor);
+    while (WHITESPACE.test(content[cursor] ?? "")) cursor++;
+    if (content[cursor] !== "=") return null;
+    cursor++;
+    while (WHITESPACE.test(content[cursor] ?? "")) cursor++;
+    const quote = content[cursor];
+    if (quote !== '"' && quote !== "'") return null;
+    const valueStart = ++cursor;
+    const valueEnd = find(quote, valueStart);
+    if (valueEnd === -1) return null;
+    cursor = valueEnd;
+    attributes.push({ name, value: content.slice(valueStart, cursor) });
+    cursor++;
+  }
+  return null;
+}
+function isEscapedBacktick(line, offset) {
+  let slashes = 0;
+  for (let i = offset - 1; line[i] === "\\"; i--) slashes++;
+  return slashes % 2 === 1;
+}
+var XmlContainerTracker = class {
+  constructor(rootTag) {
+    this.rootTag = rootTag;
+  }
+  rootTag;
+  depth = 0;
+  inComment = false;
+  inCdata = false;
+  inlineTicks = 0;
+  fenceMarker = null;
+  consumeLine(line, startOffset = 0) {
+    const fence = /^[ \t]*(`{3,}|~{3,})(.*)$/.exec(line);
+    if (!this.inComment && !this.inCdata && this.inlineTicks === 0 && fence) {
+      const marker = fence[1];
+      const char = marker[0];
+      const suffix = fence[2];
+      if (marker.length >= 3) {
+        if (!this.fenceMarker) {
+          this.fenceMarker = { char, ticks: marker.length };
+          return null;
+        }
+        if (char === this.fenceMarker.char && marker.length >= this.fenceMarker.ticks && suffix.trim() === "") {
+          this.fenceMarker = null;
+        }
+        return null;
+      }
+    }
+    if (this.fenceMarker) return null;
+    for (let i = startOffset; i < line.length; i++) {
+      if (this.inlineTicks > 0) {
+        if (line[i] === "`") {
+          let end = i;
+          while (line[end] === "`") end++;
+          if (end - i === this.inlineTicks) this.inlineTicks = 0;
+          i = end - 1;
+        }
+        continue;
+      }
+      if (this.inComment) {
+        const end = line.indexOf("-->", i);
+        if (end === -1) return null;
+        this.inComment = false;
+        i = end + 2;
+        continue;
+      }
+      if (this.inCdata) {
+        const end = line.indexOf("]]>", i);
+        if (end === -1) return null;
+        this.inCdata = false;
+        i = end + 2;
+        continue;
+      }
+      if (line.startsWith("<!--", i)) {
+        this.inComment = true;
+        i += 3;
+        continue;
+      }
+      if (line.startsWith("<![CDATA[", i)) {
+        this.inCdata = true;
+        i += 8;
+        continue;
+      }
+      if (line[i] === "`" && !isEscapedBacktick(line, i)) {
+        let end = i;
+        while (line[end] === "`") end++;
+        this.inlineTicks = end - i;
+        i = end - 1;
+        continue;
+      }
+      if (line[i] !== "<") continue;
+      const tag = readXmlTag(line, i);
+      if (!tag) continue;
+      const tagEnd = i + tag.raw.length;
+      if (tag.tagName === this.rootTag) {
+        if (tag.isClosing) this.depth--;
+        else if (!tag.isSelfClosing) this.depth++;
+        if (this.depth === 0) return tagEnd;
+      }
+      i = tagEnd - 1;
+    }
+    return null;
+  }
+};
+
+// source/tokenize.ts
+var NOT_WHITESPACE = /\S/;
+function countStructuralBraces(source) {
+  let opens = 0;
+  let closes = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < source.length; i++) {
+    const char = source[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') inString = true;
+    else if (char === "{") opens++;
+    else if (char === "}") closes++;
+  }
+  return { opens, closes };
+}
+function firstJsonKey(content) {
+  const match = /^\{\s*"([^"]+)"/.exec(content.trimStart());
+  return match ? match[1] : null;
+}
+function jsonMeta(content) {
+  const meta = {};
+  const key = firstJsonKey(content);
+  if (key) meta.firstKey = key;
+  try {
+    const parsed = JSON.parse(content.trim());
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      const kind = parsed.__kind;
+      if (typeof kind === "string" && kind.trim()) meta.kind = kind;
+    }
+  } catch {
+    const head = /^\{\s*"__kind"\s*:\s*"([^"]*)"/.exec(content.trimStart());
+    if (head) meta.kind = head[1];
+  }
+  if (typeof meta.kind === "string" && meta.kind.startsWith("directive_v")) {
+    meta.directive = true;
+  }
+  if (key === "matrx_version") meta.directive = true;
+  if (key && TYPED_JSON_ROOT_KEYS[key]) meta.typed = TYPED_JSON_ROOT_KEYS[key];
+  return meta;
+}
+function isRecognizedJsonHead(content) {
+  const key = firstJsonKey(content);
+  if (!key) return false;
+  return key === "__kind" || key === "matrx_version" || key in TYPED_JSON_ROOT_KEYS;
+}
+function matchingJsonObjectEnd(source, start, limit) {
+  if (source[start] !== "{") return null;
+  const stack = ["{"];
+  let inString = false;
+  let escaped = false;
+  for (let index = start + 1; index < limit; index++) {
+    const char = source[index];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "{" || char === "[") {
+      stack.push(char);
+      continue;
+    }
+    if (char !== "}" && char !== "]") continue;
+    const opening = stack.pop();
+    if (char === "}" && opening !== "{" || char === "]" && opening !== "[") return null;
+    if (stack.length === 0) return index + 1;
+  }
+  return null;
+}
+function declaredKind(candidate) {
+  try {
+    const parsed = JSON.parse(candidate);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+    const kind = parsed.__kind;
+    return typeof kind === "string" && kind.trim() ? kind : null;
+  } catch {
+    return null;
+  }
+}
+function isUnclosedGenericXmlOpening(source) {
+  const text = source.trimStart();
+  const prefix = /^<([A-Za-z_][\w.:-]*)(?=\s|\/|$)/.exec(text);
+  if (!prefix || KNOWN_XML_TAG_NAMES.has(prefix[1]) || ALLOWED_RAW_HTML_TAGS.has(prefix[1].toLowerCase()))
+    return false;
+  let quote = null;
+  for (let i = prefix[0].length; i < text.length; i++) {
+    if (quote) {
+      if (text[i] === quote) quote = null;
+    } else if (text[i] === "'" || text[i] === '"') quote = text[i];
+    else if (text[i] === ">") return false;
+  }
+  return true;
+}
+function jsonStringState(line, from, upTo, state) {
+  let { inString, escaped } = state;
+  for (let idx = from; idx < upTo; idx++) {
+    const ch = line[idx];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') inString = !inString;
+  }
+  return { inString, escaped };
+}
+function backtickRunLength(str, pos) {
+  let n = 0;
+  while (pos + n < str.length && str[pos + n] === "`") n++;
+  return n;
+}
+function isSplitterTreeLine(line) {
+  return TREE_GLYPHS.test(line) || /^[\s│|]*[├└+|][\s─\-]+/.test(line);
+}
+var MEDIA_REF_PREFIXES = ["[Image URL:", "[Video URL:", "[Audio URL:"];
+var Tokenizer = class {
+  constructor(text) {
+    this.text = text;
+    this.n = text.length;
+    this.mathPairs = pairDisplayMath(text);
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+      if (text.charCodeAt(i) === 10) {
+        this.lineStarts.push(start);
+        this.contentEnds.push(i > start && text.charCodeAt(i - 1) === 13 ? i - 1 : i);
+        this.lineEnds.push(i + 1);
+        start = i + 1;
+      }
+    }
+    if (start < text.length || text.length === 0) {
+      this.lineStarts.push(start);
+      this.contentEnds.push(text.length);
+      this.lineEnds.push(text.length);
+    }
+  }
+  text;
+  n;
+  lineStarts = [];
+  contentEnds = [];
+  lineEnds = [];
+  blocks = [];
+  blockCache = /* @__PURE__ */ new Map();
+  /** Lazily built: for line i, first line j >= i where brace net from i drops to <= 0. */
+  braceStop = null;
+  braceNet = null;
+  /** Every occurrence offset of each needle searched so far (overlapping, like indexOf). */
+  occurrences = /* @__PURE__ */ new Map();
+  /** `$$` opener → closer for the pairs the core renders as math. */
+  mathPairs;
+  finder = (needle, from) => this.next(needle, from);
+  /**
+   * `text.indexOf(needle, from)` in O(log k): the first query for a needle
+   * indexes all of its occurrences once, so repeated searches for a closer
+   * that never comes stay linear over the whole text.
+   */
+  next(needle, from) {
+    let list = this.occurrences.get(needle);
+    if (!list) {
+      list = [];
+      for (let at = this.text.indexOf(needle); at !== -1; at = this.text.indexOf(needle, at + 1)) {
+        list.push(at);
+      }
+      this.occurrences.set(needle, list);
+    }
+    let lo = 0;
+    let hi = list.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (list[mid] < from) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo < list.length ? list[lo] : -1;
+  }
+  get lineCount() {
+    return this.lineStarts.length;
+  }
+  lineOf(pos) {
+    let lo = 0;
+    let hi = this.lineStarts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      if (this.lineStarts[mid] <= pos) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo;
+  }
+  isBlank(from, to) {
+    return !NOT_WHITESPACE.test(this.text.slice(from, to));
+  }
+  lineIsBlank(li) {
+    return this.isBlank(this.lineStarts[li], this.contentEnds[li]);
+  }
+  lineText(li) {
+    return this.text.slice(this.lineStarts[li], this.contentEnds[li]);
+  }
+  run() {
+    let pos = 0;
+    while (pos < this.n) {
+      const li = this.lineOf(pos);
+      const ce = this.contentEnds[li];
+      if (this.isBlank(pos, ce)) {
+        pos = this.gap(pos, li);
+        continue;
+      }
+      const island = this.detectBlock(pos, li, true);
+      if (island) {
+        this.push({ kind: "island", start: island.start, end: island.end, island, inlines: [] });
+        pos = island.end;
+        continue;
+      }
+      pos = this.paragraph(pos, li);
+    }
+    return this.blocks;
+  }
+  push(block) {
+    if (block.end <= block.start) return;
+    if (block.kind === "prose" && this.isBlank(block.start, block.end)) {
+      block = { kind: "gap", start: block.start, end: block.end, island: null, inlines: [] };
+    }
+    const last = this.blocks[this.blocks.length - 1];
+    if (block.kind === "gap" && last && last.kind === "gap" && last.end === block.start) {
+      last.end = block.end;
+      return;
+    }
+    this.blocks.push(block);
+  }
+  gap(pos, li) {
+    let end = this.lineEnds[li];
+    let k = li + 1;
+    while (k < this.lineCount && this.lineIsBlank(k)) {
+      end = this.lineEnds[k];
+      k++;
+    }
+    this.push({ kind: "gap", start: pos, end, island: null, inlines: [] });
+    return end;
+  }
+  // ── block detection ────────────────────────────────────────────────────
+  detectBlock(p, li, atParaStart) {
+    const cacheKey = atParaStart ? -1 - p : p;
+    if (this.blockCache.has(cacheKey)) return this.blockCache.get(cacheKey) ?? null;
+    const found = this.detectBlockUncached(p, li, atParaStart);
+    this.blockCache.set(cacheKey, found);
+    return found;
+  }
+  detectBlockUncached(p, li, atParaStart) {
+    const ce = this.contentEnds[li];
+    const seg = this.text.slice(p, ce);
+    const t = seg.trimStart();
+    const indent = seg.length - t.length;
+    const tp = p + indent;
+    if (p === 0) {
+      const fm = this.frontMatter(li, t);
+      if (fm) return fm;
+    }
+    if (t.startsWith("```")) return this.backtickFence(p, li, t);
+    if (indent <= 3 && t.startsWith("~~~")) {
+      const tilde = this.tildeFence(p, li, t);
+      if (tilde) return tilde;
+    }
+    if (t.startsWith("$$")) {
+      const math = this.mathBlock(p, tp);
+      if (math) return math;
+    }
+    if (t.startsWith("<")) {
+      const attr = this.attributeXml(p, tp, t);
+      if (attr) return attr;
+      const region = this.xmlRegion(p, tp, t);
+      if (region) return region;
+      const container = this.genericXml(p, li, seg, indent);
+      if (container) return container;
+      if (t.startsWith("<!--")) {
+        const comment = this.blockComment(p, tp, li);
+        if (comment) return comment;
+      }
+      const html = this.htmlBlock(p, li, t, tp, atParaStart);
+      if (html) return html;
+    }
+    if (t.startsWith("{")) {
+      const json = this.bareJson(p, li, tp);
+      if (json) return json;
+    }
+    if (TREE_GLYPHS.test(t)) {
+      const tree = this.tree(p, li);
+      if (tree) return tree;
+    }
+    return null;
+  }
+  island(type, start, end, complete, meta = {}) {
+    return { type, start, end, complete, meta };
+  }
+  frontMatter(li, t) {
+    if (this.lineText(li) !== "---" || t !== "---") return null;
+    let sawContent = false;
+    for (let k = li + 1; k < this.lineCount; k++) {
+      const line = this.lineText(k);
+      if (line === "---" || line === "...") {
+        return sawContent ? this.island("front_matter", 0, this.contentEnds[k], true) : null;
+      }
+      if (!NOT_WHITESPACE.test(line)) continue;
+      if (!/^(?:[A-Za-z0-9_"'-][^:]*:(?:\s|$)|\s+\S|-\s)/.test(line)) return null;
+      sawContent = true;
+    }
+    return null;
+  }
+  /**
+   * Backtick fence — the renderer splitter's close rules: JSON-string aware for
+   * ```json, and THE nested-fence rule (source/fence-nesting.ts) for markdown
+   * fences, with the splitter's strict-CommonMark retry when a nested fence is
+   * still open at the end of the text.
+   */
+  backtickFence(p, li, t) {
+    const openTicks = backtickRunLength(t, 0);
+    const info = t.slice(openTicks).trim();
+    const lang = info.split(/\s/)[0] ?? "";
+    const isJson = lang === "json";
+    const normalized = normalizeFenceLanguage(lang);
+    const meta = { fence: "`", ticks: openTicks, lang };
+    if (normalized && SPECIAL_CODE_LANGUAGES.has(normalized)) meta.special = normalized;
+    const nesting = fenceNestsInnerFences(lang);
+    let close = this.backtickFenceClose(li, openTicks, isJson, nesting);
+    if (close === "retry-strict") close = this.backtickFenceClose(li, openTicks, isJson, false);
+    if (typeof close === "number") {
+      return this.fenceIsland(p, this.contentEnds[close], true, meta, li, close, isJson);
+    }
+    return this.fenceIsland(p, this.n, false, meta, li, this.lineCount, isJson);
+  }
+  /** The closing line of a backtick fence opened on line `li`, or null when it never closes. */
+  backtickFenceClose(li, openTicks, isJson, nesting) {
+    let state = { inString: false, escaped: false };
+    let nestedDepth = 0;
+    let sawNested = false;
+    for (let k = li + 1; k < this.lineCount; k++) {
+      const line = this.lineText(k);
+      const trimmedLine = line.trim();
+      if (trimmedLine.startsWith("```")) {
+        const at2 = line.indexOf("```");
+        if (isJson) {
+          const probe = jsonStringState(line, 0, at2, state);
+          if (probe.inString) {
+            state = jsonStringState(line, at2, line.length, probe);
+            continue;
+          }
+        }
+        const kind = classifyInnerFenceLine(trimmedLine, openTicks, nesting, nestedDepth);
+        if (kind === "close-outer") return k;
+        if (kind === "open-nested") {
+          nestedDepth++;
+          sawNested = true;
+        }
+        if (kind === "close-nested") nestedDepth--;
+        if (isJson) state = jsonStringState(line, 0, line.length, state);
+        continue;
+      }
+      const at = line.indexOf("```");
+      if (at !== -1) {
+        if (isJson) {
+          const probe = jsonStringState(line, 0, at, state);
+          if (probe.inString) {
+            state = jsonStringState(line, at, line.length, probe);
+            continue;
+          }
+        }
+        const closeTicks = backtickRunLength(line, at);
+        const after = line.slice(at + closeTicks).trim();
+        if (closeTicks >= openTicks && after === "" && nestedDepth === 0) return k;
+        if (isJson) state = jsonStringState(line, 0, line.length, state);
+        continue;
+      }
+      if (isJson) state = jsonStringState(line, 0, line.length, state);
+    }
+    return sawNested && nestedDepth > 0 ? "retry-strict" : null;
+  }
+  fenceIsland(p, end, complete, meta, openLine, closeLine, isJson) {
+    if (isJson && openLine + 1 < this.lineCount) {
+      const bodyEnd = closeLine < this.lineCount ? this.lineStarts[closeLine] : this.n;
+      const body = this.text.slice(this.lineStarts[openLine + 1], Math.max(bodyEnd, this.lineStarts[openLine + 1]));
+      if (body.trimStart().startsWith("{")) Object.assign(meta, jsonMeta(body));
+    }
+    return this.island("fence", p, end, complete, meta);
+  }
+  tildeFence(p, li, t) {
+    const open = /^(~{3,})(.*)$/.exec(t);
+    if (!open) return null;
+    const ticks = open[1].length;
+    const lang = open[2].trim().split(/\s/)[0] ?? "";
+    const meta = { fence: "~", ticks, lang };
+    const normalized = normalizeFenceLanguage(lang);
+    if (normalized && SPECIAL_CODE_LANGUAGES.has(normalized)) meta.special = normalized;
+    const close = new RegExp(`^ {0,3}~{${ticks},}[ \\t]*$`);
+    for (let k = li + 1; k < this.lineCount; k++) {
+      if (close.test(this.lineText(k))) {
+        return this.island("fence", p, this.contentEnds[k], true, meta);
+      }
+    }
+    return this.island("fence", p, this.n, false, meta);
+  }
+  /**
+   * A line-leading `$$` that OPENS a math pair (source/math-pairs.ts — the
+   * core's rule). A closer, an unpaired `$$`, or a prose pair is never a block:
+   * a lone `$$` renders as literal text and locks nothing.
+   */
+  mathBlock(p, tp) {
+    const close = this.mathPairs.get(tp);
+    if (close === void 0) return null;
+    const end = close + 2;
+    const li = this.lineOf(tp);
+    const ce = this.contentEnds[li];
+    if (end <= ce && !this.isBlank(end, ce)) return null;
+    const endLine = this.lineOf(close);
+    const endCe = this.contentEnds[endLine];
+    if (endLine !== li && !this.isBlank(end, endCe)) return null;
+    return this.island("math_block", p, end, true, { delimiter: "$$" });
+  }
+  /** `<artifact …>`, `<decision …>`, … at the start of a line. */
+  attributeXml(p, tp, t) {
+    for (const name of ATTRIBUTE_XML_NAMES) {
+      const prefix = `<${name}`;
+      if (!t.startsWith(prefix)) continue;
+      const next = t[prefix.length];
+      if (next !== " " && next !== ">" && next !== "/" && next !== "	") continue;
+      return this.attributeElement(name, p, tp, "xml_attr");
+    }
+    return null;
+  }
+  /** Opening tag at `tp` through its `</name>` (or to EOF when still streaming). */
+  attributeElement(name, p, tp, type) {
+    const li = this.lineOf(tp);
+    const ce = this.contentEnds[li];
+    const tag = readXmlTag(this.text, tp, this.finder);
+    let openEnd;
+    if (tag && !tag.isClosing) {
+      if (tag.isSelfClosing) {
+        return this.island(type, p, tp + tag.raw.length, true, { tag: name, selfClosing: true });
+      }
+      openEnd = tp + tag.raw.length;
+    } else {
+      const gt = this.next(">", tp);
+      if (gt === -1) return this.island(type, p, this.n, false, { tag: name });
+      if (gt >= ce) return null;
+      openEnd = gt + 1;
+    }
+    const closer = `</${name}>`;
+    const close = this.next(closer, openEnd);
+    if (close === -1) return this.island(type, p, this.n, false, { tag: name });
+    return this.island(type, p, close + closer.length, true, { tag: name });
+  }
+  /** `<thinking>`, `<flashcards>`, … — exact attribute-less openers. */
+  xmlRegion(p, tp, t) {
+    for (const name of XML_TAG_BLOCK_NAMES) {
+      const opener = `<${name}>`;
+      if (!t.startsWith(opener)) continue;
+      const closer = `</${name}>`;
+      const close = this.next(closer, tp + opener.length);
+      if (close === -1) return this.island("xml_region", p, this.n, false, { tag: name });
+      return this.island("xml_region", p, close + closer.length, true, { tag: name });
+    }
+    return null;
+  }
+  /** Line-leading unknown XML element — balanced by the renderer's own tracker. */
+  genericXml(p, li, seg, indent) {
+    const first = seg.slice(indent);
+    const opening = readXmlTag(first, 0);
+    if (opening && !opening.isClosing) {
+      const root = opening.tagName;
+      if (KNOWN_XML_TAG_NAMES.has(root) || ALLOWED_RAW_HTML_TAGS.has(root.toLowerCase())) {
+        return null;
+      }
+      const tracker = new XmlContainerTracker(root);
+      const firstEnd = tracker.consumeLine(seg, indent);
+      if (firstEnd !== null) {
+        return this.island("xml_container", p, p + firstEnd, true, { tag: root });
+      }
+      for (let k = li + 1; k < this.lineCount; k++) {
+        const end = tracker.consumeLine(this.lineText(k));
+        if (end !== null) {
+          return this.island("xml_container", p, this.lineStarts[k] + end, true, {
+            tag: root
+          });
+        }
+      }
+      return this.island("xml_container", p, this.n, false, { tag: root });
+    }
+    if (isUnclosedGenericXmlOpening(seg)) {
+      return this.island("xml_container", p, this.n, false, {});
+    }
+    return null;
+  }
+  blockComment(p, tp, li) {
+    const close = this.next("-->", tp + 4);
+    if (close === -1) return this.island("html_comment", p, this.n, false);
+    const end = close + 3;
+    const raw = this.text.slice(tp, end);
+    const anchor = PINNED_ANCHOR_RE.exec(raw);
+    const ce = this.contentEnds[li];
+    if (anchor) {
+      if (end <= ce && !this.isBlank(end, ce)) return null;
+      return this.island("anchor", p, end, true, { id: anchor[1] });
+    }
+    return this.island("html_comment", p, end, true);
+  }
+  htmlBlock(p, li, t, tp, atParaStart) {
+    const tag = readXmlTag(t, 0);
+    if (!tag) return null;
+    const name = tag.tagName.toLowerCase();
+    if (!ALLOWED_RAW_HTML_TAGS.has(name)) return null;
+    if (name === "pre" && !tag.isClosing) {
+      const closer = /<\/pre\s*>/gi;
+      closer.lastIndex = tp;
+      const close = closer.exec(this.text);
+      if (!close) return this.island("html_block", p, this.n, false, { tag: name });
+      return this.island("html_block", p, close.index + close[0].length, true, { tag: name });
+    }
+    const typeSix = HTML_BLOCK_LEVEL_TAGS.has(name);
+    const typeSeven = atParaStart && t.trimEnd() === tag.raw;
+    if (!typeSix && !typeSeven) return null;
+    let end = this.contentEnds[li];
+    for (let k = li + 1; k < this.lineCount && !this.lineIsBlank(k); k++) {
+      end = this.contentEnds[k];
+    }
+    return this.island("html_block", p, end, true, { tag: name });
+  }
+  buildBraceTables() {
+    const count = this.lineCount;
+    const prefix = new Int32Array(count + 1);
+    for (let i = 0; i < count; i++) {
+      const { opens, closes } = countStructuralBraces(this.lineText(i));
+      prefix[i + 1] = prefix[i] + opens - closes;
+    }
+    const stop = new Int32Array(count).fill(-1);
+    const stack = [];
+    for (let m = 0; m <= count; m++) {
+      const value = prefix[m];
+      while (stack.length && prefix[stack[stack.length - 1]] >= value) {
+        const i = stack.pop();
+        if (i < count) stop[i] = m - 1;
+      }
+      stack.push(m);
+    }
+    this.braceNet = prefix;
+    this.braceStop = stop;
+  }
+  /** A line-leading bare JSON object — the splitter's structural brace walk. */
+  bareJson(p, li, tp) {
+    let lastLine = null;
+    let net = 0;
+    if (p === this.lineStarts[li]) {
+      if (!this.braceStop || !this.braceNet) this.buildBraceTables();
+      const stop = this.braceStop[li];
+      if (stop !== -1) {
+        lastLine = stop;
+        net = this.braceNet[stop + 1] - this.braceNet[li];
+      }
+    } else {
+      let running = 0;
+      for (let k = li; k < this.lineCount; k++) {
+        const line = k === li ? this.text.slice(tp, this.contentEnds[li]) : this.lineText(k);
+        const { opens, closes } = countStructuralBraces(line);
+        running += opens - closes;
+        if (running <= 0) {
+          lastLine = k;
+          net = running;
+          break;
+        }
+      }
+    }
+    if (lastLine === null) {
+      if (isRecognizedJsonHead(this.text.slice(tp, tp + 512))) {
+        return this.island("json", p, this.n, false, jsonMeta(this.text.slice(tp)));
+      }
+      return null;
+    }
+    if (net !== 0) return null;
+    const end = this.contentEnds[lastLine];
+    const content = this.text.slice(tp, end).trim();
+    try {
+      const parsed = JSON.parse(content);
+      if (parsed === null || typeof parsed !== "object") return null;
+    } catch {
+      return null;
+    }
+    return this.island("json", p, end, true, jsonMeta(content));
+  }
+  tree(p, li) {
+    let treeLines = 0;
+    let lastTree = li;
+    let k = li;
+    while (k < this.lineCount) {
+      if (this.lineIsBlank(k)) {
+        k++;
+        continue;
+      }
+      if (!TREE_GLYPHS.test(this.lineText(k))) break;
+      treeLines++;
+      lastTree = k;
+      k++;
+    }
+    if (treeLines < 3) return null;
+    return this.island("tree", p, this.contentEnds[lastTree], true);
+  }
+  // ── prose ──────────────────────────────────────────────────────────────
+  paragraph(pos, li) {
+    let end = this.contentEnds[li];
+    let breakLine = -1;
+    for (let k = li + 1; k < this.lineCount; k++) {
+      if (this.lineIsBlank(k)) break;
+      if (this.detectBlock(this.lineStarts[k], k, false)) {
+        breakLine = k;
+        break;
+      }
+      end = this.contentEnds[k];
+    }
+    if (breakLine !== -1) {
+      const breakIsland = this.detectBlock(this.lineStarts[breakLine], breakLine, false);
+      if (breakIsland?.type === "tree") {
+        let root = breakLine;
+        for (let j = breakLine - 1; j >= li; j--) {
+          const trimmed = this.lineText(j).trim();
+          if (!trimmed || isSplitterTreeLine(trimmed) || /^#{1,6}\s/.test(trimmed)) break;
+          root = j;
+        }
+        if (root < breakLine) {
+          const treeStart = root === li ? pos : this.lineStarts[root];
+          const tree = { ...breakIsland, start: treeStart };
+          if (treeStart > pos) {
+            const proseEnd = this.contentEnds[root - 1];
+            const scan2 = this.scanInline(pos, proseEnd);
+            if (!scan2.breakIsland) {
+              this.push({ kind: "prose", start: pos, end: proseEnd, island: null, inlines: scan2.inlines });
+              this.push({ kind: "gap", start: proseEnd, end: treeStart, island: null, inlines: [] });
+              this.push({ kind: "island", start: treeStart, end: tree.end, island: tree, inlines: [] });
+              return tree.end;
+            }
+          } else {
+            this.push({ kind: "island", start: treeStart, end: tree.end, island: tree, inlines: [] });
+            return tree.end;
+          }
+        }
+      }
+    }
+    const scan = this.scanInline(pos, end);
+    if (!scan.breakIsland) {
+      this.push({ kind: "prose", start: pos, end, island: null, inlines: scan.inlines });
+      return end;
+    }
+    const br = scan.breakIsland;
+    if (scan.orphan) {
+      let start = pos;
+      while (this.blocks.length) {
+        const last = this.blocks[this.blocks.length - 1];
+        if (last.kind === "island") break;
+        this.blocks.pop();
+        start = last.start;
+      }
+      const island = { ...br, start };
+      this.push({ kind: "island", start, end: island.end, island, inlines: [] });
+      return island.end;
+    }
+    this.push({
+      kind: "prose",
+      start: pos,
+      end: br.start,
+      island: null,
+      inlines: scan.inlines.filter((inline) => inline.end <= br.start)
+    });
+    this.push({ kind: "island", start: br.start, end: br.end, island: br, inlines: [] });
+    return br.end;
+  }
+  scanInline(ps, pe) {
+    const text = this.text;
+    const inlines = [];
+    const hasKind = text.slice(ps, pe).includes("__kind");
+    let kindBudget = 4 * (pe - ps) + 65536;
+    const stop = (island, orphan = false) => ({ inlines, breakIsland: island, orphan });
+    const within = (needle, from) => {
+      const at = this.next(needle, from);
+      return at !== -1 && at + needle.length <= pe ? at : -1;
+    };
+    let runs = null;
+    const codeSpanClose = (n, from) => {
+      if (!runs) {
+        runs = /* @__PURE__ */ new Map();
+        for (let k = ps; k < pe; ) {
+          if (text.charCodeAt(k) !== 96) {
+            k++;
+            continue;
+          }
+          const len = backtickRunLength(text, k);
+          const list2 = runs.get(len);
+          if (list2) list2.push(k);
+          else runs.set(len, [k]);
+          k += len;
+        }
+      }
+      const list = runs.get(n);
+      if (!list) return -1;
+      let lo = 0;
+      let hi = list.length;
+      while (lo < hi) {
+        const mid = lo + hi >>> 1;
+        if (list[mid] < from) lo = mid + 1;
+        else hi = mid;
+      }
+      const at = list[lo];
+      return at !== void 0 && at + n <= pe ? at : -1;
+    };
+    let i = ps;
+    while (i < pe) {
+      const ch = text[i];
+      if (ch === "\\") {
+        const nextCh = text[i + 1];
+        if (nextCh === "(" || nextCh === "[") {
+          const close = within(nextCh === "(" ? "\\)" : "\\]", i + 2);
+          if (close !== -1) {
+            inlines.push(this.island("math_inline", i, close + 2, true, { delimiter: nextCh === "(" ? "\\(" : "\\[" }));
+            i = close + 2;
+            continue;
+          }
+        }
+        i += 2;
+        continue;
+      }
+      if (ch === "`") {
+        const n = backtickRunLength(text, i);
+        const close = codeSpanClose(n, i + n);
+        i = close === -1 ? i + n : close + n;
+        continue;
+      }
+      if (ch === "$") {
+        if (text[i + 1] === "$") {
+          const close = this.mathPairs.get(i);
+          if (close === void 0) {
+            i += 2;
+            continue;
+          }
+          if (close + 2 > pe) return stop(this.island("math_block", i, close + 2, true, { delimiter: "$$" }));
+          inlines.push(this.island("math_inline", i, close + 2, true, { delimiter: "$$" }));
+          i = close + 2;
+          continue;
+        }
+        const end = singleDollarMathEnd(text, i, pe);
+        if (end > 0) {
+          inlines.push(this.island("math_inline", i, end, true, { delimiter: "$" }));
+          i = end;
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (ch === "{") {
+        if (text[i + 1] === "{") {
+          const close = this.next("}}", i + 2);
+          if (close !== -1 && close + 2 <= pe && close - i <= 200 && !text.slice(i, close).includes("\n")) {
+            const raw = text.slice(i, close + 2);
+            const strict = STRICT_VARIABLE_RE.exec(raw);
+            inlines.push(
+              this.island("variable", i, close + 2, true, strict ? { name: strict[1] } : { template: true })
+            );
+            i = close + 2;
+            continue;
+          }
+          i += 2;
+          continue;
+        }
+        if (hasKind && kindBudget > 0 && /^\{\s*"/.test(text.slice(i, i + 64))) {
+          const limit = Math.min(pe, i + 65536);
+          const end = matchingJsonObjectEnd(text, i, limit);
+          kindBudget -= (end ?? limit) - i;
+          if (end !== null) {
+            const kind = declaredKind(text.slice(i, end));
+            if (kind) {
+              inlines.push(this.island("kind_json", i, end, true, jsonMeta(text.slice(i, end))));
+              i = end;
+              continue;
+            }
+          }
+        }
+        i++;
+        continue;
+      }
+      if (ch === "[") {
+        const media = MEDIA_REF_PREFIXES.find((prefix) => text.startsWith(prefix, i));
+        if (media) {
+          const close = within("]", i + media.length);
+          const newline = this.next("\n", i);
+          if (close !== -1 && (newline === -1 || newline > close)) {
+            inlines.push(this.island("media_ref", i, close + 1, true, { media: media.slice(1, 6).toLowerCase() }));
+            i = close + 1;
+            continue;
+          }
+        }
+        i++;
+        continue;
+      }
+      if (ch === "<") {
+        if (text.startsWith("<!--", i)) {
+          const close = this.next("-->", i + 4);
+          if (close === -1) return stop(this.island("html_comment", i, this.n, false));
+          const end = close + 3;
+          const anchor = end - i <= 64 ? PINNED_ANCHOR_RE.exec(text.slice(i, end)) : null;
+          const type = anchor ? "anchor" : "html_comment";
+          const meta = anchor ? { id: anchor[1] } : {};
+          if (end > pe) return stop(this.island(type, i, end, true, meta));
+          inlines.push(this.island(type, i, end, true, meta));
+          i = end;
+          continue;
+        }
+        const cite = CITE_RE.exec(text.slice(i, i + 64));
+        if (cite) {
+          inlines.push(this.island("cite", i, i + cite[0].length, true, { n: Number(cite[1]) }));
+          i += cite[0].length;
+          continue;
+        }
+        const tag = readXmlTag(text, i, this.finder);
+        if (tag && i + tag.raw.length <= pe) {
+          const name = tag.tagName;
+          const tagEnd = i + tag.raw.length;
+          const isAttr = ATTRIBUTE_XML_NAMES.includes(name);
+          const isThinking = THINKING_FAMILY.includes(name) && tag.raw === `<${name}>`;
+          if (!tag.isClosing && (isAttr || isThinking)) {
+            if (tag.isSelfClosing) {
+              inlines.push(this.island("xml_inline", i, tagEnd, true, { tag: name, selfClosing: true }));
+              i = tagEnd;
+              continue;
+            }
+            const closer = `</${name}>`;
+            const close = this.next(closer, tagEnd);
+            const blockType = isAttr ? "xml_attr" : "xml_region";
+            if (close === -1) return stop(this.island(blockType, i, this.n, false, { tag: name }));
+            const end = close + closer.length;
+            if (end > pe) return stop(this.island(blockType, i, end, true, { tag: name }));
+            inlines.push(this.island("xml_inline", i, end, true, { tag: name }));
+            i = end;
+            continue;
+          }
+          if (tag.isClosing && THINKING_FAMILY.includes(name)) {
+            return stop(this.island("xml_region", i, tagEnd, true, { tag: name, continuation: true }), true);
+          }
+          const lower = name.toLowerCase();
+          inlines.push(
+            this.island(ALLOWED_RAW_HTML_TAGS.has(lower) ? "html_tag" : "xml_tag", i, tagEnd, true, {
+              tag: name
+            })
+          );
+          i = tagEnd;
+          continue;
+        }
+        const pending = ATTRIBUTE_XML_NAMES.find(
+          (name) => text.startsWith(`<${name}`, i) && /\s/.test(text[i + name.length + 1] ?? "")
+        );
+        if (pending && this.next(">", i) === -1) {
+          return stop(this.island("xml_attr", i, this.n, false, { tag: pending }));
+        }
+        i++;
+        continue;
+      }
+      i++;
+    }
+    return { inlines, breakIsland: null, orphan: false };
+  }
+};
+function tokenizeSource(text) {
+  const raw = new Tokenizer(text).run();
+  const cp = buildCodePointIndex(text);
+  const inline = (island) => ({
+    islandType: island.type,
+    inline: true,
+    complete: island.complete,
+    meta: island.meta,
+    start: island.start,
+    end: island.end,
+    startCp: cp.toCodePoint(island.start),
+    endCp: cp.toCodePoint(island.end),
+    raw: text.slice(island.start, island.end)
+  });
+  return raw.map(
+    (block) => ({
+      kind: block.kind,
+      islandType: block.island?.type ?? null,
+      complete: block.island ? block.island.complete : true,
+      meta: block.island?.meta ?? {},
+      inlines: block.inlines.map(inline),
+      start: block.start,
+      end: block.end,
+      startCp: cp.toCodePoint(block.start),
+      endCp: cp.toCodePoint(block.end),
+      raw: text.slice(block.start, block.end)
+    })
+  );
+}
+function joinSource(blocks) {
+  let out = "";
+  for (const block of blocks) out += block.raw;
+  return out;
+}
+function listIslands(blocks) {
+  const out = [];
+  for (const block of blocks) {
+    if (block.kind === "island" && block.islandType) {
+      out.push({
+        islandType: block.islandType,
+        inline: false,
+        complete: block.complete,
+        meta: block.meta,
+        start: block.start,
+        end: block.end,
+        startCp: block.startCp,
+        endCp: block.endCp,
+        raw: block.raw
+      });
+    } else {
+      out.push(...block.inlines);
+    }
+  }
+  return out;
+}
+function blockAt(blocks, offset) {
+  let lo = 0;
+  let hi = blocks.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    const block = blocks[mid];
+    if (offset < block.start) hi = mid - 1;
+    else if (offset >= block.end) lo = mid + 1;
+    else return block;
+  }
+  return null;
+}
+
+// source/splice.ts
+var SourceSpliceError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "SourceSpliceError";
+  }
+  code;
+};
+function blockEdit(block, text) {
+  return { start: block.start, end: block.end, text };
+}
+function islandEdit(island, text) {
+  return { start: island.start, end: island.end, text, island: true };
+}
+function blockRangeEdit(first, last, text) {
+  return { start: first.start, end: last.end, text };
+}
+function locateIsland(text, raw, from, expected, expectedFromEnd) {
+  if (expected >= from && text.startsWith(raw, expected)) return expected;
+  if (expectedFromEnd >= from && text.startsWith(raw, expectedFromEnd)) return expectedFromEnd;
+  const after = text.indexOf(raw, Math.max(from, expected));
+  const before = expected > from ? text.lastIndexOf(raw, expected) : -1;
+  const beforeOk = before >= from ? before : -1;
+  if (after === -1) return beforeOk;
+  if (beforeOk === -1) return after;
+  return expected - beforeOk <= after - expected ? beforeOk : after;
+}
+function commonPrefix(a, b) {
+  const max = Math.min(a.length, b.length);
+  let i = 0;
+  while (i < max && a.charCodeAt(i) === b.charCodeAt(i)) i++;
+  if (i > 0 && (splitsSurrogatePair(a, i) || splitsSurrogatePair(b, i))) i--;
+  return i;
+}
+function commonSuffix(a, b, prefix) {
+  const max = Math.min(a.length, b.length) - prefix;
+  let i = 0;
+  while (i < max && a.charCodeAt(a.length - 1 - i) === b.charCodeAt(b.length - 1 - i)) i++;
+  if (i > 0 && (splitsSurrogatePair(a, a.length - i) || splitsSurrogatePair(b, b.length - i))) i--;
+  return i;
+}
+function spliceSave(original, edits, options = {}) {
+  const blocks = options.blocks ?? tokenizeSource(original);
+  if (options.blocks && joinSource(blocks) !== original) {
+    throw new SourceSpliceError("stale_blocks", "the blocks passed in were not cut from this original text");
+  }
+  const boundaries = /* @__PURE__ */ new Set([0, original.length]);
+  for (const block of blocks) {
+    boundaries.add(block.start);
+    boundaries.add(block.end);
+  }
+  const islands = listIslands(blocks);
+  const islandAt = /* @__PURE__ */ new Map();
+  for (const island of islands) islandAt.set(`${island.start}:${island.end}`, island);
+  const sorted = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
+  let previousEnd = -1;
+  for (const edit of sorted) {
+    if (edit.start < 0 || edit.end > original.length || edit.start > edit.end) {
+      throw new SourceSpliceError("out_of_range", `edit [${edit.start}, ${edit.end}) is outside the text`);
+    }
+    if (edit.island) {
+      if (!islandAt.has(`${edit.start}:${edit.end}`)) {
+        throw new SourceSpliceError(
+          "misaligned",
+          `islandEdit [${edit.start}, ${edit.end}) does not name an island's exact span`
+        );
+      }
+    } else if (!boundaries.has(edit.start) || !boundaries.has(edit.end)) {
+      throw new SourceSpliceError(
+        "misaligned",
+        `edit [${edit.start}, ${edit.end}) does not start and end on block boundaries`
+      );
+    }
+    if (edit.start < previousEnd) {
+      throw new SourceSpliceError("overlap", `edit [${edit.start}, ${edit.end}) overlaps the previous edit`);
+    }
+    previousEnd = edit.end;
+  }
+  const effective = [];
+  const replacedIslands = /* @__PURE__ */ new Set();
+  const pushSegment = (oldStart, oldEnd, replacement) => {
+    const old = original.slice(oldStart, oldEnd);
+    if (old === replacement) return;
+    const prefix = commonPrefix(old, replacement);
+    const suffix = commonSuffix(old, replacement, prefix);
+    effective.push({
+      oldStart: oldStart + prefix,
+      oldEnd: oldEnd - suffix,
+      replacement: replacement.slice(prefix, replacement.length - suffix)
+    });
+  };
+  for (const edit of sorted) {
+    if (edit.island) {
+      replacedIslands.add(`${edit.start}:${edit.end}`);
+      pushSegment(edit.start, edit.end, edit.text);
+      continue;
+    }
+    if (edit.text === original.slice(edit.start, edit.end)) continue;
+    const inside = islands.filter((island) => island.start >= edit.start && island.end <= edit.end);
+    let oldCursor2 = edit.start;
+    let newCursor2 = 0;
+    for (const island of inside) {
+      const at = locateIsland(edit.text, island.raw, newCursor2, newCursor2 + (island.start - oldCursor2), edit.text.length - (edit.end - island.start));
+      if (at === -1) {
+        const name = island.meta.tag ?? island.meta.name ?? island.meta.lang ?? "";
+        throw new SourceSpliceError(
+          "island_edit",
+          `edit [${edit.start}, ${edit.end}) changes or removes the protected ${island.islandType}${name ? ` (${String(name)})` : ""} island at [${island.start}, ${island.end}); islands change only through islandEdit()`
+        );
+      }
+      pushSegment(oldCursor2, island.start, edit.text.slice(newCursor2, at));
+      oldCursor2 = island.end;
+      newCursor2 = at + island.raw.length;
+    }
+    pushSegment(oldCursor2, edit.end, edit.text.slice(newCursor2));
+  }
+  if (effective.length === 0) {
+    return {
+      text: original,
+      changed: false,
+      changes: [],
+      integrity: { ok: true, bytesOutsideEditsIdentical: true, disturbed: [] },
+      blocks
+    };
+  }
+  let text = "";
+  let cursor = 0;
+  let delta = 0;
+  const pending = [];
+  for (const edit of effective) {
+    text += original.slice(cursor, edit.oldStart);
+    const newStart = edit.oldStart + delta;
+    text += edit.replacement;
+    const newEnd = newStart + edit.replacement.length;
+    const owner = sorted.find((e) => e.start <= edit.oldStart && e.end >= edit.oldEnd);
+    pending.push({
+      blockStart: owner?.start ?? edit.oldStart,
+      blockEnd: owner?.end ?? edit.oldEnd,
+      oldStart: edit.oldStart,
+      oldEnd: edit.oldEnd,
+      newStart,
+      newEnd
+    });
+    delta += edit.replacement.length - (edit.oldEnd - edit.oldStart);
+    cursor = edit.oldEnd;
+  }
+  text += original.slice(cursor);
+  const oldCp = buildCodePointIndex(original);
+  const newCp = buildCodePointIndex(text);
+  const changes = pending.map((change) => ({
+    ...change,
+    oldStartCp: oldCp.toCodePoint(change.oldStart),
+    oldEndCp: oldCp.toCodePoint(change.oldEnd),
+    newStartCp: newCp.toCodePoint(change.newStart),
+    newEndCp: newCp.toCodePoint(change.newEnd)
+  }));
+  let bytesOutsideEditsIdentical = true;
+  let oldCursor = 0;
+  let newCursor = 0;
+  for (const change of changes) {
+    if (original.slice(oldCursor, change.oldStart) !== text.slice(newCursor, change.newStart)) {
+      bytesOutsideEditsIdentical = false;
+    }
+    oldCursor = change.oldEnd;
+    newCursor = change.newEnd;
+  }
+  if (original.slice(oldCursor) !== text.slice(newCursor)) bytesOutsideEditsIdentical = false;
+  const newBlocks = tokenizeSource(text);
+  const newIslandsByStart = /* @__PURE__ */ new Map();
+  for (const island of listIslands(newBlocks)) {
+    const list = newIslandsByStart.get(island.start);
+    if (list) list.push(island.raw);
+    else newIslandsByStart.set(island.start, [island.raw]);
+  }
+  const disturbed = [];
+  for (const island of islands) {
+    if (replacedIslands.has(`${island.start}:${island.end}`)) continue;
+    const mappedStart = mapPosition(changes, island.start, { assoc: 1 }).pos;
+    const candidates = newIslandsByStart.get(mappedStart);
+    if (!candidates || !candidates.includes(island.raw)) {
+      disturbed.push({
+        islandType: island.islandType,
+        inline: island.inline,
+        start: island.start,
+        end: island.end,
+        mappedStart
+      });
+    }
+  }
+  const integrity = {
+    ok: bytesOutsideEditsIdentical && disturbed.length === 0,
+    bytesOutsideEditsIdentical,
+    disturbed
+  };
+  if ((options.requireIntegrity ?? true) && !integrity.ok) {
+    const named = disturbed.slice(0, 5).map((island) => `${island.islandType}@${island.start}`).join(", ");
+    throw new SourceSpliceError(
+      "integrity",
+      `integrity: the save disturbed ${disturbed.length} protected island(s) it did not replace${named ? ` (${named}${disturbed.length > 5 ? ", \u2026" : ""})` : ""}${bytesOutsideEditsIdentical ? "" : "; bytes outside the edits changed"}`
+    );
+  }
+  return { text, changed: true, changes, integrity, blocks: newBlocks };
+}
+function mapPosition(changes, pos, options = {}) {
+  const assoc = options.assoc ?? 1;
+  const cp = options.unit === "codepoint";
+  let delta = 0;
+  for (const change of changes) {
+    const oldStart = cp ? change.oldStartCp : change.oldStart;
+    const oldEnd = cp ? change.oldEndCp : change.oldEnd;
+    const newStart = cp ? change.newStartCp : change.newStart;
+    const newEnd = cp ? change.newEndCp : change.newEnd;
+    if (pos < oldStart) break;
+    if (pos > oldEnd) {
+      delta = newEnd - oldEnd;
+      continue;
+    }
+    if (oldStart === oldEnd) {
+      return { pos: assoc < 0 ? newStart : newEnd, deleted: false };
+    }
+    if (pos === oldStart) return { pos: newStart, deleted: false };
+    if (pos === oldEnd) return { pos: newEnd, deleted: false };
+    return { pos: assoc < 0 ? newStart : newEnd, deleted: true };
+  }
+  return { pos: pos + delta, deleted: false };
+}
+function mapRange(changes, start, end, unit = "utf16") {
+  const cp = unit === "codepoint";
+  const mappedStart = mapPosition(changes, start, { assoc: 1, unit });
+  const mappedEnd = mapPosition(changes, end, { assoc: -1, unit });
+  const touched = changes.some((change) => {
+    const oldStart = cp ? change.oldStartCp : change.oldStart;
+    const oldEnd = cp ? change.oldEndCp : change.oldEnd;
+    return oldStart < end && oldEnd > start;
+  });
+  const newStart = mappedStart.pos;
+  const newEnd = Math.max(newStart, mappedEnd.pos);
+  return { start: newStart, end: newEnd, touched, collapsed: newEnd === newStart && end > start };
+}
+
+export { NESTING_FENCE_LANGUAGES, SourceSpliceError, XmlContainerTracker, blockAt, blockEdit, blockRangeEdit, buildCodePointIndex, classifyInnerFenceLine, fenceNestsInnerFences, isSingleDollarMath, islandEdit, joinSource, listIslands, looksLikeDisplayMath, mapPosition, mapRange, pairDisplayMath, readXmlTag, singleDollarMathEnd, spliceSave, splitsSurrogatePair, toCodePointOffset, toUtf16Offset, tokenizeSource };
+//# sourceMappingURL=source.js.map
+//# sourceMappingURL=source.js.map