@uniweb/semantic-parser 1.8.0 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/semantic-parser",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "Semantic parser for ProseMirror/TipTap content structures",
   "type": "module",
   "main": "./src/index.js",

package/src/builders/doc.js

@@ -23,8 +23,9 @@
  * This builder was written with its own spelling for several concepts, and
  * `parseContent` emits a DIFFERENT one for the same thing: a link's text is
  * `text` here and `label` there; an image's address is `src` here and `url`
- * there; a video's cover is a string here and `{ src | url | identifier }`
  * there; a list item is a plain string here and a whole content GROUP there.
+ * (A video's cover was a fourth — an editor's `coverImg` — until the parser
+ * stopped reading the editor's `Video`, 2026-10-18; both sides say `poster`.)
  *
  * ⛔ EVERY ONE OF THOSE MISMATCHES FAILED SILENTLY, which is why the rule is
  * now written down. Measured 2026-09-16, all four on the shapes a caller would
@@ -180,16 +181,13 @@ function iconNode({ src, url, library, name, size, color }) {
 const PLAYBACK_FLAGS = ['autoplay', 'muted', 'loop', 'controls']
 
 function videoNode(video) {
-  const { src, url, alt, caption, placement, poster, coverImg } = video
+  const { src, url, alt, caption, placement, poster } = video
   const attrs = { src: src || url, role: 'video' }
   if (alt) attrs.alt = alt
   if (caption) attrs.caption = caption
   // The cover is `poster`, what the parser emits for a video and what a
-  // component reads. `coverImg` is an editor's spelling — a string, or an
-  // object whose `src` or `url` is the address; an `identifier` alone names
-  // no address, so it gives none.
-  const cover = poster || (typeof coverImg === 'string' ? coverImg : coverImg?.src || coverImg?.url)
-  if (cover) attrs.poster = cover
+  // component reads. ⛔ Until 2026-10-18 an editor's `coverImg` was taken too.
+  if (poster) attrs.poster = poster
   if (placement) attrs.placement = placement
   for (const flag of PLAYBACK_FLAGS) if (typeof video[flag] === 'boolean') attrs[flag] = video[flag]
   return { type: 'image', attrs }

package/src/processors/groups.js

@@ -417,20 +417,6 @@ function processGroupContent(elements, options = {}) {
                     body.icons.push(element.attrs);
                     break;
 
-                case "button":
-                    // Map button to link with role
-                    body.links.push({
-                        href: element.attrs?.href || '',
-                        label: element.text || '',
-                        role: element.attrs?.variant ? `button-${element.attrs.variant}` : 'button',
-                        variant: element.attrs?.variant || 'primary',
-                        size: element.attrs?.size,
-                        icon: element.attrs?.icon,
-                        target: element.attrs?.target,
-                        class: element.attrs?.class,
-                    });
-                    break;
-
                 case "blockquote":
                     // Process blockquote content recursively
                     const quoteContent = processGroupContent(element.children);
@@ -515,7 +501,7 @@ function processGroupContent(elements, options = {}) {
                     break;
 
                 case "form":
-                    // Route FormBlock data by the schema id it targets, so it
+                    // Route a form's data by the schema id it targets, so it
                     // shares a namespace with tagged markdown data blocks
                     // (```yaml:<id>``` also lands at data[<id>]). When no
                     // schemaId is present (legacy content), fall back to the
@@ -527,18 +513,6 @@ function processGroupContent(elements, options = {}) {
                     }
                     break;
 
-                case "card-group":
-                    // Map cards to data by type: data.person = [...], data.event = [...]
-                    // Each card type becomes a key, with an array of cards of that type
-                    (element.cards || []).forEach(card => {
-                        const cardType = card.cardType || 'card';
-                        if (!body.data[cardType]) body.data[cardType] = [];
-                        // Remove cardType from the card object since it's now the key
-                        const { cardType: _, ...cardData } = card;
-                        body.data[cardType].push(cardData);
-                    });
-                    break;
-
             }
         }
     }

package/src/processors/sequence.js

@@ -3,7 +3,6 @@ import {
     escapeText,
     escapeAttribute as escapeAttr,
     sanitizeMathML,
-    sanitizeSVG,
     isSafeLink,
     isLinkTarget,
     isStyleName,
@@ -18,12 +17,9 @@ import {
 // rule that a text node held HTML — so `<img src=x onerror=…>` written in
 // content ran on the published page, and `if a<b then` showed as `if a`.
 
-/**
- * Check if an inline node is an icon.
- * TipTap editor uses type "UniwebIcon"; markdown pipeline uses type "image" with role "icon".
- */
+/** Check if an inline node is an icon: an `image` with role "icon". */
 function isIconNode(node) {
-    return node.type === "UniwebIcon" || (node.type === "image" && node.attrs?.role === "icon");
+    return node.type === "image" && node.attrs?.role === "icon";
 }
 
 /**
@@ -207,11 +203,6 @@ function createSequenceElement(node, options = {}) {
                 mathml: sanitizeMathML(node.attrs?.mathml || ""),
                 attrs,
             };
-        case "ImageBlock":
-            return {
-                type: "image",
-                attrs: parseImgBlock(attrs, options),
-            };
         case "image":
             // `role` decides which content array this lands in — the contract
             // published in docs/reference/content-structure.md ("Media Assets"):
@@ -234,28 +225,20 @@ function createSequenceElement(node, options = {}) {
             // poster/autoplay/muted/loop/controls, so the author's declaration
             // was demoted to an image AND its playback attrs were dropped —
             // while the build had already generated a poster for it
-            // (@uniweb/build site/assets.js). Note this does NOT route to
-            // parseVideoBlock: that reader speaks the editor's dialect
-            // (coverImg, info), not the markdown one.
+            // (@uniweb/build site/assets.js).
             if (attrs?.role === "video") {
                 return {
                     type: "video",
                     attrs: parseMarkdownVideo(attrs, options),
                 };
             }
-            // Standard ProseMirror image node - resolve attrs the same way as
-            // ImageBlock so info.identifier lands as a CDN URL. CLI-deployed
-            // content uses this node type; without parseImgBlock the url
+            // Standard ProseMirror image node - read through parseImgBlock, so
+            // its address lands in `url`. Without parseImgBlock the url
             // wouldn't be populated and components render an empty slot.
             return {
                 type: "image",
                 attrs: parseImgBlock(attrs || {}, options),
             };
-        case "Video":
-            return {
-                type: "video",
-                attrs: parseVideoBlock(attrs, options),
-            };
         case "bulletList":
         case "orderedList": {
             const listItems = content
@@ -321,34 +304,11 @@ function createSequenceElement(node, options = {}) {
                 attrs,
             };
 
-        // Custom TipTap elements
-        case "card-group":
-            return {
-                type: "card-group",
-                cards:
-                    node.content
-                        ?.filter((c) => c.type === "card" && !c.attrs?.hidden)
-                        .map((card) => parseCardBlock(card.attrs)) || [],
-            };
-
-        case "document-group":
-            // The editor's older container: one `document` element per document
-            // it holds, so a document is one kind of content whichever node
-            // wrote it (`documentFromEditorNode`). Until 2026-09-29 this was a
-            // `document-group` element whose documents became `content.links`.
-            return (node.content || [])
-                .filter((c) => c.type === "document")
-                .map((doc) => ({
-                    type: "document",
-                    attrs: documentFromEditorNode(doc.attrs),
-                }));
-
-        // The editor renamed this node to `StructuredContent` (2026-07-31,
-        // editor-internal). Both are accepted: the new name is what the editor
-        // emits now, and the old one still arrives from documents authored
-        // before the rename, which the framework never rewrites.
+        // The editor's form node. ⛔ Until 2026-10-18 its name before
+        // 2026-07-31, `FormBlock`, was read too — and the editor's `card-group`,
+        // `document-group`, `ImageBlock`, `Video`, `UniwebIcon`, `Icon` and
+        // `button` nodes, which no writer produces now.
         case "StructuredContent":
-        case "FormBlock":
             // Parse form data (can be JSON string or object)
             let formData = attrs?.data;
             if (typeof formData === "string") {
@@ -366,29 +326,6 @@ function createSequenceElement(node, options = {}) {
                 attrs,
             };
 
-        case "button": {
-            let textContent = getTextContent(content, options);
-
-            if (!textContent) return null;
-
-            return {
-                type: "button",
-                text: textContent,
-                children: processInlineElements(content, options),
-                attrs,
-            };
-        }
-        case "UniwebIcon":
-            return {
-                type: "icon",
-                attrs: parseUniwebIcon(attrs),
-            };
-        case "Icon":
-            return {
-                type: "icon",
-                attrs: parseIconBlock(attrs),
-            };
-
         default:
             return {
                 type: node.type,
@@ -653,9 +590,9 @@ function processInlineElements(content, options = {}) {
         if (isIconNode(item)) {
             items.push({
                 type: "icon",
-                attrs: parseUniwebIcon(item.attrs),
+                attrs: parseIcon(item.attrs),
             });
-        } else if (item.type === "image" || item.type === "ImageBlock") {
+        } else if (item.type === "image") {
             // A media node that stayed inside its paragraph — content-reader
             // hoists a standalone one to the document root, but an image sitting
             // beside text does not qualify (parser/block.js `isBlockEligible`).
@@ -715,6 +652,11 @@ function processInlineElements(content, options = {}) {
  * layout, so a framework package never composes a serve location or guesses an
  * origin — a host may move its assets without a framework release.
  *
+ * ⛔ No asset host is built into this package: a reference resolves through this
+ * pattern, or is the address the content holds. Until 2026-10-17 an
+ * `info.identifier` (`{version}/{filename}`) was composed against a fixed host;
+ * it is not read.
+ *
  * ⛔ Three ways this returns '' — "unresolved", never a guess:
  *   - **no pattern** (the host declared none) — absent ⇒ absent
  *   - **an unknown placeholder** — never emit a half-substituted URL
@@ -750,8 +692,9 @@ function processInlineElements(content, options = {}) {
  * the one every fallback path already resolves to. The convention is: unprefixed
  * identifies the primary; a prefix names the attr it belongs to.
  *
- * `url` rides in the primary slot because the editor's `ImageBlock` uses it where
- * markdown's `image` uses `src`; both mean the same reference.
+ * `url` rides in the primary slot because the editor's `ImageBlock` used it where
+ * `image` uses `src`. This parser reads `src` alone since 2026-10-18; the entry
+ * stays because this list is exported and read outside it.
  */
 export const ASSET_SLOTS = [
     { urls: ["src", "url"], id: "assetId", ext: "assetExt" },
@@ -791,72 +734,6 @@ function secondaryAssetUrl(attrs, options, urlAttr) {
     return resolved || attrs?.[urlAttr] || "";
 }
 
-// ⛔ LEGACY BELOW — the PHP-estate identifier path. Do not extend it.
-//
-// `{version}/{filename}` identifiers have no current producer — the CLI emits
-// `src`, and editors store the URL their host hands them. Only content authored
-// against the original hosted service still carries one, and the hardcoded host
-// below cannot be correct for any other deployment: the CLI can be pointed at
-// any host. New references use `assetId`/`assetExt` above.
-const ASSET_BASE_URL = "https://assets.uniweb.app/";
-
-/**
- * Resolve an asset identifier ({version}/{filename}) to a direct URL.
- * Assets are hosted at assets.uniweb.app under dist/{version}/base.{ext}.
- */
-function resolveAssetIdentifier(identifier) {
-    if (!identifier || typeof identifier !== "string") return "";
-    // ⛔ An identifier that is ALREADY a URL or a rooted path is not an
-    // identifier — it is a serve URL sitting in the identifier slot, and it is
-    // usable exactly as it stands. Composing it against the legacy base
-    // destroys it: `split("/")` on `/gateway/asset/dist/{id}/base.png` takes
-    // `""` as the version and `"gateway"` as the filename, yielding
-    // `https://assets.uniweb.app/dist//base.gateway` — not a 404 and not a
-    // validation failure, a URL-shaped string that renders a broken image and
-    // reads like a missing file.
-    //
-    // The legacy grammar is `{version}/{filename}` with no leading slash, so
-    // nothing legitimate is caught here. Passing it through is not constructing
-    // a serve location: it is declining to construct one over a value that is
-    // already an address. (Measured 2026-08-17 against a real producer.)
-    if (/^(?:[a-z][a-z0-9+.-]*:|\/\/|\/)/i.test(identifier)) return identifier;
-    const [version, filename] = identifier.split("/");
-    if (!filename) return "";
-    const ext = filename.substring(filename.lastIndexOf(".") + 1);
-    return `${ASSET_BASE_URL}dist/${version}/base.${ext}`;
-}
-
-function makeAssetUrl(info) {
-    const src = info?.src || info?.url || "";
-    if (src) return src;
-    if (info?.identifier) return resolveAssetIdentifier(info.identifier);
-    return "";
-}
-
-function parseCardBlock(itemAttrs) {
-    const { address, ...others } = itemAttrs;
-
-    let parsedAddress = null;
-
-    try {
-        if (address) {
-            parsedAddress = JSON.parse(address);
-        }
-    } catch {}
-
-    const { coverImg = null, icon } = others;
-
-    if (icon) {
-        others.icon = parseUniwebIcon(icon);
-    }
-
-    return {
-        ...others,
-        address: parsedAddress,
-        coverImg: makeAssetUrl(coverImg),
-    };
-}
-
 // A document authored in markdown: `![Annual report](./report.pdf){role=pdf …}`.
 //
 // Read through `parseImgBlock`, which resolves the address and the preview's the
@@ -900,146 +777,47 @@ function fileFacts(url, attrs = {}) {
     };
 }
 
-// The editor's older `document` node — its `title`, `coverImg` and `src` (or
-// asset identifier) — read into the same shape a markdown document has.
-function documentFromEditorNode(itemAttrs) {
-    const {
-        href,
-        downloadUrl,
-        title = "",
-        alt = "",
-        coverImg,
-        author,
-        description,
-        fileType,
-    } = parseDocumentBlock(itemAttrs || {});
-    const url = href || downloadUrl || "";
-    return {
-        url,
-        ...fileFacts(url, itemAttrs),
-        alt: alt || title,
-        caption: title,
-        role: "pdf",
-        ...(coverImg && { preview: coverImg }),
-        ...(author && { author }),
-        ...(description && { description }),
-        ...(fileType && { fileType }),
-    };
-}
-
-function parseDocumentBlock(itemAttrs) {
-    const { src, info = {}, coverImg = null, ...others } = itemAttrs;
-
-    let ele = {
-        ...others,
-        coverImg: makeAssetUrl(coverImg),
-    };
-
-    if (src) {
-        ele.href = src;
-    } else {
-        const { identifier = "" } = info;
-
-        if (identifier) {
-            ele.downloadUrl = resolveAssetIdentifier(identifier);
-        }
-    }
-
-    return ele;
-}
-
-function parseUniwebIcon(itemAttrs) {
-    const { svg, url, src, size, color, preserveColors, href, target, library, name } = itemAttrs || {};
+/**
+ * An icon: named (`library` + `name`, resolved at render through the icon
+ * corpus) or a file (`src`) — `![Logo](icon:./logo.svg)` or
+ * `![Logo](./logo.svg){role=icon}`, both documented in AGENTS.md and
+ * docs/reference/content-structure.md. Until 2026-07-30 a file-sourced icon
+ * delivered `{}` and rendered nothing. `url` is the key kit's <Icon> fetches
+ * from. Keys are omitted when absent.
+ *
+ * ⛔ Until 2026-10-18 this also read the editor's `UniwebIcon` (an inline `svg`,
+ * a `url`, `preserveColors`, a `family:id` name) and its `Icon` node.
+ */
+function parseIcon(itemAttrs) {
+    const { src, size, color, href, target, library, name } = itemAttrs || {};
 
-    // Build object with only defined fields — icon source varies:
-    // TipTap editor: svg/url (resolved inline)
-    // Markdown pipeline: library + name (resolved at runtime via CDN)
-    //                    OR a file, which arrives as `src`
     const icon = {};
-    // Markup from content, so rebuilt from the SVG allowlist (`../sanitize.js`).
-    if (svg) icon.svg = sanitizeSVG(svg);
-    // Standard ProseMirror `image` nodes use `src`; the editor's `UniwebIcon`
-    // uses `url`. Honor either, exactly as parseImgBlock does below — a
-    // file-sourced icon is authored `![Logo](icon:./logo.svg)` or
-    // `![Logo](./logo.svg){role=icon}` (both documented in AGENTS.md and
-    // docs/reference/content-structure.md), and reaches here as `src` with no
-    // library/name. Until 2026-07-30 this reader dropped it, so every
-    // documented file-sourced icon delivered `{}` and rendered nothing.
-    // `url` is the key kit's <Icon> fetches from.
-    if (url || src) icon.url = url || src;
+    if (src) icon.url = src;
     if (size) icon.size = size;
     if (color) icon.color = color;
-    if (preserveColors) icon.preserveColors = preserveColors;
     if (href) icon.href = href;
     if (target) icon.target = target;
-    // The editor carries the family inside `name` as `family:id`; the markdown
-    // pipeline carries them separately. Normalize to the separate form, which
-    // is what `<Icon library name />` consumes.
-    let resolvedLibrary = library;
-    let resolvedName = name;
-    if (!resolvedLibrary && typeof name === "string" && name.includes(":")) {
-        const [family, ...rest] = name.split(":");
-        resolvedLibrary = family;
-        resolvedName = rest.join(":");
-    }
-    if (resolvedLibrary) icon.library = resolvedLibrary;
-    if (resolvedName) icon.name = resolvedName;
-
-    return icon;
-}
-
-// The editor's `Icon` node carries an inline SVG blob plus a theme. Return an
-// ATTRS OBJECT, like every other parser in this file — not the bare `svg`
-// string it used to return.
-//
-// The string form was a live bug, not just an inconsistency: kit renders a
-// sequence icon with `<Icon {...element.attrs} />` (styled/Prose/index.jsx),
-// and spreading a string yields indexed character props — `{0:'<', 1:'s', …}`
-// — so the icon rendered as nothing and React saw a wall of unknown props. It
-// failed silently because `attrs.svg` on a string is `undefined`, never an
-// error.
-//
-// Keys are omitted when absent so a consumer can distinguish "not provided"
-// from "empty", matching parseUniwebIcon's shape above.
-function parseIconBlock(itemAttrs) {
-    const { svg, theme } = itemAttrs || {};
-
-    const icon = {};
-    if (svg) icon.svg = sanitizeSVG(svg);
-    if (theme) icon.theme = theme;
+    if (library) icon.library = library;
+    if (name) icon.name = name;
 
     return icon;
 }
 
 function parseImgBlock(itemAttrs, options) {
     let {
-        info: imgInfo,
-        targetId,
         caption = "",
         alt = "",
         src,
-        url,
         href = "",
         target = "",
         role,
-        credit, // the editor's word for `author` — delivered as `author`
         id, // {#fig-id} cross-reference label — preserved so Press
             // adapters can emit \label{id} (LaTeX) / <id> (Typst).
-        // ── Markdown-authored attributes ────────────────────────────────
-        // This function was written for the EDITOR's `ImageBlock` node and
-        // later reused for the markdown `image` node (see `case "image"`), so
-        // its vocabulary was the editor's. Everything markdown declares and
-        // the editor does not was therefore tokenized, declared, and then
-        // dropped one layer before delivery — the published "Image
-        // Attributes" table (docs/reference/content-structure.md) reached no
-        // component, and neither did the `role=pdf` set added 2026-07-29 for
-        // the editor's `document` fold-in. Carried 2026-07-30.
-        //
-        // ⭐ An element now holds the vocabulary's words, whichever node it
-        // came from. ⛔ Until 2026-10-15 it also held the editor's `direction`
-        // and two things derived from it — `imgPos` (left/right) and a
-        // layout `size` (basic/lg/full, `basic` for every image without one) —
-        // plus `filter` and `theme`, none of which a stored document holds. A
+        // ⭐ An element holds the vocabulary's words. ⛔ This function was
+        // written for the editor's `ImageBlock` and read its words too — `url`,
+        // `credit`, an `info` envelope (`contentType`, `viewType`, `contentId`)
+        // and `targetId` — until 2026-10-18; and until 2026-10-15 its
+        // `direction`, `imgPos`, a layout `size`, `filter` and `theme`. A
         // component handing the element to kit's <Image> passed that `size` as
         // Image's avatar preset, so a "wide" image drew as a 96px square.
         width,
@@ -1053,39 +831,18 @@ function parseImgBlock(itemAttrs, options) {
         description, // role=pdf — describes the RESOURCE, not the image (≠ alt)
     } = itemAttrs;
 
-    let { contentType, viewType, contentId, identifier } = imgInfo || {};
-
     caption = stripTags(caption);
-    const attribution = author || credit;
 
-    // Reference precedence. Standard ProseMirror `image` nodes use `src`; the
-    // custom `ImageBlock` node uses `url`. Honor either so callers don't have to
-    // pre-normalize.
-    //
     // ⭐ A store-held asset (`assetId`) wins WHEN IT RESOLVES — not merely when
     // it is present. That distinction is the whole reason a producer can write
     // `assetId` alongside `src` before any deployment declares
     // `config.assets.url`: until one does, resolution yields '' and the node
     // renders through `src` exactly as it does today. Content written now stays
     // correct whichever order the halves arrive in.
-    //
-    // `identifier` is the LEGACY estate path and keeps its old precedence over a
-    // stale `src`.
-    const assetUrl = assetUrlFromAttrs(itemAttrs, options);
-    if (assetUrl) {
-        url = assetUrl;
-    } else if (identifier) {
-        url = makeAssetUrl(imgInfo);
-    } else if (!url && src) {
-        url = src;
-    }
+    const url = assetUrlFromAttrs(itemAttrs, options) || src || undefined;
 
     return {
-        contentType,
-        viewType,
-        contentId: targetId || contentId,
         url,
-        value: identifier || "",
         alt: alt || caption,
         caption,
         href,
@@ -1104,24 +861,21 @@ function parseImgBlock(itemAttrs, options) {
             const p = secondaryAssetUrl(itemAttrs, options, "preview");
             return p ? { preview: p } : {};
         })()),
-        ...(attribution && { author: attribution }),
+        ...(author && { author }),
         ...(description && { description }),
     };
 }
 
 // A video authored in markdown: `![alt](./demo.mp4){role=video …}`.
 //
-// Distinct from parseVideoBlock below, which reads the EDITOR's `Video` node
-// (`coverImg`, `info`). The two surfaces name the same concepts differently and
-// collapsing them would drop one side's spelling; this reader carries the
-// attribute set that docs/reference/content-structure.md publishes for the
-// video role, and the shape it documents: `{ src, href, target }` plus the
-// playback flags.
+// This reader carries the attribute set that docs/reference/content-structure.md
+// publishes for the video role, and the shape it documents: `{ src, href,
+// target }` plus the playback flags. ⛔ Until 2026-10-18 the editor's `Video`
+// node had a reader of its own, `parseVideoBlock`, and this one took the
+// editor's `url` and `info` too.
 function parseMarkdownVideo(itemAttrs, options) {
     const {
         src,
-        url,
-        info,
         poster,
         alt = "",
         caption = "",
@@ -1136,18 +890,11 @@ function parseMarkdownVideo(itemAttrs, options) {
         placement, // where it sits in a flow, same as parseImgBlock
     } = itemAttrs || {};
 
-    // Reference precedence, now genuinely identical to parseImgBlock: a
-    // resolvable store-held asset, then the legacy identifier, then the authored
-    // src/url.
-    //
-    // ⚠️ The comment here used to claim identifier-precedence "matching
-    // parseImgBlock" while the code did the opposite — it passed `src` INTO
-    // `makeAssetUrl`, which returns a src/url before it ever looks at
-    // `identifier`. So image and video resolved differently for years and the
-    // comment asserted they did not. Aligned to the documented intent (2026-08-17).
+    // Reference precedence, as parseImgBlock's: a resolvable store-held asset,
+    // then the address the node holds.
     const assetUrl = assetUrlFromAttrs(itemAttrs, options);
     const video = {
-        src: assetUrl || makeAssetUrl(info) || url || src || "",
+        src: assetUrl || src || "",
         alt,
         caption: stripTags(caption),
         role,
@@ -1172,33 +919,6 @@ function parseMarkdownVideo(itemAttrs, options) {
     return video;
 }
 
-function parseVideoBlock(itemAttrs, options) {
-    let {
-        src,
-        caption = "",
-        info = {},
-        coverImg = {},
-        alt,
-        href = "",
-        target = "",
-        placement, // where it sits in a flow; the editor's `direction` is not read
-    } = itemAttrs;
-
-    // Same precedence as parseImgBlock / parseMarkdownVideo: a resolvable
-    // store-held asset, then the legacy identifier, then the authored src.
-    const video = assetUrlFromAttrs(itemAttrs, options) || makeAssetUrl(info) || src || "";
-
-    return {
-        src: video,
-        caption,
-        coverImg: makeAssetUrl(coverImg),
-        alt,
-        href,
-        target,
-        ...(placement && { placement }),
-    };
-}
-
 function stripTags(htmlString) {
     if (!htmlString || typeof htmlString !== "string") return "";
 
@@ -1260,7 +980,7 @@ function isLink(item, options = {}) {
 
                 for (let i = 0; i < originalContent.length; i++) {
                     if (isIconNode(originalContent[i])) {
-                        const iconAttrs = parseUniwebIcon(originalContent[i].attrs);
+                        const iconAttrs = parseIcon(originalContent[i].attrs);
                         if (i < linkIndex) {
                             // Take the last icon before the link
                             iconBefore = iconAttrs;

package/src/sanitize.js

@@ -441,6 +441,19 @@ export function sanitizeSVG(svg) {
     return rebuild(svg, SVG);
 }
 
+/**
+ * What in an SVG string falls outside the allowlist `sanitizeSVG` rebuilds
+ * from, reported as `inspectMathML` reports MathML. Empty when the markup is
+ * within it.
+ *
+ * @param {string} svg
+ * @returns {Array<{reason: 'element'|'attribute'|'style'|'markup', element?: string, attribute?: string, value?: string}>}
+ */
+export function inspectSVG(svg) {
+    if (typeof svg !== "string" || !svg) return [];
+    return inspect(svg, SVG);
+}
+
 /**
  * Whether a link may be followed: a relative URL, or `http:`, `https:`,
  * `mailto:`, `tel:`, or the framework's `page:` / `topic:` references. Control
@@ -454,6 +467,75 @@ export function isSafeLink(url) {
     return typeof url === "string" && isSafeUrl(url);
 }
 
+/**
+ * Whether an address may be loaded as an image: a link a page may follow
+ * (`isSafeLink`), or the image itself, as data (`isImageData`).
+ *
+ * @param {string} url
+ * @returns {boolean}
+ */
+export function isImageSource(url) {
+    return isSafeLink(url) || isImageData(url);
+}
+
+/**
+ * Whether a `data:` URL holds an image a page may show: a PNG, JPEG, GIF, WebP
+ * or AVIF in base64, or SVG — percent-encoded or base64 — whose markup is within
+ * the allowlist `sanitizeSVG` rebuilds from. ⭐ Admitted [Diego, 2026-10-16]: a
+ * picture an `<img>` loads runs no script, and a built-in starter image is one.
+ * The URL is read as a browser reads it: tab and newline removed, leading and
+ * trailing spaces and controls trimmed.
+ *
+ * @param {string} url
+ * @returns {boolean}
+ */
+export function isImageData(url) {
+    if (typeof url !== "string") return false;
+    const address = url.replace(/[\t\n\r]/g, "").replace(/^[\u0000- ]+|[\u0000- ]+$/g, "");
+    if (RASTER_DATA.test(address)) return true;
+    const svg = svgOfData(address);
+    return svg !== null && inspect(svg, SVG).length === 0;
+}
+
+const SVG_DATA = /^data:image\/svg\+xml((?:;[^,;]*)*?)(;base64)?,([\s\S]*)$/i;
+
+/** The markup an SVG `data:` URL holds, decoded as a browser decodes it; null for any other URL. */
+function svgOfData(address) {
+    const data = SVG_DATA.exec(address);
+    if (!data) return null;
+    const body = percentDecode(data[3]);
+    if (!data[2]) return body;
+    try {
+        const binary = atob(body.replace(/[\t\n\f\r ]+/g, ""));
+        return new TextDecoder().decode(Uint8Array.from(binary, (c) => c.charCodeAt(0)));
+    } catch {
+        return null;
+    }
+}
+
+/** Percent-decode as a URL is: `%` and two hex digits is a byte, anything else stays, and the bytes are read as UTF-8. */
+function percentDecode(text) {
+    if (!text.includes("%")) return text;
+    const bytes = [];
+    const utf8 = new TextEncoder();
+    let run = "";
+    const flush = () => {
+        for (const byte of utf8.encode(run)) bytes.push(byte);
+        run = "";
+    };
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === "%" && /^[0-9a-f]{2}$/i.test(text.slice(i + 1, i + 3))) {
+            flush();
+            bytes.push(parseInt(text.slice(i + 1, i + 3), 16));
+            i += 2;
+        } else {
+            run += text[i];
+        }
+    }
+    flush();
+    return new TextDecoder().decode(new Uint8Array(bytes));
+}
+
 // ─── Values content may hold ─────────────────────────────────────────────────
 //
 // The rules below decide what a text's marks may put into the markup the parser
@@ -552,5 +634,23 @@ export function allowlists() {
             style: "declaration by declaration: a property of letters and -, a value with none of \\ < > { } /* and no unsafe value",
             markup: "no comment, doctype or processing instruction; CDATA is text",
         },
+        imageData: {
+            raster: RASTER_DATA.source,
+            rasterFlags: "i",
+            svg: {
+                mediaType: "image/svg+xml, with any parameters, and `;base64` when the body is base64",
+                decoding: "the body percent-decoded as a URL is (`%` and two hex digits is a byte, anything else stays), then base64-decoded when marked, read as UTF-8",
+                elements: [...SVG_ELEMENTS.values()],
+                attributes: [...SVG_ATTRIBUTES.values()],
+                commonAttributes: "class, id, role, dir, aria-<letters>, data-<letters, digits and ->",
+                droppedWithContent: [...DROP_WITH_CONTENT],
+                neverAttributes: "on…, in any case; src",
+                references: "href and xlink:href only: a fragment, `#` then a letter then letters, digits, _ . : or -; on `image`, also a raster image matching `raster`, or a URL with no scheme or one of the link schemes",
+                unsafeValue: UNSAFE_VALUE.source,
+                urlInAValue: "only url(#id), a reference within the document",
+                style: "declaration by declaration: a property of letters and -, a value with none of \\ < > { } /* and no unsafe value",
+                markup: "no comment, doctype or processing instruction; CDATA is text",
+            },
+        },
     };
 }