@bendyline/squisq-editor-react 2.2.0 → 2.3.0

package/dist/chunk-NITZVAXL.js

@@ -0,0 +1,986 @@
+// src/tiptapBridge.ts
+import { resolveIcon } from "@bendyline/squisq/icons";
+import {
+  matchTrailingTemplateAnnotation,
+  matchTrailingPandocAttr,
+  tokenizeAttrTokens
+} from "@bendyline/squisq/markdown";
+var RE_BOLD_STAR = /\*\*(?![\s*])(.+?)(?<![\s*])\*\*/g;
+var RE_BOLD_UNDER = /(?<![\p{L}\p{N}_])__(?![\s_])(.+?)(?<![\s_])__(?![\p{L}\p{N}_])/gu;
+var RE_ITALIC_STAR = /\*(?![\s*])(.+?)(?<![\s*])\*/g;
+var RE_ITALIC_UNDER = /(?<![\p{L}\p{N}_])_(?![\s_])(.+?)(?<![\s_])_(?![\p{L}\p{N}_])/gu;
+var RE_STRIKETHROUGH = /~~(.+?)~~/g;
+var ESCAPABLE_MD_CHARS = ["*", "_", "~", "\\"];
+var RE_MD_ESCAPE = /\\([*_~\\])/g;
+var RE_INLINE_CODE = /`(.+?)`/g;
+var RE_IMAGE = /!\[(.*?)\]\((.+?)\)/g;
+var RE_MENTION = /@\[([^\]]+?)\]\(([a-z][a-z0-9+.-]*)\\?:([^)\s]+)\)/gi;
+var RE_MENTION_TAG = /<span\b[^>]*?\bdata-mention\b[^>]*?>(?:<[^>]+>)*([^<]*)<\/span>/gi;
+var RE_ICON_MD = /\{\[([a-zA-Z0-9_:-]+)\]\}/g;
+var RE_ICON_TAG = /<i\b[^>]*?\bdata-icon="([^"]*)"[^>]*?><\/i>/gi;
+var RE_STRONG_TAG = /<strong>(.*?)<\/strong>/g;
+var RE_B_TAG = /<b>(.*?)<\/b>/g;
+var RE_EM_TAG = /<em>(.*?)<\/em>/g;
+var RE_I_TAG = /<i>(.*?)<\/i>/g;
+var RE_S_TAG = /<s>(.*?)<\/s>/g;
+var RE_DEL_TAG = /<del>(.*?)<\/del>/g;
+var RE_CODE_TAG = /<code>(.*?)<\/code>/g;
+var RE_A_TAG = /<a\b([^>]*)>(.*?)<\/a>/g;
+var RE_IMG_TAG = /<img\b([^>]*)>/g;
+var RE_STRIP_TAGS = /<[^>]+>/g;
+function markdownToTiptap(markdown) {
+  if (!markdown.trim()) return "<p></p>";
+  const html = markdown.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const lines = html.split("\n");
+  const frontmatterEnd = findFrontmatterEnd(lines);
+  const outputBlocks = [];
+  let inCodeBlock = false;
+  let codeBlockLang = "";
+  let codeBlockLines = [];
+  const listStack = [];
+  let inTable = false;
+  let tableLines = [];
+  let pendingBlankLines = 0;
+  let lastBlockWasList = false;
+  const flushPendingBlankParagraphs = () => {
+    if (pendingBlankLines === 0) return;
+    const emptyParagraphs = outputBlocks.length === 0 ? pendingBlankLines : Math.max(0, pendingBlankLines - 1);
+    for (let i = 0; i < emptyParagraphs; i++) {
+      outputBlocks.push("<p></p>");
+    }
+    pendingBlankLines = 0;
+  };
+  const pushBlock = (block) => {
+    flushPendingBlankParagraphs();
+    outputBlocks.push(block);
+    lastBlockWasList = false;
+  };
+  const sealOpenItem = (level) => {
+    if (level.openAttrs === null) return;
+    level.items.push(`<li${level.openAttrs}>${level.openContent}</li>`);
+    level.openAttrs = null;
+    level.openContent = "";
+  };
+  const popListLevel = () => {
+    const level = listStack.pop();
+    if (!level) return;
+    sealOpenItem(level);
+    if (level.items.length === 0) return;
+    const tag = level.type === "ol" ? "ol" : "ul";
+    let attr = level.type === "task" ? ' data-type="taskList"' : "";
+    if (level.type === "ol" && level.start != null && level.start !== 1) {
+      attr += ` start="${level.start}"`;
+    }
+    const html2 = `<${tag}${attr}>${level.items.join("")}</${tag}>`;
+    const parent = listStack[listStack.length - 1];
+    if (!parent) {
+      pushBlock(html2);
+      lastBlockWasList = true;
+      return;
+    }
+    if (parent.openAttrs === null) {
+      parent.openAttrs = parent.type === "task" ? ' data-type="taskItem"' : "";
+      parent.openContent = "<p></p>";
+    }
+    parent.openContent += html2;
+  };
+  const flushList = () => {
+    while (listStack.length > 0) popListLevel();
+  };
+  const addListItem = (indent, type, attrs, content, start = null) => {
+    while (listStack.length > 0 && indent < listStack[listStack.length - 1].minIndent) {
+      popListLevel();
+    }
+    const top = listStack[listStack.length - 1];
+    if (!top) {
+      listStack.push({
+        indent,
+        minIndent: 0,
+        type,
+        start,
+        items: [],
+        openAttrs: attrs,
+        openContent: content
+      });
+      return;
+    }
+    if (indent > top.indent) {
+      listStack.push({
+        indent,
+        minIndent: top.indent + 1,
+        type,
+        start,
+        items: [],
+        openAttrs: attrs,
+        openContent: content
+      });
+      return;
+    }
+    if (indent < top.indent) top.indent = indent;
+    if (top.type !== type) {
+      const { indent: depth, minIndent } = top;
+      popListLevel();
+      listStack.push({
+        indent: depth,
+        minIndent,
+        type,
+        start,
+        items: [],
+        openAttrs: attrs,
+        openContent: content
+      });
+      return;
+    }
+    sealOpenItem(top);
+    top.openAttrs = attrs;
+    top.openContent = content;
+  };
+  const flushTable = () => {
+    if (!inTable || tableLines.length === 0) {
+      inTable = false;
+      tableLines = [];
+      return;
+    }
+    const separatorCells = tableLines.length >= 2 ? parseTableCells(tableLines[1]) : [];
+    const isSeparator = separatorCells.length > 0 && separatorCells.every((cell) => /^:?-+:?$/.test(cell.trim()));
+    if (tableLines.length < 2 || !isSeparator) {
+      for (const tl of tableLines) {
+        pushBlock(`<p>${inlineToHtml(tl)}</p>`);
+      }
+      inTable = false;
+      tableLines = [];
+      return;
+    }
+    const alignments = parseAlignments(tableLines[1]);
+    const headerCells = parseTableCells(tableLines[0]);
+    const thHtml = headerCells.map((cell, i) => {
+      const align = alignments[i];
+      const style = align ? ` style="text-align: ${align}"` : "";
+      return `<th${style}>${inlineToHtml(cell)}</th>`;
+    }).join("");
+    const bodyHtml = tableLines.slice(2).map((rowLine) => {
+      const cells = parseTableCells(rowLine);
+      const tdHtml = cells.map((cell, i) => {
+        const align = alignments[i];
+        const style = align ? ` style="text-align: ${align}"` : "";
+        return `<td${style}>${inlineToHtml(cell)}</td>`;
+      }).join("");
+      return `<tr>${tdHtml}</tr>`;
+    }).join("");
+    pushBlock(`<table><thead><tr>${thHtml}</tr></thead><tbody>${bodyHtml}</tbody></table>`);
+    inTable = false;
+    tableLines = [];
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("```")) {
+      if (!inCodeBlock) {
+        flushList();
+        flushTable();
+        flushPendingBlankParagraphs();
+        inCodeBlock = true;
+        codeBlockLang = line.slice(3).trim();
+        codeBlockLines = [];
+        continue;
+      } else {
+        const langAttr = codeBlockLang ? ` class="language-${escapeHtml(codeBlockLang)}"` : "";
+        pushBlock(`<pre><code${langAttr}>${escapeHtml(codeBlockLines.join("\n"))}</code></pre>`);
+        inCodeBlock = false;
+        codeBlockLang = "";
+        codeBlockLines = [];
+        continue;
+      }
+    }
+    if (inCodeBlock) {
+      codeBlockLines.push(line);
+      continue;
+    }
+    if (inTable && !/^\|.*\|$/.test(line.trim())) {
+      flushTable();
+    }
+    if (line.trim() === "") {
+      flushList();
+      pendingBlankLines++;
+      continue;
+    }
+    const precededByBlank = pendingBlankLines > 0 || outputBlocks.length === 0;
+    if (precededByBlank && !inTable && listStack.length === 0 && !lastBlockWasList && isIndentedCodeLine(line)) {
+      const codeLines = [];
+      let scan = i;
+      for (; scan < lines.length; scan++) {
+        const scanned = lines[scan];
+        if (scanned.trim() === "") {
+          codeLines.push("");
+          continue;
+        }
+        if (!isIndentedCodeLine(scanned)) break;
+        codeLines.push(stripCodeIndent(scanned));
+      }
+      let end = codeLines.length;
+      while (end > 0 && codeLines[end - 1] === "") end--;
+      const trailingBlanks = codeLines.length - end;
+      codeLines.length = end;
+      i = scan - trailingBlanks - 1;
+      pushBlock(`<pre><code>${escapeHtml(codeLines.join("\n"))}</code></pre>`);
+      continue;
+    }
+    flushPendingBlankParagraphs();
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      flushList();
+      pushBlock(headingToHtml(headingMatch[1].length, headingMatch[2]));
+      continue;
+    }
+    if (/^(---|\*\*\*|___)(\s*)$/.test(line.trim())) {
+      flushList();
+      pushBlock("<hr>");
+      continue;
+    }
+    if (line.startsWith("> ")) {
+      flushList();
+      const quoteLines = [line.slice(2)];
+      while (i + 1 < lines.length && lines[i + 1].startsWith("> ")) {
+        i++;
+        quoteLines.push(lines[i].slice(2));
+      }
+      pushBlock(
+        `<blockquote>${quoteLines.map((quoteLine) => `<p>${inlineToHtml(quoteLine)}</p>`).join("")}</blockquote>`
+      );
+      continue;
+    }
+    const taskMatch = line.match(/^([ \t]*)[-*+]\s+\[([xX ])\]\s*(.*)$/);
+    if (taskMatch) {
+      const checkedAttr = taskMatch[2].toLowerCase() === "x" ? ' data-checked="true"' : "";
+      addListItem(
+        indentWidth(taskMatch[1]),
+        "task",
+        ` data-type="taskItem"${checkedAttr}`,
+        `<p>${inlineToHtml(taskMatch[3])}</p>`
+      );
+      continue;
+    }
+    const ulMatch = line.match(/^([ \t]*)[-*+]\s+(.+)$/);
+    if (ulMatch) {
+      addListItem(indentWidth(ulMatch[1]), "ul", "", `<p>${inlineToHtml(ulMatch[2])}</p>`);
+      continue;
+    }
+    const olMatch = line.match(/^([ \t]*)(\d+)\.\s+(.+)$/);
+    if (olMatch) {
+      addListItem(
+        indentWidth(olMatch[1]),
+        "ol",
+        "",
+        `<p>${inlineToHtml(olMatch[3])}</p>`,
+        parseInt(olMatch[2], 10)
+      );
+      continue;
+    }
+    if (/^\|.*\|$/.test(line.trim())) {
+      if (!inTable) {
+        flushList();
+        inTable = true;
+        tableLines = [];
+      }
+      tableLines.push(line);
+      continue;
+    }
+    const standaloneImageMatch = line.trim().match(/^!\[(.*?)\]\((.+?)\)$/);
+    if (standaloneImageMatch) {
+      flushList();
+      const alt = escapeHtml(standaloneImageMatch[1] ?? "");
+      const src = escapeHtml(standaloneImageMatch[2] ?? "");
+      pushBlock(`<img alt="${alt}" src="${src}">`);
+      continue;
+    }
+    const trimmed = line.trim();
+    if (/^<img\b[^>]*>$/i.test(trimmed)) {
+      flushList();
+      pushBlock(trimmed);
+      continue;
+    }
+    if (/^<(?:video|audio)\b[^>]*>(?:[\s\S]*?<\/(?:video|audio)>)?$/i.test(trimmed)) {
+      flushList();
+      pushBlock(trimmed);
+      continue;
+    }
+    const setextLevel = i + 1 < lines.length && i + 1 > frontmatterEnd ? matchSetextUnderline(lines[i + 1]) : null;
+    if (setextLevel !== null) {
+      flushList();
+      i++;
+      pushBlock(headingToHtml(setextLevel, line.trim()));
+      continue;
+    }
+    flushList();
+    pushBlock(`<p>${inlineToHtml(line)}</p>`);
+  }
+  if (inCodeBlock) {
+    const langAttr = codeBlockLang ? ` class="language-${escapeHtml(codeBlockLang)}"` : "";
+    pushBlock(`<pre><code${langAttr}>${escapeHtml(codeBlockLines.join("\n"))}</code></pre>`);
+  }
+  flushList();
+  flushTable();
+  flushPendingBlankParagraphs();
+  return outputBlocks.join("") || "<p></p>";
+}
+function tiptapToMarkdown(html) {
+  if (!html || html === "<p></p>") return "";
+  const lines = [];
+  let remaining = html;
+  while (remaining.length > 0) {
+    const headingMatch = remaining.match(/^<h([1-6])([^>]*)>(.*?)<\/h\1>/s);
+    if (headingMatch) {
+      const level = parseInt(headingMatch[1], 10);
+      const attrs = headingMatch[2];
+      const headingHtml = headingMatch[3];
+      const chromeStart = headingHtml.search(
+        /<span\b[^>]*\bclass="[^"]*\bsquisq-(?:template|props)-badge\b[^"]*"[^>]*>/i
+      );
+      let text = htmlToInline(chromeStart >= 0 ? headingHtml.slice(0, chromeStart) : headingHtml);
+      const blockAttrsMatch = attrs.match(/data-block-attrs="([^"]*)"/);
+      const tmplMatch = attrs.match(/data-template="([^"]+)"/);
+      const paramsMatch = attrs.match(/data-template-params="([^"]+)"/);
+      const hasEmptyTemplateAnnotation = /\sdata-template-empty(?:="[^"]*")?/.test(attrs);
+      if (blockAttrsMatch) {
+        const inner = unescapeHtml(blockAttrsMatch[1]);
+        text += ` {${inner}}`;
+      }
+      if (tmplMatch || paramsMatch) {
+        let annotation = tmplMatch ? tmplMatch[1] : "";
+        if (paramsMatch) {
+          annotation += (annotation ? " " : "") + unescapeHtml(paramsMatch[1]);
+        }
+        text += ` {[${annotation}]}`;
+      } else if (hasEmptyTemplateAnnotation) {
+        text += " {[]}";
+      }
+      lines.push("#".repeat(level) + " " + text);
+      lines.push("");
+      remaining = remaining.slice(headingMatch[0].length);
+      continue;
+    }
+    const codeMatch = remaining.match(/^<pre\b[^>]*><code\b([^>]*)>(.*?)<\/code><\/pre>/s);
+    if (codeMatch) {
+      const lang = /\bclass="language-([^"]*)"/.exec(codeMatch[1] ?? "")?.[1] ?? "";
+      const code = unescapeHtml(codeMatch[2]);
+      lines.push("```" + lang);
+      lines.push(code);
+      lines.push("```");
+      lines.push("");
+      remaining = remaining.slice(codeMatch[0].length);
+      continue;
+    }
+    const bqMatch = remaining.match(/^<blockquote>(.*?)<\/blockquote>/s);
+    if (bqMatch) {
+      const paragraphs = bqMatch[1].split(/<\/p>\s*<p[^>]*>/i).map((paragraph) => paragraph.replace(/^<p[^>]*>/i, "").replace(/<\/p>\s*$/i, ""));
+      for (const paragraph of paragraphs) {
+        for (const quoteLine of htmlToInline(paragraph).split("\n")) {
+          lines.push("> " + quoteLine);
+        }
+      }
+      const next = remaining.slice(bqMatch[0].length);
+      if (!/^\s*<blockquote>/.test(next)) lines.push("");
+      remaining = next;
+      continue;
+    }
+    if (remaining.startsWith("<hr>") || remaining.startsWith("<hr/>") || remaining.startsWith("<hr />")) {
+      const hrMatch = remaining.match(/^<hr\s*\/?>/);
+      lines.push("---");
+      lines.push("");
+      remaining = remaining.slice(hrMatch[0].length);
+      continue;
+    }
+    const tableMatch = remaining.match(
+      /^<div[^>]*class="[^"]*tableWrapper[^"]*"[^>]*><table[^>]*>(.*?)<\/table>\s*<\/div>/s
+    ) || remaining.match(/^<table[^>]*>(.*?)<\/table>/s);
+    if (tableMatch) {
+      const tableContent = tableMatch[1];
+      const rows = [];
+      const rowRegex = /<tr[^>]*>(.*?)<\/tr>/gs;
+      let rowExec;
+      while ((rowExec = rowRegex.exec(tableContent)) !== null) {
+        const rowHtml = rowExec[1];
+        const cells = [];
+        const cellRegex = /<(th|td)([^>]*)>(.*?)<\/\1>/gs;
+        let cellExec;
+        while ((cellExec = cellRegex.exec(rowHtml)) !== null) {
+          const tag = cellExec[1];
+          const attrs = cellExec[2];
+          const content = htmlToInline(cellExec[3].replace(/<\/?p>/g, ""));
+          const alignExec = attrs.match(/text-align:\s*(left|center|right)/);
+          cells.push({
+            content,
+            align: alignExec ? alignExec[1] : null,
+            isHeader: tag === "th"
+          });
+        }
+        if (cells.length > 0) {
+          rows.push(cells);
+        }
+      }
+      if (rows.length > 0) {
+        const headerIdx = rows.findIndex((r) => r.some((c) => c.isHeader));
+        const hIdx = headerIdx >= 0 ? headerIdx : 0;
+        const headerRow = rows[hIdx];
+        const dataRows = rows.filter((_, i) => i !== hIdx);
+        const aligns = headerRow.map((c) => c.align);
+        lines.push("| " + headerRow.map((c) => c.content || " ").join(" | ") + " |");
+        lines.push(
+          "| " + aligns.map((a) => {
+            if (a === "center") return ":---:";
+            if (a === "right") return "---:";
+            return "---";
+          }).join(" | ") + " |"
+        );
+        for (const row of dataRows) {
+          lines.push("| " + row.map((c) => c.content || " ").join(" | ") + " |");
+        }
+        lines.push("");
+      }
+      remaining = remaining.slice(tableMatch[0].length);
+      continue;
+    }
+    const listOpenMatch = remaining.match(/^<(ul|ol)\b([^>]*)>/i);
+    if (listOpenMatch) {
+      const tag = listOpenMatch[1].toLowerCase();
+      const matched = matchBalancedTag(remaining, 0, tag);
+      if (matched) {
+        const isTask = /data-type="taskList"/i.test(listOpenMatch[2] ?? "");
+        lines.push(
+          ...renderList(matched.inner, tag === "ol", isTask, "", readListStart(listOpenMatch[2]))
+        );
+        lines.push("");
+        remaining = remaining.slice(matched.end);
+        continue;
+      }
+    }
+    const pMatch = remaining.match(/^<p>(.*?)<\/p>/s);
+    if (pMatch) {
+      const text = htmlToInline(pMatch[1]);
+      if (text.trim()) {
+        lines.push(text);
+        lines.push("");
+      } else {
+        lines.push("");
+      }
+      remaining = remaining.slice(pMatch[0].length);
+      continue;
+    }
+    const imgMatch = remaining.match(/^<img\b([^>]*)>/);
+    if (imgMatch) {
+      const attrs = imgMatch[1] ?? "";
+      const src = /\bsrc="([^"]*)"/i.exec(attrs)?.[1];
+      if (src) {
+        const alt = /\balt="([^"]*)"/i.exec(attrs)?.[1] ?? "";
+        lines.push(serializeImage(src, alt, attrs));
+        lines.push("");
+      }
+      remaining = remaining.slice(imgMatch[0].length);
+      continue;
+    }
+    const mediaMatch = remaining.match(/^<(video|audio)\b([^>]*)>(?:[\s\S]*?<\/\1>)?/);
+    if (mediaMatch) {
+      const tag = mediaMatch[1] === "video" ? "video" : "audio";
+      lines.push(serializeMediaTag(tag, mediaMatch[2] ?? ""));
+      lines.push("");
+      remaining = remaining.slice(mediaMatch[0].length);
+      continue;
+    }
+    const skipMatch = remaining.match(/^(<[^>]+>|\s+)/);
+    if (skipMatch) {
+      remaining = remaining.slice(skipMatch[0].length);
+      continue;
+    }
+    const textMatch = remaining.match(/^([^<]+)/);
+    if (textMatch) {
+      lines.push(unescapeHtml(textMatch[1]));
+      remaining = remaining.slice(textMatch[0].length);
+      continue;
+    }
+    remaining = remaining.slice(1);
+  }
+  return lines.join("\n");
+}
+function matchBalancedTag(html, start, tag) {
+  const re = new RegExp(`<${tag}\\b[^>]*>|</${tag}\\s*>`, "gi");
+  re.lastIndex = start;
+  let depth = 0;
+  let innerStart = -1;
+  let match;
+  while ((match = re.exec(html)) !== null) {
+    if (match[0][1] === "/") {
+      depth--;
+      if (depth === 0)
+        return { inner: html.slice(innerStart, match.index), end: match.index + match[0].length };
+      if (depth < 0) return null;
+    } else {
+      if (depth === 0) {
+        if (match.index !== start) return null;
+        innerStart = match.index + match[0].length;
+      }
+      depth++;
+    }
+  }
+  return null;
+}
+function splitTopLevelListItems(inner) {
+  const items = [];
+  const re = /<li\b([^>]*)>|<\/li\s*>/gi;
+  let depth = 0;
+  let itemStart = -1;
+  let itemAttrs = "";
+  let match;
+  while ((match = re.exec(inner)) !== null) {
+    if (match[0][1] === "/") {
+      depth--;
+      if (depth === 0 && itemStart >= 0) {
+        items.push({ attrs: itemAttrs, inner: inner.slice(itemStart, match.index) });
+      }
+      if (depth < 0) depth = 0;
+    } else {
+      if (depth === 0) {
+        itemStart = match.index + match[0].length;
+        itemAttrs = match[1] ?? "";
+      }
+      depth++;
+    }
+  }
+  return items;
+}
+function readListStart(attrs) {
+  const parsed = parseInt(/\bstart="(\d+)"/i.exec(attrs ?? "")?.[1] ?? "", 10);
+  return Number.isFinite(parsed) ? parsed : 1;
+}
+function splitItemContent(itemHtml) {
+  const nested = [];
+  let content = "";
+  let cursor = 0;
+  const re = /<(ul|ol)\b([^>]*)>/gi;
+  let match;
+  while ((match = re.exec(itemHtml)) !== null) {
+    const tag = match[1].toLowerCase();
+    const matched = matchBalancedTag(itemHtml, match.index, tag);
+    if (!matched) break;
+    content += itemHtml.slice(cursor, match.index);
+    nested.push({
+      ordered: tag === "ol",
+      task: /data-type="taskList"/i.test(match[2] ?? ""),
+      inner: matched.inner,
+      start: readListStart(match[2])
+    });
+    cursor = matched.end;
+    re.lastIndex = matched.end;
+  }
+  return { content: content + itemHtml.slice(cursor), nested };
+}
+function renderList(inner, ordered, task, indent, start = 1) {
+  const lines = [];
+  const items = splitTopLevelListItems(inner);
+  items.forEach((item, idx) => {
+    const { content, nested } = splitItemContent(item.inner);
+    const marker = ordered ? `${start + idx}. ` : "- ";
+    if (task) {
+      const checked = /data-checked="true"/.test(item.attrs);
+      const body = content.replace(/<label\b[^>]*>.*?<\/label>/s, "");
+      const text = htmlToInline(body.replace(/<[^>]+>/g, "").trim());
+      lines.push(`${indent}- [${checked ? "x" : " "}] ${text}`.trimEnd());
+    } else {
+      lines.push(...renderListItem(marker, content, indent));
+    }
+    const childIndent = indent + " ".repeat(task ? 2 : marker.length);
+    for (const child of nested) {
+      lines.push(...renderList(child.inner, child.ordered, child.task, childIndent, child.start));
+    }
+  });
+  return lines;
+}
+function renderListItem(prefix, html, outerIndent = "") {
+  const indent = outerIndent + " ".repeat(prefix.length);
+  const media = [];
+  const htmlWithoutMedia = html.replace(
+    /<(video|audio)\b([^>]*)>(?:[\s\S]*?<\/\1>)?/gi,
+    (_full, tag, attrs) => {
+      media.push(serializeMediaTag(tag.toLowerCase() === "video" ? "video" : "audio", attrs ?? ""));
+      return "";
+    }
+  );
+  const paragraphs = htmlWithoutMedia.split(/<\/p>\s*<p[^>]*>/i).map((p) => p.replace(/^<p[^>]*>/i, "").replace(/<\/p>\s*$/i, ""));
+  const textLines = [];
+  paragraphs.forEach((paragraph, pIdx) => {
+    const inline = htmlToInline(paragraph).trim();
+    if (!inline) return;
+    const subLines = inline.split("\n");
+    subLines.forEach((sub, sIdx) => {
+      if (pIdx === 0 && sIdx === 0) {
+        textLines.push(outerIndent + prefix + sub);
+      } else {
+        if (sIdx === 0) textLines.push("");
+        textLines.push(indent + sub);
+      }
+    });
+  });
+  if (textLines.length === 0 && media.length === 0) return [outerIndent + prefix];
+  const result = [];
+  if (textLines.length > 0) {
+    result.push(...textLines);
+    for (const tag of media) {
+      result.push("");
+      result.push(indent + tag);
+    }
+  } else {
+    result.push(outerIndent + prefix + media[0]);
+    for (const tag of media.slice(1)) {
+      result.push("");
+      result.push(indent + tag);
+    }
+  }
+  return result;
+}
+function findFrontmatterEnd(lines) {
+  if (lines[0]?.trim() !== "---") return -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === "---") return i;
+  }
+  return -1;
+}
+function matchSetextUnderline(line) {
+  const match = /^ {0,3}(=+|-+)[ \t]*$/.exec(line);
+  if (!match) return null;
+  return match[1][0] === "=" ? 1 : 2;
+}
+function isIndentedCodeLine(line) {
+  return /^(?: {4}|\t)/.test(line) && line.trim() !== "";
+}
+function stripCodeIndent(line) {
+  return line.startsWith("	") ? line.slice(1) : line.slice(4);
+}
+function headingToHtml(level, rawText) {
+  let text = rawText;
+  let attrs = "";
+  let templateInner = null;
+  let pandocInner = null;
+  for (let pass = 0; pass < 4; pass++) {
+    let matched = false;
+    if (templateInner == null) {
+      const m = matchTrailingTemplateAnnotation(text);
+      if (m) {
+        templateInner = m.inner.trim();
+        text = text.slice(0, m.index).trimEnd();
+        matched = true;
+      }
+    }
+    if (pandocInner == null) {
+      const m = matchTrailingPandocAttr(text);
+      if (m) {
+        pandocInner = m.inner.trim();
+        text = text.slice(0, m.index).trimEnd();
+        matched = true;
+      }
+    }
+    if (!matched) break;
+  }
+  if (templateInner != null) {
+    const tokens = tokenizeAttrTokens(templateInner);
+    if (tokens.length === 0) {
+      attrs += ' data-template-empty="true"';
+    }
+    const firstIsParam = tokens.length > 0 && tokens[0].indexOf("=") > 0;
+    if (!firstIsParam && tokens[0]) {
+      attrs += ` data-template="${escapeHtml(tokens[0])}"`;
+    }
+    const params = tokens.slice(firstIsParam ? 0 : 1).filter((t) => t.includes("="));
+    if (params.length > 0) {
+      attrs += ` data-template-params="${escapeHtml(params.join(" "))}"`;
+    }
+  }
+  if (pandocInner != null) {
+    attrs += ` data-block-attrs="${escapeHtml(pandocInner)}"`;
+  }
+  return `<h${level}${attrs}>${inlineToHtml(text)}</h${level}>`;
+}
+function indentWidth(raw) {
+  let width = 0;
+  for (const ch of raw) width += ch === "	" ? 4 : 1;
+  return width;
+}
+function parseTableCells(line) {
+  let inner = line.trim();
+  if (inner.startsWith("|")) inner = inner.slice(1);
+  if (inner.endsWith("|")) inner = inner.slice(0, -1);
+  return inner.split("|").map((cell) => cell.trim());
+}
+function parseAlignments(separatorLine) {
+  return parseTableCells(separatorLine).map((cell) => {
+    const s = cell.replace(/\s/g, "");
+    if (s.startsWith(":") && s.endsWith(":")) return "center";
+    if (s.endsWith(":")) return "right";
+    if (s.startsWith(":")) return "left";
+    return null;
+  });
+}
+function serializeMediaTag(tag, attrs) {
+  const src = /\bsrc="([^"]*)"/i.exec(attrs)?.[1] ?? "";
+  const controls = /\bcontrols\b/i.test(attrs);
+  const width = /\bwidth="([^"]*)"/i.exec(attrs)?.[1];
+  const height = /\bheight="([^"]*)"/i.exec(attrs)?.[1];
+  const poster = tag === "video" ? /\bposter="([^"]*)"/i.exec(attrs)?.[1] : void 0;
+  const parts = [`<${tag} src="${src}"`];
+  if (controls) parts.push(" controls");
+  if (width) parts.push(` width="${width}"`);
+  if (height) parts.push(` height="${height}"`);
+  if (poster) parts.push(` poster="${poster}"`);
+  parts.push(`></${tag}>`);
+  return parts.join("");
+}
+function serializeImage(src, alt, attrs) {
+  const width = /\bwidth="([^"]*)"/i.exec(attrs)?.[1];
+  const height = /\bheight="([^"]*)"/i.exec(attrs)?.[1];
+  const title = /\btitle="([^"]*)"/i.exec(attrs)?.[1];
+  if (!width && !height) {
+    return `![${alt}](${src})`;
+  }
+  const parts = [`<img alt="${alt}" src="${src}"`];
+  if (width) parts.push(` width="${width}"`);
+  if (height) parts.push(` height="${height}"`);
+  if (title) parts.push(` title="${title}"`);
+  parts.push(">");
+  return parts.join("");
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function unescapeHtml(text) {
+  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&nbsp;|&#160;|&#xA0;/gi, "\xA0").replace(/&amp;/g, "&");
+}
+function inlineToHtml(text) {
+  const placeholders = [];
+  const stash = (html) => {
+    const token = `\0PH${placeholders.length}\0`;
+    placeholders.push(html);
+    return token;
+  };
+  let staged = text.replace(
+    RE_INLINE_CODE,
+    (_m, code) => stash(`<code>${escapeHtml(code)}</code>`)
+  );
+  staged = staged.replace(
+    RE_IMAGE,
+    (_m, alt, src) => stash(`<img alt="${escapeHtml(alt)}" src="${escapeHtml(src)}">`)
+  );
+  staged = staged.replace(
+    RE_MENTION,
+    (_m, label, kind, id) => stash(
+      `<span data-mention="true" data-kind="${escapeHtml(kind)}" data-id="${escapeHtml(id)}" data-label="${escapeHtml(label)}" class="mention">@${escapeHtml(label)}</span>`
+    )
+  );
+  staged = staged.replace(RE_ICON_MD, (full, token) => {
+    const icon = resolveIcon(token);
+    if (!icon) return full;
+    return stash(
+      `<i class="fa-${icon.family} fa-${icon.name}" data-icon="${escapeHtml(token)}" data-family="${icon.family}" data-name="${icon.name}" contenteditable="false"></i>`
+    );
+  });
+  staged = replaceMarkdownLinks(staged, (linkText, destination) => {
+    const { url, title } = splitLinkDestination(destination);
+    const titleAttr = title === null ? "" : ` title="${escapeHtml(title)}"`;
+    return stash(`<a href="${escapeHtml(url)}"${titleAttr}>${inlineToHtml(linkText)}</a>`);
+  });
+  let result = escapeHtml(staged);
+  result = result.replace(
+    RE_MD_ESCAPE,
+    (_m, ch) => `\0ESC${ESCAPABLE_MD_CHARS.indexOf(ch)}\0`
+  );
+  result = result.replace(RE_BOLD_STAR, "<strong>$1</strong>");
+  result = result.replace(RE_BOLD_UNDER, "<strong>$1</strong>");
+  result = result.replace(RE_ITALIC_STAR, "<em>$1</em>");
+  result = result.replace(RE_ITALIC_UNDER, "<em>$1</em>");
+  result = result.replace(RE_STRIKETHROUGH, "<s>$1</s>");
+  for (let index = 0; index < ESCAPABLE_MD_CHARS.length; index++) {
+    result = result.split(`\0ESC${index}\0`).join(ESCAPABLE_MD_CHARS[index]);
+  }
+  for (let index = placeholders.length - 1; index >= 0; index--) {
+    result = result.split(`\0PH${index}\0`).join(placeholders[index] ?? "");
+  }
+  return preserveLeadingSpaces(result);
+}
+function replaceMarkdownLinks(text, replace) {
+  let output = "";
+  let consumedThrough = 0;
+  let searchFrom = 0;
+  while (searchFrom < text.length) {
+    const labelOpen = text.indexOf("[", searchFrom);
+    if (labelOpen < 0) break;
+    if (isEscapedMarkdownCharacter(text, labelOpen)) {
+      searchFrom = labelOpen + 1;
+      continue;
+    }
+    const labelClose = findMatchingMarkdownDelimiter(text, labelOpen, "[", "]");
+    const destinationOpen = labelClose + 1;
+    if (labelClose < 0 || text[destinationOpen] !== "(") {
+      searchFrom = labelOpen + 1;
+      continue;
+    }
+    const destinationClose = findMatchingMarkdownDelimiter(text, destinationOpen, "(", ")");
+    if (destinationClose < 0) {
+      searchFrom = labelOpen + 1;
+      continue;
+    }
+    const label = text.slice(labelOpen + 1, labelClose);
+    const href = text.slice(destinationOpen + 1, destinationClose);
+    if (!label || !href) {
+      searchFrom = labelOpen + 1;
+      continue;
+    }
+    output += text.slice(consumedThrough, labelOpen) + replace(label, href);
+    consumedThrough = destinationClose + 1;
+    searchFrom = consumedThrough;
+  }
+  return output + text.slice(consumedThrough);
+}
+function splitLinkDestination(destination) {
+  const OPENER_FOR = { '"': '"', "'": "'", ")": "(" };
+  const trimmed = destination.trimEnd();
+  const opener = OPENER_FOR[trimmed[trimmed.length - 1] ?? ""];
+  if (!opener) return { url: destination.trim(), title: null };
+  for (let index = trimmed.length - 2; index > 0; index--) {
+    if (trimmed[index] !== opener) continue;
+    if (isEscapedMarkdownCharacter(trimmed, index)) continue;
+    if (!/\s/.test(trimmed[index - 1])) continue;
+    const url = trimmed.slice(0, index).trim();
+    if (!url) continue;
+    return {
+      url,
+      // Backslash escapes inside a title are real escapes (`\"` is a literal
+      // quote), matching core's parser.
+      title: trimmed.slice(index + 1, -1).replace(/\\([\\"'()])/g, "$1")
+    };
+  }
+  return { url: destination.trim(), title: null };
+}
+function escapeLinkTitleAttr(attrValue) {
+  return attrValue.replace(/\\/g, "\\\\").replace(/&quot;/g, "\\&quot;");
+}
+function findMatchingMarkdownDelimiter(text, start, open, close) {
+  let depth = 0;
+  for (let index = start; index < text.length; index++) {
+    if (isEscapedMarkdownCharacter(text, index)) continue;
+    if (text[index] === open) depth++;
+    if (text[index] !== close) continue;
+    depth--;
+    if (depth === 0) return index;
+  }
+  return -1;
+}
+function isEscapedMarkdownCharacter(text, index) {
+  let backslashes = 0;
+  for (let cursor = index - 1; cursor >= 0 && text[cursor] === "\\"; cursor--) {
+    backslashes++;
+  }
+  return backslashes % 2 === 1;
+}
+function isMarkdownWordChar(ch) {
+  return ch !== void 0 && /[\p{L}\p{N}_]/u.test(ch);
+}
+function isMarkdownSpace(ch) {
+  return ch === void 0 || /\s/.test(ch);
+}
+var RE_BARE_URL = /(?:https?:\/\/|ftp:\/\/|www\.)(?:\([^\s<>()]*\)|[^\s<>[\]()])+/gi;
+function escapeMarkdownText(text) {
+  let out = "";
+  let cursor = 0;
+  RE_BARE_URL.lastIndex = 0;
+  let url;
+  while ((url = RE_BARE_URL.exec(text)) !== null) {
+    out += escapeMarkdownRun(text.slice(cursor, url.index));
+    out += url[0];
+    cursor = url.index + url[0].length;
+  }
+  return out + escapeMarkdownRun(text.slice(cursor));
+}
+function escapeMarkdownRun(text) {
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    const prev = text[i - 1];
+    const next = text[i + 1];
+    if (ch === "\\") {
+      out += ESCAPABLE_MD_CHARS.includes(next ?? "") ? "\\\\" : "\\";
+      continue;
+    }
+    if (ch === "~") {
+      out += prev === "~" || next === "~" ? "\\~" : "~";
+      continue;
+    }
+    if (ch === "*") {
+      out += !isMarkdownSpace(next) || !isMarkdownSpace(prev) ? "\\*" : "*";
+      continue;
+    }
+    if (ch === "_") {
+      const canOpen = !isMarkdownWordChar(prev) && !isMarkdownSpace(next);
+      const canClose = !isMarkdownWordChar(next) && !isMarkdownSpace(prev);
+      out += canOpen || canClose ? "\\_" : "_";
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+function escapeMarkdownTextNodes(html) {
+  let out = "";
+  let cursor = 0;
+  const re = /<code\b[^>]*>[\s\S]*?<\/code>|<[^>]+>/gi;
+  let match;
+  while ((match = re.exec(html)) !== null) {
+    out += escapeMarkdownText(html.slice(cursor, match.index));
+    out += match[0];
+    cursor = match.index + match[0].length;
+  }
+  return out + escapeMarkdownText(html.slice(cursor));
+}
+function htmlToInline(html) {
+  let result = html;
+  result = result.replace(/<br\s*\/?>/gi, "  \n");
+  result = escapeMarkdownTextNodes(result);
+  result = result.replace(RE_ICON_TAG, (_m, token) => `{[${token}]}`);
+  result = result.replace(RE_STRONG_TAG, "**$1**");
+  result = result.replace(RE_B_TAG, "**$1**");
+  result = result.replace(RE_EM_TAG, "*$1*");
+  result = result.replace(RE_I_TAG, "*$1*");
+  result = result.replace(RE_S_TAG, "~~$1~~");
+  result = result.replace(RE_DEL_TAG, "~~$1~~");
+  result = result.replace(RE_CODE_TAG, "`$1`");
+  result = result.replace(RE_MENTION_TAG, (match, _inner) => {
+    const kind = /data-kind="([^"]*)"/i.exec(match)?.[1] ?? "";
+    const id = /data-id="([^"]*)"/i.exec(match)?.[1] ?? "";
+    const label = /data-label="([^"]*)"/i.exec(match)?.[1] ?? "";
+    if (!kind || !id || !label) return match;
+    return `@[${label}](${kind}:${id})`;
+  });
+  result = result.replace(RE_A_TAG, (match, attrs, text) => {
+    const href = /\bhref="([^"]*)"/i.exec(attrs)?.[1];
+    if (href === void 0) return match;
+    const title = /\btitle="([^"]*)"/i.exec(attrs)?.[1];
+    const titlePart = title ? ` "${escapeLinkTitleAttr(title)}"` : "";
+    return `[${text}](${href}${titlePart})`;
+  });
+  result = result.replace(RE_IMG_TAG, (match, attrs) => {
+    const src = /\bsrc="([^"]*)"/i.exec(attrs)?.[1];
+    if (!src) return match;
+    const alt = /\balt="([^"]*)"/i.exec(attrs)?.[1] ?? "";
+    return serializeImage(src, alt, attrs);
+  });
+  result = result.replace(RE_STRIP_TAGS, "");
+  return restoreLeadingSpaces(unescapeHtml(result));
+}
+function preserveLeadingSpaces(html) {
+  return html.replace(/^ +/, (spaces) => "&nbsp;".repeat(spaces.length));
+}
+function restoreLeadingSpaces(text) {
+  return text.replace(/(^|\n)(\u00a0+)/g, (_match, prefix, spaces) => {
+    return prefix + " ".repeat(spaces.length);
+  });
+}
+
+export {
+  markdownToTiptap,
+  tiptapToMarkdown
+};