@jini-ai/platform 0.5.9 → 0.5.10

package/dist/web/html-to-markdown.js

@@ -27,53 +27,60 @@ function plainText(root) {
     }
     return parts.join("").replace(/\s+/g, " ");
 }
+/** First child element with this tag; the HTML parser always synthesizes html and head. */
+function childElement({ parent, tagName }, _options = {}) {
+    return parent.childNodes.find((node) => isElement(node) && node.tagName === tagName);
+}
 /** Resolve the document base before preparation drops the invisible head. O(head nodes). */
 function documentBase(document, pageUrl) {
-    const head = document.childNodes.find(isElement)?.childNodes.find(node => isElement(node) && node.tagName === "head");
-    const base = head && isElement(head) ? head.childNodes.find(node => isElement(node) && node.tagName === "base") : undefined;
-    return absolute({ raw: base && isElement(base) ? attr({ element: base, name: "href" }) : undefined, base: pageUrl, protocols: ASSET_PROTOCOLS }) ?? pageUrl;
+    const head = childElement({ parent: document.childNodes.find(isElement), tagName: "head" });
+    const base = childElement({ parent: head, tagName: "base" });
+    return absolute({ raw: base ? attr({ element: base, name: "href" }) : undefined, base: pageUrl, protocols: ASSET_PROTOCOLS }) ?? pageUrl;
 }
 /** Normalize reader URLs using the same owner as page facts; mutate only the freshly parsed tree. */
 function prepareElement(element, base) {
-    const href = element.tagName === "a" ? absolute({ raw: attr({ element, name: "href" }), base, protocols: LINK_PROTOCOLS }) : undefined;
-    const src = element.tagName === "img" ? absolute({ raw: imageSource({ img: element }), base, protocols: ASSET_PROTOCOLS }) : undefined;
     // HTML must not supply the library's data-mdast override: it can inject arbitrary Markdown nodes.
     // The old reader ignored table spans; retaining that contract also prevents hostile span expansion.
     element.attrs = element.attrs.filter(attribute => !attribute.name.startsWith("data-mdast") && !["colspan", "rowspan"].includes(attribute.name));
     if (element.tagName === "table")
         promoteFirstRow(element);
-    if (element.tagName === "a" || element.tagName === "img") {
-        element.attrs = element.attrs.filter(attribute => !["href", "src", "title"].includes(attribute.name));
-        if (href)
-            element.attrs.push({ name: "href", value: href });
-        if (src)
-            element.attrs.push({ name: "src", value: src });
-        if (element.tagName === "img") {
-            const alt = element.attrs.find(attribute => attribute.name === "alt");
-            if (alt)
-                alt.value = alt.value.replace(/\s+/g, " ").trim();
-        }
+    if (element.tagName === "a")
+        replaceUrlAttribute({ element, name: "href", value: absolute({ raw: attr({ element, name: "href" }), base, protocols: LINK_PROTOCOLS }) });
+    if (element.tagName === "img") {
+        replaceUrlAttribute({ element, name: "src", value: absolute({ raw: imageSource({ img: element }), base, protocols: ASSET_PROTOCOLS }) });
+        const alt = element.attrs.find(attribute => attribute.name === "alt");
+        if (alt)
+            alt.value = alt.value.replace(/\s+/g, " ").trim();
     }
 }
+/** Links and images keep only their normalized URL: raw href/src/title never reach the bridge. */
+function replaceUrlAttribute({ element, name, value }, _options = {}) {
+    element.attrs = element.attrs.filter(attribute => !["href", "src", "title"].includes(attribute.name));
+    if (value)
+        element.attrs.push({ name, value });
+}
 /** The existing reader treats the first row as the header, including tables made only of td cells. */
 function promoteFirstRow(table) {
+    for (const cell of firstRow({ table })?.childNodes ?? []) {
+        if (isElement(cell) && cell.tagName === "td") {
+            cell.tagName = "th";
+            cell.nodeName = "th";
+        }
+    }
+}
+/** Document-order search that never descends into a nested table, whose rows are its own. */
+function firstRow({ table }, _options = {}) {
     const pending = [...table.childNodes].reverse();
     while (pending.length) {
         const node = pending.pop();
         if (!isElement(node) || node.tagName === "table")
             continue;
-        if (node.tagName === "tr") {
-            for (const cell of node.childNodes) {
-                if (isElement(cell) && cell.tagName === "td") {
-                    cell.tagName = "th";
-                    cell.nodeName = "th";
-                }
-            }
-            return;
-        }
+        if (node.tagName === "tr")
+            return node;
         for (let i = node.childNodes.length - 1; i >= 0; i--)
             pending.push(node.childNodes[i]);
     }
+    return undefined;
 }
 /** Drop invisible subtrees and images with no usable URL before the bridge sees them. */
 function readable(node, base) {
@@ -85,48 +92,57 @@ function readable(node, base) {
         return false;
     return node.tagName !== "img" || absolute({ raw: imageSource({ img: node }), base, protocols: ASSET_PROTOCOLS }) !== undefined;
 }
+const ATTENTION = new Set(["b", "strong", "i", "em"]);
 /** Move whitespace outside attention before serialization; empty attention is plain whitespace.
  * Only this newly parsed tree is mutated. Nested inline wrappers retain their formatting.
  */
 function attentionChildren(parent) {
-    parent.childNodes = parent.childNodes.flatMap(node => {
-        if (!isElement(node) || !["b", "strong", "i", "em"].includes(node.tagName))
-            return [node];
-        const boundary = (last) => {
-            let edge = node;
-            while (edge && isElement(edge))
-                edge = last ? edge.childNodes.at(-1) : edge.childNodes[0];
-            return edge?.nodeName === "#text" && "value" in edge ? edge : undefined;
-        };
-        const first = boundary(false);
-        const leading = first?.value.match(/^\s+/)?.[0] ?? "";
-        if (first)
-            first.value = first.value.slice(leading.length);
-        const last = boundary(true);
-        const trailing = last?.value.match(/\s+$/)?.[0] ?? "";
-        if (last && trailing)
-            last.value = last.value.slice(0, -trailing.length);
-        const text = (value) => ({ nodeName: "#text", value, parentNode: parent });
-        const descendants = [...node.childNodes];
-        let image = false;
-        while (descendants.length && !image) {
-            const child = descendants.pop();
-            if (isElement(child) && child.tagName === "img")
-                image = true;
-            else if ("childNodes" in child)
-                descendants.push(...child.childNodes);
-        }
-        // No marker pair is emitted when whitespace was the entire content.
-        return [...(leading ? [text(leading)] : []), ...(plainText(node).trim() || image ? [node] : []), ...(trailing ? [text(trailing)] : [])];
-    });
+    parent.childNodes = parent.childNodes.flatMap(node => isElement(node) && ATTENTION.has(node.tagName) ? splitAttention({ node, parent }) : [node]);
+}
+function splitAttention({ node, parent }, _options = {}) {
+    const leading = takeEdgeWhitespace({ node, last: false });
+    const trailing = takeEdgeWhitespace({ node, last: true });
+    const text = (value) => ({ nodeName: "#text", value, parentNode: parent });
+    // No marker pair is emitted when whitespace was the entire content.
+    const kept = plainText(node).trim() || containsImage({ node }) ? [node] : [];
+    return [...(leading ? [text(leading)] : []), ...kept, ...(trailing ? [text(trailing)] : [])];
+}
+/** Removes and returns the whitespace at one edge of the subtree's first/last text node. */
+function takeEdgeWhitespace({ node, last }, _options = {}) {
+    const edge = edgeText({ node, last });
+    if (!edge)
+        return "";
+    const whitespace = (last ? /\s+$/ : /^\s+/).exec(edge.value)?.[0] ?? "";
+    edge.value = last ? edge.value.slice(0, edge.value.length - whitespace.length) : edge.value.slice(whitespace.length);
+    return whitespace;
+}
+/** The first/last leaf of the subtree when it is a text node. */
+function edgeText({ node, last }, _options = {}) {
+    let edge = node;
+    while (edge && isElement(edge))
+        edge = last ? edge.childNodes.at(-1) : edge.childNodes[0];
+    return edge?.nodeName === "#text" && "value" in edge ? edge : undefined;
+}
+/** Iterative descendant search with early exit. */
+function containsImage({ node }, _options = {}) {
+    const descendants = [...node.childNodes];
+    while (descendants.length) {
+        const child = descendants.pop();
+        if (isElement(child) && child.tagName === "img")
+            return true;
+        if ("childNodes" in child)
+            descendants.push(...child.childNodes);
+    }
+    return false;
 }
 function hastText(root) {
     const pending = [root];
     const parts = [];
     while (pending.length) {
         const node = pending.pop();
+        // HAST text nodes always carry a value.
         if (node.type === "text")
-            parts.push(node.value ?? "");
+            parts.push(node.value);
         else if (node.children)
             for (let i = node.children.length - 1; i >= 0; i--)
                 pending.push(node.children[i]);
@@ -167,31 +183,63 @@ const readerAttention = (node, _parent, state, info) => {
 function prepare(document, base) {
     const pending = [{ node: document, depth: 0 }];
     while (pending.length) {
-        const { node, depth, prepared } = pending.pop();
-        if (prepared) {
-            if (isElement(node))
-                attentionChildren(node);
+        const entry = pending.pop();
+        // A node's attention is split only after all its children were prepared (post-order).
+        if (entry.prepared) {
+            if (isElement(entry.node))
+                attentionChildren(entry.node);
             continue;
         }
-        if (isElement(node)) {
-            prepareElement(node, base);
-            if (depth > MAX_DEPTH) {
-                const text = plainText(node);
-                node.tagName = "span";
-                node.nodeName = "span";
-                node.attrs = [];
-                node.childNodes = [{ nodeName: "#text", value: text, parentNode: node }];
-                continue;
-            }
-        }
-        if (!("childNodes" in node))
-            continue;
-        node.childNodes = node.childNodes.filter(child => readable(child, base));
-        pending.push({ node, depth, prepared: true });
-        for (let i = node.childNodes.length - 1; i >= 0; i--)
-            pending.push({ node: node.childNodes[i], depth: depth + 1 });
+        visit({ entry, base, pending });
+    }
+}
+/** Prepares one node and schedules its readable children, or flattens it past the depth bound. */
+function visit({ entry: { node, depth }, base, pending }, _options = {}) {
+    if (isElement(node)) {
+        prepareElement(node, base);
+        if (depth > MAX_DEPTH)
+            return flattenToText({ element: node });
+    }
+    if (!("childNodes" in node))
+        return;
+    node.childNodes = node.childNodes.filter(child => readable(child, base));
+    pending.push({ node, depth, prepared: true });
+    for (let i = node.childNodes.length - 1; i >= 0; i--)
+        pending.push({ node: node.childNodes[i], depth: depth + 1 });
+}
+function flattenToText({ element }, _options = {}) {
+    const text = plainText(element);
+    element.tagName = "span";
+    element.nodeName = "span";
+    element.attrs = [];
+    element.childNodes = [{ nodeName: "#text", value: text, parentNode: element }];
+}
+/** Snapshot code text with its whitespace; the bridge's handlers see a whitespace-minified clone. */
+function annotateInlineCode({ hast }, _options = {}) {
+    const pending = [hast];
+    while (pending.length) {
+        const node = pending.pop();
+        if (node.type === "element" && node.tagName === "code")
+            node.data = { readerInlineCode: hastText(node) };
+        if (node.children)
+            pending.push(...node.children);
     }
 }
+const READER_HANDLERS = {
+    a: (state, node) => node.properties.href && hasVisibleAnchorContent({ node }) ? defaultHandlers.a(state, node) : state.all(node),
+    code: (state, node) => {
+        // annotateInlineCode stamped every code element before the bridge ran.
+        const result = { type: "inlineCode", value: node.data.readerInlineCode };
+        state.patch(node, result);
+        return result;
+    },
+    // Strikethrough was plain text in this reader; no extra GFM serialization extension is needed.
+    del: (state, node) => state.all(node),
+    s: (state, node) => state.all(node),
+    strike: (state, node) => state.all(node),
+    audio: (state, node) => state.all(node),
+    video: (state, node) => state.all(node),
+};
 /**
  * Convert untrusted HTML to readable Markdown with absolute, allowlisted link/image URLs.
  * @returns Markdown without surrounding whitespace; input is capped before parsing and errors propagate.
@@ -202,31 +250,8 @@ export function htmlToMarkdown({ html, pageUrl }, _optional = {}) {
     const document = parse(boundHtml({ html }).html);
     prepare(document, documentBase(document, pageUrl));
     const hast = fromParse5(document);
-    const pending = [hast];
-    while (pending.length) {
-        const node = pending.pop();
-        if (node.type === "element" && node.tagName === "code")
-            node.data = { readerInlineCode: hastText(node) };
-        if (node.children)
-            pending.push(...node.children);
-    }
-    const markdown = toMdast(hast, {
-        document: true,
-        handlers: {
-            a: (state, node) => node.properties.href && hasVisibleAnchorContent({ node }) ? defaultHandlers.a(state, node) : state.all(node),
-            code: (state, node) => {
-                const result = { type: "inlineCode", value: String(node.data?.readerInlineCode ?? "") };
-                state.patch(node, result);
-                return result;
-            },
-            // Strikethrough was plain text in this reader; no extra GFM serialization extension is needed.
-            del: (state, node) => state.all(node),
-            s: (state, node) => state.all(node),
-            strike: (state, node) => state.all(node),
-            audio: (state, node) => state.all(node),
-            video: (state, node) => state.all(node),
-        },
-    });
+    annotateInlineCode({ hast });
+    const markdown = toMdast(hast, { document: true, handlers: READER_HANDLERS });
     // Preparation moves whitespace out of emphasis; handlers preserve raw reader text.
     // A nested list is indented by its parent item, including every continuation line.
     // The serializer owns blank-line runs and inline spaces; code fences/list indents stay verbatim.