typewright 0.2.1

package/dist/core/index.cjs

@@ -0,0 +1,2952 @@
+'use strict';
+
+// 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 commit2 = (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) {
+          commit2(r);
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (c === "$" && opts.math) {
+        const r = tryMath(i, end);
+        if (r) {
+          commit2(r);
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (c === "<") {
+        const r = tryAutolink(i, end);
+        if (r) {
+          commit2(r);
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (c === "!" && buf[i + 1] === "[") {
+        const r = tryLink(i, end, true);
+        if (r) {
+          commit2(r);
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (c === "[") {
+        if (opts.footnotes && buf[i + 1] === "^") {
+          const rf = tryFootnoteRef(i, end);
+          if (rf) {
+            commit2(rf);
+            continue;
+          }
+        }
+        const r = tryLink(i, end, false);
+        if (r) {
+          commit2(r);
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (c === "*" || c === "_" || c === "~") {
+        const r = tryEmph(i, end);
+        if (r) {
+          commit2(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, lineStart2) {
+  if (lineStart2 <= 0) return false;
+  const end = lineStart2 - 1;
+  let start = end - 1;
+  while (start >= 0 && src[start] !== "\n") start--;
+  start += 1;
+  return src.slice(start, end).trim() === "";
+}
+function blankLineFullyAfter(src, lineStart2, minStart) {
+  if (lineStart2 <= 0) return false;
+  const end = lineStart2 - 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;
+}
+
+// src/core/unified.ts
+function collectMarkers(doc, source) {
+  const markers = [];
+  const push = (from, to, kind) => {
+    if (to > from) markers.push({ from, to, kind });
+  };
+  walk(doc, (node) => {
+    switch (node.type) {
+      case "heading": {
+        push(node.from, node.contentFrom, "heading");
+        break;
+      }
+      case "emphasis":
+      case "strong":
+      case "strikethrough": {
+        const kind = node.type === "strikethrough" ? "strike" : node.type;
+        const kids = node.children;
+        const first = kids[0];
+        const last = kids[kids.length - 1];
+        const innerFrom = first ? first.from : node.to;
+        const innerTo = last ? last.to : node.from;
+        push(node.from, innerFrom, kind);
+        push(innerTo, node.to, kind);
+        break;
+      }
+      case "inlineCode": {
+        const ticks = Math.max(1, node.ticks);
+        const openTo = Math.min(node.from + ticks, node.to);
+        const closeFrom = Math.max(node.to - ticks, openTo);
+        push(node.from, openTo, "code");
+        push(closeFrom, node.to, "code");
+        break;
+      }
+      case "link": {
+        const kids = node.children;
+        const last = kids[kids.length - 1];
+        const textEnd = last ? last.to : node.from + 1;
+        const midTo = Math.min(textEnd + 2, node.to);
+        push(node.from, Math.min(node.from + 1, node.to), "link");
+        push(textEnd, midTo, "link");
+        push(midTo, node.to - 1, "link");
+        push(Math.max(node.to - 1, node.from), node.to, "link");
+        break;
+      }
+      case "image": {
+        const bracketOpen = node.from + 1;
+        const altStart = bracketOpen + 1;
+        const altEnd = Math.min(altStart + node.alt.length, node.to);
+        const midTo = Math.min(altEnd + 2, node.to);
+        push(node.from, Math.min(node.from + 1, node.to), "image");
+        push(bracketOpen, Math.min(bracketOpen + 1, node.to), "image");
+        push(altEnd, midTo, "image");
+        push(midTo, node.to - 1, "image");
+        push(Math.max(node.to - 1, node.from), node.to, "image");
+        break;
+      }
+      case "listItem": {
+        push(node.from, node.contentFrom, "listMarker");
+        break;
+      }
+      case "math": {
+        const delim = node.display ? 2 : 1;
+        const openTo = Math.min(node.from + delim, node.to);
+        const closeFrom = Math.max(node.to - delim, openTo);
+        push(node.from, openTo, "math");
+        push(closeFrom, node.to, "math");
+        break;
+      }
+      case "footnoteRef": {
+        const openTo = Math.min(node.from + 2, node.to);
+        const closeFrom = Math.max(node.to - 1, openTo);
+        push(node.from, openTo, "footnoteRef");
+        push(closeFrom, node.to, "footnoteRef");
+        break;
+      }
+      case "codeBlock": {
+        if (!source || !node.fenced) break;
+        let openTo = source.indexOf("\n", node.from);
+        if (openTo === -1 || openTo > node.to) openTo = node.to;
+        if (openTo > node.from && source[openTo - 1] === "\r") openTo--;
+        push(node.from, openTo, "fence");
+        const closeStart = source.lastIndexOf("\n", node.to - 1) + 1;
+        if (closeStart > node.from) {
+          const closeText = source.slice(closeStart, node.to);
+          const cm = /^( {0,3})(`{3,}|~{3,}) *$/.exec(closeText);
+          const om = /^ {0,3}([`~])/.exec(source.slice(node.from, openTo));
+          if (cm && om && cm[2][0] === om[1]) push(closeStart, node.to, "fence");
+        }
+        break;
+      }
+      case "blockquote": {
+        if (!source) break;
+        const lineStart2 = source.lastIndexOf("\n", node.from - 1) + 1;
+        if (lineStart2 !== node.from) break;
+        let p = node.from;
+        while (p < node.to) {
+          let end = source.indexOf("\n", p);
+          if (end === -1 || end > node.to) end = node.to;
+          const qm = /^(?: {0,3}> ?)+/.exec(source.slice(p, end));
+          if (qm) push(p, p + qm[0].length, "blockquote");
+          p = end + 1;
+        }
+        break;
+      }
+    }
+    return true;
+  });
+  return markers;
+}
+function hiddenMarkers(doc, sel, source) {
+  const lo = Math.min(sel.from, sel.to) - 1;
+  const hi = Math.max(sel.from, sel.to) + 1;
+  const intersects = (m) => m.from < hi && lo < m.to;
+  return collectMarkers(doc, source).filter((m) => !intersects(m));
+}
+function activeBlockIndex(doc, offset) {
+  const blocks = doc.children;
+  for (let i = 0; i < blocks.length; i++) {
+    const b = blocks[i];
+    if (b && offset >= b.from && offset <= b.to) return i;
+  }
+  return -1;
+}
+
+// src/core/fold.ts
+function headingFoldRanges(doc) {
+  const blocks = doc.children;
+  const ranges = [];
+  for (let i = 0; i < blocks.length; i++) {
+    const h = blocks[i];
+    if (!h || h.type !== "heading") continue;
+    let to = doc.to;
+    for (let j = i + 1; j < blocks.length; j++) {
+      const n = blocks[j];
+      if (n && n.type === "heading" && n.level <= h.level) {
+        to = n.from;
+        break;
+      }
+    }
+    const from = h.to;
+    if (to > from) {
+      ranges.push({ headingFrom: h.from, level: h.level, from, to });
+    }
+  }
+  return ranges;
+}
+
+// src/core/commands.ts
+var COMMANDS = [
+  { id: "bold", label: "Bold", kbd: "\u2318B", group: "inline" },
+  { id: "italic", label: "Italic", kbd: "\u2318I", group: "inline" },
+  { id: "strikethrough", label: "Strikethrough", group: "inline" },
+  { id: "inlineCode", label: "Inline Code", kbd: "\u2318E", group: "inline" },
+  { id: "link", label: "Link", kbd: "\u2318K", group: "inline" },
+  { id: "heading1", label: "Heading 1", group: "block" },
+  { id: "heading2", label: "Heading 2", group: "block" },
+  { id: "heading3", label: "Heading 3", group: "block" },
+  { id: "heading4", label: "Heading 4", group: "block" },
+  { id: "heading5", label: "Heading 5", group: "block" },
+  { id: "heading6", label: "Heading 6", group: "block" },
+  { id: "bulletList", label: "Bullet List", group: "block" },
+  { id: "orderedList", label: "Ordered List", group: "block" },
+  { id: "taskList", label: "Task List", group: "block" },
+  { id: "quote", label: "Quote", group: "block" },
+  { id: "horizontalRule", label: "Horizontal Rule", group: "insert" },
+  { id: "codeBlock", label: "Code Block", group: "insert" },
+  { id: "table", label: "Table", group: "insert" }
+];
+function norm(sel) {
+  return { from: Math.min(sel.from, sel.to), to: Math.max(sel.from, sel.to) };
+}
+function toggleWrap(text, sel, marker) {
+  const len = marker.length;
+  const { from, to } = norm(sel);
+  if (from >= len && text.slice(from - len, from) === marker && text.slice(to, to + len) === marker) {
+    const t2 = text.slice(0, from - len) + text.slice(from, to) + text.slice(to + len);
+    return { text: t2, selection: { from: from - len, to: to - len } };
+  }
+  const selected = text.slice(from, to);
+  if (selected.length >= 2 * len && selected.startsWith(marker) && selected.endsWith(marker)) {
+    const inner = selected.slice(len, selected.length - len);
+    const t2 = text.slice(0, from) + inner + text.slice(to);
+    return { text: t2, selection: { from, to: from + inner.length } };
+  }
+  const t = text.slice(0, from) + marker + selected + marker + text.slice(to);
+  if (from === to) return { text: t, selection: { from: from + len, to: from + len } };
+  return { text: t, selection: { from: from + len, to: to + len } };
+}
+function insertLink(text, sel) {
+  const { from, to } = norm(sel);
+  const label = text.slice(from, to) || "text";
+  const url = "https://";
+  const inserted = `[${label}](${url})`;
+  const t = text.slice(0, from) + inserted + text.slice(to);
+  const urlStart = from + label.length + 3;
+  return { text: t, selection: { from: urlStart, to: urlStart + url.length } };
+}
+var HEADING_RE = /^ {0,3}#{1,6}\s+/;
+var LIST_RE = /^ {0,3}(?:[-*+]\s(?:\[[ xX]\]\s)?|\d+[.)]\s)/;
+var QUOTE_RE = /^ {0,3}>\s?/;
+function applyLinePrefix(text, sel, p) {
+  const { from, to } = norm(sel);
+  const start = text.lastIndexOf("\n", from - 1) + 1;
+  const searchFrom = to > from ? to - 1 : to;
+  let end = text.indexOf("\n", searchFrom);
+  if (end === -1) end = text.length;
+  const lines = text.slice(start, end).split("\n");
+  const allHave = lines.every((l) => l.trim() === "" || p.has(l));
+  const out = lines.map((l, i) => l.trim() === "" ? l : allHave ? p.strip(l) : p.add(p.strip(l), i)).join("\n");
+  const t = text.slice(0, start) + out + text.slice(end);
+  return { text: t, selection: { from: start, to: start + out.length } };
+}
+function stripAllPrefixes(line) {
+  return line.replace(HEADING_RE, "").replace(LIST_RE, "").replace(QUOTE_RE, "");
+}
+function insertBlock(text, sel, block, selectInner) {
+  const { from, to } = norm(sel);
+  const before = text.slice(0, from);
+  const after = text.slice(to);
+  const lead = before === "" || before.endsWith("\n\n") ? "" : before.endsWith("\n") ? "\n" : "\n\n";
+  const trail = after === "" || after.startsWith("\n\n") ? "" : after.startsWith("\n") ? "\n" : "\n\n";
+  const insertedAt = from + lead.length;
+  const t = before + lead + block + trail + after;
+  const selection = selectInner ? { from: insertedAt + selectInner[0], to: insertedAt + selectInner[1] } : { from: insertedAt, to: insertedAt + block.length };
+  return { text: t, selection };
+}
+function applyCommand(text, sel, cmd) {
+  switch (cmd) {
+    case "bold":
+      return toggleWrap(text, sel, "**");
+    case "italic":
+      return toggleWrap(text, sel, "*");
+    case "strikethrough":
+      return toggleWrap(text, sel, "~~");
+    case "inlineCode":
+      return toggleWrap(text, sel, "`");
+    case "link":
+      return insertLink(text, sel);
+    case "heading1":
+    case "heading2":
+    case "heading3":
+    case "heading4":
+    case "heading5":
+    case "heading6": {
+      const level = cmd === "heading1" ? 1 : cmd === "heading2" ? 2 : cmd === "heading3" ? 3 : cmd === "heading4" ? 4 : cmd === "heading5" ? 5 : 6;
+      const marker = "#".repeat(level) + " ";
+      return applyLinePrefix(text, sel, {
+        has: (l) => new RegExp(`^ {0,3}#{${level}}\\s`).test(l),
+        strip: (l) => l.replace(HEADING_RE, ""),
+        add: (l) => marker + l
+      });
+    }
+    case "bulletList":
+      return applyLinePrefix(text, sel, {
+        has: (l) => /^ {0,3}[-*+]\s/.test(l),
+        strip: stripAllPrefixes,
+        add: (l) => "- " + l
+      });
+    case "orderedList":
+      return applyLinePrefix(text, sel, {
+        has: (l) => /^ {0,3}\d+[.)]\s/.test(l),
+        strip: stripAllPrefixes,
+        add: (l, i) => `${i + 1}. ` + l
+      });
+    case "taskList":
+      return applyLinePrefix(text, sel, {
+        has: (l) => /^ {0,3}[-*+]\s\[[ xX]\]\s/.test(l),
+        strip: stripAllPrefixes,
+        add: (l) => "- [ ] " + l
+      });
+    case "quote":
+      return applyLinePrefix(text, sel, {
+        has: (l) => QUOTE_RE.test(l),
+        strip: (l) => l.replace(QUOTE_RE, ""),
+        add: (l) => "> " + l
+      });
+    case "horizontalRule":
+      return insertBlock(text, sel, "---");
+    case "codeBlock": {
+      const selected = text.slice(norm(sel).from, norm(sel).to);
+      const block = "```\n" + selected + "\n```";
+      return insertBlock(text, sel, block, selected ? void 0 : [4, 4]);
+    }
+    case "table": {
+      const block = "| Column | Column |\n| --- | --- |\n| Cell | Cell |";
+      return insertBlock(text, sel, block, [2, 8]);
+    }
+    default: {
+      return { text, selection: norm(sel) };
+    }
+  }
+}
+
+// src/core/text.ts
+var TextDoc = class _TextDoc {
+  text;
+  _lineStarts = null;
+  constructor(text = "") {
+    this.text = text;
+  }
+  get length() {
+    return this.text.length;
+  }
+  /** Apply one change, returning a new document. */
+  apply(change) {
+    const { from, to, insert } = normalize(change, this.text.length);
+    return new _TextDoc(this.text.slice(0, from) + insert + this.text.slice(to));
+  }
+  /**
+   * Apply several changes, returning a new document. Changes are given in
+   * document coordinates of THIS doc; they are applied right-to-left so earlier
+   * offsets stay valid.
+   */
+  applyAll(changes) {
+    const sorted = [...changes].sort((a, b) => b.from - a.from);
+    let text = this.text;
+    for (const c of sorted) {
+      const { from, to, insert } = normalize(c, text.length);
+      text = text.slice(0, from) + insert + text.slice(to);
+    }
+    return new _TextDoc(text);
+  }
+  lineStarts() {
+    if (this._lineStarts) return this._lineStarts;
+    const starts = [0];
+    for (let i = 0; i < this.text.length; i++) {
+      if (this.text.charCodeAt(i) === 10) starts.push(i + 1);
+    }
+    this._lineStarts = starts;
+    return starts;
+  }
+  /** Total number of lines (a trailing newline yields an extra empty line). */
+  get lines() {
+    return this.lineStarts().length;
+  }
+  /** The line (1-based) containing `offset`. */
+  lineAt(offset) {
+    const off = clamp(offset, 0, this.text.length);
+    const starts = this.lineStarts();
+    let lo = 0;
+    let hi = starts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (starts[mid] <= off) lo = mid;
+      else hi = mid - 1;
+    }
+    const from = starts[lo];
+    const nextStart = starts[lo + 1];
+    const to = nextStart === void 0 ? this.text.length : nextStart - 1;
+    return { number: lo + 1, from, to, text: this.text.slice(from, to) };
+  }
+  /** Line/column (both 1-based) for an offset. */
+  positionAt(offset) {
+    const line = this.lineAt(offset);
+    return { line: line.number, column: clamp(offset, 0, this.text.length) - line.from + 1 };
+  }
+  /** Offset for a 1-based line/column. */
+  offsetAt(line, column) {
+    const starts = this.lineStarts();
+    const idx = clamp(line, 1, starts.length) - 1;
+    const from = starts[idx];
+    const nextStart = starts[idx + 1];
+    const to = nextStart === void 0 ? this.text.length : nextStart - 1;
+    return clamp(from + (column - 1), from, to);
+  }
+  /**
+   * Map an offset from this document's coordinates to the coordinates AFTER the
+   * given change(s). `assoc` controls which side of an insertion at the offset
+   * the mapped position sticks to: -1 = before (default), 1 = after.
+   */
+  mapOffset(offset, changes, assoc = -1) {
+    const list = Array.isArray(changes) ? changes : [changes];
+    const ordered = [...list].sort((a, b) => a.from - b.from);
+    let result = offset;
+    for (const c of ordered) {
+      const { from, to, insert } = normalize(c, Number.MAX_SAFE_INTEGER);
+      const delta = insert.length - (to - from);
+      if (result < from) continue;
+      if (result > to) {
+        result += delta;
+      } else if (result === from && assoc < 0) ; else if (result === to && assoc > 0) {
+        result += delta;
+      } else {
+        result = assoc < 0 ? from : from + insert.length;
+      }
+    }
+    return result;
+  }
+  toString() {
+    return this.text;
+  }
+};
+function normalize(change, len) {
+  let from = clamp(Math.min(change.from, change.to), 0, len);
+  let to = clamp(Math.max(change.from, change.to), 0, len);
+  return { from, to, insert: change.insert };
+}
+function clamp(n, lo, hi) {
+  return n < lo ? lo : n > hi ? hi : n;
+}
+
+// src/core/highlight.ts
+function escapeHtml2(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.charAt(i);
+    }
+  }
+  return out;
+}
+function span(kind, text) {
+  return `<span class="tw-tok-${kind}">${escapeHtml2(text)}</span>`;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+function isIdentStart(ch) {
+  return ch >= 65 && ch <= 90 || // A-Z
+  ch >= 97 && ch <= 122 || // a-z
+  ch === 95 || // _
+  ch === 36;
+}
+function isIdentPart(ch) {
+  return isIdentStart(ch) || isDigit(ch);
+}
+function isNumberPart(ch) {
+  return isDigit(ch) || ch === 46 || // .
+  ch === 95 || // _ separator
+  ch === 120 || // x
+  ch === 88 || // X
+  ch === 111 || // o
+  ch === 79 || // O
+  ch === 98 || // b
+  ch === 66 || // B
+  ch >= 97 && ch <= 102 || // a-f (hex + exponent 'e')
+  ch >= 65 && ch <= 70;
+}
+function isPunct(ch) {
+  switch (ch) {
+    case 123:
+    // {
+    case 125:
+    // }
+    case 40:
+    // (
+    case 41:
+    // )
+    case 91:
+    // [
+    case 93:
+    // ]
+    case 60:
+    // <
+    case 62:
+    // >
+    case 61:
+    // =
+    case 43:
+    // +
+    case 45:
+    // -
+    case 42:
+    // *
+    case 47:
+    // /
+    case 37:
+    // %
+    case 33:
+    // !
+    case 63:
+    // ?
+    case 58:
+    // :
+    case 59:
+    // ;
+    case 44:
+    // ,
+    case 46:
+    // .
+    case 38:
+    // &
+    case 124:
+    // |
+    case 94:
+    // ^
+    case 126:
+    // ~
+    case 64:
+      return true;
+    default:
+      return false;
+  }
+}
+function prevNonSpace(code, i) {
+  let k = i - 1;
+  while (k >= 0) {
+    const c = code.charCodeAt(k);
+    if (c === 32 || c === 9 || c === 10 || c === 13) {
+      k--;
+      continue;
+    }
+    return c;
+  }
+  return 0;
+}
+function consumeString(code, start, quote) {
+  const n = code.length;
+  let j = start + 1;
+  while (j < n) {
+    const c = code.charCodeAt(j);
+    if (c === 92) {
+      j += 2;
+      continue;
+    }
+    if (c === quote) {
+      return j + 1;
+    }
+    if (quote !== 96 && c === 10) {
+      return j;
+    }
+    j++;
+  }
+  return n;
+}
+var JS_KEYWORDS = /* @__PURE__ */ new Set([
+  "abstract",
+  "any",
+  "as",
+  "asserts",
+  "async",
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "declare",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "from",
+  "function",
+  "get",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "infer",
+  "instanceof",
+  "interface",
+  "is",
+  "keyof",
+  "let",
+  "namespace",
+  "new",
+  "null",
+  "of",
+  "override",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "return",
+  "satisfies",
+  "set",
+  "static",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "type",
+  "typeof",
+  "undefined",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield"
+]);
+var TS_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "symbol",
+  "bigint",
+  "unknown",
+  "never",
+  "Array",
+  "Record",
+  "Promise",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Date",
+  "RegExp",
+  "Error"
+]);
+var PY_KEYWORDS = /* @__PURE__ */ new Set([
+  "and",
+  "as",
+  "assert",
+  "async",
+  "await",
+  "break",
+  "case",
+  "class",
+  "continue",
+  "def",
+  "del",
+  "elif",
+  "else",
+  "except",
+  "False",
+  "finally",
+  "for",
+  "from",
+  "global",
+  "if",
+  "import",
+  "in",
+  "is",
+  "lambda",
+  "match",
+  "None",
+  "nonlocal",
+  "not",
+  "or",
+  "pass",
+  "raise",
+  "return",
+  "True",
+  "try",
+  "while",
+  "with",
+  "yield"
+]);
+var BASH_KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "then",
+  "else",
+  "elif",
+  "fi",
+  "for",
+  "while",
+  "until",
+  "do",
+  "done",
+  "case",
+  "esac",
+  "in",
+  "function",
+  "select",
+  "time",
+  "return",
+  "break",
+  "continue",
+  "echo",
+  "cd",
+  "export",
+  "local",
+  "read",
+  "printf",
+  "source",
+  "exit",
+  "set",
+  "unset",
+  "test",
+  "eval",
+  "exec",
+  "trap",
+  "shift"
+]);
+var SQL_KEYWORDS = /* @__PURE__ */ new Set([
+  "add",
+  "all",
+  "alter",
+  "and",
+  "as",
+  "asc",
+  "auto_increment",
+  "begin",
+  "between",
+  "by",
+  "case",
+  "column",
+  "commit",
+  "constraint",
+  "create",
+  "cross",
+  "default",
+  "delete",
+  "desc",
+  "distinct",
+  "drop",
+  "else",
+  "end",
+  "exists",
+  "foreign",
+  "from",
+  "full",
+  "group",
+  "having",
+  "if",
+  "in",
+  "index",
+  "inner",
+  "insert",
+  "into",
+  "is",
+  "join",
+  "key",
+  "left",
+  "like",
+  "limit",
+  "not",
+  "null",
+  "offset",
+  "on",
+  "or",
+  "order",
+  "outer",
+  "primary",
+  "references",
+  "right",
+  "rollback",
+  "select",
+  "set",
+  "table",
+  "then",
+  "union",
+  "unique",
+  "update",
+  "values",
+  "view",
+  "when",
+  "where",
+  "with",
+  // common types / functions
+  "int",
+  "integer",
+  "bigint",
+  "smallint",
+  "decimal",
+  "numeric",
+  "float",
+  "real",
+  "double",
+  "char",
+  "varchar",
+  "text",
+  "boolean",
+  "bool",
+  "date",
+  "datetime",
+  "timestamp",
+  "count",
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "coalesce"
+]);
+function highlightCLike(code) {
+  const n = code.length;
+  let out = "";
+  let i = 0;
+  let prevWord = "";
+  while (i < n) {
+    const ch = code.charCodeAt(i);
+    if (ch === 47 && code.charCodeAt(i + 1) === 47) {
+      let j = i + 2;
+      while (j < n && code.charCodeAt(j) !== 10) j++;
+      out += span("comment", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 47 && code.charCodeAt(i + 1) === 42) {
+      let j = i + 2;
+      while (j < n && !(code.charCodeAt(j) === 42 && code.charCodeAt(j + 1) === 47)) {
+        j++;
+      }
+      j = Math.min(n, j + 2);
+      out += span("comment", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 34 || ch === 39 || ch === 96) {
+      const end = consumeString(code, i, ch);
+      out += span("string", code.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (isDigit(ch) || ch === 46 && isDigit(code.charCodeAt(i + 1))) {
+      let j = i + 1;
+      while (j < n && isNumberPart(code.charCodeAt(j))) j++;
+      out += span("number", code.slice(i, j));
+      i = j;
+      prevWord = "";
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      let j = i + 1;
+      while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      const word = code.slice(i, j);
+      if (JS_KEYWORDS.has(word)) {
+        out += span("keyword", word);
+      } else if (TS_TYPES.has(word)) {
+        out += span("type", word);
+      } else {
+        let k = j;
+        while (k < n) {
+          const c = code.charCodeAt(k);
+          if (c === 32 || c === 9) {
+            k++;
+            continue;
+          }
+          break;
+        }
+        const isCall = code.charCodeAt(k) === 40;
+        if (prevNonSpace(code, i) === 46) {
+          out += span("prop", word);
+        } else if (prevWord === "class" || prevWord === "interface") {
+          out += span("type", word);
+        } else if (isCall || prevWord === "function") {
+          out += span("fn", word);
+        } else {
+          out += escapeHtml2(word);
+        }
+      }
+      prevWord = word;
+      i = j;
+      continue;
+    }
+    if (isPunct(ch)) {
+      out += span("punct", code.charAt(i));
+      i++;
+      continue;
+    }
+    out += escapeHtml2(code.charAt(i));
+    i++;
+  }
+  return out;
+}
+function highlightJson(code) {
+  const n = code.length;
+  let out = "";
+  let i = 0;
+  while (i < n) {
+    const ch = code.charCodeAt(i);
+    if (ch === 34) {
+      const end = consumeString(code, i, 34);
+      const text = code.slice(i, end);
+      let k = end;
+      while (k < n) {
+        const c = code.charCodeAt(k);
+        if (c === 32 || c === 9 || c === 10 || c === 13) {
+          k++;
+          continue;
+        }
+        break;
+      }
+      out += span(code.charCodeAt(k) === 58 ? "prop" : "string", text);
+      i = end;
+      continue;
+    }
+    if (isDigit(ch) || ch === 45 && isDigit(code.charCodeAt(i + 1))) {
+      let j = i + 1;
+      while (j < n && isNumberPart(code.charCodeAt(j))) j++;
+      out += span("number", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      let j = i + 1;
+      while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      const word = code.slice(i, j);
+      if (word === "true" || word === "false" || word === "null") {
+        out += span("keyword", word);
+      } else {
+        out += escapeHtml2(word);
+      }
+      i = j;
+      continue;
+    }
+    if (isPunct(ch)) {
+      out += span("punct", code.charAt(i));
+      i++;
+      continue;
+    }
+    out += escapeHtml2(code.charAt(i));
+    i++;
+  }
+  return out;
+}
+function highlightCss(code) {
+  const n = code.length;
+  let out = "";
+  let i = 0;
+  let depth = 0;
+  let beforeColon = true;
+  while (i < n) {
+    const ch = code.charCodeAt(i);
+    if (ch === 47 && code.charCodeAt(i + 1) === 42) {
+      let j = i + 2;
+      while (j < n && !(code.charCodeAt(j) === 42 && code.charCodeAt(j + 1) === 47)) {
+        j++;
+      }
+      j = Math.min(n, j + 2);
+      out += span("comment", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 34 || ch === 39) {
+      const end = consumeString(code, i, ch);
+      out += span("string", code.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (ch === 64) {
+      let j = i + 1;
+      while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      out += span("keyword", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 123) {
+      out += span("punct", "{");
+      depth++;
+      beforeColon = true;
+      i++;
+      continue;
+    }
+    if (ch === 125) {
+      out += span("punct", "}");
+      if (depth > 0) depth--;
+      beforeColon = true;
+      i++;
+      continue;
+    }
+    if (ch === 59) {
+      out += span("punct", ";");
+      beforeColon = true;
+      i++;
+      continue;
+    }
+    if (ch === 58) {
+      out += span("punct", ":");
+      beforeColon = false;
+      i++;
+      continue;
+    }
+    if (isDigit(ch) || ch === 46 && isDigit(code.charCodeAt(i + 1))) {
+      let j = i + 1;
+      while (j < n && isNumberPart(code.charCodeAt(j))) j++;
+      out += span("number", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (isIdentStart(ch) || ch === 45) {
+      let j = i + 1;
+      while (j < n && (isIdentPart(code.charCodeAt(j)) || code.charCodeAt(j) === 45)) {
+        j++;
+      }
+      const word = code.slice(i, j);
+      if (depth > 0 && beforeColon) {
+        out += span("prop", word);
+      } else {
+        out += escapeHtml2(word);
+      }
+      i = j;
+      continue;
+    }
+    if (isPunct(ch)) {
+      out += span("punct", code.charAt(i));
+      i++;
+      continue;
+    }
+    out += escapeHtml2(code.charAt(i));
+    i++;
+  }
+  return out;
+}
+function isTagChar(ch) {
+  return isIdentPart(ch) || ch === 45 || ch === 58;
+}
+function highlightHtml(code) {
+  const n = code.length;
+  let out = "";
+  let i = 0;
+  while (i < n) {
+    const ch = code.charCodeAt(i);
+    if (ch === 60 && code.startsWith("<!--", i)) {
+      const idx = code.indexOf("-->", i + 4);
+      const j = idx === -1 ? n : idx + 3;
+      out += span("comment", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 60) {
+      let j = i + 1;
+      if (code.charCodeAt(j) === 47) j++;
+      out += span("punct", code.slice(i, j));
+      const nameStart = j;
+      while (j < n && isTagChar(code.charCodeAt(j))) j++;
+      if (j > nameStart) out += span("keyword", code.slice(nameStart, j));
+      while (j < n && code.charCodeAt(j) !== 62) {
+        const c = code.charCodeAt(j);
+        if (c === 34 || c === 39) {
+          const end = consumeString(code, j, c);
+          out += span("string", code.slice(j, end));
+          j = end;
+          continue;
+        }
+        if (c === 61) {
+          out += span("punct", "=");
+          j++;
+          continue;
+        }
+        if (isTagChar(c)) {
+          const a = j;
+          while (j < n && isTagChar(code.charCodeAt(j))) j++;
+          out += span("prop", code.slice(a, j));
+          continue;
+        }
+        out += escapeHtml2(code.charAt(j));
+        j++;
+      }
+      if (j < n && code.charCodeAt(j) === 62) {
+        out += span("punct", ">");
+        j++;
+      }
+      i = j;
+      continue;
+    }
+    if (ch === 38) {
+      let j = i + 1;
+      while (j < n && j - i < 12 && code.charCodeAt(j) !== 59 && (isIdentPart(code.charCodeAt(j)) || code.charCodeAt(j) === 35)) {
+        j++;
+      }
+      if (j < n && code.charCodeAt(j) === 59) {
+        out += span("type", code.slice(i, j + 1));
+        i = j + 1;
+        continue;
+      }
+    }
+    out += escapeHtml2(code.charAt(i));
+    i++;
+  }
+  return out;
+}
+function highlightMarkdownLine(line) {
+  const n = line.length;
+  let out = "";
+  let i = 0;
+  while (i < n && (line.charCodeAt(i) === 32 || line.charCodeAt(i) === 9)) {
+    out += line.charAt(i);
+    i++;
+  }
+  if (line.charCodeAt(i) === 35) {
+    let h = i;
+    while (h < n && line.charCodeAt(h) === 35) h++;
+    if (h - i <= 6 && (h >= n || line.charCodeAt(h) === 32)) {
+      out += span("keyword", line.slice(i, h));
+      i = h;
+    }
+  } else if (line.charCodeAt(i) === 62) {
+    out += span("keyword", ">");
+    i++;
+  } else {
+    const c = line.charCodeAt(i);
+    if ((c === 45 || c === 43 || c === 42) && line.charCodeAt(i + 1) === 32) {
+      out += span("punct", line.charAt(i));
+      i++;
+    }
+  }
+  while (i < n) {
+    const ch = line.charCodeAt(i);
+    if (ch === 96) {
+      let j = i + 1;
+      while (j < n && line.charCodeAt(j) !== 96) j++;
+      j = Math.min(n, j + 1);
+      out += span("string", line.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 42 || ch === 95 || ch === 126) {
+      let j = i;
+      while (j < n && line.charCodeAt(j) === ch) j++;
+      out += span("punct", line.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 91 || ch === 93 || ch === 40 || ch === 41) {
+      out += span("punct", line.charAt(i));
+      i++;
+      continue;
+    }
+    out += escapeHtml2(line.charAt(i));
+    i++;
+  }
+  return out;
+}
+function highlightMarkdown(code) {
+  const lines = code.split("\n");
+  let out = "";
+  for (let i = 0; i < lines.length; i++) {
+    if (i > 0) out += "\n";
+    out += highlightMarkdownLine(lines[i] ?? "");
+  }
+  return out;
+}
+function highlightPython(code) {
+  const n = code.length;
+  let out = "";
+  let i = 0;
+  let prevWord = "";
+  while (i < n) {
+    const ch = code.charCodeAt(i);
+    if (ch === 35) {
+      let j = i + 1;
+      while (j < n && code.charCodeAt(j) !== 10) j++;
+      out += span("comment", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if ((ch === 34 || ch === 39) && code.charCodeAt(i + 1) === ch && code.charCodeAt(i + 2) === ch) {
+      const marker = code.slice(i, i + 3);
+      const idx = code.indexOf(marker, i + 3);
+      const j = idx === -1 ? n : idx + 3;
+      out += span("string", code.slice(i, j));
+      i = j;
+      prevWord = "";
+      continue;
+    }
+    if (ch === 34 || ch === 39) {
+      const end = consumeString(code, i, ch);
+      out += span("string", code.slice(i, end));
+      i = end;
+      prevWord = "";
+      continue;
+    }
+    if (ch === 64 && isIdentStart(code.charCodeAt(i + 1))) {
+      let j = i + 1;
+      while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      out += span("keyword", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (isDigit(ch) || ch === 46 && isDigit(code.charCodeAt(i + 1))) {
+      let j = i + 1;
+      while (j < n && isNumberPart(code.charCodeAt(j))) j++;
+      out += span("number", code.slice(i, j));
+      i = j;
+      prevWord = "";
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      let j = i + 1;
+      while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      const word = code.slice(i, j);
+      if (PY_KEYWORDS.has(word)) {
+        out += span("keyword", word);
+      } else if (prevWord === "def") {
+        out += span("fn", word);
+      } else if (prevWord === "class") {
+        out += span("type", word);
+      } else {
+        let k = j;
+        while (k < n && (code.charCodeAt(k) === 32 || code.charCodeAt(k) === 9))
+          k++;
+        out += code.charCodeAt(k) === 40 ? span("fn", word) : escapeHtml2(word);
+      }
+      prevWord = word;
+      i = j;
+      continue;
+    }
+    if (isPunct(ch)) {
+      out += span("punct", code.charAt(i));
+      i++;
+      continue;
+    }
+    out += escapeHtml2(code.charAt(i));
+    i++;
+  }
+  return out;
+}
+function highlightBash(code) {
+  const n = code.length;
+  let out = "";
+  let i = 0;
+  while (i < n) {
+    const ch = code.charCodeAt(i);
+    if (ch === 35) {
+      const prev = i > 0 ? code.charCodeAt(i - 1) : 10;
+      if (i === 0 || prev === 32 || prev === 9 || prev === 10 || prev === 13 || prev === 59) {
+        let j = i + 1;
+        while (j < n && code.charCodeAt(j) !== 10) j++;
+        out += span("comment", code.slice(i, j));
+        i = j;
+        continue;
+      }
+    }
+    if (ch === 34 || ch === 39) {
+      const end = consumeString(code, i, ch);
+      out += span("string", code.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (ch === 36) {
+      let j = i + 1;
+      if (code.charCodeAt(j) === 123) {
+        while (j < n && code.charCodeAt(j) !== 125) j++;
+        j = Math.min(n, j + 1);
+      } else {
+        while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      }
+      out += span("prop", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (isDigit(ch)) {
+      let j = i + 1;
+      while (j < n && isNumberPart(code.charCodeAt(j))) j++;
+      out += span("number", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      let j = i + 1;
+      while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      const word = code.slice(i, j);
+      out += BASH_KEYWORDS.has(word) ? span("keyword", word) : escapeHtml2(word);
+      i = j;
+      continue;
+    }
+    if (isPunct(ch)) {
+      out += span("punct", code.charAt(i));
+      i++;
+      continue;
+    }
+    out += escapeHtml2(code.charAt(i));
+    i++;
+  }
+  return out;
+}
+function highlightSql(code) {
+  const n = code.length;
+  let out = "";
+  let i = 0;
+  while (i < n) {
+    const ch = code.charCodeAt(i);
+    if (ch === 45 && code.charCodeAt(i + 1) === 45) {
+      let j = i + 2;
+      while (j < n && code.charCodeAt(j) !== 10) j++;
+      out += span("comment", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 47 && code.charCodeAt(i + 1) === 42) {
+      let j = i + 2;
+      while (j < n && !(code.charCodeAt(j) === 42 && code.charCodeAt(j + 1) === 47)) {
+        j++;
+      }
+      j = Math.min(n, j + 2);
+      out += span("comment", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 39 || ch === 34) {
+      const end = consumeString(code, i, ch);
+      out += span("string", code.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (isDigit(ch) || ch === 46 && isDigit(code.charCodeAt(i + 1))) {
+      let j = i + 1;
+      while (j < n && isNumberPart(code.charCodeAt(j))) j++;
+      out += span("number", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      let j = i + 1;
+      while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      const word = code.slice(i, j);
+      out += SQL_KEYWORDS.has(word.toLowerCase()) ? span("keyword", word) : escapeHtml2(word);
+      i = j;
+      continue;
+    }
+    if (isPunct(ch)) {
+      out += span("punct", code.charAt(i));
+      i++;
+      continue;
+    }
+    out += escapeHtml2(code.charAt(i));
+    i++;
+  }
+  return out;
+}
+var ALIASES = {
+  js: "javascript",
+  jsx: "javascript",
+  javascript: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  ts: "typescript",
+  tsx: "typescript",
+  typescript: "typescript",
+  json: "json",
+  jsonc: "json",
+  json5: "json",
+  css: "css",
+  html: "html",
+  htm: "html",
+  xml: "html",
+  md: "markdown",
+  markdown: "markdown",
+  py: "python",
+  python: "python",
+  sh: "bash",
+  bash: "bash",
+  shell: "bash",
+  zsh: "bash",
+  sql: "sql"
+};
+var TOKENIZERS = {
+  javascript: highlightCLike,
+  typescript: highlightCLike,
+  json: highlightJson,
+  css: highlightCss,
+  html: highlightHtml,
+  markdown: highlightMarkdown,
+  python: highlightPython,
+  bash: highlightBash,
+  sql: highlightSql
+};
+function highlightToHtml(lang, code) {
+  const info = typeof lang === "string" ? lang : "";
+  const first = info.trim().split(/\s+/)[0] ?? "";
+  const key = first.toLowerCase();
+  const resolved = ALIASES[key] ?? key;
+  const tokenizer = TOKENIZERS[resolved];
+  if (!tokenizer) return escapeHtml2(code);
+  return tokenizer(code);
+}
+
+// src/core/comments.ts
+var MAPPER = new TextDoc();
+var ASSOC_FROM = 1;
+var ASSOC_TO = 1;
+function mapAnchor(anchor, change) {
+  const from = MAPPER.mapOffset(anchor.from, change, ASSOC_FROM);
+  const to = MAPPER.mapOffset(anchor.to, change, ASSOC_TO);
+  const collapsed = from === to;
+  const deletedWholeRange = change.to > change.from && change.from <= anchor.from && change.to >= anchor.to;
+  if (collapsed && deletedWholeRange) return null;
+  return { from: Math.min(from, to), to: Math.max(from, to) };
+}
+
+// src/core/table.ts
+var clampInt = (n, lo, hi) => n < lo ? lo : n > hi ? hi : n;
+function delimCell(align) {
+  switch (align) {
+    case "left":
+      return ":---";
+    case "center":
+      return ":---:";
+    case "right":
+      return "---:";
+    default:
+      return "---";
+  }
+}
+var cellText = (text, cell) => text.slice(cell.from, cell.to);
+var emptyRow = (ncols) => Array.from({ length: ncols }, () => "");
+function tableToGrid(text, table) {
+  const ncols = Math.max(1, table.header.length);
+  const header = table.header.map((c) => cellText(text, c));
+  while (header.length < ncols) header.push("");
+  const align = [];
+  for (let i = 0; i < ncols; i++) align.push(table.align[i] ?? null);
+  const rows = table.rows.map((row) => {
+    const cells = row.map((c) => cellText(text, c));
+    while (cells.length < ncols) cells.push("");
+    cells.length = ncols;
+    return cells;
+  });
+  return { header, align, rows };
+}
+function cellsForLine(grid, lineIdx) {
+  const ncols = grid.header.length;
+  if (lineIdx === 0) return grid.header;
+  if (lineIdx === 1) {
+    const a = [];
+    for (let i = 0; i < ncols; i++) a.push(delimCell(grid.align[i] ?? null));
+    return a;
+  }
+  return grid.rows[lineIdx - 2] ?? grid.header;
+}
+function gridLines(grid) {
+  const ncols = grid.header.length;
+  const rowLine = (cells) => {
+    const out = cells.slice(0, ncols);
+    while (out.length < ncols) out.push("");
+    return `| ${out.join(" | ")} |`;
+  };
+  const delim = [];
+  for (let i = 0; i < ncols; i++) delim.push(delimCell(grid.align[i] ?? null));
+  const lines = [rowLine(grid.header), `| ${delim.join(" | ")} |`];
+  for (const r of grid.rows) lines.push(rowLine(r));
+  return lines;
+}
+function lineStart(lines, lineIdx) {
+  let off = 0;
+  for (const l of lines.slice(0, lineIdx)) off += l.length + 1;
+  return off;
+}
+function colOffsetInLine(cells, col) {
+  let off = 2;
+  for (const c of cells.slice(0, col)) off += c.length + 3;
+  return off;
+}
+function commit(text, table, grid, lineIdx, col) {
+  const lines = gridLines(grid);
+  const block = lines.join("\n");
+  const inBlock = lineStart(lines, lineIdx) + colOffsetInLine(cellsForLine(grid, lineIdx), col);
+  const newText = text.slice(0, table.from) + block + text.slice(table.to);
+  return { text: newText, selection: table.from + inBlock };
+}
+function cellSourceRange(table, row, col) {
+  const cell = row === 0 ? table.header[col] : table.rows[row - 1]?.[col];
+  if (!cell) return null;
+  return { from: cell.from, to: cell.to };
+}
+function addRow(text, table, atRow) {
+  const grid = tableToGrid(text, table);
+  const bodyIdx = clampInt(atRow - 1, 0, grid.rows.length);
+  grid.rows.splice(bodyIdx, 0, emptyRow(grid.header.length));
+  return commit(text, table, grid, 2 + bodyIdx, 0);
+}
+function addColumn(text, table, atCol) {
+  const grid = tableToGrid(text, table);
+  const idx = clampInt(atCol, 0, grid.header.length);
+  grid.header.splice(idx, 0, "");
+  grid.align.splice(idx, 0, null);
+  for (const r of grid.rows) r.splice(idx, 0, "");
+  return commit(text, table, grid, 0, idx);
+}
+function removeRow(text, table, atRow) {
+  const grid = tableToGrid(text, table);
+  const bodyIdx = atRow - 1;
+  if (bodyIdx >= 0 && bodyIdx < grid.rows.length) grid.rows.splice(bodyIdx, 1);
+  const lineIdx = grid.rows.length === 0 ? 0 : 2 + clampInt(bodyIdx, 0, grid.rows.length - 1);
+  return commit(text, table, grid, lineIdx, 0);
+}
+function removeColumn(text, table, atCol) {
+  const grid = tableToGrid(text, table);
+  if (grid.header.length > 1 && atCol >= 0 && atCol < grid.header.length) {
+    grid.header.splice(atCol, 1);
+    grid.align.splice(atCol, 1);
+    for (const r of grid.rows) r.splice(atCol, 1);
+  }
+  const caretCol = clampInt(atCol, 0, grid.header.length - 1);
+  return commit(text, table, grid, 0, caretCol);
+}
+function setAlignment(text, table, col, align) {
+  const grid = tableToGrid(text, table);
+  if (col >= 0 && col < grid.align.length) grid.align[col] = align;
+  const caretCol = clampInt(col, 0, grid.align.length - 1);
+  return commit(text, table, grid, 1, caretCol);
+}
+
+// src/core/index.ts
+var EditorView = class {
+  dom;
+  constructor(options) {
+    this.dom = options.parent;
+    throw new Error(
+      "typewright/core: engine not yet implemented (pre-alpha scaffold). See SPEC.md for the architecture and roadmap."
+    );
+  }
+  /** Current document string. */
+  get doc() {
+    return "";
+  }
+  /** Apply an edit. */
+  dispatch(_change) {
+  }
+  setSelection(_selection) {
+  }
+  destroy() {
+  }
+};
+
+exports.COMMANDS = COMMANDS;
+exports.EditorView = EditorView;
+exports.TextDoc = TextDoc;
+exports.activeBlockIndex = activeBlockIndex;
+exports.addColumn = addColumn;
+exports.addRow = addRow;
+exports.applyCommand = applyCommand;
+exports.cellSourceRange = cellSourceRange;
+exports.childrenOf = childrenOf;
+exports.collectMarkers = collectMarkers;
+exports.headingFoldRanges = headingFoldRanges;
+exports.hiddenMarkers = hiddenMarkers;
+exports.highlightToHtml = highlightToHtml;
+exports.isInline = isInline;
+exports.mapAnchor = mapAnchor;
+exports.parse = parse;
+exports.parseIncremental = parseIncremental;
+exports.removeColumn = removeColumn;
+exports.removeRow = removeRow;
+exports.renderInline = renderInline;
+exports.renderNode = renderNode;
+exports.renderToHtml = renderToHtml;
+exports.safeUrl = safeUrl;
+exports.setAlignment = setAlignment;
+exports.walk = walk;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map