create-markdown 0.2.2 → 0.4.0

package/dist/react/index.js

@@ -1,1782 +0,0 @@
-// src/react/block-renderer.tsx
-import { jsxDEV, Fragment } from "react/jsx-dev-runtime";
-function BlockRenderer({
-  blocks,
-  className,
-  customRenderers
-}) {
-  return /* @__PURE__ */ jsxDEV("div", {
-    className,
-    children: blocks.map((block) => /* @__PURE__ */ jsxDEV(BlockElement, {
-      block,
-      customRenderers
-    }, block.id, false, undefined, this))
-  }, undefined, false, undefined, this);
-}
-function BlockElement({
-  block,
-  customRenderers
-}) {
-  const CustomRenderer = customRenderers?.[block.type];
-  if (CustomRenderer) {
-    return /* @__PURE__ */ jsxDEV(CustomRenderer, {
-      block
-    }, undefined, false, undefined, this);
-  }
-  switch (block.type) {
-    case "paragraph":
-      return /* @__PURE__ */ jsxDEV(ParagraphRenderer, {
-        block
-      }, undefined, false, undefined, this);
-    case "heading":
-      return /* @__PURE__ */ jsxDEV(HeadingRenderer, {
-        block
-      }, undefined, false, undefined, this);
-    case "bulletList":
-      return /* @__PURE__ */ jsxDEV(BulletListRenderer, {
-        block,
-        customRenderers
-      }, undefined, false, undefined, this);
-    case "numberedList":
-      return /* @__PURE__ */ jsxDEV(NumberedListRenderer, {
-        block,
-        customRenderers
-      }, undefined, false, undefined, this);
-    case "checkList":
-      return /* @__PURE__ */ jsxDEV(CheckListRenderer, {
-        block
-      }, undefined, false, undefined, this);
-    case "codeBlock":
-      return /* @__PURE__ */ jsxDEV(CodeBlockRenderer, {
-        block
-      }, undefined, false, undefined, this);
-    case "blockquote":
-      return /* @__PURE__ */ jsxDEV(BlockquoteRenderer, {
-        block
-      }, undefined, false, undefined, this);
-    case "table":
-      return /* @__PURE__ */ jsxDEV(TableRenderer, {
-        block
-      }, undefined, false, undefined, this);
-    case "image":
-      return /* @__PURE__ */ jsxDEV(ImageRenderer, {
-        block
-      }, undefined, false, undefined, this);
-    case "divider":
-      return /* @__PURE__ */ jsxDEV(DividerRenderer, {}, undefined, false, undefined, this);
-    case "callout":
-      return /* @__PURE__ */ jsxDEV(CalloutRenderer, {
-        block
-      }, undefined, false, undefined, this);
-    default:
-      return null;
-  }
-}
-function InlineContent({ spans }) {
-  return /* @__PURE__ */ jsxDEV(Fragment, {
-    children: spans.map((span, index) => /* @__PURE__ */ jsxDEV(SpanElement, {
-      span
-    }, index, false, undefined, this))
-  }, undefined, false, undefined, this);
-}
-function SpanElement({ span }) {
-  let content = span.text;
-  const styles = span.styles;
-  if (styles.code) {
-    content = /* @__PURE__ */ jsxDEV("code", {
-      children: content
-    }, undefined, false, undefined, this);
-  }
-  if (styles.highlight) {
-    content = /* @__PURE__ */ jsxDEV("mark", {
-      children: content
-    }, undefined, false, undefined, this);
-  }
-  if (styles.strikethrough) {
-    content = /* @__PURE__ */ jsxDEV("del", {
-      children: content
-    }, undefined, false, undefined, this);
-  }
-  if (styles.underline) {
-    content = /* @__PURE__ */ jsxDEV("u", {
-      children: content
-    }, undefined, false, undefined, this);
-  }
-  if (styles.italic) {
-    content = /* @__PURE__ */ jsxDEV("em", {
-      children: content
-    }, undefined, false, undefined, this);
-  }
-  if (styles.bold) {
-    content = /* @__PURE__ */ jsxDEV("strong", {
-      children: content
-    }, undefined, false, undefined, this);
-  }
-  if (styles.link) {
-    content = /* @__PURE__ */ jsxDEV("a", {
-      href: styles.link.url,
-      title: styles.link.title,
-      children: content
-    }, undefined, false, undefined, this);
-  }
-  return /* @__PURE__ */ jsxDEV(Fragment, {
-    children: content
-  }, undefined, false, undefined, this);
-}
-function ParagraphRenderer({ block }) {
-  return /* @__PURE__ */ jsxDEV("p", {
-    children: /* @__PURE__ */ jsxDEV(InlineContent, {
-      spans: block.content
-    }, undefined, false, undefined, this)
-  }, undefined, false, undefined, this);
-}
-function HeadingRenderer({ block }) {
-  const Tag = `h${block.props.level}`;
-  return /* @__PURE__ */ jsxDEV(Tag, {
-    children: /* @__PURE__ */ jsxDEV(InlineContent, {
-      spans: block.content
-    }, undefined, false, undefined, this)
-  }, undefined, false, undefined, this);
-}
-function BulletListRenderer({
-  block,
-  customRenderers
-}) {
-  return /* @__PURE__ */ jsxDEV("ul", {
-    children: block.children.map((child) => /* @__PURE__ */ jsxDEV("li", {
-      children: [
-        /* @__PURE__ */ jsxDEV(InlineContent, {
-          spans: child.content
-        }, undefined, false, undefined, this),
-        child.children.length > 0 && /* @__PURE__ */ jsxDEV(BlockElement, {
-          block: child,
-          customRenderers
-        }, undefined, false, undefined, this)
-      ]
-    }, child.id, true, undefined, this))
-  }, undefined, false, undefined, this);
-}
-function NumberedListRenderer({
-  block,
-  customRenderers
-}) {
-  return /* @__PURE__ */ jsxDEV("ol", {
-    children: block.children.map((child) => /* @__PURE__ */ jsxDEV("li", {
-      children: [
-        /* @__PURE__ */ jsxDEV(InlineContent, {
-          spans: child.content
-        }, undefined, false, undefined, this),
-        child.children.length > 0 && /* @__PURE__ */ jsxDEV(BlockElement, {
-          block: child,
-          customRenderers
-        }, undefined, false, undefined, this)
-      ]
-    }, child.id, true, undefined, this))
-  }, undefined, false, undefined, this);
-}
-function CheckListRenderer({ block }) {
-  return /* @__PURE__ */ jsxDEV("div", {
-    style: { display: "flex", alignItems: "flex-start", gap: "0.5rem" },
-    children: [
-      /* @__PURE__ */ jsxDEV("input", {
-        type: "checkbox",
-        checked: block.props.checked,
-        readOnly: true,
-        style: { marginTop: "0.25rem" }
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV("span", {
-        style: { textDecoration: block.props.checked ? "line-through" : "none" },
-        children: /* @__PURE__ */ jsxDEV(InlineContent, {
-          spans: block.content
-        }, undefined, false, undefined, this)
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-function CodeBlockRenderer({ block }) {
-  const code = block.content.map((span) => span.text).join("");
-  const language = block.props.language;
-  return /* @__PURE__ */ jsxDEV("pre", {
-    children: /* @__PURE__ */ jsxDEV("code", {
-      className: language ? `language-${language}` : undefined,
-      children: code
-    }, undefined, false, undefined, this)
-  }, undefined, false, undefined, this);
-}
-function BlockquoteRenderer({ block }) {
-  return /* @__PURE__ */ jsxDEV("blockquote", {
-    children: /* @__PURE__ */ jsxDEV(InlineContent, {
-      spans: block.content
-    }, undefined, false, undefined, this)
-  }, undefined, false, undefined, this);
-}
-function TableRenderer({ block }) {
-  const { headers, rows, alignments } = block.props;
-  const getAlignment = (index) => {
-    return alignments?.[index] ?? undefined;
-  };
-  return /* @__PURE__ */ jsxDEV("table", {
-    children: [
-      headers.length > 0 && /* @__PURE__ */ jsxDEV("thead", {
-        children: /* @__PURE__ */ jsxDEV("tr", {
-          children: headers.map((header, i) => /* @__PURE__ */ jsxDEV("th", {
-            style: { textAlign: getAlignment(i) },
-            children: header
-          }, i, false, undefined, this))
-        }, undefined, false, undefined, this)
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV("tbody", {
-        children: rows.map((row, rowIndex) => /* @__PURE__ */ jsxDEV("tr", {
-          children: row.map((cell, cellIndex) => /* @__PURE__ */ jsxDEV("td", {
-            style: { textAlign: getAlignment(cellIndex) },
-            children: cell
-          }, cellIndex, false, undefined, this))
-        }, rowIndex, false, undefined, this))
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-function ImageRenderer({ block }) {
-  return /* @__PURE__ */ jsxDEV("figure", {
-    children: [
-      /* @__PURE__ */ jsxDEV("img", {
-        src: block.props.url,
-        alt: block.props.alt ?? "",
-        title: block.props.title,
-        width: block.props.width,
-        height: block.props.height
-      }, undefined, false, undefined, this),
-      block.props.alt && /* @__PURE__ */ jsxDEV("figcaption", {
-        children: block.props.alt
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-function DividerRenderer() {
-  return /* @__PURE__ */ jsxDEV("hr", {}, undefined, false, undefined, this);
-}
-function CalloutRenderer({ block }) {
-  const calloutType = block.props.type;
-  const styles = {
-    padding: "1rem",
-    borderRadius: "0.25rem",
-    borderLeft: "4px solid",
-    marginBottom: "1rem"
-  };
-  const colors = {
-    info: { borderColor: "#3b82f6", backgroundColor: "#eff6ff" },
-    warning: { borderColor: "#f59e0b", backgroundColor: "#fffbeb" },
-    tip: { borderColor: "#10b981", backgroundColor: "#ecfdf5" },
-    danger: { borderColor: "#ef4444", backgroundColor: "#fef2f2" },
-    note: { borderColor: "#6b7280", backgroundColor: "#f9fafb" }
-  };
-  const colorStyle = colors[calloutType] ?? colors.note;
-  return /* @__PURE__ */ jsxDEV("div", {
-    style: {
-      ...styles,
-      borderLeftColor: colorStyle.borderColor,
-      backgroundColor: colorStyle.backgroundColor
-    },
-    role: "alert",
-    children: [
-      /* @__PURE__ */ jsxDEV("strong", {
-        style: { textTransform: "capitalize", display: "block", marginBottom: "0.5rem" },
-        children: calloutType
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(InlineContent, {
-        spans: block.content
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-// src/react/hooks.ts
-import { useState, useCallback, useMemo } from "react";
-
-// src/core/utils.ts
-var ID_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-var ID_LENGTH = 8;
-function generateId(length = ID_LENGTH) {
-  let id = "";
-  const charsLength = ID_CHARS.length;
-  for (let i = 0;i < length; i++) {
-    id += ID_CHARS.charAt(Math.floor(Math.random() * charsLength));
-  }
-  return id;
-}
-function deepClone(block, regenerateIds = true) {
-  return {
-    id: regenerateIds ? generateId() : block.id,
-    type: block.type,
-    content: block.content.map((span) => ({
-      text: span.text,
-      styles: { ...span.styles }
-    })),
-    children: block.children.map((child) => deepClone(child, regenerateIds)),
-    props: { ...block.props }
-  };
-}
-function deepCloneBlocks(blocks, regenerateIds = true) {
-  return blocks.map((block) => deepClone(block, regenerateIds));
-}
-function spansToPlainText(spans) {
-  return spans.map((span) => span.text).join("");
-}
-function plainSpan(text) {
-  return { text, styles: {} };
-}
-function plainContent(text) {
-  return [plainSpan(text)];
-}
-
-// src/core/document.ts
-var DOCUMENT_VERSION = 1;
-function createDocument(blocks = [], options = {}) {
-  const { meta = {} } = options;
-  return {
-    version: DOCUMENT_VERSION,
-    blocks: deepCloneBlocks(blocks, false),
-    meta: {
-      createdAt: new Date,
-      updatedAt: new Date,
-      ...meta
-    }
-  };
-}
-function insertBlock(doc, block, index) {
-  const newBlocks = [...doc.blocks];
-  const insertIndex = index ?? newBlocks.length;
-  newBlocks.splice(insertIndex, 0, deepClone(block, false));
-  return {
-    ...doc,
-    blocks: newBlocks,
-    meta: {
-      ...doc.meta,
-      updatedAt: new Date
-    }
-  };
-}
-function appendBlock(doc, block) {
-  return insertBlock(doc, block);
-}
-function removeBlock(doc, blockId) {
-  const newBlocks = doc.blocks.filter((block) => block.id !== blockId);
-  if (newBlocks.length === doc.blocks.length) {
-    return doc;
-  }
-  return {
-    ...doc,
-    blocks: newBlocks,
-    meta: {
-      ...doc.meta,
-      updatedAt: new Date
-    }
-  };
-}
-function updateBlock(doc, blockId, updates) {
-  const blockIndex = doc.blocks.findIndex((block) => block.id === blockId);
-  if (blockIndex === -1) {
-    return doc;
-  }
-  const newBlocks = [...doc.blocks];
-  const existingBlock = newBlocks[blockIndex];
-  newBlocks[blockIndex] = {
-    ...existingBlock,
-    ...updates,
-    id: existingBlock.id,
-    type: existingBlock.type,
-    content: updates.content ?? existingBlock.content,
-    children: updates.children ?? existingBlock.children,
-    props: updates.props ? { ...existingBlock.props, ...updates.props } : existingBlock.props
-  };
-  return {
-    ...doc,
-    blocks: newBlocks,
-    meta: {
-      ...doc.meta,
-      updatedAt: new Date
-    }
-  };
-}
-function moveBlock(doc, blockId, newIndex) {
-  const currentIndex = doc.blocks.findIndex((block) => block.id === blockId);
-  if (currentIndex === -1) {
-    return doc;
-  }
-  const targetIndex = Math.max(0, Math.min(newIndex, doc.blocks.length - 1));
-  if (currentIndex === targetIndex) {
-    return doc;
-  }
-  const newBlocks = [...doc.blocks];
-  const [movedBlock] = newBlocks.splice(currentIndex, 1);
-  newBlocks.splice(targetIndex, 0, movedBlock);
-  return {
-    ...doc,
-    blocks: newBlocks,
-    meta: {
-      ...doc.meta,
-      updatedAt: new Date
-    }
-  };
-}
-function findBlock(doc, blockId) {
-  return doc.blocks.find((block) => block.id === blockId);
-}
-function getBlockIndex(doc, blockId) {
-  return doc.blocks.findIndex((block) => block.id === blockId);
-}
-function updateMeta(doc, meta) {
-  return {
-    ...doc,
-    meta: {
-      ...doc.meta,
-      ...meta,
-      updatedAt: new Date
-    }
-  };
-}
-function clearBlocks(doc) {
-  return {
-    ...doc,
-    blocks: [],
-    meta: {
-      ...doc.meta,
-      updatedAt: new Date
-    }
-  };
-}
-function setBlocks(doc, blocks) {
-  return {
-    ...doc,
-    blocks: deepCloneBlocks(blocks, false),
-    meta: {
-      ...doc.meta,
-      updatedAt: new Date
-    }
-  };
-}
-
-// src/parsers/tokenizer.ts
-var PATTERNS = {
-  heading: /^(#{1,6})\s+(.*)$/,
-  setextH1: /^=+\s*$/,
-  setextH2: /^-+\s*$/,
-  bulletList: /^(\s*)([-*+])\s+(.*)$/,
-  numberedList: /^(\s*)(\d+)\.\s+(.*)$/,
-  checkList: /^(\s*)[-*+]\s+\[([ xX])\]\s+(.*)$/,
-  codeFence: /^(\s*)(`{3,}|~{3,})(\w*)?\s*$/,
-  blockquote: /^>\s?(.*)$/,
-  callout: /^>\s*\[!(\w+)\]\s*$/,
-  divider: /^(\s*)(-{3,}|\*{3,}|_{3,})\s*$/,
-  tableRow: /^\|(.+)\|$/,
-  tableSeparator: /^\|[\s\-:|]+\|$/,
-  image: /^!\[([^\]]*)\]\(([^)]+)\)$/,
-  blank: /^\s*$/
-};
-function tokenize(markdown) {
-  const lines = markdown.split(/\r?\n/);
-  const tokens = [];
-  const state = {
-    inCodeBlock: false,
-    codeBlockFence: "",
-    lineNumber: 0
-  };
-  for (let i = 0;i < lines.length; i++) {
-    state.lineNumber = i + 1;
-    const line = lines[i];
-    const token = tokenizeLine(line, state, lines, i);
-    if (token) {
-      tokens.push(token);
-    }
-  }
-  return tokens;
-}
-function tokenizeLine(line, state, allLines, lineIndex) {
-  const lineNumber = state.lineNumber;
-  if (state.inCodeBlock) {
-    const fenceMatch = line.match(PATTERNS.codeFence);
-    if (fenceMatch && line.trim().startsWith(state.codeBlockFence.charAt(0))) {
-      state.inCodeBlock = false;
-      state.codeBlockFence = "";
-      return {
-        type: "code_fence_end",
-        raw: line,
-        content: "",
-        indent: 0,
-        line: lineNumber
-      };
-    }
-    return {
-      type: "code_content",
-      raw: line,
-      content: line,
-      indent: 0,
-      line: lineNumber
-    };
-  }
-  const codeFenceMatch = line.match(PATTERNS.codeFence);
-  if (codeFenceMatch) {
-    state.inCodeBlock = true;
-    state.codeBlockFence = codeFenceMatch[2];
-    const language = codeFenceMatch[3] || "";
-    return {
-      type: "code_fence_start",
-      raw: line,
-      content: "",
-      indent: (codeFenceMatch[1] || "").length,
-      line: lineNumber,
-      meta: { language }
-    };
-  }
-  if (PATTERNS.blank.test(line)) {
-    return {
-      type: "blank",
-      raw: line,
-      content: "",
-      indent: 0,
-      line: lineNumber
-    };
-  }
-  const dividerMatch = line.match(PATTERNS.divider);
-  if (dividerMatch) {
-    const prevLine = lineIndex > 0 ? allLines[lineIndex - 1] : "";
-    if (prevLine.trim() && !PATTERNS.blank.test(prevLine)) {
-      if (PATTERNS.setextH2.test(line)) {}
-    } else {
-      return {
-        type: "divider",
-        raw: line,
-        content: "",
-        indent: (dividerMatch[1] || "").length,
-        line: lineNumber
-      };
-    }
-  }
-  const headingMatch = line.match(PATTERNS.heading);
-  if (headingMatch) {
-    return {
-      type: "heading",
-      raw: line,
-      content: headingMatch[2].trim(),
-      indent: 0,
-      line: lineNumber,
-      meta: { level: headingMatch[1].length }
-    };
-  }
-  const calloutMatch = line.match(PATTERNS.callout);
-  if (calloutMatch) {
-    return {
-      type: "callout",
-      raw: line,
-      content: "",
-      indent: 0,
-      line: lineNumber,
-      meta: { calloutType: calloutMatch[1].toLowerCase() }
-    };
-  }
-  const blockquoteMatch = line.match(PATTERNS.blockquote);
-  if (blockquoteMatch) {
-    return {
-      type: "blockquote",
-      raw: line,
-      content: blockquoteMatch[1],
-      indent: 0,
-      line: lineNumber
-    };
-  }
-  const checkListMatch = line.match(PATTERNS.checkList);
-  if (checkListMatch) {
-    const checked = checkListMatch[2].toLowerCase() === "x";
-    return {
-      type: "check_list_item",
-      raw: line,
-      content: checkListMatch[3],
-      indent: checkListMatch[1].length,
-      line: lineNumber,
-      meta: { checked }
-    };
-  }
-  const bulletMatch = line.match(PATTERNS.bulletList);
-  if (bulletMatch) {
-    return {
-      type: "bullet_list_item",
-      raw: line,
-      content: bulletMatch[3],
-      indent: bulletMatch[1].length,
-      line: lineNumber,
-      meta: { listMarker: bulletMatch[2] }
-    };
-  }
-  const numberedMatch = line.match(PATTERNS.numberedList);
-  if (numberedMatch) {
-    return {
-      type: "numbered_list_item",
-      raw: line,
-      content: numberedMatch[3],
-      indent: numberedMatch[1].length,
-      line: lineNumber,
-      meta: { listIndex: parseInt(numberedMatch[2], 10) }
-    };
-  }
-  if (PATTERNS.tableSeparator.test(line)) {
-    return {
-      type: "table_separator",
-      raw: line,
-      content: line,
-      indent: 0,
-      line: lineNumber
-    };
-  }
-  const tableRowMatch = line.match(PATTERNS.tableRow);
-  if (tableRowMatch) {
-    return {
-      type: "table_row",
-      raw: line,
-      content: tableRowMatch[1],
-      indent: 0,
-      line: lineNumber
-    };
-  }
-  const imageMatch = line.match(PATTERNS.image);
-  if (imageMatch) {
-    return {
-      type: "image",
-      raw: line,
-      content: imageMatch[2],
-      indent: 0,
-      line: lineNumber,
-      meta: { language: imageMatch[1] }
-    };
-  }
-  if (PATTERNS.setextH1.test(line) || PATTERNS.setextH2.test(line)) {
-    const prevLine = lineIndex > 0 ? allLines[lineIndex - 1] : "";
-    if (prevLine.trim() && !PATTERNS.blank.test(prevLine)) {
-      return {
-        type: "heading",
-        raw: line,
-        content: prevLine.trim(),
-        indent: 0,
-        line: lineNumber,
-        meta: { level: PATTERNS.setextH1.test(line) ? 1 : 2 }
-      };
-    }
-    return {
-      type: "divider",
-      raw: line,
-      content: "",
-      indent: 0,
-      line: lineNumber
-    };
-  }
-  return {
-    type: "paragraph",
-    raw: line,
-    content: line.trim(),
-    indent: line.length - line.trimStart().length,
-    line: lineNumber
-  };
-}
-
-// src/parsers/inline.ts
-function parseInlineContent(text) {
-  if (!text) {
-    return [];
-  }
-  const tokens = tokenizeInline(text);
-  return tokensToSpans(tokens);
-}
-function tokenizeInline(text) {
-  const tokens = [];
-  let remaining = text;
-  let pos = 0;
-  while (pos < remaining.length) {
-    const matched = tryMatchInline(remaining, pos);
-    if (matched) {
-      if (matched.startIndex > pos) {
-        tokens.push({
-          type: "text",
-          content: remaining.slice(pos, matched.startIndex)
-        });
-      }
-      tokens.push(matched.token);
-      pos = matched.endIndex;
-    } else {
-      pos++;
-    }
-  }
-  return parseInlineTokens(text);
-}
-function parseInlineTokens(text) {
-  const tokens = [];
-  let i = 0;
-  let textBuffer = "";
-  const flushText = () => {
-    if (textBuffer) {
-      tokens.push({ type: "text", content: textBuffer });
-      textBuffer = "";
-    }
-  };
-  while (i < text.length) {
-    if (text[i] === "\\" && i + 1 < text.length) {
-      textBuffer += text[i + 1];
-      i += 2;
-      continue;
-    }
-    if (text[i] === "`") {
-      const match = matchCode(text, i);
-      if (match) {
-        flushText();
-        tokens.push(match.token);
-        i = match.end;
-        continue;
-      }
-    }
-    if (text[i] === "[" || text[i] === "!" && text[i + 1] === "[") {
-      const isImage = text[i] === "!";
-      const match = matchLink(text, isImage ? i + 1 : i, isImage);
-      if (match) {
-        flushText();
-        tokens.push(match.token);
-        i = match.end;
-        continue;
-      }
-    }
-    if (text[i] === "*" || text[i] === "_") {
-      const match = matchEmphasis(text, i);
-      if (match) {
-        flushText();
-        tokens.push(match.token);
-        i = match.end;
-        continue;
-      }
-    }
-    if (text[i] === "~" && text[i + 1] === "~") {
-      const match = matchStrikethrough(text, i);
-      if (match) {
-        flushText();
-        tokens.push(match.token);
-        i = match.end;
-        continue;
-      }
-    }
-    if (text[i] === "=" && text[i + 1] === "=") {
-      const match = matchHighlight(text, i);
-      if (match) {
-        flushText();
-        tokens.push(match.token);
-        i = match.end;
-        continue;
-      }
-    }
-    textBuffer += text[i];
-    i++;
-  }
-  flushText();
-  return tokens;
-}
-function matchCode(text, start) {
-  let backticks = 0;
-  let i = start;
-  while (i < text.length && text[i] === "`") {
-    backticks++;
-    i++;
-  }
-  if (backticks === 0)
-    return null;
-  const closePattern = "`".repeat(backticks);
-  const closeIndex = text.indexOf(closePattern, i);
-  if (closeIndex === -1)
-    return null;
-  if (text[closeIndex + backticks] === "`") {
-    return null;
-  }
-  const content = text.slice(i, closeIndex);
-  return {
-    token: { type: "code", content: content.trim() },
-    end: closeIndex + backticks
-  };
-}
-function matchLink(text, start, isImage = false) {
-  if (text[start] !== "[")
-    return null;
-  let bracketDepth = 1;
-  let i = start + 1;
-  while (i < text.length && bracketDepth > 0) {
-    if (text[i] === "[")
-      bracketDepth++;
-    else if (text[i] === "]")
-      bracketDepth--;
-    else if (text[i] === "\\")
-      i++;
-    i++;
-  }
-  if (bracketDepth !== 0)
-    return null;
-  const linkText = text.slice(start + 1, i - 1);
-  if (text[i] !== "(")
-    return null;
-  const urlStart = i + 1;
-  let urlEnd = urlStart;
-  let parenDepth = 1;
-  while (urlEnd < text.length && parenDepth > 0) {
-    if (text[urlEnd] === "(")
-      parenDepth++;
-    else if (text[urlEnd] === ")")
-      parenDepth--;
-    else if (text[urlEnd] === "\\")
-      urlEnd++;
-    urlEnd++;
-  }
-  if (parenDepth !== 0)
-    return null;
-  const urlPart = text.slice(urlStart, urlEnd - 1).trim();
-  let url = urlPart;
-  let title;
-  const titleMatch = urlPart.match(/^(.+?)\s+["'](.+?)["']$/);
-  if (titleMatch) {
-    url = titleMatch[1];
-    title = titleMatch[2];
-  }
-  const children = parseInlineTokens(linkText);
-  const token = isImage ? { type: "image", content: linkText, url, title, children } : { type: "link", content: linkText, url, title, children };
-  return {
-    token,
-    end: isImage ? urlEnd + 1 : urlEnd
-  };
-}
-function matchEmphasis(text, start) {
-  const char = text[start];
-  if (char !== "*" && char !== "_")
-    return null;
-  let count = 0;
-  let i = start;
-  while (i < text.length && text[i] === char && count < 3) {
-    count++;
-    i++;
-  }
-  if (count === 0)
-    return null;
-  const closePattern = char.repeat(count);
-  let searchStart = i;
-  while (searchStart < text.length) {
-    const closeIndex = text.indexOf(closePattern, searchStart);
-    if (closeIndex === -1)
-      return null;
-    if (text[closeIndex + count] === char) {
-      searchStart = closeIndex + 1;
-      continue;
-    }
-    if (text[closeIndex - 1] === " ") {
-      searchStart = closeIndex + 1;
-      continue;
-    }
-    const content = text.slice(i, closeIndex);
-    if (!content.trim()) {
-      searchStart = closeIndex + 1;
-      continue;
-    }
-    const children = parseInlineTokens(content);
-    if (count === 3) {
-      return {
-        token: {
-          type: "bold",
-          content,
-          children: [{ type: "italic", content, children }]
-        },
-        end: closeIndex + count
-      };
-    } else if (count === 2) {
-      return {
-        token: { type: "bold", content, children },
-        end: closeIndex + count
-      };
-    } else {
-      return {
-        token: { type: "italic", content, children },
-        end: closeIndex + count
-      };
-    }
-  }
-  return null;
-}
-function matchStrikethrough(text, start) {
-  if (text[start] !== "~" || text[start + 1] !== "~")
-    return null;
-  const closeIndex = text.indexOf("~~", start + 2);
-  if (closeIndex === -1)
-    return null;
-  const content = text.slice(start + 2, closeIndex);
-  if (!content.trim())
-    return null;
-  const children = parseInlineTokens(content);
-  return {
-    token: { type: "strikethrough", content, children },
-    end: closeIndex + 2
-  };
-}
-function matchHighlight(text, start) {
-  if (text[start] !== "=" || text[start + 1] !== "=")
-    return null;
-  const closeIndex = text.indexOf("==", start + 2);
-  if (closeIndex === -1)
-    return null;
-  const content = text.slice(start + 2, closeIndex);
-  if (!content.trim())
-    return null;
-  const children = parseInlineTokens(content);
-  return {
-    token: { type: "highlight", content, children },
-    end: closeIndex + 2
-  };
-}
-function tokensToSpans(tokens) {
-  const spans = [];
-  for (const token of tokens) {
-    const newSpans = tokenToSpans(token, {});
-    spans.push(...newSpans);
-  }
-  return mergeAdjacentSpans(spans);
-}
-function tokenToSpans(token, inheritedStyles) {
-  switch (token.type) {
-    case "text":
-      return [{ text: token.content, styles: { ...inheritedStyles } }];
-    case "bold":
-      return processStyledToken(token, { ...inheritedStyles, bold: true });
-    case "italic":
-      return processStyledToken(token, { ...inheritedStyles, italic: true });
-    case "code":
-      return [{ text: token.content, styles: { ...inheritedStyles, code: true } }];
-    case "strikethrough":
-      return processStyledToken(token, { ...inheritedStyles, strikethrough: true });
-    case "highlight":
-      return processStyledToken(token, { ...inheritedStyles, highlight: true });
-    case "link":
-      return processStyledToken(token, {
-        ...inheritedStyles,
-        link: { url: token.url || "", title: token.title }
-      });
-    case "image":
-      return [{ text: `[image: ${token.content}]`, styles: inheritedStyles }];
-    default:
-      return [{ text: token.content, styles: inheritedStyles }];
-  }
-}
-function processStyledToken(token, styles) {
-  if (token.children && token.children.length > 0) {
-    const spans = [];
-    for (const child of token.children) {
-      spans.push(...tokenToSpans(child, styles));
-    }
-    return spans;
-  }
-  return [{ text: token.content, styles }];
-}
-function mergeAdjacentSpans(spans) {
-  if (spans.length === 0)
-    return [];
-  const merged = [spans[0]];
-  for (let i = 1;i < spans.length; i++) {
-    const current = spans[i];
-    const previous = merged[merged.length - 1];
-    if (stylesEqual(current.styles, previous.styles)) {
-      previous.text += current.text;
-    } else {
-      merged.push(current);
-    }
-  }
-  return merged;
-}
-function stylesEqual(a, b) {
-  return a.bold === b.bold && a.italic === b.italic && a.underline === b.underline && a.strikethrough === b.strikethrough && a.code === b.code && a.highlight === b.highlight && linksEqual(a.link, b.link);
-}
-function linksEqual(a, b) {
-  if (!a && !b)
-    return true;
-  if (!a || !b)
-    return false;
-  return a.url === b.url && a.title === b.title;
-}
-function tryMatchInline(text, pos) {
-  const matchers = [
-    () => matchCode(text, pos),
-    () => matchEmphasis(text, pos),
-    () => matchStrikethrough(text, pos),
-    () => matchHighlight(text, pos)
-  ];
-  for (const match of matchers) {
-    const result = match();
-    if (result) {
-      return {
-        token: result.token,
-        startIndex: pos,
-        endIndex: result.end
-      };
-    }
-  }
-  return null;
-}
-
-// src/parsers/markdown.ts
-var DEFAULT_OPTIONS = {
-  generateId,
-  strict: false
-};
-function markdownToBlocks(markdown, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  const tokens = tokenize(markdown);
-  return parseTokens(tokens, opts);
-}
-function parseTokens(tokens, options) {
-  const blocks = [];
-  const state = {
-    options,
-    tokens,
-    index: 0
-  };
-  while (state.index < tokens.length) {
-    const token = tokens[state.index];
-    if (token.type === "blank") {
-      state.index++;
-      continue;
-    }
-    const block = parseBlock(state);
-    if (block) {
-      blocks.push(block);
-    }
-  }
-  return blocks;
-}
-function parseBlock(state) {
-  const token = state.tokens[state.index];
-  switch (token.type) {
-    case "heading":
-      return parseHeading(state);
-    case "paragraph":
-      return parseParagraph(state);
-    case "bullet_list_item":
-      return parseBulletList(state);
-    case "numbered_list_item":
-      return parseNumberedList(state);
-    case "check_list_item":
-      return parseCheckListItem(state);
-    case "code_fence_start":
-      return parseCodeBlock(state);
-    case "blockquote":
-      return parseBlockquote(state);
-    case "callout":
-      return parseCallout(state);
-    case "divider":
-      return parseDivider(state);
-    case "table_row":
-      return parseTable(state);
-    case "image":
-      return parseImage(state);
-    default:
-      state.index++;
-      return null;
-  }
-}
-function parseHeading(state) {
-  const token = state.tokens[state.index];
-  const level = token.meta?.level ?? 1;
-  const content = parseInlineContent(token.content);
-  state.index++;
-  return {
-    id: state.options.generateId(),
-    type: "heading",
-    content,
-    children: [],
-    props: { level }
-  };
-}
-function parseParagraph(state) {
-  const lines = [];
-  while (state.index < state.tokens.length && state.tokens[state.index].type === "paragraph") {
-    lines.push(state.tokens[state.index].content);
-    state.index++;
-  }
-  const content = parseInlineContent(lines.join(" "));
-  return {
-    id: state.options.generateId(),
-    type: "paragraph",
-    content,
-    children: [],
-    props: {}
-  };
-}
-function parseBulletList(state) {
-  const children = [];
-  const baseIndent = state.tokens[state.index].indent;
-  while (state.index < state.tokens.length && state.tokens[state.index].type === "bullet_list_item" && state.tokens[state.index].indent >= baseIndent) {
-    const token = state.tokens[state.index];
-    if (token.indent > baseIndent) {
-      state.index++;
-      continue;
-    }
-    const content = parseInlineContent(token.content);
-    children.push({
-      id: state.options.generateId(),
-      type: "paragraph",
-      content,
-      children: [],
-      props: {}
-    });
-    state.index++;
-  }
-  return {
-    id: state.options.generateId(),
-    type: "bulletList",
-    content: [],
-    children,
-    props: {}
-  };
-}
-function parseNumberedList(state) {
-  const children = [];
-  const baseIndent = state.tokens[state.index].indent;
-  while (state.index < state.tokens.length && state.tokens[state.index].type === "numbered_list_item" && state.tokens[state.index].indent >= baseIndent) {
-    const token = state.tokens[state.index];
-    if (token.indent > baseIndent) {
-      state.index++;
-      continue;
-    }
-    const content = parseInlineContent(token.content);
-    children.push({
-      id: state.options.generateId(),
-      type: "paragraph",
-      content,
-      children: [],
-      props: {}
-    });
-    state.index++;
-  }
-  return {
-    id: state.options.generateId(),
-    type: "numberedList",
-    content: [],
-    children,
-    props: {}
-  };
-}
-function parseCheckListItem(state) {
-  const token = state.tokens[state.index];
-  const checked = token.meta?.checked ?? false;
-  const content = parseInlineContent(token.content);
-  state.index++;
-  return {
-    id: state.options.generateId(),
-    type: "checkList",
-    content,
-    children: [],
-    props: { checked }
-  };
-}
-function parseCodeBlock(state) {
-  const startToken = state.tokens[state.index];
-  const language = startToken.meta?.language ?? "";
-  const codeLines = [];
-  state.index++;
-  while (state.index < state.tokens.length && state.tokens[state.index].type === "code_content") {
-    codeLines.push(state.tokens[state.index].content);
-    state.index++;
-  }
-  if (state.index < state.tokens.length && state.tokens[state.index].type === "code_fence_end") {
-    state.index++;
-  }
-  return {
-    id: state.options.generateId(),
-    type: "codeBlock",
-    content: plainContent(codeLines.join(`
-`)),
-    children: [],
-    props: { language: language || undefined }
-  };
-}
-function parseBlockquote(state) {
-  const lines = [];
-  while (state.index < state.tokens.length && state.tokens[state.index].type === "blockquote") {
-    lines.push(state.tokens[state.index].content);
-    state.index++;
-  }
-  const content = parseInlineContent(lines.join(`
-`));
-  return {
-    id: state.options.generateId(),
-    type: "blockquote",
-    content,
-    children: [],
-    props: {}
-  };
-}
-function parseCallout(state) {
-  const calloutToken = state.tokens[state.index];
-  const calloutType = calloutToken.meta?.calloutType ?? "note";
-  state.index++;
-  const lines = [];
-  while (state.index < state.tokens.length && state.tokens[state.index].type === "blockquote") {
-    lines.push(state.tokens[state.index].content);
-    state.index++;
-  }
-  const content = parseInlineContent(lines.join(`
-`));
-  return {
-    id: state.options.generateId(),
-    type: "callout",
-    content,
-    children: [],
-    props: { type: calloutType }
-  };
-}
-function parseDivider(state) {
-  state.index++;
-  return {
-    id: state.options.generateId(),
-    type: "divider",
-    content: [],
-    children: [],
-    props: {}
-  };
-}
-function parseTable(state) {
-  const rows = [];
-  let headers = [];
-  let alignments = [];
-  let isFirstRow = true;
-  let hasSeparator = false;
-  while (state.index < state.tokens.length && (state.tokens[state.index].type === "table_row" || state.tokens[state.index].type === "table_separator")) {
-    const token = state.tokens[state.index];
-    if (token.type === "table_separator") {
-      alignments = parseTableAlignments(token.content);
-      hasSeparator = true;
-      state.index++;
-      continue;
-    }
-    const cells = token.content.split("|").map((cell) => cell.trim()).filter((cell) => cell !== "");
-    if (isFirstRow && !hasSeparator) {
-      headers = cells;
-      isFirstRow = false;
-    } else if (hasSeparator) {
-      rows.push(cells);
-    }
-    state.index++;
-  }
-  if (!hasSeparator && headers.length > 0) {
-    rows.unshift(headers);
-    headers = [];
-  }
-  return {
-    id: state.options.generateId(),
-    type: "table",
-    content: [],
-    children: [],
-    props: {
-      headers,
-      rows,
-      alignments: alignments.length > 0 ? alignments : undefined
-    }
-  };
-}
-function parseTableAlignments(separator) {
-  return separator.split("|").map((cell) => cell.trim()).filter((cell) => cell !== "").map((cell) => {
-    const leftColon = cell.startsWith(":");
-    const rightColon = cell.endsWith(":");
-    if (leftColon && rightColon)
-      return "center";
-    if (leftColon)
-      return "left";
-    if (rightColon)
-      return "right";
-    return null;
-  });
-}
-function parseImage(state) {
-  const token = state.tokens[state.index];
-  const url = token.content;
-  const alt = token.meta?.language ?? "";
-  state.index++;
-  return {
-    id: state.options.generateId(),
-    type: "image",
-    content: [],
-    children: [],
-    props: {
-      url,
-      alt: alt || undefined
-    }
-  };
-}
-
-// src/serializers/markdown.ts
-var DEFAULT_OPTIONS2 = {
-  lineEnding: `
-`,
-  listIndent: 2,
-  headingStyle: "atx",
-  codeBlockStyle: "fenced",
-  bulletChar: "-",
-  emphasisChar: "*"
-};
-function blocksToMarkdown(blocks, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS2, ...options };
-  const serializedBlocks = blocks.map((block, index) => serializeBlock(block, 0, opts, index, blocks));
-  return serializedBlocks.filter((s) => s !== null).join(opts.lineEnding + opts.lineEnding);
-}
-function serializeBlock(block, depth, options, index = 0, siblings = []) {
-  switch (block.type) {
-    case "paragraph":
-      return serializeParagraph(block, options);
-    case "heading":
-      return serializeHeading(block, options);
-    case "bulletList":
-      return serializeBulletList(block, depth, options);
-    case "numberedList":
-      return serializeNumberedList(block, depth, options, index, siblings);
-    case "checkList":
-      return serializeCheckList(block, depth, options);
-    case "codeBlock":
-      return serializeCodeBlock(block, options);
-    case "blockquote":
-      return serializeBlockquote(block, options);
-    case "table":
-      return serializeTable(block, options);
-    case "image":
-      return serializeImage(block);
-    case "divider":
-      return "---";
-    case "callout":
-      return serializeCallout(block, options);
-    default:
-      return serializeInlineContent(block.content, options);
-  }
-}
-function serializeParagraph(block, options) {
-  return serializeInlineContent(block.content, options);
-}
-function serializeHeading(block, options) {
-  const level = block.props.level;
-  const content = serializeInlineContent(block.content, options);
-  if (options.headingStyle === "setext" && (level === 1 || level === 2)) {
-    const underline = level === 1 ? "=" : "-";
-    return `${content}${options.lineEnding}${underline.repeat(content.length)}`;
-  }
-  return `${"#".repeat(level)} ${content}`;
-}
-function serializeBulletList(block, depth, options) {
-  const indent = " ".repeat(depth * options.listIndent);
-  const bullet = options.bulletChar;
-  return block.children.map((child) => {
-    const content = serializeListItemContent(child, depth, options);
-    return `${indent}${bullet} ${content}`;
-  }).join(options.lineEnding);
-}
-function serializeNumberedList(block, depth, options, _blockIndex = 0, _siblings = []) {
-  const indent = " ".repeat(depth * options.listIndent);
-  return block.children.map((child, index) => {
-    const content = serializeListItemContent(child, depth, options);
-    return `${indent}${index + 1}. ${content}`;
-  }).join(options.lineEnding);
-}
-function serializeCheckList(block, depth, options) {
-  const indent = " ".repeat(depth * options.listIndent);
-  const checked = block.props.checked ? "x" : " ";
-  const content = serializeInlineContent(block.content, options);
-  return `${indent}- [${checked}] ${content}`;
-}
-function serializeListItemContent(item, depth, options) {
-  if (item.children.length > 0) {
-    const content = serializeInlineContent(item.content, options);
-    const nestedContent = item.children.map((child, index) => serializeBlock(child, depth + 1, options, index, item.children)).join(options.lineEnding);
-    return `${content}${options.lineEnding}${nestedContent}`;
-  }
-  return serializeInlineContent(item.content, options);
-}
-function serializeCodeBlock(block, options) {
-  const code = spansToPlainText(block.content);
-  const language = block.props.language ?? "";
-  if (options.codeBlockStyle === "indented") {
-    return code.split(`
-`).map((line) => `    ${line}`).join(options.lineEnding);
-  }
-  return `\`\`\`${language}${options.lineEnding}${code}${options.lineEnding}\`\`\``;
-}
-function serializeBlockquote(block, options) {
-  const content = serializeInlineContent(block.content, options);
-  return content.split(`
-`).map((line) => `> ${line}`).join(options.lineEnding);
-}
-function serializeImage(block) {
-  const alt = block.props.alt ?? "";
-  const url = block.props.url ?? "";
-  const title = block.props.title;
-  if (title) {
-    return `![${alt}](${url} "${title}")`;
-  }
-  return `![${alt}](${url})`;
-}
-function serializeTable(block, options) {
-  const { headers, rows, alignments } = block.props;
-  const lineEnding = options.lineEnding;
-  const columnWidths = headers.map((header, i) => {
-    const rowWidths = rows.map((row) => (row[i] ?? "").length);
-    return Math.max(header.length, ...rowWidths, 3);
-  });
-  const headerRow = headers.map((header, i) => header.padEnd(columnWidths[i])).join(" | ");
-  const separatorRow = headers.map((_, i) => {
-    const width = columnWidths[i];
-    const alignment = alignments?.[i] ?? null;
-    if (alignment === "left")
-      return `:${"-".repeat(width - 1)}`;
-    if (alignment === "right")
-      return `${"-".repeat(width - 1)}:`;
-    if (alignment === "center")
-      return `:${"-".repeat(width - 2)}:`;
-    return "-".repeat(width);
-  }).join(" | ");
-  const dataRows = rows.map((row) => row.map((cell, i) => (cell ?? "").padEnd(columnWidths[i])).join(" | "));
-  return [
-    `| ${headerRow} |`,
-    `| ${separatorRow} |`,
-    ...dataRows.map((row) => `| ${row} |`)
-  ].join(lineEnding);
-}
-function serializeCallout(block, options) {
-  const type = block.props.type.toUpperCase();
-  const content = serializeInlineContent(block.content, options);
-  const lineEnding = options.lineEnding;
-  return `> [!${type}]${lineEnding}> ${content.split(`
-`).join(`${lineEnding}> `)}`;
-}
-function serializeInlineContent(spans, options) {
-  return spans.map((span) => serializeSpan(span, options)).join("");
-}
-function serializeSpan(span, options) {
-  let text = span.text;
-  const styles = span.styles;
-  if (!hasStyles(styles)) {
-    return text;
-  }
-  if (styles.code) {
-    text = `\`${text}\``;
-  }
-  if (styles.highlight) {
-    text = `==${text}==`;
-  }
-  if (styles.strikethrough) {
-    text = `~~${text}~~`;
-  }
-  if (styles.bold && styles.italic) {
-    const char = options.emphasisChar;
-    text = `${char}${char}${char}${text}${char}${char}${char}`;
-  } else {
-    if (styles.italic) {
-      const char = options.emphasisChar;
-      text = `${char}${text}${char}`;
-    }
-    if (styles.bold) {
-      const char = options.emphasisChar;
-      text = `${char}${char}${text}${char}${char}`;
-    }
-  }
-  if (styles.underline) {
-    text = `<u>${text}</u>`;
-  }
-  if (styles.link) {
-    const { url, title } = styles.link;
-    if (title) {
-      text = `[${text}](${url} "${title}")`;
-    } else {
-      text = `[${text}](${url})`;
-    }
-  }
-  return text;
-}
-function hasStyles(styles) {
-  return !!(styles.bold || styles.italic || styles.underline || styles.strikethrough || styles.code || styles.highlight || styles.link);
-}
-
-// src/react/hooks.ts
-function useDocument(initialBlocks = [], options) {
-  const [document, setDocument] = useState(() => createDocument(initialBlocks, options));
-  const insert = useCallback((block, index) => {
-    setDocument((doc) => insertBlock(doc, block, index));
-  }, []);
-  const append = useCallback((block) => {
-    setDocument((doc) => appendBlock(doc, block));
-  }, []);
-  const remove = useCallback((blockId) => {
-    setDocument((doc) => removeBlock(doc, blockId));
-  }, []);
-  const update = useCallback((blockId, updates) => {
-    setDocument((doc) => updateBlock(doc, blockId, updates));
-  }, []);
-  const move = useCallback((blockId, newIndex) => {
-    setDocument((doc) => moveBlock(doc, blockId, newIndex));
-  }, []);
-  const find = useCallback((blockId) => findBlock(document, blockId), [document]);
-  const getIndex = useCallback((blockId) => getBlockIndex(document, blockId), [document]);
-  const clear = useCallback(() => {
-    setDocument((doc) => clearBlocks(doc));
-  }, []);
-  const set = useCallback((blocks) => {
-    setDocument((doc) => setBlocks(doc, blocks));
-  }, []);
-  const toMd = useCallback(() => blocksToMarkdown(document.blocks), [document]);
-  const fromMd = useCallback((markdown) => {
-    const blocks = markdownToBlocks(markdown);
-    setDocument((doc) => setBlocks(doc, blocks));
-  }, []);
-  const meta = useCallback((newMeta) => {
-    setDocument((doc) => updateMeta(doc, newMeta));
-  }, []);
-  return {
-    document,
-    blocks: document.blocks,
-    insertBlock: insert,
-    appendBlock: append,
-    removeBlock: remove,
-    updateBlock: update,
-    moveBlock: move,
-    findBlock: find,
-    getBlockIndex: getIndex,
-    clearBlocks: clear,
-    setBlocks: set,
-    setDocument,
-    toMarkdown: toMd,
-    fromMarkdown: fromMd,
-    updateMeta: meta
-  };
-}
-function useMarkdown(initialMarkdown = "") {
-  const [markdown, setMarkdownState] = useState(initialMarkdown);
-  const blocks = useMemo(() => markdownToBlocks(markdown), [markdown]);
-  const setMarkdown = useCallback((newMarkdown) => {
-    setMarkdownState(newMarkdown);
-  }, []);
-  const setBlocksFromBlocks = useCallback((newBlocks) => {
-    const newMarkdown = blocksToMarkdown(newBlocks);
-    setMarkdownState(newMarkdown);
-  }, []);
-  return {
-    markdown,
-    blocks,
-    setMarkdown,
-    setBlocks: setBlocksFromBlocks
-  };
-}
-function useBlockEditor(documentHook) {
-  const { document, blocks, removeBlock: removeBlock2, updateBlock: updateBlock2, moveBlock: moveBlock2, insertBlock: insertBlock2 } = documentHook;
-  const [selectedBlockId, setSelectedBlockId] = useState(null);
-  const selectedBlock = useMemo(() => selectedBlockId ? findBlock(document, selectedBlockId) : undefined, [document, selectedBlockId]);
-  const selectBlock = useCallback((blockId) => {
-    setSelectedBlockId(blockId);
-  }, []);
-  const selectNext = useCallback(() => {
-    if (!selectedBlockId) {
-      if (blocks.length > 0) {
-        setSelectedBlockId(blocks[0].id);
-      }
-      return;
-    }
-    const currentIndex = getBlockIndex(document, selectedBlockId);
-    if (currentIndex < blocks.length - 1) {
-      setSelectedBlockId(blocks[currentIndex + 1].id);
-    }
-  }, [document, blocks, selectedBlockId]);
-  const selectPrevious = useCallback(() => {
-    if (!selectedBlockId) {
-      if (blocks.length > 0) {
-        setSelectedBlockId(blocks[blocks.length - 1].id);
-      }
-      return;
-    }
-    const currentIndex = getBlockIndex(document, selectedBlockId);
-    if (currentIndex > 0) {
-      setSelectedBlockId(blocks[currentIndex - 1].id);
-    }
-  }, [document, blocks, selectedBlockId]);
-  const deleteSelected = useCallback(() => {
-    if (!selectedBlockId)
-      return;
-    const currentIndex = getBlockIndex(document, selectedBlockId);
-    removeBlock2(selectedBlockId);
-    if (blocks.length > 1) {
-      if (currentIndex < blocks.length - 1) {
-        setSelectedBlockId(blocks[currentIndex + 1].id);
-      } else if (currentIndex > 0) {
-        setSelectedBlockId(blocks[currentIndex - 1].id);
-      }
-    } else {
-      setSelectedBlockId(null);
-    }
-  }, [document, blocks, selectedBlockId, removeBlock2]);
-  const updateSelectedContent = useCallback((content) => {
-    if (!selectedBlockId)
-      return;
-    updateBlock2(selectedBlockId, { content });
-  }, [selectedBlockId, updateBlock2]);
-  const duplicateSelected = useCallback(() => {
-    if (!selectedBlockId || !selectedBlock)
-      return;
-    const currentIndex = getBlockIndex(document, selectedBlockId);
-    const clonedBlock = {
-      ...selectedBlock,
-      id: Math.random().toString(36).substring(2, 9)
-    };
-    insertBlock2(clonedBlock, currentIndex + 1);
-    setSelectedBlockId(clonedBlock.id);
-  }, [document, selectedBlockId, selectedBlock, insertBlock2]);
-  const moveSelectedUp = useCallback(() => {
-    if (!selectedBlockId)
-      return;
-    const currentIndex = getBlockIndex(document, selectedBlockId);
-    if (currentIndex > 0) {
-      moveBlock2(selectedBlockId, currentIndex - 1);
-    }
-  }, [document, selectedBlockId, moveBlock2]);
-  const moveSelectedDown = useCallback(() => {
-    if (!selectedBlockId)
-      return;
-    const currentIndex = getBlockIndex(document, selectedBlockId);
-    if (currentIndex < blocks.length - 1) {
-      moveBlock2(selectedBlockId, currentIndex + 1);
-    }
-  }, [document, blocks, selectedBlockId, moveBlock2]);
-  return {
-    selectedBlockId,
-    selectedBlock,
-    selectBlock,
-    selectNext,
-    selectPrevious,
-    deleteSelected,
-    updateSelectedContent,
-    duplicateSelected,
-    moveSelectedUp,
-    moveSelectedDown
-  };
-}
-// src/core/blocks.ts
-function createBlock(type, content = [], props = {}, children = []) {
-  return {
-    id: generateId(),
-    type,
-    content,
-    children,
-    props
-  };
-}
-function text(content) {
-  return plainSpan(content);
-}
-function bold(content) {
-  return { text: content, styles: { bold: true } };
-}
-function italic(content) {
-  return { text: content, styles: { italic: true } };
-}
-function code(content) {
-  return { text: content, styles: { code: true } };
-}
-function link(content, url, title) {
-  return {
-    text: content,
-    styles: { link: { url, title } }
-  };
-}
-function paragraph(content) {
-  const textContent = typeof content === "string" ? plainContent(content) : content;
-  return createBlock("paragraph", textContent, {});
-}
-function heading(level, content) {
-  const textContent = typeof content === "string" ? plainContent(content) : content;
-  return createBlock("heading", textContent, { level });
-}
-var h1 = (content) => heading(1, content);
-var h2 = (content) => heading(2, content);
-var h3 = (content) => heading(3, content);
-var h4 = (content) => heading(4, content);
-var h5 = (content) => heading(5, content);
-var h6 = (content) => heading(6, content);
-function bulletList(items) {
-  const children = items.map((item) => {
-    if (typeof item === "string") {
-      return paragraph(item);
-    }
-    if (Array.isArray(item)) {
-      return paragraph(item);
-    }
-    return item;
-  });
-  return createBlock("bulletList", [], {}, children);
-}
-function numberedList(items) {
-  const children = items.map((item) => {
-    if (typeof item === "string") {
-      return paragraph(item);
-    }
-    if (Array.isArray(item)) {
-      return paragraph(item);
-    }
-    return item;
-  });
-  return createBlock("numberedList", [], {}, children);
-}
-function checkListItem(content, checked = false) {
-  const textContent = typeof content === "string" ? plainContent(content) : content;
-  return createBlock("checkList", textContent, { checked });
-}
-function checkList(items) {
-  return items.map((item) => checkListItem(item.content, item.checked ?? false));
-}
-function codeBlock(code2, language) {
-  return createBlock("codeBlock", plainContent(code2), { language });
-}
-function blockquote(content) {
-  const textContent = typeof content === "string" ? plainContent(content) : content;
-  return createBlock("blockquote", textContent, {});
-}
-function divider() {
-  return createBlock("divider", [], {});
-}
-function image(url, alt, options) {
-  return createBlock("image", [], {
-    url,
-    alt,
-    title: options?.title,
-    width: options?.width,
-    height: options?.height
-  });
-}
-function callout(type, content) {
-  const textContent = typeof content === "string" ? plainContent(content) : content;
-  return createBlock("callout", textContent, { type });
-}
-export {
-  useMarkdown,
-  useDocument,
-  useBlockEditor,
-  text,
-  paragraph,
-  numberedList,
-  link,
-  italic,
-  image,
-  heading,
-  h6,
-  h5,
-  h4,
-  h3,
-  h2,
-  h1,
-  divider,
-  codeBlock,
-  code,
-  checkListItem,
-  checkList,
-  callout,
-  bulletList,
-  bold,
-  blockquote,
-  InlineContent,
-  BlockRenderer,
-  BlockElement
-};