typewright 0.2.1

package/dist/chunk-M6IVEMXO.js

@@ -0,0 +1,1398 @@
+// src/core/ast.ts
+var INLINE_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "emphasis",
+  "strong",
+  "strikethrough",
+  "inlineCode",
+  "link",
+  "image",
+  "autolink",
+  "break",
+  "math",
+  "footnoteRef"
+]);
+function isInline(node) {
+  return INLINE_TYPES.has(node.type);
+}
+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 };
+}
+function headSafety(block) {
+  switch (block.type) {
+    case "heading":
+    case "thematicBreak":
+    case "mathBlock":
+      return "always";
+    case "codeBlock":
+      return block.fenced ? "always" : "never";
+    case "paragraph":
+    case "table":
+    case "htmlBlock":
+    case "blockquote":
+      return "needs-blank";
+    default:
+      return "never";
+  }
+}
+function prevLineIsBlank(src, lineStart) {
+  if (lineStart <= 0) return false;
+  const end = lineStart - 1;
+  let start = end - 1;
+  while (start >= 0 && src[start] !== "\n") start--;
+  start += 1;
+  return src.slice(start, end).trim() === "";
+}
+function blankLineFullyAfter(src, lineStart, minStart) {
+  if (lineStart <= 0) return false;
+  const end = lineStart - 1;
+  let start = end - 1;
+  while (start >= 0 && src[start] !== "\n") start--;
+  start += 1;
+  if (start < minStart) return false;
+  return src.slice(start, end).trim() === "";
+}
+function shiftBlock(block, delta) {
+  const clone = structuredClone(block);
+  walk(clone, (n) => {
+    const p = n;
+    p.from += delta;
+    p.to += delta;
+    if (typeof p.contentFrom === "number") p.contentFrom += delta;
+  });
+  return clone;
+}
+function lineStartingAt(lines, off) {
+  let lo = 0;
+  let hi = lines.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    const f = lines[mid].from;
+    if (f === off) return mid;
+    if (f < off) lo = mid + 1;
+    else hi = mid - 1;
+  }
+  return -1;
+}
+function lastBlockAtOrBefore(blocks, off) {
+  let lo = 0;
+  let hi = blocks.length - 1;
+  let ans = -1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    if (blocks[mid].from <= off) {
+      ans = mid;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return ans;
+}
+var MAX_JOIN_ATTEMPTS = 4;
+function tryReuseSuffix(blocks, prevSrc, to, delta, nextLines, cLine) {
+  const dEnd = lastBlockAtOrBefore(blocks, to);
+  let attempts = 0;
+  for (let j = dEnd + 1; j < blocks.length; j++) {
+    const joinOff = blocks[j].from;
+    if (joinOff < to) continue;
+    if (!blankLineFullyAfter(prevSrc, joinOff, to)) continue;
+    const nextJoinOff = joinOff + delta;
+    const joinLine = lineStartingAt(nextLines, nextJoinOff);
+    if (joinLine <= cLine) continue;
+    if (++attempts > MAX_JOIN_ATTEMPTS) break;
+    const guard = parseBlocks(nextLines.slice(cLine, joinLine + 1));
+    const dirty = [];
+    let proven = false;
+    for (const b of guard) {
+      if (b.from === nextJoinOff) {
+        proven = true;
+        break;
+      }
+      if (b.from > nextJoinOff) break;
+      dirty.push(b);
+    }
+    if (!proven) continue;
+    const rest = blocks.slice(j);
+    const shifted = rest.map((b) => shiftBlock(b, delta));
+    return { dirty, shifted, endLine: joinLine, count: rest.length };
+  }
+  return null;
+}
+function runIncremental(prev, prevSrc, change, nextSrc, options) {
+  const nextLines = splitLines(nextSrc);
+  const total = nextLines.length;
+  const full = () => ({
+    doc: parse(nextSrc, options),
+    stats: {
+      fellBack: true,
+      reusedBlocks: 0,
+      reparsedFromLine: 0,
+      reparsedToLine: total,
+      reusedSuffixBlocks: 0,
+      totalLines: total
+    }
+  });
+  const from = Math.max(0, Math.min(change.from, change.to));
+  const to = Math.min(prevSrc.length, Math.max(change.from, change.to));
+  if (to < from) return full();
+  if (nextSrc.length !== prevSrc.length + change.insert.length - (to - from)) return full();
+  if (prevSrc.slice(0, from) !== nextSrc.slice(0, from)) return full();
+  const delta = change.insert.length - (to - from);
+  const blocks = prev.children;
+  const hi = Math.min(blocks.length - 1, lastBlockAtOrBefore(blocks, from));
+  for (let k = hi; k >= 1; k--) {
+    const cut = blocks[k].from;
+    if (cut > from) continue;
+    const safety = headSafety(blocks[k - 1]);
+    if (safety === "never") continue;
+    if (safety === "needs-blank" && !prevLineIsBlank(prevSrc, cut)) continue;
+    const c = lineStartingAt(nextLines, cut);
+    if (c < 0) continue;
+    opts = {
+      math: options?.math === true,
+      footnotes: options?.footnotes === true,
+      defLists: options?.defLists === true
+    };
+    const suffix = tryReuseSuffix(blocks, prevSrc, to, delta, nextLines, c);
+    if (suffix) {
+      const children2 = blocks.slice(0, k).concat(suffix.dirty, suffix.shifted);
+      return {
+        doc: { type: "document", from: 0, to: nextSrc.length, children: children2 },
+        stats: {
+          fellBack: false,
+          reusedBlocks: k,
+          reparsedFromLine: c,
+          reparsedToLine: suffix.endLine,
+          reusedSuffixBlocks: suffix.count,
+          totalLines: total
+        }
+      };
+    }
+    const tail = parseBlocks(nextLines.slice(c));
+    const children = blocks.slice(0, k).concat(tail);
+    return {
+      doc: { type: "document", from: 0, to: nextSrc.length, children },
+      stats: {
+        fellBack: false,
+        reusedBlocks: k,
+        reparsedFromLine: c,
+        reparsedToLine: total,
+        reusedSuffixBlocks: 0,
+        totalLines: total
+      }
+    };
+  }
+  return full();
+}
+function parseIncremental(prev, prevSrc, change, nextSrc, options) {
+  return runIncremental(prev, prevSrc, change, nextSrc, options).doc;
+}
+
+// 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 renderNode(node, options) {
+  return renderBlockNode(node, options, newFnCtx());
+}
+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 = options?.highlight ? options.highlight(node.lang, node.value) : 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;
+}
+
+export { childrenOf, isInline, parse, parseIncremental, renderInline, renderNode, renderToHtml, safeUrl, walk };
+//# sourceMappingURL=chunk-M6IVEMXO.js.map
+//# sourceMappingURL=chunk-M6IVEMXO.js.map