typewright 0.2.1

package/dist/streaming/index.cjs

@@ -0,0 +1,1494 @@
+'use strict';
+
+// src/core/ast.ts
+function walk(node, visit) {
+  const go = (n) => {
+    if (visit(n) === false) return;
+    const kids = childrenOf(n);
+    for (const k of kids) go(k);
+  };
+  go(node);
+}
+function childrenOf(node) {
+  switch (node.type) {
+    case "document":
+    case "blockquote":
+      return node.children;
+    case "heading":
+    case "paragraph":
+    case "emphasis":
+    case "strong":
+    case "strikethrough":
+    case "tableCell":
+      return node.children;
+    case "link":
+      return node.children;
+    case "list":
+      return node.items;
+    case "listItem":
+      return node.children;
+    case "table":
+      return [...node.header, ...node.rows.flat()];
+    case "footnoteDef":
+      return node.children;
+    case "defList":
+      return node.items;
+    case "defItem":
+      return [...node.term, ...node.definitions.flat()];
+    default:
+      return [];
+  }
+}
+
+// src/core/parser.ts
+var MAX_URL = 4096;
+var MAX_TITLE = 1024;
+var MAX_ALT = 4096;
+var MAX_LANG = 256;
+var MAX_VALUE = 1e6;
+var MAX_FOOTNOTE_ID = 256;
+var cap = (s, n) => s.length > n ? s.slice(0, n) : s;
+var opts = { math: false, footnotes: false, defLists: false };
+function splitLines(src) {
+  const lines = [];
+  let from = 0;
+  for (let i = 0; i <= src.length; i++) {
+    if (i === src.length || src[i] === "\n") {
+      let end = i;
+      if (end > from && src[end - 1] === "\r") end--;
+      lines.push({ from, to: end, text: src.slice(from, end) });
+      from = i + 1;
+    }
+  }
+  return lines;
+}
+var leadingSpaces = (t) => {
+  let n = 0;
+  while (n < t.length && t[n] === " ") n++;
+  return n;
+};
+var isBlank = (line) => line.text.trim() === "";
+var FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+var ATX_RE = /^( {0,3})(#{1,6})(?=\s|$)/;
+var ITEM_RE = /^( {0,3})([-+*]|\d{1,9}[.)])( +|$)/;
+var HTML_TAG_RE = /^<\/?([A-Za-z][A-Za-z0-9-]*)(?:[\s/>]|$)/;
+var ESM_RE = /^(?:import|export)\b/;
+var isFence = (t) => {
+  const m = FENCE_RE.exec(t);
+  if (!m) return false;
+  return m[2][0] !== "`" || !m[3].includes("`");
+};
+var isAtx = (t) => ATX_RE.test(t);
+var isThematic = (t) => {
+  const trimmed = t.trim();
+  if (trimmed.length < 3) return false;
+  const compact = trimmed.replace(/ /g, "");
+  return /^(?:-{3,}|_{3,}|\*{3,})$/.test(compact);
+};
+var isQuote = (t) => /^ {0,3}>/.test(t);
+function detectItem(line) {
+  const m = ITEM_RE.exec(line.text);
+  if (!m) return null;
+  const marker = m[2];
+  return {
+    indent: m[1].length,
+    marker,
+    markerLen: marker.length,
+    spacesAfter: m[3] === "" ? 0 : m[3].length,
+    ordered: /\d/.test(marker[0])
+  };
+}
+function htmlVariant(t) {
+  const s = t.replace(/^ {0,3}/, "");
+  if (ESM_RE.test(s)) return "mdxFlow";
+  const m = HTML_TAG_RE.exec(s);
+  if (!m) return null;
+  return /[A-Z]/.test(m[1][0]) ? "mdxFlow" : "html";
+}
+function isDelimRow(t) {
+  let s = t.trim();
+  if (!s.includes("-")) return false;
+  s = s.replace(/^\|/, "").replace(/\|$/, "");
+  const cells = s.split("|");
+  return cells.length >= 1 && cells.every((c) => /^ *:?-+:? *$/.test(c));
+}
+function isTableStartAt(lines, j) {
+  const line = lines[j];
+  const next = lines[j + 1];
+  if (!line || !next) return false;
+  if (isBlank(line)) return false;
+  return line.text.includes("|") && isDelimRow(next.text);
+}
+var MATH_FENCE_RE = /^ {0,3}\$\$[ \t]*$/;
+var isMathOpen = (t) => opts.math && MATH_FENCE_RE.test(t);
+var FOOTNOTE_DEF_RE = /^( {0,3})\[\^([^\]\s]+)\]:/;
+var isFootnoteDef = (line) => opts.footnotes && FOOTNOTE_DEF_RE.test(line.text);
+var DEF_RE = /^( {0,3}):[ \t]+/;
+function isDefListStartAt(lines, j) {
+  if (!opts.defLists) return false;
+  const line = lines[j];
+  const next = lines[j + 1];
+  if (!line || !next) return false;
+  if (isBlank(line)) return false;
+  if (startsBlock(lines, j)) return false;
+  return DEF_RE.test(next.text);
+}
+function startsBlock(lines, j) {
+  const line = lines[j];
+  const t = line.text;
+  return isFence(t) || isAtx(t) || isThematic(t) || isQuote(t) || detectItem(line) !== null || htmlVariant(t) !== null || isTableStartAt(lines, j) || isMathOpen(t) || isFootnoteDef(line);
+}
+function startsOtherBlock(line) {
+  const t = line.text;
+  return isFence(t) || isAtx(t) || isThematic(t) || isQuote(t) || detectItem(line) !== null || htmlVariant(t) !== null || isMathOpen(t) || isFootnoteDef(line);
+}
+function buildHeading(line) {
+  const t = line.text;
+  const m = ATX_RE.exec(t);
+  const indent = m[1].length;
+  const hashes = m[2];
+  const level = hashes.length;
+  let ce = indent + hashes.length;
+  if (t[ce] === " ") ce++;
+  const contentFrom = line.from + ce;
+  let end = t.length;
+  while (end > ce && (t[end - 1] === " " || t[end - 1] === "	")) end--;
+  let e2 = end;
+  while (e2 > ce && t[e2 - 1] === "#") e2--;
+  if (e2 < end && (e2 === ce || t[e2 - 1] === " " || t[e2 - 1] === "	")) {
+    end = e2;
+    while (end > ce && (t[end - 1] === " " || t[end - 1] === "	")) end--;
+  }
+  const children = parseInlineSegs([
+    { from: contentFrom, to: line.from + end, text: t.slice(ce, end) }
+  ]);
+  return { type: "heading", from: line.from, to: line.to, level, contentFrom, children };
+}
+function buildFence(lines, i) {
+  const open = lines[i];
+  const m = FENCE_RE.exec(open.text);
+  const indent = m[1].length;
+  const fenceChar = m[2][0];
+  const fenceLen = m[2].length;
+  const lang = cap(m[3].trim(), MAX_LANG);
+  const inner = [];
+  let j = i + 1;
+  let closeTo = null;
+  while (j < lines.length) {
+    const cm = /^( {0,3})(`{3,}|~{3,}) *$/.exec(lines[j].text);
+    if (cm && cm[2][0] === fenceChar && cm[2].length >= fenceLen) {
+      closeTo = lines[j].to;
+      j++;
+      break;
+    }
+    inner.push(lines[j]);
+    j++;
+  }
+  const value = cap(
+    inner.map((l) => leadingSpaces(l.text) >= indent ? l.text.slice(indent) : l.text.trimStart()).join("\n"),
+    MAX_VALUE
+  );
+  const to = closeTo ?? (inner.length ? inner[inner.length - 1].to : open.to);
+  return { node: { type: "codeBlock", from: open.from, to, lang, value, fenced: true }, next: j };
+}
+function buildMathBlock(lines, i) {
+  const open = lines[i];
+  const inner = [];
+  let j = i + 1;
+  let closeTo = null;
+  while (j < lines.length) {
+    if (MATH_FENCE_RE.test(lines[j].text)) {
+      closeTo = lines[j].to;
+      j++;
+      break;
+    }
+    inner.push(lines[j]);
+    j++;
+  }
+  const value = cap(inner.map((l) => l.text).join("\n"), MAX_VALUE);
+  const to = closeTo ?? (inner.length ? inner[inner.length - 1].to : open.to);
+  const node = { type: "mathBlock", from: open.from, to, value };
+  return { node, next: j };
+}
+function buildIndentedCode(lines, i) {
+  const from = lines[i].from;
+  const inner = [lines[i]];
+  let j = i + 1;
+  let pending = [];
+  while (j < lines.length) {
+    const line = lines[j];
+    if (isBlank(line)) {
+      pending.push(line);
+      j++;
+      continue;
+    }
+    if (leadingSpaces(line.text) >= 4) {
+      inner.push(...pending, line);
+      pending = [];
+      j++;
+      continue;
+    }
+    break;
+  }
+  const last = inner[inner.length - 1];
+  const value = cap(inner.map((l) => l.text.slice(4)).join("\n"), MAX_VALUE);
+  return {
+    node: { type: "codeBlock", from, to: last.to, lang: "", value, fenced: false },
+    next: j
+  };
+}
+function buildThematic(line) {
+  return { type: "thematicBreak", from: line.from, to: line.to };
+}
+function stripQuote(line) {
+  const m = /^( {0,3})>( ?)/.exec(line.text);
+  const cut = m[0].length;
+  return { from: line.from + cut, to: line.to, text: line.text.slice(cut) };
+}
+function buildBlockquote(lines, i) {
+  const from = lines[i].from;
+  const inner = [];
+  let j = i;
+  while (j < lines.length && isQuote(lines[j].text)) {
+    inner.push(stripQuote(lines[j]));
+    j++;
+  }
+  const to = lines[j - 1].to;
+  const children = parseBlocks(inner);
+  return { node: { type: "blockquote", from, to, children }, next: j };
+}
+var TASK_RE = /^\[([ xX])\](\s|$)/;
+function collectItem(lines, idx) {
+  const line0 = lines[idx];
+  const det = detectItem(line0);
+  const contentCol = det.indent + det.markerLen + 1;
+  const localStart = det.indent + det.markerLen + (det.spacesAfter > 0 ? 1 : 0);
+  let task = null;
+  let bodyStart = localStart;
+  const afterMarker = line0.text.slice(localStart);
+  const tm = TASK_RE.exec(afterMarker);
+  if (tm) {
+    task = tm[1] === " " ? "unchecked" : "checked";
+    bodyStart = localStart + tm[0].length;
+  }
+  const contentFrom = line0.from + bodyStart;
+  const body = [
+    { from: contentFrom, to: line0.to, text: line0.text.slice(bodyStart) }
+  ];
+  let lastTo = line0.to;
+  let loose = false;
+  let pendingBlank = false;
+  let j = idx + 1;
+  while (j < lines.length) {
+    const lj = lines[j];
+    if (isBlank(lj)) {
+      pendingBlank = true;
+      j++;
+      continue;
+    }
+    const ind = leadingSpaces(lj.text);
+    if (ind >= contentCol) {
+      if (pendingBlank) {
+        loose = true;
+        body.push({ from: lj.from, to: lj.from, text: "" });
+      }
+      body.push({
+        from: lj.from + contentCol,
+        to: lj.to,
+        text: lj.text.slice(contentCol)
+      });
+      lastTo = lj.to;
+      pendingBlank = false;
+      j++;
+      continue;
+    }
+    if (detectItem(lj)) break;
+    if (pendingBlank) break;
+    if (startsOtherBlock(lj)) break;
+    body.push({ from: lj.from, to: lj.to, text: lj.text });
+    lastTo = lj.to;
+    j++;
+  }
+  const children = parseBlocks(body);
+  const item = {
+    type: "listItem",
+    from: line0.from,
+    to: lastTo,
+    task,
+    contentFrom,
+    children
+  };
+  return { item, next: j, blankBefore: pendingBlank, loose };
+}
+function buildList(lines, start) {
+  const first = detectItem(lines[start]);
+  const ordered = first.ordered;
+  const startNum = ordered ? parseInt(first.marker, 10) || 0 : 1;
+  const items = [];
+  let loose = false;
+  let i = start;
+  while (i < lines.length) {
+    const det = detectItem(lines[i]);
+    if (!det || det.ordered !== ordered) break;
+    const r = collectItem(lines, i);
+    if (r.blankBefore) loose = true;
+    if (r.loose) loose = true;
+    items.push(r.item);
+    i = r.next;
+  }
+  const node = {
+    type: "list",
+    from: items[0].from,
+    to: items[items.length - 1].to,
+    ordered,
+    start: startNum,
+    tight: !loose,
+    items
+  };
+  return { node, next: i };
+}
+function parseAligns(delim) {
+  return splitCellRanges(delim).map(([a, b]) => {
+    const cell = delim.slice(a, b).trim();
+    const left = cell.startsWith(":");
+    const right = cell.endsWith(":");
+    if (left && right) return "center";
+    if (left) return "left";
+    if (right) return "right";
+    return null;
+  });
+}
+function splitCellRanges(t) {
+  const cells = [];
+  let s = 0;
+  for (let k = 0; k < t.length; k++) {
+    if (t[k] === "|" && t[k - 1] !== "\\") {
+      cells.push([s, k]);
+      s = k + 1;
+    }
+  }
+  cells.push([s, t.length]);
+  if (cells.length > 1 && t.slice(cells[0][0], cells[0][1]).trim() === "") cells.shift();
+  if (cells.length > 1 && t.slice(cells[cells.length - 1][0], cells[cells.length - 1][1]).trim() === "")
+    cells.pop();
+  return cells;
+}
+function splitRow(line) {
+  const t = line.text;
+  return splitCellRanges(t).map(([a, b]) => {
+    let ca = a;
+    while (ca < b && t[ca] === " ") ca++;
+    let cb = b;
+    while (cb > ca && t[cb - 1] === " ") cb--;
+    const from = line.from + ca;
+    const to = line.from + cb;
+    const children = parseInlineSegs([{ from, to, text: t.slice(ca, cb) }]);
+    return { type: "tableCell", from, to, children };
+  });
+}
+function buildTable(lines, i) {
+  const header = splitRow(lines[i]);
+  const align = parseAligns(lines[i + 1].text);
+  const rows = [];
+  let j = i + 2;
+  let lastTo = lines[i + 1].to;
+  while (j < lines.length) {
+    const line = lines[j];
+    if (isBlank(line) || startsOtherBlock(line)) break;
+    rows.push(splitRow(line));
+    lastTo = line.to;
+    j++;
+  }
+  return {
+    node: { type: "table", from: lines[i].from, to: lastTo, align, header, rows },
+    next: j
+  };
+}
+function buildHtml(lines, i) {
+  const variant = htmlVariant(lines[i].text);
+  const from = lines[i].from;
+  const block = [];
+  let j = i;
+  while (j < lines.length && !isBlank(lines[j])) {
+    block.push(lines[j]);
+    j++;
+  }
+  const to = block[block.length - 1].to;
+  const value = cap(block.map((l) => l.text).join("\n"), MAX_VALUE);
+  return { node: { type: "htmlBlock", from, to, value, variant }, next: j };
+}
+function buildFootnoteDef(lines, i) {
+  const line0 = lines[i];
+  const m = FOOTNOTE_DEF_RE.exec(line0.text);
+  const indent = m[1].length;
+  const id = m[2];
+  const markerLen = m[0].length - indent;
+  const contentCol = indent + markerLen + 1;
+  let bodyStart = indent + markerLen;
+  if (line0.text[bodyStart] === " ") bodyStart++;
+  const contentFrom = line0.from + bodyStart;
+  const body = [
+    { from: contentFrom, to: line0.to, text: line0.text.slice(bodyStart) }
+  ];
+  let lastTo = line0.to;
+  let pendingBlank = false;
+  let j = i + 1;
+  while (j < lines.length) {
+    const lj = lines[j];
+    if (isBlank(lj)) {
+      pendingBlank = true;
+      j++;
+      continue;
+    }
+    const ind = leadingSpaces(lj.text);
+    if (ind >= contentCol) {
+      if (pendingBlank) body.push({ from: lj.from, to: lj.from, text: "" });
+      body.push({ from: lj.from + contentCol, to: lj.to, text: lj.text.slice(contentCol) });
+      lastTo = lj.to;
+      pendingBlank = false;
+      j++;
+      continue;
+    }
+    if (pendingBlank) break;
+    if (isFootnoteDef(lj)) break;
+    if (startsOtherBlock(lj)) break;
+    if (isDefListStartAt(lines, j)) break;
+    body.push({ from: lj.from, to: lj.to, text: lj.text });
+    lastTo = lj.to;
+    j++;
+  }
+  const children = parseBlocks(body);
+  const node = { type: "footnoteDef", from: line0.from, to: lastTo, id, children };
+  return { node, next: j };
+}
+function collectDefinition(lines, idx) {
+  const line0 = lines[idx];
+  const m = DEF_RE.exec(line0.text);
+  const contentCol = m[0].length;
+  const body = [
+    { from: line0.from + contentCol, to: line0.to, text: line0.text.slice(contentCol) }
+  ];
+  let lastTo = line0.to;
+  let pendingBlank = false;
+  let j = idx + 1;
+  while (j < lines.length) {
+    const lj = lines[j];
+    if (isBlank(lj)) {
+      pendingBlank = true;
+      j++;
+      continue;
+    }
+    if (DEF_RE.test(lj.text)) break;
+    const ind = leadingSpaces(lj.text);
+    if (ind >= contentCol) {
+      if (pendingBlank) body.push({ from: lj.from, to: lj.from, text: "" });
+      body.push({ from: lj.from + contentCol, to: lj.to, text: lj.text.slice(contentCol) });
+      lastTo = lj.to;
+      pendingBlank = false;
+      j++;
+      continue;
+    }
+    if (pendingBlank) break;
+    if (startsOtherBlock(lj)) break;
+    if (isFootnoteDef(lj)) break;
+    if (isDefListStartAt(lines, j)) break;
+    body.push({ from: lj.from, to: lj.to, text: lj.text });
+    lastTo = lj.to;
+    j++;
+  }
+  return { blocks: parseBlocks(body), to: lastTo, next: j };
+}
+function collectDefItem(lines, idx) {
+  const termLine = lines[idx];
+  const term = parseInlineSegs([
+    { from: termLine.from, to: termLine.to, text: termLine.text }
+  ]);
+  const definitions = [];
+  let lastTo = termLine.to;
+  let j = idx + 1;
+  while (j < lines.length && DEF_RE.test(lines[j].text)) {
+    const d = collectDefinition(lines, j);
+    definitions.push(d.blocks);
+    lastTo = d.to;
+    j = d.next;
+  }
+  const item = { type: "defItem", from: termLine.from, to: lastTo, term, definitions };
+  return { item, next: j };
+}
+function buildDefList(lines, start) {
+  const items = [];
+  let i = start;
+  while (i < lines.length && isDefListStartAt(lines, i)) {
+    const r = collectDefItem(lines, i);
+    items.push(r.item);
+    i = r.next;
+  }
+  const node = {
+    type: "defList",
+    from: items[0].from,
+    to: items[items.length - 1].to,
+    items
+  };
+  return { node, next: i };
+}
+function buildParagraph(lines, i) {
+  const para = [lines[i]];
+  let j = i + 1;
+  while (j < lines.length) {
+    if (isBlank(lines[j])) break;
+    if (startsBlock(lines, j)) break;
+    para.push(lines[j]);
+    j++;
+  }
+  const from = para[0].from;
+  const to = para[para.length - 1].to;
+  const children = parseInlineSegs(para.map((l) => ({ from: l.from, to: l.to, text: l.text })));
+  return { node: { type: "paragraph", from, to, children }, next: j };
+}
+function parseBlocks(lines) {
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (isBlank(line)) {
+      i++;
+      continue;
+    }
+    const t = line.text;
+    if (isFence(t)) {
+      const b = buildFence(lines, i);
+      out.push(b.node);
+      i = b.next;
+    } else if (isMathOpen(t)) {
+      const b = buildMathBlock(lines, i);
+      out.push(b.node);
+      i = b.next;
+    } else if (leadingSpaces(t) >= 4) {
+      const b = buildIndentedCode(lines, i);
+      out.push(b.node);
+      i = b.next;
+    } else if (isAtx(t)) {
+      out.push(buildHeading(line));
+      i++;
+    } else if (isThematic(t)) {
+      out.push(buildThematic(line));
+      i++;
+    } else if (isQuote(t)) {
+      const b = buildBlockquote(lines, i);
+      out.push(b.node);
+      i = b.next;
+    } else if (detectItem(line)) {
+      const b = buildList(lines, i);
+      out.push(b.node);
+      i = b.next;
+    } else if (isDefListStartAt(lines, i)) {
+      const b = buildDefList(lines, i);
+      out.push(b.node);
+      i = b.next;
+    } else if (isTableStartAt(lines, i)) {
+      const b = buildTable(lines, i);
+      out.push(b.node);
+      i = b.next;
+    } else if (htmlVariant(t)) {
+      const b = buildHtml(lines, i);
+      out.push(b.node);
+      i = b.next;
+    } else if (isFootnoteDef(line)) {
+      const b = buildFootnoteDef(lines, i);
+      out.push(b.node);
+      i = b.next;
+    } else {
+      const b = buildParagraph(lines, i);
+      out.push(b.node);
+      i = b.next;
+    }
+  }
+  return out;
+}
+var isWs = (ch) => ch === void 0 || ch === " " || ch === "\n" || ch === "	" || ch === "\r";
+var isAlnum = (ch) => ch !== void 0 && /[0-9A-Za-z]/.test(ch);
+function parseInlineSegs(segs) {
+  if (segs.length === 0) return [];
+  let buf = "";
+  const map = [];
+  for (let s = 0; s < segs.length; s++) {
+    const seg = segs[s];
+    if (s > 0) {
+      map.push(segs[s - 1].to);
+      buf += "\n";
+    }
+    for (let k = 0; k < seg.text.length; k++) {
+      map.push(seg.from + k);
+      buf += seg.text[k];
+    }
+  }
+  map.push(segs[segs.length - 1].to);
+  const abs = (k) => k < map.length ? map[k] : segs[segs.length - 1].to;
+  const text = (from, to, value) => ({
+    type: "text",
+    from,
+    to,
+    value: cap(value, MAX_VALUE)
+  });
+  function tryCode(i, end) {
+    let n = 1;
+    while (i + n < end && buf[i + n] === "`") n++;
+    let k = i + n;
+    while (k < end) {
+      if (buf[k] === "`") {
+        let m = 1;
+        while (k + m < end && buf[k + m] === "`") m++;
+        if (m === n) {
+          let val = buf.slice(i + n, k);
+          if (val.length > 2 && val[0] === " " && val[val.length - 1] === " " && val.trim() !== "")
+            val = val.slice(1, -1);
+          const node = {
+            type: "inlineCode",
+            from: abs(i),
+            to: abs(k + n),
+            value: cap(val, MAX_VALUE),
+            ticks: n
+          };
+          return { node, endIdx: k + n };
+        }
+        k += m;
+        continue;
+      }
+      k++;
+    }
+    return null;
+  }
+  function tryMath(i, end) {
+    let n = 1;
+    while (i + n < end && buf[i + n] === "$" && n < 2) n++;
+    const after = buf[i + n];
+    if (after === void 0 || after === " " || after === "	" || after === "\n") return null;
+    let k = i + n;
+    while (k < end) {
+      const ch = buf[k];
+      if (ch === "\\") {
+        k += 2;
+        continue;
+      }
+      if (ch === "\n") return null;
+      if (ch === "$") {
+        let m = 1;
+        while (k + m < end && buf[k + m] === "$" && m < 2) m++;
+        if (m === n && k > i + n) {
+          const prev = buf[k - 1];
+          if (prev !== " " && prev !== "	" && prev !== "\n") {
+            const node = {
+              type: "math",
+              from: abs(i),
+              to: abs(k + n),
+              value: cap(buf.slice(i + n, k), MAX_VALUE),
+              display: n === 2
+            };
+            return { node, endIdx: k + n };
+          }
+        }
+        k += m;
+        continue;
+      }
+      k++;
+    }
+    return null;
+  }
+  function tryFootnoteRef(i, end) {
+    const idStart = i + 2;
+    const stop = Math.min(end, idStart + MAX_FOOTNOTE_ID);
+    let k = idStart;
+    while (k < stop) {
+      const ch = buf[k];
+      if (ch === "]") break;
+      if (ch === " " || ch === "	" || ch === "\n" || ch === "[" || ch === "^") return null;
+      k++;
+    }
+    if (k >= stop || buf[k] !== "]" || k === idStart) return null;
+    const node = {
+      type: "footnoteRef",
+      from: abs(i),
+      to: abs(k + 1),
+      id: buf.slice(idStart, k)
+    };
+    return { node, endIdx: k + 1 };
+  }
+  function tryAutolink(i, end) {
+    let k = i + 1;
+    while (k < end && buf[k] !== ">" && buf[k] !== "<" && buf[k] !== " " && buf[k] !== "\n") k++;
+    if (k >= end || buf[k] !== ">") return null;
+    const content = buf.slice(i + 1, k);
+    const isUri = /^[a-zA-Z][a-zA-Z0-9+.-]*:[^\s]*$/.test(content);
+    const isEmail = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(content);
+    if (!isUri && !isEmail) return null;
+    const node = {
+      type: "autolink",
+      from: abs(i),
+      to: abs(k + 1),
+      url: cap(content, MAX_URL)
+    };
+    return { node, endIdx: k + 1 };
+  }
+  function matchLabel(open, end) {
+    const stop = Math.min(end, open + 4096);
+    let depth = 0;
+    for (let k = open; k < stop; k++) {
+      const ch = buf[k];
+      if (ch === "\\") {
+        k++;
+        continue;
+      }
+      if (ch === "[") depth++;
+      else if (ch === "]") {
+        depth--;
+        if (depth === 0) return k;
+      }
+    }
+    return -1;
+  }
+  function tryLink(i, end, isImage) {
+    const br = i + (isImage ? 1 : 0);
+    if (buf[br] !== "[") return null;
+    const close = matchLabel(br, end);
+    if (close < 0) return null;
+    let k = close + 1;
+    if (buf[k] !== "(") return null;
+    k++;
+    while (k < end && (buf[k] === " " || buf[k] === "\n")) k++;
+    let url = "";
+    if (buf[k] === "<") {
+      k++;
+      const s = k;
+      while (k < end && buf[k] !== ">" && buf[k] !== "\n") k++;
+      if (buf[k] !== ">") return null;
+      url = buf.slice(s, k);
+      k++;
+    } else {
+      const s = k;
+      let depth = 0;
+      while (k < end) {
+        const ch = buf[k];
+        if (ch === " " || ch === "\n") break;
+        if (ch === "(") depth++;
+        else if (ch === ")") {
+          if (depth === 0) break;
+          depth--;
+        }
+        k++;
+      }
+      url = buf.slice(s, k);
+    }
+    let title;
+    while (k < end && (buf[k] === " " || buf[k] === "\n")) k++;
+    const q = buf[k];
+    if (q === '"' || q === "'" || q === "(") {
+      const closeCh = q === "(" ? ")" : q;
+      k++;
+      const s = k;
+      while (k < end && buf[k] !== closeCh) k++;
+      if (buf[k] !== closeCh) return null;
+      title = buf.slice(s, k);
+      k++;
+      while (k < end && (buf[k] === " " || buf[k] === "\n")) k++;
+    }
+    if (buf[k] !== ")") return null;
+    const endIdx = k + 1;
+    const from = abs(i);
+    const to = abs(endIdx);
+    if (isImage) {
+      const node2 = {
+        type: "image",
+        from,
+        to,
+        url: cap(url, MAX_URL),
+        alt: cap(buf.slice(br + 1, close), MAX_ALT)
+      };
+      if (title !== void 0) node2.title = cap(title, MAX_TITLE);
+      return { node: node2, endIdx };
+    }
+    const node = {
+      type: "link",
+      from,
+      to,
+      url: cap(url, MAX_URL),
+      children: parseInlineRange(br + 1, close)
+    };
+    if (title !== void 0) node.title = cap(title, MAX_TITLE);
+    return { node, endIdx };
+  }
+  function tryEmph(i, end) {
+    const c = buf[i];
+    let n = 1;
+    while (i + n < end && buf[i + n] === c) n++;
+    const isStrike = c === "~";
+    if (isStrike && n < 2) return null;
+    const strength = isStrike ? 2 : n >= 2 ? 2 : 1;
+    if (i + strength > end) return null;
+    const after = buf[i + strength];
+    const before = buf[i - 1];
+    if (isWs(after)) return null;
+    if (c === "_" && isAlnum(before)) return null;
+    let k = i + strength;
+    while (k < end) {
+      if (buf[k] === c) {
+        let m = 1;
+        while (k + m < end && buf[k + m] === c) m++;
+        if (m >= strength) {
+          const prev = buf[k - 1];
+          const aft = buf[k + strength];
+          if (!isWs(prev) && (c !== "_" || !isAlnum(aft))) {
+            const children = parseInlineRange(i + strength, k);
+            const from = abs(i);
+            const to = abs(k + strength);
+            let node;
+            if (isStrike) {
+              node = { type: "strikethrough", from, to, children };
+            } else if (strength === 2) {
+              node = { type: "strong", from, to, marker: c.repeat(2), children };
+            } else {
+              node = { type: "emphasis", from, to, marker: c, children };
+            }
+            return { node, endIdx: k + strength };
+          }
+        }
+        k += m;
+        continue;
+      }
+      k++;
+    }
+    return null;
+  }
+  function parseInlineRange(start, end) {
+    const out = [];
+    let i = start;
+    let textStart = start;
+    const flush = (upto) => {
+      if (upto > textStart) out.push(text(abs(textStart), abs(upto), buf.slice(textStart, upto)));
+    };
+    const commit = (hit) => {
+      flush(i);
+      out.push(hit.node);
+      i = hit.endIdx;
+      textStart = i;
+    };
+    while (i < end) {
+      const c = buf[i];
+      if (c === "\\") {
+        if (buf[i + 1] === "\n") {
+          flush(i);
+          out.push({ type: "break", from: abs(i), to: abs(i + 2), hard: true });
+          i += 2;
+          textStart = i;
+          continue;
+        }
+        i += 2;
+        continue;
+      }
+      if (c === "\n") {
+        let sp = 0;
+        let p = i - 1;
+        while (p >= textStart && buf[p] === " ") {
+          sp++;
+          p--;
+        }
+        const hard = sp >= 2;
+        flush(hard ? i - sp : i);
+        out.push({
+          type: "break",
+          from: abs(hard ? i - sp : i),
+          to: abs(i + 1),
+          hard
+        });
+        i++;
+        textStart = i;
+        continue;
+      }
+      if (c === "`") {
+        const r = tryCode(i, end);
+        if (r) {
+          commit(r);
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (c === "$" && opts.math) {
+        const r = tryMath(i, end);
+        if (r) {
+          commit(r);
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (c === "<") {
+        const r = tryAutolink(i, end);
+        if (r) {
+          commit(r);
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (c === "!" && buf[i + 1] === "[") {
+        const r = tryLink(i, end, true);
+        if (r) {
+          commit(r);
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (c === "[") {
+        if (opts.footnotes && buf[i + 1] === "^") {
+          const rf = tryFootnoteRef(i, end);
+          if (rf) {
+            commit(rf);
+            continue;
+          }
+        }
+        const r = tryLink(i, end, false);
+        if (r) {
+          commit(r);
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (c === "*" || c === "_" || c === "~") {
+        const r = tryEmph(i, end);
+        if (r) {
+          commit(r);
+          continue;
+        }
+        i++;
+        continue;
+      }
+      i++;
+    }
+    flush(end);
+    return out;
+  }
+  return parseInlineRange(0, buf.length);
+}
+function parse(src, options) {
+  opts = {
+    math: options?.math === true,
+    footnotes: options?.footnotes === true,
+    defLists: options?.defLists === true
+  };
+  const lines = splitLines(src);
+  const children = parseBlocks(lines);
+  return { type: "document", from: 0, to: src.length, children };
+}
+
+// src/core/render.ts
+var MAX_URL2 = 8192;
+var SAFE_SCHEMES = /^(https?:|mailto:)/;
+function newFnCtx() {
+  return { nums: /* @__PURE__ */ new Map() };
+}
+function fnNumber(ctx, slug) {
+  const existing = ctx.nums.get(slug);
+  if (existing !== void 0) return existing;
+  const n = ctx.nums.size + 1;
+  ctx.nums.set(slug, n);
+  return n;
+}
+function escapeHtml(value) {
+  let out = "";
+  for (let i = 0; i < value.length; i++) {
+    const ch = value.charCodeAt(i);
+    switch (ch) {
+      case 38:
+        out += "&amp;";
+        break;
+      case 60:
+        out += "&lt;";
+        break;
+      case 62:
+        out += "&gt;";
+        break;
+      case 34:
+        out += "&quot;";
+        break;
+      default:
+        out += value[i];
+    }
+  }
+  return out;
+}
+function slugFootnoteId(id) {
+  const slug = id.replace(/[^A-Za-z0-9_-]+/g, "-");
+  return slug === "" ? "_" : slug;
+}
+function safeUrl(url) {
+  if (typeof url !== "string" || url.length === 0) return "#";
+  const trimmed = url.trim().slice(0, MAX_URL2);
+  if (trimmed === "") return "#";
+  const probe = trimmed.replace(/[\u0000-\u0020\u007f]/g, "").toLowerCase();
+  if (probe === "") return "#";
+  if (SAFE_SCHEMES.test(probe)) return trimmed;
+  if (/^[a-z][a-z0-9+.-]*:/.test(probe)) return "#";
+  return trimmed;
+}
+function attrUrl(url) {
+  return escapeHtml(safeUrl(url));
+}
+function renderInline(nodes, options) {
+  return inlineRun(nodes, options, newFnCtx());
+}
+function inlineRun(nodes, options, ctx) {
+  let out = "";
+  for (const node of nodes) out += renderInlineNode(node, options, ctx);
+  return out;
+}
+function renderInlineNode(node, options, ctx) {
+  switch (node.type) {
+    case "text":
+      return escapeHtml(node.value);
+    case "strong":
+      return `<strong>${inlineRun(node.children, options, ctx)}</strong>`;
+    case "emphasis":
+      return `<em>${inlineRun(node.children, options, ctx)}</em>`;
+    case "strikethrough":
+      return `<del>${inlineRun(node.children, options, ctx)}</del>`;
+    case "inlineCode":
+      return `<code>${escapeHtml(node.value)}</code>`;
+    case "link": {
+      const title = node.title ? ` title="${escapeHtml(node.title)}"` : "";
+      return `<a href="${attrUrl(node.url)}"${title}>${inlineRun(node.children, options, ctx)}</a>`;
+    }
+    case "image": {
+      const title = node.title ? ` title="${escapeHtml(node.title)}"` : "";
+      return `<img src="${attrUrl(node.url)}" alt="${escapeHtml(node.alt)}"${title}>`;
+    }
+    case "autolink":
+      return `<a href="${attrUrl(node.url)}">${escapeHtml(node.url)}</a>`;
+    case "break":
+      return node.hard ? "<br>\n" : "\n";
+    case "math":
+      return options?.math ? options.math(node.value, node.display) : `<span class="tw-math-src">${escapeHtml(node.value)}</span>`;
+    case "footnoteRef": {
+      const slug = slugFootnoteId(node.id);
+      const n = fnNumber(ctx, slug);
+      const safe = escapeHtml(slug);
+      return `<sup class="tw-fnref" id="fnref-${safe}"><a href="#fn-${safe}">[${n}]</a></sup>`;
+    }
+    default: {
+      const _never = node;
+      return _never;
+    }
+  }
+}
+function renderBlockNode(node, options, ctx) {
+  switch (node.type) {
+    case "heading": {
+      const l = node.level;
+      return `<h${l}>${inlineRun(node.children, options, ctx)}</h${l}>`;
+    }
+    case "paragraph":
+      return `<p>${inlineRun(node.children, options, ctx)}</p>`;
+    case "blockquote":
+      return `<blockquote>${renderBlocks(node.children, options, ctx)}</blockquote>`;
+    case "list":
+      return renderList(node.ordered, node.start, node.tight, node.items, options, ctx);
+    case "codeBlock": {
+      const cls = node.lang ? ` class="language-${escapeHtml(node.lang)}"` : "";
+      const body = escapeHtml(node.value);
+      return `<pre><code${cls}>${body}</code></pre>`;
+    }
+    case "thematicBreak":
+      return "<hr>";
+    case "table":
+      return renderTable(node, options, ctx);
+    case "htmlBlock":
+      return `<pre>${escapeHtml(node.value)}</pre>`;
+    case "mathBlock":
+      return options?.math ? options.math(node.value, true) : `<div class="tw-math-src">${escapeHtml(node.value)}</div>`;
+    case "footnoteDef":
+      return `<div class="tw-footnote-def">${renderBlocks(node.children, options, ctx)}</div>`;
+    case "defList": {
+      let out = "";
+      for (const item of node.items) {
+        out += `<dt>${inlineRun(item.term, options, ctx)}</dt>`;
+        for (const def of item.definitions) {
+          out += `<dd>${renderBlocks(def, options, ctx)}</dd>`;
+        }
+      }
+      return `<dl>${out}</dl>`;
+    }
+    default: {
+      const _never = node;
+      return _never;
+    }
+  }
+}
+function renderBlocks(blocks, options, ctx) {
+  let out = "";
+  for (const b of blocks) {
+    if (b.type === "footnoteDef") continue;
+    out += renderBlockNode(b, options, ctx);
+  }
+  return out;
+}
+function renderList(ordered, start, tight, items, options, ctx) {
+  const tag = ordered ? "ol" : "ul";
+  const startAttr = ordered && Number.isFinite(start) && start !== 1 ? ` start="${escapeHtml(String(Math.trunc(start)))}"` : "";
+  let body = "";
+  for (const item of items) body += renderListItem(item, tight, options, ctx);
+  return `<${tag}${startAttr}>${body}</${tag}>`;
+}
+function renderListItem(item, tight, options, ctx) {
+  let checkbox = "";
+  if (item.task !== null) {
+    const checked = item.task === "checked" ? " checked" : "";
+    checkbox = `<input type="checkbox" disabled${checked}> `;
+  }
+  return `<li>${checkbox}${renderItemChildren(item.children, tight, options, ctx)}</li>`;
+}
+function renderItemChildren(children, tight, options, ctx) {
+  if (tight) {
+    let out = "";
+    for (const child of children) {
+      out += child.type === "paragraph" ? inlineRun(child.children, options, ctx) : renderBlockNode(child, options, ctx);
+    }
+    return out;
+  }
+  return renderBlocks(children, options, ctx);
+}
+function renderTable(node, options, ctx) {
+  const align = node.align;
+  const cellStyle = (col) => {
+    const a = align[col];
+    return a ? ` style="text-align:${a}"` : "";
+  };
+  const headCells = renderRow(node.header, "th", cellStyle, options, ctx);
+  const head = `<thead><tr>${headCells}</tr></thead>`;
+  let bodyRows = "";
+  for (const row of node.rows) {
+    bodyRows += `<tr>${renderRow(row, "td", cellStyle, options, ctx)}</tr>`;
+  }
+  const body = `<tbody>${bodyRows}</tbody>`;
+  return `<table>${head}${body}</table>`;
+}
+function renderRow(cells, tag, cellStyle, options, ctx) {
+  let out = "";
+  for (let i = 0; i < cells.length; i++) {
+    const cell = cells[i];
+    out += `<${tag}${cellStyle(i)}>${inlineRun(cell.children, options, ctx)}</${tag}>`;
+  }
+  return out;
+}
+function collectFootnoteDefs(doc) {
+  const defs = [];
+  walk(doc, (n) => {
+    if (n.type === "footnoteDef") {
+      defs.push(n);
+      return false;
+    }
+    return true;
+  });
+  return defs;
+}
+function renderToHtml(doc, options) {
+  const ctx = newFnCtx();
+  let out = renderBlocks(doc.children, options, ctx);
+  const defs = collectFootnoteDefs(doc);
+  if (defs.length > 0) {
+    let items = "";
+    for (const def of defs) {
+      const safe = escapeHtml(slugFootnoteId(def.id));
+      items += `<li id="fn-${safe}">` + renderBlocks(def.children, options, ctx) + ` <a href="#fnref-${safe}" class="tw-fn-back">\u21A9</a></li>`;
+    }
+    out += `<section class="tw-footnotes"><ol>${items}</ol></section>`;
+  }
+  return out;
+}
+
+// src/streaming/anticipate.ts
+function normalizeOpt(o) {
+  const all = (v) => ({
+    emphasis: v,
+    strong: v,
+    code: v,
+    strikethrough: v,
+    links: v,
+    headings: v,
+    fences: v,
+    listItems: v,
+    tables: v,
+    jsx: v
+  });
+  if (o === true || o === void 0) return all(true);
+  if (o === false) return all(false);
+  return { ...all(true), ...o };
+}
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function inlineHtml(text) {
+  const doc = parse(text);
+  const first = doc.children[0];
+  if (first && (first.type === "paragraph" || first.type === "heading")) {
+    return renderInline(first.children);
+  }
+  return esc(text);
+}
+var CARET = '<span class="tw-caret" aria-hidden="true"></span>';
+function indexesOf(line, sub) {
+  const out = [];
+  let i = line.indexOf(sub);
+  while (i >= 0) {
+    out.push(i);
+    i = line.indexOf(sub, i + sub.length);
+  }
+  return out;
+}
+function findOpenLink(line) {
+  const bi = line.lastIndexOf("[");
+  if (bi < 0) return null;
+  const rest = line.slice(bi);
+  if (!rest.includes("]")) return bi;
+  if (/^\[[^\]]*\]\([^)]*$/.test(rest)) return bi;
+  return null;
+}
+function pushEmphasis(line, ch, dbl, cands) {
+  const masked = line.split(dbl).join("

");
+  const idx = [];
+  for (let i = 0; i < masked.length; i++) if (masked[i] === ch) idx.push(i);
+  if (idx.length % 2 === 1) {
+    cands.push({ kind: "emphasis", tag: "em", cls: "tw-pending tw-pending-em", opener: idx[idx.length - 1], dl: 1 });
+  }
+}
+function findOpenRun(line, opt) {
+  const cands = [];
+  if (opt.strong) {
+    const x = indexesOf(line, "**");
+    if (x.length % 2 === 1) cands.push({ kind: "strong", tag: "strong", cls: "tw-pending tw-pending-strong", opener: x[x.length - 1], dl: 2 });
+  }
+  if (opt.strikethrough) {
+    const x = indexesOf(line, "~~");
+    if (x.length % 2 === 1) cands.push({ kind: "strikethrough", tag: "del", cls: "tw-pending tw-pending-del", opener: x[x.length - 1], dl: 2 });
+  }
+  if (opt.code) {
+    const ticks = [];
+    for (const m of line.matchAll(/`+/g)) {
+      if (m[0].length >= 3) continue;
+      for (let k = 0; k < m[0].length; k++) ticks.push(m.index + k);
+    }
+    if (ticks.length % 2 === 1) cands.push({ kind: "code", tag: "code", cls: "tw-pending tw-pending-code", opener: ticks[ticks.length - 1], dl: 1 });
+  }
+  if (opt.links) {
+    const li = findOpenLink(line);
+    if (li !== null) cands.push({ kind: "link", tag: "a", cls: "tw-pending tw-pending-link", opener: li, dl: 1 });
+  }
+  if (opt.emphasis) {
+    pushEmphasis(line, "*", "**", cands);
+    pushEmphasis(line, "_", "__", cands);
+  }
+  if (!cands.length) return null;
+  cands.sort((a, b) => a.opener - b.opener);
+  return cands[0];
+}
+function isFormingJsx(line, opt) {
+  return opt.jsx && /<[A-Z][A-Za-z0-9]*\b[^>]*$/.test(line) && !/\/?>\s*$/.test(line);
+}
+var LIST_ITEM_RE = /^( {0,3})([-+*]|\d{1,9}[.)])[ \t]+(.*)$/;
+function isFormingListItem(line, opt) {
+  return opt.listItems && LIST_ITEM_RE.test(line);
+}
+var TABLE_ROW_RE = /^ {0,3}\|/;
+function splitTableCells(row) {
+  let s = row.trim();
+  if (s.startsWith("|")) s = s.slice(1);
+  if (s.endsWith("|")) s = s.slice(0, -1);
+  return s.split("|").map((c) => c.trim());
+}
+function hasTrailing(line, opt) {
+  if (!line.trim()) return false;
+  return isFormingJsx(line, opt) || isFormingListItem(line, opt) || findOpenRun(line, opt) !== null;
+}
+function renderActiveLine(line, opt, pending, fallback) {
+  if (isFormingJsx(line, opt)) {
+    const name = /<([A-Z][A-Za-z0-9]*)/.exec(line)?.[1] ?? "Component";
+    pending.push("jsx");
+    const label = fallback ? esc(fallback) : `\u2039${esc(name)}\u203A rendering\u2026`;
+    return `<div class="tw-skeleton" data-component="${esc(name)}"><span class="tw-skeleton-label">${label}</span><div class="tw-skeleton-bar"></div><div class="tw-skeleton-bar" style="width:70%"></div></div>`;
+  }
+  if (isFormingListItem(line, opt)) return renderActiveListItem(line, opt, pending);
+  const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+  const body = heading ? heading[2] ?? "" : line;
+  const inner = renderInlineWithOpen(body, opt, pending);
+  if (heading) return `<h${heading[1].length}>${inner}${CARET}</h${heading[1].length}>`;
+  return `<p>${inner}${CARET}</p>`;
+}
+function renderActiveListItem(line, opt, pending) {
+  const m = LIST_ITEM_RE.exec(line);
+  const marker = m[2];
+  const content = m[3] ?? "";
+  pending.push("listItem");
+  const inner = content ? renderInlineWithOpen(content, opt, pending) : "";
+  const li = `<li class="tw-pending tw-pending-li">${inner}${CARET}</li>`;
+  if (/\d/.test(marker)) {
+    const n = parseInt(marker, 10);
+    const startAttr = Number.isFinite(n) && n !== 1 ? ` start="${esc(String(n))}"` : "";
+    return `<ol${startAttr} class="tw-pending tw-pending-list">${li}</ol>`;
+  }
+  return `<ul class="tw-pending tw-pending-list">${li}</ul>`;
+}
+function renderInlineWithOpen(text, opt, pending) {
+  const open = findOpenRun(text, opt);
+  if (!open) return inlineHtml(text);
+  const prefix = text.slice(0, open.opener);
+  pending.push(open.kind);
+  if (open.kind === "link") {
+    const after = text.slice(open.opener + 1);
+    const close = after.indexOf("]");
+    const label = close >= 0 ? after.slice(0, close) : after;
+    return `${inlineHtml(prefix)}<a class="${open.cls}">${inlineHtml(label)}</a>`;
+  }
+  const content = text.slice(open.opener + open.dl);
+  const inner = open.kind === "code" ? esc(content) : inlineHtml(content);
+  return `${inlineHtml(prefix)}<${open.tag} class="${open.cls}">${inner}</${open.tag}>`;
+}
+function renderOpenFence(block, pending) {
+  const nl = block.indexOf("\n");
+  const info = block.slice(3, nl < 0 ? block.length : nl).trim();
+  const lang = info.split(/\s+/)[0] ?? "";
+  const code = nl < 0 ? "" : block.slice(nl + 1);
+  pending.push("code");
+  const langAttr = lang ? ` class="language-${esc(lang)}"` : "";
+  return `<pre class="tw-codeblock"><code${langAttr}>${esc(code)}${CARET}</code></pre>`;
+}
+function renderActiveTableRow(row, pending) {
+  const cells = splitTableCells(row);
+  pending.push("tableRow");
+  let tds = "";
+  for (let i = 0; i < cells.length; i++) {
+    const caret = i === cells.length - 1 ? CARET : "";
+    tds += `<td>${cells[i] ? inlineHtml(cells[i]) : ""}${caret}</td>`;
+  }
+  return `<table class="tw-pending tw-pending-table"><tbody><tr>${tds}</tr></tbody></table>`;
+}
+function anticipate(partial, options = true, componentFallback) {
+  const opt = normalizeOpt(options);
+  const pending = [];
+  if (!partial) return { html: "", pending };
+  const fenceCount = (partial.match(/^```/gm) ?? []).length;
+  if (opt.fences && fenceCount % 2 === 1) {
+    const idx = partial.lastIndexOf("```");
+    const committed2 = partial.slice(0, idx).replace(/\n+$/, "");
+    const open = partial.slice(idx);
+    const committedHtml2 = committed2.trim() ? renderToHtml(parse(committed2)) : "";
+    return { html: committedHtml2 + renderOpenFence(open, pending), pending };
+  }
+  if (opt.tables) {
+    const nl = partial.lastIndexOf("\n");
+    if (nl >= 0) {
+      const row = partial.slice(nl + 1);
+      if (TABLE_ROW_RE.test(row)) {
+        const committed2 = partial.slice(0, nl);
+        const doc = parse(committed2);
+        const last = doc.children[doc.children.length - 1];
+        if (last && last.type === "table") {
+          return { html: renderToHtml(doc) + renderActiveTableRow(row, pending), pending };
+        }
+      }
+    }
+  }
+  const lastNl = partial.lastIndexOf("\n");
+  const active = lastNl >= 0 ? partial.slice(lastNl + 1) : partial;
+  if (!hasTrailing(active, opt)) {
+    return { html: renderToHtml(parse(partial)), pending };
+  }
+  const committed = lastNl >= 0 ? partial.slice(0, lastNl) : "";
+  const committedHtml = committed.trim() ? renderToHtml(parse(committed)) : "";
+  return { html: committedHtml + renderActiveLine(active, opt, pending, componentFallback), pending };
+}
+
+// src/streaming/index.ts
+var DEFAULT_CPS = 220;
+var TICK_MS = 1e3 / 30;
+function createStreamController(onUpdate, options = {}) {
+  const smoothCfg = !options.smooth ? null : typeof options.smooth === "object" ? options.smooth : { charsPerSecond: DEFAULT_CPS };
+  const cps = smoothCfg && smoothCfg.charsPerSecond > 0 ? smoothCfg.charsPerSecond : DEFAULT_CPS;
+  const perTick = Math.max(1, Math.round(cps * TICK_MS / 1e3));
+  let text = "";
+  let revealed = 0;
+  let complete = false;
+  let timer = null;
+  const emit = () => onUpdate(smoothCfg ? text.slice(0, revealed) : text, complete);
+  const stopTimer = () => {
+    if (timer !== null) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+  const tick = () => {
+    revealed = Math.min(text.length, revealed + perTick);
+    emit();
+    if (revealed >= text.length) stopTimer();
+  };
+  const ensureTimer = () => {
+    if (timer !== null || complete || revealed >= text.length) return;
+    timer = setInterval(tick, TICK_MS);
+  };
+  return {
+    push(chunk) {
+      if (complete) return;
+      text += chunk;
+      if (smoothCfg) ensureTimer();
+      emit();
+    },
+    replace(full) {
+      text = full;
+      complete = false;
+      if (smoothCfg) {
+        if (revealed > text.length) revealed = text.length;
+        ensureTimer();
+      }
+      emit();
+    },
+    end() {
+      complete = true;
+      revealed = text.length;
+      stopTimer();
+      emit();
+    },
+    reset() {
+      text = "";
+      revealed = 0;
+      complete = false;
+      stopTimer();
+      emit();
+    },
+    get text() {
+      return text;
+    },
+    get complete() {
+      return complete;
+    }
+  };
+}
+async function pipeStream(source, controller) {
+  if (Symbol.asyncIterator in source) {
+    for await (const chunk of source) {
+      controller.push(chunk);
+    }
+  } else {
+    const reader = source.getReader();
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value != null) controller.push(value);
+    }
+  }
+  controller.end();
+}
+
+exports.anticipate = anticipate;
+exports.createStreamController = createStreamController;
+exports.pipeStream = pipeStream;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map