@vicacha-devs/astro-tiptap-blocks 1.2.0 → 1.2.1

package/README.md

@@ -163,6 +163,12 @@ pnpm check && pnpm build
 
 ---
 
+## TODO
+
+- [ ] Remove the `conventional-changelog-writer` override from `pnpm-workspace.yaml` once `semantic-release` ships `@semantic-release/release-notes-generator@15` (the `conventionalcommits@10` preset needs writer 9, but `release-notes-generator@14` bundles writer 8).
+
+---
+
 ## License
 
 MIT © Vicacha Devs

package/dist/lib/html-parser/html-custom-blocks.js

@@ -154,7 +154,21 @@ export const convertCustomHtmlElement = (el, convertTree) => {
             const propKey = k
                 .replace(/^data-/, "")
                 .replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-            attrs[propKey] = v;
+            if (propKey === "__proto__" ||
+                propKey === "constructor" ||
+                propKey === "prototype" ||
+                /^on[a-z]/i.test(propKey)) {
+                continue;
+            }
+            if (/^(?:src|href|url|action|formaction)$|(?:Url|Href|Src|Uri)$/.test(propKey)) {
+                const safeVal = sanitizeTiptapUrl(v);
+                if (safeVal === "#")
+                    return [];
+                attrs[propKey] = safeVal;
+            }
+            else {
+                attrs[propKey] = v;
+            }
         }
         return [{ type: customNodeType, attrs }];
     }

package/dist/lib/html-parser/html-inline.d.ts

@@ -1,17 +1,6 @@
-import type { TiptapInlineNode, TiptapMark } from "../../types";
-export interface HtmlToken {
-    type: "open" | "close" | "self" | "text";
-    tag?: string;
-    attrs?: Record<string, string>;
-    text?: string;
-}
-export interface SimpleElement {
-    tag: string;
-    attrs: Record<string, string>;
-    children: Array<SimpleElement | string>;
-}
-export declare const tokenizeHtml: (html: string) => HtmlToken[];
-export declare const buildElementTree: (tokens: HtmlToken[]) => Array<SimpleElement | string>;
-export declare const extractRawText: (nodes: Array<SimpleElement | string>) => string;
-export declare const parseInlineStyleProps: (style?: string) => Record<string, string>;
+import type { TiptapBlockNode, TiptapInlineNode, TiptapMark } from "../../types";
+import { type SimpleElement } from "./html-tokenizer";
+export * from "./html-tokenizer";
+export declare const BLOCK_CHILD_TAGS: Set<string>;
 export declare const collectInlineNodes: (nodes: Array<SimpleElement | string>, activeMarks?: TiptapMark[]) => TiptapInlineNode[];
+export declare const convertTableElement: (el: SimpleElement, convertTree: (nodes: Array<SimpleElement | string>) => TiptapBlockNode[]) => TiptapBlockNode[];

package/dist/lib/html-parser/html-inline.js

@@ -1,93 +1,19 @@
 import { decodeHtmlEntities, sanitizeCssColor, sanitizeCssDimension, sanitizeCssFontFamily, sanitizeTiptapUrl, } from "../sanitize";
-const SELF_CLOSING_TAGS = new Set(["br", "hr", "img", "input", "meta", "link", "source"]);
-const IGNORED_CONTAINERS = new Set(["script", "style", "object", "embed"]);
-const parseAttributes = (attrString) => {
-    const attrs = {};
-    const attrRegex = /([a-zA-Z0-9_:-]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
-    let match;
-    while ((match = attrRegex.exec(attrString)) !== null) {
-        const key = match[1].toLowerCase();
-        const val = match[2] ?? match[3] ?? match[4] ?? "";
-        attrs[key] = decodeHtmlEntities(val);
-    }
-    return attrs;
-};
-export const tokenizeHtml = (html) => {
-    const sanitized = html
-        .replace(/<!--[\s\S]*?-->/g, "")
-        .replace(/<(script|style|object|embed)\b[^>]*>[\s\S]*?<\/\1>/gi, "");
-    const tokens = [];
-    const tagRegex = /<\/?([a-zA-Z0-9-]+)([^>]*)>/g;
-    let lastIndex = 0;
-    let match;
-    while ((match = tagRegex.exec(sanitized)) !== null) {
-        if (match.index > lastIndex) {
-            tokens.push({ type: "text", text: sanitized.slice(lastIndex, match.index) });
-        }
-        const fullMatch = match[0];
-        const tag = match[1].toLowerCase();
-        const rawAttrs = match[2] || "";
-        const isClosing = fullMatch.startsWith("</");
-        const isSelfClosing = fullMatch.endsWith("/>") || SELF_CLOSING_TAGS.has(tag);
-        if (!IGNORED_CONTAINERS.has(tag)) {
-            if (isClosing)
-                tokens.push({ type: "close", tag });
-            else if (isSelfClosing)
-                tokens.push({ type: "self", tag, attrs: parseAttributes(rawAttrs) });
-            else
-                tokens.push({ type: "open", tag, attrs: parseAttributes(rawAttrs) });
-        }
-        lastIndex = tagRegex.lastIndex;
-    }
-    if (lastIndex < sanitized.length) {
-        tokens.push({ type: "text", text: sanitized.slice(lastIndex) });
-    }
-    return tokens;
-};
-export const buildElementTree = (tokens) => {
-    const root = { tag: "root", attrs: {}, children: [] };
-    const stack = [root];
-    for (const token of tokens) {
-        const current = stack[stack.length - 1];
-        if (token.type === "text" && token.text !== undefined) {
-            current.children.push(token.text);
-        }
-        else if (token.type === "self" && token.tag) {
-            current.children.push({ tag: token.tag, attrs: token.attrs || {}, children: [] });
-        }
-        else if (token.type === "open" && token.tag) {
-            const el = { tag: token.tag, attrs: token.attrs || {}, children: [] };
-            current.children.push(el);
-            stack.push(el);
-        }
-        else if (token.type === "close" && token.tag) {
-            for (let i = stack.length - 1; i >= 1; i--) {
-                if (stack[i].tag === token.tag) {
-                    stack.length = i;
-                    break;
-                }
-            }
-        }
-    }
-    return root.children;
-};
-export const extractRawText = (nodes) => nodes
-    .map((n) => typeof n === "string"
-    ? decodeHtmlEntities(n)
-    : n.tag === "br"
-        ? "\n"
-        : extractRawText(n.children))
-    .join("");
-export const parseInlineStyleProps = (style) => {
-    const map = {};
-    if (!style)
-        return map;
-    for (const part of style.split(";")) {
-        const idx = part.indexOf(":");
-        if (idx > 0)
-            map[part.slice(0, idx).trim().toLowerCase()] = part.slice(idx + 1).trim();
-    }
-    return map;
+import { extractRawText, parseInlineStyleProps } from "./html-tokenizer";
+export * from "./html-tokenizer";
+export const BLOCK_CHILD_TAGS = new Set(["p", "ul", "ol", "blockquote", "pre", "table", "details"]);
+const TAG_TO_MARK = {
+    strong: "bold",
+    b: "bold",
+    em: "italic",
+    i: "italic",
+    u: "underline",
+    s: "strike",
+    strike: "strike",
+    del: "strike",
+    code: "code",
+    sub: "subscript",
+    sup: "superscript",
 };
 export const collectInlineNodes = (nodes, activeMarks = []) => {
     const result = [];
@@ -127,20 +53,9 @@ export const collectInlineNodes = (nodes, activeMarks = []) => {
         }
         const nextMarks = [...activeMarks];
         const styles = parseInlineStyleProps(node.attrs.style);
-        if (node.tag === "strong" || node.tag === "b")
-            nextMarks.push({ type: "bold" });
-        else if (node.tag === "em" || node.tag === "i")
-            nextMarks.push({ type: "italic" });
-        else if (node.tag === "u")
-            nextMarks.push({ type: "underline" });
-        else if (node.tag === "s" || node.tag === "strike" || node.tag === "del")
-            nextMarks.push({ type: "strike" });
-        else if (node.tag === "code")
-            nextMarks.push({ type: "code" });
-        else if (node.tag === "sub")
-            nextMarks.push({ type: "subscript" });
-        else if (node.tag === "sup")
-            nextMarks.push({ type: "superscript" });
+        const simpleMarkType = TAG_TO_MARK[node.tag];
+        if (simpleMarkType)
+            nextMarks.push({ type: simpleMarkType });
         else if (node.tag === "abbr")
             nextMarks.push({ type: "abbr", attrs: { title: node.attrs.title || null } });
         else if (node.tag === "mark") {
@@ -179,3 +94,37 @@ export const collectInlineNodes = (nodes, activeMarks = []) => {
     }
     return result;
 };
+export const convertTableElement = (el, convertTree) => {
+    const rows = [];
+    const collectRows = (children) => {
+        for (const child of children) {
+            if (typeof child === "string")
+                continue;
+            if (child.tag === "tr") {
+                const cells = child.children
+                    .filter((c) => typeof c !== "string" && (c.tag === "td" || c.tag === "th"))
+                    .map((cell) => {
+                    const styles = parseInlineStyleProps(cell.attrs.style);
+                    const bg = sanitizeCssColor(cell.attrs["data-background-color"] || styles["background-color"]);
+                    const hasBlocks = cell.children.some((c) => typeof c !== "string" && BLOCK_CHILD_TAGS.has(c.tag));
+                    return {
+                        type: cell.tag === "th" ? "tableHeader" : "tableCell",
+                        attrs: {
+                            ...(cell.attrs.colspan ? { colspan: Number(cell.attrs.colspan) } : {}),
+                            ...(cell.attrs.rowspan ? { rowspan: Number(cell.attrs.rowspan) } : {}),
+                            ...(bg ? { backgroundColor: bg } : {}),
+                        },
+                        content: hasBlocks
+                            ? convertTree(cell.children)
+                            : [{ type: "paragraph", content: collectInlineNodes(cell.children) }],
+                    };
+                });
+                rows.push({ type: "tableRow", content: cells });
+            }
+            else if (["thead", "tbody", "tfoot"].includes(child.tag))
+                collectRows(child.children);
+        }
+    };
+    collectRows(el.children);
+    return [{ type: "table", content: rows }];
+};

package/dist/lib/html-parser/html-parser.js

@@ -1,23 +1,18 @@
-import { decodeHtmlEntities, sanitizeCssColor, sanitizeTiptapUrl } from "../sanitize";
+import { decodeHtmlEntities, sanitizeTiptapSrcset, sanitizeTiptapUrl } from "../sanitize";
 import { convertCustomHtmlElement, findChildByTag } from "./html-custom-blocks";
-import { buildElementTree, collectInlineNodes, extractRawText, parseInlineStyleProps, tokenizeHtml, } from "./html-inline";
+import { BLOCK_CHILD_TAGS, buildElementTree, collectInlineNodes, convertTableElement, extractRawText, parseInlineStyleProps, tokenizeHtml, } from "./html-inline";
 const extractBaseBlockAttrs = (el) => {
     const styles = parseInlineStyleProps(el.attrs.style);
     const textAlign = (el.attrs["data-text-align"] ||
         styles["text-align"] ||
         null);
     const dir = (el.attrs.dir || null);
-    return {
-        ...(textAlign ? { textAlign } : {}),
-        ...(dir ? { dir } : {}),
-    };
+    return { ...(textAlign ? { textAlign } : {}), ...(dir ? { dir } : {}) };
 };
 const convertElementToBlocks = (el) => {
     const custom = convertCustomHtmlElement(el, convertTreeToBlocks);
-    if (custom !== null) {
+    if (custom !== null)
         return custom;
-    }
-    const dataType = el.attrs["data-type"] || "";
     if (/^h[1-6]$/.test(el.tag)) {
         const level = Number(el.attrs["data-level"] || el.tag[1]);
         const seoTag = (el.attrs["data-seo-tag"] || null);
@@ -56,7 +51,7 @@ const convertElementToBlocks = (el) => {
             },
         ];
     }
-    if (el.tag === "ul" && dataType === "taskList") {
+    if (el.tag === "ul" && el.attrs["data-type"] === "taskList") {
         const items = el.children
             .filter((c) => typeof c !== "string" && c.tag === "li")
             .map((li) => ({
@@ -69,16 +64,23 @@ const convertElementToBlocks = (el) => {
     if (el.tag === "ul" || el.tag === "ol") {
         const items = el.children
             .filter((c) => typeof c !== "string" && c.tag === "li")
-            .map((li) => {
-            const hasBlock = li.children.some((c) => typeof c !== "string" && ["p", "ul", "ol", "blockquote"].includes(c.tag));
-            return {
-                type: "listItem",
-                content: hasBlock
-                    ? convertTreeToBlocks(li.children)
-                    : [{ type: "paragraph", content: collectInlineNodes(li.children) }],
-            };
-        });
-        return [{ type: el.tag === "ol" ? "orderedList" : "bulletList", content: items }];
+            .map((li) => ({
+            type: "listItem",
+            content: li.children.some((c) => typeof c !== "string" && BLOCK_CHILD_TAGS.has(c.tag))
+                ? convertTreeToBlocks(li.children)
+                : [{ type: "paragraph", content: collectInlineNodes(li.children) }],
+        }));
+        if (el.tag === "ol") {
+            const startAttr = el.attrs.start ? Number(el.attrs.start) : undefined;
+            return [
+                {
+                    type: "orderedList",
+                    ...(startAttr && startAttr > 1 ? { attrs: { start: startAttr } } : {}),
+                    content: items,
+                },
+            ];
+        }
+        return [{ type: "bulletList", content: items }];
     }
     if (el.tag === "pre") {
         const codeEl = findChildByTag(el, "code");
@@ -108,6 +110,7 @@ const convertElementToBlocks = (el) => {
         const src = sanitizeTiptapUrl(el.attrs.src);
         if (src === "#")
             return [];
+        const safeSrcset = sanitizeTiptapSrcset(el.attrs.srcset);
         return [
             {
                 type: "image",
@@ -118,6 +121,8 @@ const convertElementToBlocks = (el) => {
                     "caption": el.attrs["data-caption"] || null,
                     "width": el.attrs.width || null,
                     "height": el.attrs.height || null,
+                    ...(safeSrcset ? { srcset: safeSrcset } : {}),
+                    ...(el.attrs.sizes ? { sizes: el.attrs.sizes } : {}),
                     "data-align": el.attrs["data-align"] || null,
                     "data-asset-id": el.attrs["data-asset-id"] || null,
                     "data-document-id": el.attrs["data-document-id"] || null,
@@ -127,37 +132,8 @@ const convertElementToBlocks = (el) => {
     }
     if (el.tag === "hr")
         return [{ type: "horizontalRule" }];
-    if (el.tag === "table") {
-        const rows = [];
-        const collectRows = (children) => {
-            for (const child of children) {
-                if (typeof child === "string")
-                    continue;
-                if (child.tag === "tr") {
-                    const cells = child.children
-                        .filter((c) => typeof c !== "string" && (c.tag === "td" || c.tag === "th"))
-                        .map((cell) => {
-                        const styles = parseInlineStyleProps(cell.attrs.style);
-                        const bg = sanitizeCssColor(cell.attrs["data-background-color"] || styles["background-color"]);
-                        return {
-                            type: cell.tag === "th" ? "tableHeader" : "tableCell",
-                            attrs: {
-                                ...(cell.attrs.colspan ? { colspan: Number(cell.attrs.colspan) } : {}),
-                                ...(cell.attrs.rowspan ? { rowspan: Number(cell.attrs.rowspan) } : {}),
-                                ...(bg ? { backgroundColor: bg } : {}),
-                            },
-                            content: [{ type: "paragraph", content: collectInlineNodes(cell.children) }],
-                        };
-                    });
-                    rows.push({ type: "tableRow", content: cells });
-                }
-                else if (["thead", "tbody", "tfoot"].includes(child.tag))
-                    collectRows(child.children);
-            }
-        };
-        collectRows(el.children);
-        return [{ type: "table", content: rows }];
-    }
+    if (el.tag === "table")
+        return convertTableElement(el, convertTreeToBlocks);
     return convertTreeToBlocks(el.children);
 };
 export const convertTreeToBlocks = (nodes) => {

package/dist/lib/html-parser/html-tokenizer.d.ts

@@ -0,0 +1,15 @@
+export interface HtmlToken {
+    type: "open" | "close" | "self" | "text";
+    tag?: string;
+    attrs?: Record<string, string>;
+    text?: string;
+}
+export interface SimpleElement {
+    tag: string;
+    attrs: Record<string, string>;
+    children: Array<SimpleElement | string>;
+}
+export declare const tokenizeHtml: (html: string) => HtmlToken[];
+export declare const buildElementTree: (tokens: HtmlToken[]) => Array<SimpleElement | string>;
+export declare const extractRawText: (nodes: Array<SimpleElement | string>) => string;
+export declare const parseInlineStyleProps: (style?: string) => Record<string, string>;

package/dist/lib/html-parser/html-tokenizer.js

@@ -0,0 +1,91 @@
+import { decodeHtmlEntities } from "../sanitize";
+const SELF_CLOSING_TAGS = new Set(["br", "hr", "img", "input", "meta", "link", "source"]);
+const IGNORED_CONTAINERS = new Set(["script", "style", "object", "embed"]);
+const parseAttributes = (attrString) => {
+    const attrs = {};
+    const attrRegex = /([a-zA-Z0-9_:-]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+    let match;
+    while ((match = attrRegex.exec(attrString)) !== null) {
+        const key = match[1].toLowerCase();
+        const val = match[2] ?? match[3] ?? match[4] ?? "";
+        attrs[key] = decodeHtmlEntities(val);
+    }
+    return attrs;
+};
+export const tokenizeHtml = (html) => {
+    const sanitized = html
+        .replace(/<!--[\s\S]*?-->/g, "")
+        .replace(/<(script|style|object|embed)\b[^>]*>[\s\S]*?<\/\1>/gi, "");
+    const tokens = [];
+    const tagRegex = /<\/?([a-zA-Z0-9-]+)((?:"[^"]*"|'[^']*'|[^>"'])*)>/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = tagRegex.exec(sanitized)) !== null) {
+        if (match.index > lastIndex) {
+            tokens.push({ type: "text", text: sanitized.slice(lastIndex, match.index) });
+        }
+        const fullMatch = match[0];
+        const tag = match[1].toLowerCase();
+        const rawAttrs = match[2] || "";
+        const isClosing = fullMatch.startsWith("</");
+        const isSelfClosing = fullMatch.endsWith("/>") || SELF_CLOSING_TAGS.has(tag);
+        if (!IGNORED_CONTAINERS.has(tag)) {
+            if (isClosing)
+                tokens.push({ type: "close", tag });
+            else if (isSelfClosing)
+                tokens.push({ type: "self", tag, attrs: parseAttributes(rawAttrs) });
+            else
+                tokens.push({ type: "open", tag, attrs: parseAttributes(rawAttrs) });
+        }
+        lastIndex = tagRegex.lastIndex;
+    }
+    if (lastIndex < sanitized.length) {
+        tokens.push({ type: "text", text: sanitized.slice(lastIndex) });
+    }
+    return tokens;
+};
+export const buildElementTree = (tokens) => {
+    const root = { tag: "root", attrs: {}, children: [] };
+    const stack = [root];
+    for (const token of tokens) {
+        const current = stack[stack.length - 1];
+        if (token.type === "text" && token.text !== undefined) {
+            current.children.push(token.text);
+        }
+        else if (token.type === "self" && token.tag) {
+            current.children.push({ tag: token.tag, attrs: token.attrs || {}, children: [] });
+        }
+        else if (token.type === "open" && token.tag) {
+            const el = { tag: token.tag, attrs: token.attrs || {}, children: [] };
+            current.children.push(el);
+            stack.push(el);
+        }
+        else if (token.type === "close" && token.tag) {
+            for (let i = stack.length - 1; i >= 1; i--) {
+                if (stack[i].tag === token.tag) {
+                    stack.length = i;
+                    break;
+                }
+            }
+        }
+    }
+    return root.children;
+};
+export const extractRawText = (nodes) => nodes
+    .map((n) => typeof n === "string"
+    ? decodeHtmlEntities(n)
+    : n.tag === "br"
+        ? "\n"
+        : extractRawText(n.children))
+    .join("");
+export const parseInlineStyleProps = (style) => {
+    const map = {};
+    if (!style)
+        return map;
+    for (const part of style.split(";")) {
+        const idx = part.indexOf(":");
+        if (idx > 0)
+            map[part.slice(0, idx).trim().toLowerCase()] = part.slice(idx + 1).trim();
+    }
+    return map;
+};

package/dist/lib/markdown-parser/markdown-inline.d.ts

@@ -0,0 +1,5 @@
+import type { TiptapBlockNode, TiptapInlineNode } from "../../types";
+export declare const parseMarkdownInline: (text: string) => TiptapInlineNode[];
+export declare const parseMediaBlock: (kind: string, label: string, rawUrl: string) => TiptapBlockNode[];
+export declare const parseQuoteChunk: (chunk: string, parseBody: (md: string) => TiptapBlockNode[]) => TiptapBlockNode[];
+export declare const isLikelyMarkdown: (text: string) => boolean;

package/dist/lib/markdown-parser/markdown-inline.js

@@ -0,0 +1,135 @@
+import { parseTiptapHtml } from "../html-parser";
+import { sanitizeTiptapIframeUrl, sanitizeTiptapUrl } from "../sanitize";
+export const parseMarkdownInline = (text) => {
+    if (!text)
+        return [];
+    const nodes = [];
+    const tokenRe = /(\$(?!\$)([^$\n]+)\$|!\[([^\]]*)\]\(([^)\s]+)(?:\s+"([^"]*)")?\)|\[([^\]]+)\]\(([^)\s]+)(?:\s+"([^"]*)")?\)|`([^`]+)`|\*\*([^*]+)\*\*|==([^=]+)==|~~([^~]+)~~|\*([^*]+)\*|<([a-zA-Z0-9-]+)(?:\s[^>]*)?>[\s\S]*?<\/\14>)/g;
+    let lastIdx = 0;
+    let match;
+    while ((match = tokenRe.exec(text)) !== null) {
+        if (match.index > lastIdx)
+            nodes.push({ type: "text", text: text.slice(lastIdx, match.index) });
+        if (match[2] !== undefined) {
+            nodes.push({ type: "mathematics", attrs: { latex: match[2].trim(), displayMode: "inline" } });
+        }
+        else if (match[4] !== undefined) {
+            const safeHref = sanitizeTiptapUrl(match[4]);
+            if (safeHref !== "#") {
+                nodes.push({
+                    type: "text",
+                    text: match[3] || "Image",
+                    marks: [{ type: "link", attrs: { href: safeHref, title: match[5] || null } }],
+                });
+            }
+        }
+        else if (match[6] !== undefined && match[7] !== undefined) {
+            const label = match[6];
+            const rawHref = match[7];
+            if (/^(?:tiptap|internal|cms|doc):\/\//.test(rawHref)) {
+                const parts = rawHref.replace(/^[a-z]+:\/\//i, "").split("/");
+                nodes.push({
+                    type: "linker",
+                    attrs: {
+                        collectionName: parts[0] || null,
+                        documentId: parts[1] || null,
+                        label,
+                        href: rawHref,
+                    },
+                });
+            }
+            else {
+                nodes.push({
+                    type: "text",
+                    text: label,
+                    marks: [
+                        { type: "link", attrs: { href: sanitizeTiptapUrl(rawHref), title: match[8] || null } },
+                    ],
+                });
+            }
+        }
+        else if (match[9] !== undefined)
+            nodes.push({ type: "text", text: match[9], marks: [{ type: "code" }] });
+        else if (match[10] !== undefined)
+            nodes.push({ type: "text", text: match[10], marks: [{ type: "bold" }] });
+        else if (match[11] !== undefined)
+            nodes.push({ type: "text", text: match[11], marks: [{ type: "highlight" }] });
+        else if (match[12] !== undefined)
+            nodes.push({ type: "text", text: match[12], marks: [{ type: "strike" }] });
+        else if (match[13] !== undefined)
+            nodes.push({ type: "text", text: match[13], marks: [{ type: "italic" }] });
+        else if (match[14] !== undefined) {
+            const first = parseTiptapHtml(`<p>${match[0]}</p>`).content[0];
+            if (first && "content" in first && Array.isArray(first.content))
+                nodes.push(...first.content);
+        }
+        lastIdx = tokenRe.lastIndex;
+    }
+    if (lastIdx < text.length)
+        nodes.push({ type: "text", text: text.slice(lastIdx) });
+    return nodes;
+};
+export const parseMediaBlock = (kind, label, rawUrl) => {
+    if (kind === "video") {
+        const src = sanitizeTiptapUrl(rawUrl);
+        const isEmbed = /youtube\.com|youtu\.be|vimeo\.com/i.test(src);
+        return src === "#"
+            ? []
+            : [
+                {
+                    type: "video",
+                    attrs: { src, title: label, caption: label, embedType: isEmbed ? "embed" : "file" },
+                },
+            ];
+    }
+    if (kind === "audio") {
+        const src = sanitizeTiptapUrl(rawUrl);
+        return src === "#" ? [] : [{ type: "audio", attrs: { src, title: label, caption: label } }];
+    }
+    if (kind === "attachment") {
+        const href = sanitizeTiptapUrl(rawUrl);
+        return href === "#"
+            ? []
+            : [{ type: "attachment", attrs: { href, filename: label, title: label } }];
+    }
+    const src = sanitizeTiptapIframeUrl(rawUrl);
+    return src === "#" ? [] : [{ type: "iframe", attrs: { src, title: label } }];
+};
+export const parseQuoteChunk = (chunk, parseBody) => {
+    const stripped = chunk
+        .split("\n")
+        .map((l) => l.replace(/^>\s?/, ""))
+        .join("\n")
+        .trim();
+    if (stripped.startsWith("**Lead:**")) {
+        return [
+            {
+                type: "leadParagraph",
+                content: parseMarkdownInline(stripped.replace(/^\*\*Lead:\*\*\s*/, "")),
+            },
+        ];
+    }
+    const calloutMatch = /^\[!(INFO|SUCCESS|WARNING|DANGER|NEUTRAL|TIP)\](?:\s+([^\n]*))?\n?([\s\S]*)$/i.exec(stripped);
+    if (calloutMatch) {
+        const variant = calloutMatch[1].toLowerCase();
+        return [
+            {
+                type: "informationPane",
+                attrs: { variant, title: calloutMatch[2]?.trim() || null },
+                content: parseBody(calloutMatch[3] || ""),
+            },
+        ];
+    }
+    const convMatch = /^\*\*Conversation History\*\*(?:\s+\*\(([^)]+)\)\*)?\n?([\s\S]*)$/i.exec(stripped);
+    if (convMatch) {
+        return [
+            {
+                type: "conversationHistory",
+                attrs: { author: convMatch[1] || null },
+                content: parseBody(convMatch[2] || ""),
+            },
+        ];
+    }
+    return [{ type: "blockquote", content: parseBody(stripped) }];
+};
+export const isLikelyMarkdown = (text) => /(?:^|\n)(?:#{1,6}\s|>\s|[-*]\s+\[[ xX]\]\s|[-*]\s+\S|\d+\.\s+\S|```|\$\$|<!--\s*(?:tiptap-node:|pagebreak|toc)|\[(?:Video|Audio|Attachment|Embed):|!\[[^\]]*\]\([^)]+\)|\|.+\|\n\|[\s:-]+\|)/.test(text) || /(\*\*[^*]+\*\*|==[^=]+==|~~[^~]+~~|\[[^\]]+\]\([^)]+\)|\$(?!\$)[^$\n]+\$)/.test(text);

package/dist/lib/markdown-parser/markdown-parser.d.ts

@@ -1,4 +1,4 @@
-import type { TiptapDocNode, TiptapInlineNode } from "../../types";
-export declare const parseMarkdownInline: (text: string) => TiptapInlineNode[];
-export declare const isLikelyMarkdown: (text: string) => boolean;
+import type { TiptapDocNode } from "../../types";
+import { isLikelyMarkdown, parseMarkdownInline } from "./markdown-inline";
+export { isLikelyMarkdown, parseMarkdownInline };
 export declare const parseTiptapMarkdown: (markdown: string) => TiptapDocNode;