@x12i/editor 1.0.0 → 1.1.0

package/dist/chunk-FYXMOAJT.js

@@ -0,0 +1,1890 @@
+// src/schema.ts
+var DOCUMENT_VERSION = 1;
+function createEmptyDocument(id = "root") {
+  return {
+    version: DOCUMENT_VERSION,
+    blocks: [{ id, type: "paragraph", content: [] }]
+  };
+}
+var BLOCK_TYPES = [
+  "paragraph",
+  "heading",
+  "quote",
+  "callout",
+  "toggle",
+  "divider",
+  "bulleted-list",
+  "numbered-list",
+  "task-list",
+  "code",
+  "equation",
+  "table",
+  "image",
+  "video",
+  "audio",
+  "file",
+  "bookmark",
+  "columns",
+  "page-break",
+  "table-of-contents",
+  "chart",
+  "diagram",
+  "data-view",
+  "ai"
+];
+var MARK_TYPES = [
+  "bold",
+  "italic",
+  "underline",
+  "strike",
+  "code",
+  "link",
+  "color",
+  "highlight"
+];
+var CALLOUT_VARIANTS = [
+  "info",
+  "success",
+  "warning",
+  "danger",
+  "neutral"
+];
+var blockTypeSet = new Set(BLOCK_TYPES);
+function isKnownBlockType(type) {
+  return typeof type === "string" && blockTypeSet.has(type);
+}
+function createParagraph(id, text = "") {
+  return {
+    id,
+    type: "paragraph",
+    content: text === "" ? [] : [{ type: "text", text }]
+  };
+}
+
+// src/ids.ts
+var ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
+var ID_LENGTH = 12;
+function generateBlockId() {
+  const bytes = new Uint8Array(ID_LENGTH);
+  const webCrypto = globalThis.crypto;
+  if (webCrypto?.getRandomValues) {
+    webCrypto.getRandomValues(bytes);
+  } else {
+    for (let index = 0; index < ID_LENGTH; index += 1) bytes[index] = Math.floor(Math.random() * 256);
+  }
+  let id = "";
+  for (const byte of bytes) id += ALPHABET.charAt(byte % ALPHABET.length);
+  return id;
+}
+function createSeededRandom(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let value = state;
+    value = Math.imul(value ^ value >>> 15, value | 1);
+    value ^= value + Math.imul(value ^ value >>> 7, value | 61);
+    return ((value ^ value >>> 14) >>> 0) / 4294967296;
+  };
+}
+function createSequentialIdGenerator(prefix = "b", start = 1) {
+  let counter = start;
+  return () => {
+    const id = `${prefix}${counter}`;
+    counter += 1;
+    return id;
+  };
+}
+function walkListItems(items, visit) {
+  for (const item of items) {
+    visit(item.id);
+    if (item.children) walkListItems(item.children, visit);
+  }
+}
+function walkBlocks(blocks, visit, parent = null) {
+  for (const block of blocks) {
+    visit(block, parent);
+    switch (block.type) {
+      case "toggle":
+        walkBlocks(block.children ?? [], visit, block);
+        break;
+      case "columns":
+        for (const column of block.columns ?? []) walkBlocks(column, visit, block);
+        break;
+      case "ai":
+        if (block.result) walkBlocks(block.result, visit, block);
+        break;
+      default:
+        break;
+    }
+  }
+}
+function collectIds(doc) {
+  const ids = [];
+  walkBlocks(doc.blocks, (block) => {
+    ids.push(block.id);
+    if (block.type === "bulleted-list" || block.type === "numbered-list" || block.type === "task-list") {
+      walkListItems(block.items ?? [], (id) => ids.push(id));
+    }
+  });
+  return ids;
+}
+function findDuplicateIds(doc) {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const id of collectIds(doc)) {
+    if (seen.has(id)) duplicates.add(id);
+    seen.add(id);
+  }
+  return [...duplicates];
+}
+
+// src/url.ts
+var DEFAULT_PROTOCOLS = ["http", "https", "mailto", "tel"];
+var INVISIBLE = /[\u0000-\u0020\u007f-\u00a0\u1680\u180e\u2000-\u200f\u2028-\u202f\u205f-\u2064\u3000\ufeff]/g;
+var SCHEME = /^([a-z][a-z0-9+.-]*):/i;
+var DATA_IMAGE = /^data:image\/[a-z0-9.+-]+(?:;[a-z0-9=.+-]+)*,/i;
+function sanitizeUrl(input, options = {}) {
+  if (typeof input !== "string") return null;
+  const trimmed = input.trim();
+  if (trimmed === "") return null;
+  const compact = trimmed.replace(INVISIBLE, "");
+  const scheme = SCHEME.exec(compact);
+  if (scheme === null) {
+    return trimmed;
+  }
+  const protocol = (scheme[1] ?? "").toLowerCase();
+  if (protocol === "data") {
+    return options.allowDataImage === true && DATA_IMAGE.test(compact) ? trimmed : null;
+  }
+  const allowed = options.allowedProtocols ?? DEFAULT_PROTOCOLS;
+  return allowed.includes(protocol) ? trimmed : null;
+}
+function isSafeUrl(input, options) {
+  return sanitizeUrl(input, options) !== null;
+}
+function sanitizeMediaUrl(input) {
+  return sanitizeUrl(input, { allowDataImage: true });
+}
+var DOMAIN_LIKE = /^(?:[a-z0-9-]+\.)+[a-z]{2,}(?::\d+)?(?:[/?#]|$)/i;
+var EMAIL_LIKE = /^[^\s@/:]+@[^\s@/:]+\.[^\s@/:]+$/;
+function normalizeUrlInput(input) {
+  const trimmed = input.trim();
+  if (trimmed === "") return "";
+  if (EMAIL_LIKE.test(trimmed)) return `mailto:${trimmed}`;
+  if (DOMAIN_LIKE.test(trimmed)) return `https://${trimmed}`;
+  return trimmed;
+}
+
+// src/tokens.ts
+var TEXT_COLOR_TOKENS = [
+  "color.text.secondary",
+  "color.text.link",
+  "color.accent.default",
+  "color.status.success.foreground",
+  "color.status.warning.foreground",
+  "color.status.danger.foreground",
+  "color.status.info.foreground",
+  "color.chart.categorical.4"
+];
+var HIGHLIGHT_TOKENS = [
+  "color.highlight",
+  "color.accent.subtle",
+  "color.status.success.background",
+  "color.status.warning.background",
+  "color.status.danger.background",
+  "color.status.info.background"
+];
+var textColorSet = new Set(TEXT_COLOR_TOKENS);
+var highlightSet = new Set(HIGHLIGHT_TOKENS);
+function isTextColorToken(token) {
+  return typeof token === "string" && textColorSet.has(token);
+}
+function isHighlightToken(token) {
+  return typeof token === "string" && highlightSet.has(token);
+}
+var toKebab = (segment) => segment.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+function tokenToCssVarName(token) {
+  return `--kit-${token.split(".").map(toKebab).join("-")}`;
+}
+function textColorToCss(token) {
+  return isTextColorToken(token) ? `var(${tokenToCssVarName(token)})` : null;
+}
+function highlightToCss(token) {
+  return isHighlightToken(token) ? `var(${tokenToCssVarName(token)})` : null;
+}
+
+// src/tiptap-json.ts
+var TIPTAP_NODES = {
+  doc: "doc",
+  text: "text",
+  paragraph: "paragraph",
+  heading: "heading",
+  blockquote: "blockquote",
+  callout: "callout",
+  toggle: "toggle",
+  toggleSummary: "toggleSummary",
+  horizontalRule: "horizontalRule",
+  bulletList: "bulletList",
+  orderedList: "orderedList",
+  listItem: "listItem",
+  taskList: "taskList",
+  taskItem: "taskItem",
+  codeBlock: "codeBlock",
+  equation: "equation",
+  table: "table",
+  tableRow: "tableRow",
+  tableCell: "tableCell",
+  tableHeader: "tableHeader",
+  image: "image",
+  media: "media",
+  file: "file",
+  bookmark: "bookmark",
+  columns: "columns",
+  column: "column",
+  pageBreak: "pageBreak",
+  tableOfContents: "tableOfContents",
+  chart: "chart",
+  diagram: "diagram",
+  dataView: "dataView",
+  aiBlock: "aiBlock",
+  unknownBlock: "unknownBlock",
+  hardBreak: "hardBreak",
+  mention: "mention",
+  emoji: "emoji"
+};
+var TIPTAP_MARKS = {
+  bold: "bold",
+  italic: "italic",
+  underline: "underline",
+  strike: "strike",
+  code: "code",
+  link: "link",
+  color: "color",
+  highlight: "highlight"
+};
+var BLOCK_ID_NODES = [
+  TIPTAP_NODES.paragraph,
+  TIPTAP_NODES.heading,
+  TIPTAP_NODES.blockquote,
+  TIPTAP_NODES.callout,
+  TIPTAP_NODES.toggle,
+  TIPTAP_NODES.horizontalRule,
+  TIPTAP_NODES.bulletList,
+  TIPTAP_NODES.orderedList,
+  TIPTAP_NODES.taskList,
+  TIPTAP_NODES.codeBlock,
+  TIPTAP_NODES.equation,
+  TIPTAP_NODES.table,
+  TIPTAP_NODES.image,
+  TIPTAP_NODES.media,
+  TIPTAP_NODES.file,
+  TIPTAP_NODES.bookmark,
+  TIPTAP_NODES.columns,
+  TIPTAP_NODES.pageBreak,
+  TIPTAP_NODES.tableOfContents,
+  TIPTAP_NODES.chart,
+  TIPTAP_NODES.diagram,
+  TIPTAP_NODES.dataView,
+  TIPTAP_NODES.aiBlock,
+  TIPTAP_NODES.unknownBlock,
+  TIPTAP_NODES.listItem,
+  TIPTAP_NODES.taskItem
+];
+
+// src/convert.ts
+function createContext(options) {
+  return {
+    warnings: options?.warnings,
+    generateId: options?.generateId ?? generateBlockId,
+    seenIds: /* @__PURE__ */ new Set()
+  };
+}
+function warn(ctx, code, message, extra = {}) {
+  if (!ctx.warnings) return;
+  const warning = { code, message };
+  if (extra.blockId !== void 0) warning.blockId = extra.blockId;
+  if (extra.nodeType !== void 0) warning.nodeType = extra.nodeType;
+  ctx.warnings.push(warning);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function safeUrl(value, ctx, media) {
+  const url = str(value);
+  if (url === "") return "";
+  const safe = media ? sanitizeMediaUrl(url) : sanitizeUrl(url);
+  if (safe === null) {
+    warn(ctx, "invalid-value", "An unsafe URL was replaced by an empty value.");
+    return "";
+  }
+  return url;
+}
+function optionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function nullable(value) {
+  return value === void 0 ? null : value;
+}
+function node(type, attrs2, content) {
+  const result = { type };
+  if (attrs2 !== void 0) result.attrs = attrs2;
+  if (content !== void 0 && content.length > 0) result.content = content;
+  return result;
+}
+var markOrder = new Map(MARK_TYPES.map((type, index) => [type, index]));
+function markToTiptap(mark, ctx) {
+  switch (mark.type) {
+    case "bold":
+    case "italic":
+    case "underline":
+    case "strike":
+    case "code":
+      return { type: mark.type };
+    case "link":
+      if (typeof mark.href !== "string" || mark.href === "") {
+        warn(ctx, "invalid-mark", "A link mark without an href was dropped.", { nodeType: "link" });
+        return null;
+      }
+      if (sanitizeUrl(mark.href) === null) {
+        warn(ctx, "invalid-mark", "A link with an unsafe URL was dropped.", { nodeType: "link" });
+        return null;
+      }
+      return { type: TIPTAP_MARKS.link, attrs: { href: mark.href } };
+    case "color":
+    case "highlight":
+      if (typeof mark.token !== "string" || mark.token === "") {
+        warn(ctx, "invalid-mark", `A ${mark.type} mark without a token was dropped.`, { nodeType: mark.type });
+        return null;
+      }
+      return { type: mark.type, attrs: { token: mark.token } };
+    default: {
+      const unknown = mark;
+      warn(ctx, "unknown-mark", `The mark "${String(unknown.type)}" is not supported and was dropped.`, {
+        nodeType: String(unknown.type)
+      });
+      return null;
+    }
+  }
+}
+function sortMarks(marks) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = marks.filter((mark) => {
+    if (seen.has(mark.type)) return false;
+    seen.add(mark.type);
+    return true;
+  });
+  return unique.map((mark, index) => ({ mark, index })).sort((a, b) => (markOrder.get(a.mark.type) ?? 99) - (markOrder.get(b.mark.type) ?? 99) || a.index - b.index).map((entry) => entry.mark);
+}
+function marksToTiptap(marks, ctx) {
+  if (!marks || marks.length === 0) return void 0;
+  const converted = [];
+  for (const mark of marks) {
+    const result = markToTiptap(mark, ctx);
+    if (result) converted.push(result);
+  }
+  const sorted = sortMarks(converted);
+  return sorted.length > 0 ? sorted : void 0;
+}
+function withMarks(base, marks) {
+  if (marks) base.marks = marks.map((mark) => ({ ...mark, ...mark.attrs ? { attrs: { ...mark.attrs } } : {} }));
+  return base;
+}
+function inlineToTiptap(inline, ctx) {
+  const out = [];
+  for (const item of inline ?? []) {
+    if (!isRecord(item)) continue;
+    switch (item.type) {
+      case "text": {
+        const marks = marksToTiptap(item.marks, ctx);
+        const parts = str(item.text).split("\n");
+        parts.forEach((part, index) => {
+          if (index > 0) out.push(withMarks({ type: TIPTAP_NODES.hardBreak }, marks));
+          if (part !== "") out.push(withMarks({ type: TIPTAP_NODES.text, text: part }, marks));
+        });
+        break;
+      }
+      case "mention":
+        out.push({
+          type: TIPTAP_NODES.mention,
+          attrs: { kind: str(item.kind, "person"), id: str(item.id), label: str(item.label) }
+        });
+        break;
+      case "emoji":
+        out.push({ type: TIPTAP_NODES.emoji, attrs: { shortcode: str(item.shortcode) } });
+        break;
+      default:
+        warn(ctx, "unknown-inline", `The inline node "${String(item.type)}" was dropped.`);
+    }
+  }
+  return out;
+}
+function marksFromTiptap(marks, ctx) {
+  if (!marks || marks.length === 0) return [];
+  const converted = [];
+  for (const mark of marks) {
+    if (!isRecord(mark)) continue;
+    switch (mark.type) {
+      case "bold":
+      case "italic":
+      case "underline":
+      case "strike":
+      case "code":
+        converted.push({ type: mark.type });
+        break;
+      case "link": {
+        const href = optionalString(mark.attrs?.href);
+        if (href === void 0 || href === "") {
+          warn(ctx, "invalid-mark", "A link mark without an href was dropped.", { nodeType: "link" });
+        } else if (sanitizeUrl(href) === null) {
+          warn(ctx, "invalid-mark", "A link with an unsafe URL was dropped.", { nodeType: "link" });
+        } else {
+          converted.push({ type: "link", attrs: { href } });
+        }
+        break;
+      }
+      case "color":
+      case "highlight": {
+        const token = optionalString(mark.attrs?.token);
+        if (token === void 0 || token === "") {
+          warn(ctx, "invalid-mark", `A ${mark.type} mark without a token path was dropped.`, { nodeType: mark.type });
+        } else {
+          converted.push({ type: mark.type, attrs: { token } });
+        }
+        break;
+      }
+      default:
+        warn(ctx, "unknown-mark", `The mark "${String(mark.type)}" is not supported and was dropped.`, {
+          nodeType: String(mark.type)
+        });
+    }
+  }
+  return sortMarks(converted).map((mark) => {
+    switch (mark.type) {
+      case "link":
+        return { type: "link", href: str(mark.attrs?.href) };
+      case "color":
+        return { type: "color", token: str(mark.attrs?.token) };
+      case "highlight":
+        return { type: "highlight", token: str(mark.attrs?.token) };
+      default:
+        return { type: mark.type };
+    }
+  });
+}
+function marksEqual(a, b) {
+  const left = a ?? [];
+  if (left.length !== b.length) return false;
+  return left.every((mark, index) => JSON.stringify(mark) === JSON.stringify(b[index]));
+}
+var MENTION_KINDS = ["person", "page", "date"];
+function inlineFromTiptap(nodes, ctx) {
+  const out = [];
+  const pushText = (text, marks) => {
+    if (text === "") return;
+    const last = out[out.length - 1];
+    if (last && last.type === "text" && marksEqual(last.marks, marks)) {
+      last.text += text;
+    } else {
+      out.push(marks.length > 0 ? { type: "text", text, marks } : { type: "text", text });
+    }
+  };
+  for (const item of nodes ?? []) {
+    if (!isRecord(item)) continue;
+    switch (item.type) {
+      case TIPTAP_NODES.text:
+        pushText(str(item.text), marksFromTiptap(item.marks, ctx));
+        break;
+      case TIPTAP_NODES.hardBreak:
+        pushText("\n", marksFromTiptap(item.marks, ctx));
+        break;
+      case TIPTAP_NODES.mention: {
+        const kind = MENTION_KINDS.find((candidate) => candidate === item.attrs?.kind) ?? "person";
+        out.push({ type: "mention", kind, id: str(item.attrs?.id), label: str(item.attrs?.label) });
+        break;
+      }
+      case TIPTAP_NODES.emoji:
+        out.push({ type: "emoji", shortcode: str(item.attrs?.shortcode) });
+        break;
+      default:
+        warn(ctx, "unknown-inline", `The inline node "${item.type}" was dropped.`, { nodeType: item.type });
+        if (typeof item.text === "string") pushText(item.text, marksFromTiptap(item.marks, ctx));
+    }
+  }
+  return out;
+}
+function normalizeInline(inline) {
+  const ctx = createContext(void 0);
+  return inlineFromTiptap(inlineToTiptap(inline, ctx), ctx);
+}
+function joinInlines(parts) {
+  const joined = [];
+  parts.forEach((part, index) => {
+    if (index > 0) joined.push({ type: "text", text: "\n" });
+    joined.push(...part);
+  });
+  return joined;
+}
+function plainTextOf(tiptapNode) {
+  if (typeof tiptapNode.text === "string") return tiptapNode.text;
+  if (tiptapNode.type === TIPTAP_NODES.hardBreak) return "\n";
+  const children = tiptapNode.content ?? [];
+  const separator = children.some((child) => !(child.type === TIPTAP_NODES.text || child.type === TIPTAP_NODES.hardBreak)) ? "\n" : "";
+  return children.map(plainTextOf).join(separator);
+}
+var EMPTY_PARAGRAPH = () => ({ type: TIPTAP_NODES.paragraph });
+function paragraphOf(inline, ctx) {
+  return node(TIPTAP_NODES.paragraph, void 0, inlineToTiptap(inline, ctx));
+}
+function listItemToTiptap(item, listType, itemType, ctx) {
+  const attrs2 = { id: item.id };
+  if (itemType === TIPTAP_NODES.taskItem) attrs2.checked = item.checked === true;
+  const content = [paragraphOf(item.content, ctx)];
+  if (item.children && item.children.length > 0) {
+    content.push(
+      node(
+        listType,
+        void 0,
+        item.children.map((child) => listItemToTiptap(child, listType, itemType, ctx))
+      )
+    );
+  }
+  return node(itemType, attrs2, content);
+}
+function listToTiptap(block, listType, itemType, ctx) {
+  const items = block.items && block.items.length > 0 ? block.items : [{ id: ctx.generateId(), content: [] }];
+  return node(
+    listType,
+    { id: block.id },
+    items.map((item) => listItemToTiptap(item, listType, itemType, ctx))
+  );
+}
+function blocksToTiptap(blocks, ctx) {
+  return (blocks ?? []).map((block) => blockToTiptap(block, ctx));
+}
+function blockToTiptap(block, ctx) {
+  const id = block.id;
+  switch (block.type) {
+    case "paragraph":
+      return node(TIPTAP_NODES.paragraph, { id }, inlineToTiptap(block.content, ctx));
+    case "heading":
+      return node(TIPTAP_NODES.heading, { id, level: block.level }, inlineToTiptap(block.content, ctx));
+    case "quote":
+      return node(TIPTAP_NODES.blockquote, { id }, [paragraphOf(block.content, ctx)]);
+    case "callout":
+      return node(TIPTAP_NODES.callout, { id, variant: block.variant }, inlineToTiptap(block.content, ctx));
+    case "toggle":
+      return node(TIPTAP_NODES.toggle, { id }, [
+        node(TIPTAP_NODES.toggleSummary, void 0, inlineToTiptap(block.summary, ctx)),
+        ...blocksToTiptap(block.children, ctx)
+      ]);
+    case "divider":
+      return node(TIPTAP_NODES.horizontalRule, { id });
+    case "bulleted-list":
+      return listToTiptap(block, TIPTAP_NODES.bulletList, TIPTAP_NODES.listItem, ctx);
+    case "numbered-list":
+      return listToTiptap(block, TIPTAP_NODES.orderedList, TIPTAP_NODES.listItem, ctx);
+    case "task-list":
+      return listToTiptap(block, TIPTAP_NODES.taskList, TIPTAP_NODES.taskItem, ctx);
+    case "code":
+      return node(
+        TIPTAP_NODES.codeBlock,
+        { id, language: nullable(block.language) },
+        block.code ? [{ type: TIPTAP_NODES.text, text: block.code }] : []
+      );
+    case "equation":
+      return node(
+        TIPTAP_NODES.equation,
+        { id },
+        block.latex ? [{ type: TIPTAP_NODES.text, text: block.latex }] : []
+      );
+    case "table":
+      return tableToTiptap(block, ctx);
+    case "image":
+      return {
+        type: TIPTAP_NODES.image,
+        attrs: {
+          id,
+          src: block.src,
+          alt: block.alt ?? "",
+          caption: block.caption === void 0 ? null : normalizeInline(block.caption),
+          align: nullable(block.align),
+          width: nullable(block.width)
+        }
+      };
+    case "video":
+    case "audio":
+      return {
+        type: TIPTAP_NODES.media,
+        attrs: {
+          id,
+          kind: block.type,
+          src: block.src,
+          caption: block.caption === void 0 ? null : normalizeInline(block.caption)
+        }
+      };
+    case "file":
+      return { type: TIPTAP_NODES.file, attrs: { id, src: block.src, name: block.name, size: nullable(block.size) } };
+    case "bookmark":
+      return {
+        type: TIPTAP_NODES.bookmark,
+        attrs: { id, url: block.url, title: nullable(block.title), description: nullable(block.description) }
+      };
+    case "columns": {
+      const columns = block.columns && block.columns.length > 0 ? block.columns : [[]];
+      return node(
+        TIPTAP_NODES.columns,
+        { id },
+        columns.map((column) => {
+          const content = blocksToTiptap(column, ctx);
+          return node(TIPTAP_NODES.column, void 0, content.length > 0 ? content : [EMPTY_PARAGRAPH()]);
+        })
+      );
+    }
+    case "page-break":
+      return { type: TIPTAP_NODES.pageBreak, attrs: { id } };
+    case "table-of-contents":
+      return { type: TIPTAP_NODES.tableOfContents, attrs: { id } };
+    case "chart":
+      return { type: TIPTAP_NODES.chart, attrs: { id, spec: cloneJson(block.spec) } };
+    case "diagram":
+      return {
+        type: TIPTAP_NODES.diagram,
+        attrs: {
+          id,
+          engine: block.engine,
+          diagram: block.diagram === void 0 ? null : cloneJson(block.diagram),
+          source: nullable(block.source)
+        }
+      };
+    case "data-view":
+      return { type: TIPTAP_NODES.dataView, attrs: { id, dataset: block.dataset, view: cloneJson(block.view) } };
+    case "ai":
+      return {
+        type: TIPTAP_NODES.aiBlock,
+        attrs: { id, prompt: block.prompt, result: block.result === void 0 ? null : cloneJson(block.result) }
+      };
+    default: {
+      const unknown = block;
+      const blockType = String(unknown.type);
+      const blockId = optionalString(unknown.id);
+      warn(ctx, "unknown-block", `The block type "${blockType}" is not supported; it is kept as an opaque block.`, {
+        blockId,
+        nodeType: blockType
+      });
+      return {
+        type: TIPTAP_NODES.unknownBlock,
+        attrs: { id: nullable(blockId), blockType, payload: cloneJson(unknown) }
+      };
+    }
+  }
+}
+function tableToTiptap(block, ctx) {
+  const rows = block.rows && block.rows.length > 0 ? block.rows : [[{ content: [] }]];
+  const headerRow = block.headerRow;
+  const headerColumn = block.headerColumn;
+  return node(
+    TIPTAP_NODES.table,
+    { id: block.id, headerRow: nullable(headerRow), headerColumn: nullable(headerColumn) },
+    rows.map(
+      (row, rowIndex) => node(
+        TIPTAP_NODES.tableRow,
+        void 0,
+        row.map((cell, columnIndex) => {
+          const isHeader = cell.header === true || headerRow === true && rowIndex === 0 || headerColumn === true && columnIndex === 0;
+          return node(
+            isHeader ? TIPTAP_NODES.tableHeader : TIPTAP_NODES.tableCell,
+            { colspan: cell.colSpan ?? 1, rowspan: cell.rowSpan ?? 1, colwidth: null },
+            [paragraphOf(cell.content, ctx)]
+          );
+        })
+      )
+    )
+  );
+}
+function readId(source, ctx) {
+  const candidate = source.attrs?.id;
+  let id = typeof candidate === "string" && candidate !== "" ? candidate : "";
+  if (id !== "" && ctx.seenIds.has(id)) {
+    warn(ctx, "duplicate-id", `The id "${id}" was used twice; the second block got a new id.`, {
+      blockId: id,
+      nodeType: source.type
+    });
+    id = "";
+  }
+  if (id === "") {
+    do {
+      id = ctx.generateId();
+    } while (ctx.seenIds.has(id));
+  }
+  ctx.seenIds.add(id);
+  return id;
+}
+function inlineOfTextblock(textblock, ctx) {
+  return inlineFromTiptap(textblock.content, ctx);
+}
+function inlineOfContainer(container, ctx, extraBlocks) {
+  const runs = [];
+  for (const child of container.content ?? []) {
+    if (child.type === TIPTAP_NODES.paragraph || child.type === TIPTAP_NODES.heading) {
+      runs.push(inlineOfTextblock(child, ctx));
+    } else if (extraBlocks) {
+      blockFromTiptap(child, ctx, extraBlocks);
+    } else {
+      const text = plainTextOf(child);
+      warn(ctx, "lossy", `A "${child.type}" inside a ${container.type} was reduced to plain text.`, {
+        nodeType: child.type
+      });
+      if (text !== "") runs.push([{ type: "text", text }]);
+    }
+  }
+  return normalizeInline(joinInlines(runs));
+}
+function listItemFromTiptap(source, parentListType, isTask, ctx) {
+  const id = readId(source, ctx);
+  const runs = [];
+  const children = [];
+  for (const child of source.content ?? []) {
+    if (child.type === TIPTAP_NODES.paragraph) {
+      runs.push(inlineOfTextblock(child, ctx));
+    } else if (child.type === TIPTAP_NODES.bulletList || child.type === TIPTAP_NODES.orderedList || child.type === TIPTAP_NODES.taskList) {
+      if (child.type !== parentListType) {
+        warn(ctx, "lossy", `A nested ${child.type} inside a ${parentListType} took the type of its parent list.`, {
+          nodeType: child.type
+        });
+      }
+      for (const nested of child.content ?? []) {
+        if (nested.type === TIPTAP_NODES.listItem || nested.type === TIPTAP_NODES.taskItem) {
+          children.push(listItemFromTiptap(nested, parentListType, isTask, ctx));
+        }
+      }
+    } else {
+      const text = plainTextOf(child);
+      warn(ctx, "lossy", `A "${child.type}" inside a list item was reduced to plain text.`, { nodeType: child.type });
+      if (text !== "") runs.push([{ type: "text", text }]);
+    }
+  }
+  const content = normalizeInline(joinInlines(runs));
+  const result = isTask ? { id, content, checked: source.attrs?.checked === true } : { id, content };
+  if (children.length > 0) result.children = children;
+  return result;
+}
+function listFromTiptap(source, type, ctx) {
+  const id = readId(source, ctx);
+  const isTask = type === "task-list";
+  const items = [];
+  for (const child of source.content ?? []) {
+    if (child.type === TIPTAP_NODES.listItem || child.type === TIPTAP_NODES.taskItem) {
+      items.push(listItemFromTiptap(child, source.type, isTask, ctx));
+    }
+  }
+  return { id, type, items };
+}
+var HEADER_ATTR_VALUES = [true, false];
+function readHint(value) {
+  return HEADER_ATTR_VALUES.find((candidate) => candidate === value) ?? null;
+}
+function resolveHeaderFlag(hint, allHeader, ambiguous) {
+  if (hint === true) return allHeader;
+  if (hint === false) return false;
+  return allHeader && !ambiguous ? true : void 0;
+}
+function tableFromTiptap(source, ctx) {
+  const id = readId(source, ctx);
+  const rowNodes = (source.content ?? []).filter((row) => row.type === TIPTAP_NODES.tableRow);
+  const grid = rowNodes.map(
+    (row) => (row.content ?? []).filter(
+      (cell) => cell.type === TIPTAP_NODES.tableCell || cell.type === TIPTAP_NODES.tableHeader
+    )
+  );
+  const isHeader = (cell) => cell.type === TIPTAP_NODES.tableHeader;
+  const firstRow = grid[0] ?? [];
+  const rowAll = firstRow.length > 0 && firstRow.every(isHeader);
+  const columnAll = grid.length > 0 && grid.every((row) => row.length > 0 && isHeader(row[0]));
+  const headerRow = resolveHeaderFlag(
+    readHint(source.attrs?.headerRow),
+    rowAll,
+    firstRow.length === 1 && columnAll
+  );
+  const headerColumn = resolveHeaderFlag(
+    readHint(source.attrs?.headerColumn),
+    columnAll,
+    grid.length === 1 && rowAll
+  );
+  const rows = grid.map(
+    (row, rowIndex) => row.map((cellNode, columnIndex) => {
+      const cell = { content: inlineOfContainer(cellNode, ctx) };
+      const colSpan = optionalNumber(cellNode.attrs?.colspan);
+      const rowSpan = optionalNumber(cellNode.attrs?.rowspan);
+      if (colSpan !== void 0 && colSpan > 1) cell.colSpan = colSpan;
+      if (rowSpan !== void 0 && rowSpan > 1) cell.rowSpan = rowSpan;
+      const coveredByRow = headerRow === true && rowIndex === 0;
+      const coveredByColumn = headerColumn === true && columnIndex === 0;
+      if (isHeader(cellNode) && !coveredByRow && !coveredByColumn) cell.header = true;
+      return cell;
+    })
+  );
+  if (rows.length === 0) rows.push([{ content: [] }]);
+  const block = { id, type: "table", rows };
+  if (headerRow !== void 0) block.headerRow = headerRow;
+  if (headerColumn !== void 0) block.headerColumn = headerColumn;
+  return block;
+}
+function codeTextOf(source) {
+  return (source.content ?? []).map((child) => child.type === TIPTAP_NODES.hardBreak ? "\n" : str(child.text)).join("");
+}
+function captionOf(value, ctx) {
+  if (!Array.isArray(value)) return void 0;
+  const inline = inlineFromTiptap(inlineToTiptap(value, ctx), ctx);
+  return inline;
+}
+var ALIGNMENTS = ["start", "center", "end"];
+var DIAGRAM_ENGINES = ["mermaid", "canvas", "excalidraw"];
+function blockFromTiptap(source, ctx, out) {
+  if (!isRecord(source)) return;
+  switch (source.type) {
+    case TIPTAP_NODES.paragraph:
+      out.push({ id: readId(source, ctx), type: "paragraph", content: inlineOfTextblock(source, ctx) });
+      return;
+    case TIPTAP_NODES.heading: {
+      const id = readId(source, ctx);
+      const raw = optionalNumber(source.attrs?.level) ?? 1;
+      const level = Math.min(4, Math.max(1, Math.round(raw)));
+      if (level !== raw) {
+        warn(ctx, "invalid-value", `Heading level ${raw} was clamped to ${level}.`, { blockId: id, nodeType: "heading" });
+      }
+      out.push({ id, type: "heading", level, content: inlineOfTextblock(source, ctx) });
+      return;
+    }
+    case TIPTAP_NODES.blockquote: {
+      const id = readId(source, ctx);
+      const trailing = [];
+      const content = inlineOfContainer(source, ctx, trailing);
+      const hasText = (source.content ?? []).some(
+        (child) => child.type === TIPTAP_NODES.paragraph || child.type === TIPTAP_NODES.heading
+      );
+      if (hasText || trailing.length === 0) out.push({ id, type: "quote", content });
+      out.push(...trailing);
+      return;
+    }
+    case TIPTAP_NODES.callout: {
+      const id = readId(source, ctx);
+      const raw = source.attrs?.variant;
+      const variant = CALLOUT_VARIANTS.find((candidate) => candidate === raw) ?? "info";
+      if (variant !== raw) {
+        warn(ctx, "invalid-value", `Callout variant "${String(raw)}" became "info".`, { blockId: id, nodeType: "callout" });
+      }
+      out.push({ id, type: "callout", variant, content: inlineOfTextblock(source, ctx) });
+      return;
+    }
+    case TIPTAP_NODES.toggle: {
+      const id = readId(source, ctx);
+      const [first, ...rest] = source.content ?? [];
+      const hasSummary = first?.type === TIPTAP_NODES.toggleSummary;
+      const children = [];
+      for (const child of hasSummary ? rest : source.content ?? []) blockFromTiptap(child, ctx, children);
+      out.push({
+        id,
+        type: "toggle",
+        summary: hasSummary && first ? inlineOfTextblock(first, ctx) : [],
+        children
+      });
+      return;
+    }
+    case TIPTAP_NODES.horizontalRule:
+      out.push({ id: readId(source, ctx), type: "divider" });
+      return;
+    case TIPTAP_NODES.bulletList:
+      out.push(listFromTiptap(source, "bulleted-list", ctx));
+      return;
+    case TIPTAP_NODES.orderedList:
+      out.push(listFromTiptap(source, "numbered-list", ctx));
+      return;
+    case TIPTAP_NODES.taskList:
+      out.push(listFromTiptap(source, "task-list", ctx));
+      return;
+    case TIPTAP_NODES.codeBlock: {
+      const block = {
+        id: readId(source, ctx),
+        type: "code",
+        code: codeTextOf(source)
+      };
+      const language = optionalString(source.attrs?.language);
+      if (language !== void 0) block.language = language;
+      out.push(block);
+      return;
+    }
+    case TIPTAP_NODES.equation:
+      out.push({ id: readId(source, ctx), type: "equation", latex: codeTextOf(source) });
+      return;
+    case TIPTAP_NODES.table:
+      out.push(tableFromTiptap(source, ctx));
+      return;
+    case TIPTAP_NODES.image: {
+      const block = {
+        id: readId(source, ctx),
+        type: "image",
+        src: safeUrl(source.attrs?.src, ctx, true),
+        alt: str(source.attrs?.alt)
+      };
+      const caption = captionOf(source.attrs?.caption, ctx);
+      if (caption !== void 0) block.caption = caption;
+      const align = ALIGNMENTS.find((candidate) => candidate === source.attrs?.align);
+      if (align !== void 0) block.align = align;
+      const width = optionalNumber(source.attrs?.width);
+      if (width !== void 0) block.width = width;
+      out.push(block);
+      return;
+    }
+    case TIPTAP_NODES.media: {
+      const block = {
+        id: readId(source, ctx),
+        type: source.attrs?.kind === "audio" ? "audio" : "video",
+        src: safeUrl(source.attrs?.src, ctx, true)
+      };
+      const caption = captionOf(source.attrs?.caption, ctx);
+      if (caption !== void 0) block.caption = caption;
+      out.push(block);
+      return;
+    }
+    case TIPTAP_NODES.file: {
+      const block = {
+        id: readId(source, ctx),
+        type: "file",
+        src: safeUrl(source.attrs?.src, ctx, false),
+        name: str(source.attrs?.name)
+      };
+      const size = optionalNumber(source.attrs?.size);
+      if (size !== void 0) block.size = size;
+      out.push(block);
+      return;
+    }
+    case TIPTAP_NODES.bookmark: {
+      const block = {
+        id: readId(source, ctx),
+        type: "bookmark",
+        url: safeUrl(source.attrs?.url, ctx, false)
+      };
+      const title = optionalString(source.attrs?.title);
+      const description = optionalString(source.attrs?.description);
+      if (title !== void 0) block.title = title;
+      if (description !== void 0) block.description = description;
+      out.push(block);
+      return;
+    }
+    case TIPTAP_NODES.columns: {
+      const id = readId(source, ctx);
+      const columns = [];
+      for (const column of source.content ?? []) {
+        if (column.type !== TIPTAP_NODES.column) continue;
+        const blocks = [];
+        for (const child of column.content ?? []) blockFromTiptap(child, ctx, blocks);
+        columns.push(blocks);
+      }
+      out.push({ id, type: "columns", columns });
+      return;
+    }
+    case TIPTAP_NODES.pageBreak:
+      out.push({ id: readId(source, ctx), type: "page-break" });
+      return;
+    case TIPTAP_NODES.tableOfContents:
+      out.push({ id: readId(source, ctx), type: "table-of-contents" });
+      return;
+    case TIPTAP_NODES.chart:
+      out.push({
+        id: readId(source, ctx),
+        type: "chart",
+        spec: cloneJson(source.attrs?.spec)
+      });
+      return;
+    case TIPTAP_NODES.diagram: {
+      const block = {
+        id: readId(source, ctx),
+        type: "diagram",
+        engine: DIAGRAM_ENGINES.find((candidate) => candidate === source.attrs?.engine) ?? "mermaid"
+      };
+      if (isRecord(source.attrs?.diagram)) block.diagram = cloneJson(source.attrs?.diagram);
+      const diagramSource = optionalString(source.attrs?.source);
+      if (diagramSource !== void 0) block.source = diagramSource;
+      out.push(block);
+      return;
+    }
+    case TIPTAP_NODES.dataView:
+      out.push({
+        id: readId(source, ctx),
+        type: "data-view",
+        dataset: str(source.attrs?.dataset),
+        view: cloneJson(source.attrs?.view)
+      });
+      return;
+    case TIPTAP_NODES.aiBlock: {
+      const block = {
+        id: readId(source, ctx),
+        type: "ai",
+        prompt: str(source.attrs?.prompt)
+      };
+      if (Array.isArray(source.attrs?.result)) block.result = cloneJson(source.attrs?.result);
+      out.push(block);
+      return;
+    }
+    case TIPTAP_NODES.unknownBlock: {
+      const payload = source.attrs?.payload;
+      if (isRecord(payload)) {
+        const copy = cloneJson(payload);
+        const id = optionalString(copy.id) ?? optionalString(source.attrs?.id) ?? ctx.generateId();
+        copy.id = id;
+        ctx.seenIds.add(id);
+        warn(ctx, "unknown-block", `The block type "${String(copy.type)}" is not supported; it was kept as is.`, {
+          blockId: id,
+          nodeType: String(copy.type)
+        });
+        out.push(copy);
+      }
+      return;
+    }
+    case TIPTAP_NODES.text:
+    case TIPTAP_NODES.hardBreak:
+    case TIPTAP_NODES.mention:
+    case TIPTAP_NODES.emoji:
+      out.push({ id: ctx.generateId(), type: "paragraph", content: inlineFromTiptap([source], ctx) });
+      return;
+    default: {
+      const children = source.content ?? [];
+      const hasInlineOnly = children.length > 0 && children.every(
+        (child) => child.type === TIPTAP_NODES.text || child.type === TIPTAP_NODES.hardBreak || child.type === TIPTAP_NODES.mention || child.type === TIPTAP_NODES.emoji
+      );
+      warn(ctx, "unknown-node", `The node "${source.type}" is not supported and was converted to plain blocks.`, {
+        nodeType: source.type
+      });
+      if (hasInlineOnly) {
+        out.push({ id: readId(source, ctx), type: "paragraph", content: inlineOfTextblock(source, ctx) });
+      } else {
+        for (const child of children) blockFromTiptap(child, ctx, out);
+      }
+    }
+  }
+}
+function documentToTiptap(doc, options) {
+  const ctx = createContext(options);
+  const content = blocksToTiptap(doc.blocks, ctx);
+  const result = {
+    type: "doc",
+    content: content.length > 0 ? content : [{ type: TIPTAP_NODES.paragraph, attrs: { id: ctx.generateId() } }]
+  };
+  if (doc.title !== void 0) result.attrs = { title: doc.title };
+  return result;
+}
+function tiptapToDocument(json, options) {
+  const ctx = createContext(options);
+  const blocks = [];
+  const top = json.type === "doc" ? json.content ?? [] : [json];
+  for (const child of top) blockFromTiptap(child, ctx, blocks);
+  const doc = { version: DOCUMENT_VERSION, blocks };
+  const title = optionalString(json.attrs?.title);
+  if (title !== void 0) doc.title = title;
+  return doc;
+}
+function normalizeDocument(doc, options) {
+  const ctx = { ...options };
+  return tiptapToDocument(documentToTiptap(doc, ctx), ctx);
+}
+
+// src/emoji.ts
+var EMOJI_SHORTCODES = {
+  smile: "\u{1F604}",
+  grin: "\u{1F601}",
+  joy: "\u{1F602}",
+  wink: "\u{1F609}",
+  heart: "\u2764\uFE0F",
+  thumbsup: "\u{1F44D}",
+  "+1": "\u{1F44D}",
+  thumbsdown: "\u{1F44E}",
+  "-1": "\u{1F44E}",
+  clap: "\u{1F44F}",
+  pray: "\u{1F64F}",
+  fire: "\u{1F525}",
+  rocket: "\u{1F680}",
+  tada: "\u{1F389}",
+  eyes: "\u{1F440}",
+  thinking: "\u{1F914}",
+  sparkles: "\u2728",
+  star: "\u2B50",
+  warning: "\u26A0\uFE0F",
+  check: "\u2705",
+  white_check_mark: "\u2705",
+  x: "\u274C",
+  bulb: "\u{1F4A1}",
+  memo: "\u{1F4DD}",
+  book: "\u{1F4D6}",
+  calendar: "\u{1F4C5}",
+  lock: "\u{1F512}",
+  link: "\u{1F517}",
+  pushpin: "\u{1F4CC}",
+  hourglass: "\u231B",
+  zap: "\u26A1",
+  bug: "\u{1F41B}",
+  wave: "\u{1F44B}",
+  muscle: "\u{1F4AA}",
+  ok_hand: "\u{1F44C}",
+  coffee: "\u2615",
+  sunny: "\u2600\uFE0F",
+  question: "\u2753",
+  exclamation: "\u2757"
+};
+function emojiForShortcode(shortcode) {
+  const key = shortcode.replace(/^:|:$/g, "").toLowerCase();
+  return EMOJI_SHORTCODES[key] ?? null;
+}
+function emojiToText(shortcode) {
+  return emojiForShortcode(shortcode) ?? `:${shortcode.replace(/^:|:$/g, "")}:`;
+}
+
+// src/text.ts
+function inlineToPlainText(inline) {
+  let text = "";
+  for (const node2 of inline ?? []) {
+    if (node2.type === "text") text += node2.text;
+    else if (node2.type === "mention") text += `@${node2.label}`;
+    else if (node2.type === "emoji") text += emojiToText(node2.shortcode);
+  }
+  return text;
+}
+function indent(depth) {
+  return "  ".repeat(depth);
+}
+function listLines(items, kind, markers, depth) {
+  const lines = [];
+  items.forEach((item, index) => {
+    let marker = "";
+    if (markers) {
+      if (kind === "bulleted") marker = "- ";
+      else if (kind === "numbered") marker = `${index + 1}. `;
+      else marker = `[${item.checked ? "x" : " "}] `;
+    }
+    lines.push(`${markers ? indent(depth) : ""}${marker}${inlineToPlainText(item.content)}`);
+    if (item.children) lines.push(...listLines(item.children, kind, markers, depth + 1));
+  });
+  return lines;
+}
+function blockText(block, options) {
+  switch (block.type) {
+    case "paragraph":
+    case "heading":
+    case "quote":
+    case "callout":
+      return inlineToPlainText(block.content);
+    case "toggle": {
+      const parts = [inlineToPlainText(block.summary), ...blocksText(block.children ?? [], options)];
+      return parts.filter((part) => part !== "").join(options.blockSeparator);
+    }
+    case "divider":
+    case "page-break":
+    case "table-of-contents":
+      return "";
+    case "bulleted-list":
+      return listLines(block.items ?? [], "bulleted", options.markers, 0).join("\n");
+    case "numbered-list":
+      return listLines(block.items ?? [], "numbered", options.markers, 0).join("\n");
+    case "task-list":
+      return listLines(block.items ?? [], "task", options.markers, 0).join("\n");
+    case "code":
+      return block.code;
+    case "equation":
+      return block.latex;
+    case "table":
+      return (block.rows ?? []).map((row) => row.map((cell) => inlineToPlainText(cell.content)).join("	")).join("\n");
+    case "image":
+      return [block.alt, inlineToPlainText(block.caption)].filter((part) => part !== "").join("\n");
+    case "video":
+    case "audio":
+      return inlineToPlainText(block.caption);
+    case "file":
+      return block.name;
+    case "bookmark":
+      return [block.title, block.description, block.url].filter((part) => !!part).join("\n");
+    case "columns":
+      return (block.columns ?? []).flatMap((column) => blocksText(column, options)).join(options.blockSeparator);
+    case "chart":
+      return [block.spec?.title, block.spec?.subtitle].filter((part) => !!part).join("\n");
+    case "diagram":
+      return block.diagram?.title ?? block.source ?? "";
+    case "data-view":
+      return [block.view?.name, block.dataset].filter((part) => !!part).join("\n");
+    case "ai":
+      return [block.prompt, ...blocksText(block.result ?? [], options)].filter((part) => part !== "").join(options.blockSeparator);
+    default:
+      return "";
+  }
+}
+function blocksText(blocks, options) {
+  return blocks.map((block) => blockText(block, options)).filter((text) => text !== "");
+}
+function documentToPlainText(doc, options = {}) {
+  const resolved = {
+    blockSeparator: options.blockSeparator ?? "\n\n",
+    markers: options.markers ?? true
+  };
+  return blocksText(doc.blocks ?? [], resolved).join(resolved.blockSeparator);
+}
+function getSegmenter() {
+  return Intl.Segmenter;
+}
+function countWords(text, locale) {
+  if (text.trim() === "") return 0;
+  const Segmenter = getSegmenter();
+  if (Segmenter) {
+    const segmenter = new Segmenter(locale, { granularity: "word" });
+    let count = 0;
+    for (const part of segmenter.segment(text)) if (part.isWordLike) count += 1;
+    return count;
+  }
+  return text.trim().split(/\s+/).length;
+}
+function countCharacters(text, options = {}) {
+  const source = options.includeSpaces === false ? text.replace(/\s+/g, "") : text;
+  const Segmenter = getSegmenter();
+  if (Segmenter) {
+    let count = 0;
+    for (const _ of new Segmenter(void 0, { granularity: "grapheme" }).segment(source)) {
+      void _;
+      count += 1;
+    }
+    return count;
+  }
+  return [...source].length;
+}
+function getDocumentStats(doc, options = {}) {
+  const text = documentToPlainText(doc, { markers: false, blockSeparator: "\n" });
+  const words = countWords(text, options.locale);
+  return {
+    words,
+    characters: countCharacters(text.replace(/\n/g, " ")),
+    charactersNoSpaces: countCharacters(text, { includeSpaces: false }),
+    blocks: doc.blocks?.length ?? 0,
+    readingMinutes: words === 0 ? 0 : Math.max(1, Math.ceil(words / 200))
+  };
+}
+
+// src/outline.ts
+function getOutline(doc, options = {}) {
+  const items = [];
+  const maxLevel = options.maxLevel ?? 4;
+  walkBlocks(doc.blocks ?? [], (block) => {
+    if (block.type !== "heading" || block.level > maxLevel) return;
+    const text = inlineToPlainText(block.content).trim();
+    if (text === "" && options.includeEmpty !== true) return;
+    items.push({ id: block.id, level: block.level, text });
+  });
+  return items;
+}
+function buildOutlineTree(items) {
+  const roots = [];
+  const stack = [];
+  for (const item of items) {
+    const entry = { ...item, children: [] };
+    while (stack.length > 0 && stack[stack.length - 1].level >= entry.level) stack.pop();
+    const parent = stack[stack.length - 1];
+    if (parent) parent.children.push(entry);
+    else roots.push(entry);
+    stack.push(entry);
+  }
+  return roots;
+}
+function slugifyHeading(text) {
+  return text.normalize("NFKC").toLowerCase().replace(/[^\p{L}\p{N}\s-]+/gu, "").trim().replace(/[\s-]+/g, "-");
+}
+
+// src/html.ts
+var defaultExportLabels = {
+  tableOfContents: "Table of contents",
+  chart: "Chart",
+  diagram: "Diagram",
+  dataView: "Data view",
+  ai: "AI",
+  file: "File"
+};
+var ESCAPES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (char) => ESCAPES[char] ?? char);
+}
+function attrs(values) {
+  let out = "";
+  for (const [name, value] of Object.entries(values)) {
+    if (value === void 0 || value === null || value === false) continue;
+    out += value === true ? ` ${name}` : ` ${name}="${escapeHtml(String(value))}"`;
+  }
+  return out;
+}
+function safeToken(value) {
+  return value.replace(/[^a-zA-Z0-9_+.-]/g, "");
+}
+function applyMark(html, mark) {
+  switch (mark.type) {
+    case "bold":
+      return `<strong>${html}</strong>`;
+    case "italic":
+      return `<em>${html}</em>`;
+    case "underline":
+      return `<u>${html}</u>`;
+    case "strike":
+      return `<s>${html}</s>`;
+    case "code":
+      return `<code>${html}</code>`;
+    case "link": {
+      const href = sanitizeUrl(mark.href);
+      return href === null ? html : `<a${attrs({ href, rel: "noopener noreferrer" })}>${html}</a>`;
+    }
+    case "color": {
+      const css = textColorToCss(mark.token);
+      return css === null ? html : `<span${attrs({ "data-kit": "editor-text-color", "data-token": mark.token, style: `color: ${css}` })}>${html}</span>`;
+    }
+    case "highlight": {
+      const css = highlightToCss(mark.token);
+      return css === null ? html : `<mark${attrs({ "data-kit": "editor-highlight", "data-token": mark.token, style: `background-color: ${css}` })}>${html}</mark>`;
+    }
+    default:
+      return html;
+  }
+}
+var APPLY_ORDER = ["code", "strike", "underline", "italic", "bold", "highlight", "color", "link"];
+function renderInline(inline) {
+  let html = "";
+  for (const node2 of inline ?? []) {
+    if (node2.type === "text") {
+      let part = escapeHtml(node2.text).replace(/\n/g, "<br>");
+      const marks = node2.marks ?? [];
+      for (const type of APPLY_ORDER) {
+        const mark = marks.find((candidate) => candidate.type === type);
+        if (mark) part = applyMark(part, mark);
+      }
+      html += part;
+    } else if (node2.type === "mention") {
+      html += `<span${attrs({ "data-kit": "editor-mention", "data-kind": node2.kind, "data-id": node2.id })}>@${escapeHtml(node2.label)}</span>`;
+    } else if (node2.type === "emoji") {
+      html += `<span${attrs({ "data-kit": "editor-emoji", "data-shortcode": node2.shortcode })}>${escapeHtml(emojiToText(node2.shortcode))}</span>`;
+    }
+  }
+  return html;
+}
+function renderItems(items, kind, ctx) {
+  const tag = kind === "ol" ? "ol" : "ul";
+  const open = kind === "task" ? `<ul${attrs({ "data-kit": "editor-task-list" })}>` : `<${tag}>`;
+  let html = open;
+  for (const item of items) {
+    const nested = item.children && item.children.length > 0 ? renderItems(item.children, kind, ctx) : "";
+    if (kind === "task") {
+      const checked = item.checked === true;
+      const labelId = `${ctx.idPrefix}${item.id}-label`;
+      html += `<li${attrs({ "data-kit": "editor-task-item", "data-checked": checked ? "true" : "false" })}>`;
+      html += `<input${attrs({ type: "checkbox", disabled: true, checked, "aria-labelledby": labelId })}>`;
+      html += `<span${attrs({ id: labelId, dir: "auto" })}>${renderInline(item.content)}</span>${nested}</li>`;
+    } else {
+      html += `<li${attrs({ dir: "auto" })}>${renderInline(item.content)}${nested}</li>`;
+    }
+  }
+  return `${html}</${tag}>`;
+}
+function formatBytes(size, locale) {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = size;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  const formatted = new Intl.NumberFormat(locale, { maximumFractionDigits: unit === 0 ? 0 : 1 }).format(value);
+  return `${formatted} ${units[unit]}`;
+}
+function renderCaption(caption) {
+  return caption && caption.length > 0 ? `<figcaption dir="auto">${renderInline(caption)}</figcaption>` : "";
+}
+function renderOutline(nodes, ctx) {
+  if (nodes.length === 0) return "";
+  let html = "<ol>";
+  for (const node2 of nodes) {
+    html += `<li><a href="#${escapeHtml(ctx.idPrefix + node2.id)}">${escapeHtml(node2.text)}</a>${renderOutline(node2.children, ctx)}</li>`;
+  }
+  return `${html}</ol>`;
+}
+function renderEmbed(blockId, type, title, subtitle, label, body = "") {
+  const heading = `<figcaption><span data-kit="editor-embed-kind">${escapeHtml(label)}</span> ${escapeHtml(title)}${subtitle ? ` <small>${escapeHtml(subtitle)}</small>` : ""}</figcaption>`;
+  return `<figure${attrs({ "data-block-id": blockId, "data-kit": "editor-embed", "data-block-type": type, role: "group", "aria-label": title || label })}>${heading}${body}</figure>`;
+}
+function renderBlock(block, ctx) {
+  const id = attrs({ "data-block-id": block.id });
+  switch (block.type) {
+    case "paragraph":
+      return `<p${id}${attrs({ dir: "auto" })}>${renderInline(block.content)}</p>`;
+    case "heading": {
+      const level = Math.min(4, Math.max(1, Math.round(block.level)));
+      return `<h${level}${attrs({ id: ctx.idPrefix + block.id, dir: "auto" })}${id}>${renderInline(block.content)}</h${level}>`;
+    }
+    case "quote":
+      return `<blockquote${id}${attrs({ dir: "auto" })}>${renderInline(block.content)}</blockquote>`;
+    case "callout":
+      return `<div${id}${attrs({ "data-kit": "editor-callout", "data-variant": safeToken(block.variant), role: "note", dir: "auto" })}>${renderInline(block.content)}</div>`;
+    case "toggle":
+      return `<details${id}${attrs({ "data-kit": "editor-toggle" })}><summary${attrs({ dir: "auto" })}>${renderInline(block.summary)}</summary>${renderBlocks(block.children ?? [], ctx)}</details>`;
+    case "divider":
+      return `<hr${id}>`;
+    case "bulleted-list":
+      return renderListBlock(block, "ul", ctx);
+    case "numbered-list":
+      return renderListBlock(block, "ol", ctx);
+    case "task-list":
+      return renderListBlock(block, "task", ctx);
+    case "code": {
+      const language = block.language ? safeToken(block.language) : "";
+      return `<pre${id}${attrs({ "data-kit": "editor-code-block", "data-language": language || void 0, dir: "ltr" })}><code${attrs({ class: language ? `language-${language}` : void 0 })}>${escapeHtml(block.code)}</code></pre>`;
+    }
+    case "equation":
+      return `<pre${id}${attrs({ "data-kit": "editor-equation", dir: "ltr" })}><code>${escapeHtml(block.latex)}</code></pre>`;
+    case "table":
+      return renderTable(block);
+    case "image": {
+      const src = sanitizeMediaUrl(block.src);
+      const img = src === null ? "" : `<img${attrs({ src, alt: block.alt ?? "", loading: "lazy", decoding: "async", width: block.width })}>`;
+      return `<figure${id}${attrs({ "data-kit": "editor-image", "data-align": block.align })}>${img}${renderCaption(block.caption)}</figure>`;
+    }
+    case "video":
+    case "audio": {
+      const src = sanitizeMediaUrl(block.src);
+      const media = src === null ? "" : `<${block.type}${attrs({ src, controls: true, preload: "none" })}></${block.type}>`;
+      return `<figure${id}${attrs({ "data-kit": "editor-media", "data-kind": block.type })}>${media}${renderCaption(block.caption)}</figure>`;
+    }
+    case "file": {
+      const href = sanitizeUrl(block.src);
+      const name = escapeHtml(block.name);
+      const link = href === null ? name : `<a${attrs({ href, download: true, rel: "noopener noreferrer" })}>${name}</a>`;
+      const size = typeof block.size === "number" ? ` <span data-kit="editor-file-size">(${escapeHtml(formatBytes(block.size, ctx.locale))})</span>` : "";
+      return `<p${id}${attrs({ "data-kit": "editor-file", dir: "auto" })}>${link}${size}</p>`;
+    }
+    case "bookmark": {
+      const href = sanitizeUrl(block.url);
+      const title = block.title ? `<strong>${escapeHtml(block.title)}</strong>` : escapeHtml(block.url);
+      const description = block.description ? `<span>${escapeHtml(block.description)}</span>` : "";
+      const inner = `${title}${description}`;
+      return href === null ? `<div${id}${attrs({ "data-kit": "editor-bookmark" })}>${inner}</div>` : `<a${id}${attrs({ "data-kit": "editor-bookmark", href, rel: "noopener noreferrer" })}>${inner}</a>`;
+    }
+    case "columns": {
+      const columns = block.columns ?? [];
+      return `<div${id}${attrs({ "data-kit": "editor-columns", "data-count": columns.length })}>${columns.map((column) => `<div data-kit="editor-column">${renderBlocks(column, ctx)}</div>`).join("")}</div>`;
+    }
+    case "page-break":
+      return `<hr${id}${attrs({ "data-kit": "editor-page-break" })}>`;
+    case "table-of-contents":
+      return `<nav${id}${attrs({ "data-kit": "editor-toc", "aria-label": ctx.labels.tableOfContents })}>${renderOutline(ctx.outline, ctx)}</nav>`;
+    case "chart":
+      return renderEmbed(
+        block.id,
+        "chart",
+        block.spec?.title ?? "",
+        block.spec?.subtitle,
+        ctx.labels.chart,
+        block.spec?.a11y?.description ? `<p dir="auto">${escapeHtml(block.spec.a11y.description)}</p>` : ""
+      );
+    case "diagram": {
+      const title = block.diagram?.title ?? "";
+      const body = block.source ? `<pre dir="ltr"><code>${escapeHtml(block.source)}</code></pre>` : "";
+      return renderEmbed(block.id, "diagram", title, void 0, ctx.labels.diagram, body);
+    }
+    case "data-view":
+      return renderEmbed(block.id, "data-view", block.view?.name ?? block.dataset, block.view?.name ? block.dataset : void 0, ctx.labels.dataView);
+    case "ai":
+      return renderEmbed(block.id, "ai", block.prompt, void 0, ctx.labels.ai, renderBlocks(block.result ?? [], ctx));
+    default: {
+      const unknownType = String(block.type);
+      return `<div${id}${attrs({ "data-kit": "editor-unknown", "data-block-type": unknownType, hidden: true })}></div>`;
+    }
+  }
+}
+function renderListBlock(block, kind, ctx) {
+  const html = renderItems(block.items ?? [], kind, ctx);
+  return html.replace(/^<(ul|ol)/, `<$1${attrs({ "data-block-id": block.id })}`);
+}
+function renderTable(block) {
+  const rows = block.rows ?? [];
+  const renderRow = (row, rowIndex) => `<tr>${row.map((cell, columnIndex) => {
+    const header = cell.header === true || block.headerRow === true && rowIndex === 0 || block.headerColumn === true && columnIndex === 0;
+    const tag = header ? "th" : "td";
+    let scope;
+    if (header && block.headerRow === true && rowIndex === 0) scope = "col";
+    else if (header && block.headerColumn === true && columnIndex === 0) scope = "row";
+    return `<${tag}${attrs({
+      scope,
+      colspan: cell.colSpan && cell.colSpan > 1 ? cell.colSpan : void 0,
+      rowspan: cell.rowSpan && cell.rowSpan > 1 ? cell.rowSpan : void 0,
+      dir: "auto"
+    })}>${renderInline(cell.content)}</${tag}>`;
+  }).join("")}</tr>`;
+  const headRow = block.headerRow === true ? rows[0] : void 0;
+  const bodyRows = headRow ? rows.slice(1) : rows;
+  const thead = headRow ? `<thead>${renderRow(headRow, 0)}</thead>` : "";
+  const tbody = `<tbody>${bodyRows.map((row, index) => renderRow(row, headRow ? index + 1 : index)).join("")}</tbody>`;
+  return `<div${attrs({ "data-kit": "editor-table-wrapper", "data-block-id": block.id })}><table${attrs({ "data-kit": "editor-table" })}>${thead}${tbody}</table></div>`;
+}
+function renderBlocks(blocks, ctx) {
+  return blocks.map((block) => renderBlock(block, ctx)).join("");
+}
+function documentToHtml(doc, options = {}) {
+  const ctx = {
+    idPrefix: options.idPrefix ?? "kit-",
+    labels: { ...defaultExportLabels, ...options.labels },
+    locale: options.locale,
+    outline: buildOutlineTree(getOutline(doc))
+  };
+  const html = renderBlocks(doc.blocks ?? [], ctx);
+  return options.wrap === true ? `<div data-kit="editor-view">${html}</div>` : html;
+}
+
+// src/markdown.ts
+function escapeMarkdown(text) {
+  return text.replace(/([\\`*_[\]<>~|])/g, "\\$1");
+}
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function escapeLineStart(line) {
+  return line.replace(/^(\s*)([#>+-])/, "$1\\$2").replace(/^(\s*)(\d+)([.)])(\s|$)/, "$1$2\\$3$4").replace(/^(\s*)([=]{2,}|[-]{2,})\s*$/, "$1\\$2").replace(/^(\s*)(:{1}[a-z0-9_+-]+:)/i, "$1\\$2");
+}
+function codeSpan(text) {
+  const runs = text.match(/`+/g) ?? [];
+  const longest = runs.reduce((max, run) => Math.max(max, run.length), 0);
+  const fence2 = "`".repeat(longest + 1);
+  const pad = text.startsWith("`") || text.endsWith("`") || text.startsWith(" ") && text.endsWith(" ") && text.trim() !== "" ? " " : "";
+  return `${fence2}${pad}${text}${pad}${fence2}`;
+}
+function encodeDestination(href) {
+  return href.replace(/ /g, "%20").replace(/\(/g, "%28").replace(/\)/g, "%29").replace(/</g, "%3C").replace(/>/g, "%3E");
+}
+function markKey(mark) {
+  return JSON.stringify(mark);
+}
+function openToken(mark, ctx) {
+  switch (mark.type) {
+    case "bold":
+      return "**";
+    case "italic":
+      return "*";
+    case "strike":
+      return "~~";
+    case "underline":
+      return ctx.inlineHtml ? "<u>" : "";
+    case "link":
+      return sanitizeUrl(mark.href) === null ? "" : "[";
+    case "color":
+      return ctx.inlineHtml && isTextColorToken(mark.token) ? `<span data-color-token="${escapeHtml(mark.token)}">` : "";
+    case "highlight":
+      return ctx.inlineHtml && isHighlightToken(mark.token) ? `<mark data-token="${escapeHtml(mark.token)}">` : "";
+    default:
+      return "";
+  }
+}
+function closeToken(mark, ctx) {
+  switch (mark.type) {
+    case "bold":
+      return "**";
+    case "italic":
+      return "*";
+    case "strike":
+      return "~~";
+    case "underline":
+      return ctx.inlineHtml ? "</u>" : "";
+    case "link": {
+      const href = sanitizeUrl(mark.href);
+      return href === null ? "" : `](${encodeDestination(href)})`;
+    }
+    case "color":
+      return ctx.inlineHtml && isTextColorToken(mark.token) ? "</span>" : "";
+    case "highlight":
+      return ctx.inlineHtml && isHighlightToken(mark.token) ? "</mark>" : "";
+    default:
+      return "";
+  }
+}
+function renderInline2(inline, ctx, escapeLines = true) {
+  const nodes = normalizeInline(inline);
+  let out = "";
+  let active = [];
+  const closeFrom = (keep) => {
+    for (let index = active.length - 1; index >= keep; index -= 1) {
+      const mark = active[index];
+      if (mark.type === "code") continue;
+      const token = closeToken(mark, ctx);
+      if (token === "") continue;
+      const trailing = /\s+$/.exec(out)?.[0] ?? "";
+      if (trailing !== "" && mark.type !== "link") out = out.slice(0, out.length - trailing.length);
+      out += token + (mark.type !== "link" ? trailing : "");
+    }
+    active = active.slice(0, keep);
+  };
+  for (const node2 of nodes) {
+    if (node2.type !== "text") {
+      closeFrom(0);
+      if (node2.type === "mention") {
+        out += `[@${escapeMarkdown(node2.label)}](kit:mention/${node2.kind}/${encodeURIComponent(node2.id)})`;
+      } else {
+        const code = node2.shortcode.replace(/^:|:$/g, "");
+        out += emojiForShortcode(code) !== null ? `:${code}:` : escapeMarkdown(`:${code}:`);
+      }
+      continue;
+    }
+    const marks = (node2.marks ?? []).filter((mark) => mark.type !== "code");
+    const hasCode = (node2.marks ?? []).some((mark) => mark.type === "code");
+    let keep = 0;
+    while (keep < active.length && keep < marks.length && markKey(active[keep]) === markKey(marks[keep])) keep += 1;
+    closeFrom(keep);
+    let text = node2.text;
+    let lead = "";
+    if (marks.length > keep) {
+      const match = /^\s+/.exec(text);
+      if (match && text.trim() !== "") {
+        lead = match[0];
+        text = text.slice(lead.length);
+      }
+      if (text.trim() === "") {
+        out += node2.text.replace(/\n/g, "\\\n");
+        continue;
+      }
+    }
+    out += lead;
+    for (let index = keep; index < marks.length; index += 1) {
+      const mark = marks[index];
+      out += openToken(mark, ctx) ?? "";
+      active.push(mark);
+    }
+    if (hasCode && !text.includes("\n")) out += codeSpan(text);
+    else
+      out += text.split("\n").map((part, position) => position === 0 || !escapeLines ? escapeMarkdown(part) : escapeLineStart(escapeMarkdown(part))).join("\\\n");
+  }
+  closeFrom(0);
+  return out;
+}
+function renderInlineLine(inline, ctx, newline) {
+  return renderInline2(inline, ctx, false).replace(/\\\n/g, newline).replace(/\n/g, newline);
+}
+var CALLOUT_LABEL = {
+  info: "INFO",
+  success: "SUCCESS",
+  warning: "WARNING",
+  danger: "DANGER",
+  neutral: "NEUTRAL"
+};
+function fence(content, info) {
+  const runs = content.match(/`+/g) ?? [];
+  const longest = runs.reduce((max, run) => Math.max(max, run.length), 0);
+  const marker = "`".repeat(Math.max(3, longest + 1));
+  return `${marker}${info}
+${content}
+${marker}`;
+}
+function safeInfo(value) {
+  return value.replace(/[^a-zA-Z0-9_+.#-]/g, "");
+}
+function prefixLines(text, first, rest) {
+  return text.split("\n").map((line, index) => (index === 0 ? first : rest) + line).join("\n");
+}
+function renderItems2(items, kind, ctx) {
+  const lines = [];
+  items.forEach((item, index) => {
+    const marker = kind === "numbered" ? `${index + 1}. ` : "- ";
+    const checkbox = kind === "task" ? `[${item.checked ? "x" : " "}] ` : "";
+    const body = escapeLineStart(renderInline2(item.content, ctx));
+    const pad = " ".repeat(marker.length);
+    lines.push(prefixLines(`${checkbox}${body}`, marker, pad).replace(/ +$/, ""));
+    if (item.children && item.children.length > 0) {
+      const nested = renderItems2(item.children, kind, ctx).join("\n");
+      lines.push(prefixLines(nested, pad, pad));
+    }
+  });
+  return lines;
+}
+function renderTable2(block, ctx) {
+  const rows = block.rows ?? [];
+  const width = rows.reduce((max, row) => Math.max(max, row.length), 0);
+  if (rows.length === 0 || width === 0) return "";
+  const cell = (inline) => renderInlineLine(inline, ctx, "<br>").replace(/\|/g, "\\|") || " ";
+  const toLine = (row) => `| ${Array.from({ length: width }, (_, index) => row[index] ? cell(row[index]?.content) : " ").join(" | ")} |`;
+  const [head, ...body] = rows;
+  const delimiter = `| ${Array.from({ length: width }, () => "---").join(" | ")} |`;
+  return [toLine(head ?? []), delimiter, ...body.map(toLine)].join("\n");
+}
+function renderBlock2(block, ctx) {
+  switch (block.type) {
+    case "paragraph": {
+      const text = renderInline2(block.content, ctx);
+      return text === "" ? "" : escapeLineStart(text);
+    }
+    case "heading": {
+      const level = Math.min(4, Math.max(1, Math.round(block.level)));
+      return `${"#".repeat(level)} ${renderInlineLine(block.content, ctx, " ")}`.trimEnd();
+    }
+    case "quote":
+      return prefixLines(escapeLineStart(renderInline2(block.content, ctx)), "> ", "> ");
+    case "callout": {
+      const label = CALLOUT_LABEL[block.variant] ?? "INFO";
+      const body = escapeLineStart(renderInline2(block.content, ctx));
+      return prefixLines(`[!${label}]${body === "" ? "" : `
+${body}`}`, "> ", "> ");
+    }
+    case "toggle": {
+      const summary = escapeHtml(
+        normalizeInline(block.summary).map((node2) => node2.type === "text" ? node2.text : node2.type === "mention" ? `@${node2.label}` : emojiToText(node2.shortcode)).join("").replace(/\n/g, " ")
+      );
+      const body = renderBlocks2(block.children ?? [], ctx);
+      return `<details>
+<summary>${summary}</summary>
+${body === "" ? "" : `
+${body}
+`}
+</details>`;
+    }
+    case "divider":
+      return "---";
+    case "bulleted-list":
+      return renderItems2(block.items ?? [], "bulleted", ctx).join("\n");
+    case "numbered-list":
+      return renderItems2(block.items ?? [], "numbered", ctx).join("\n");
+    case "task-list":
+      return renderItems2(block.items ?? [], "task", ctx).join("\n");
+    case "code":
+      return fence(block.code, safeInfo(block.language ?? ""));
+    case "equation":
+      return `$$
+${block.latex}
+$$`;
+    case "table":
+      return renderTable2(block, ctx);
+    case "image": {
+      const src = sanitizeMediaUrl(block.src);
+      const alt = escapeMarkdown(oneLine(block.alt ?? ""));
+      if (src === null) return alt;
+      const caption = normalizeInline(block.caption).map((node2) => node2.type === "text" ? node2.text : "").join("").replace(/\s+/g, " ").trim();
+      const title = caption === "" ? "" : ` "${caption.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+      return `![${alt}](${encodeDestination(src)}${title})`;
+    }
+    case "video":
+    case "audio": {
+      const src = sanitizeMediaUrl(block.src);
+      if (src === null) return "";
+      const caption = normalizeInline(block.caption).map((node2) => node2.type === "text" ? node2.text : "").join("").replace(/\s+/g, " ").trim();
+      return `<${block.type} src="${escapeHtml(src)}"${caption === "" ? "" : ` title="${escapeHtml(caption)}"`} controls></${block.type}>`;
+    }
+    case "file": {
+      const href = sanitizeUrl(block.src);
+      const name = escapeMarkdown(oneLine(block.name));
+      return href === null ? name : `[${name}](${encodeDestination(href)})`;
+    }
+    case "bookmark": {
+      const href = sanitizeUrl(block.url);
+      const label = escapeMarkdown(oneLine(block.title || block.url));
+      return href === null ? label : `[${label}](${encodeDestination(href)})`;
+    }
+    case "columns":
+      return (block.columns ?? []).map((column) => renderBlocks2(column, ctx)).filter((text) => text !== "").join("\n\n");
+    case "page-break":
+      return "<!-- page-break -->";
+    case "table-of-contents":
+      return "[TOC]";
+    case "chart":
+      return fence(JSON.stringify(block.spec, null, 2), "kit-chart");
+    case "diagram":
+      if (block.engine === "mermaid" && typeof block.source === "string" && block.diagram === void 0) {
+        return fence(block.source, "mermaid");
+      }
+      return fence(JSON.stringify({ engine: block.engine, diagram: block.diagram, source: block.source }, null, 2), "kit-diagram");
+    case "data-view":
+      return fence(JSON.stringify({ dataset: block.dataset, view: block.view }, null, 2), "kit-data-view");
+    case "ai":
+      return fence(JSON.stringify({ prompt: block.prompt, result: block.result }, null, 2), "kit-ai");
+    default:
+      return fence(JSON.stringify(block, null, 2), "kit-block");
+  }
+}
+var LIST_TYPES = /* @__PURE__ */ new Set(["bulleted-list", "numbered-list", "task-list"]);
+function flattenColumns(blocks) {
+  return blocks.flatMap((block) => block.type === "columns" ? flattenColumns((block.columns ?? []).flat()) : [block]);
+}
+function renderBlocks2(blocks, ctx) {
+  const parts = [];
+  let previous;
+  for (const block of flattenColumns(blocks)) {
+    const text = renderBlock2(block, ctx);
+    if (text === "") continue;
+    if (previous && block.type === previous.type && LIST_TYPES.has(block.type)) parts.push("<!-- -->");
+    parts.push(text);
+    previous = block;
+  }
+  return parts.join("\n\n");
+}
+function documentToMarkdown(doc, options = {}) {
+  const ctx = { inlineHtml: options.inlineHtml ?? true };
+  const body = renderBlocks2(doc.blocks ?? [], ctx);
+  return body === "" ? "" : `${body}
+`;
+}
+
+export {
+  DOCUMENT_VERSION,
+  createEmptyDocument,
+  BLOCK_TYPES,
+  MARK_TYPES,
+  CALLOUT_VARIANTS,
+  isKnownBlockType,
+  createParagraph,
+  generateBlockId,
+  createSeededRandom,
+  createSequentialIdGenerator,
+  walkBlocks,
+  collectIds,
+  findDuplicateIds,
+  sanitizeUrl,
+  isSafeUrl,
+  sanitizeMediaUrl,
+  normalizeUrlInput,
+  TEXT_COLOR_TOKENS,
+  HIGHLIGHT_TOKENS,
+  isTextColorToken,
+  isHighlightToken,
+  tokenToCssVarName,
+  textColorToCss,
+  highlightToCss,
+  TIPTAP_NODES,
+  TIPTAP_MARKS,
+  BLOCK_ID_NODES,
+  normalizeInline,
+  documentToTiptap,
+  tiptapToDocument,
+  normalizeDocument,
+  EMOJI_SHORTCODES,
+  emojiForShortcode,
+  emojiToText,
+  inlineToPlainText,
+  documentToPlainText,
+  countWords,
+  countCharacters,
+  getDocumentStats,
+  getOutline,
+  buildOutlineTree,
+  slugifyHeading,
+  defaultExportLabels,
+  escapeHtml,
+  documentToHtml,
+  escapeMarkdown,
+  documentToMarkdown
+};
+//# sourceMappingURL=chunk-FYXMOAJT.js.map