@x12i/editor 0.0.0-stage → 1.1.0

package/dist/index.js

@@ -0,0 +1,1326 @@
+import {
+  BLOCK_ID_NODES,
+  BLOCK_TYPES,
+  CALLOUT_VARIANTS,
+  DOCUMENT_VERSION,
+  EMOJI_SHORTCODES,
+  HIGHLIGHT_TOKENS,
+  MARK_TYPES,
+  TEXT_COLOR_TOKENS,
+  TIPTAP_MARKS,
+  TIPTAP_NODES,
+  buildOutlineTree,
+  collectIds,
+  countCharacters,
+  countWords,
+  createEmptyDocument,
+  createParagraph,
+  createSeededRandom,
+  createSequentialIdGenerator,
+  defaultExportLabels,
+  documentToHtml,
+  documentToMarkdown,
+  documentToPlainText,
+  documentToTiptap,
+  emojiForShortcode,
+  emojiToText,
+  escapeHtml,
+  escapeMarkdown,
+  findDuplicateIds,
+  generateBlockId,
+  getDocumentStats,
+  getOutline,
+  highlightToCss,
+  inlineToPlainText,
+  isHighlightToken,
+  isKnownBlockType,
+  isSafeUrl,
+  isTextColorToken,
+  normalizeDocument,
+  normalizeInline,
+  normalizeUrlInput,
+  sanitizeMediaUrl,
+  sanitizeUrl,
+  slugifyHeading,
+  textColorToCss,
+  tiptapToDocument,
+  tokenToCssVarName,
+  walkBlocks
+} from "./chunk-FYXMOAJT.js";
+
+// src/markdown-import.ts
+var ENTITIES = {
+  "&": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&apos;": "'",
+  "&nbsp;": "\xA0"
+};
+function decodeEntities(text) {
+  return text.replace(/&(?:amp|lt|gt|quot|apos|nbsp|#39);/g, (entity) => ENTITIES[entity] ?? entity);
+}
+var PUNCTUATION = /[!-/:-@[-`{-~\p{P}\p{S}]/u;
+var WHITESPACE = /\s/;
+function findClosingBracket(text, start) {
+  let depth = 0;
+  for (let index = start; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === "\\") {
+      index += 1;
+    } else if (char === "`") {
+      const run = /^`+/.exec(text.slice(index))?.[0] ?? "`";
+      const close = text.indexOf(run, index + run.length);
+      if (close !== -1) index = close + run.length - 1;
+      else index += run.length - 1;
+    } else if (char === "[") {
+      depth += 1;
+    } else if (char === "]") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+function parseLinkTarget(text, start) {
+  if (text[start] !== "(") return null;
+  let index = start + 1;
+  while (index < text.length && /\s/.test(text[index] ?? "")) index += 1;
+  let href;
+  if (text[index] === "<") {
+    const close = text.indexOf(">", index);
+    if (close === -1) return null;
+    href = text.slice(index + 1, close);
+    index = close + 1;
+  } else {
+    let depth = 0;
+    const begin = index;
+    while (index < text.length) {
+      const char = text[index];
+      if (char === "\\") {
+        index += 2;
+        continue;
+      }
+      if (char === "(") depth += 1;
+      else if (char === ")") {
+        if (depth === 0) break;
+        depth -= 1;
+      } else if (/\s/.test(char)) break;
+      index += 1;
+    }
+    href = text.slice(begin, index).replace(/\\([!-/:-@[-`{-~])/g, "$1");
+  }
+  while (index < text.length && /\s/.test(text[index] ?? "")) index += 1;
+  let title;
+  const quote = text[index];
+  if (quote === '"' || quote === "'") {
+    let close = index + 1;
+    while (close < text.length && text[close] !== quote) close += text[close] === "\\" ? 2 : 1;
+    if (close >= text.length) return null;
+    title = text.slice(index + 1, close).replace(/\\(["'\\])/g, "$1");
+    index = close + 1;
+    while (index < text.length && /\s/.test(text[index] ?? "")) index += 1;
+  }
+  if (text[index] !== ")") return null;
+  return { href: decodeEntities(href), title, end: index + 1 };
+}
+function withMark(nodes, mark) {
+  return nodes.map((node) => node.type === "text" ? { ...node, marks: [...node.marks ?? [], mark] } : node);
+}
+var TAG = /^<(\/?)([a-zA-Z][a-zA-Z0-9]*)((?:\s+[a-zA-Z-]+(?:="[^"]*")?)*)\s*(\/?)>/;
+var AUTOLINK = /^<((?:https?:\/\/|mailto:)[^<>\s]+)>/i;
+var BARE_URL = /^https?:\/\/[^\s<]+/i;
+function attributeOf(source, name) {
+  const match = new RegExp(`\\s${name}="([^"]*)"`).exec(source);
+  return match ? decodeEntities(match[1] ?? "") : void 0;
+}
+function htmlMark(tag, attributes, closing) {
+  if (closing && tag === "mark") return { type: "highlight", token: "" };
+  if (closing && tag === "span") return { type: "color", token: "" };
+  switch (tag) {
+    case "u":
+      return { type: "underline" };
+    case "strong":
+    case "b":
+      return { type: "bold" };
+    case "em":
+    case "i":
+      return { type: "italic" };
+    case "s":
+    case "del":
+    case "strike":
+      return { type: "strike" };
+    case "mark": {
+      const token = attributeOf(attributes, "data-token");
+      return token !== void 0 && isHighlightToken(token) ? { type: "highlight", token } : null;
+    }
+    case "span": {
+      const token = attributeOf(attributes, "data-color-token");
+      return token !== void 0 && isTextColorToken(token) ? { type: "color", token } : null;
+    }
+    default:
+      return null;
+  }
+}
+function tokenize(text) {
+  const tokens = [];
+  let buffer = "";
+  const flush = () => {
+    if (buffer !== "") {
+      tokens.push({ k: "text", text: buffer });
+      buffer = "";
+    }
+  };
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    const rest = text.slice(index);
+    if (char === "\\") {
+      const next = text[index + 1];
+      if (next === "\n") {
+        buffer += "\n";
+        index += 2;
+        continue;
+      }
+      if (next !== void 0 && /[!-/:-@[-`{-~]/.test(next)) {
+        buffer += next;
+        index += 2;
+        continue;
+      }
+      buffer += char;
+      index += 1;
+      continue;
+    }
+    if (char === "\n") {
+      if (/ {2,}$/.test(buffer)) buffer = `${buffer.replace(/ +$/, "")}
+`;
+      else buffer = `${buffer.replace(/ +$/, "")} `;
+      index += 1;
+      while (text[index] === " ") index += 1;
+      continue;
+    }
+    if (char === "`") {
+      const run = /^`+/.exec(rest)?.[0] ?? "`";
+      let close = -1;
+      let search = index + run.length;
+      while (search < text.length) {
+        const found = text.indexOf(run, search);
+        if (found === -1) break;
+        const after = text[found + run.length];
+        if (after !== "`" && text[found - 1] !== "`") {
+          close = found;
+          break;
+        }
+        search = found + 1;
+      }
+      if (close === -1) {
+        buffer += run;
+        index += run.length;
+        continue;
+      }
+      let code = text.slice(index + run.length, close).replace(/\n/g, " ");
+      if (code.length > 1 && code.startsWith(" ") && code.endsWith(" ") && code.trim() !== "") code = code.slice(1, -1);
+      flush();
+      tokens.push({ k: "nodes", nodes: [{ type: "text", text: code, marks: [{ type: "code" }] }] });
+      index = close + run.length;
+      continue;
+    }
+    if (char === "[" || char === "!" && text[index + 1] === "[") {
+      const isImage = char === "!";
+      const bracket = isImage ? index + 1 : index;
+      const close = findClosingBracket(text, bracket);
+      if (close !== -1) {
+        const target = parseLinkTarget(text, close + 1);
+        if (target) {
+          const label = text.slice(bracket + 1, close);
+          flush();
+          const mention = /^kit:mention\/(person|page|date)\/(.+)$/.exec(target.href);
+          if (!isImage && mention) {
+            tokens.push({
+              k: "nodes",
+              nodes: [
+                {
+                  type: "mention",
+                  kind: mention[1],
+                  id: decodeURIComponent(mention[2] ?? ""),
+                  label: label.replace(/^@/, "").replace(/\\([!-/:-@[-`{-~])/g, "$1")
+                }
+              ]
+            });
+          } else {
+            const inner = parseInlineNodes(isImage && label === "" ? target.href : label);
+            tokens.push({ k: "nodes", nodes: withMark(inner, { type: "link", href: target.href }) });
+          }
+          index = target.end;
+          continue;
+        }
+      }
+    }
+    if (char === "<") {
+      const auto = AUTOLINK.exec(rest);
+      if (auto) {
+        flush();
+        const href = auto[1];
+        tokens.push({
+          k: "nodes",
+          nodes: [{ type: "text", text: href.replace(/^mailto:/i, ""), marks: [{ type: "link", href }] }]
+        });
+        index += auto[0].length;
+        continue;
+      }
+      const tag = TAG.exec(rest);
+      if (tag) {
+        const name = tag[2].toLowerCase();
+        if (name === "br") {
+          buffer += "\n";
+          index += tag[0].length;
+          continue;
+        }
+        const mark = htmlMark(name, tag[3], tag[1] === "/");
+        if (mark) {
+          flush();
+          tokens.push({ k: "mark", mark, open: tag[1] !== "/" });
+          index += tag[0].length;
+          continue;
+        }
+      }
+    }
+    if (char === "*" || char === "_" || char === "~") {
+      const run = new RegExp(`^\\${char}+`).exec(rest)?.[0] ?? char;
+      if (char === "~" && run.length !== 2) {
+        buffer += run;
+        index += run.length;
+        continue;
+      }
+      const before = index === 0 ? " " : text[index - 1];
+      const after = index + run.length >= text.length ? " " : text[index + run.length];
+      const beforeSpace = WHITESPACE.test(before);
+      const afterSpace = WHITESPACE.test(after);
+      const beforePunct = PUNCTUATION.test(before);
+      const afterPunct = PUNCTUATION.test(after);
+      const leftFlanking = !afterSpace && (!afterPunct || beforeSpace || beforePunct);
+      const rightFlanking = !beforeSpace && (!beforePunct || afterSpace || afterPunct);
+      const open = char === "_" ? leftFlanking && (!rightFlanking || beforePunct) : leftFlanking;
+      const close = char === "_" ? rightFlanking && (!leftFlanking || afterPunct) : rightFlanking;
+      flush();
+      tokens.push({ k: "delim", char, count: run.length, open, close });
+      index += run.length;
+      continue;
+    }
+    if (char === ":") {
+      const shortcode = /^:([a-z0-9_+-]+):/i.exec(rest);
+      if (shortcode && emojiForShortcode(shortcode[1]) !== null) {
+        flush();
+        tokens.push({ k: "nodes", nodes: [{ type: "emoji", shortcode: shortcode[1] }] });
+        index += shortcode[0].length;
+        continue;
+      }
+    }
+    if ((char === "h" || char === "H") && (index === 0 || !/[\p{L}\p{N}]/u.test(text[index - 1]))) {
+      const url = BARE_URL.exec(rest);
+      if (url) {
+        let value = url[0];
+        while (/[.,;:!?'"*_~]$/.test(value) || value.endsWith(")") && !value.includes("(")) value = value.slice(0, -1);
+        if (value.length > "https://".length) {
+          flush();
+          tokens.push({ k: "nodes", nodes: [{ type: "text", text: value, marks: [{ type: "link", href: value }] }] });
+          index += value.length;
+          continue;
+        }
+      }
+    }
+    buffer += char;
+    index += 1;
+  }
+  flush();
+  return tokens;
+}
+function resolveEmphasis(tokens) {
+  const list = [...tokens];
+  for (let index = 0; index < list.length; index += 1) {
+    const token = list[index];
+    if (token.k !== "mark" || !token.open) continue;
+    let closeAt = -1;
+    for (let search = index + 1; search < list.length; search += 1) {
+      const candidate = list[search];
+      if (candidate.k === "mark" && !candidate.open && candidate.mark.type === token.mark.type) {
+        closeAt = search;
+        break;
+      }
+    }
+    if (closeAt === -1) {
+      list[index] = { k: "text", text: "" };
+      continue;
+    }
+    const children = list.slice(index + 1, closeAt);
+    list.splice(index, closeAt - index + 1, { k: "span", mark: token.mark, children: resolveEmphasis(children) });
+  }
+  for (let index = 0; index < list.length; index += 1) {
+    const token = list[index];
+    if (token.k === "mark") list[index] = { k: "text", text: "" };
+  }
+  for (let closerIndex = 0; closerIndex < list.length; closerIndex += 1) {
+    let closer = list[closerIndex];
+    if (closer.k !== "delim" || !closer.close) continue;
+    while (closer.k === "delim" && closer.count > 0 && closer.close) {
+      let openerIndex = -1;
+      for (let search = closerIndex - 1; search >= 0; search -= 1) {
+        const candidate = list[search];
+        if (candidate.k === "delim" && candidate.char === closer.char && candidate.open && candidate.count > 0) {
+          if (closer.char === "~" && (candidate.count < 2 || closer.count < 2)) continue;
+          openerIndex = search;
+          break;
+        }
+      }
+      if (openerIndex === -1) break;
+      const opener = list[openerIndex];
+      const use = closer.char === "~" ? 2 : opener.count >= 2 && closer.count >= 2 ? 2 : 1;
+      const mark = closer.char === "~" ? { type: "strike" } : use === 2 ? { type: "bold" } : { type: "italic" };
+      const children = list.slice(openerIndex + 1, closerIndex);
+      opener.count -= use;
+      closer.count -= use;
+      list.splice(openerIndex + 1, closerIndex - openerIndex - 1, { k: "span", mark, children });
+      closerIndex = openerIndex + 2;
+      closer = list[closerIndex];
+      if (closer.k !== "delim") break;
+    }
+  }
+  return list;
+}
+function tokensToNodes(tokens, inherited) {
+  const out = [];
+  const push = (text, marks) => {
+    if (text !== "") out.push(marks.length > 0 ? { type: "text", text, marks } : { type: "text", text });
+  };
+  for (const token of tokens) {
+    switch (token.k) {
+      case "text":
+        push(decodeEntities(token.text), inherited);
+        break;
+      case "delim":
+        push(token.char.repeat(token.count), inherited);
+        break;
+      case "nodes":
+        for (const node of token.nodes) {
+          out.push(node.type === "text" ? { ...node, marks: [...inherited, ...node.marks ?? []] } : node);
+        }
+        break;
+      case "span":
+        out.push(...tokensToNodes(token.children, [...inherited, token.mark]));
+        break;
+      default:
+        break;
+    }
+  }
+  return out;
+}
+function parseInlineNodes(text) {
+  return tokensToNodes(resolveEmphasis(tokenize(text)), []);
+}
+function markdownToInline(markdown) {
+  return normalizeInline(parseInlineNodes(markdown.trim()));
+}
+var HEADING = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?(?:[ \t]+#+)?[ \t]*$/;
+var FENCE = /^ {0,3}(`{3,}|~{3,})[ \t]*([^`]*?)[ \t]*$/;
+var THEMATIC = /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/;
+var BULLET = /^( {0,3})([-+*])(?:[ \t]+(.*))?$/;
+var ORDERED = /^( {0,3})(\d{1,9})([.)])(?:[ \t]+(.*))?$/;
+var QUOTE = /^ {0,3}>[ ]?(.*)$/;
+var TABLE_DELIMITER = /^\s*\|?\s*:?-+:?\s*(?:\|\s*:?-+:?\s*)*\|?\s*$/;
+var SETEXT = /^ {0,3}(=+|-+)[ \t]*$/;
+var EQUATION_FENCE = /^ {0,3}\$\$[ \t]*$/;
+var EQUATION_ONE_LINE = /^ {0,3}\$\$(.+)\$\$[ \t]*$/;
+function expandTabs(line) {
+  return line.replace(/^[ \t]+/, (indent) => indent.replace(/\t/g, "    "));
+}
+function indentOf(line) {
+  return /^ */.exec(line)?.[0].length ?? 0;
+}
+function isBlank(line) {
+  return line === void 0 || line.trim() === "";
+}
+function matchListMarker(line) {
+  if (THEMATIC.test(line)) return null;
+  const bullet = BULLET.exec(line);
+  if (bullet) {
+    const indent = bullet[1].length;
+    const text = bullet[3] ?? "";
+    const gap = text === "" ? 1 : /^( {0,3}[-+*])([ \t]+)/.exec(line)?.[2]?.replace(/\t/g, "    ").length ?? 1;
+    return { ordered: false, delimiter: bullet[2], indent, contentOffset: indent + 1 + Math.min(gap, 4), text };
+  }
+  const ordered = ORDERED.exec(line);
+  if (ordered) {
+    const indent = ordered[1].length;
+    const text = ordered[4] ?? "";
+    const marker = ordered[2].length + 1;
+    const gap = text === "" ? 1 : /^( {0,3}\d{1,9}[.)])([ \t]+)/.exec(line)?.[2]?.replace(/\t/g, "    ").length ?? 1;
+    return { ordered: true, delimiter: ordered[3], indent, contentOffset: indent + marker + Math.min(gap, 4), text };
+  }
+  return null;
+}
+function startsBlock(line, previousIsParagraph) {
+  if (HEADING.test(line) || FENCE.test(line) || THEMATIC.test(line) || QUOTE.test(line)) return true;
+  if (EQUATION_FENCE.test(line) || EQUATION_ONE_LINE.test(line)) return true;
+  if (/^ {0,3}<(details|!--|video|audio)/i.test(line) || /^ {0,3}\[TOC\]\s*$/i.test(line)) return true;
+  const marker = matchListMarker(line);
+  if (marker) {
+    if (previousIsParagraph && (marker.text === "" || marker.ordered && !/^ {0,3}1[.)]/.test(line))) return false;
+    return true;
+  }
+  return false;
+}
+var CALLOUT_ALIASES = {
+  info: "info",
+  note: "info",
+  tip: "success",
+  success: "success",
+  warning: "warning",
+  caution: "danger",
+  danger: "danger",
+  important: "neutral",
+  neutral: "neutral"
+};
+function splitTableRow(line) {
+  let trimmed = line.trim();
+  if (trimmed.startsWith("|")) trimmed = trimmed.slice(1);
+  if (trimmed.endsWith("|") && !trimmed.endsWith("\\|")) trimmed = trimmed.slice(0, -1);
+  const cells = [];
+  let current = "";
+  let inCode = false;
+  for (let index = 0; index < trimmed.length; index += 1) {
+    const char = trimmed[index];
+    if (char === "\\" && trimmed[index + 1] === "|") {
+      current += "|";
+      index += 1;
+    } else if (char === "`") {
+      inCode = !inCode;
+      current += char;
+    } else if (char === "|" && !inCode) {
+      cells.push(current.trim());
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  cells.push(current.trim());
+  return cells;
+}
+function joinParagraphInline(parts) {
+  const joined = [];
+  parts.forEach((part, index) => {
+    if (index > 0) joined.push({ type: "text", text: "\n" });
+    joined.push(...part);
+  });
+  return normalizeInline(joined);
+}
+function plainOf(block) {
+  if ("content" in block && Array.isArray(block.content)) {
+    return block.content.map((node) => node.type === "text" ? node.text : node.type === "mention" ? `@${node.label}` : `:${node.shortcode}:`).join("");
+  }
+  if (block.type === "code") return block.code;
+  return "";
+}
+function itemFromLines(lines, task, ctx) {
+  const blocks = parseBlocks(lines, ctx);
+  const children = [];
+  const runs = [];
+  for (const block of blocks) {
+    if (block.type === "paragraph") runs.push(block.content);
+    else if (block.type === "bulleted-list" || block.type === "numbered-list" || block.type === "task-list") {
+      for (const item2 of block.items) children.push(item2);
+    } else {
+      const text = plainOf(block);
+      if (text !== "") runs.push([{ type: "text", text }]);
+    }
+  }
+  const base = { id: ctx.generateId(), content: joinParagraphInline(runs) };
+  const item = task ? { ...base, checked: false } : base;
+  if (children.length > 0) item.children = children;
+  return item;
+}
+function parseList(lines, start, ctx) {
+  const first = matchListMarker(lines[start]);
+  const items = [];
+  let index = start;
+  let isTask;
+  while (index < lines.length) {
+    const marker = matchListMarker(lines[index]);
+    if (!marker || marker.ordered !== first.ordered || marker.delimiter !== first.delimiter) break;
+    if (index !== start && marker.indent >= first.contentOffset) break;
+    const itemLines = [marker.text];
+    let cursor = index + 1;
+    let previousBlank = false;
+    while (cursor < lines.length) {
+      const line = lines[cursor];
+      if (isBlank(line)) {
+        itemLines.push("");
+        previousBlank = true;
+        cursor += 1;
+        continue;
+      }
+      const indent = indentOf(line);
+      if (indent >= marker.contentOffset) {
+        itemLines.push(line.slice(marker.contentOffset));
+      } else if (!previousBlank && !startsBlock(line, !isBlank(itemLines[itemLines.length - 1])) && !matchListMarker(line)) {
+        itemLines.push(line.trimStart());
+      } else {
+        break;
+      }
+      previousBlank = false;
+      cursor += 1;
+    }
+    let trailing = 0;
+    while (itemLines.length > 1 && isBlank(itemLines[itemLines.length - 1])) {
+      itemLines.pop();
+      trailing += 1;
+    }
+    cursor -= trailing;
+    let checked;
+    const taskMatch = /^\[([ xX])\](?:[ \t]+(.*))?$/.exec(itemLines[0]);
+    if (isTask === void 0) isTask = taskMatch !== null;
+    else if (taskMatch !== null !== isTask) break;
+    if (isTask && taskMatch) {
+      checked = taskMatch[1] !== " ";
+      itemLines[0] = taskMatch[2] ?? "";
+    }
+    const item = itemFromLines(itemLines, isTask === true, ctx);
+    if (isTask === true) item.checked = checked === true;
+    items.push(item);
+    index = cursor;
+    let lookahead = index;
+    while (lookahead < lines.length && isBlank(lines[lookahead])) lookahead += 1;
+    const sibling = lookahead < lines.length ? matchListMarker(lines[lookahead]) : null;
+    if (sibling && sibling.ordered === first.ordered && sibling.delimiter === first.delimiter && sibling.indent < first.contentOffset) {
+      index = lookahead;
+    } else {
+      break;
+    }
+  }
+  const type = isTask ? "task-list" : first.ordered ? "numbered-list" : "bulleted-list";
+  return { block: { id: ctx.generateId(), type, items }, next: index };
+}
+function parseCalloutFromQuote(inner, ctx) {
+  const head = inner[0];
+  if (!head || head.type !== "paragraph") return null;
+  const firstText = head.content[0];
+  if (!firstText || firstText.type !== "text") return null;
+  const match = /^\[!([A-Za-z]+)\][ \t]*\n?/.exec(firstText.text);
+  if (!match) return null;
+  const variant = CALLOUT_ALIASES[match[1].toLowerCase()];
+  if (!variant) return null;
+  const content = [{ ...firstText, text: firstText.text.slice(match[0].length) }, ...head.content.slice(1)];
+  const runs = [normalizeInline(content)];
+  const trailing = [];
+  for (const block of inner.slice(1)) {
+    if (block.type === "paragraph") runs.push(block.content);
+    else trailing.push(block);
+  }
+  return [{ id: ctx.generateId(), type: "callout", variant, content: joinParagraphInline(runs) }, ...trailing];
+}
+function parseKitFence(info, code, ctx) {
+  const kind = info.toLowerCase();
+  if (kind === "mermaid") {
+    return { id: ctx.generateId(), type: "diagram", engine: "mermaid", source: code };
+  }
+  if (!kind.startsWith("kit-")) return null;
+  let data;
+  try {
+    data = JSON.parse(code);
+  } catch {
+    return null;
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return null;
+  const record = data;
+  switch (kind) {
+    case "kit-chart":
+      return { id: ctx.generateId(), type: "chart", spec: record };
+    case "kit-diagram": {
+      const engine = record.engine === "canvas" || record.engine === "excalidraw" ? record.engine : "mermaid";
+      const block = { id: ctx.generateId(), type: "diagram", engine };
+      if (typeof record.diagram === "object" && record.diagram !== null) block.diagram = record.diagram;
+      if (typeof record.source === "string") block.source = record.source;
+      return block;
+    }
+    case "kit-data-view":
+      return {
+        id: ctx.generateId(),
+        type: "data-view",
+        dataset: typeof record.dataset === "string" ? record.dataset : "",
+        view: record.view
+      };
+    case "kit-ai": {
+      const block = {
+        id: ctx.generateId(),
+        type: "ai",
+        prompt: typeof record.prompt === "string" ? record.prompt : ""
+      };
+      if (Array.isArray(record.result)) block.result = record.result;
+      return block;
+    }
+    case "kit-block":
+      return typeof record.type === "string" ? { ...record, id: typeof record.id === "string" ? record.id : ctx.generateId() } : null;
+    default:
+      return null;
+  }
+}
+function parseMediaTag(line, ctx) {
+  const match = /^ {0,3}<(video|audio)\b([^>]*)>\s*<\/\1>\s*$|^ {0,3}<(video|audio)\b([^>]*)\/>\s*$/i.exec(line);
+  if (!match) return null;
+  const kind = (match[1] ?? match[3] ?? "video").toLowerCase();
+  const attributes = ` ${match[2] ?? match[4] ?? ""}`;
+  const src = attributeOf(attributes, "src");
+  if (src === void 0) return null;
+  const block = { id: ctx.generateId(), type: kind, src };
+  const title = attributeOf(attributes, "title");
+  if (title !== void 0 && title !== "") block.caption = [{ type: "text", text: title }];
+  return block;
+}
+var IMAGE_ONLY = /^\s*!\[((?:[^\]\\]|\\.)*)\]\(\s*(<[^>]*>|[^\s)]*)(?:\s+"((?:[^"\\]|\\.)*)")?\s*\)\s*$/;
+function parseImageOnly(text, ctx) {
+  const match = IMAGE_ONLY.exec(text);
+  if (!match) return null;
+  const src = decodeEntities(match[2].replace(/^<|>$/g, ""));
+  const block = {
+    id: ctx.generateId(),
+    type: "image",
+    src,
+    alt: match[1].replace(/\\([!-/:-@[-`{-~])/g, "$1")
+  };
+  if (match[3] !== void 0 && match[3] !== "") {
+    block.caption = [{ type: "text", text: match[3].replace(/\\(["\\])/g, "$1") }];
+  }
+  return block;
+}
+function parseDetails(lines, start, ctx) {
+  if (!/^ {0,3}<details(\s[^>]*)?>\s*$/i.test(lines[start])) return null;
+  let depth = 0;
+  let end = -1;
+  for (let index = start; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (/^ {0,3}<details(\s[^>]*)?>\s*$/i.test(line)) depth += 1;
+    if (/^ {0,3}<\/details>\s*$/i.test(line)) {
+      depth -= 1;
+      if (depth === 0) {
+        end = index;
+        break;
+      }
+    }
+  }
+  if (end === -1) return null;
+  const body = lines.slice(start + 1, end);
+  let summary = [];
+  let rest = body;
+  const summaryIndex = body.findIndex((line) => /<summary[^>]*>/i.test(line));
+  if (summaryIndex !== -1) {
+    const joined = body.slice(summaryIndex).join("\n");
+    const match = /<summary[^>]*>([\s\S]*?)<\/summary>/i.exec(joined);
+    if (match) {
+      const summaryText = decodeEntities(match[1].replace(/<[^>]+>/g, "").trim());
+      summary = summaryText === "" ? [] : [{ type: "text", text: summaryText }];
+      const consumed = joined.slice(0, (match.index ?? 0) + match[0].length).split("\n").length;
+      rest = [...body.slice(0, summaryIndex), ...body.slice(summaryIndex + consumed)];
+    }
+  }
+  return {
+    block: { id: ctx.generateId(), type: "toggle", summary, children: parseBlocks(rest, ctx) },
+    next: end + 1
+  };
+}
+function parseBlocks(rawLines, ctx) {
+  const lines = rawLines.map(expandTabs);
+  const blocks = [];
+  let index = 0;
+  while (index < lines.length) {
+    const line = lines[index];
+    if (isBlank(line)) {
+      index += 1;
+      continue;
+    }
+    const fenceMatch = FENCE.exec(line);
+    if (fenceMatch) {
+      const marker = fenceMatch[1];
+      const info = fenceMatch[2].split(/\s+/)[0] ?? "";
+      const fenceIndent = indentOf(line);
+      const body = [];
+      index += 1;
+      while (index < lines.length) {
+        const current = lines[index];
+        const closing = new RegExp(`^ {0,3}\\${marker[0]}{${marker.length},}[ \\t]*$`).test(current);
+        if (closing) {
+          index += 1;
+          break;
+        }
+        body.push(current.replace(new RegExp(`^ {0,${fenceIndent}}`), ""));
+        index += 1;
+      }
+      const code = body.join("\n");
+      const kit = parseKitFence(info, code, ctx);
+      if (kit) blocks.push(kit);
+      else {
+        const block = { id: ctx.generateId(), type: "code", code };
+        if (info !== "") block.language = info;
+        blocks.push(block);
+      }
+      continue;
+    }
+    if (EQUATION_FENCE.test(line)) {
+      const body = [];
+      index += 1;
+      while (index < lines.length && !EQUATION_FENCE.test(lines[index])) {
+        body.push(lines[index].trimEnd());
+        index += 1;
+      }
+      index += 1;
+      blocks.push({ id: ctx.generateId(), type: "equation", latex: body.join("\n").trim() });
+      continue;
+    }
+    const oneLine = EQUATION_ONE_LINE.exec(line);
+    if (oneLine) {
+      blocks.push({ id: ctx.generateId(), type: "equation", latex: oneLine[1].trim() });
+      index += 1;
+      continue;
+    }
+    const heading = HEADING.exec(line);
+    if (heading) {
+      const level = Math.min(4, heading[1].length);
+      blocks.push({ id: ctx.generateId(), type: "heading", level, content: markdownToInline(heading[2] ?? "") });
+      index += 1;
+      continue;
+    }
+    if (THEMATIC.test(line)) {
+      blocks.push({ id: ctx.generateId(), type: "divider" });
+      index += 1;
+      continue;
+    }
+    if (/^ {0,3}<!--\s*-->\s*$/.test(line)) {
+      index += 1;
+      continue;
+    }
+    if (/^ {0,3}<!--\s*page-break\s*-->\s*$/i.test(line)) {
+      blocks.push({ id: ctx.generateId(), type: "page-break" });
+      index += 1;
+      continue;
+    }
+    if (/^ {0,3}(\[TOC\]|<!--\s*toc\s*-->)\s*$/i.test(line)) {
+      blocks.push({ id: ctx.generateId(), type: "table-of-contents" });
+      index += 1;
+      continue;
+    }
+    const media = parseMediaTag(line, ctx);
+    if (media) {
+      blocks.push(media);
+      index += 1;
+      continue;
+    }
+    const details = parseDetails(lines, index, ctx);
+    if (details) {
+      blocks.push(details.block);
+      index = details.next;
+      continue;
+    }
+    if (QUOTE.test(line)) {
+      const inner = [];
+      while (index < lines.length) {
+        const current = lines[index];
+        const quote = QUOTE.exec(current);
+        if (quote) {
+          inner.push(quote[1]);
+        } else if (!isBlank(current) && !startsBlock(current, true) && inner.length > 0 && !isBlank(inner[inner.length - 1])) {
+          inner.push(current.trim());
+        } else break;
+        index += 1;
+      }
+      const parsed = parseBlocks(inner, ctx);
+      const callout = parseCalloutFromQuote(parsed, ctx);
+      if (callout) {
+        blocks.push(...callout);
+      } else {
+        const runs = [];
+        const trailing = [];
+        for (const block of parsed) {
+          if (block.type === "paragraph" || block.type === "heading") runs.push(block.content);
+          else trailing.push(block);
+        }
+        if (runs.length > 0 || trailing.length === 0) {
+          blocks.push({ id: ctx.generateId(), type: "quote", content: joinParagraphInline(runs) });
+        }
+        blocks.push(...trailing);
+      }
+      continue;
+    }
+    if (matchListMarker(line)) {
+      const result = parseList(lines, index, ctx);
+      blocks.push(result.block);
+      index = result.next;
+      continue;
+    }
+    if (line.includes("|") && index + 1 < lines.length && TABLE_DELIMITER.test(lines[index + 1]) && lines[index + 1].includes("-")) {
+      const header = splitTableRow(line);
+      const delimiter = splitTableRow(lines[index + 1]);
+      if (header.length === delimiter.length) {
+        const rows = [header.map((text2) => ({ content: markdownToInline(text2) }))];
+        index += 2;
+        while (index < lines.length && !isBlank(lines[index]) && lines[index].includes("|")) {
+          const cells = splitTableRow(lines[index]);
+          const row = [];
+          for (let column = 0; column < header.length; column += 1) {
+            row.push({ content: markdownToInline(cells[column] ?? "") });
+          }
+          rows.push(row);
+          index += 1;
+        }
+        blocks.push({ id: ctx.generateId(), type: "table", headerRow: true, rows });
+        continue;
+      }
+    }
+    const paragraph = [line];
+    index += 1;
+    let setext = null;
+    while (index < lines.length) {
+      const current = lines[index];
+      if (isBlank(current)) break;
+      const underline = SETEXT.exec(current);
+      if (underline) {
+        setext = underline[1].startsWith("=") ? 1 : 2;
+        index += 1;
+        break;
+      }
+      if (startsBlock(current, true)) break;
+      if (current.includes("|") && TABLE_DELIMITER.test(lines[index + 1] ?? "") && (lines[index + 1] ?? "").includes("-")) break;
+      paragraph.push(current);
+      index += 1;
+    }
+    const text = paragraph.map((part, position) => position === paragraph.length - 1 ? part.trimEnd() : part).join("\n").trim();
+    if (setext !== null) {
+      blocks.push({ id: ctx.generateId(), type: "heading", level: setext, content: markdownToInline(text.replace(/\n/g, " ")) });
+      continue;
+    }
+    const image = parseImageOnly(text, ctx);
+    if (image) {
+      blocks.push(image);
+      continue;
+    }
+    blocks.push({ id: ctx.generateId(), type: "paragraph", content: markdownToInline(text) });
+  }
+  return blocks;
+}
+function markdownToDocument(markdown, options = {}) {
+  const ctx = { generateId: options.generateId ?? generateBlockId };
+  const lines = markdown.replace(/\r\n?/g, "\n").split("\n");
+  const doc = { version: DOCUMENT_VERSION, blocks: parseBlocks(lines, ctx) };
+  if (options.title !== void 0) doc.title = options.title;
+  return doc;
+}
+
+// src/diff.ts
+function signatureOf(block) {
+  const copy = { ...block };
+  if (block.type === "toggle") copy.children = (block.children ?? []).map((child) => child.id);
+  if (block.type === "columns") copy.columns = (block.columns ?? []).map((column) => column.map((child) => child.id));
+  if (block.type === "ai" && block.result) copy.result = block.result.map((child) => child.id);
+  return JSON.stringify(copy);
+}
+function indexBlocks(doc) {
+  const order = [];
+  const entries = /* @__PURE__ */ new Map();
+  walkBlocks(doc.blocks ?? [], (block, parent) => {
+    order.push(block.id);
+    entries.set(block.id, { signature: signatureOf(block), parentId: parent?.id ?? null });
+  });
+  return { order, entries };
+}
+function longestCommonSubsequence(a, b) {
+  const table = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+  for (let i2 = a.length - 1; i2 >= 0; i2 -= 1) {
+    for (let j2 = b.length - 1; j2 >= 0; j2 -= 1) {
+      const row = table[i2];
+      row[j2] = a[i2] === b[j2] ? table[i2 + 1][j2 + 1] + 1 : Math.max(table[i2 + 1][j2], row[j2 + 1]);
+    }
+  }
+  const common = /* @__PURE__ */ new Set();
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      common.add(a[i]);
+      i += 1;
+      j += 1;
+    } else if (table[i + 1][j] >= table[i][j + 1]) {
+      i += 1;
+    } else {
+      j += 1;
+    }
+  }
+  return common;
+}
+function diffDocuments(previous, next) {
+  const before = indexBlocks(previous);
+  const after = indexBlocks(next);
+  const added = after.order.filter((id) => !before.entries.has(id));
+  const removed = before.order.filter((id) => !after.entries.has(id));
+  const shared = after.order.filter((id) => before.entries.has(id));
+  const changed = [];
+  const candidates = [];
+  for (const id of shared) {
+    if (before.entries.get(id)?.signature !== after.entries.get(id)?.signature) changed.push(id);
+    else candidates.push(id);
+  }
+  const beforeShared = before.order.filter((id) => after.entries.has(id));
+  const stable = longestCommonSubsequence(beforeShared, shared);
+  const moved = [];
+  const unchanged = [];
+  for (const id of candidates) {
+    const sameParent = before.entries.get(id)?.parentId === after.entries.get(id)?.parentId;
+    if (stable.has(id) && sameParent) unchanged.push(id);
+    else moved.push(id);
+  }
+  return { added, removed, changed, moved, unchanged };
+}
+
+// src/validate.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createCollector() {
+  const issues = [];
+  return {
+    issues,
+    add(code, severity, path, message) {
+      issues.push({ code, severity, path, message });
+    }
+  };
+}
+function checkInline(inline, path, c) {
+  if (!Array.isArray(inline)) {
+    c.add("invalid-inline", "error", path, "Inline content must be an array.");
+    return;
+  }
+  inline.forEach((node, index) => {
+    const here = `${path}[${index}]`;
+    if (!isRecord(node)) {
+      c.add("invalid-inline", "error", here, "An inline node must be an object.");
+      return;
+    }
+    if (node.type === "text") {
+      if (typeof node.text !== "string") c.add("invalid-inline", "error", here, "A text node needs a string `text`.");
+      if (node.marks === void 0) return;
+      if (!Array.isArray(node.marks)) {
+        c.add("invalid-inline", "error", `${here}.marks`, "Marks must be an array.");
+        return;
+      }
+      node.marks.forEach((mark, markIndex) => {
+        const markPath = `${here}.marks[${markIndex}]`;
+        if (!isRecord(mark)) {
+          c.add("invalid-inline", "error", markPath, "A mark must be an object.");
+          return;
+        }
+        switch (mark.type) {
+          case "bold":
+          case "italic":
+          case "underline":
+          case "strike":
+          case "code":
+            break;
+          case "link":
+            if (typeof mark.href !== "string") c.add("invalid-inline", "error", markPath, "A link mark needs a string `href`.");
+            else if (sanitizeUrl(mark.href) === null) c.add("unsafe-url", "warning", markPath, `The link "${mark.href}" is not a safe URL and will not render.`);
+            break;
+          case "color":
+            if (!isTextColorToken(mark.token)) c.add("unknown-token", "warning", markPath, `"${String(mark.token)}" is not an allowed text color token.`);
+            break;
+          case "highlight":
+            if (!isHighlightToken(mark.token)) c.add("unknown-token", "warning", markPath, `"${String(mark.token)}" is not an allowed highlight token.`);
+            break;
+          default:
+            c.add("invalid-inline", "warning", markPath, `The mark "${String(mark.type)}" is not supported.`);
+        }
+      });
+    } else if (node.type === "mention") {
+      if (typeof node.id !== "string" || typeof node.label !== "string") c.add("invalid-inline", "error", here, "A mention needs string `id` and `label`.");
+    } else if (node.type === "emoji") {
+      if (typeof node.shortcode !== "string") c.add("invalid-inline", "error", here, "An emoji needs a string `shortcode`.");
+    } else {
+      c.add("invalid-inline", "warning", here, `The inline node "${String(node.type)}" is not supported.`);
+    }
+  });
+}
+function checkItems(items, path, task, c) {
+  if (!Array.isArray(items)) {
+    c.add("invalid-field", "error", path, "`items` must be an array.");
+    return;
+  }
+  items.forEach((item, index) => {
+    const here = `${path}[${index}]`;
+    if (!isRecord(item)) {
+      c.add("invalid-field", "error", here, "A list item must be an object.");
+      return;
+    }
+    if (typeof item.id !== "string" || item.id === "") c.add("missing-id", "error", here, "A list item needs a string `id`.");
+    checkInline(item.content, `${here}.content`, c);
+    if (task && typeof item.checked !== "boolean") c.add("invalid-field", "error", `${here}.checked`, "A task item needs a boolean `checked`.");
+    if (item.children !== void 0) checkItems(item.children, `${here}.children`, task, c);
+  });
+}
+function checkUrl(value, path, c, media) {
+  if (typeof value !== "string") {
+    c.add("invalid-field", "error", path, "Expected a string URL.");
+    return;
+  }
+  const safe = media ? sanitizeMediaUrl(value) : sanitizeUrl(value);
+  if (safe === null && value !== "") c.add("unsafe-url", "warning", path, `"${value.slice(0, 40)}" is not a safe URL and will not render.`);
+}
+function checkBlocks(blocks, path, c) {
+  if (!Array.isArray(blocks)) {
+    c.add("invalid-field", "error", path, "Expected an array of blocks.");
+    return;
+  }
+  blocks.forEach((block, index) => checkBlock(block, `${path}[${index}]`, c));
+}
+function checkBlock(block, path, c) {
+  if (!isRecord(block)) {
+    c.add("invalid-block", "error", path, "A block must be an object.");
+    return;
+  }
+  if (typeof block.id !== "string" || block.id === "") c.add("missing-id", "error", path, "A block needs a string `id`.");
+  if (!isKnownBlockType(block.type)) {
+    c.add("unknown-block-type", "warning", path, `The block type "${String(block.type)}" is not known; it is kept as an opaque block.`);
+    return;
+  }
+  switch (block.type) {
+    case "paragraph":
+    case "quote":
+      checkInline(block.content, `${path}.content`, c);
+      break;
+    case "heading":
+      if (![1, 2, 3, 4].includes(block.level)) c.add("invalid-field", "error", `${path}.level`, "A heading level must be 1, 2, 3 or 4.");
+      checkInline(block.content, `${path}.content`, c);
+      break;
+    case "callout":
+      if (!CALLOUT_VARIANTS.includes(block.variant)) c.add("invalid-field", "error", `${path}.variant`, "Unknown callout variant.");
+      checkInline(block.content, `${path}.content`, c);
+      break;
+    case "toggle":
+      checkInline(block.summary, `${path}.summary`, c);
+      checkBlocks(block.children, `${path}.children`, c);
+      break;
+    case "bulleted-list":
+    case "numbered-list":
+      checkItems(block.items, `${path}.items`, false, c);
+      break;
+    case "task-list":
+      checkItems(block.items, `${path}.items`, true, c);
+      break;
+    case "code":
+      if (typeof block.code !== "string") c.add("invalid-field", "error", `${path}.code`, "A code block needs a string `code`.");
+      break;
+    case "equation":
+      if (typeof block.latex !== "string") c.add("invalid-field", "error", `${path}.latex`, "An equation needs a string `latex`.");
+      break;
+    case "table":
+      if (!Array.isArray(block.rows) || block.rows.some((row) => !Array.isArray(row))) {
+        c.add("invalid-field", "error", `${path}.rows`, "`rows` must be an array of arrays of cells.");
+      } else {
+        block.rows.forEach(
+          (row, rowIndex) => row.forEach((cell, columnIndex) => {
+            const here = `${path}.rows[${rowIndex}][${columnIndex}]`;
+            if (!isRecord(cell)) c.add("invalid-field", "error", here, "A table cell must be an object.");
+            else checkInline(cell.content, `${here}.content`, c);
+          })
+        );
+      }
+      break;
+    case "image":
+      checkUrl(block.src, `${path}.src`, c, true);
+      if (typeof block.alt !== "string") c.add("invalid-field", "error", `${path}.alt`, "An image needs a string `alt` (an empty string marks it decorative).");
+      if (block.caption !== void 0) checkInline(block.caption, `${path}.caption`, c);
+      break;
+    case "video":
+    case "audio":
+      checkUrl(block.src, `${path}.src`, c, true);
+      if (block.caption !== void 0) checkInline(block.caption, `${path}.caption`, c);
+      break;
+    case "file":
+      checkUrl(block.src, `${path}.src`, c, false);
+      if (typeof block.name !== "string") c.add("invalid-field", "error", `${path}.name`, "A file needs a string `name`.");
+      break;
+    case "bookmark":
+      checkUrl(block.url, `${path}.url`, c, false);
+      break;
+    case "columns":
+      if (!Array.isArray(block.columns)) c.add("invalid-field", "error", `${path}.columns`, "`columns` must be an array of block arrays.");
+      else block.columns.forEach((column, index) => checkBlocks(column, `${path}.columns[${index}]`, c));
+      break;
+    case "chart":
+      if (!isRecord(block.spec)) c.add("invalid-field", "error", `${path}.spec`, "A chart needs a `spec` object.");
+      break;
+    case "diagram":
+      if (!["mermaid", "canvas", "excalidraw"].includes(block.engine)) c.add("invalid-field", "error", `${path}.engine`, "Unknown diagram engine.");
+      break;
+    case "data-view":
+      if (typeof block.dataset !== "string") c.add("invalid-field", "error", `${path}.dataset`, "A data view needs a string `dataset`.");
+      if (!isRecord(block.view)) c.add("invalid-field", "error", `${path}.view`, "A data view needs a `view` object.");
+      break;
+    case "ai":
+      if (typeof block.prompt !== "string") c.add("invalid-field", "error", `${path}.prompt`, "An AI block needs a string `prompt`.");
+      if (block.result !== void 0) checkBlocks(block.result, `${path}.result`, c);
+      break;
+    default:
+      break;
+  }
+}
+function validateDocument(value) {
+  const c = createCollector();
+  if (!isRecord(value)) {
+    c.add("invalid-document", "error", "", "A document must be an object.");
+    return { valid: false, issues: c.issues };
+  }
+  if (value.version !== DOCUMENT_VERSION) {
+    c.add("unsupported-version", "error", "version", `Expected document version ${DOCUMENT_VERSION}, got ${String(value.version)}.`);
+  }
+  if (value.title !== void 0 && typeof value.title !== "string") c.add("invalid-field", "error", "title", "`title` must be a string.");
+  checkBlocks(value.blocks, "blocks", c);
+  if (c.issues.every((issue) => issue.code !== "invalid-field" || issue.path !== "blocks")) {
+    const seen = /* @__PURE__ */ new Set();
+    const reported = /* @__PURE__ */ new Set();
+    try {
+      for (const id of collectIds(value)) {
+        if (seen.has(id) && !reported.has(id)) {
+          reported.add(id);
+          c.add("duplicate-id", "error", "", `The id "${id}" is used more than once.`);
+        }
+        seen.add(id);
+      }
+    } catch {
+    }
+  }
+  return { valid: c.issues.every((issue) => issue.severity !== "error"), issues: c.issues };
+}
+function isEditorDocument(value) {
+  return validateDocument(value).valid;
+}
+function sanitizeInline(inline) {
+  return (inline ?? []).map((node) => {
+    if (node.type !== "text" || !node.marks) return node;
+    const marks = node.marks.filter((mark) => {
+      if (mark.type === "link") return sanitizeUrl(mark.href) !== null;
+      if (mark.type === "color") return isTextColorToken(mark.token);
+      if (mark.type === "highlight") return isHighlightToken(mark.token);
+      return true;
+    });
+    const { marks: _marks, ...rest } = node;
+    void _marks;
+    return marks.length > 0 ? { ...rest, marks } : rest;
+  });
+}
+function sanitizeItems(items) {
+  return items.map((item) => {
+    const copy = { ...item, content: sanitizeInline(item.content) };
+    if (item.children) copy.children = sanitizeItems(item.children);
+    return copy;
+  });
+}
+function sanitizeBlock(block) {
+  switch (block.type) {
+    case "paragraph":
+    case "heading":
+    case "quote":
+    case "callout":
+      return { ...block, content: sanitizeInline(block.content) };
+    case "toggle":
+      return { ...block, summary: sanitizeInline(block.summary), children: sanitizeBlocks(block.children ?? []) };
+    case "bulleted-list":
+    case "numbered-list":
+      return { ...block, items: sanitizeItems(block.items ?? []) };
+    case "task-list":
+      return { ...block, items: sanitizeItems(block.items ?? []) };
+    case "table":
+      return {
+        ...block,
+        rows: (block.rows ?? []).map((row) => row.map((cell) => ({ ...cell, content: sanitizeInline(cell.content) })))
+      };
+    case "image": {
+      const copy = { ...block, src: sanitizeMediaUrl(block.src) ?? "" };
+      if (block.caption) copy.caption = sanitizeInline(block.caption);
+      return copy;
+    }
+    case "video":
+    case "audio": {
+      const copy = { ...block, src: sanitizeMediaUrl(block.src) ?? "" };
+      if (block.caption) copy.caption = sanitizeInline(block.caption);
+      return copy;
+    }
+    case "file":
+      return { ...block, src: sanitizeUrl(block.src) ?? "" };
+    case "bookmark":
+      return { ...block, url: sanitizeUrl(block.url) ?? "" };
+    case "columns":
+      return { ...block, columns: (block.columns ?? []).map(sanitizeBlocks) };
+    case "ai":
+      return block.result ? { ...block, result: sanitizeBlocks(block.result) } : block;
+    default:
+      return block;
+  }
+}
+function sanitizeBlocks(blocks) {
+  return blocks.map(sanitizeBlock);
+}
+function sanitizeDocument(doc) {
+  return { ...doc, blocks: sanitizeBlocks(doc.blocks ?? []) };
+}
+export {
+  BLOCK_ID_NODES,
+  BLOCK_TYPES,
+  CALLOUT_VARIANTS,
+  DOCUMENT_VERSION,
+  EMOJI_SHORTCODES,
+  HIGHLIGHT_TOKENS,
+  MARK_TYPES,
+  TEXT_COLOR_TOKENS,
+  TIPTAP_MARKS,
+  TIPTAP_NODES,
+  buildOutlineTree,
+  collectIds,
+  countCharacters,
+  countWords,
+  createEmptyDocument,
+  createParagraph,
+  createSeededRandom,
+  createSequentialIdGenerator,
+  defaultExportLabels,
+  diffDocuments,
+  documentToHtml,
+  documentToMarkdown,
+  documentToPlainText,
+  documentToTiptap,
+  emojiForShortcode,
+  emojiToText,
+  escapeHtml,
+  escapeMarkdown,
+  findDuplicateIds,
+  generateBlockId,
+  getDocumentStats,
+  getOutline,
+  highlightToCss,
+  inlineToPlainText,
+  isEditorDocument,
+  isHighlightToken,
+  isKnownBlockType,
+  isSafeUrl,
+  isTextColorToken,
+  markdownToDocument,
+  markdownToInline,
+  normalizeDocument,
+  normalizeInline,
+  normalizeUrlInput,
+  sanitizeDocument,
+  sanitizeMediaUrl,
+  sanitizeUrl,
+  slugifyHeading,
+  textColorToCss,
+  tiptapToDocument,
+  tokenToCssVarName,
+  validateDocument,
+  walkBlocks
+};
+//# sourceMappingURL=index.js.map