create-markdown 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -2,6 +2,23 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __reExport = (target, mod, secondTarget) => {
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(target, key) && key !== "default")
+      __defProp(target, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  if (secondTarget) {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(secondTarget, key) && key !== "default")
+        __defProp(secondTarget, key, {
+          get: () => mod[key],
+          enumerable: true
+        });
+    return secondTarget;
+  }
+};
 var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
   var entry = __moduleCache.get(from), desc;
@@ -29,1732 +46,8 @@ var __export = (target, all) => {
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
-  warningCallout: () => warningCallout,
-  updateProps: () => updateProps,
-  updateMeta: () => updateMeta,
-  updateBlock: () => updateBlock,
-  unescapeMarkdown: () => unescapeMarkdown,
-  underline: () => underline,
-  trimTrailingWhitespace: () => trimTrailingWhitespace,
-  trimBlankLines: () => trimBlankLines,
-  tokenize: () => tokenize,
-  toMarkdown: () => toMarkdown,
-  tipCallout: () => tipCallout,
-  text: () => text,
-  table: () => table,
-  swapBlocks: () => swapBlocks,
-  styled: () => styled,
-  stringify: () => stringify,
-  strikethrough: () => strikethrough,
-  spansToPlainText: () => spansToPlainText,
-  spans: () => spans,
-  setMetaField: () => setMetaField,
-  setContent: () => setContent,
-  setBlocks: () => setBlocks,
-  setBlockContent: () => setBlockContent,
-  serializeSpan: () => serializeSpan,
-  serializeInlineContent: () => serializeInlineContent,
-  serializeBlock: () => serializeBlock,
-  replaceBlock: () => replaceBlock,
-  removeBlocks: () => removeBlocks,
-  removeBlock: () => removeBlock,
-  prependContent: () => prependContent,
-  prependBlock: () => prependBlock,
-  plainSpan: () => plainSpan,
-  plainContent: () => plainContent,
-  parseInlineContent: () => parseInlineContent,
-  parse: () => parse,
-  paragraph: () => paragraph,
-  numberedList: () => numberedList,
-  noteCallout: () => noteCallout,
-  normalizeLineEndings: () => normalizeLineEndings,
-  moveBlock: () => moveBlock,
-  markdownToDocument: () => markdownToDocument,
-  markdownToBlocks: () => markdownToBlocks,
-  mapBlocks: () => mapBlocks,
-  link: () => link,
-  italic: () => italic,
-  isValidHeadingLevel: () => isValidHeadingLevel,
-  isValidBlockType: () => isValidBlockType,
-  isListToken: () => isListToken,
-  isEmpty: () => isEmpty,
-  isCodeToken: () => isCodeToken,
-  insertBlocks: () => insertBlocks,
-  insertBlock: () => insertBlock,
-  infoCallout: () => infoCallout,
-  indent: () => indent,
-  image: () => image,
-  highlight: () => highlight,
-  heading: () => heading,
-  hasContent: () => hasContent,
-  hasChildren: () => hasChildren,
-  hasBlock: () => hasBlock,
-  h6: () => h6,
-  h5: () => h5,
-  h4: () => h4,
-  h3: () => h3,
-  h2: () => h2,
-  h1: () => h1,
-  groupTokens: () => groupTokens,
-  getMetaField: () => getMetaField,
-  getLastBlock: () => getLastBlock,
-  getFirstBlock: () => getFirstBlock,
-  getBlockIndex: () => getBlockIndex,
-  getBlockCount: () => getBlockCount,
-  getBlockAt: () => getBlockAt,
-  generateId: () => generateId,
-  fromMarkdown: () => fromMarkdown,
-  findBlocksByType: () => findBlocksByType,
-  findBlock: () => findBlock,
-  filterBlocks: () => filterBlocks,
-  escapeMarkdown: () => escapeMarkdown,
-  escapeCodeBlock: () => escapeCodeBlock,
-  emptyDocument: () => emptyDocument,
-  documentToMarkdown: () => documentToMarkdown,
-  divider: () => divider,
-  deepCloneBlocks: () => deepCloneBlocks,
-  deepClone: () => deepClone,
-  dangerCallout: () => dangerCallout,
-  createDocument: () => createDocument,
-  createBlock: () => createBlock,
-  convertLineEndings: () => convertLineEndings,
-  codeBlock: () => codeBlock,
-  code: () => code,
-  cloneDocument: () => cloneDocument,
-  clearBlocks: () => clearBlocks,
-  checkListItem: () => checkListItem,
-  checkList: () => checkList,
-  callout: () => callout,
-  bulletList: () => bulletList,
-  bold: () => bold,
-  blocksToMarkdown: () => blocksToMarkdown,
-  blockquote: () => blockquote,
-  appendContent: () => appendContent,
-  appendBlockContent: () => appendBlockContent,
-  appendBlock: () => appendBlock,
-  addChildren: () => addChildren,
-  VERSION: () => VERSION,
-  DOCUMENT_VERSION: () => DOCUMENT_VERSION
+  VERSION: () => VERSION
 });
 module.exports = __toCommonJS(exports_src);
-
-// 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 normalizeLineEndings(text) {
-  return text.replace(/\r\n|\r/g, `
-`);
-}
-function convertLineEndings(text, lineEnding) {
-  const normalized = normalizeLineEndings(text);
-  if (lineEnding === `\r
-`) {
-    return normalized.replace(/\n/g, `\r
-`);
-  }
-  return normalized;
-}
-var MARKDOWN_ESCAPE_CHARS = /[\\`*_{}[\]()#+\-.!|]/g;
-function escapeMarkdown(text) {
-  return text.replace(MARKDOWN_ESCAPE_CHARS, "\\$&");
-}
-function unescapeMarkdown(text) {
-  return text.replace(/\\([\\`*_{}[\]()#+\-.!|])/g, "$1");
-}
-function escapeCodeBlock(text) {
-  return text.replace(/```/g, "\\`\\`\\`");
-}
-function trimTrailingWhitespace(text) {
-  return text.split(`
-`).map((line) => line.trimEnd()).join(`
-`);
-}
-function trimBlankLines(text) {
-  const lines = text.split(`
-`);
-  let start = 0;
-  while (start < lines.length && lines[start].trim() === "") {
-    start++;
-  }
-  let end = lines.length - 1;
-  while (end >= start && lines[end].trim() === "") {
-    end--;
-  }
-  return lines.slice(start, end + 1).join(`
-`);
-}
-function indent(text, spaces) {
-  const padding = " ".repeat(spaces);
-  return text.split(`
-`).map((line) => line.trim() ? padding + line : line).join(`
-`);
-}
-function spansToPlainText(spans) {
-  return spans.map((span) => span.text).join("");
-}
-function plainSpan(text) {
-  return { text, styles: {} };
-}
-function plainContent(text) {
-  return [plainSpan(text)];
-}
-function hasContent(block) {
-  return block.content.length > 0 && block.content.some((span) => span.text.length > 0);
-}
-function hasChildren(block) {
-  return block.children.length > 0;
-}
-function isValidHeadingLevel(level) {
-  return Number.isInteger(level) && level >= 1 && level <= 6;
-}
-function isValidBlockType(type) {
-  const validTypes = [
-    "paragraph",
-    "heading",
-    "bulletList",
-    "numberedList",
-    "checkList",
-    "codeBlock",
-    "blockquote",
-    "table",
-    "image",
-    "divider",
-    "callout"
-  ];
-  return validTypes.includes(type);
-}
-// 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 strikethrough(content) {
-  return { text: content, styles: { strikethrough: true } };
-}
-function underline(content) {
-  return { text: content, styles: { underline: true } };
-}
-function highlight(content) {
-  return { text: content, styles: { highlight: true } };
-}
-function link(content, url, title) {
-  return {
-    text: content,
-    styles: { link: { url, title } }
-  };
-}
-function styled(content, styles) {
-  return { text: content, styles };
-}
-function spans(...textSpans) {
-  return textSpans;
-}
-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 });
-}
-var infoCallout = (content) => callout("info", content);
-var warningCallout = (content) => callout("warning", content);
-var tipCallout = (content) => callout("tip", content);
-var dangerCallout = (content) => callout("danger", content);
-var noteCallout = (content) => callout("note", content);
-function table(headers, rows, alignments) {
-  return createBlock("table", [], {
-    headers,
-    rows,
-    alignments
-  });
-}
-function appendContent(block, ...newSpans) {
-  return {
-    ...block,
-    content: [...block.content, ...newSpans]
-  };
-}
-function prependContent(block, ...newSpans) {
-  return {
-    ...block,
-    content: [...newSpans, ...block.content]
-  };
-}
-function setContent(block, content) {
-  return {
-    ...block,
-    content
-  };
-}
-function addChildren(block, ...newChildren) {
-  return {
-    ...block,
-    children: [...block.children, ...newChildren]
-  };
-}
-function updateProps(block, props) {
-  return {
-    ...block,
-    props: { ...block.props, ...props }
-  };
-}
-// 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 emptyDocument(options = {}) {
-  return createDocument([], options);
-}
-function cloneDocument(doc) {
-  return {
-    version: doc.version,
-    blocks: deepCloneBlocks(doc.blocks, true),
-    meta: {
-      ...doc.meta,
-      createdAt: new Date,
-      updatedAt: new Date
-    }
-  };
-}
-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 prependBlock(doc, block) {
-  return insertBlock(doc, block, 0);
-}
-function insertBlocks(doc, blocks, index) {
-  const newBlocks = [...doc.blocks];
-  const insertIndex = index ?? newBlocks.length;
-  newBlocks.splice(insertIndex, 0, ...deepCloneBlocks(blocks, false));
-  return {
-    ...doc,
-    blocks: newBlocks,
-    meta: {
-      ...doc.meta,
-      updatedAt: new Date
-    }
-  };
-}
-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 removeBlocks(doc, blockIds) {
-  const idSet = new Set(blockIds);
-  const newBlocks = doc.blocks.filter((block) => !idSet.has(block.id));
-  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 replaceBlock(doc, blockId, newBlock) {
-  const blockIndex = doc.blocks.findIndex((block) => block.id === blockId);
-  if (blockIndex === -1) {
-    return doc;
-  }
-  const newBlocks = [...doc.blocks];
-  newBlocks[blockIndex] = deepClone(newBlock, false);
-  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 swapBlocks(doc, blockId1, blockId2) {
-  const index1 = doc.blocks.findIndex((block) => block.id === blockId1);
-  const index2 = doc.blocks.findIndex((block) => block.id === blockId2);
-  if (index1 === -1 || index2 === -1 || index1 === index2) {
-    return doc;
-  }
-  const newBlocks = [...doc.blocks];
-  [newBlocks[index1], newBlocks[index2]] = [newBlocks[index2], newBlocks[index1]];
-  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 getBlockAt(doc, index) {
-  return doc.blocks[index];
-}
-function getFirstBlock(doc) {
-  return doc.blocks[0];
-}
-function getLastBlock(doc) {
-  return doc.blocks[doc.blocks.length - 1];
-}
-function findBlocksByType(doc, type) {
-  return doc.blocks.filter((block) => block.type === type);
-}
-function hasBlock(doc, blockId) {
-  return doc.blocks.some((block) => block.id === blockId);
-}
-function getBlockCount(doc) {
-  return doc.blocks.length;
-}
-function isEmpty(doc) {
-  return doc.blocks.length === 0;
-}
-function setBlockContent(doc, blockId, content) {
-  return updateBlock(doc, blockId, { content });
-}
-function appendBlockContent(doc, blockId, content) {
-  const block = findBlock(doc, blockId);
-  if (!block)
-    return doc;
-  return updateBlock(doc, blockId, {
-    content: [...block.content, ...content]
-  });
-}
-function updateMeta(doc, meta) {
-  return {
-    ...doc,
-    meta: {
-      ...doc.meta,
-      ...meta,
-      updatedAt: new Date
-    }
-  };
-}
-function setMetaField(doc, key, value) {
-  return updateMeta(doc, { [key]: value });
-}
-function getMetaField(doc, key) {
-  return doc.meta[key];
-}
-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
-    }
-  };
-}
-function filterBlocks(doc, predicate) {
-  const newBlocks = doc.blocks.filter(predicate);
-  if (newBlocks.length === doc.blocks.length) {
-    return doc;
-  }
-  return {
-    ...doc,
-    blocks: newBlocks,
-    meta: {
-      ...doc.meta,
-      updatedAt: new Date
-    }
-  };
-}
-function mapBlocks(doc, transform) {
-  return {
-    ...doc,
-    blocks: doc.blocks.map(transform),
-    meta: {
-      ...doc.meta,
-      updatedAt: new Date
-    }
-  };
-}
-// src/serializers/markdown.ts
-var DEFAULT_OPTIONS = {
-  lineEnding: `
-`,
-  listIndent: 2,
-  headingStyle: "atx",
-  codeBlockStyle: "fenced",
-  bulletChar: "-",
-  emphasisChar: "*"
-};
-function blocksToMarkdown(blocks, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...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 documentToMarkdown(doc, options = {}) {
-  return blocksToMarkdown(doc.blocks, options);
-}
-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 underline2 = level === 1 ? "=" : "-";
-    return `${content}${options.lineEnding}${underline2.repeat(content.length)}`;
-  }
-  return `${"#".repeat(level)} ${content}`;
-}
-function serializeBulletList(block, depth, options) {
-  const indent2 = " ".repeat(depth * options.listIndent);
-  const bullet = options.bulletChar;
-  return block.children.map((child) => {
-    const content = serializeListItemContent(child, depth, options);
-    return `${indent2}${bullet} ${content}`;
-  }).join(options.lineEnding);
-}
-function serializeNumberedList(block, depth, options, _blockIndex = 0, _siblings = []) {
-  const indent2 = " ".repeat(depth * options.listIndent);
-  return block.children.map((child, index) => {
-    const content = serializeListItemContent(child, depth, options);
-    return `${indent2}${index + 1}. ${content}`;
-  }).join(options.lineEnding);
-}
-function serializeCheckList(block, depth, options) {
-  const indent2 = " ".repeat(depth * options.listIndent);
-  const checked = block.props.checked ? "x" : " ";
-  const content = serializeInlineContent(block.content, options);
-  return `${indent2}- [${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 code2 = spansToPlainText(block.content);
-  const language = block.props.language ?? "";
-  if (options.codeBlockStyle === "indented") {
-    return code2.split(`
-`).map((line) => `    ${line}`).join(options.lineEnding);
-  }
-  return `\`\`\`${language}${options.lineEnding}${code2}${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(spans2, options) {
-  return spans2.map((span) => serializeSpan(span, options)).join("");
-}
-function serializeSpan(span, options) {
-  let text2 = span.text;
-  const styles = span.styles;
-  if (!hasStyles(styles)) {
-    return text2;
-  }
-  if (styles.code) {
-    text2 = `\`${text2}\``;
-  }
-  if (styles.highlight) {
-    text2 = `==${text2}==`;
-  }
-  if (styles.strikethrough) {
-    text2 = `~~${text2}~~`;
-  }
-  if (styles.bold && styles.italic) {
-    const char = options.emphasisChar;
-    text2 = `${char}${char}${char}${text2}${char}${char}${char}`;
-  } else {
-    if (styles.italic) {
-      const char = options.emphasisChar;
-      text2 = `${char}${text2}${char}`;
-    }
-    if (styles.bold) {
-      const char = options.emphasisChar;
-      text2 = `${char}${char}${text2}${char}${char}`;
-    }
-  }
-  if (styles.underline) {
-    text2 = `<u>${text2}</u>`;
-  }
-  if (styles.link) {
-    const { url, title } = styles.link;
-    if (title) {
-      text2 = `[${text2}](${url} "${title}")`;
-    } else {
-      text2 = `[${text2}](${url})`;
-    }
-  }
-  return text2;
-}
-function hasStyles(styles) {
-  return !!(styles.bold || styles.italic || styles.underline || styles.strikethrough || styles.code || styles.highlight || styles.link);
-}
-function stringify(blocks, options) {
-  return blocksToMarkdown(blocks, options);
-}
-// 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
-  };
-}
-function groupTokens(tokens) {
-  const groups = [];
-  let currentGroup = [];
-  let lastType = null;
-  for (const token of tokens) {
-    if (token.type === "blank") {
-      if (currentGroup.length > 0) {
-        groups.push(currentGroup);
-        currentGroup = [];
-      }
-      lastType = null;
-      continue;
-    }
-    if (lastType === token.type) {
-      currentGroup.push(token);
-    } else {
-      if (currentGroup.length > 0) {
-        groups.push(currentGroup);
-      }
-      currentGroup = [token];
-      lastType = token.type;
-    }
-  }
-  if (currentGroup.length > 0) {
-    groups.push(currentGroup);
-  }
-  return groups;
-}
-function isListToken(token) {
-  return token.type === "bullet_list_item" || token.type === "numbered_list_item" || token.type === "check_list_item";
-}
-function isCodeToken(token) {
-  return token.type === "code_fence_start" || token.type === "code_fence_end" || token.type === "code_content";
-}
-
-// src/parsers/inline.ts
-function parseInlineContent(text2) {
-  if (!text2) {
-    return [];
-  }
-  const tokens = tokenizeInline(text2);
-  return tokensToSpans(tokens);
-}
-function tokenizeInline(text2) {
-  const tokens = [];
-  let remaining = text2;
-  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(text2);
-}
-function parseInlineTokens(text2) {
-  const tokens = [];
-  let i = 0;
-  let textBuffer = "";
-  const flushText = () => {
-    if (textBuffer) {
-      tokens.push({ type: "text", content: textBuffer });
-      textBuffer = "";
-    }
-  };
-  while (i < text2.length) {
-    if (text2[i] === "\\" && i + 1 < text2.length) {
-      textBuffer += text2[i + 1];
-      i += 2;
-      continue;
-    }
-    if (text2[i] === "`") {
-      const match = matchCode(text2, i);
-      if (match) {
-        flushText();
-        tokens.push(match.token);
-        i = match.end;
-        continue;
-      }
-    }
-    if (text2[i] === "[" || text2[i] === "!" && text2[i + 1] === "[") {
-      const isImage = text2[i] === "!";
-      const match = matchLink(text2, isImage ? i + 1 : i, isImage);
-      if (match) {
-        flushText();
-        tokens.push(match.token);
-        i = match.end;
-        continue;
-      }
-    }
-    if (text2[i] === "*" || text2[i] === "_") {
-      const match = matchEmphasis(text2, i);
-      if (match) {
-        flushText();
-        tokens.push(match.token);
-        i = match.end;
-        continue;
-      }
-    }
-    if (text2[i] === "~" && text2[i + 1] === "~") {
-      const match = matchStrikethrough(text2, i);
-      if (match) {
-        flushText();
-        tokens.push(match.token);
-        i = match.end;
-        continue;
-      }
-    }
-    if (text2[i] === "=" && text2[i + 1] === "=") {
-      const match = matchHighlight(text2, i);
-      if (match) {
-        flushText();
-        tokens.push(match.token);
-        i = match.end;
-        continue;
-      }
-    }
-    textBuffer += text2[i];
-    i++;
-  }
-  flushText();
-  return tokens;
-}
-function matchCode(text2, start) {
-  let backticks = 0;
-  let i = start;
-  while (i < text2.length && text2[i] === "`") {
-    backticks++;
-    i++;
-  }
-  if (backticks === 0)
-    return null;
-  const closePattern = "`".repeat(backticks);
-  const closeIndex = text2.indexOf(closePattern, i);
-  if (closeIndex === -1)
-    return null;
-  if (text2[closeIndex + backticks] === "`") {
-    return null;
-  }
-  const content = text2.slice(i, closeIndex);
-  return {
-    token: { type: "code", content: content.trim() },
-    end: closeIndex + backticks
-  };
-}
-function matchLink(text2, start, isImage = false) {
-  if (text2[start] !== "[")
-    return null;
-  let bracketDepth = 1;
-  let i = start + 1;
-  while (i < text2.length && bracketDepth > 0) {
-    if (text2[i] === "[")
-      bracketDepth++;
-    else if (text2[i] === "]")
-      bracketDepth--;
-    else if (text2[i] === "\\")
-      i++;
-    i++;
-  }
-  if (bracketDepth !== 0)
-    return null;
-  const linkText = text2.slice(start + 1, i - 1);
-  if (text2[i] !== "(")
-    return null;
-  const urlStart = i + 1;
-  let urlEnd = urlStart;
-  let parenDepth = 1;
-  while (urlEnd < text2.length && parenDepth > 0) {
-    if (text2[urlEnd] === "(")
-      parenDepth++;
-    else if (text2[urlEnd] === ")")
-      parenDepth--;
-    else if (text2[urlEnd] === "\\")
-      urlEnd++;
-    urlEnd++;
-  }
-  if (parenDepth !== 0)
-    return null;
-  const urlPart = text2.slice(urlStart, urlEnd - 1).trim();
-  let url = urlPart;
-  let title;
-  const titleMatch = urlPart.match(/^(.+?)\s+["'](.+?)["']$/);
-  if (titleMatch) {
-    url = titleMatch[1];
-    title = titleMatch[2];
-  }
-  const token = isImage ? { type: "image", content: linkText, url, title } : { type: "link", content: linkText, url, title };
-  return {
-    token,
-    end: isImage ? urlEnd + 1 : urlEnd
-  };
-}
-function matchEmphasis(text2, start) {
-  const char = text2[start];
-  if (char !== "*" && char !== "_")
-    return null;
-  let count = 0;
-  let i = start;
-  while (i < text2.length && text2[i] === char && count < 3) {
-    count++;
-    i++;
-  }
-  if (count === 0)
-    return null;
-  const closePattern = char.repeat(count);
-  let searchStart = i;
-  while (searchStart < text2.length) {
-    const closeIndex = text2.indexOf(closePattern, searchStart);
-    if (closeIndex === -1)
-      return null;
-    if (text2[closeIndex + count] === char) {
-      searchStart = closeIndex + 1;
-      continue;
-    }
-    if (text2[closeIndex - 1] === " ") {
-      searchStart = closeIndex + 1;
-      continue;
-    }
-    const content = text2.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(text2, start) {
-  if (text2[start] !== "~" || text2[start + 1] !== "~")
-    return null;
-  const closeIndex = text2.indexOf("~~", start + 2);
-  if (closeIndex === -1)
-    return null;
-  const content = text2.slice(start + 2, closeIndex);
-  if (!content.trim())
-    return null;
-  const children = parseInlineTokens(content);
-  return {
-    token: { type: "strikethrough", content, children },
-    end: closeIndex + 2
-  };
-}
-function matchHighlight(text2, start) {
-  if (text2[start] !== "=" || text2[start + 1] !== "=")
-    return null;
-  const closeIndex = text2.indexOf("==", start + 2);
-  if (closeIndex === -1)
-    return null;
-  const content = text2.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 spans2 = [];
-  for (const token of tokens) {
-    const newSpans = tokenToSpans(token, {});
-    spans2.push(...newSpans);
-  }
-  return mergeAdjacentSpans(spans2);
-}
-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 spans2 = [];
-    for (const child of token.children) {
-      spans2.push(...tokenToSpans(child, styles));
-    }
-    return spans2;
-  }
-  return [{ text: token.content, styles }];
-}
-function mergeAdjacentSpans(spans2) {
-  if (spans2.length === 0)
-    return [];
-  const merged = [spans2[0]];
-  for (let i = 1;i < spans2.length; i++) {
-    const current = spans2[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(text2, pos) {
-  const matchers = [
-    () => matchCode(text2, pos),
-    () => matchEmphasis(text2, pos),
-    () => matchStrikethrough(text2, pos),
-    () => matchHighlight(text2, 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_OPTIONS2 = {
-  generateId,
-  strict: false
-};
-function markdownToBlocks(markdown, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS2, ...options };
-  const tokens = tokenize(markdown);
-  return parseTokens(tokens, opts);
-}
-function markdownToDocument(markdown, options = {}) {
-  const blocks = markdownToBlocks(markdown, options);
-  return createDocument(blocks);
-}
-function parse(markdown, options) {
-  return markdownToBlocks(markdown, options);
-}
-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/index.ts
-function fromMarkdown(markdown) {
-  const blocks = markdownToBlocks(markdown);
-  return createDocument(blocks);
-}
-function toMarkdown(blocksOrDoc) {
-  const blocks = Array.isArray(blocksOrDoc) ? blocksOrDoc : blocksOrDoc.blocks;
-  return blocksToMarkdown(blocks);
-}
+__reExport(exports_src, require("@create-markdown/core"), module.exports);
 var VERSION = "0.2.0";