@owomark/core 0.1.5 → 0.1.7

package/dist/chunk-TRLKIMRD.js

@@ -1,3227 +0,0 @@
-import {
-  applyBlockquotePrefix,
-  getBlockquotePrefixAtPos,
-  normalizeMarkdownPaste
-} from "./chunk-BGXCXQZP.js";
-import {
-  deleteToLineEnd,
-  deleteToLineStart,
-  deleteWordBackward,
-  deleteWordForward
-} from "./chunk-MPIWZLI3.js";
-
-// src/parser/inline-tokens.ts
-function overlaps(segs, start, end) {
-  return segs.some((s) => start < s.end && end > s.start);
-}
-function tok(type, text, start) {
-  return { type, text, start, end: start + text.length };
-}
-function isEscaped(raw, index) {
-  let backslashCount = 0;
-  for (let cursor = index - 1; cursor >= 0 && raw[cursor] === "\\"; cursor--) {
-    backslashCount += 1;
-  }
-  return backslashCount % 2 === 1;
-}
-function findInlineMathRanges(raw) {
-  const ranges = [];
-  for (let start = 0; start < raw.length; start++) {
-    if (raw[start] !== "$" || isEscaped(raw, start)) continue;
-    if (raw[start + 1] === "$") {
-      start += 1;
-      continue;
-    }
-    for (let end = start + 1; end < raw.length; end++) {
-      if (raw[end] !== "$" || isEscaped(raw, end)) continue;
-      if (raw[end - 1] === "$" || raw[end + 1] === "$") continue;
-      ranges.push({ start, end: end + 1 });
-      start = end;
-      break;
-    }
-  }
-  return ranges;
-}
-function tokenizeInline(raw, baseOffset = 0) {
-  if (!raw) return [{ type: "text", text: "", start: baseOffset, end: baseOffset }];
-  const segs = [];
-  for (const m of raw.matchAll(/`([^`]+)`/g)) {
-    const s = m.index;
-    segs.push({
-      start: s,
-      end: s + m[0].length,
-      tokens: [
-        tok("code-marker", "`", baseOffset + s),
-        tok("code", m[1], baseOffset + s + 1),
-        tok("code-marker", "`", baseOffset + s + m[0].length - 1)
-      ]
-    });
-  }
-  for (const m of raw.matchAll(/!\[([^\]]*)\]\(([^)]*)\)/g)) {
-    const s = m.index;
-    if (!overlaps(segs, s, s + m[0].length)) {
-      const tokens = [];
-      let pos2 = s;
-      tokens.push(tok("image-marker", "![", baseOffset + pos2));
-      pos2 += 2;
-      tokens.push(tok("image-alt", m[1], baseOffset + pos2));
-      pos2 += m[1].length;
-      tokens.push(tok("link-bracket", "](", baseOffset + pos2));
-      pos2 += 2;
-      tokens.push(tok("image-url", m[2], baseOffset + pos2));
-      pos2 += m[2].length;
-      tokens.push(tok("link-bracket", ")", baseOffset + pos2));
-      segs.push({ start: s, end: s + m[0].length, tokens });
-    }
-  }
-  for (const m of raw.matchAll(/\[([^\]]*)\]\(([^)]*)\)/g)) {
-    const s = m.index;
-    if (!overlaps(segs, s, s + m[0].length)) {
-      const tokens = [];
-      let pos2 = s;
-      tokens.push(tok("link-bracket", "[", baseOffset + pos2));
-      pos2 += 1;
-      tokens.push(tok("link-text", m[1], baseOffset + pos2));
-      pos2 += m[1].length;
-      tokens.push(tok("link-bracket", "](", baseOffset + pos2));
-      pos2 += 2;
-      tokens.push(tok("link-url", m[2], baseOffset + pos2));
-      pos2 += m[2].length;
-      tokens.push(tok("link-bracket", ")", baseOffset + pos2));
-      segs.push({ start: s, end: s + m[0].length, tokens });
-    }
-  }
-  for (const m of raw.matchAll(/~~(.+?)~~/g)) {
-    const s = m.index;
-    if (!overlaps(segs, s, s + m[0].length)) {
-      segs.push({
-        start: s,
-        end: s + m[0].length,
-        tokens: [
-          tok("strikethrough-marker", "~~", baseOffset + s),
-          tok("strikethrough", m[1], baseOffset + s + 2),
-          tok("strikethrough-marker", "~~", baseOffset + s + m[0].length - 2)
-        ]
-      });
-    }
-  }
-  for (const range of findInlineMathRanges(raw)) {
-    if (!overlaps(segs, range.start, range.end)) {
-      const innerStart = range.start + 1;
-      const innerEnd = range.end - 1;
-      segs.push({
-        start: range.start,
-        end: range.end,
-        tokens: [
-          tok("math-marker", "$", baseOffset + range.start),
-          tok("math-text", raw.slice(innerStart, innerEnd), baseOffset + innerStart),
-          tok("math-marker", "$", baseOffset + innerEnd)
-        ]
-      });
-    }
-  }
-  for (const m of raw.matchAll(/\*\*(.+?)\*\*/g)) {
-    const s = m.index;
-    if (!overlaps(segs, s, s + m[0].length)) {
-      segs.push({
-        start: s,
-        end: s + m[0].length,
-        tokens: [
-          tok("strong-marker", "**", baseOffset + s),
-          tok("strong", m[1], baseOffset + s + 2),
-          tok("strong-marker", "**", baseOffset + s + m[0].length - 2)
-        ]
-      });
-    }
-  }
-  for (const m of raw.matchAll(/(?<![a-zA-Z0-9])__(.+?)__(?![a-zA-Z0-9])/g)) {
-    const s = m.index;
-    if (!overlaps(segs, s, s + m[0].length)) {
-      segs.push({
-        start: s,
-        end: s + m[0].length,
-        tokens: [
-          tok("strong-marker", "__", baseOffset + s),
-          tok("strong", m[1], baseOffset + s + 2),
-          tok("strong-marker", "__", baseOffset + s + m[0].length - 2)
-        ]
-      });
-    }
-  }
-  for (const m of raw.matchAll(/(?<!\*)\*([^*]+)\*(?!\*)/g)) {
-    const s = m.index;
-    if (!overlaps(segs, s, s + m[0].length)) {
-      segs.push({
-        start: s,
-        end: s + m[0].length,
-        tokens: [
-          tok("emphasis-marker", "*", baseOffset + s),
-          tok("emphasis", m[1], baseOffset + s + 1),
-          tok("emphasis-marker", "*", baseOffset + s + m[0].length - 1)
-        ]
-      });
-    }
-  }
-  for (const m of raw.matchAll(/(?<![a-zA-Z0-9])_([^_]+)_(?![a-zA-Z0-9])/g)) {
-    const s = m.index;
-    if (!overlaps(segs, s, s + m[0].length)) {
-      segs.push({
-        start: s,
-        end: s + m[0].length,
-        tokens: [
-          tok("emphasis-marker", "_", baseOffset + s),
-          tok("emphasis", m[1], baseOffset + s + 1),
-          tok("emphasis-marker", "_", baseOffset + s + m[0].length - 1)
-        ]
-      });
-    }
-  }
-  segs.sort((a, b) => a.start - b.start);
-  const result = [];
-  let pos = 0;
-  for (const seg of segs) {
-    if (seg.start > pos) {
-      result.push(tok("text", raw.slice(pos, seg.start), baseOffset + pos));
-    }
-    result.push(...seg.tokens);
-    pos = seg.end;
-  }
-  if (pos < raw.length) {
-    result.push(tok("text", raw.slice(pos), baseOffset + pos));
-  }
-  return result;
-}
-
-// src/parser/blocks.ts
-var MATH_FENCE_RE = /^\$\$\s*$/;
-var SINGLE_LINE_MATH_BLOCK_RE = /^ {0,3}\$\$(?!\s*$)([^\n]*?)(?<!\\)\$\$\s*$/;
-function tokenizeBlock(raw, blockType, baseOffset = 0) {
-  if (blockType === "code-fence") {
-    return tokenizeCodeFence(raw, baseOffset);
-  }
-  if (blockType === "directive-container") {
-    return tokenizeMultiLineBlock(raw, baseOffset, (line, i, isFirst, isLast) => {
-      if (isFirst || isLast && /^:::\s*$/.test(line)) {
-        return [{ type: "fence-marker", text: line, start: -1, end: -1 }];
-      }
-      return tokenizeInline(line, -1);
-    });
-  }
-  if (blockType === "math-block") {
-    const singleLineMatch = raw.match(SINGLE_LINE_MATH_BLOCK_RE);
-    if (singleLineMatch) {
-      const leadingWhitespace = raw.match(/^ {0,3}/)?.[0] ?? "";
-      const trimmed = raw.slice(leadingWhitespace.length).replace(/\s+$/, "");
-      const inner = trimmed.slice(2, -2);
-      const start = baseOffset + leadingWhitespace.length;
-      return [
-        { type: "fence-marker", text: "$$", start, end: start + 2 },
-        { type: "math-text", text: inner, start: start + 2, end: start + 2 + inner.length },
-        { type: "fence-marker", text: "$$", start: start + 2 + inner.length, end: start + 4 + inner.length }
-      ];
-    }
-    return tokenizeMultiLineBlock(raw, baseOffset, (line, _i, isFirst, isLast) => {
-      if ((isFirst || isLast) && MATH_FENCE_RE.test(line)) {
-        return [{ type: "fence-marker", text: line, start: -1, end: -1 }];
-      }
-      return [{ type: "math-text", text: line, start: -1, end: -1 }];
-    });
-  }
-  if (blockType === "table") {
-    return tokenizeMultiLineBlock(raw, baseOffset, (line) => {
-      return tokenizeInline(line, -1);
-    });
-  }
-  if (blockType === "thematic-break") {
-    return [{ type: "hr", text: raw, start: baseOffset, end: baseOffset + raw.length }];
-  }
-  const headingMatch = raw.match(/^(#{1,6}\s)(.*)/);
-  if (headingMatch && blockType === "heading") {
-    return [
-      { type: "heading-marker", text: headingMatch[1], start: baseOffset, end: baseOffset + headingMatch[1].length },
-      ...tokenizeInline(headingMatch[2], baseOffset + headingMatch[1].length)
-    ];
-  }
-  const bqMatch = raw.match(/^((?:>\s?)+)(.*)/);
-  if (bqMatch && blockType === "blockquote") {
-    return [
-      { type: "blockquote-marker", text: bqMatch[1], start: baseOffset, end: baseOffset + bqMatch[1].length },
-      ...tokenizeInline(bqMatch[2], baseOffset + bqMatch[1].length)
-    ];
-  }
-  const listMatch = raw.match(/^(\s*(?:[-*+]|\d+\.)\s)(.*)/);
-  if (listMatch && (blockType === "unordered-list" || blockType === "ordered-list")) {
-    return [
-      { type: "list-marker", text: listMatch[1], start: baseOffset, end: baseOffset + listMatch[1].length },
-      ...tokenizeInline(listMatch[2], baseOffset + listMatch[1].length)
-    ];
-  }
-  return tokenizeInline(raw, baseOffset);
-}
-function tokenizeMultiLineBlock(raw, baseOffset, classifyLine) {
-  const lines = raw.split("\n");
-  const tokens = [];
-  let offset = baseOffset;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (i > 0) {
-      tokens.push({ type: "text", text: "\n", start: offset, end: offset + 1 });
-      offset += 1;
-    }
-    const lineTokens = classifyLine(line, i, i === 0, i === lines.length - 1);
-    let pos = offset;
-    for (const t of lineTokens) {
-      if (t.start === -1) {
-        t.start = pos;
-        t.end = pos + t.text.length;
-      }
-      pos = t.end;
-    }
-    tokens.push(...lineTokens);
-    offset += line.length;
-  }
-  return tokens;
-}
-function tokenizeCodeFence(raw, baseOffset) {
-  const lines = raw.split("\n");
-  const tokens = [];
-  let offset = baseOffset;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (i > 0) {
-      tokens.push({ type: "text", text: "\n", start: offset, end: offset + 1 });
-      offset += 1;
-    }
-    if (i === 0) {
-      const fenceMatch = line.match(/^( {0,3}[`~]{3,})(.*)/);
-      if (fenceMatch) {
-        tokens.push({ type: "fence-marker", text: fenceMatch[1], start: offset, end: offset + fenceMatch[1].length });
-        if (fenceMatch[2]) {
-          tokens.push({ type: "fence-lang", text: fenceMatch[2], start: offset + fenceMatch[1].length, end: offset + line.length });
-        }
-      } else {
-        tokens.push({ type: "fence-marker", text: line, start: offset, end: offset + line.length });
-      }
-    } else if (i === lines.length - 1 && /^ {0,3}[`~]{3,}\s*$/.test(line)) {
-      tokens.push({ type: "fence-marker", text: line, start: offset, end: offset + line.length });
-    } else {
-      tokens.push({ type: "code-block-text", text: line, start: offset, end: offset + line.length });
-    }
-    offset += line.length;
-  }
-  return tokens;
-}
-
-// src/model/document.ts
-function createBlockIdGenerator() {
-  let nextId = 1;
-  return () => "b" + nextId++;
-}
-var defaultNextId = 1;
-function defaultGenBlockId() {
-  return "b" + defaultNextId++;
-}
-function resetBlockIdCounter() {
-  defaultNextId = 1;
-}
-function tokensToDecorators(tokens, raw, baseOffset) {
-  const decorators = [];
-  let pos = baseOffset;
-  for (const token of tokens) {
-    if (token.start > pos) {
-      const gapText = raw.slice(pos - baseOffset, token.start - baseOffset);
-      if (gapText) {
-        decorators.push({ type: "text", leaves: [{ text: gapText }] });
-      }
-    }
-    decorators.push({
-      type: token.type,
-      leaves: [{ text: token.text }]
-    });
-    pos = token.end;
-  }
-  if (pos - baseOffset < raw.length) {
-    const trailing = raw.slice(pos - baseOffset);
-    if (trailing) {
-      decorators.push({ type: "text", leaves: [{ text: trailing }] });
-    }
-  }
-  return decorators;
-}
-var HEADING_RE = /^(#{1,6})\s/;
-var UL_RE = /^(\s*)([-*+])\s/;
-var OL_RE = /^(\s*)(\d+)\.\s/;
-var BQ_RE = /^(\s*>)/;
-var FENCE_RE = /^( {0,3})([`~]{3,})(.*)/;
-var HR_RE = /^(\*{3,}|-{3,}|_{3,})\s*$/;
-var DIRECTIVE_OPEN_RE = /^:::(\w+)/;
-var DIRECTIVE_CLOSE_RE = /^:::\s*$/;
-var TABLE_SEPARATOR_RE = /^\|[\s:]*-{3,}[\s:]*(\|[\s:]*-{3,}[\s:]*)*\|?\s*$/;
-var TABLE_ROW_RE = /^\|/;
-function parseMarkdownToDocument(markdown, genId) {
-  const genBlockId = genId ?? defaultGenBlockId;
-  const lines = markdown.split("\n");
-  const blocks = [];
-  let i = 0;
-  let offset = 0;
-  while (i < lines.length) {
-    const line = lines[i];
-    const fenceMatch = line.match(FENCE_RE);
-    if (fenceMatch) {
-      const marker = fenceMatch[2];
-      const closeRe = new RegExp(`^ {0,3}${marker[0]}{${marker.length},}\\s*$`);
-      let closeIndex = -1;
-      for (let j = i + 1; j < lines.length; j++) {
-        if (closeRe.test(lines[j])) {
-          closeIndex = j;
-          break;
-        }
-      }
-      if (closeIndex !== -1) {
-        const lang = fenceMatch[3].trim().split(/\s+/)[0] || "";
-        const fenceLines = lines.slice(i, closeIndex + 1);
-        const raw = fenceLines.join("\n");
-        const tokens2 = tokenizeBlock(raw, "code-fence", offset);
-        blocks.push({
-          type: "code-fence",
-          raw,
-          language: lang,
-          id: genBlockId(),
-          depth: 0,
-          decorators: tokensToDecorators(tokens2, raw, offset)
-        });
-        offset += raw.length + 1;
-        i = closeIndex + 1;
-        continue;
-      }
-    }
-    const directiveMatch = line.match(DIRECTIVE_OPEN_RE);
-    if (directiveMatch) {
-      const directiveName = directiveMatch[1];
-      let closeIndex = -1;
-      for (let j = i + 1; j < lines.length; j++) {
-        if (DIRECTIVE_CLOSE_RE.test(lines[j])) {
-          closeIndex = j;
-          break;
-        }
-      }
-      if (closeIndex !== -1) {
-        const containerLines = lines.slice(i, closeIndex + 1);
-        const raw = containerLines.join("\n");
-        const tokens2 = tokenizeBlock(raw, "directive-container", offset);
-        blocks.push({
-          type: "directive-container",
-          raw,
-          directiveName,
-          id: genBlockId(),
-          depth: 0,
-          decorators: tokensToDecorators(tokens2, raw, offset)
-        });
-        offset += raw.length + 1;
-        i = closeIndex + 1;
-        continue;
-      }
-    }
-    if (SINGLE_LINE_MATH_BLOCK_RE.test(line)) {
-      const tokens2 = tokenizeBlock(line, "math-block", offset);
-      blocks.push({
-        type: "math-block",
-        raw: line,
-        id: genBlockId(),
-        depth: 0,
-        decorators: tokensToDecorators(tokens2, line, offset)
-      });
-      offset += line.length + 1;
-      i++;
-      continue;
-    }
-    if (MATH_FENCE_RE.test(line)) {
-      let closeIndex = -1;
-      for (let j = i + 1; j < lines.length; j++) {
-        if (MATH_FENCE_RE.test(lines[j])) {
-          closeIndex = j;
-          break;
-        }
-      }
-      if (closeIndex !== -1) {
-        const mathLines = lines.slice(i, closeIndex + 1);
-        const raw = mathLines.join("\n");
-        const tokens2 = tokenizeBlock(raw, "math-block", offset);
-        blocks.push({
-          type: "math-block",
-          raw,
-          id: genBlockId(),
-          depth: 0,
-          decorators: tokensToDecorators(tokens2, raw, offset)
-        });
-        offset += raw.length + 1;
-        i = closeIndex + 1;
-        continue;
-      }
-    }
-    if (TABLE_ROW_RE.test(line) && i + 1 < lines.length && TABLE_SEPARATOR_RE.test(lines[i + 1])) {
-      let endIndex = i + 1;
-      for (let j = i + 2; j < lines.length; j++) {
-        if (TABLE_ROW_RE.test(lines[j])) {
-          endIndex = j;
-        } else {
-          break;
-        }
-      }
-      const tableLines = lines.slice(i, endIndex + 1);
-      const raw = tableLines.join("\n");
-      const tokens2 = tokenizeBlock(raw, "table", offset);
-      blocks.push({
-        type: "table",
-        raw,
-        id: genBlockId(),
-        depth: 0,
-        decorators: tokensToDecorators(tokens2, raw, offset)
-      });
-      offset += raw.length + 1;
-      i = endIndex + 1;
-      continue;
-    }
-    if (HR_RE.test(line.trim())) {
-      const tokens2 = tokenizeBlock(line, "thematic-break", offset);
-      blocks.push({
-        type: "thematic-break",
-        raw: line,
-        id: genBlockId(),
-        depth: 0,
-        decorators: tokensToDecorators(tokens2, line, offset)
-      });
-      offset += line.length + 1;
-      i++;
-      continue;
-    }
-    const headingMatch = line.match(HEADING_RE);
-    if (headingMatch) {
-      const tokens2 = tokenizeBlock(line, "heading", offset);
-      blocks.push({
-        type: "heading",
-        raw: line,
-        headingLevel: headingMatch[1].length,
-        id: genBlockId(),
-        depth: 0,
-        decorators: tokensToDecorators(tokens2, line, offset)
-      });
-      offset += line.length + 1;
-      i++;
-      continue;
-    }
-    if (BQ_RE.test(line)) {
-      const bqMatch = line.match(/^((?:>\s?)+)/);
-      const bqDepth = bqMatch ? (bqMatch[1].match(/>/g) ?? []).length : 0;
-      const tokens2 = tokenizeBlock(line, "blockquote", offset);
-      blocks.push({
-        type: "blockquote",
-        raw: line,
-        id: genBlockId(),
-        depth: bqDepth,
-        decorators: tokensToDecorators(tokens2, line, offset)
-      });
-      offset += line.length + 1;
-      i++;
-      continue;
-    }
-    const ulMatch = line.match(UL_RE);
-    if (ulMatch) {
-      const indent = ulMatch[1].length;
-      const tokens2 = tokenizeBlock(line, "unordered-list", offset);
-      blocks.push({
-        type: "unordered-list",
-        raw: line,
-        id: genBlockId(),
-        depth: Math.floor(indent / 2),
-        decorators: tokensToDecorators(tokens2, line, offset)
-      });
-      offset += line.length + 1;
-      i++;
-      continue;
-    }
-    const olMatch = line.match(OL_RE);
-    if (olMatch) {
-      const indent = olMatch[1].length;
-      const tokens2 = tokenizeBlock(line, "ordered-list", offset);
-      blocks.push({
-        type: "ordered-list",
-        raw: line,
-        id: genBlockId(),
-        depth: Math.floor(indent / 2),
-        decorators: tokensToDecorators(tokens2, line, offset)
-      });
-      offset += line.length + 1;
-      i++;
-      continue;
-    }
-    const tokens = tokenizeBlock(line, "paragraph", offset);
-    blocks.push({
-      type: "paragraph",
-      raw: line,
-      id: genBlockId(),
-      depth: 0,
-      decorators: tokensToDecorators(tokens, line, offset)
-    });
-    offset += line.length + 1;
-    i++;
-  }
-  return { blocks };
-}
-function blocksMatch(a, b) {
-  return a.raw === b.raw && a.type === b.type;
-}
-function reconcileBlocks(oldBlocks, newBlocks) {
-  const oldLen = oldBlocks.length;
-  const newLen = newBlocks.length;
-  let head = 0;
-  while (head < oldLen && head < newLen && blocksMatch(oldBlocks[head], newBlocks[head])) {
-    head++;
-  }
-  let tail = 0;
-  while (tail < oldLen - head && tail < newLen - head && blocksMatch(oldBlocks[oldLen - 1 - tail], newBlocks[newLen - 1 - tail])) {
-    tail++;
-  }
-  const result = new Array(newLen);
-  for (let i = 0; i < head; i++) {
-    result[i] = oldBlocks[i];
-  }
-  for (let i = head; i < newLen - tail; i++) {
-    result[i] = newBlocks[i];
-  }
-  for (let j = 0; j < tail; j++) {
-    result[newLen - tail + j] = oldBlocks[oldLen - tail + j];
-  }
-  return result;
-}
-function serializeDocument(doc) {
-  return doc.blocks.map((b) => b.raw).join("\n");
-}
-var blockIdIndexCache = /* @__PURE__ */ new WeakMap();
-function getBlockIdIndex(blocks) {
-  let index = blockIdIndexCache.get(blocks);
-  if (index) return index;
-  index = /* @__PURE__ */ new Map();
-  for (let i = 0; i < blocks.length; i++) {
-    index.set(blocks[i].id, i);
-  }
-  blockIdIndexCache.set(blocks, index);
-  return index;
-}
-function getBlockById(doc, blockId) {
-  const idx = getBlockIdIndex(doc.blocks).get(blockId);
-  return idx !== void 0 ? doc.blocks[idx] : void 0;
-}
-function getBlockIndexById(doc, blockId) {
-  return getBlockIdIndex(doc.blocks).get(blockId) ?? -1;
-}
-var prefixSumCache = /* @__PURE__ */ new WeakMap();
-function getPrefixSums(blocks) {
-  let sums = prefixSumCache.get(blocks);
-  if (sums) return sums;
-  sums = new Array(blocks.length);
-  let pos = 0;
-  for (let i = 0; i < blocks.length; i++) {
-    sums[i] = pos;
-    pos += blocks[i].raw.length + 1;
-  }
-  prefixSumCache.set(blocks, sums);
-  return sums;
-}
-function getBlockAtOffset(doc, offset) {
-  const { blocks } = doc;
-  if (blocks.length === 0) return { blockIndex: 0, offsetInBlock: 0 };
-  const sums = getPrefixSums(blocks);
-  let lo = 0;
-  let hi = blocks.length - 1;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >>> 1;
-    if (sums[mid] <= offset) {
-      lo = mid;
-    } else {
-      hi = mid - 1;
-    }
-  }
-  return { blockIndex: lo, offsetInBlock: offset - sums[lo] };
-}
-function getBlockStartOffset(doc, blockIndex) {
-  const { blocks } = doc;
-  if (blocks.length === 0 || blockIndex <= 0) return 0;
-  const sums = getPrefixSums(blocks);
-  const clamped = Math.min(blockIndex, blocks.length - 1);
-  return sums[clamped];
-}
-
-// src/model/virtual-selection.ts
-function linearToVirtualPosition(doc, linearOffset) {
-  const { blocks } = doc;
-  if (blocks.length === 0) return { blockId: "", offset: 0 };
-  const { blockIndex, offsetInBlock } = getBlockAtOffset(doc, linearOffset);
-  const block = blocks[blockIndex];
-  return {
-    blockId: block.id,
-    offset: Math.max(0, Math.min(offsetInBlock, block.raw.length))
-  };
-}
-function linearToVirtual(doc, selection) {
-  return {
-    anchor: linearToVirtualPosition(doc, selection.anchor),
-    focus: linearToVirtualPosition(doc, selection.focus)
-  };
-}
-function virtualPositionToLinear(doc, vpos) {
-  const idx = getBlockIndexById(doc, vpos.blockId);
-  if (idx === -1) {
-    return clampToLastBlock(doc, vpos.offset);
-  }
-  const block = doc.blocks[idx];
-  const start = getBlockStartOffset(doc, idx);
-  return start + Math.max(0, Math.min(vpos.offset, block.raw.length));
-}
-function virtualToLinear(doc, vsel) {
-  return {
-    anchor: virtualPositionToLinear(doc, vsel.anchor),
-    focus: virtualPositionToLinear(doc, vsel.focus)
-  };
-}
-function clampToLastBlock(doc, offset) {
-  if (doc.blocks.length === 0) return 0;
-  const lastIdx = doc.blocks.length - 1;
-  const lastBlock = doc.blocks[lastIdx];
-  const start = getBlockStartOffset(doc, lastIdx);
-  return start + Math.min(offset, lastBlock.raw.length);
-}
-function virtualPositionsEqual(a, b) {
-  return a.blockId === b.blockId && a.offset === b.offset;
-}
-function isVirtualSelectionCollapsed(vsel) {
-  return virtualPositionsEqual(vsel.anchor, vsel.focus);
-}
-function getBlockIndexForPosition(doc, vpos) {
-  return getBlockIndexById(doc, vpos.blockId);
-}
-
-// src/patterns/side-annotation.ts
-var SIDE_ANNOTATION_TAIL_RE = /\(>(?:[}{:\]\[|\-!?~]|->|=>|~>|}\->|}\=>|}\!|}\?|\]->|\]=>|\|->|\|=>)[^\n)]+\)\s*$/;
-var SIDE_CONTINUATION_TAIL_RE = /\(>\+\)\s*$/;
-
-// src/commands/enter.ts
-var NOT_HANDLED = {
-  handled: false,
-  value: "",
-  selectionStart: 0,
-  selectionEnd: 0
-};
-function getLineAt(text, pos) {
-  let lineStart = pos;
-  while (lineStart > 0 && text[lineStart - 1] !== "\n") lineStart--;
-  let lineEnd = pos;
-  while (lineEnd < text.length && text[lineEnd] !== "\n") lineEnd++;
-  return { line: text.slice(lineStart, lineEnd), lineStart, lineEnd };
-}
-function escapeRegExp(text) {
-  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function parseStructuralTokens(line) {
-  let index = 0;
-  let listSeen = false;
-  const tokens = [];
-  while (index < line.length) {
-    const remainder = line.slice(index);
-    const tokenMatch = remainder.match(/^(?:\s*> ?|\s*(?:[-*+]|\d+\.)\s+)/);
-    if (!tokenMatch) break;
-    const raw = tokenMatch[0];
-    const trimmed = raw.trimStart();
-    if (trimmed.startsWith(">")) {
-      tokens.push({ kind: "blockquote", raw });
-      index += raw.length;
-      continue;
-    }
-    if (listSeen) break;
-    const unordered = trimmed.match(/^([-*+])\s+$/);
-    if (unordered) {
-      tokens.push({ kind: "unordered-list", raw, marker: unordered[1] });
-      listSeen = true;
-      index += raw.length;
-      continue;
-    }
-    const ordered = trimmed.match(/^(\d+)\.\s+$/);
-    if (ordered) {
-      tokens.push({ kind: "ordered-list", raw, number: parseInt(ordered[1], 10) });
-      listSeen = true;
-      index += raw.length;
-      continue;
-    }
-    break;
-  }
-  return {
-    prefix: line.slice(0, index),
-    rest: line.slice(index),
-    tokens
-  };
-}
-function getContinuationPrefix(tokens) {
-  return tokens.map((token) => {
-    if (token.kind === "ordered-list") {
-      return token.raw.replace(/\d+\.(\s+)$/, `${token.number + 1}.$1`);
-    }
-    return token.raw;
-  }).join("");
-}
-function matchFenceLine(line) {
-  const { prefix, rest } = parseStructuralTokens(line);
-  const match = rest.match(/^([`~]{3,})([^\n]*)$/);
-  if (!match) return null;
-  return { prefix, marker: match[1] };
-}
-function isMatchingFenceClose(line, prefix, marker) {
-  const { prefix: linePrefix, rest } = parseStructuralTokens(line);
-  if (linePrefix !== prefix) return false;
-  const closeRe = new RegExp(`^${escapeRegExp(marker[0])}{${marker.length},}\\s*$`);
-  return closeRe.test(rest);
-}
-function findFenceContext(text, pos) {
-  const lines = text.slice(0, pos).split("\n");
-  let context = null;
-  for (const line of lines) {
-    const fence = matchFenceLine(line);
-    if (!context) {
-      if (fence) context = fence;
-      continue;
-    }
-    if (isMatchingFenceClose(line, context.prefix, context.marker)) {
-      context = null;
-    }
-  }
-  return context;
-}
-function hasSideAnnotationTail(content) {
-  return SIDE_ANNOTATION_TAIL_RE.test(content) || SIDE_CONTINUATION_TAIL_RE.test(content);
-}
-function getContinuationContentSplit(content, cursorInContent) {
-  const markerMatch = content.match(SIDE_CONTINUATION_TAIL_RE);
-  if (!markerMatch || markerMatch.index == null) return null;
-  if (cursorInContent < 0 || cursorInContent >= markerMatch.index) return null;
-  const afterCursor = content.slice(cursorInContent);
-  const beforeMarkerAfterCursor = afterCursor.slice(0, markerMatch.index - cursorInContent);
-  if (!beforeMarkerAfterCursor.trim()) return null;
-  return {
-    beforeCursor: content.slice(0, cursorInContent),
-    afterCursor
-  };
-}
-function handleSideAnnotationContinuation(text, line, lineStart, lineEnd, selectionEnd, structural) {
-  const content = structural.rest;
-  if (!hasSideAnnotationTail(content)) return NOT_HANDLED;
-  const cursorInContent = selectionEnd - lineStart - structural.prefix.length;
-  const splitContent = getContinuationContentSplit(content, cursorInContent);
-  if (splitContent) {
-    const newText2 = text.slice(0, lineStart) + structural.prefix + splitContent.beforeCursor + `
-${structural.prefix}` + splitContent.afterCursor + text.slice(lineEnd);
-    const newCursor2 = lineStart + structural.prefix.length + splitContent.beforeCursor.length + 1 + structural.prefix.length;
-    return { handled: true, value: newText2, selectionStart: newCursor2, selectionEnd: newCursor2 };
-  }
-  const contentBeforeMarker = content.replace(SIDE_CONTINUATION_TAIL_RE, "").trim();
-  if (SIDE_CONTINUATION_TAIL_RE.test(content) && !contentBeforeMarker) {
-    const newText2 = text.slice(0, lineStart) + structural.prefix + text.slice(lineEnd);
-    const newCursor2 = lineStart + structural.prefix.length;
-    return { handled: true, value: newText2, selectionStart: newCursor2, selectionEnd: newCursor2 };
-  }
-  const suffix = " (>+)";
-  const prefix = structural.prefix;
-  const insert = `
-${prefix}${suffix}`;
-  const insertAt = SIDE_CONTINUATION_TAIL_RE.test(text.slice(selectionEnd)) ? lineEnd : selectionEnd;
-  let newText = text.slice(0, insertAt) + insert + text.slice(insertAt);
-  const hasTerminalBlankLine = text.endsWith("\n");
-  const hasFollowingSideContinuation = hasSideContinuationBelow(text, lineEnd);
-  if (hasTerminalBlankLine && hasFollowingSideContinuation && newText.endsWith("\n")) {
-    newText = newText.slice(0, -1);
-  }
-  const newCursor = insertAt + 1 + prefix.length;
-  return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-}
-function hasSideContinuationBelow(text, lineEnd) {
-  if (lineEnd >= text.length || text[lineEnd] !== "\n") return false;
-  const nextLineStart = lineEnd + 1;
-  if (nextLineStart >= text.length) return false;
-  let nextLineEnd = nextLineStart;
-  while (nextLineEnd < text.length && text[nextLineEnd] !== "\n") nextLineEnd++;
-  const nextLine = text.slice(nextLineStart, nextLineEnd);
-  const nextStructural = parseStructuralTokens(nextLine);
-  return hasSideAnnotationTail(nextStructural.rest);
-}
-function handleMarkdownEnter(params) {
-  const { text, selectionStart, selectionEnd } = params;
-  const { line, lineStart, lineEnd } = getLineAt(text, selectionStart);
-  const cursorInLine = selectionStart - lineStart;
-  const structural = parseStructuralTokens(line);
-  const listToken = structural.tokens.find((t) => t.kind === "unordered-list" || t.kind === "ordered-list");
-  const hasOnlyBlockquotes = structural.tokens.length > 0 && structural.tokens.every((t) => t.kind === "blockquote");
-  const fenceContextBeforeLine = findFenceContext(text, lineStart);
-  const textAfterCursor = line.slice(cursorInLine).trim();
-  const afterCursorIsSideMarkerOnly = params.enableSideAnnotation !== false && SIDE_CONTINUATION_TAIL_RE.test(textAfterCursor);
-  const sideContinuationSplitCandidate = params.enableSideAnnotation !== false && getContinuationContentSplit(structural.rest, cursorInLine - structural.prefix.length) !== null;
-  if (afterCursorIsSideMarkerOnly) {
-    const content = structural.rest;
-    const contentBeforeMarker = content.replace(SIDE_CONTINUATION_TAIL_RE, "").trim();
-    if (!contentBeforeMarker) {
-      const newText = text.slice(0, lineStart) + structural.prefix + text.slice(lineEnd);
-      const newCursor = lineStart + structural.prefix.length;
-      return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-    }
-  }
-  if (textAfterCursor && !hasOnlyBlockquotes && !afterCursorIsSideMarkerOnly && !sideContinuationSplitCandidate) {
-    return NOT_HANDLED;
-  }
-  const fenceMatch = matchFenceLine(line);
-  if (fenceMatch && !(fenceContextBeforeLine && isMatchingFenceClose(line, fenceContextBeforeLine.prefix, fenceContextBeforeLine.marker))) {
-    const prefix = fenceMatch.prefix;
-    const marker = fenceMatch.marker;
-    const textAfter = text.slice(lineEnd);
-    const closingRe = new RegExp(`^[\\s\\S]*?\\n${escapeRegExp(prefix)}${escapeRegExp(marker[0])}{${marker.length},}\\s*$`, "m");
-    if (!closingRe.test(textAfter)) {
-      const insert = `
-${prefix}
-${prefix}${marker}`;
-      const newText = text.slice(0, selectionEnd) + insert + text.slice(selectionEnd);
-      const newCursor = selectionEnd + 1 + prefix.length;
-      return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-    }
-  }
-  const fenceContext = findFenceContext(text, selectionStart);
-  if (fenceContext) {
-    const innerIndent = structural.rest.match(/^(\s+)/)?.[1] ?? "";
-    if (!fenceContext.prefix && !innerIndent) return NOT_HANDLED;
-    const insert = `
-${fenceContext.prefix}${innerIndent}`;
-    const newText = text.slice(0, selectionEnd) + insert + text.slice(selectionEnd);
-    const newCursor = selectionEnd + insert.length;
-    return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-  }
-  if (listToken) {
-    const contentAfterPrefix = structural.rest.trim();
-    if (!contentAfterPrefix) {
-      if (structural.tokens.length === 1) {
-        const newText2 = text.slice(0, lineStart) + "\n" + text.slice(lineEnd);
-        const newCursor2 = lineStart + 1;
-        return { handled: true, value: newText2, selectionStart: newCursor2, selectionEnd: newCursor2 };
-      }
-      const outerTokens = structural.tokens.filter((t) => t !== listToken);
-      const outerPrefix = outerTokens.map((t) => t.raw).join("");
-      const newText = text.slice(0, lineStart) + outerPrefix + text.slice(lineEnd);
-      const newCursor = lineStart + outerPrefix.length;
-      return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-    }
-    if (contentAfterPrefix) {
-      const prefix = getContinuationPrefix(structural.tokens);
-      const insert = `
-${prefix}`;
-      const newText = text.slice(0, selectionEnd) + insert + text.slice(selectionEnd);
-      const newCursor = selectionEnd + insert.length;
-      return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-    }
-  }
-  if (params.enableSideAnnotation !== false) {
-    const sideResult = handleSideAnnotationContinuation(text, line, lineStart, lineEnd, selectionEnd, structural);
-    if (sideResult.handled) return sideResult;
-  }
-  if (hasOnlyBlockquotes) {
-    const contentAfterPrefix = structural.rest.trim();
-    if (!contentAfterPrefix) {
-      const newText2 = text.slice(0, lineStart) + "\n" + text.slice(lineEnd);
-      const newCursor2 = lineStart + 1;
-      return { handled: true, value: newText2, selectionStart: newCursor2, selectionEnd: newCursor2 };
-    }
-    const prefix = /\s$/.test(structural.prefix) ? structural.prefix : `${structural.prefix} `;
-    const before = text.slice(0, selectionEnd);
-    const after = text.slice(selectionEnd);
-    const newText = before + `
-${prefix}` + after;
-    const newCursor = selectionEnd + 1 + prefix.length;
-    return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-  }
-  return NOT_HANDLED;
-}
-
-// src/commands/indent.ts
-var FOUR_SPACE_LANGUAGES = /* @__PURE__ */ new Set(["py", "python", "rs", "rust"]);
-var TWO_SPACE_LANGUAGES = /* @__PURE__ */ new Set([
-  "bash",
-  "c",
-  "c++",
-  "cpp",
-  "css",
-  "html",
-  "javascript",
-  "js",
-  "json",
-  "jsx",
-  "shell",
-  "sh",
-  "ts",
-  "tsx",
-  "typescript"
-]);
-function getLineStarts(text) {
-  const starts = [0];
-  for (let i = 0; i < text.length; i++) {
-    if (text[i] === "\n") starts.push(i + 1);
-  }
-  return starts;
-}
-function findLineIndex(lineStarts, position) {
-  let low = 0;
-  let high = lineStarts.length - 1;
-  while (low <= high) {
-    const mid = Math.floor((low + high) / 2);
-    const lineStart = lineStarts[mid];
-    const nextLineStart = mid + 1 < lineStarts.length ? lineStarts[mid + 1] : Number.MAX_SAFE_INTEGER;
-    if (position < lineStart) {
-      high = mid - 1;
-      continue;
-    }
-    if (position >= nextLineStart) {
-      low = mid + 1;
-      continue;
-    }
-    return mid;
-  }
-  return lineStarts.length - 1;
-}
-function getLineRange(text, lineStarts, lineIndex) {
-  const start = lineStarts[lineIndex];
-  const end = lineIndex + 1 < lineStarts.length ? lineStarts[lineIndex + 1] : text.length;
-  return { start, end };
-}
-function parseFence(line) {
-  const match = line.match(/^\s*([`~]{3,})([^\n]*)$/);
-  if (!match) return null;
-  return { marker: match[1], info: match[2].trim() };
-}
-function isClosingFence(line, marker) {
-  const pattern = new RegExp(`^\\s*${marker[0]}{${marker.length},}\\s*$`);
-  return pattern.test(line);
-}
-function normalizeFenceLanguage(info) {
-  if (!info) return "";
-  return info.split(/\s+/)[0]?.toLowerCase() || "";
-}
-function resolveFenceContext(text, selectionStart) {
-  const lineStarts = getLineStarts(text);
-  const currentLineIndex = findLineIndex(lineStarts, selectionStart);
-  let activeFence = null;
-  for (let lineIndex = 0; lineIndex < lineStarts.length; lineIndex++) {
-    const { start, end } = getLineRange(text, lineStarts, lineIndex);
-    const line = text.slice(start, end).replace(/\n$/, "");
-    if (!activeFence) {
-      const fence = parseFence(line);
-      if (fence) activeFence = { ...fence, lineIndex };
-      continue;
-    }
-    if (isClosingFence(line, activeFence.marker)) {
-      if (currentLineIndex > activeFence.lineIndex && currentLineIndex < lineIndex) {
-        return {
-          fence: {
-            language: normalizeFenceLanguage(activeFence.info),
-            startLineIndex: activeFence.lineIndex + 1,
-            endLineIndex: lineIndex - 1
-          },
-          lineStarts
-        };
-      }
-      activeFence = null;
-      continue;
-    }
-  }
-  if (activeFence && currentLineIndex > activeFence.lineIndex) {
-    return {
-      fence: {
-        language: normalizeFenceLanguage(activeFence.info),
-        startLineIndex: activeFence.lineIndex + 1,
-        endLineIndex: lineStarts.length - 1
-      },
-      lineStarts
-    };
-  }
-  return { fence: null, lineStarts };
-}
-function resolveIndentSize(language, mode) {
-  if (mode === "2") return 2;
-  if (mode === "4") return 4;
-  const normalized = language.toLowerCase();
-  if (FOUR_SPACE_LANGUAGES.has(normalized)) return 4;
-  if (TWO_SPACE_LANGUAGES.has(normalized)) return 2;
-  return 2;
-}
-function getSelectionLineIndexes(text, lineStarts, selectionStart, selectionEnd) {
-  const selectionEndsAtLineStart = selectionEnd > selectionStart && lineStarts.includes(selectionEnd);
-  const startLineIndex = findLineIndex(lineStarts, selectionStart);
-  const effectiveEnd = selectionEndsAtLineStart ? selectionEnd - 1 : selectionEnd > selectionStart && text[selectionEnd - 1] === "\n" ? selectionEnd - 1 : selectionEnd;
-  const endLineIndex = findLineIndex(lineStarts, Math.max(selectionStart, effectiveEnd));
-  return { startLineIndex, endLineIndex };
-}
-function applyMarkdownIndent(params) {
-  const { text, selectionStart, selectionEnd, shiftKey, mode } = params;
-  const { fence, lineStarts } = resolveFenceContext(text, selectionStart);
-  if (!fence) {
-    return { handled: false, value: text, selectionStart, selectionEnd, indentSize: 0, language: "" };
-  }
-  const indentSize = resolveIndentSize(fence.language, mode);
-  const indentUnit = " ".repeat(indentSize);
-  if (selectionStart === selectionEnd) {
-    const currentLineIndex = findLineIndex(lineStarts, selectionStart);
-    const { start, end } = getLineRange(text, lineStarts, currentLineIndex);
-    const line = text.slice(start, end);
-    if (shiftKey) {
-      const leadingSpaces = line.match(/^ */)?.[0].length || 0;
-      const removable = Math.min(indentSize, leadingSpaces);
-      if (removable === 0) {
-        return { handled: true, value: text, selectionStart, selectionEnd, indentSize, language: fence.language };
-      }
-      const nextValue3 = `${text.slice(0, start)}${line.slice(removable)}${text.slice(end)}`;
-      const cursorShift = Math.min(removable, Math.max(0, selectionStart - start));
-      const nextSelection2 = selectionStart - cursorShift;
-      return { handled: true, value: nextValue3, selectionStart: nextSelection2, selectionEnd: nextSelection2, indentSize, language: fence.language };
-    }
-    const nextValue2 = `${text.slice(0, selectionStart)}${indentUnit}${text.slice(selectionEnd)}`;
-    const nextSelection = selectionStart + indentUnit.length;
-    return { handled: true, value: nextValue2, selectionStart: nextSelection, selectionEnd: nextSelection, indentSize, language: fence.language };
-  }
-  const { startLineIndex, endLineIndex } = getSelectionLineIndexes(text, lineStarts, selectionStart, selectionEnd);
-  const boundedStartLineIndex = Math.max(startLineIndex, fence.startLineIndex);
-  const boundedEndLineIndex = Math.min(endLineIndex, fence.endLineIndex);
-  if (boundedStartLineIndex > boundedEndLineIndex) {
-    return { handled: false, value: text, selectionStart, selectionEnd, indentSize, language: fence.language };
-  }
-  const segmentStart = lineStarts[boundedStartLineIndex];
-  const segmentEnd = boundedEndLineIndex + 1 < lineStarts.length ? lineStarts[boundedEndLineIndex + 1] : text.length;
-  const segmentText = text.slice(segmentStart, segmentEnd);
-  const hasTrailingNewline = segmentText.endsWith("\n");
-  const lines = (hasTrailingNewline ? segmentText.slice(0, -1) : segmentText).split("\n");
-  let totalInserted = 0;
-  let totalRemoved = 0;
-  const nextLines = lines.map((line) => {
-    if (shiftKey) {
-      const leadingSpaces = line.match(/^ */)?.[0].length || 0;
-      const removable = Math.min(indentSize, leadingSpaces);
-      totalRemoved += removable;
-      return line.slice(removable);
-    }
-    totalInserted += indentUnit.length;
-    return `${indentUnit}${line}`;
-  });
-  const nextSegment = `${nextLines.join("\n")}${hasTrailingNewline ? "\n" : ""}`;
-  const nextValue = `${text.slice(0, segmentStart)}${nextSegment}${text.slice(segmentEnd)}`;
-  const firstLineAdjustment = shiftKey ? Math.min(indentSize, text.slice(segmentStart, getLineRange(text, lineStarts, boundedStartLineIndex).end).match(/^ */)?.[0].length || 0) : indentUnit.length;
-  return {
-    handled: true,
-    value: nextValue,
-    selectionStart: selectionStart + (shiftKey ? -Math.min(firstLineAdjustment, Math.max(0, selectionStart - segmentStart)) : indentUnit.length),
-    selectionEnd: selectionEnd + (shiftKey ? -totalRemoved : totalInserted),
-    indentSize,
-    language: fence.language
-  };
-}
-
-// src/commands/char-input.ts
-var PAIRS = {
-  "(": { open: "(", close: ")" },
-  "[": { open: "[", close: "]" },
-  "{": { open: "{", close: "}" },
-  '"': { open: '"', close: '"' },
-  "'": { open: "'", close: "'" },
-  "`": { open: "`", close: "`" }
-};
-var CLOSING_CHARS = /* @__PURE__ */ new Set([")", "]", "}", '"', "'", "`"]);
-var MARKDOWN_PAIRS = {
-  "*": { open: "*", close: "*" },
-  "$": { open: "$", close: "$" }
-};
-function handleCharInput(params) {
-  const { key, text, selectionStart, selectionEnd, isComposing } = params;
-  if (isComposing) return NOT_HANDLED;
-  if (key.length !== 1) return NOT_HANDLED;
-  const hasSelection = selectionStart !== selectionEnd;
-  const charAfter = selectionEnd < text.length ? text[selectionEnd] : "";
-  if (!hasSelection && CLOSING_CHARS.has(key) && charAfter === key) {
-    return {
-      handled: true,
-      value: text,
-      selectionStart: selectionStart + 1,
-      selectionEnd: selectionEnd + 1
-    };
-  }
-  const pair = PAIRS[key];
-  if (pair) {
-    if (hasSelection) {
-      const selected = text.slice(selectionStart, selectionEnd);
-      const newText2 = text.slice(0, selectionStart) + pair.open + selected + pair.close + text.slice(selectionEnd);
-      return { handled: true, value: newText2, selectionStart: selectionStart + 1, selectionEnd: selectionEnd + 1 };
-    }
-    if (key === '"' || key === "'" || key === "`") {
-      const charBefore = selectionStart > 0 ? text[selectionStart - 1] : "";
-      if (/\w/.test(charBefore)) return NOT_HANDLED;
-      if (key === "`" && charBefore === "`") return NOT_HANDLED;
-    }
-    const newText = text.slice(0, selectionStart) + pair.open + pair.close + text.slice(selectionEnd);
-    const newCursor = selectionStart + 1;
-    return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-  }
-  if (key === "*" && !hasSelection) {
-    let lineStart = selectionStart;
-    while (lineStart > 0 && text[lineStart - 1] !== "\n") lineStart--;
-    const textBeforeCursor = text.slice(lineStart, selectionStart);
-    if (/^\s*$/.test(textBeforeCursor)) return NOT_HANDLED;
-  }
-  const mdPair = MARKDOWN_PAIRS[key];
-  if (mdPair) {
-    if (hasSelection) {
-      const selected = text.slice(selectionStart, selectionEnd);
-      const newText2 = text.slice(0, selectionStart) + mdPair.open + selected + mdPair.close + text.slice(selectionEnd);
-      return { handled: true, value: newText2, selectionStart: selectionStart + 1, selectionEnd: selectionEnd + 1 };
-    }
-    if (charAfter === key) {
-      return { handled: true, value: text, selectionStart: selectionStart + 1, selectionEnd: selectionEnd + 1 };
-    }
-    if (key === "*" && selectionStart > 0 && text[selectionStart - 1] === "*") {
-      return NOT_HANDLED;
-    }
-    if (key === "$" && selectionStart > 0 && text[selectionStart - 1] === "$") {
-      return NOT_HANDLED;
-    }
-    const newText = text.slice(0, selectionStart) + mdPair.open + mdPair.close + text.slice(selectionEnd);
-    const newCursor = selectionStart + 1;
-    return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-  }
-  return NOT_HANDLED;
-}
-var ALL_PAIRS = [...Object.values(PAIRS), ...Object.values(MARKDOWN_PAIRS)];
-function findMatchedPair(text, pos) {
-  if (pos <= 0 || pos >= text.length) return null;
-  const charBefore = text[pos - 1];
-  const charAfter = text[pos];
-  return ALL_PAIRS.find((p) => p.open === charBefore && p.close === charAfter) ?? null;
-}
-function deletePair(text, pos) {
-  const newText = text.slice(0, pos - 1) + text.slice(pos + 1);
-  const newCursor = pos - 1;
-  return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-}
-function handleSmartDelete(params) {
-  const { text, selectionStart, selectionEnd } = params;
-  if (selectionStart !== selectionEnd || selectionStart >= text.length) return NOT_HANDLED;
-  if (findMatchedPair(text, selectionStart)) return deletePair(text, selectionStart);
-  return NOT_HANDLED;
-}
-
-// src/commands/backspace.ts
-var PAIRS2 = {
-  "(": { open: "(", close: ")" },
-  "[": { open: "[", close: "]" },
-  "{": { open: "{", close: "}" },
-  '"': { open: '"', close: '"' },
-  "'": { open: "'", close: "'" },
-  "`": { open: "`", close: "`" },
-  "*": { open: "*", close: "*" },
-  "$": { open: "$", close: "$" }
-};
-var ALL_PAIRS2 = Object.values(PAIRS2);
-var SIDE_CONTINUATION_ONLY_RE = /^(?<prefix>(?:\s*> ?|\s*(?:[-*+]|\d+\.)\s+)*)\s*\(>\+\)\s*$/;
-function findMatchedPair2(text, pos) {
-  if (pos <= 0 || pos >= text.length) return null;
-  const charBefore = text[pos - 1];
-  const charAfter = text[pos];
-  return ALL_PAIRS2.find((p) => p.open === charBefore && p.close === charAfter) ?? null;
-}
-function deletePair2(text, pos) {
-  const newText = text.slice(0, pos - 1) + text.slice(pos + 1);
-  const newCursor = pos - 1;
-  return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-}
-function getLineAt2(text, pos) {
-  let lineStart = pos;
-  while (lineStart > 0 && text[lineStart - 1] !== "\n") lineStart--;
-  let lineEnd = pos;
-  while (lineEnd < text.length && text[lineEnd] !== "\n") lineEnd++;
-  return { line: text.slice(lineStart, lineEnd), lineStart, lineEnd };
-}
-function getEmptySideContinuationBackspaceResult(text, pos) {
-  const { line, lineStart, lineEnd } = getLineAt2(text, pos);
-  const match = SIDE_CONTINUATION_ONLY_RE.exec(line);
-  if (!match) return NOT_HANDLED;
-  const prefix = match.groups?.prefix ?? "";
-  const expectedCursor = lineStart + prefix.length;
-  if (pos !== expectedCursor) return NOT_HANDLED;
-  const prevLineCursor = Math.max(0, lineStart - 1);
-  if (lineEnd < text.length && text[lineEnd] === "\n") {
-    const newText2 = text.slice(0, lineStart) + text.slice(lineEnd + 1);
-    return {
-      handled: true,
-      value: newText2,
-      selectionStart: prevLineCursor,
-      selectionEnd: prevLineCursor
-    };
-  }
-  const removalStart = lineStart > 0 && text[lineStart - 1] === "\n" ? lineStart - 1 : lineStart;
-  const newText = text.slice(0, removalStart) + text.slice(lineEnd);
-  return {
-    handled: true,
-    value: newText,
-    selectionStart: prevLineCursor,
-    selectionEnd: prevLineCursor
-  };
-}
-function handleSmartBackspace(params) {
-  const { text, selectionStart, selectionEnd } = params;
-  if (selectionStart !== selectionEnd || selectionStart === 0) return NOT_HANDLED;
-  const sideContinuationResult = getEmptySideContinuationBackspaceResult(text, selectionStart);
-  if (sideContinuationResult.handled) return sideContinuationResult;
-  if (findMatchedPair2(text, selectionStart)) return deletePair2(text, selectionStart);
-  return NOT_HANDLED;
-}
-
-// src/commands/inline-format.ts
-function toggleBold(params) {
-  return toggleWrap(params, "**");
-}
-function toggleItalic(params) {
-  return toggleWrap(params, "*");
-}
-function insertLink(params) {
-  const { text, selectionStart, selectionEnd, url } = params;
-  const hasSelection = selectionStart !== selectionEnd;
-  const selected = text.slice(selectionStart, selectionEnd);
-  const linkUrl = url || "url";
-  if (hasSelection) {
-    const insert2 = `[${selected}](${linkUrl})`;
-    const newText2 = text.slice(0, selectionStart) + insert2 + text.slice(selectionEnd);
-    const urlStart = selectionStart + 1 + selected.length + 2;
-    const urlEnd = urlStart + linkUrl.length;
-    return { handled: true, value: newText2, selectionStart: urlStart, selectionEnd: urlEnd };
-  }
-  const insert = `[link text](${linkUrl})`;
-  const newText = text.slice(0, selectionStart) + insert + text.slice(selectionEnd);
-  const textStart = selectionStart + 1;
-  const textEnd = textStart + 9;
-  return { handled: true, value: newText, selectionStart: textStart, selectionEnd: textEnd };
-}
-function insertCodeFence(params) {
-  const { text, selectionStart, selectionEnd, language } = params;
-  const lang = language || "";
-  const insert = `\`\`\`${lang}
-
-\`\`\``;
-  const newText = text.slice(0, selectionStart) + insert + text.slice(selectionEnd);
-  const newCursor = selectionStart + 3 + lang.length + 1;
-  return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-}
-function insertMathBlock(params) {
-  const { text, selectionStart, selectionEnd } = params;
-  const insert = "$$\n\n$$";
-  const newText = text.slice(0, selectionStart) + insert + text.slice(selectionEnd);
-  const newCursor = selectionStart + insert.indexOf("\n") + 1;
-  return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-}
-function insertTable(params) {
-  const { text, selectionStart, selectionEnd } = params;
-  const insert = "| Column 1 | Column 2 | Column 3 |\n| --- | --- | --- |\n|  |  |  |";
-  const newText = text.slice(0, selectionStart) + insert + text.slice(selectionEnd);
-  const newCursor = selectionStart + "| Column 1 | Column 2 | Column 3 |\n| --- | --- | --- |\n| ".length;
-  return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-}
-function insertImage(params) {
-  const { text, selectionStart, selectionEnd } = params;
-  const insert = "![alt text](url)";
-  const newText = text.slice(0, selectionStart) + insert + text.slice(selectionEnd);
-  const altStart = selectionStart + 2;
-  const altEnd = altStart + 8;
-  return { handled: true, value: newText, selectionStart: altStart, selectionEnd: altEnd };
-}
-function insertSideAnnotation(params) {
-  const { text, selectionStart, selectionEnd, type } = params;
-  const typeSymbol = type || "}";
-  const hasSelection = selectionStart !== selectionEnd;
-  if (!hasSelection) {
-    const insert = ` (>${typeSymbol} \u6807\u6CE8)`;
-    const newText2 = text.slice(0, selectionStart) + insert + text.slice(selectionEnd);
-    const annoStart2 = selectionStart + 4 + typeSymbol.length;
-    const annoEnd2 = annoStart2 + 2;
-    return { handled: true, value: newText2, selectionStart: annoStart2, selectionEnd: annoEnd2 };
-  }
-  const selected = text.slice(selectionStart, selectionEnd);
-  const lines = selected.split("\n");
-  const nonEmptyLines = lines.filter((l) => l.trim());
-  if (nonEmptyLines.length <= 3) {
-    const result = [];
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      if (!line.trim()) {
-        result.push(line);
-        continue;
-      }
-      if (i === 0 || result.every((r) => !r.trim())) {
-        result.push(`${line} (>${typeSymbol} \u6807\u6CE8)`);
-      } else {
-        result.push(`${line} (>+)`);
-      }
-    }
-    const newSelected = result.join("\n");
-    const newText2 = text.slice(0, selectionStart) + newSelected + text.slice(selectionEnd);
-    const annoOffset2 = newSelected.indexOf("\u6807\u6CE8");
-    const annoStart2 = selectionStart + annoOffset2;
-    const annoEnd2 = annoStart2 + 2;
-    return { handled: true, value: newText2, selectionStart: annoStart2, selectionEnd: annoEnd2 };
-  }
-  const indent = "";
-  const container = `:::side
-(>${typeSymbol} \u6807\u6CE8)
-
-${selected}
-:::`;
-  const newText = text.slice(0, selectionStart) + container + text.slice(selectionEnd);
-  const annoOffset = container.indexOf("\u6807\u6CE8");
-  const annoStart = selectionStart + annoOffset;
-  const annoEnd = annoStart + 2;
-  return { handled: true, value: newText, selectionStart: annoStart, selectionEnd: annoEnd };
-}
-function toggleWrap(params, wrapper) {
-  const { text, selectionStart, selectionEnd } = params;
-  const wLen = wrapper.length;
-  const hasSelection = selectionStart !== selectionEnd;
-  if (hasSelection) {
-    const selected = text.slice(selectionStart, selectionEnd);
-    const before = text.slice(Math.max(0, selectionStart - wLen), selectionStart);
-    const after = text.slice(selectionEnd, selectionEnd + wLen);
-    if (before === wrapper && after === wrapper) {
-      const newText3 = text.slice(0, selectionStart - wLen) + selected + text.slice(selectionEnd + wLen);
-      return {
-        handled: true,
-        value: newText3,
-        selectionStart: selectionStart - wLen,
-        selectionEnd: selectionEnd - wLen
-      };
-    }
-    const newText2 = text.slice(0, selectionStart) + wrapper + selected + wrapper + text.slice(selectionEnd);
-    return {
-      handled: true,
-      value: newText2,
-      selectionStart: selectionStart + wLen,
-      selectionEnd: selectionEnd + wLen
-    };
-  }
-  const insert = wrapper + wrapper;
-  const newText = text.slice(0, selectionStart) + insert + text.slice(selectionEnd);
-  const newCursor = selectionStart + wLen;
-  return { handled: true, value: newText, selectionStart: newCursor, selectionEnd: newCursor };
-}
-
-// src/commands/slash/registry.ts
-function createCommandRegistry() {
-  const commands = /* @__PURE__ */ new Map();
-  function register(def) {
-    if (commands.has(def.id)) {
-      console.warn(`[owomark] CommandRegistry: overriding existing command "${def.id}"`);
-    }
-    commands.set(def.id, {
-      def,
-      lowerId: def.id.toLowerCase(),
-      lowerLabel: def.label.toLowerCase(),
-      lowerKeywords: def.keywords?.map((k) => k.toLowerCase()) ?? []
-    });
-    return () => commands.delete(def.id);
-  }
-  function unregister(id) {
-    commands.delete(id);
-  }
-  function get(id) {
-    return commands.get(id)?.def;
-  }
-  function getAll() {
-    return Array.from(commands.values()).map((c) => c.def);
-  }
-  const DEFAULT_PRIORITY = 100;
-  function search(query) {
-    const lowerQuery = query.toLowerCase().trim();
-    const results = [];
-    for (const { def, lowerId, lowerLabel, lowerKeywords } of commands.values()) {
-      if (def.slashMenu === false) continue;
-      if (lowerQuery === "") {
-        results.push(def);
-        continue;
-      }
-      const matched = lowerId.includes(lowerQuery) || lowerLabel.includes(lowerQuery) || lowerKeywords.some((k) => k.includes(lowerQuery));
-      if (matched) {
-        results.push(def);
-      }
-    }
-    results.sort((a, b) => {
-      const catA = a.category ?? "";
-      const catB = b.category ?? "";
-      if (catA !== catB) return catA.localeCompare(catB);
-      return (a.priority ?? DEFAULT_PRIORITY) - (b.priority ?? DEFAULT_PRIORITY);
-    });
-    return results;
-  }
-  return { register, unregister, get, getAll, search };
-}
-
-// src/core/block-context.ts
-var BLOCK_TO_CONTEXT = {
-  "heading": "heading",
-  "paragraph": "paragraph",
-  "unordered-list": "unordered-list",
-  "ordered-list": "ordered-list",
-  "blockquote": "blockquote",
-  "code-fence": "code-block",
-  "thematic-break": "thematic-break",
-  "directive-container": "directive-container",
-  "math-block": "math-block",
-  "table": "table"
-};
-function resolveBlockContextType(block) {
-  if (block.type === "paragraph" && !block.raw.trim()) return "empty";
-  return BLOCK_TO_CONTEXT[block.type];
-}
-
-// src/core/core-events.ts
-function createCoreEventHub() {
-  const changeListeners = /* @__PURE__ */ new Set();
-  const selectionListeners = /* @__PURE__ */ new Set();
-  const compositionListeners = /* @__PURE__ */ new Set();
-  const stateListeners = /* @__PURE__ */ new Set();
-  const slashStateListeners = /* @__PURE__ */ new Set();
-  return {
-    onChange(callback) {
-      changeListeners.add(callback);
-      return () => changeListeners.delete(callback);
-    },
-    onSelectionChange(callback) {
-      selectionListeners.add(callback);
-      return () => selectionListeners.delete(callback);
-    },
-    onCompositionStateChange(callback) {
-      compositionListeners.add(callback);
-      return () => compositionListeners.delete(callback);
-    },
-    onStateChange(callback) {
-      stateListeners.add(callback);
-      return () => stateListeners.delete(callback);
-    },
-    onSlashStateChange(callback) {
-      slashStateListeners.add(callback);
-      return () => slashStateListeners.delete(callback);
-    },
-    emitChange(markdown) {
-      for (const listener of changeListeners) listener(markdown);
-    },
-    emitSelectionChange(selection) {
-      for (const listener of selectionListeners) listener(selection);
-    },
-    emitCompositionChange(active) {
-      for (const listener of compositionListeners) listener(active);
-    },
-    emitStateChange(snapshot) {
-      for (const listener of stateListeners) listener(snapshot);
-    },
-    emitSlashStateChange(state) {
-      for (const listener of slashStateListeners) listener(state);
-    }
-  };
-}
-
-// src/core/core-selection.ts
-function toVirtualSelectionOrNull(doc, selection) {
-  if (!selection) return null;
-  return linearToVirtual(doc, selection);
-}
-function getLinearSelectionOrFallback(doc, selection) {
-  if (!selection) return { anchor: 0, focus: 0 };
-  return virtualToLinear(doc, selection);
-}
-
-// src/commands/slash/slash-manager.ts
-var INACTIVE_STATE = {
-  active: false,
-  triggerOffset: 0,
-  query: "",
-  selectedIndex: 0,
-  filteredCommands: [],
-  pending: false
-};
-function createSlashManager(registry, deps) {
-  let state = { ...INACTIVE_STATE };
-  const listeners = /* @__PURE__ */ new Set();
-  function emit() {
-    const snapshot = { ...state };
-    for (const listener of listeners) listener(snapshot);
-  }
-  function setState(patch) {
-    state = { ...state, ...patch };
-    emit();
-  }
-  function reset() {
-    state = { ...INACTIVE_STATE };
-    emit();
-  }
-  function mapSelectionThroughReplacement(selection, startOffset, endOffset, replacementLength) {
-    const delta = replacementLength - (endOffset - startOffset);
-    function mapOffset(offset) {
-      if (offset <= startOffset) return offset;
-      if (offset >= endOffset) return offset + delta;
-      return startOffset + replacementLength;
-    }
-    return {
-      anchor: mapOffset(selection.anchor),
-      focus: mapOffset(selection.focus)
-    };
-  }
-  function replaceBlockMarkdownById(blockId, markdown) {
-    const currentDoc = deps.getDocument();
-    const blockIndex = getBlockIndexById(currentDoc, blockId);
-    if (blockIndex === void 0) return false;
-    const block = currentDoc.blocks[blockIndex];
-    if (!block) return false;
-    const currentMarkdown = deps.getMarkdown();
-    const blockStart = getBlockStartOffset(currentDoc, blockIndex);
-    const blockEnd = blockStart + block.raw.length;
-    let removeStart = blockStart;
-    let removeEnd = blockEnd;
-    let replacement = markdown ?? "";
-    if (markdown === null) {
-      const hasPrev = blockIndex > 0;
-      const hasNext = blockIndex < currentDoc.blocks.length - 1;
-      if (hasNext) {
-        removeEnd += 1;
-      } else if (hasPrev) {
-        removeStart = Math.max(0, removeStart - 1);
-      }
-    }
-    const nextMarkdown = currentMarkdown.slice(0, removeStart) + replacement + currentMarkdown.slice(removeEnd);
-    const nextSelection = mapSelectionThroughReplacement(
-      deps.getLinearSelection(),
-      removeStart,
-      removeEnd,
-      replacement.length
-    );
-    deps.applyUpdate(nextMarkdown, nextSelection);
-    return true;
-  }
-  function buildCommandContext(triggerInfo) {
-    const markdown = deps.getMarkdown();
-    const sel = deps.getLinearSelection();
-    const doc = deps.getDocument();
-    const pos = Math.min(sel.anchor, sel.focus);
-    const { blockIndex } = getBlockAtOffset(doc, pos);
-    const block = doc.blocks[blockIndex];
-    let latestPlaceholderId = null;
-    const ctx = {
-      text: markdown,
-      selectionStart: pos,
-      selectionEnd: Math.max(sel.anchor, sel.focus),
-      applyUpdate: (newText, newSel) => {
-        deps.applyUpdate(newText, { anchor: newSel.anchor, focus: newSel.focus });
-      },
-      document: doc,
-      blockType: block?.type ?? "paragraph",
-      blockDepth: block?.depth ?? 0,
-      triggerInfo,
-      enableSideAnnotation: deps.featureFlags.enableSideAnnotation,
-      enableMath: deps.featureFlags.enableMath,
-      turnIntoBlock(prefix) {
-        const md = deps.getMarkdown();
-        const d = deps.getDocument();
-        const curSel = deps.getLinearSelection();
-        const p = Math.min(curSel.anchor, curSel.focus);
-        const { blockIndex: bi } = getBlockAtOffset(d, p);
-        const blk = d.blocks[bi];
-        if (!blk) return;
-        const blockStart = getBlockStartOffset(d, bi);
-        const oldPrefix = getContentStartOffset(blk.raw, blk.type);
-        const content = blk.raw.slice(oldPrefix);
-        const newRaw = prefix + content;
-        const newText = md.slice(0, blockStart) + newRaw + md.slice(blockStart + blk.raw.length);
-        const newCursor = blockStart + prefix.length + content.length;
-        deps.applyUpdate(newText, { anchor: newCursor, focus: newCursor });
-      },
-      replaceTriggerText(text) {
-        if (!triggerInfo) return;
-        const md = deps.getMarkdown();
-        const before = md.slice(0, triggerInfo.startOffset);
-        const after = md.slice(triggerInfo.endOffset);
-        const newText = before + text + after;
-        const newCursor = triggerInfo.startOffset + text.length;
-        deps.applyUpdate(newText, { anchor: newCursor, focus: newCursor });
-      },
-      insertBlockBelow(blockMarkdown) {
-        const md = deps.getMarkdown();
-        const d = deps.getDocument();
-        const curSel = deps.getLinearSelection();
-        const p = Math.min(curSel.anchor, curSel.focus);
-        const { blockIndex: bi } = getBlockAtOffset(d, p);
-        const blockEnd = getBlockStartOffset(d, bi) + (d.blocks[bi]?.raw.length ?? 0);
-        const newText = md.slice(0, blockEnd) + "\n" + blockMarkdown + md.slice(blockEnd);
-        const newCursor = blockEnd + 1 + blockMarkdown.length;
-        deps.applyUpdate(newText, { anchor: newCursor, focus: newCursor });
-      },
-      insertPlaceholderBlock(blockMarkdown) {
-        const d = deps.getDocument();
-        const curSel = deps.getLinearSelection();
-        const p = Math.min(curSel.anchor, curSel.focus);
-        const { blockIndex: bi } = getBlockAtOffset(d, p);
-        const blk = d.blocks[bi];
-        if (!blk) return null;
-        const blockStart = getBlockStartOffset(d, bi);
-        const md = deps.getMarkdown();
-        const newText = md.slice(0, blockStart) + blockMarkdown + md.slice(blockStart + blk.raw.length);
-        const newCursor = blockStart + blockMarkdown.length;
-        deps.applyUpdate(newText, { anchor: newCursor, focus: newCursor });
-        const updatedDoc = deps.getDocument();
-        const updatedPos = Math.max(0, Math.min(newCursor, deps.getMarkdown().length));
-        const { blockIndex: updatedIndex } = getBlockAtOffset(updatedDoc, updatedPos);
-        latestPlaceholderId = updatedDoc.blocks[updatedIndex]?.id ?? null;
-        return latestPlaceholderId;
-      },
-      replaceBlockById(blockId, blockMarkdown) {
-        return replaceBlockMarkdownById(blockId, blockMarkdown);
-      },
-      removeBlockById(blockId) {
-        return replaceBlockMarkdownById(blockId, null);
-      }
-    };
-    return {
-      ctx,
-      getLatestPlaceholderId: () => latestPlaceholderId
-    };
-  }
-  function getExecutableSlashCommands(query, triggerInfo) {
-    const candidates = registry.search(query);
-    if (candidates.length === 0) return candidates;
-    const { ctx } = buildCommandContext(triggerInfo);
-    return candidates.filter((cmd) => cmd.canExecute ? cmd.canExecute(ctx) : true);
-  }
-  function runCommand(cmd, ctx, payload, onError) {
-    try {
-      const result = cmd.execute(ctx, payload);
-      if (result instanceof Promise) {
-        result.catch((err) => {
-          onError?.();
-          console.error(`[owomark] ${ctx.triggerInfo ? "Slash command" : "Command"} "${cmd.id}" failed:`, err);
-        });
-      }
-    } catch (err) {
-      onError?.();
-      console.error(`[owomark] ${ctx.triggerInfo ? "Slash command" : "Command"} "${cmd.id}" threw:`, err);
-    }
-  }
-  function isValidTriggerPosition(pos, markdown, doc) {
-    if (doc.blocks.length === 0 && pos === 0) return true;
-    const { blockIndex } = getBlockAtOffset(doc, pos);
-    const block = doc.blocks[blockIndex];
-    if (!block) return false;
-    if (block.type === "code-fence") return false;
-    const blockStart = getBlockStartOffset(doc, blockIndex);
-    const offsetInBlock = pos - blockStart;
-    const raw = block.raw;
-    const contentStart = getContentStartOffset(raw, block.type);
-    if (offsetInBlock === contentStart) {
-      return true;
-    }
-    if (offsetInBlock > 0) {
-      const prevChar = raw[offsetInBlock - 1];
-      if (prevChar === " " || prevChar === "	") {
-        return true;
-      }
-    }
-    return false;
-  }
-  function getContentStartOffset(raw, blockType) {
-    if (blockType === "heading") {
-      const m = raw.match(/^#{1,6}\s/);
-      return m ? m[0].length : 0;
-    }
-    if (blockType === "blockquote") {
-      const m = raw.match(/^(?:>\s?)+/);
-      return m ? m[0].length : 0;
-    }
-    if (blockType === "unordered-list" || blockType === "ordered-list") {
-      const m = raw.match(/^\s*(?:[-*+]|\d+\.)\s/);
-      return m ? m[0].length : 0;
-    }
-    return 0;
-  }
-  function tryActivate(pos, markdown, doc) {
-    if (deps.isComposing()) return false;
-    if (state.active) return false;
-    if (!isValidTriggerPosition(pos, markdown, doc)) return false;
-    const available = getExecutableSlashCommands("", {
-      startOffset: pos,
-      endOffset: pos + 1,
-      query: ""
-    });
-    if (available.length === 0) return false;
-    setState({
-      active: true,
-      triggerOffset: pos,
-      query: "",
-      selectedIndex: 0,
-      filteredCommands: available,
-      pending: false
-    });
-    return true;
-  }
-  function updateQuery(cursorOffset, markdown) {
-    if (!state.active) return;
-    const queryStart = state.triggerOffset + 1;
-    if (cursorOffset < queryStart) {
-      reset();
-      return;
-    }
-    const query = markdown.slice(queryStart, cursorOffset);
-    if (query.includes(" ")) {
-      reset();
-      return;
-    }
-    const filtered = getExecutableSlashCommands(query, {
-      startOffset: state.triggerOffset,
-      endOffset: cursorOffset,
-      query
-    });
-    if (filtered.length === 0) {
-      reset();
-      return;
-    }
-    setState({
-      query,
-      filteredCommands: filtered,
-      selectedIndex: 0
-    });
-  }
-  function handleKeyDown(key, shiftKey, ctrlKey, metaKey, altKey) {
-    if (!state.active) return false;
-    if (key === "Shift" || key === "Control" || key === "Alt" || key === "Meta") {
-      return false;
-    }
-    if (key === "Escape") {
-      reset();
-      return true;
-    }
-    if (key === "ArrowUp") {
-      const newIndex = state.selectedIndex <= 0 ? state.filteredCommands.length - 1 : state.selectedIndex - 1;
-      setState({ selectedIndex: newIndex });
-      return true;
-    }
-    if (key === "ArrowDown") {
-      const newIndex = state.selectedIndex >= state.filteredCommands.length - 1 ? 0 : state.selectedIndex + 1;
-      setState({ selectedIndex: newIndex });
-      return true;
-    }
-    if (key === "Enter") {
-      executeByIndex(state.selectedIndex);
-      return true;
-    }
-    return false;
-  }
-  function handleBackspace(cursorOffset, markdown) {
-    if (!state.active) return false;
-    if (cursorOffset <= state.triggerOffset + 1) {
-      reset();
-      return false;
-    }
-    return false;
-  }
-  function executeByIndex(index) {
-    if (!state.active) return;
-    const cmd = state.filteredCommands[index];
-    if (!cmd) return;
-    const originalTrigger = {
-      startOffset: state.triggerOffset,
-      endOffset: state.triggerOffset + 1 + state.query.length,
-      query: state.query
-    };
-    reset();
-    deps.pushHistory();
-    const markdown = deps.getMarkdown();
-    const before = markdown.slice(0, originalTrigger.startOffset);
-    const after = markdown.slice(originalTrigger.endOffset);
-    const cleanedText = before + after;
-    const cursorAt = originalTrigger.startOffset;
-    deps.applyUpdate(cleanedText, { anchor: cursorAt, focus: cursorAt });
-    const triggerInfo = {
-      startOffset: cursorAt,
-      endOffset: cursorAt,
-      query: originalTrigger.query
-    };
-    const builtCtx = buildCommandContext(triggerInfo);
-    const ctx = builtCtx.ctx;
-    if (cmd.canExecute && !cmd.canExecute(ctx)) {
-      deps.applyUpdate(markdown, { anchor: originalTrigger.endOffset, focus: originalTrigger.endOffset });
-      return;
-    }
-    try {
-      const result = cmd.execute(ctx);
-      if (result instanceof Promise) {
-        setState({
-          active: false,
-          pending: true,
-          triggerOffset: cursorAt,
-          query: originalTrigger.query,
-          selectedIndex: 0,
-          filteredCommands: [cmd]
-        });
-        result.then(() => {
-          reset();
-        }).catch((err) => {
-          const placeholderId = builtCtx.getLatestPlaceholderId();
-          if (placeholderId) {
-            if (!replaceBlockMarkdownById(placeholderId, `/${originalTrigger.query}`)) {
-              deps.applyUpdate(markdown, { anchor: originalTrigger.endOffset, focus: originalTrigger.endOffset });
-            }
-          } else {
-            deps.applyUpdate(markdown, { anchor: originalTrigger.endOffset, focus: originalTrigger.endOffset });
-          }
-          reset();
-          console.error(`[owomark] Slash command "${cmd.id}" failed:`, err);
-        });
-        return;
-      }
-      reset();
-    } catch (err) {
-      deps.applyUpdate(markdown, { anchor: originalTrigger.endOffset, focus: originalTrigger.endOffset });
-      reset();
-      console.error(`[owomark] Slash command "${cmd.id}" threw:`, err);
-    }
-  }
-  function executeById(id, payload) {
-    const cmd = registry.get(id);
-    if (!cmd) return;
-    const { ctx } = buildCommandContext(null);
-    if (cmd.canExecute && !cmd.canExecute(ctx)) {
-      return;
-    }
-    runCommand(cmd, ctx, payload);
-  }
-  function dismiss() {
-    if (state.active) reset();
-  }
-  return {
-    registry,
-    getSlashState: () => ({ ...state, filteredCommands: [...state.filteredCommands] }),
-    tryActivate,
-    updateQuery,
-    handleKeyDown,
-    handleBackspace,
-    executeByIndex,
-    executeById,
-    dismiss,
-    onSlashStateChange(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    }
-  };
-}
-
-// src/commands/slash/builtin-commands.ts
-function makeFormatCommand(id, label, shortcut, executeFn) {
-  return {
-    id,
-    label,
-    category: "format",
-    slashMenu: false,
-    shortcut,
-    execute(ctx) {
-      const result = executeFn({
-        text: ctx.text,
-        selectionStart: ctx.selectionStart,
-        selectionEnd: ctx.selectionEnd
-      });
-      if (result.handled) {
-        ctx.applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-      }
-    }
-  };
-}
-var bold = makeFormatCommand("bold", "Bold", "Ctrl+B", toggleBold);
-var italic = makeFormatCommand("italic", "Italic", "Ctrl+I", toggleItalic);
-var link = {
-  id: "link",
-  label: "Link",
-  category: "insert",
-  slashMenu: true,
-  priority: 50,
-  shortcut: "Ctrl+K",
-  execute(ctx, payload) {
-    const url = typeof payload === "string" ? payload : void 0;
-    const result = insertLink({
-      text: ctx.text,
-      selectionStart: ctx.selectionStart,
-      selectionEnd: ctx.selectionEnd,
-      url
-    });
-    if (result.handled) {
-      ctx.applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-    }
-  }
-};
-var codeFence = {
-  id: "code-fence",
-  label: "Code Block",
-  category: "insert",
-  slashMenu: true,
-  priority: 60,
-  keywords: ["code", "fence", "block"],
-  execute(ctx, payload) {
-    const lang = typeof payload === "string" ? payload : void 0;
-    const result = insertCodeFence({
-      text: ctx.text,
-      selectionStart: ctx.selectionStart,
-      selectionEnd: ctx.selectionEnd,
-      language: lang
-    });
-    if (result.handled) {
-      ctx.applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-    }
-  }
-};
-var mathBlock = {
-  id: "math",
-  label: "Math Block",
-  category: "insert",
-  slashMenu: true,
-  priority: 65,
-  keywords: ["math", "equation", "formula", "latex", "katex"],
-  canExecute(ctx) {
-    return ctx.enableMath;
-  },
-  execute(ctx) {
-    const result = insertMathBlock({
-      text: ctx.text,
-      selectionStart: ctx.selectionStart,
-      selectionEnd: ctx.selectionEnd
-    });
-    if (result.handled) {
-      ctx.applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-    }
-  }
-};
-var sideAnnotation = {
-  id: "side-annotation",
-  label: "Side Annotation",
-  category: "insert",
-  slashMenu: true,
-  priority: 70,
-  shortcut: "Ctrl+Shift+]",
-  keywords: ["side", "annotation", "brace", "margin", "note"],
-  canExecute(ctx) {
-    return ctx.enableSideAnnotation;
-  },
-  execute(ctx, payload) {
-    const type = typeof payload === "string" ? payload : void 0;
-    const result = insertSideAnnotation({
-      text: ctx.text,
-      selectionStart: ctx.selectionStart,
-      selectionEnd: ctx.selectionEnd,
-      type
-    });
-    if (result.handled) {
-      ctx.applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-    }
-  }
-};
-var heading1 = {
-  id: "heading-1",
-  label: "Heading 1",
-  category: "basic",
-  slashMenu: true,
-  priority: 10,
-  keywords: ["h1", "title"],
-  execute(ctx) {
-    ctx.turnIntoBlock("# ");
-  }
-};
-var heading2 = {
-  id: "heading-2",
-  label: "Heading 2",
-  category: "basic",
-  slashMenu: true,
-  priority: 11,
-  keywords: ["h2"],
-  execute(ctx) {
-    ctx.turnIntoBlock("## ");
-  }
-};
-var heading3 = {
-  id: "heading-3",
-  label: "Heading 3",
-  category: "basic",
-  slashMenu: true,
-  priority: 12,
-  keywords: ["h3"],
-  execute(ctx) {
-    ctx.turnIntoBlock("### ");
-  }
-};
-var blockquote = {
-  id: "blockquote",
-  label: "Blockquote",
-  category: "basic",
-  slashMenu: true,
-  priority: 20,
-  keywords: ["quote"],
-  execute(ctx) {
-    ctx.turnIntoBlock("> ");
-  }
-};
-var unorderedList = {
-  id: "unordered-list",
-  label: "Bullet List",
-  category: "basic",
-  slashMenu: true,
-  priority: 30,
-  keywords: ["bullet", "list", "ul"],
-  execute(ctx) {
-    ctx.turnIntoBlock("- ");
-  }
-};
-var orderedList = {
-  id: "ordered-list",
-  label: "Numbered List",
-  category: "basic",
-  slashMenu: true,
-  priority: 31,
-  keywords: ["number", "list", "ol"],
-  execute(ctx) {
-    ctx.turnIntoBlock("1. ");
-  }
-};
-var thematicBreak = {
-  id: "thematic-break",
-  label: "Divider",
-  category: "basic",
-  slashMenu: true,
-  priority: 40,
-  keywords: ["divider", "hr", "line", "separator"],
-  execute(ctx) {
-    ctx.insertBlockBelow("---");
-  }
-};
-var table = {
-  id: "insert-table",
-  label: "Table",
-  category: "insert",
-  slashMenu: true,
-  priority: 75,
-  keywords: ["table", "grid"],
-  execute(ctx) {
-    const result = insertTable({
-      text: ctx.text,
-      selectionStart: ctx.selectionStart,
-      selectionEnd: ctx.selectionEnd
-    });
-    if (result.handled) {
-      ctx.applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-    }
-  }
-};
-var image = {
-  id: "insert-image",
-  label: "Image",
-  category: "insert",
-  slashMenu: true,
-  priority: 80,
-  keywords: ["image", "picture", "photo", "img"],
-  execute(ctx) {
-    const result = insertImage({
-      text: ctx.text,
-      selectionStart: ctx.selectionStart,
-      selectionEnd: ctx.selectionEnd
-    });
-    if (result.handled) {
-      ctx.applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-    }
-  }
-};
-var builtinCommands = [
-  bold,
-  italic,
-  link,
-  codeFence,
-  mathBlock,
-  sideAnnotation,
-  heading1,
-  heading2,
-  heading3,
-  blockquote,
-  unorderedList,
-  orderedList,
-  thematicBreak,
-  table,
-  image
-];
-
-// src/core/editor-core.ts
-var HISTORY_LIMIT = 100;
-var HISTORY_SNAPSHOT_DEBOUNCE_MS = 300;
-var TAB_INDENT_SPACES = 2;
-var TAB_INDENT = " ".repeat(TAB_INDENT_SPACES);
-function createOwoMarkCore(options) {
-  const genBlockId = createBlockIdGenerator();
-  const events = createCoreEventHub();
-  let doc = { blocks: [] };
-  let composition = { active: false, range: null };
-  let lastSelection = null;
-  let indentMode = options?.indentMode ?? "auto";
-  const featureFlags = {
-    enableSideAnnotation: options?.enableSideAnnotation !== false,
-    enableMath: options?.enableMath !== false
-  };
-  const undoStack = [];
-  const redoStack = [];
-  let lastHistoryMarkdown = "";
-  let documentChangeCallback = null;
-  const blockContextListeners = /* @__PURE__ */ new Set();
-  let lastBlockContext = null;
-  let historyTimer = null;
-  const commandRegistry = createCommandRegistry();
-  let slashMgr = null;
-  function getMarkdown() {
-    return serializeDocument(doc);
-  }
-  function getLinearSelection() {
-    return getLinearSelectionOrFallback(doc, lastSelection);
-  }
-  function buildSnapshot() {
-    return {
-      markdown: getMarkdown(),
-      document: doc,
-      selection: {
-        linear: lastSelection ? virtualToLinear(doc, lastSelection) : null,
-        virtual: lastSelection
-      },
-      composition
-    };
-  }
-  function computeBlockContext() {
-    const sel = getLinearSelection();
-    const pos = Math.min(sel.anchor, sel.focus);
-    const markdown = getMarkdown();
-    if (doc.blocks.length === 0 || doc.blocks.length === 1 && doc.blocks[0].raw === "") {
-      return {
-        type: "empty",
-        depth: 0,
-        blockIndex: 0,
-        blockId: doc.blocks[0]?.id ?? ""
-      };
-    }
-    const { blockIndex } = getBlockAtOffset(doc, Math.min(pos, Math.max(0, markdown.length - 1)));
-    const block = doc.blocks[blockIndex];
-    if (!block) {
-      return { type: "empty", depth: 0, blockIndex: 0, blockId: "" };
-    }
-    const contextType = resolveBlockContextType(block);
-    const result = {
-      type: contextType,
-      depth: block.depth,
-      blockIndex,
-      blockId: block.id
-    };
-    if (block.type === "heading") {
-      result.headingLevel = block.headingLevel;
-    }
-    if (block.type === "code-fence") {
-      result.language = block.language;
-    }
-    return result;
-  }
-  function emitBlockContextChange() {
-    const ctx = computeBlockContext();
-    if (lastBlockContext && lastBlockContext.type === ctx.type && lastBlockContext.blockIndex === ctx.blockIndex && lastBlockContext.blockId === ctx.blockId && lastBlockContext.depth === ctx.depth) {
-      return;
-    }
-    lastBlockContext = ctx;
-    for (const listener of blockContextListeners) listener(ctx);
-  }
-  function resetExternalDocumentState(markdown) {
-    undoStack.length = 0;
-    redoStack.length = 0;
-    if (historyTimer) {
-      clearTimeout(historyTimer);
-      historyTimer = null;
-    }
-    composition = { active: false, range: null };
-    lastSelection = null;
-    lastHistoryMarkdown = markdown;
-  }
-  function syncEmptyAttrOnDoc() {
-    return doc.blocks.length === 0 || doc.blocks.length === 1 && doc.blocks[0].raw === "";
-  }
-  function setMarkdown(markdown) {
-    doc = parseMarkdownToDocument(markdown, genBlockId);
-    resetExternalDocumentState(markdown);
-    const endOffset = Math.max(0, markdown.length);
-    const endLinear = { anchor: endOffset, focus: endOffset };
-    lastSelection = linearToVirtual(doc, endLinear);
-    documentChangeCallback?.(doc, lastSelection);
-    lastHistoryMarkdown = markdown;
-    events.emitChange(markdown);
-    events.emitStateChange(buildSnapshot());
-  }
-  function pushHistory() {
-    const md = getMarkdown();
-    if (md === lastHistoryMarkdown) return;
-    undoStack.push({ markdown: lastHistoryMarkdown, selection: getLinearSelection() });
-    if (undoStack.length > HISTORY_LIMIT) undoStack.shift();
-    redoStack.length = 0;
-    lastHistoryMarkdown = md;
-  }
-  function scheduleHistorySnapshot() {
-    if (historyTimer) clearTimeout(historyTimer);
-    historyTimer = setTimeout(pushHistory, HISTORY_SNAPSHOT_DEBOUNCE_MS);
-  }
-  function applyUpdate(newMarkdown, newSelection) {
-    const oldDoc = doc;
-    const newDoc = parseMarkdownToDocument(newMarkdown, genBlockId);
-    doc = { blocks: reconcileBlocks(oldDoc.blocks, newDoc.blocks) };
-    const vsel = linearToVirtual(doc, newSelection);
-    lastSelection = vsel;
-    documentChangeCallback?.(doc, vsel);
-    scheduleHistorySnapshot();
-    events.emitChange(newMarkdown);
-    events.emitStateChange(buildSnapshot());
-    emitBlockContextChange();
-  }
-  slashMgr = createSlashManager(commandRegistry, {
-    getMarkdown,
-    getDocument: () => doc,
-    getLinearSelection,
-    isComposing: () => composition.active,
-    applyUpdate: (newText, sel) => applyUpdate(newText, sel),
-    pushHistory,
-    featureFlags
-  });
-  slashMgr.onSlashStateChange((state) => {
-    events.emitSlashStateChange(state);
-  });
-  for (const cmd of builtinCommands) {
-    commandRegistry.register(cmd);
-  }
-  function replaceMarkdown(markdown, selection) {
-    pushHistory();
-    applyUpdate(markdown, selection);
-  }
-  function performUndo() {
-    pushHistory();
-    const entry = undoStack.pop();
-    if (!entry) return;
-    redoStack.push({ markdown: getMarkdown(), selection: getLinearSelection() });
-    doc = parseMarkdownToDocument(entry.markdown, genBlockId);
-    lastHistoryMarkdown = entry.markdown;
-    const vsel = linearToVirtual(doc, entry.selection);
-    lastSelection = vsel;
-    documentChangeCallback?.(doc, vsel);
-    events.emitChange(entry.markdown);
-    events.emitStateChange(buildSnapshot());
-  }
-  function performRedo() {
-    const entry = redoStack.pop();
-    if (!entry) return;
-    undoStack.push({ markdown: getMarkdown(), selection: getLinearSelection() });
-    doc = parseMarkdownToDocument(entry.markdown, genBlockId);
-    lastHistoryMarkdown = entry.markdown;
-    const vsel = linearToVirtual(doc, entry.selection);
-    lastSelection = vsel;
-    documentChangeCallback?.(doc, vsel);
-    events.emitChange(entry.markdown);
-    events.emitStateChange(buildSnapshot());
-  }
-  function dispatch(command, payload) {
-    if (command === "undo") {
-      performUndo();
-      return;
-    }
-    if (command === "redo") {
-      performRedo();
-      return;
-    }
-    const idMap = {
-      toggleBold: "bold",
-      toggleItalic: "italic",
-      insertLink: "link",
-      insertCodeFence: "code-fence",
-      insertMath: "math",
-      insertSideAnnotation: "side-annotation"
-    };
-    const id = idMap[command] ?? command;
-    slashMgr.executeById(id, payload);
-  }
-  function applyBeforeInput(intent, selection) {
-    if (composition.active) {
-      return { action: "allow-native", snapshot: buildSnapshot() };
-    }
-    const sel = selection ?? getLinearSelection();
-    const markdown = getMarkdown();
-    const pos = Math.min(sel.anchor, sel.focus);
-    const end = Math.max(sel.anchor, sel.focus);
-    const { inputType, data } = intent;
-    if (inputType === "insertParagraph") {
-      let text = markdown;
-      let cursor = pos;
-      if (pos !== end) {
-        text = text.slice(0, pos) + text.slice(end);
-      }
-      const result = handleMarkdownEnter({ text, selectionStart: cursor, selectionEnd: cursor, enableSideAnnotation: featureFlags.enableSideAnnotation });
-      if (result.handled) {
-        applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-      } else {
-        const newText = text.slice(0, cursor) + "\n" + text.slice(cursor);
-        const newCursor = cursor + 1;
-        applyUpdate(newText, { anchor: newCursor, focus: newCursor });
-      }
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if (inputType === "insertLineBreak") {
-      const newText = markdown.slice(0, pos) + "\n" + markdown.slice(end);
-      const newCursor = pos + 1;
-      applyUpdate(newText, { anchor: newCursor, focus: newCursor });
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if (inputType === "deleteContentBackward") {
-      if (slashMgr.getSlashState().active) {
-        slashMgr.handleBackspace(pos, markdown);
-        if (slashMgr.getSlashState().active) {
-          if (pos !== end) {
-            const newText = markdown.slice(0, pos) + markdown.slice(end);
-            applyUpdate(newText, { anchor: pos, focus: pos });
-            slashMgr.updateQuery(pos, newText);
-          } else if (pos > 0) {
-            const newText = markdown.slice(0, pos - 1) + markdown.slice(pos);
-            applyUpdate(newText, { anchor: pos - 1, focus: pos - 1 });
-            slashMgr.updateQuery(pos - 1, newText);
-          }
-          return { action: "handled", snapshot: buildSnapshot() };
-        }
-      }
-      if (pos !== end) {
-        const newText = markdown.slice(0, pos) + markdown.slice(end);
-        applyUpdate(newText, { anchor: pos, focus: pos });
-        return { action: "handled", snapshot: buildSnapshot() };
-      }
-      const result = handleSmartBackspace({ text: markdown, selectionStart: pos, selectionEnd: pos });
-      if (result.handled) {
-        applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-        return { action: "handled", snapshot: buildSnapshot() };
-      }
-      if (pos > 0) {
-        const newText = markdown.slice(0, pos - 1) + markdown.slice(pos);
-        applyUpdate(newText, { anchor: pos - 1, focus: pos - 1 });
-      }
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if (inputType === "deleteContentForward") {
-      if (pos !== end) {
-        const newText = markdown.slice(0, pos) + markdown.slice(end);
-        applyUpdate(newText, { anchor: pos, focus: pos });
-        return { action: "handled", snapshot: buildSnapshot() };
-      }
-      const delResult = handleSmartDelete({ text: markdown, selectionStart: pos, selectionEnd: pos });
-      if (delResult.handled) {
-        applyUpdate(delResult.value, { anchor: delResult.selectionStart, focus: delResult.selectionEnd });
-        return { action: "handled", snapshot: buildSnapshot() };
-      }
-      if (pos < markdown.length) {
-        const newText = markdown.slice(0, pos) + markdown.slice(pos + 1);
-        applyUpdate(newText, { anchor: pos, focus: pos });
-      }
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if (inputType === "deleteWordBackward") {
-      if (pos !== end) {
-        const newText = markdown.slice(0, pos) + markdown.slice(end);
-        applyUpdate(newText, { anchor: pos, focus: pos });
-      } else {
-        const { newText, newPos } = deleteWordBackward(markdown, pos);
-        applyUpdate(newText, { anchor: newPos, focus: newPos });
-      }
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if (inputType === "deleteWordForward") {
-      if (pos !== end) {
-        const newText = markdown.slice(0, pos) + markdown.slice(end);
-        applyUpdate(newText, { anchor: pos, focus: pos });
-      } else {
-        const { newText, newPos } = deleteWordForward(markdown, pos);
-        applyUpdate(newText, { anchor: newPos, focus: newPos });
-      }
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if (inputType === "deleteSoftLineBackward" || inputType === "deleteHardLineBackward") {
-      if (pos !== end) {
-        const newText = markdown.slice(0, pos) + markdown.slice(end);
-        applyUpdate(newText, { anchor: pos, focus: pos });
-      } else {
-        const { newText, newPos } = deleteToLineStart(markdown, pos);
-        applyUpdate(newText, { anchor: newPos, focus: newPos });
-      }
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if (inputType === "deleteSoftLineForward" || inputType === "deleteHardLineForward") {
-      if (pos !== end) {
-        const newText = markdown.slice(0, pos) + markdown.slice(end);
-        applyUpdate(newText, { anchor: pos, focus: pos });
-      } else {
-        const { newText, newPos } = deleteToLineEnd(markdown, pos);
-        applyUpdate(newText, { anchor: newPos, focus: newPos });
-      }
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if (inputType === "insertText" && data) {
-      if (data.length === 1) {
-        const result = handleCharInput({
-          key: data,
-          text: markdown,
-          selectionStart: pos,
-          selectionEnd: end,
-          isComposing: false
-        });
-        if (result.handled) {
-          applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-          if (data === "/") {
-            slashMgr.tryActivate(pos, result.value, doc);
-          } else if (slashMgr.getSlashState().active) {
-            slashMgr.updateQuery(result.selectionStart, result.value);
-          }
-          return { action: "handled", snapshot: buildSnapshot() };
-        }
-      }
-      if (data === "/" && slashMgr.tryActivate(pos, markdown, doc)) {
-        const newText2 = markdown.slice(0, pos) + "/" + markdown.slice(end);
-        const newCursor2 = pos + 1;
-        applyUpdate(newText2, { anchor: newCursor2, focus: newCursor2 });
-        return { action: "handled", snapshot: buildSnapshot() };
-      }
-      if (slashMgr.getSlashState().active) {
-        const newText2 = markdown.slice(0, pos) + data + markdown.slice(end);
-        const newCursor2 = pos + data.length;
-        applyUpdate(newText2, { anchor: newCursor2, focus: newCursor2 });
-        slashMgr.updateQuery(newCursor2, newText2);
-        return { action: "handled", snapshot: buildSnapshot() };
-      }
-      const newText = markdown.slice(0, pos) + data + markdown.slice(end);
-      const newCursor = pos + data.length;
-      applyUpdate(newText, { anchor: newCursor, focus: newCursor });
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if (inputType === "insertFromPaste") {
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if (inputType === "historyUndo") {
-      performUndo();
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if (inputType === "historyRedo") {
-      performRedo();
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if (inputType === "formatBold") {
-      dispatch("toggleBold");
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if (inputType === "formatItalic") {
-      dispatch("toggleItalic");
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    return { action: "allow-native", snapshot: buildSnapshot() };
-  }
-  function applyKeyDown(intent, selection) {
-    if (composition.active) {
-      return { action: "allow-native", snapshot: buildSnapshot() };
-    }
-    if (slashMgr.getSlashState().active) {
-      const consumed = slashMgr.handleKeyDown(
-        intent.key,
-        intent.shiftKey,
-        intent.ctrlKey,
-        intent.metaKey,
-        intent.altKey
-      );
-      if (consumed) {
-        return { action: "handled", snapshot: buildSnapshot() };
-      }
-    }
-    const sel = selection ?? getLinearSelection();
-    const markdown = getMarkdown();
-    const pos = Math.min(sel.anchor, sel.focus);
-    const end = Math.max(sel.anchor, sel.focus);
-    const { key, ctrlKey, metaKey, altKey, shiftKey } = intent;
-    if (key === "Tab") {
-      const result = applyMarkdownIndent({
-        text: markdown,
-        selectionStart: pos,
-        selectionEnd: end,
-        shiftKey,
-        mode: indentMode
-      });
-      if (result.handled) {
-        applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-        return { action: "handled", snapshot: buildSnapshot() };
-      }
-      if (shiftKey) {
-        const lineStart = markdown.lastIndexOf("\n", pos - 1) + 1;
-        const textFromLineStart = markdown.slice(lineStart);
-        const leadingSpaces = textFromLineStart.match(/^ */)?.[0].length ?? 0;
-        const removable = Math.min(TAB_INDENT_SPACES, leadingSpaces);
-        if (removable > 0) {
-          const newText = markdown.slice(0, lineStart) + textFromLineStart.slice(removable);
-          const cursorShift = Math.min(removable, pos - lineStart);
-          const newPos = pos - cursorShift;
-          applyUpdate(newText, { anchor: newPos, focus: newPos });
-        }
-      } else {
-        const newText = markdown.slice(0, pos) + TAB_INDENT + markdown.slice(end);
-        const newPos = pos + TAB_INDENT.length;
-        applyUpdate(newText, { anchor: newPos, focus: newPos });
-      }
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if ((ctrlKey || metaKey) && key === "b") {
-      const result = toggleBold({ text: markdown, selectionStart: pos, selectionEnd: end });
-      if (result.handled) {
-        applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-      }
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if ((ctrlKey || metaKey) && key === "i") {
-      const result = toggleItalic({ text: markdown, selectionStart: pos, selectionEnd: end });
-      if (result.handled) {
-        applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-      }
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if ((ctrlKey || metaKey) && key === "k") {
-      const result = insertLink({ text: markdown, selectionStart: pos, selectionEnd: end });
-      if (result.handled) {
-        applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-      }
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if ((ctrlKey || metaKey) && key === "z" && !shiftKey) {
-      performUndo();
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if ((ctrlKey || metaKey) && (key === "z" && shiftKey || key === "y")) {
-      performRedo();
-      return { action: "handled", snapshot: buildSnapshot() };
-    }
-    if (key.length === 1 && !ctrlKey && !metaKey && !altKey) {
-      const result = handleCharInput({
-        key,
-        text: markdown,
-        selectionStart: pos,
-        selectionEnd: end,
-        isComposing: false
-      });
-      if (result.handled) {
-        applyUpdate(result.value, { anchor: result.selectionStart, focus: result.selectionEnd });
-        return { action: "handled", snapshot: buildSnapshot() };
-      }
-    }
-    return { action: "allow-native", snapshot: buildSnapshot() };
-  }
-  function applyPasteIntent(intent, selection) {
-    const cleaned = normalizeMarkdownPaste(intent.text);
-    const markdown = getMarkdown();
-    const sel = selection ?? getLinearSelection();
-    const pos = Math.min(sel.anchor, sel.focus);
-    const end = Math.max(sel.anchor, sel.focus);
-    const blockquotePrefix = getBlockquotePrefixAtPos(markdown, pos);
-    const toInsert = applyBlockquotePrefix(cleaned, blockquotePrefix);
-    const newText = markdown.slice(0, pos) + toInsert + markdown.slice(end);
-    const newCursor = pos + toInsert.length;
-    pushHistory();
-    applyUpdate(newText, { anchor: newCursor, focus: newCursor });
-    return { action: "handled", snapshot: buildSnapshot() };
-  }
-  function handleCompositionStart(selection) {
-    const vsel = selection ? toVirtualSelectionOrNull(doc, selection) : lastSelection;
-    pushHistory();
-    composition = { active: true, range: vsel };
-    events.emitCompositionChange(true);
-  }
-  function handleCompositionUpdate() {
-    composition = { ...composition, active: true };
-  }
-  function handleCompositionEnd(_selection, _fallbackText) {
-    composition = { active: false, range: null };
-    events.emitCompositionChange(false);
-    return { action: "composition-sync", snapshot: buildSnapshot() };
-  }
-  function syncText(text, selection) {
-    const oldMarkdown = getMarkdown();
-    if (text === oldMarkdown) return;
-    const oldDoc = doc;
-    const newDoc = parseMarkdownToDocument(text, genBlockId);
-    doc = { blocks: reconcileBlocks(oldDoc.blocks, newDoc.blocks) };
-    const linearSel = selection ?? getLinearSelection();
-    const vsel = linearToVirtual(doc, linearSel);
-    lastSelection = vsel;
-    documentChangeCallback?.(doc, vsel);
-    scheduleHistorySnapshot();
-    events.emitChange(text);
-    events.emitStateChange(buildSnapshot());
-  }
-  function updateSelection(selection) {
-    lastSelection = linearToVirtual(doc, selection);
-    events.emitSelectionChange(selection);
-    emitBlockContextChange();
-  }
-  if (options?.initialMarkdown) {
-    doc = parseMarkdownToDocument(options.initialMarkdown, genBlockId);
-    const endOffset = Math.max(0, options.initialMarkdown.length);
-    const endLinear = { anchor: endOffset, focus: endOffset };
-    lastSelection = linearToVirtual(doc, endLinear);
-    lastHistoryMarkdown = options.initialMarkdown;
-  }
-  return {
-    getSnapshot: buildSnapshot,
-    getMarkdown,
-    getSelection: () => lastSelection ? virtualToLinear(doc, lastSelection) : null,
-    getDocument: () => doc,
-    getVirtualSelection: () => lastSelection,
-    getComposition: () => composition,
-    setMarkdown,
-    replaceMarkdown,
-    dispatch,
-    setIndentMode(mode) {
-      indentMode = mode;
-    },
-    setEnableSideAnnotation(enabled) {
-      featureFlags.enableSideAnnotation = enabled;
-    },
-    setEnableMath(enabled) {
-      featureFlags.enableMath = enabled;
-      if (slashMgr.getSlashState().active) {
-        const selection = getLinearSelection();
-        slashMgr.updateQuery(Math.max(selection.anchor, selection.focus), getMarkdown());
-      }
-    },
-    syncText,
-    applyBeforeInput,
-    applyKeyDown,
-    applyPaste: applyPasteIntent,
-    handleCompositionStart,
-    handleCompositionUpdate,
-    handleCompositionEnd,
-    updateSelection,
-    // Block context
-    getBlockContext: computeBlockContext,
-    insertBlock(type, options2) {
-      const commandMap = {
-        "code-fence": "code-fence",
-        "blockquote": "blockquote",
-        "math": "math",
-        "table": "insert-table",
-        "image": "insert-image",
-        "thematic-break": "thematic-break"
-      };
-      dispatch(commandMap[type], options2?.language);
-    },
-    // Slash command system
-    getCommandRegistry: () => commandRegistry,
-    getSlashState: () => slashMgr.getSlashState(),
-    registerCommand: (def) => commandRegistry.register(def),
-    executeSlashCommand: (index) => slashMgr.executeByIndex(index),
-    dismissSlashMenu: () => slashMgr.dismiss(),
-    onChange: events.onChange,
-    onSelectionChange: events.onSelectionChange,
-    onCompositionStateChange: events.onCompositionStateChange,
-    onStateChange: events.onStateChange,
-    onSlashStateChange: (callback) => slashMgr.onSlashStateChange(callback),
-    onBlockContextChange(callback) {
-      blockContextListeners.add(callback);
-      return () => blockContextListeners.delete(callback);
-    },
-    onDocumentChange(callback) {
-      documentChangeCallback = callback;
-      return () => {
-        if (documentChangeCallback === callback) {
-          documentChangeCallback = null;
-        }
-      };
-    },
-    destroy() {
-      if (historyTimer) {
-        clearTimeout(historyTimer);
-        historyTimer = null;
-      }
-    }
-  };
-}
-
-// src/model/selection.ts
-function domRangeToOffset(root, range) {
-  const anchor = nodeOffsetToLinear(root, range.startContainer, range.startOffset);
-  const focus = nodeOffsetToLinear(root, range.endContainer, range.endOffset);
-  if (anchor === null || focus === null) return null;
-  return { anchor, focus };
-}
-function offsetToDomRange(root, selection) {
-  const doc = root.ownerDocument;
-  const range = doc.createRange();
-  const textLen = getModelTextLength(root);
-  const clampedAnchor = Math.max(0, Math.min(selection.anchor, textLen));
-  const clampedFocus = Math.max(0, Math.min(selection.focus, textLen));
-  const start = linearToNodeOffset(root, Math.min(clampedAnchor, clampedFocus));
-  const end = linearToNodeOffset(root, Math.max(clampedAnchor, clampedFocus));
-  if (!start || !end) return null;
-  range.setStart(start.node, start.offset);
-  range.setEnd(end.node, end.offset);
-  return range;
-}
-function restoreSelection(root, selection) {
-  const textLen = getModelTextLength(root);
-  const clamped = {
-    anchor: Math.max(0, Math.min(selection.anchor, textLen)),
-    focus: Math.max(0, Math.min(selection.focus, textLen))
-  };
-  const range = offsetToDomRange(root, clamped);
-  if (!range) return;
-  const sel = root.ownerDocument.getSelection();
-  if (!sel) return;
-  sel.removeAllRanges();
-  if (clamped.anchor <= clamped.focus) {
-    sel.addRange(range);
-  } else {
-    sel.addRange(range);
-    sel.collapseToEnd();
-    const focusPos = linearToNodeOffset(root, clamped.focus);
-    if (focusPos) {
-      sel.extend(focusPos.node, focusPos.offset);
-    }
-  }
-}
-function readSelection(root) {
-  const sel = root.ownerDocument.getSelection();
-  if (!sel || sel.rangeCount === 0) return null;
-  if (!root.contains(sel.anchorNode)) return null;
-  const anchor = nodeOffsetToLinear(root, sel.anchorNode, sel.anchorOffset);
-  const focus = nodeOffsetToLinear(root, sel.focusNode, sel.focusOffset);
-  if (anchor === null || focus === null) return null;
-  return { anchor, focus };
-}
-var blockCacheMap = /* @__PURE__ */ new WeakMap();
-function getBlocks(root) {
-  let cached = blockCacheMap.get(root);
-  if (cached) return cached;
-  cached = Array.from(root.querySelectorAll("[data-owo-block]"));
-  blockCacheMap.set(root, cached);
-  return cached;
-}
-function invalidateBlockCache(root) {
-  blockCacheMap.delete(root);
-}
-function getOwnerBlock(root, node) {
-  if (node === root) return null;
-  if (node.nodeType === Node.ELEMENT_NODE) {
-    const el = node;
-    if (el.hasAttribute("data-owo-block")) return el;
-    return el.closest?.("[data-owo-block]");
-  }
-  return node.parentElement?.closest("[data-owo-block]") ?? null;
-}
-function getModelTextLength(root) {
-  const blocks = getBlocks(root);
-  if (blocks.length === 0) return 0;
-  let len = 0;
-  for (let i = 0; i < blocks.length; i++) {
-    if (i > 0) len += 1;
-    len += blocks[i].textContent?.length ?? 0;
-  }
-  return len;
-}
-function nodeOffsetToLinear(root, node, offset) {
-  if (!root.contains(node)) return null;
-  if (node === root) {
-    const targetChild2 = root.childNodes[offset];
-    if (targetChild2) {
-      return countTextBefore(root, targetChild2);
-    }
-    return getModelTextLength(root);
-  }
-  if (node.nodeType === Node.TEXT_NODE) {
-    return countTextBefore(root, node) + offset;
-  }
-  const el = node;
-  const targetChild = el.childNodes[offset];
-  if (targetChild) {
-    return countTextBefore(root, targetChild);
-  }
-  const block = getOwnerBlock(root, node);
-  if (block) {
-    return countBlockStartOffset(root, block) + (node === block ? block.textContent?.length ?? 0 : countTextWithinBlockBefore(block, node) + (node.textContent?.length ?? 0));
-  }
-  return getModelTextLength(root);
-}
-function countTextBefore(root, target) {
-  const blocks = getBlocks(root);
-  const targetBlock = getOwnerBlock(root, target);
-  let count = 0;
-  for (let i = 0; i < blocks.length; i++) {
-    const block = blocks[i];
-    if (i > 0) count += 1;
-    if (block === targetBlock) {
-      count += countTextWithinBlockBefore(block, target);
-      return count;
-    }
-    const pos = block.compareDocumentPosition(target);
-    if ((pos & Node.DOCUMENT_POSITION_FOLLOWING) !== 0) {
-      count += block.textContent?.length ?? 0;
-    } else {
-      return count;
-    }
-  }
-  return count;
-}
-function countBlockStartOffset(root, targetBlock) {
-  const blocks = getBlocks(root);
-  let offset = 0;
-  for (const block of blocks) {
-    if (block === targetBlock) return offset;
-    offset += (block.textContent?.length ?? 0) + 1;
-  }
-  return offset;
-}
-function countTextWithinBlockBefore(block, target) {
-  const walker = block.ownerDocument.createTreeWalker(block, NodeFilter.SHOW_TEXT);
-  let count = 0;
-  while (walker.nextNode()) {
-    const textNode = walker.currentNode;
-    if (textNode === target) break;
-    const pos = textNode.compareDocumentPosition(target);
-    const isBeforeTarget = (pos & Node.DOCUMENT_POSITION_FOLLOWING) !== 0;
-    const isInsideTarget = (pos & Node.DOCUMENT_POSITION_CONTAINED_BY) !== 0;
-    if (isBeforeTarget && !isInsideTarget) {
-      count += textNode.textContent?.length ?? 0;
-    } else {
-      break;
-    }
-  }
-  return count;
-}
-function linearToNodeOffset(root, offset) {
-  const blocks = getBlocks(root);
-  if (blocks.length === 0) {
-    return { node: root, offset: 0 };
-  }
-  let pos = 0;
-  for (let i = 0; i < blocks.length; i++) {
-    const block = blocks[i];
-    if (i > 0) {
-      if (pos === offset) {
-        return firstPositionInBlock(block);
-      }
-      pos += 1;
-    }
-    const blockTextLen = block.textContent?.length ?? 0;
-    if (pos + blockTextLen >= offset) {
-      const inBlockOffset = offset - pos;
-      if (inBlockOffset === 0) {
-        return firstPositionInBlock(block);
-      }
-      const walker = block.ownerDocument.createTreeWalker(block, NodeFilter.SHOW_TEXT);
-      let blockPos = 0;
-      while (walker.nextNode()) {
-        const textNode = walker.currentNode;
-        const len = textNode.textContent?.length ?? 0;
-        if (blockPos + len >= inBlockOffset) {
-          return { node: textNode, offset: inBlockOffset - blockPos };
-        }
-        blockPos += len;
-      }
-      return lastPositionInBlock(block);
-    }
-    pos += blockTextLen;
-  }
-  return lastPositionInBlock(blocks[blocks.length - 1]);
-}
-function firstPositionInBlock(block) {
-  const walker = block.ownerDocument.createTreeWalker(block, NodeFilter.SHOW_TEXT);
-  if (walker.nextNode()) {
-    return { node: walker.currentNode, offset: 0 };
-  }
-  return { node: block, offset: 0 };
-}
-function lastPositionInBlock(block) {
-  const walker = block.ownerDocument.createTreeWalker(block, NodeFilter.SHOW_TEXT);
-  let lastText = null;
-  while (walker.nextNode()) lastText = walker.currentNode;
-  if (lastText) {
-    return { node: lastText, offset: lastText.textContent?.length ?? 0 };
-  }
-  return { node: block, offset: block.childNodes.length };
-}
-
-// src/model/dirty-range.ts
-function expandDirtyRange(current, blockIndex, totalBlocks) {
-  if (totalBlocks <= 0) return current;
-  const clamped = Math.max(0, Math.min(blockIndex, totalBlocks - 1));
-  if (!current) {
-    return { startBlock: clamped, endBlock: clamped };
-  }
-  return {
-    startBlock: Math.min(current.startBlock, clamped),
-    endBlock: Math.max(current.endBlock, clamped)
-  };
-}
-function expandWithContext(range, totalBlocks, context = 1) {
-  if (totalBlocks <= 0) return null;
-  return {
-    startBlock: Math.max(0, range.startBlock - context),
-    endBlock: Math.min(totalBlocks - 1, range.endBlock + context)
-  };
-}
-
-// src/render/blockquote-bars.ts
-var BQ_BAR_WIDTH = 3;
-var BQ_GAP = 12;
-var BQ_STEP = BQ_BAR_WIDTH + BQ_GAP;
-function buildBlockquoteBarsBoxShadow(depth) {
-  if (depth <= 1) return null;
-  const shadows = [];
-  for (let i = depth - 1; i >= 1; i--) {
-    const barEnd = i * BQ_STEP;
-    shadows.push(`inset ${barEnd}px 0 0 0 var(--owo-editor-bg, #ffffff)`);
-    shadows.push(`inset ${barEnd + BQ_BAR_WIDTH}px 0 0 0 var(--owo-editor-border-strong, #cbd5e1)`);
-  }
-  return shadows.join(", ");
-}
-
-// src/render/block-render.ts
-function applyBlockquoteBarsStyle(el, depth) {
-  const shadow = buildBlockquoteBarsBoxShadow(depth);
-  if (!shadow) return;
-  el.style.paddingLeft = `${depth * BQ_STEP}px`;
-  el.style.boxShadow = shadow;
-}
-var TOKEN_TO_CLASS = {
-  "text": "",
-  "strong-marker": "owo-syntax-marker",
-  "strong": "owo-syntax-strong",
-  "emphasis-marker": "owo-syntax-marker",
-  "emphasis": "owo-syntax-emphasis",
-  "code-marker": "owo-syntax-marker",
-  "code": "owo-syntax-inline-code",
-  "link-bracket": "owo-syntax-marker",
-  "link-text": "owo-syntax-link-text",
-  "link-url": "owo-syntax-link-url",
-  "image-marker": "owo-syntax-marker",
-  "image-alt": "owo-syntax-link-text",
-  "image-url": "owo-syntax-link-url",
-  "heading-marker": "owo-syntax-heading-marker",
-  "list-marker": "owo-syntax-list-marker",
-  "blockquote-marker": "owo-syntax-blockquote-marker",
-  "fence-marker": "owo-syntax-fence",
-  "fence-lang": "owo-syntax-fence-lang",
-  "code-block-text": "owo-syntax-code-block",
-  "strikethrough-marker": "owo-syntax-marker",
-  "strikethrough": "owo-syntax-strikethrough",
-  "math-marker": "owo-syntax-marker",
-  "math-text": "owo-syntax-math",
-  "hr": "owo-syntax-hr",
-  "html": "owo-syntax-html"
-};
-var BLOCK_TYPE_TO_CLASS = {
-  "heading": "owo-block-heading",
-  "paragraph": "owo-block-paragraph",
-  "unordered-list": "owo-block-list",
-  "ordered-list": "owo-block-list",
-  "blockquote": "owo-block-blockquote",
-  "code-fence": "owo-block-code-fence",
-  "directive-container": "owo-block-directive-container",
-  "thematic-break": "owo-block-hr",
-  "math-block": "owo-block-math",
-  "table": "owo-block-table"
-};
-function createBlockElement(doc, tokens, blockIndex, blockType, headingLevel, depth) {
-  const div = doc.createElement("div");
-  div.setAttribute("data-owo-block", String(blockIndex));
-  div.className = BLOCK_TYPE_TO_CLASS[blockType] || "owo-block-paragraph";
-  if (blockType === "heading" && headingLevel) {
-    div.setAttribute("data-owo-heading", String(headingLevel));
-  }
-  if (blockType === "blockquote" && depth && depth > 0) {
-    div.setAttribute("data-owo-depth", String(depth));
-    applyBlockquoteBarsStyle(div, depth);
-  }
-  renderTokensInto(doc, div, tokens);
-  return div;
-}
-function renderTokensInto(doc, container, tokens) {
-  for (const token of tokens) {
-    const cls = TOKEN_TO_CLASS[token.type];
-    const parts = token.text.split("\n");
-    for (let i = 0; i < parts.length; i++) {
-      if (i > 0) {
-        container.appendChild(doc.createTextNode("\n"));
-      }
-      const part = parts[i];
-      if (!part && i < parts.length - 1) continue;
-      const leaf = doc.createElement("span");
-      leaf.setAttribute("data-owo-leaf", "true");
-      leaf.textContent = part;
-      if (cls) {
-        const decorator = doc.createElement("span");
-        decorator.className = cls;
-        decorator.setAttribute("data-owo-token", token.type);
-        decorator.appendChild(leaf);
-        container.appendChild(decorator);
-      } else {
-        if (part) {
-          container.appendChild(leaf);
-        }
-      }
-    }
-  }
-  if (container.childNodes.length === 0) {
-    container.appendChild(doc.createElement("br"));
-  }
-}
-function updateBlockElement(doc, existing, tokens, blockType, headingLevel, depth) {
-  const newClass = BLOCK_TYPE_TO_CLASS[blockType] || "owo-block-paragraph";
-  if (existing.className !== newClass) {
-    existing.className = newClass;
-  }
-  if (blockType === "heading" && headingLevel) {
-    existing.setAttribute("data-owo-heading", String(headingLevel));
-  } else {
-    existing.removeAttribute("data-owo-heading");
-  }
-  if (blockType === "blockquote" && depth && depth > 0) {
-    existing.setAttribute("data-owo-depth", String(depth));
-    applyBlockquoteBarsStyle(existing, depth);
-  } else {
-    existing.removeAttribute("data-owo-depth");
-    existing.style.paddingLeft = "";
-    existing.style.boxShadow = "";
-  }
-  existing.textContent = "";
-  renderTokensInto(doc, existing, tokens);
-  return true;
-}
-
-// src/render/dom-patch.ts
-function fullRender(root, doc) {
-  const ownerDoc = root.ownerDocument;
-  root.textContent = "";
-  let offset = 0;
-  for (let i = 0; i < doc.blocks.length; i++) {
-    const block = doc.blocks[i];
-    const tokens = tokenizeBlock(block.raw, block.type, offset);
-    const el = createBlockElement(ownerDoc, tokens, i, block.type, block.type === "heading" ? block.headingLevel : void 0, block.depth);
-    root.appendChild(el);
-    offset += block.raw.length + 1;
-  }
-  invalidateBlockCache(root);
-}
-function patchDirtyBlocks(root, doc, dirty) {
-  const ownerDoc = root.ownerDocument;
-  const blockElements = getBlockElements(root);
-  if (blockElements.length !== doc.blocks.length) {
-    fullRender(root, doc);
-    return;
-  }
-  for (let i = dirty.startBlock; i <= dirty.endBlock && i < doc.blocks.length; i++) {
-    const block = doc.blocks[i];
-    const offset = getBlockStartOffset(doc, i);
-    const tokens = tokenizeBlock(block.raw, block.type, offset);
-    const existing = blockElements[i];
-    if (existing) {
-      updateBlockElement(ownerDoc, existing, tokens, block.type, block.type === "heading" ? block.headingLevel : void 0, block.depth);
-    }
-  }
-}
-function detectAndRenderDirty(root, oldDoc, newDoc, fullFallback = false) {
-  const oldBlockCount = oldDoc.blocks.length;
-  const newBlockCount = newDoc.blocks.length;
-  if (oldBlockCount !== newBlockCount) {
-    fullRender(root, newDoc);
-    return;
-  }
-  let dirty = null;
-  for (let i = 0; i < newBlockCount; i++) {
-    if (newDoc.blocks[i].raw !== oldDoc.blocks[i].raw || newDoc.blocks[i].type !== oldDoc.blocks[i].type) {
-      dirty = expandDirtyRange(dirty, i, newBlockCount);
-    }
-  }
-  if (dirty) {
-    const expanded = expandWithContext(dirty, newBlockCount);
-    if (expanded) patchDirtyBlocks(root, newDoc, expanded);
-  } else if (fullFallback) {
-    fullRender(root, newDoc);
-  }
-}
-function getBlockElements(root) {
-  const elements = [];
-  for (const child of root.children) {
-    if (child instanceof HTMLElement && child.hasAttribute("data-owo-block")) {
-      elements.push(child);
-    }
-  }
-  return elements;
-}
-
-export {
-  tokenizeInline,
-  tokenizeBlock,
-  createBlockIdGenerator,
-  resetBlockIdCounter,
-  parseMarkdownToDocument,
-  reconcileBlocks,
-  serializeDocument,
-  getBlockById,
-  getBlockIndexById,
-  getBlockAtOffset,
-  getBlockStartOffset,
-  linearToVirtualPosition,
-  linearToVirtual,
-  virtualPositionToLinear,
-  virtualToLinear,
-  virtualPositionsEqual,
-  isVirtualSelectionCollapsed,
-  getBlockIndexForPosition,
-  SIDE_ANNOTATION_TAIL_RE,
-  SIDE_CONTINUATION_TAIL_RE,
-  NOT_HANDLED,
-  handleMarkdownEnter,
-  resolveIndentSize,
-  applyMarkdownIndent,
-  handleCharInput,
-  handleSmartDelete,
-  handleSmartBackspace,
-  toggleBold,
-  toggleItalic,
-  insertLink,
-  insertCodeFence,
-  insertMathBlock,
-  insertTable,
-  insertImage,
-  insertSideAnnotation,
-  createCommandRegistry,
-  resolveBlockContextType,
-  createOwoMarkCore,
-  domRangeToOffset,
-  offsetToDomRange,
-  restoreSelection,
-  readSelection,
-  invalidateBlockCache,
-  expandDirtyRange,
-  expandWithContext,
-  BQ_STEP,
-  buildBlockquoteBarsBoxShadow,
-  TOKEN_TO_CLASS,
-  BLOCK_TYPE_TO_CLASS,
-  createBlockElement,
-  updateBlockElement,
-  fullRender,
-  patchDirtyBlocks,
-  detectAndRenderDirty
-};