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

package/dist/lib/parser/parser.js

@@ -1,253 +1,43 @@
 import { parseTiptapHtml } from "../html-parser";
 import { isLikelyMarkdown, parseTiptapMarkdown } from "../markdown-parser";
-import { resolveInternalLinkHref } from "../relations";
-import { resolveTiptapMediaUrl, sanitizeCssColor, sanitizeTextStyleAttrs, sanitizeTiptapIframeUrl, slugifyHeadingText, } from "../sanitize";
-const extractInlineText = (nodes) => (nodes ?? [])
-    .map((n) => (n.type === "text" ? n.text : n.type === "linker" ? n.attrs.label || "" : ""))
-    .join("");
-const sanitizeMarks = (marks, options) => {
-    if (!Array.isArray(marks) || marks.length === 0)
-        return undefined;
-    const result = [];
-    for (const mark of marks) {
-        if (!mark || typeof mark !== "object" || !("type" in mark))
-            continue;
-        if (mark.type === "link") {
-            result.push({
-                ...mark,
-                attrs: {
-                    ...mark.attrs,
-                    href: resolveInternalLinkHref({ href: mark.attrs?.href }, options?.resolveInternalLink),
-                },
-            });
-        }
-        else if (mark.type === "highlight") {
-            const color = sanitizeCssColor(mark.attrs?.color);
-            result.push({ type: "highlight", ...(color ? { attrs: { color } } : {}) });
-        }
-        else if (mark.type === "textStyle") {
-            const safeAttrs = sanitizeTextStyleAttrs(mark.attrs);
-            if (safeAttrs)
-                result.push({ type: "textStyle", attrs: safeAttrs });
-        }
-        else {
-            result.push(mark);
-        }
-    }
-    return result.length > 0 ? result : undefined;
-};
-const sanitizeInlineNodes = (nodes, options) => {
-    if (!Array.isArray(nodes))
-        return [];
-    const result = [];
-    for (const node of nodes) {
-        if (!node || typeof node !== "object" || !("type" in node))
-            continue;
-        if (node.type === "text") {
-            const marks = sanitizeMarks(node.marks, options);
-            result.push({
-                type: "text",
-                text: typeof node.text === "string" ? node.text : "",
-                ...(marks ? { marks } : {}),
-            });
-        }
-        else if (node.type === "hardBreak") {
-            result.push({ type: "hardBreak" });
-        }
-        else if (node.type === "linker") {
-            const href = resolveInternalLinkHref(node.attrs || {}, options?.resolveInternalLink);
-            result.push({ ...node, attrs: { ...node.attrs, href } });
-        }
-        else if (node.type === "mathematics") {
-            result.push({
-                type: "mathematics",
-                attrs: {
-                    latex: String(node.attrs?.latex ?? ""),
-                    displayMode: node.attrs?.displayMode ?? "inline",
-                },
-            });
-        }
-    }
-    return result;
-};
-const sanitizeBlockNodes = (nodes, options) => {
-    if (!Array.isArray(nodes))
-        return [];
-    const result = [];
-    for (const node of nodes) {
-        if (!node || typeof node !== "object" || !("type" in node))
-            continue;
-        switch (node.type) {
-            case "heading": {
-                const content = sanitizeInlineNodes(node.content, options);
-                const level = (node.attrs?.level ?? 2);
-                const rawText = extractInlineText(content);
-                const id = node.attrs?.id || (rawText ? slugifyHeadingText(rawText) : null);
-                result.push({ ...node, attrs: { ...node.attrs, level, ...(id ? { id } : {}) }, content });
-                break;
-            }
-            case "paragraph":
-            case "leadParagraph":
-                result.push({ ...node, content: sanitizeInlineNodes(node.content, options) });
-                break;
-            case "blockquote":
-            case "informationPane":
-            case "conversationHistory":
-                result.push({ ...node, content: sanitizeBlockNodes(node.content, options) });
-                break;
-            case "details":
-                result.push({
-                    ...node,
-                    content: (node.content ?? [])
-                        .map((child) => {
-                        if (child.type === "detailsSummary")
-                            return {
-                                type: "detailsSummary",
-                                content: sanitizeInlineNodes(child.content, options),
-                            };
-                        if (child.type === "detailsContent")
-                            return {
-                                type: "detailsContent",
-                                content: sanitizeBlockNodes(child.content, options),
-                            };
-                        return sanitizeBlockNodes([child], options)[0];
-                    })
-                        .filter(Boolean),
-                });
-                break;
-            case "layoutContainer":
-                result.push({
-                    ...node,
-                    content: (node.content ?? []).map((col) => ({
-                        type: "layoutColumn",
-                        content: sanitizeBlockNodes(col.content, options),
-                    })),
-                });
-                break;
-            case "bulletList":
-            case "orderedList":
-                result.push({
-                    ...node,
-                    content: (node.content ?? []).map((item) => ({
-                        type: "listItem",
-                        content: sanitizeBlockNodes(item.content, options),
-                    })),
-                });
-                break;
-            case "taskList":
-                result.push({
-                    ...node,
-                    content: (node.content ?? []).map((item) => ({
-                        type: "taskItem",
-                        attrs: { checked: Boolean(item.attrs?.checked) },
-                        content: sanitizeBlockNodes(item.content, options),
-                    })),
-                });
-                break;
-            case "codeBlock":
-                result.push({
-                    ...node,
-                    content: sanitizeInlineNodes(node.content, options).filter((n) => n.type === "text"),
-                });
-                break;
-            case "image":
-            case "video":
-            case "audio": {
-                const safeSrc = resolveTiptapMediaUrl(node.attrs?.src, options);
-                if (safeSrc !== "#")
-                    result.push({ ...node, attrs: { ...node.attrs, src: safeSrc } });
-                break;
-            }
-            case "attachment": {
-                const safeHref = resolveTiptapMediaUrl(node.attrs?.href, options);
-                if (safeHref !== "#")
-                    result.push({ ...node, attrs: { ...node.attrs, href: safeHref } });
-                break;
-            }
-            case "iframe": {
-                const safeSrc = sanitizeTiptapIframeUrl(node.attrs?.src, options?.allowedIframeDomains);
-                if (safeSrc !== "#")
-                    result.push({ ...node, attrs: { ...node.attrs, src: safeSrc } });
-                break;
-            }
-            case "mathematics":
-                result.push({
-                    type: "mathematics",
-                    attrs: {
-                        latex: String(node.attrs?.latex ?? ""),
-                        displayMode: node.attrs?.displayMode ?? "block",
-                    },
-                });
-                break;
-            case "tableOfContents":
-                result.push({ ...node });
-                break;
-            case "pageBreak":
-            case "horizontalRule":
-                result.push({ type: node.type });
-                break;
-            case "table":
-                result.push({
-                    ...node,
-                    content: (node.content ?? []).map((row) => ({
-                        type: "tableRow",
-                        content: (row.content ?? []).map((cell) => ({
-                            ...cell,
-                            attrs: {
-                                ...cell.attrs,
-                                backgroundColor: sanitizeCssColor(cell.attrs?.backgroundColor),
-                            },
-                            content: sanitizeBlockNodes(cell.content, options),
-                        })),
-                    })),
-                });
-                break;
-            default: {
-                const custom = node;
-                if (typeof custom.type === "string" && custom.type.trim()) {
-                    const safeAttrs = {};
-                    let hasUnsafeUrl = false;
-                    for (const [k, v] of Object.entries(custom.attrs ?? {})) {
-                        if (typeof v === "string" && (/^(src|href)$/i.test(k) || k.endsWith("Url"))) {
-                            const resolved = resolveTiptapMediaUrl(v, options);
-                            if (resolved === "#") {
-                                hasUnsafeUrl = true;
-                                break;
-                            }
-                            safeAttrs[k] = resolved;
-                        }
-                        else
-                            safeAttrs[k] = v;
-                    }
-                    if (!hasUnsafeUrl) {
-                        result.push({
-                            type: custom.type,
-                            ...(custom.attrs ? { attrs: safeAttrs } : {}),
-                            ...(Array.isArray(custom.content)
-                                ? { content: sanitizeBlockNodes(custom.content, options) }
-                                : {}),
-                        });
-                    }
-                }
-                break;
-            }
-        }
-    }
-    return result;
-};
-const populateTocBlocks = (blocks) => {
+import { slugifyHeadingText } from "../sanitize";
+import { extractInlineText } from "./parser-inline";
+import { sanitizeBlockNodes } from "./parser-sanitize";
+const collectTocHeadings = (blocks) => {
     const headings = [];
-    for (const b of blocks) {
+    for (const b of blocks ?? []) {
         if (b.type === "heading") {
             const text = extractInlineText(b.content).trim();
-            if (text)
+            if (text) {
                 headings.push({
                     id: b.attrs?.id || slugifyHeadingText(text),
                     text,
                     level: b.attrs?.level ?? 2,
                 });
+            }
+        }
+        else if (b.type === "blockquote" ||
+            b.type === "informationPane" ||
+            b.type === "conversationHistory") {
+            headings.push(...collectTocHeadings(b.content));
+        }
+        else if (b.type === "layoutContainer") {
+            for (const col of b.content ?? [])
+                headings.push(...collectTocHeadings(col.content));
+        }
+        else if (b.type === "details") {
+            for (const child of b.content ?? []) {
+                if (child.type === "detailsContent")
+                    headings.push(...collectTocHeadings(child.content));
+                else if (child.type !== "detailsSummary")
+                    headings.push(...collectTocHeadings([child]));
+            }
         }
     }
+    return headings;
+};
+const populateTocBlocks = (blocks) => {
+    const headings = collectTocHeadings(blocks);
     return blocks.map((b) => b.type === "tableOfContents" && (!b.attrs?.headings || b.attrs.headings.length === 0)
         ? { ...b, attrs: { ...b.attrs, headings } }
         : b);

package/dist/lib/relations/relations-uri.d.ts

@@ -0,0 +1,16 @@
+import type { TiptapInternalLinkResolver } from "../../types";
+export declare const parseInternalLinkUri: (href: string | null | undefined) => {
+    collectionName: string;
+    documentId: string;
+} | null;
+export declare const formatInternalLinkUri: (collectionName: string, documentId: string) => string;
+/**
+ * Resolves an internal link URI (`tiptap://collectionName/documentId` or `linker` attributes) into a safe frontend href.
+ * Uses `resolveInternalLink` when provided, or defaults to `/<shortCollection>/<documentId>`.
+ */
+export declare const resolveInternalLinkHref: (input: {
+    href?: string | null;
+    collectionName?: string | null;
+    documentId?: string | null;
+    label?: string | null;
+}, resolver?: TiptapInternalLinkResolver) => string;

package/dist/lib/relations/relations-uri.js

@@ -0,0 +1,39 @@
+import { sanitizeTiptapUrl } from "../sanitize";
+const INTERNAL_URI_RE = /^(?:tiptap|internal|cms|doc):\/\/([a-zA-Z0-9_.:-]+)\/([a-zA-Z0-9_.:-]+)(?:\?.*)?$/;
+export const parseInternalLinkUri = (href) => {
+    if (!href || typeof href !== "string")
+        return null;
+    const match = INTERNAL_URI_RE.exec(href.trim());
+    if (!match)
+        return null;
+    return { collectionName: match[1], documentId: match[2] };
+};
+export const formatInternalLinkUri = (collectionName, documentId) => `tiptap://${collectionName.trim()}/${documentId.trim()}`;
+/**
+ * Resolves an internal link URI (`tiptap://collectionName/documentId` or `linker` attributes) into a safe frontend href.
+ * Uses `resolveInternalLink` when provided, or defaults to `/<shortCollection>/<documentId>`.
+ */
+export const resolveInternalLinkHref = (input, resolver) => {
+    const parsedFromHref = parseInternalLinkUri(input.href);
+    const collectionName = (input.collectionName || parsedFromHref?.collectionName || "").trim();
+    const documentId = (input.documentId || parsedFromHref?.documentId || "").trim();
+    if (collectionName && documentId) {
+        const rawUri = formatInternalLinkUri(collectionName, documentId);
+        if (resolver) {
+            return sanitizeTiptapUrl(resolver({
+                collectionName,
+                documentId,
+                href: rawUri,
+                label: input.label,
+            }));
+        }
+        if (input.href && !/^(?:tiptap|internal|cms|doc):\/\//.test(input.href.trim())) {
+            return sanitizeTiptapUrl(input.href);
+        }
+        const shortCollection = collectionName.includes(".")
+            ? collectionName.split(".").pop() || collectionName
+            : collectionName.replace(/^api::/, "");
+        return sanitizeTiptapUrl(`/${shortCollection}/${documentId}`);
+    }
+    return sanitizeTiptapUrl(input.href);
+};

package/dist/lib/relations/relations.d.ts

@@ -1,4 +1,6 @@
-import type { TiptapContentInput, TiptapInternalLinkResolver } from "../../types";
+import type { TiptapContentInput } from "../../types";
+import { formatInternalLinkUri, parseInternalLinkUri, resolveInternalLinkHref } from "./relations-uri";
+export { formatInternalLinkUri, parseInternalLinkUri, resolveInternalLinkHref };
 export type TiptapMediaNodeType = "image" | "video" | "audio" | "attachment";
 export interface ExtractedMediaReference {
     nodeType: TiptapMediaNodeType;
@@ -21,23 +23,8 @@ export interface ExtractedRelationsResult {
         documentId: string;
     }>>;
 }
-export declare const parseInternalLinkUri: (href: string | null | undefined) => {
-    collectionName: string;
-    documentId: string;
-} | null;
-export declare const formatInternalLinkUri: (collectionName: string, documentId: string) => string;
-/**
- * Resolves an internal link URI (`tiptap://collectionName/documentId` or `linker` attributes) into a safe frontend href.
- * Uses `resolveInternalLink` when provided, or defaults to `/<shortCollection>/<documentId>`.
- */
-export declare const resolveInternalLinkHref: (input: {
-    href?: string | null;
-    collectionName?: string | null;
-    documentId?: string | null;
-    label?: string | null;
-}, resolver?: TiptapInternalLinkResolver) => string;
 /**
  * Extracts all referenced media assets (`image`, `video`, `audio`, `attachment`)
- * and internal links (`linker` nodes and internal `tiptap://` link marks) from a Tiptap document.
+ * and internal links (`linker` nodes and internal `tiptap://` link marks) from any Tiptap document input.
  */
 export declare const extractRelationsFromTiptap: (doc: TiptapContentInput | unknown) => ExtractedRelationsResult;

package/dist/lib/relations/relations.js

@@ -1,48 +1,13 @@
-import { sanitizeTiptapUrl } from "../sanitize";
+import { parseTiptapContent } from "../parser";
+import { formatInternalLinkUri, parseInternalLinkUri, resolveInternalLinkHref, } from "./relations-uri";
+export { formatInternalLinkUri, parseInternalLinkUri, resolveInternalLinkHref };
 const MEDIA_NODE_TYPES = new Set(["image", "video", "audio", "attachment"]);
-const INTERNAL_URI_RE = /^(?:tiptap|internal|cms|doc):\/\/([a-zA-Z0-9_.:-]+)\/([a-zA-Z0-9_.:-]+)(?:\?.*)?$/;
-export const parseInternalLinkUri = (href) => {
-    if (!href || typeof href !== "string")
-        return null;
-    const match = INTERNAL_URI_RE.exec(href.trim());
-    if (!match)
-        return null;
-    return { collectionName: match[1], documentId: match[2] };
-};
-export const formatInternalLinkUri = (collectionName, documentId) => `tiptap://${collectionName.trim()}/${documentId.trim()}`;
-/**
- * Resolves an internal link URI (`tiptap://collectionName/documentId` or `linker` attributes) into a safe frontend href.
- * Uses `resolveInternalLink` when provided, or defaults to `/<shortCollection>/<documentId>`.
- */
-export const resolveInternalLinkHref = (input, resolver) => {
-    const parsedFromHref = parseInternalLinkUri(input.href);
-    const collectionName = (input.collectionName || parsedFromHref?.collectionName || "").trim();
-    const documentId = (input.documentId || parsedFromHref?.documentId || "").trim();
-    if (collectionName && documentId) {
-        const rawUri = formatInternalLinkUri(collectionName, documentId);
-        if (resolver) {
-            return sanitizeTiptapUrl(resolver({
-                collectionName,
-                documentId,
-                href: rawUri,
-                label: input.label,
-            }));
-        }
-        if (input.href && !/^(?:tiptap|internal|cms|doc):\/\//.test(input.href.trim())) {
-            return sanitizeTiptapUrl(input.href);
-        }
-        const shortCollection = collectionName.includes(".")
-            ? collectionName.split(".").pop() || collectionName
-            : collectionName.replace(/^api::/, "");
-        return sanitizeTiptapUrl(`/${shortCollection}/${documentId}`);
-    }
-    return sanitizeTiptapUrl(input.href);
-};
 /**
  * Extracts all referenced media assets (`image`, `video`, `audio`, `attachment`)
- * and internal links (`linker` nodes and internal `tiptap://` link marks) from a Tiptap document.
+ * and internal links (`linker` nodes and internal `tiptap://` link marks) from any Tiptap document input.
  */
 export const extractRelationsFromTiptap = (doc) => {
+    const normalizedRoot = typeof doc === "string" ? parseTiptapContent(doc) : doc;
     const mediaIdsSet = new Set();
     const mediaDocIdsSet = new Set();
     const mediaAssets = [];
@@ -123,7 +88,7 @@ export const extractRelationsFromTiptap = (doc) => {
         if (Array.isArray(n.content))
             n.content.forEach(walk);
     };
-    walk(doc);
+    walk(normalizedRoot);
     const internalLinks = Array.from(internalLinksMap.values());
     const linksByCollection = {};
     for (const link of internalLinks) {

package/dist/lib/sanitize/sanitize-format.d.ts

@@ -0,0 +1,12 @@
+import type { TiptapTextStyleMarkAttrs } from "../../types";
+export declare const DEFAULT_ALLOWED_IFRAME_DOMAINS: ReadonlyArray<string>;
+export declare const normalizeEmbedUrl: (url: string) => string;
+export declare const isTrustedMediaEmbedUrl: (url: string | null | undefined) => boolean;
+export declare const sanitizeCssColor: (color: string | null | undefined) => string | null;
+export declare const sanitizeCssDimension: (val: string | null | undefined) => string | null;
+export declare const sanitizeCssFontFamily: (font: string | null | undefined) => string | null;
+export declare const sanitizeTextStyleAttrs: (attrs?: TiptapTextStyleMarkAttrs) => TiptapTextStyleMarkAttrs | undefined;
+export declare const buildSafeInlineStyle: (attrs?: TiptapTextStyleMarkAttrs) => string | undefined;
+export declare const slugifyHeadingText: (text: string) => string;
+export declare const formatFileSize: (bytes: number | string | null | undefined) => string;
+export declare const formatLatexPreview: (latex: string | null | undefined) => string;

package/dist/lib/sanitize/sanitize-format.js

@@ -0,0 +1,158 @@
+export const DEFAULT_ALLOWED_IFRAME_DOMAINS = [
+    "youtube.com",
+    "youtube-nocookie.com",
+    "youtu.be",
+    "vimeo.com",
+    "player.vimeo.com",
+    "open.spotify.com",
+    "w.soundcloud.com",
+    "codepen.io",
+    "codesandbox.io",
+    "stackblitz.com",
+    "figma.com",
+    "loom.com",
+    "openstreetmap.org",
+    "google.com",
+    "maps.google.com",
+];
+export const normalizeEmbedUrl = (url) => {
+    try {
+        const parsed = new URL(url);
+        const host = parsed.hostname.toLowerCase();
+        if ((host === "youtube.com" || host === "www.youtube.com") && parsed.pathname === "/watch") {
+            const videoId = parsed.searchParams.get("v");
+            if (videoId && /^[\w-]{6,20}$/.test(videoId)) {
+                return `https://www.youtube.com/embed/${videoId}`;
+            }
+        }
+        if (host === "youtu.be" && /^\/[\w-]{6,20}$/.test(parsed.pathname)) {
+            return `https://www.youtube.com/embed${parsed.pathname}`;
+        }
+        if ((host === "vimeo.com" || host === "www.vimeo.com") && /^\/\d+$/.test(parsed.pathname)) {
+            return `https://player.vimeo.com/video${parsed.pathname}`;
+        }
+        return parsed.toString();
+    }
+    catch {
+        return url;
+    }
+};
+export const isTrustedMediaEmbedUrl = (url) => {
+    if (!url || url === "#")
+        return false;
+    try {
+        const host = new URL(url).hostname.toLowerCase();
+        return DEFAULT_ALLOWED_IFRAME_DOMAINS.some((domain) => host === domain || host.endsWith(`.${domain}`));
+    }
+    catch {
+        return false;
+    }
+};
+const SAFE_COLOR_REGEX = /^(#[0-9a-fA-F]{3,8}|(?:rgb|rgba|hsl|hsla)\(\s*[\d.,%\s/]+\)|var\(--[a-zA-Z0-9_-]+\)|[a-zA-Z]{3,20})$/;
+const SAFE_DIMENSION_REGEX = /^\d+(?:\.\d+)?(?:px|rem|em|%|pt|ch|vh|vw)?$/;
+const SAFE_FONT_FAMILY_REGEX = /^[a-zA-Z0-9\s,'"-]+$/;
+export const sanitizeCssColor = (color) => {
+    if (!color || typeof color !== "string")
+        return null;
+    const trimmed = color.trim();
+    return SAFE_COLOR_REGEX.test(trimmed) ? trimmed : null;
+};
+export const sanitizeCssDimension = (val) => {
+    if (!val || typeof val !== "string")
+        return null;
+    const trimmed = val.trim();
+    return SAFE_DIMENSION_REGEX.test(trimmed) ? trimmed : null;
+};
+export const sanitizeCssFontFamily = (font) => {
+    if (!font || typeof font !== "string")
+        return null;
+    const trimmed = font.trim();
+    return SAFE_FONT_FAMILY_REGEX.test(trimmed) && !/url\(|expression\(|;/i.test(trimmed)
+        ? trimmed
+        : null;
+};
+export const sanitizeTextStyleAttrs = (attrs) => {
+    if (!attrs)
+        return undefined;
+    const color = sanitizeCssColor(attrs.color);
+    const fontFamily = sanitizeCssFontFamily(attrs.fontFamily);
+    const fontSize = sanitizeCssDimension(attrs.fontSize);
+    const lineHeight = sanitizeCssDimension(attrs.lineHeight);
+    if (!color && !fontFamily && !fontSize && !lineHeight)
+        return undefined;
+    return {
+        ...(color ? { color } : {}),
+        ...(fontFamily ? { fontFamily } : {}),
+        ...(fontSize ? { fontSize } : {}),
+        ...(lineHeight ? { lineHeight } : {}),
+    };
+};
+export const buildSafeInlineStyle = (attrs) => {
+    const safe = sanitizeTextStyleAttrs(attrs);
+    if (!safe)
+        return undefined;
+    const parts = [];
+    if (safe.color)
+        parts.push(`color: ${safe.color}`);
+    if (safe.fontFamily)
+        parts.push(`font-family: ${safe.fontFamily}`);
+    if (safe.fontSize)
+        parts.push(`font-size: ${safe.fontSize}`);
+    if (safe.lineHeight)
+        parts.push(`line-height: ${safe.lineHeight}`);
+    return parts.length > 0 ? parts.join("; ") : undefined;
+};
+export const slugifyHeadingText = (text) => text
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]/g, "")
+    .replace(/[\s_-]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "section";
+export const formatFileSize = (bytes) => {
+    const num = typeof bytes === "string" ? Number(bytes) : bytes;
+    if (!num || Number.isNaN(num) || num <= 0)
+        return "";
+    if (num < 1024)
+        return `${num} B`;
+    if (num < 1024 * 1024)
+        return `${(num / 1024).toFixed(1)} KB`;
+    return `${(num / (1024 * 1024)).toFixed(1)} MB`;
+};
+const LATEX_SYMBOLS = [
+    [/\\alpha(?![a-zA-Z])/g, "α"],
+    [/\\beta(?![a-zA-Z])/g, "β"],
+    [/\\gamma(?![a-zA-Z])/g, "γ"],
+    [/\\delta(?![a-zA-Z])/g, "δ"],
+    [/\\pi(?![a-zA-Z])/g, "π"],
+    [/\\theta(?![a-zA-Z])/g, "θ"],
+    [/\\lambda(?![a-zA-Z])/g, "λ"],
+    [/\\sigma(?![a-zA-Z])/g, "σ"],
+    [/\\omega(?![a-zA-Z])/g, "ω"],
+    [/\\infty(?![a-zA-Z])/g, "∞"],
+    [/\\sum(?![a-zA-Z])/g, "∑"],
+    [/\\prod(?![a-zA-Z])/g, "∏"],
+    [/\\int(?![a-zA-Z])/g, "∫"],
+    [/\\sqrt\{([^}]+)\}/g, "√($1)"],
+    [/\\sqrt(?![a-zA-Z])/g, "√"],
+    [/\\frac\{([^}]+)\}\{([^}]+)\}/g, "($1)/($2)"],
+    [/\\pm(?![a-zA-Z])/g, "±"],
+    [/\\times(?![a-zA-Z])/g, "×"],
+    [/\\div(?![a-zA-Z])/g, "÷"],
+    [/\\cdot(?![a-zA-Z])/g, "·"],
+    [/\\neq(?![a-zA-Z])/g, "≠"],
+    [/\\leq(?![a-zA-Z])/g, "≤"],
+    [/\\geq(?![a-zA-Z])/g, "≥"],
+    [/\\approx(?![a-zA-Z])/g, "≈"],
+    [/\\rightarrow(?![a-zA-Z])|\\to(?![a-zA-Z])/g, "→"],
+    [/\\leftarrow(?![a-zA-Z])/g, "←"],
+    [/\\Rightarrow(?![a-zA-Z])/g, "⇒"],
+];
+export const formatLatexPreview = (latex) => {
+    if (!latex)
+        return "";
+    let result = latex.trim();
+    for (const [pattern, replacement] of LATEX_SYMBOLS) {
+        result = result.replace(pattern, replacement);
+    }
+    return result;
+};

package/dist/lib/sanitize/sanitize.d.ts

@@ -1,8 +1,9 @@
-import type { TiptapMediaUrlResolver, TiptapTextStyleMarkAttrs } from "../../types";
+import type { TiptapMediaUrlResolver } from "../../types";
+export * from "./sanitize-format";
 export declare const decodeHtmlEntities: (text: string) => string;
 /**
  * Validates and sanitizes a URL for safe rendering in `href` or `src` attributes.
- * Blocks `javascript:`, `vbscript:`, `data:text/html`, `data:image/svg+xml`, and `//` protocol-relative URLs.
+ * Blocks `javascript:`, `vbscript:`, `data:text/html`, `data:image/svg+xml`, and `//` or `/\` protocol-relative URLs.
  */
 export declare const sanitizeTiptapUrl: (rawUrl: string | null | undefined) => string;
 /**
@@ -13,15 +14,14 @@ export declare const resolveTiptapMediaUrl: (rawUrl: string | null | undefined,
     mediaBaseUrl?: string;
     resolveMediaUrl?: TiptapMediaUrlResolver;
 }) => string;
+/**
+ * Sanitizes a responsive `srcset` attribute string by validating and resolving every candidate URL.
+ */
+export declare const sanitizeTiptapSrcset: (rawSrcset: string | null | undefined, options?: {
+    mediaBaseUrl?: string;
+    resolveMediaUrl?: TiptapMediaUrlResolver;
+}) => string | undefined;
 /**
  * Enforces HTTPS-only URLs and optional domain allowlist for sandboxed `<iframe>` embeds.
  */
 export declare const sanitizeTiptapIframeUrl: (rawUrl: string | null | undefined, allowedDomains?: ReadonlyArray<string>) => string;
-export declare const sanitizeCssColor: (color: string | null | undefined) => string | null;
-export declare const sanitizeCssDimension: (val: string | null | undefined) => string | null;
-export declare const sanitizeCssFontFamily: (font: string | null | undefined) => string | null;
-export declare const sanitizeTextStyleAttrs: (attrs?: TiptapTextStyleMarkAttrs) => TiptapTextStyleMarkAttrs | undefined;
-export declare const buildSafeInlineStyle: (attrs?: TiptapTextStyleMarkAttrs) => string | undefined;
-export declare const slugifyHeadingText: (text: string) => string;
-export declare const formatFileSize: (bytes: number | string | null | undefined) => string;
-export declare const formatLatexPreview: (latex: string | null | undefined) => string;