@jini-ai/platform 0.5.2 → 0.5.3

package/dist/web/html-document.js

@@ -0,0 +1,268 @@
+import { parse, serialize } from "parse5";
+export const MAX_LINKS = 500;
+export const MAX_IMAGES = 300;
+const MAX_STYLESHEETS = 100;
+const MAX_META = 60;
+const MAX_LINK_TEXT = 200;
+const MAX_META_VALUE = 500;
+export const LINK_PROTOCOLS = new Set(["http:", "https:", "mailto:", "tel:"]);
+export const ASSET_PROTOCOLS = new Set(["http:", "https:"]);
+/** Never visible and never page content; removed from the text and the returned HTML copy. */
+const STRIPPED = new Set(["script", "noscript", "template"]);
+/** Not visible text either, but `style` stays in the HTML copy because theming needs it. */
+const INVISIBLE = new Set([...STRIPPED, "style", "head", "svg", "iframe", "object", "canvas"]);
+const BLOCKS = new Set(["address", "article", "aside", "blockquote", "br", "dd", "div", "dl", "dt", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hr", "li", "main", "nav", "ol", "p", "pre", "section", "table", "td", "th", "tr", "ul"]);
+/** `meta name=` keys worth returning; every `og:*` property is returned as well. */
+const META_NAMES = new Set(["generator", "theme-color", "author", "keywords", "twitter:title", "twitter:description", "twitter:image", "application-name"]);
+export function attr({ element, name }, _optional = {}) {
+    return element.attrs.find(a => a.name === name)?.value;
+}
+function isElement(node) {
+    return "tagName" in node;
+}
+/** Iterative pre-order walk: deeply nested hostile HTML cannot overflow the stack. O(nodes). */
+function* walk(root) {
+    const pending = [root];
+    while (pending.length) {
+        const node = pending.pop();
+        yield node;
+        // Read after the yield on purpose: stripActiveHtml filters childNodes in between.
+        const children = "childNodes" in node ? node.childNodes : [];
+        for (let i = children.length - 1; i >= 0; i--)
+            pending.push(children[i]);
+    }
+}
+function collapse(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function textOf(root) {
+    const parts = [];
+    for (const node of walk(root))
+        if (node.nodeName === "#text" && "value" in node)
+            parts.push(node.value);
+    return collapse(parts.join(" "));
+}
+/** Resolves against `base`; drops fragment-only, unparseable and other-protocol values, and fragments. */
+export function absolute({ raw, base, protocols }, _optional = {}) {
+    const value = raw?.trim();
+    if (!value || value.startsWith("#"))
+        return undefined;
+    let url;
+    try {
+        url = new URL(value, base);
+    }
+    catch {
+        return undefined;
+    }
+    if (!protocols.has(url.protocol))
+        return undefined;
+    if (url.protocol === "http:" || url.protocol === "https:")
+        url.hash = "";
+    return url.href;
+}
+function siteHost(hostname) {
+    return hostname.toLowerCase().replace(/^www\./, "");
+}
+function isInternal(href, pageHost) {
+    const url = new URL(href);
+    return (url.protocol === "http:" || url.protocol === "https:") && siteHost(url.hostname) === pageHost;
+}
+function linkText(anchor) {
+    const text = textOf(anchor) || attr({ element: anchor, name: "aria-label" }) || attr({ element: anchor, name: "title" }) || "";
+    if (text)
+        return collapse(text).slice(0, MAX_LINK_TEXT);
+    for (const node of walk(anchor))
+        if (isElement(node) && node.tagName === "img")
+            return collapse(attr({ element: node, name: "alt" }) ?? "").slice(0, MAX_LINK_TEXT);
+    return "";
+}
+/** First usable image URL: lazy loaders park the real one in `data-src` behind a `data:` placeholder. */
+export function imageSource({ img }, _optional = {}) {
+    const src = attr({ element: img, name: "src" });
+    if (src && !src.trim().startsWith("data:"))
+        return src;
+    return attr({ element: img, name: "data-src" }) ?? attr({ element: img, name: "data-lazy-src" }) ?? attr({ element: img, name: "srcset" })?.trim().split(/\s+/)[0];
+}
+function collect(document) {
+    const raw = { anchors: [], images: [], linkTags: [], metas: [] };
+    for (const node of walk(document)) {
+        if (!isElement(node))
+            continue;
+        switch (node.tagName) {
+            case "a":
+                raw.anchors.push(node);
+                break;
+            case "img":
+                raw.images.push(node);
+                break;
+            case "link":
+                raw.linkTags.push(node);
+                break;
+            case "meta":
+                raw.metas.push(node);
+                break;
+            case "title":
+                raw.title ??= node;
+                break;
+            case "html":
+                raw.html ??= node;
+                break;
+            case "base":
+                raw.base ??= attr({ element: node, name: "href" });
+                break;
+        }
+    }
+    return raw;
+}
+function readMeta(raw, base) {
+    const meta = {};
+    const put = (key, value) => {
+        if (value === undefined || key in meta || Object.keys(meta).length >= MAX_META)
+            return;
+        meta[key] = collapse(value).slice(0, MAX_META_VALUE);
+    };
+    for (const element of raw.metas) {
+        const property = attr({ element, name: "property" })?.toLowerCase();
+        const name = attr({ element, name: "name" })?.toLowerCase();
+        const content = attr({ element, name: "content" });
+        if (property?.startsWith("og:"))
+            put(property, property === "og:image" || property === "og:url" ? absolute({ raw: content, base, protocols: ASSET_PROTOCOLS }) : content);
+        else if (name && META_NAMES.has(name))
+            put(name, name === "twitter:image" ? absolute({ raw: content, base, protocols: ASSET_PROTOCOLS }) : content);
+    }
+    for (const element of raw.linkTags) {
+        const rel = (attr({ element, name: "rel" }) ?? "").toLowerCase().split(/\s+/);
+        const href = absolute({ raw: attr({ element, name: "href" }), base, protocols: ASSET_PROTOCOLS });
+        if (rel.includes("canonical"))
+            put("canonical", href);
+        if (rel.includes("icon"))
+            put("favicon", href);
+        if (rel.includes("apple-touch-icon"))
+            put("apple-touch-icon", href);
+    }
+    return meta;
+}
+function readLinks(anchors, base, pageHost) {
+    const seen = new Set();
+    const links = [];
+    let truncated = false;
+    for (const anchor of anchors) {
+        const href = absolute({ raw: attr({ element: anchor, name: "href" }), base, protocols: LINK_PROTOCOLS });
+        if (!href || seen.has(href))
+            continue;
+        seen.add(href);
+        if (links.length === MAX_LINKS) {
+            truncated = true;
+            break;
+        }
+        links.push({ href, text: linkText(anchor), internal: isInternal(href, pageHost) });
+    }
+    return { links, truncated };
+}
+function readImages(images, base) {
+    const seen = new Set();
+    const out = [];
+    let truncated = false;
+    for (const img of images) {
+        const src = absolute({ raw: imageSource({ img }), base, protocols: ASSET_PROTOCOLS });
+        if (!src || seen.has(src))
+            continue;
+        seen.add(src);
+        if (out.length === MAX_IMAGES) {
+            truncated = true;
+            break;
+        }
+        out.push({ src, alt: collapse(attr({ element: img, name: "alt" }) ?? "") });
+    }
+    return { images: out, truncated };
+}
+function readStylesheets(linkTags, base) {
+    const out = new Set();
+    for (const element of linkTags) {
+        const rel = (attr({ element, name: "rel" }) ?? "").toLowerCase().split(/\s+/);
+        const href = absolute({ raw: attr({ element, name: "href" }), base, protocols: ASSET_PROTOCOLS });
+        if (rel.includes("stylesheet") && href && out.size < MAX_STYLESHEETS)
+            out.add(href);
+    }
+    return [...out];
+}
+/**
+ * Extracts page facts. Relative URLs resolve against `<base href>` (itself resolved against the page
+ * URL) so links match what a browser would follow.
+ * @param required.html - Decoded page source; untrusted.
+ * @param required.pageUrl - The final URL the HTML was served from (after redirects).
+ * @returns Facts with every URL absolute; links deduped (fragment-free) and capped at {@link MAX_LINKS},
+ *   images at {@link MAX_IMAGES}; `internal` ignores a leading `www.`.
+ * @complexity O(nodes) plus O(anchor subtree) per anchor for its text.
+ */
+export function readHtmlDocument({ html, pageUrl }, _optional = {}) {
+    const document = parse(html);
+    const raw = collect(document);
+    const base = absolute({ raw: raw.base, base: pageUrl, protocols: ASSET_PROTOCOLS }) ?? pageUrl;
+    const pageHost = siteHost(new URL(pageUrl).hostname);
+    const links = readLinks(raw.anchors, base, pageHost);
+    const images = readImages(raw.images, base);
+    const description = raw.metas.find(m => attr({ element: m, name: "name" })?.toLowerCase() === "description");
+    const title = raw.title ? textOf(raw.title) : "";
+    const lang = raw.html ? attr({ element: raw.html, name: "lang" })?.trim() : undefined;
+    const descriptionText = description ? collapse(attr({ element: description, name: "content" }) ?? "") : "";
+    return {
+        ...(title ? { title } : {}),
+        ...(descriptionText ? { description: descriptionText } : {}),
+        ...(lang ? { lang } : {}),
+        links: links.links, linksTruncated: links.truncated,
+        images: images.images, imagesTruncated: images.truncated,
+        stylesheets: readStylesheets(raw.linkTags, base),
+        meta: readMeta(raw, base),
+    };
+}
+/**
+ * Visible text with one line per block element; scripts, styles, `<head>`, SVG and embeds omitted.
+ * @complexity O(nodes).
+ */
+export function htmlToText({ html }, _optional = {}) {
+    const pending = [parse(html)];
+    const out = [];
+    while (pending.length) {
+        const node = pending.pop();
+        if (node === "\n") {
+            out.push("\n");
+            continue;
+        }
+        if (isElement(node) && INVISIBLE.has(node.tagName))
+            continue;
+        if (node.nodeName === "#text" && "value" in node) {
+            out.push(node.value);
+            continue;
+        }
+        if (!("childNodes" in node))
+            continue;
+        const block = isElement(node) && BLOCKS.has(node.tagName);
+        if (block) {
+            out.push("\n");
+            pending.push("\n");
+        }
+        for (let i = node.childNodes.length - 1; i >= 0; i--)
+            pending.push(node.childNodes[i]);
+    }
+    return out.join("").split("\n").map(line => line.replace(/[^\S\n]+/g, " ").trim()).filter(Boolean).join("\n");
+}
+/**
+ * The page HTML with `<script>`, `<noscript>`, `<template>`, comments, `on*` handler attributes and
+ * `javascript:` attribute values removed (styles and classes kept: theming needs them). Re-serialized by parse5, so it is well-formed rather than byte-identical.
+ * @complexity O(nodes).
+ */
+export function stripActiveHtml({ html }, _optional = {}) {
+    const document = parse(html);
+    for (const node of walk(document)) {
+        if (!("childNodes" in node))
+            continue;
+        const parent = node;
+        parent.childNodes = parent.childNodes.filter(child => child.nodeName !== "#comment" && !(isElement(child) && STRIPPED.has(child.tagName)));
+        // Inert copy: an agent may paste this into a page, so handlers and script URLs never survive.
+        if (isElement(node))
+            node.attrs = node.attrs.filter(a => !/^on/i.test(a.name) && !/^\s*javascript:/i.test(a.value));
+    }
+    return serialize(document);
+}
+//# sourceMappingURL=html-document.js.map

package/dist/web/html-resource.d.ts

@@ -0,0 +1,15 @@
+/** Bound synchronous HTML parsers independently of the HTTP response byte limit. */
+export declare const MAX_HTML_CHARS = 1000000;
+/** Return a bounded prefix without splitting UTF-16; fetch projections expose its truncation flag.
+ * The caller may supply a lower projection budget; direct conversion always has a fixed ceiling.
+ * O(1) decision plus O(cap) prefix allocation; raw body output keeps its separate transport cap.
+ */
+export declare function boundHtml({ html }: {
+    html: string;
+}, { maxChars }?: {
+    maxChars?: number;
+}): {
+    html: string;
+    truncated: boolean;
+};
+//# sourceMappingURL=html-resource.d.ts.map

package/dist/web/html-resource.js

@@ -0,0 +1,12 @@
+/** Bound synchronous HTML parsers independently of the HTTP response byte limit. */
+export const MAX_HTML_CHARS = 1_000_000;
+/** Return a bounded prefix without splitting UTF-16; fetch projections expose its truncation flag.
+ * The caller may supply a lower projection budget; direct conversion always has a fixed ceiling.
+ * O(1) decision plus O(cap) prefix allocation; raw body output keeps its separate transport cap.
+ */
+export function boundHtml({ html }, { maxChars = MAX_HTML_CHARS } = {}) {
+    const limit = Math.min(MAX_HTML_CHARS, maxChars);
+    const end = /[\uDC00-\uDFFF]/.test(html[limit] ?? "") ? limit - 1 : limit;
+    return html.length > limit ? { html: html.slice(0, end), truncated: true } : { html, truncated: false };
+}
+//# sourceMappingURL=html-resource.js.map

package/dist/web/html-to-markdown.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ * @complexity O(nodes + output size) time/space for ordinary pages; nesting is bounded at 300.
+ * @example htmlToMarkdown({ html: "<h1>Hello</h1>", pageUrl: "https://example.com/" })
+ */
+export declare function htmlToMarkdown({ html, pageUrl }: {
+    html: string;
+    pageUrl: string;
+}, _optional?: Record<string, never>): string;
+//# sourceMappingURL=html-to-markdown.d.ts.map

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

@@ -0,0 +1,245 @@
+import { parse } from "parse5";
+import { fromParse5 } from "hast-util-from-parse5";
+import { defaultHandlers, toMdast } from "hast-util-to-mdast";
+import { toMarkdown } from "mdast-util-to-markdown";
+import { gfmTableToMarkdown } from "mdast-util-gfm-table";
+import { boundHtml } from "./html-resource.js";
+import { absolute, ASSET_PROTOCOLS, attr, imageSource, LINK_PROTOCOLS } from "./html-document.js";
+const SKIPPED = new Set(["head", "script", "style", "noscript", "template", "svg", "iframe", "object", "canvas", "select", "input", "textarea"]);
+/** Beyond this nesting, a subtree degrades to its plain text instead of recursing further. */
+const MAX_DEPTH = 300;
+/** Narrow a parser node before accessing element attributes. */
+function isElement(node) {
+    return "tagName" in node;
+}
+/** Iterative so a degraded, very deep subtree cannot overflow the stack either. O(subtree nodes). */
+function plainText(root) {
+    const pending = [root];
+    const parts = [];
+    while (pending.length) {
+        const node = pending.pop();
+        if (node.nodeName === "#text" && "value" in node)
+            parts.push(node.value);
+        else if ("childNodes" in node && !(isElement(node) && SKIPPED.has(node.tagName))) {
+            for (let i = node.childNodes.length - 1; i >= 0; i--)
+                pending.push(node.childNodes[i]);
+        }
+    }
+    return parts.join("").replace(/\s+/g, " ");
+}
+/** 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;
+}
+/** 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();
+        }
+    }
+}
+/** The existing reader treats the first row as the header, including tables made only of td cells. */
+function promoteFirstRow(table) {
+    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;
+        }
+        for (let i = node.childNodes.length - 1; i >= 0; i--)
+            pending.push(node.childNodes[i]);
+    }
+}
+/** Drop invisible subtrees and images with no usable URL before the bridge sees them. */
+function readable(node, base) {
+    if (node.nodeName === "#comment" || node.nodeName === "#documentType")
+        return false;
+    if (!isElement(node))
+        return true;
+    if (SKIPPED.has(node.tagName))
+        return false;
+    return node.tagName !== "img" || absolute({ raw: imageSource({ img: node }), base, protocols: ASSET_PROTOCOLS }) !== undefined;
+}
+/** 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)] : [])];
+    });
+}
+function hastText(root) {
+    const pending = [root];
+    const parts = [];
+    while (pending.length) {
+        const node = pending.pop();
+        if (node.type === "text")
+            parts.push(node.value ?? "");
+        else if (node.children)
+            for (let i = node.children.length - 1; i >= 0; i--)
+                pending.push(node.children[i]);
+    }
+    return parts.join("");
+}
+/** A prepared anchor is visible when it contains text or a usable image, even without alt text.
+ * Preparation already removed unsafe images. O(descendant nodes) time/space, with early exit.
+ */
+function hasVisibleAnchorContent({ node }, _options = {}) {
+    const pending = [node];
+    while (pending.length) {
+        const child = pending.pop();
+        if (child.type === "text" && child.value?.trim())
+            return true;
+        if (child.type === "element" && child.tagName === "img")
+            return true;
+        if (child.children)
+            pending.push(...child.children);
+    }
+    return false;
+}
+/** Reader attention never rewrites neighbouring letters into character references. */
+const readerAttention = (node, _parent, state, info) => {
+    const marker = node.type === "strong" ? "**" : "*";
+    const exit = state.enter(node.type === "strong" ? "strong" : "emphasis");
+    const tracker = state.createTracker(info);
+    tracker.move(marker);
+    const value = state.containerPhrasing(node, { ...tracker.current(), before: marker, after: marker });
+    exit();
+    return marker + value + marker;
+};
+/**
+ * Bound depth BEFORE the recursive parse5-to-hast bridge and the library's tree walks.
+ * O(nodes) time/space; discarded deep subtrees are scanned once for their visible text.
+ * The input is a newly allocated parser tree, never caller state.
+ */
+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);
+            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 });
+    }
+}
+/**
+ * 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.
+ * @complexity O(nodes + output size) time/space for ordinary pages; nesting is bounded at 300.
+ * @example htmlToMarkdown({ html: "<h1>Hello</h1>", pageUrl: "https://example.com/" })
+ */
+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),
+        },
+    });
+    // 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.
+    return toMarkdown(markdown, {
+        emphasis: "*", bullet: "-", listItemIndent: "one", fences: true,
+        rule: "-", ruleRepetition: 3, ruleSpaces: false,
+        extensions: [gfmTableToMarkdown({ tableCellPadding: true, tablePipeAlign: false }), {
+                handlers: {
+                    // The reader never escaped ordinary Markdown punctuation; only table pipes need escaping.
+                    text: (node, _parent, state) => state.stack.includes("tableCell") ? node.value.replace(/\|/g, "\\|") : node.value,
+                    strong: readerAttention, emphasis: readerAttention,
+                },
+            }],
+    }).trim();
+}
+//# sourceMappingURL=html-to-markdown.js.map

package/dist/web/index.d.ts

@@ -0,0 +1,5 @@
+/** Public-page projections and an anonymous reader over injected guarded HTTP ports. */
+export * from "./web-page.js";
+export * from "./html-document.js";
+export { htmlToMarkdown } from "./html-to-markdown.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/web/index.js

@@ -0,0 +1,5 @@
+/** Public-page projections and an anonymous reader over injected guarded HTTP ports. */
+export * from "./web-page.js";
+export * from "./html-document.js";
+export { htmlToMarkdown } from "./html-to-markdown.js";
+//# sourceMappingURL=index.js.map