@particle-academy/react-fancy 5.60.0 → 5.60.2

package/dist/chunk-MCQJFMDP.cjs

@@ -0,0 +1,893 @@
+'use strict';
+
+var chunkX2FC7ODX_cjs = require('./chunk-X2FC7ODX.cjs');
+var chunkZU5Q77OT_cjs = require('./chunk-ZU5Q77OT.cjs');
+var marked = require('marked');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/ContentRenderer/extensions.ts
+var globalRegistry = [];
+function registerExtension(extension) {
+  const idx = globalRegistry.findIndex(
+    (e) => e.tag.toLowerCase() === extension.tag.toLowerCase()
+  );
+  if (idx >= 0) {
+    globalRegistry[idx] = extension;
+  } else {
+    globalRegistry.push(extension);
+  }
+}
+function registerExtensions(extensions) {
+  for (const ext of extensions) {
+    registerExtension(ext);
+  }
+}
+function getGlobalExtensions() {
+  return [...globalRegistry];
+}
+function parseAttributes(attrString) {
+  const attrs = {};
+  const re = /(\w[\w-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
+  let m;
+  while ((m = re.exec(attrString)) !== null) {
+    attrs[m[1]] = m[2] ?? m[3] ?? m[4] ?? "";
+  }
+  return attrs;
+}
+function parseSegments(html, extensions) {
+  if (extensions.length === 0) {
+    return html ? [{ type: "html", content: html }] : [];
+  }
+  const tagNames = extensions.map((e) => e.tag).join("|");
+  const pattern = new RegExp(
+    `<(${tagNames})((?:\\s+[^>]*)?)>([\\s\\S]*?)<\\/\\1>`,
+    "gi"
+  );
+  const segments = [];
+  let lastIndex = 0;
+  let match;
+  while ((match = pattern.exec(html)) !== null) {
+    if (match.index > lastIndex) {
+      segments.push({ type: "html", content: html.slice(lastIndex, match.index) });
+    }
+    const tag = match[1].toLowerCase();
+    const rawAttrs = match[2] ? match[2].trim() : "";
+    const innerContent = match[3];
+    segments.push({
+      type: "extension",
+      tag,
+      content: innerContent,
+      attributes: rawAttrs ? parseAttributes(rawAttrs) : {}
+    });
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < html.length) {
+    segments.push({ type: "html", content: html.slice(lastIndex) });
+  }
+  return segments;
+}
+function mergeExtensions(instanceExtensions) {
+  const globals = getGlobalExtensions();
+  if (!instanceExtensions || instanceExtensions.length === 0) return globals;
+  if (globals.length === 0) return instanceExtensions;
+  const merged = [...globals];
+  for (const ext of instanceExtensions) {
+    const idx = merged.findIndex(
+      (e) => e.tag.toLowerCase() === ext.tag.toLowerCase()
+    );
+    if (idx >= 0) {
+      merged[idx] = ext;
+    } else {
+      merged.push(ext);
+    }
+  }
+  return merged;
+}
+function markdownToRawHtml(markdown) {
+  return marked.marked.parse(markdown ?? "", { async: false });
+}
+function renderMarkdown(markdown, sanitize) {
+  return chunkX2FC7ODX_cjs.sanitizeHtml(markdownToRawHtml(markdown), sanitize);
+}
+var proseClasses = [
+  "[&_h1]:text-2xl [&_h1]:font-bold [&_h1]:mt-4 [&_h1]:mb-2",
+  "[&_h2]:text-xl [&_h2]:font-semibold [&_h2]:mt-3 [&_h2]:mb-2",
+  "[&_h3]:text-lg [&_h3]:font-semibold [&_h3]:mt-2 [&_h3]:mb-1",
+  "[&_p]:mb-2",
+  "[&_a]:text-blue-500 [&_a]:underline",
+  "[&_ul]:list-disc [&_ul]:pl-5 [&_ol]:list-decimal [&_ol]:pl-5",
+  "[&_li]:mb-1",
+  "[&_blockquote]:border-l-4 [&_blockquote]:border-zinc-300 [&_blockquote]:pl-4 [&_blockquote]:italic [&_blockquote]:text-[color:var(--fancy-text-subtle,var(--color-zinc-600))] dark:[&_blockquote]:border-zinc-600 dark:[&_blockquote]:text-[color:var(--fancy-text-subtle-dark,var(--color-zinc-400))]",
+  "[&_code]:bg-[color:var(--fancy-surface-muted,var(--color-zinc-100))] [&_code]:px-1 [&_code]:rounded [&_code]:text-sm dark:[&_code]:bg-[color:var(--fancy-surface-muted-dark,var(--color-zinc-800))]",
+  "[&_pre]:bg-zinc-950 [&_pre]:text-zinc-100 [&_pre]:p-4 [&_pre]:rounded-lg [&_pre]:overflow-x-auto",
+  "[&_pre_code]:bg-transparent [&_pre_code]:px-0",
+  "[&_strong]:font-bold [&_em]:italic"
+].join(" ");
+var HTML_TAG_PATTERN = /<(p|div|br|h[1-6]|ul|ol|strong|em|a |img |table|pre|code|blockquote)[>\s/]/i;
+function detectFormat(value) {
+  return HTML_TAG_PATTERN.test(value) ? "html" : "markdown";
+}
+var STANDARD_HTML_TAGS = /* @__PURE__ */ new Set([
+  "a",
+  "abbr",
+  "address",
+  "area",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "base",
+  "bdi",
+  "bdo",
+  "blockquote",
+  "body",
+  "br",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "label",
+  "legend",
+  "li",
+  "link",
+  "main",
+  "map",
+  "mark",
+  "menu",
+  "meta",
+  "meter",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "param",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rp",
+  "rt",
+  "ruby",
+  "s",
+  "samp",
+  "script",
+  "section",
+  "select",
+  "slot",
+  "small",
+  "source",
+  "span",
+  "strike",
+  "strong",
+  "style",
+  "sub",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "title",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "wbr"
+]);
+function htmlToMarkdown(html, source) {
+  if (typeof document === "undefined") return legacyHtmlToMarkdown(html);
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  if (source) return serializeWithSource(template.content, source);
+  return serializeBlocks(template.content).replace(/^\n+/, "").replace(/\s+$/, "");
+}
+var BLOCK_ATTR = "data-md-block";
+var ITEM_ATTR = "data-md-item";
+var ROW_ATTR = "data-md-row";
+function stripTrailingNewlines(text) {
+  return text.replace(/\n+$/, "");
+}
+function indexAttr(el, attr, size) {
+  const value = el.getAttribute(attr);
+  if (value == null || !/^\d+$/.test(value)) return void 0;
+  const n = Number(value);
+  return n < size ? n : void 0;
+}
+function markdownToEditorHtml(md, sanitize = (html) => html) {
+  const plain = () => ({
+    html: sanitize(marked.marked.parse(md, { async: false }).trim()),
+    source: null
+  });
+  if (typeof document === "undefined" || md.includes("\r")) return plain();
+  const tokens = marked.marked.lexer(md);
+  const parts = [];
+  const spans = [];
+  let cursor = 0;
+  for (const token of tokens) {
+    if (token.type === "space") continue;
+    const at = md.indexOf(token.raw, cursor);
+    if (at < 0) return plain();
+    cursor = at + token.raw.length;
+    const template = document.createElement("template");
+    template.innerHTML = marked.marked.parser([token]);
+    let nodes = Array.from(template.content.childNodes);
+    const strayText = nodes.some((n) => n.nodeType === 3 && (n.textContent ?? "").trim() !== "");
+    if (!nodes.some(isElement) && !strayText) {
+      parts.push(template.innerHTML.trim());
+      continue;
+    }
+    if (strayText) {
+      const wrapper = document.createElement("div");
+      wrapper.append(...nodes);
+      template.content.append(wrapper);
+      nodes = [wrapper];
+    }
+    const id = spans.length;
+    const elements = nodes.filter(isElement);
+    for (const el of elements) el.setAttribute(BLOCK_ATTR, String(id));
+    if (token.type === "list" && elements.length === 1) {
+      const items = Array.from(elements[0].children).filter((c) => tagOf(c) === "li");
+      if (items.length === token.items.length) {
+        items.forEach((li, k) => li.setAttribute(ITEM_ATTR, String(k)));
+      }
+    }
+    if (token.type === "table" && elements.length === 1) {
+      const rows = tableRows(elements[0]);
+      if (rows.length === token.rows.length + 1) {
+        rows.forEach((tr, i) => tr.setAttribute(ROW_ATTR, String(i === 0 ? 0 : i + 1)));
+      }
+    }
+    parts.push(template.innerHTML.trim());
+    spans.push({ start: at, end: at + stripTrailingNewlines(token.raw).length, token });
+  }
+  const html = sanitize(parts.join("\n"));
+  if (spans.length === 0) return { html, source: null };
+  const seeded = document.createElement("template");
+  seeded.innerHTML = html;
+  const byId = /* @__PURE__ */ new Map();
+  for (const node of Array.from(seeded.content.childNodes)) {
+    if (!isElement(node)) continue;
+    const id = indexAttr(node, BLOCK_ATTR, spans.length);
+    if (id === void 0) continue;
+    byId.set(id, [...byId.get(id) ?? [], node]);
+  }
+  const blocks = spans.map((span, id) => {
+    const elements = byId.get(id) ?? [];
+    const block = {
+      raw: md.slice(span.start, span.end),
+      snapshot: elements.map((el) => el.outerHTML).join(""),
+      elementCount: elements.length
+    };
+    if (span.token.type === "list" && elements.length === 1) {
+      block.list = sourceList(md, span.start, span.token, elements[0]);
+    }
+    if (span.token.type === "table" && elements.length === 1) {
+      block.table = sourceTable(block.raw, span.token, elements[0]);
+    }
+    return block;
+  });
+  const gaps = spans.map((span, i) => md.slice(span.end, spans[i + 1]?.start ?? md.length));
+  return { html, source: { leading: md.slice(0, spans[0].start), blocks, gaps } };
+}
+function sourceList(md, start, token, list) {
+  const lis = Array.from(list.children).filter((c) => tagOf(c) === "li");
+  if (lis.length !== token.items.length || lis.length === 0) return void 0;
+  const items = [];
+  const bounds = [];
+  let cursor = start;
+  for (const item of token.items) {
+    const at = md.indexOf(item.raw, cursor);
+    if (at < 0) return void 0;
+    const body = stripTrailingNewlines(item.raw);
+    items.push(body);
+    bounds.push([at, at + body.length]);
+    cursor = at + item.raw.length;
+  }
+  const itemGaps = bounds.slice(0, -1).map(([, end], k) => md.slice(end, bounds[k + 1][0]));
+  const first = items[0];
+  return {
+    bullet: /^\s*([*+-])/.exec(first)?.[1] ?? "-",
+    delimiter: /^\s*\d+([.)])/.exec(first)?.[1] ?? ".",
+    loose: token.loose,
+    items,
+    itemGaps,
+    itemSnapshots: lis.map((li) => li.outerHTML)
+  };
+}
+function sourceTable(raw, token, table) {
+  const lines = raw.split("\n");
+  const rows = tableRows(table);
+  if (lines.length !== rows.length + 1) return void 0;
+  const rowSnapshots = /* @__PURE__ */ new Map();
+  for (const tr of rows) {
+    const r = indexAttr(tr, ROW_ATTR, lines.length);
+    if (r !== void 0) rowSnapshots.set(r, tr.outerHTML);
+  }
+  return { lines, columns: token.header.length, rowSnapshots };
+}
+function outerHtmlOf(nodes) {
+  return nodes.filter(isElement).map((el) => el.outerHTML).join("");
+}
+function serializeWithSource(root, src) {
+  const segments = [];
+  for (const node of Array.from(root.childNodes)) {
+    const last = segments[segments.length - 1];
+    if (node.nodeType === 3 && (node.textContent ?? "").trim() === "") {
+      if (last && last.id === void 0) last.nodes.push(node);
+      continue;
+    }
+    const id = isElement(node) ? indexAttr(node, BLOCK_ATTR, src.blocks.length) : void 0;
+    if (last && last.id === id) last.nodes.push(node);
+    else segments.push({ id, nodes: [node] });
+  }
+  const verbatim = /* @__PURE__ */ new Map();
+  segments.forEach((seg, i) => {
+    if (seg.id === void 0 || verbatim.has(seg.id)) return;
+    if (outerHtmlOf(seg.nodes) === src.blocks[seg.id].snapshot) verbatim.set(seg.id, i);
+  });
+  const pieces = [];
+  const owned = new Set(verbatim.keys());
+  const fresh = (nodes) => {
+    for (const b of collectBlocks(nodes)) pieces.push({ text: b.text, kind: b.kind });
+  };
+  segments.forEach((seg, i) => {
+    if (seg.id === void 0) return fresh(seg.nodes);
+    const id = seg.id;
+    const block = src.blocks[id];
+    if (verbatim.get(id) === i) return void pieces.push({ text: block.raw, id, kind: "block" });
+    if (owned.has(id)) return fresh(seg.nodes);
+    owned.add(id);
+    if (block.elementCount === 1) {
+      const j = seg.nodes.findIndex((n) => isElement(n) && n.outerHTML === block.snapshot);
+      if (j >= 0) {
+        fresh(seg.nodes.slice(0, j));
+        pieces.push({ text: block.raw, id, kind: "block" });
+        fresh(seg.nodes.slice(j + 1));
+        return;
+      }
+    }
+    pieces.push({ text: serializeChangedBlock(seg.nodes, block), id, kind: "block" });
+  });
+  if (pieces.length === 0) return "";
+  const used = /* @__PURE__ */ new Set();
+  const hasContent = (gap) => gap.trim() !== "";
+  const separator = (a, b) => {
+    if (a.id !== void 0 && b.id === a.id + 1) {
+      used.add(a.id);
+      return src.gaps[a.id];
+    }
+    const fallback = a.kind === "div" || b.kind === "div" ? "\n" : "\n\n";
+    if (a.id === void 0 || used.has(a.id)) return fallback;
+    const upto = b.id !== void 0 && b.id > a.id ? b.id : a.id + 1;
+    const range = [];
+    for (let g = a.id; g < upto; g++) if (!used.has(g)) range.push(g);
+    for (const g of range) used.add(g);
+    const kept = range.map((g) => src.gaps[g]).filter(hasContent).map((g) => g.trim());
+    if (kept.length > 0) return `
+
+${kept.join("\n\n")}
+
+`;
+    const own = src.gaps[a.id];
+    return (own.match(/\n/g)?.length ?? 0) >= 2 ? own : fallback;
+  };
+  let out = src.leading;
+  pieces.forEach((piece, i) => {
+    if (i > 0) out += separator(pieces[i - 1], piece);
+    out += piece.text;
+  });
+  const lastId = src.blocks.length - 1;
+  const trailing = src.gaps[lastId];
+  if (pieces[pieces.length - 1].id === lastId && !used.has(lastId)) {
+    used.add(lastId);
+    out += trailing;
+  } else {
+    const orphans = src.gaps.filter((gap, g) => !used.has(g) && hasContent(gap)).map((gap) => gap.trim());
+    if (orphans.length > 0) out += `
+
+${orphans.join("\n\n")}`;
+    out += /\s*$/.exec(trailing)[0];
+  }
+  return out;
+}
+function serializeChangedBlock(nodes, block) {
+  const elements = nodes.filter(isElement);
+  if (elements.length === 1) {
+    const el = elements[0];
+    const tag = tagOf(el);
+    if (block.list && (tag === "ul" || tag === "ol")) return serializeListWithSource(el, block.list);
+    if (block.table && tag === "table") return serializeTableWithSource(el, block.table);
+  }
+  return joinBlocks(collectBlocks(nodes));
+}
+function serializeListWithSource(list, info) {
+  const ordered = tagOf(list) === "ol";
+  const children = Array.from(list.children);
+  const verbatim = /* @__PURE__ */ new Map();
+  for (const li of children) {
+    if (tagOf(li) !== "li") continue;
+    const k = indexAttr(li, ITEM_ATTR, info.items.length);
+    if (k !== void 0 && !verbatim.has(k) && li.outerHTML === info.itemSnapshots[k]) verbatim.set(k, li);
+  }
+  const owned = new Set(verbatim.keys());
+  const out = [];
+  let num = ordered ? (Number.parseInt(list.getAttribute("start") ?? "1", 10) || 1) - 1 : 0;
+  const numberOf = (k) => Number(/^\s*(\d+)/.exec(info.items[k])?.[1] ?? Number.NaN);
+  for (const child of children) {
+    const tag = tagOf(child);
+    if (tag === "ul" || tag === "ol") {
+      const nested = indent(serializeList(child), ordered ? 3 : 2);
+      if (out.length > 0) out[out.length - 1].text += `
+${nested}`;
+      else out.push({ text: nested });
+      continue;
+    }
+    if (tag !== "li") continue;
+    const k = indexAttr(child, ITEM_ATTR, info.items.length);
+    if (k !== void 0 && verbatim.get(k) === child) {
+      if (ordered && !Number.isNaN(numberOf(k))) num = numberOf(k);
+      out.push({ text: info.items[k], k });
+      continue;
+    }
+    const mine = k !== void 0 && !owned.has(k) ? k : void 0;
+    if (mine !== void 0) owned.add(mine);
+    num = ordered && mine !== void 0 && !Number.isNaN(numberOf(mine)) ? numberOf(mine) : num + 1;
+    const marker = ordered ? `${num}${info.delimiter} ` : `${info.bullet} `;
+    out.push({
+      text: `${marker}${indent(serializeListItem(child), marker.length, true)}`.replace(/[ \t]+$/, ""),
+      k: mine
+    });
+  }
+  let last;
+  let text = "";
+  out.forEach((item, i) => {
+    if (i > 0) {
+      const prev = out[i - 1];
+      const sep = prev.k !== void 0 && item.k === prev.k + 1 ? info.itemGaps[prev.k] : last ?? info.itemGaps[0] ?? (info.loose ? "\n\n" : "\n");
+      last = sep;
+      text += sep;
+    }
+    text += item.text;
+  });
+  return text;
+}
+function serializeTableWithSource(table, info) {
+  const rows = tableRows(table);
+  if (rows.length === 0) return "";
+  const claimed = /* @__PURE__ */ new Set();
+  const lines = [];
+  rows.forEach((tr, i) => {
+    const r = indexAttr(tr, ROW_ATTR, info.lines.length);
+    if (r !== void 0 && r !== 1 && !claimed.has(r) && tr.outerHTML === info.rowSnapshots.get(r)) {
+      claimed.add(r);
+      lines.push(info.lines[r]);
+    } else {
+      lines.push(serializeTableRow(tr));
+    }
+    if (i === 0) {
+      lines.push(tableCells(tr).length === info.columns ? info.lines[1] : tableDelimiterRow(tr));
+    }
+  });
+  return lines.join("\n");
+}
+var BLOCK_TAGS = /* @__PURE__ */ new Set([
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "details",
+  "dialog",
+  "div",
+  "dl",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hgroup",
+  "hr",
+  "li",
+  "main",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "table",
+  "ul"
+]);
+function isElement(node) {
+  return node.nodeType === 1;
+}
+function tagOf(node) {
+  return isElement(node) ? node.tagName.toLowerCase() : "";
+}
+function isCustomTag(tag) {
+  return tag !== "" && !STANDARD_HTML_TAGS.has(tag);
+}
+function isBlockNode(node) {
+  return isElement(node) && BLOCK_TAGS.has(tagOf(node));
+}
+function collectBlocks(parent) {
+  const blocks = [];
+  let run = [];
+  const flush = () => {
+    if (run.length === 0) return;
+    const text = serializeInlineRun(run);
+    run = [];
+    if (text.trim() !== "") blocks.push({ kind: "inline", text });
+  };
+  const nodes = Array.isArray(parent) ? parent : Array.from(parent.childNodes);
+  for (const child of nodes) {
+    if (isBlockNode(child)) {
+      flush();
+      const el = child;
+      const tag = tagOf(el);
+      blocks.push({ kind: tag === "div" ? "div" : "block", text: serializeBlock(el), tag });
+    } else {
+      run.push(child);
+    }
+  }
+  flush();
+  return blocks;
+}
+function joinBlocks(blocks) {
+  let out = "";
+  blocks.forEach((b, i) => {
+    if (i > 0) {
+      const prev = blocks[i - 1];
+      out += prev.kind === "div" || b.kind === "div" ? "\n" : "\n\n";
+    }
+    out += b.text;
+  });
+  return out;
+}
+function serializeBlocks(parent) {
+  return joinBlocks(collectBlocks(parent));
+}
+function serializeBlock(el) {
+  const tag = tagOf(el);
+  switch (tag) {
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+      return `${"#".repeat(Number(tag[1]))} ${serializeInline(el).trim()}`;
+    case "p":
+    case "div":
+      return trimEdgeNewlines(serializeInline(el, true));
+    case "ul":
+    case "ol":
+      return serializeList(el);
+    case "pre":
+      return serializePre(el);
+    case "blockquote":
+      return serializeBlocks(el).split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n");
+    case "hr":
+      return "---";
+    case "table":
+      return serializeTable(el);
+    default:
+      return serializeBlocks(el);
+  }
+}
+function tableRows(table) {
+  return Array.from(table.querySelectorAll("tr")).filter((tr) => tr.closest("table") === table);
+}
+function tableCells(tr) {
+  return Array.from(tr.children).filter((c) => tagOf(c) === "td" || tagOf(c) === "th");
+}
+function serializeTableCell(cell) {
+  const children = Array.from(cell.childNodes);
+  while (children.length > 0 && tagOf(children[children.length - 1]) === "br") children.pop();
+  return children.map((n) => tagOf(n) === "br" ? "<br>" : serializeInlineNode(n)).join("").replace(/\n/g, " ").replace(/\|/g, "\\|").trim();
+}
+function serializeTableRow(tr) {
+  return `| ${tableCells(tr).map(serializeTableCell).join(" | ")} |`;
+}
+function tableDelimiterRow(header) {
+  const marks = tableCells(header).map((cell) => {
+    const align = cell.getAttribute("align") || cell.style?.textAlign || "";
+    if (align === "left") return ":---";
+    if (align === "center") return ":---:";
+    if (align === "right") return "---:";
+    return "---";
+  });
+  return `| ${marks.join(" | ")} |`;
+}
+function serializeTable(table) {
+  const rows = tableRows(table);
+  if (rows.length === 0) return "";
+  const lines = rows.map(serializeTableRow);
+  lines.splice(1, 0, tableDelimiterRow(rows[0]));
+  return lines.join("\n");
+}
+function serializePre(el) {
+  const code = el.querySelector("code");
+  const lang = /(?:^|\s)language-(\S+)/.exec(code?.getAttribute("class") ?? "")?.[1] ?? "";
+  const text = (code ?? el).textContent ?? "";
+  return `\`\`\`${lang}
+${text.replace(/\n$/, "")}
+\`\`\``;
+}
+function serializeList(list) {
+  const ordered = tagOf(list) === "ol";
+  let n = ordered ? Number.parseInt(list.getAttribute("start") ?? "1", 10) || 1 : 0;
+  const items = Array.from(list.children);
+  const loose = items.some(
+    (li) => tagOf(li) === "li" && Array.from(li.children).some((c) => tagOf(c) === "p")
+  );
+  const out = [];
+  for (const item of items) {
+    const tag = tagOf(item);
+    if (tag === "ul" || tag === "ol") {
+      const nested = indent(serializeList(item), ordered ? 3 : 2);
+      if (out.length > 0) out[out.length - 1] += `
+${nested}`;
+      else out.push(nested);
+      continue;
+    }
+    if (tag !== "li") continue;
+    const marker = ordered ? `${n++}. ` : "- ";
+    out.push(`${marker}${indent(serializeListItem(item), marker.length, true)}`.replace(/[ \t]+$/, ""));
+  }
+  return out.join(loose ? "\n\n" : "\n");
+}
+function serializeListItem(li) {
+  const blocks = collectBlocks(li);
+  let out = "";
+  blocks.forEach((b, i) => {
+    if (i > 0) out += b.tag === "ul" || b.tag === "ol" ? "\n" : "\n\n";
+    out += b.text;
+  });
+  return out;
+}
+function indent(text, width, skipFirst = false) {
+  const pad = " ".repeat(width);
+  return text.split("\n").map((line, i) => line === "" || skipFirst && i === 0 ? line : pad + line).join("\n");
+}
+function trimEdgeNewlines(text) {
+  return text.replace(/^\n+/, "").replace(/\n+$/, "");
+}
+function serializeInlineRun(nodes) {
+  return trimEdgeNewlines(nodes.map((n) => serializeInlineNode(n)).join(""));
+}
+function serializeInline(el, dropTrailingBr = false) {
+  const children = Array.from(el.childNodes);
+  if (dropTrailingBr) {
+    while (children.length > 0) {
+      const last = children[children.length - 1];
+      if (tagOf(last) === "br") children.pop();
+      else break;
+    }
+  }
+  return children.map((n) => serializeInlineNode(n)).join("");
+}
+function serializeInlineNode(node) {
+  if (node.nodeType === 3) return (node.textContent ?? "").replace(/ /g, " ");
+  if (!isElement(node)) return "";
+  const tag = tagOf(node);
+  if (isCustomTag(tag)) return node.outerHTML;
+  if (BLOCK_TAGS.has(tag)) return serializeBlock(node);
+  const inner = () => serializeInline(node);
+  switch (tag) {
+    case "br":
+      return "\n";
+    case "strong":
+    case "b":
+      return `**${inner()}**`;
+    case "em":
+    case "i":
+      return `*${inner()}*`;
+    case "s":
+    case "strike":
+    case "del":
+      return `~~${inner()}~~`;
+    case "code":
+      return `\`${node.textContent ?? ""}\``;
+    case "a": {
+      const href = node.getAttribute("href");
+      if (href == null) return inner();
+      const title = node.getAttribute("title");
+      return `[${inner()}](${href}${title ? ` "${title}"` : ""})`;
+    }
+    case "img": {
+      const title = node.getAttribute("title");
+      return `![${node.getAttribute("alt") ?? ""}](${node.getAttribute("src") ?? ""}${title ? ` "${title}"` : ""})`;
+    }
+    default:
+      return inner();
+  }
+}
+function legacyHtmlToMarkdown(html) {
+  let md = html;
+  md = md.replace(/<h1[^>]*>(.*?)<\/h1>/gi, "# $1\n");
+  md = md.replace(/<h2[^>]*>(.*?)<\/h2>/gi, "## $1\n");
+  md = md.replace(/<h3[^>]*>(.*?)<\/h3>/gi, "### $1\n");
+  md = md.replace(/<h4[^>]*>(.*?)<\/h4>/gi, "#### $1\n");
+  md = md.replace(/<h5[^>]*>(.*?)<\/h5>/gi, "##### $1\n");
+  md = md.replace(/<h6[^>]*>(.*?)<\/h6>/gi, "###### $1\n");
+  md = md.replace(/<li[^>]*>(.*?)<\/li>/gi, "- $1\n");
+  md = md.replace(/<\/?[uo]l[^>]*>/gi, "\n");
+  md = md.replace(/<strong[^>]*>(.*?)<\/strong>/gi, "**$1**");
+  md = md.replace(/<b[^>]*>(.*?)<\/b>/gi, "**$1**");
+  md = md.replace(/<em[^>]*>(.*?)<\/em>/gi, "*$1*");
+  md = md.replace(/<i[^>]*>(.*?)<\/i>/gi, "*$1*");
+  md = md.replace(/<u[^>]*>(.*?)<\/u>/gi, "$1");
+  md = md.replace(/<s[^>]*>(.*?)<\/s>/gi, "~~$1~~");
+  md = md.replace(/<strike[^>]*>(.*?)<\/strike>/gi, "~~$1~~");
+  md = md.replace(/<del[^>]*>(.*?)<\/del>/gi, "~~$1~~");
+  md = md.replace(/<code[^>]*>(.*?)<\/code>/gi, "`$1`");
+  md = md.replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi, "[$2]($1)");
+  md = md.replace(/<blockquote[^>]*>(.*?)<\/blockquote>/gi, "> $1\n");
+  md = md.replace(/<br\s*\/?>/gi, "\n");
+  md = md.replace(/<p[^>]*>(.*?)<\/p>/gi, "$1\n\n");
+  md = md.replace(/<div[^>]*>(.*?)<\/div>/gi, "$1\n");
+  md = md.replace(/<\/?([a-z][a-z0-9]*)\b[^>]*>/gi, (match, tagName) => {
+    return STANDARD_HTML_TAGS.has(tagName.toLowerCase()) ? "" : match;
+  });
+  md = md.replace(/&lt;/g, "<");
+  md = md.replace(/&gt;/g, ">");
+  md = md.replace(/&quot;/g, '"');
+  md = md.replace(/&#39;/g, "'");
+  md = md.replace(/&nbsp;/g, " ");
+  md = md.replace(/&amp;/g, "&");
+  md = md.replace(/\n{3,}/g, "\n\n");
+  md = md.trim();
+  return md;
+}
+function extensionEditorClasses(extensions) {
+  if (extensions.length === 0) return "";
+  return extensions.map((ext) => {
+    const tag = ext.tag.toLowerCase();
+    return [
+      `[&_${tag}]:block`,
+      `[&_${tag}]:my-2`,
+      `[&_${tag}]:rounded-lg`,
+      `[&_${tag}]:border`,
+      `[&_${tag}]:border-dashed`,
+      `[&_${tag}]:border-zinc-300`,
+      `[&_${tag}]:bg-zinc-50`,
+      `[&_${tag}]:p-3`,
+      `[&_${tag}]:text-xs`,
+      `dark:[&_${tag}]:border-zinc-600`,
+      `dark:[&_${tag}]:bg-zinc-800/50`
+    ].join(" ");
+  }).join(" ");
+}
+function RenderedContent({
+  html,
+  extensions: instanceExtensions,
+  unsafe = false
+}) {
+  const extensions = react.useMemo(
+    () => mergeExtensions(instanceExtensions),
+    [instanceExtensions]
+  );
+  const segments = react.useMemo(
+    () => parseSegments(html, extensions),
+    [html, extensions]
+  );
+  const renderHtml = (content) => unsafe ? content : chunkX2FC7ODX_cjs.sanitizeHtml(content);
+  if (segments.length === 1 && segments[0].type === "html") {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { dangerouslySetInnerHTML: { __html: renderHtml(segments[0].content) } });
+  }
+  if (segments.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: segments.map((segment, i) => {
+    if (segment.type === "html") {
+      return segment.content ? /* @__PURE__ */ jsxRuntime.jsx("div", { dangerouslySetInnerHTML: { __html: renderHtml(segment.content) } }, i) : null;
+    }
+    const ext = extensions.find(
+      (e) => e.tag.toLowerCase() === segment.tag
+    );
+    if (!ext) return null;
+    const Component = ext.component;
+    const isBlock = ext.block !== false;
+    const Wrapper = isBlock ? "div" : "span";
+    return /* @__PURE__ */ jsxRuntime.jsx(Wrapper, { "data-render-extension": segment.tag, children: /* @__PURE__ */ jsxRuntime.jsx(Component, { content: segment.content, attributes: segment.attributes }) }, i);
+  }) });
+}
+RenderedContent.displayName = "RenderedContent";
+function ContentRenderer({
+  value,
+  format = "auto",
+  lineSpacing = 1.6,
+  className,
+  extensions: instanceExtensions,
+  unsafe = false
+}) {
+  const extensions = react.useMemo(
+    () => mergeExtensions(instanceExtensions),
+    [instanceExtensions]
+  );
+  const html = react.useMemo(() => {
+    const safe = value ?? "";
+    const resolvedFormat = format === "auto" ? detectFormat(safe) : format;
+    const raw = resolvedFormat === "markdown" ? markdownToRawHtml(safe) : safe;
+    return unsafe ? raw : chunkX2FC7ODX_cjs.sanitizeHtml(raw);
+  }, [value, format, unsafe]);
+  const hasExtensions = extensions.length > 0;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "data-react-fancy-content-renderer": "",
+      style: { lineHeight: lineSpacing },
+      className: chunkZU5Q77OT_cjs.cn("text-sm", proseClasses, className),
+      children: hasExtensions ? /* @__PURE__ */ jsxRuntime.jsx(RenderedContent, { html, extensions, unsafe }) : /* @__PURE__ */ jsxRuntime.jsx("div", { dangerouslySetInnerHTML: { __html: html } })
+    }
+  );
+}
+ContentRenderer.displayName = "ContentRenderer";
+
+exports.ContentRenderer = ContentRenderer;
+exports.detectFormat = detectFormat;
+exports.extensionEditorClasses = extensionEditorClasses;
+exports.htmlToMarkdown = htmlToMarkdown;
+exports.markdownToEditorHtml = markdownToEditorHtml;
+exports.mergeExtensions = mergeExtensions;
+exports.proseClasses = proseClasses;
+exports.registerExtension = registerExtension;
+exports.registerExtensions = registerExtensions;
+exports.renderMarkdown = renderMarkdown;
+//# sourceMappingURL=chunk-MCQJFMDP.cjs.map
+//# sourceMappingURL=chunk-MCQJFMDP.cjs.map