@rightkit/doc-render 0.0.0-stage → 0.1.0

package/dist/remarkDefListAbbr.js

@@ -0,0 +1,292 @@
+const DEF_RE = /^:(?:\s+(.*))?$/;
+const ABBR_DEF_RE = /^\*\[([^\]]+)\]:\s*(.+)$/;
+/** Transform Pandoc-style definition lists and abbreviation definitions into custom mdast nodes. */
+export function remarkDefListAbbr() {
+    return (tree) => {
+        const abbreviations = new Map();
+        tree.children = transformTopLevel(tree.children, abbreviations);
+        if (abbreviations.size > 0) {
+            expandAbbreviations(tree.children, abbreviations);
+        }
+    };
+}
+function transformTopLevel(children, abbreviations) {
+    const out = [];
+    let i = 0;
+    while (i < children.length) {
+        const child = children[i];
+        if (child && child.type === "paragraph") {
+            const abbrSplit = splitAbbreviationDefinition(child, abbreviations);
+            if (abbrSplit) {
+                out.push(abbrSplit.abbr);
+                if (abbrSplit.remainder) {
+                    out.push(transformTopLevel([abbrSplit.remainder], abbreviations)[0]);
+                }
+                i += 1;
+                continue;
+            }
+            const inlineList = parseInlineDefinitionList(child);
+            if (inlineList) {
+                out.push({
+                    ...inlineList,
+                    position: child.position,
+                });
+                i += 1;
+                continue;
+            }
+        }
+        const result = consumeDefinitionList(children, i);
+        if (result) {
+            out.push(result.list);
+            i = result.nextIndex;
+            continue;
+        }
+        if (child && "children" in child && Array.isArray(child.children)) {
+            out.push(transformNode(child, abbreviations));
+            i += 1;
+            continue;
+        }
+        out.push(child);
+        i += 1;
+    }
+    return out;
+}
+function transformNode(node, abbreviations) {
+    if (node.type === "paragraph" || node.type === "heading" || node.type === "blockquote") {
+        const typed = node;
+        const copy = { ...typed, children: [...typed.children] };
+        copy.children = transformInline(copy.children, abbreviations);
+        return copy;
+    }
+    if (node.type === "list") {
+        const typed = node;
+        const copy = { ...typed, children: [...typed.children] };
+        copy.children = copy.children.map((item) => transformNode(item, abbreviations));
+        return copy;
+    }
+    if (node.type === "listItem") {
+        const typed = node;
+        const copy = { ...typed, children: [...typed.children] };
+        copy.children = transformTopLevel(copy.children, abbreviations);
+        return copy;
+    }
+    return node;
+}
+function splitAbbreviationDefinition(node, abbreviations) {
+    const text = paragraphText(node);
+    const lines = text.split("\n");
+    const first = lines[0] ?? "";
+    const m = ABBR_DEF_RE.exec(first);
+    if (!m)
+        return null;
+    const short = m[1] ?? "";
+    const long = m[2]?.trim() ?? "";
+    abbreviations.set(short, long);
+    const remainder = lines.length > 1
+        ? {
+            type: "paragraph",
+            children: [{ type: "text", value: lines.slice(1).join("\n") }],
+        }
+        : null;
+    return { abbr: { type: "abbreviationDefinition", short, long }, remainder };
+}
+function parseInlineDefinitionList(node) {
+    if (node.children.some((child) => child.type !== "text"))
+        return null;
+    const text = paragraphText(node);
+    const lines = text.split("\n");
+    const items = [];
+    let i = 0;
+    while (i < lines.length) {
+        const terms = [];
+        while (i < lines.length && !DEF_RE.exec(lines[i] ?? "")) {
+            terms.push(lines[i] ?? "");
+            i += 1;
+        }
+        if (terms.length === 0)
+            break;
+        const details = [];
+        while (i < lines.length) {
+            const m = DEF_RE.exec(lines[i] ?? "");
+            if (!m)
+                break;
+            details.push(m[1] ?? "");
+            i += 1;
+        }
+        if (details.length === 0)
+            break;
+        items.push({
+            type: "descriptionItem",
+            terms: terms.map((t) => ({ type: "descriptionTerm", children: [{ type: "text", value: t }] })),
+            details: details.map((d) => ({
+                type: "descriptionDetails",
+                children: [{ type: "text", value: d }],
+            })),
+        });
+    }
+    if (items.length === 0)
+        return null;
+    // Only treat the whole paragraph as a definition list if every line was consumed.
+    const consumed = items.reduce((sum, item) => sum + item.terms.length + item.details.length, 0);
+    if (consumed !== lines.length)
+        return null;
+    return { type: "descriptionList", children: items };
+}
+function consumeDefinitionList(children, start) {
+    const items = [];
+    let firstTermParagraph = null;
+    let lastDetailParagraph = null;
+    let i = start;
+    while (i < children.length) {
+        const termResult = consumeTerms(children, i);
+        if (!termResult)
+            break;
+        const detailsResult = consumeDetails(children, termResult.nextIndex);
+        if (detailsResult.details.length === 0)
+            break;
+        if (!firstTermParagraph)
+            firstTermParagraph = termResult.terms[0] ?? null;
+        lastDetailParagraph = detailsResult.details[detailsResult.details.length - 1] ?? null;
+        items.push({
+            type: "descriptionItem",
+            terms: termResult.terms.map((t) => ({ type: "descriptionTerm", children: t.children })),
+            details: detailsResult.details.map((d) => ({ type: "descriptionDetails", children: d.children })),
+        });
+        i = detailsResult.nextIndex;
+    }
+    if (items.length === 0)
+        return null;
+    const position = firstTermParagraph?.position && lastDetailParagraph?.position
+        ? { start: firstTermParagraph.position.start, end: lastDetailParagraph.position.end }
+        : undefined;
+    return {
+        list: { type: "descriptionList", children: items, position },
+        nextIndex: i,
+    };
+}
+function consumeTerms(children, start) {
+    const terms = [];
+    let i = start;
+    while (i < children.length) {
+        const child = children[i];
+        if (child?.type !== "paragraph")
+            break;
+        const text = paragraphText(child);
+        if (DEF_RE.exec(text) || ABBR_DEF_RE.test(text))
+            break;
+        terms.push(child);
+        i += 1;
+    }
+    if (terms.length === 0)
+        return null;
+    return { terms, nextIndex: i };
+}
+function consumeDetails(children, start) {
+    const details = [];
+    let i = start;
+    while (i < children.length) {
+        const child = children[i];
+        if (child?.type !== "paragraph")
+            break;
+        const text = paragraphText(child);
+        const m = DEF_RE.exec(text);
+        if (!m)
+            break;
+        const inner = m[1] ?? "";
+        const stripped = {
+            ...child,
+            children: inner ? [{ type: "text", value: inner }] : [],
+        };
+        details.push(stripped);
+        i += 1;
+    }
+    return { details, nextIndex: i };
+}
+function paragraphText(node) {
+    return node.children
+        .filter((c) => c.type === "text")
+        .map((c) => c.value)
+        .join("");
+}
+function transformInline(children, abbreviations) {
+    const out = [];
+    for (const child of children) {
+        if (child.type === "text" && abbreviations.size > 0) {
+            out.push(...splitAbbreviations(child, abbreviations));
+            continue;
+        }
+        if (child.type === "abbr") {
+            out.push(child);
+            continue;
+        }
+        if ("children" in child && Array.isArray(child.children)) {
+            out.push({
+                ...child,
+                children: transformInline(child.children, abbreviations),
+            });
+            continue;
+        }
+        out.push(child);
+    }
+    return out;
+}
+function splitAbbreviations(text, abbreviations) {
+    const sorted = Array.from(abbreviations.entries()).sort((a, b) => b[0].length - a[0].length);
+    let parts = [text];
+    for (const [short, long] of sorted) {
+        const next = [];
+        const pattern = new RegExp(`(^|[^A-Za-z0-9])(${escapeRegExp(short)})(?=[^A-Za-z0-9]|$)`, "g");
+        for (const part of parts) {
+            if (part.type !== "text") {
+                next.push(part);
+                continue;
+            }
+            const value = part.value;
+            const matches = Array.from(value.matchAll(pattern));
+            let lastIndex = 0;
+            for (const match of matches) {
+                const index = match.index ?? 0;
+                const leading = match[1];
+                const before = value.slice(lastIndex, index + leading.length);
+                if (before) {
+                    next.push({ type: "text", value: before });
+                }
+                next.push({
+                    type: "abbr",
+                    title: long,
+                    children: [{ type: "text", value: short }],
+                });
+                lastIndex = index + leading.length + short.length;
+            }
+            const remaining = value.slice(lastIndex);
+            if (remaining) {
+                next.push({ type: "text", value: remaining });
+            }
+            lastIndex = 0;
+        }
+        parts = next;
+    }
+    return parts;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function expandAbbreviations(children, abbreviations) {
+    for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (child.type === "paragraph" || child.type === "heading" || child.type === "blockquote") {
+            const typed = child;
+            typed.children = transformInline(typed.children, abbreviations);
+        }
+        else if (child.type === "descriptionList") {
+            for (const item of child.children) {
+                for (const term of item.terms) {
+                    term.children = transformInline(term.children, abbreviations);
+                }
+                for (const detail of item.details) {
+                    detail.children = transformInline(detail.children, abbreviations);
+                }
+            }
+        }
+    }
+}

package/dist/remarkWikiLink.d.ts

@@ -0,0 +1,10 @@
+import type { Root } from "mdast";
+export interface WikiLinkNode {
+    type: "wikiLink";
+    target: string;
+    hash: string;
+    display: string | null;
+    children: [];
+}
+/** Transform plain `[[target]]` / `[[target#hash|display]]` text segments into wiki-link nodes. */
+export declare function remarkWikiLink(): (tree: Root) => void;

package/dist/remarkWikiLink.js

@@ -0,0 +1,63 @@
+const WIKI_LINK_RE = /\[\[([^\]\n]+?)\]\]/g;
+/** Transform plain `[[target]]` / `[[target#hash|display]]` text segments into wiki-link nodes. */
+export function remarkWikiLink() {
+    return (tree) => {
+        tree.children = processChildren(tree.children);
+    };
+}
+function processChildren(children) {
+    const out = [];
+    for (const child of children) {
+        const node = child;
+        if (node.type === "text" && typeof node.value === "string") {
+            const split = splitWikiLink(node.value);
+            out.push(...(split ?? [child]));
+            continue;
+        }
+        if (Array.isArray(node.children)) {
+            out.push({
+                ...node,
+                children: processChildren(node.children),
+            });
+            continue;
+        }
+        out.push(child);
+    }
+    return out;
+}
+function splitWikiLink(value) {
+    const parts = [];
+    let lastIndex = 0;
+    let match = WIKI_LINK_RE.exec(value);
+    while (match !== null) {
+        if (match.index > lastIndex) {
+            parts.push({ type: "text", value: value.slice(lastIndex, match.index) });
+        }
+        parts.push(parseWikiLink(match[1]));
+        lastIndex = match.index + match[0].length;
+        WIKI_LINK_RE.lastIndex = lastIndex;
+        match = WIKI_LINK_RE.exec(value);
+    }
+    if (parts.length === 0)
+        return null;
+    if (lastIndex < value.length) {
+        parts.push({ type: "text", value: value.slice(lastIndex) });
+    }
+    return parts;
+}
+function parseWikiLink(inner) {
+    const pipeIndex = inner.lastIndexOf("|");
+    const left = pipeIndex >= 0 ? inner.slice(0, pipeIndex) : inner;
+    const display = pipeIndex >= 0 ? inner.slice(pipeIndex + 1) : null;
+    const hashIndex = left.indexOf("#");
+    let target = "";
+    let hash = "";
+    if (hashIndex >= 0) {
+        target = left.slice(0, hashIndex);
+        hash = left.slice(hashIndex + 1);
+    }
+    else {
+        target = left;
+    }
+    return { type: "wikiLink", target, hash, display, children: [] };
+}

package/dist/renderers.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from "react";
+import type { CslEntry } from "./citations/types.js";
+export interface MarkdownRendererProps {
+    source: string;
+    className?: string;
+    onOpenLink?: (href: string) => void;
+    bibliography?: Map<string, CslEntry>;
+}
+export interface HtmlRendererProps {
+    html: string;
+    className?: string;
+    safeMode?: boolean;
+}
+export declare function MarkdownRenderer({ source, className, onOpenLink, bibliography }: MarkdownRendererProps): import("react").JSX.Element;
+export declare function HtmlRenderer({ html, className, safeMode }: HtmlRendererProps): import("react").JSX.Element;
+export declare function renderMarkdown(source: string, options?: Omit<MarkdownRendererProps, "source">): ReactNode;
+export declare function renderHtml(html: string, options?: Omit<HtmlRendererProps, "html">): ReactNode;

package/dist/renderers.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createElement } from "react";
+import { buildHeadingSlugs } from "./headingSlugs.js";
+import { collectFootnotes } from "./footnotes.js";
+import { nodeText } from "./detectors/nodeText.js";
+import { parseToTree } from "./parseMarkdown.js";
+import { safeImageHref, safeLinkHref, sanitizeHtml } from "./security.js";
+import { formatBibliographyEntry, formatCitation } from "./citations/formatter.js";
+function textContent(children) { return children.map((child) => nodeText(child)).join(""); }
+function renderChildren(children, context) {
+    return children.map((child, index) => renderNode(child, `${context.key}:${index}`, context));
+}
+function renderNode(node, key, parent) {
+    const raw = node;
+    const context = { ...parent, key };
+    const children = node.children ?? [];
+    switch (raw.type) {
+        case "text": return raw.value;
+        case "paragraph": return _jsx("p", { children: renderChildren(children, context) }, key);
+        case "heading": return createElement(`h${raw.depth}`, { key, id: parent.headingSlugs.get(node) }, renderChildren(children, context));
+        case "emphasis": return _jsx("em", { children: renderChildren(children, context) }, key);
+        case "strong": return _jsx("strong", { children: renderChildren(children, context) }, key);
+        case "delete": return _jsx("del", { children: renderChildren(children, context) }, key);
+        case "inlineCode": return _jsx("code", { children: raw.value }, key);
+        case "code": return _jsx("pre", { className: "rk-doc-code", children: _jsx("code", { children: raw.value }) }, key);
+        case "blockquote": return _jsx("blockquote", { children: renderChildren(children, context) }, key);
+        case "list": return createElement(raw.ordered ? "ol" : "ul", { key, start: raw.ordered && raw.start !== 1 ? raw.start : undefined }, renderChildren(children, context));
+        case "listItem": return _jsx("li", { children: renderChildren(children, context) }, key);
+        case "link": {
+            const href = safeLinkHref(raw.url);
+            if (!href)
+                return _jsx("span", { children: renderChildren(children, context) }, key);
+            return _jsx("a", { href: href, rel: "noreferrer noopener", target: "_blank", onClick: (event) => { if (parent.onOpenLink) {
+                    event.preventDefault();
+                    parent.onOpenLink(href);
+                } }, children: renderChildren(children, context) }, key);
+        }
+        case "image": {
+            const src = safeImageHref(raw.url);
+            return src ? _jsx("img", { src: src, alt: raw.alt ?? "", title: raw.title ?? undefined, loading: "lazy" }, key) : _jsx("span", { children: raw.alt ?? "" }, key);
+        }
+        case "thematicBreak": return _jsx("hr", {}, key);
+        case "break": return _jsx("br", {}, key);
+        case "html": return _jsx("span", { dangerouslySetInnerHTML: { __html: sanitizeHtml(raw.value) } }, key);
+        case "table": return _jsxs("table", { children: [_jsx("thead", { children: _jsx("tr", { children: raw.children[0]?.children.map((cell, i) => _jsx("th", { children: renderChildren(cell.children, context) }, i)) }) }), _jsx("tbody", { children: raw.children.slice(1).map((row, i) => _jsx("tr", { children: row.children.map((cell, j) => _jsx("td", { children: renderChildren(cell.children, context) }, j)) }, i)) })] }, key);
+        case "footnoteReference": {
+            const footnote = parent.footnotes.get(raw.identifier);
+            return footnote ? _jsx("sup", { children: _jsx("a", { href: `#fn-${raw.identifier}`, id: `fnref-${raw.identifier}`, children: footnote.num }) }, key) : null;
+        }
+        case "math": return _jsx("pre", { className: "rk-doc-math", children: raw.value }, key);
+        case "inlineMath": return _jsx("code", { className: "rk-doc-math-inline", children: raw.value }, key);
+        case "definition":
+        case "footnoteDefinition":
+        case "yaml":
+        case "toml": return null;
+        case "imageReference":
+        case "linkReference": return _jsx("span", { children: textContent(children) }, key);
+        case "citation": {
+            const entry = parent.bibliography.get(node.key);
+            return _jsx("span", { children: entry ? formatCitation(entry, node.locator) : `[${node.key}]` }, key);
+        }
+        case "bibliography": return _jsx(Bibliography, { entries: [...parent.bibliography.values()] }, key);
+        default: return children.length ? _jsx("span", { children: renderChildren(children, context) }, key) : null;
+    }
+}
+function Bibliography({ entries }) {
+    return _jsxs("section", { className: "rk-doc-bibliography", children: [_jsx("h2", { children: "References" }), _jsx("ol", { children: entries.map((entry) => _jsx("li", { children: formatBibliographyEntry(entry) }, entry.id)) })] });
+}
+export function MarkdownRenderer({ source, className, onOpenLink, bibliography = new Map() }) {
+    const tree = parseToTree(source);
+    const headingSlugs = buildHeadingSlugs(tree);
+    const footnotes = collectFootnotes(tree);
+    const context = { headingSlugs, footnotes, onOpenLink, bibliography, key: "root" };
+    const content = renderChildren(tree.children, context);
+    if (footnotes.size)
+        content.push(_jsxs("section", { className: "rk-doc-footnotes", children: [_jsx("h2", { children: "Notes" }), _jsx("ol", { children: [...footnotes.entries()].map(([id, footnote]) => _jsx("li", { id: `fn-${id}`, children: renderChildren(footnote.children, { ...context, key: `fn:${id}` }) }, id)) })] }, "footnotes"));
+    return _jsx("article", { className: `rk-doc-markdown ${className ?? ""}`, children: content });
+}
+export function HtmlRenderer({ html, className, safeMode = true }) {
+    const content = safeMode ? sanitizeHtml(html) : html;
+    return _jsx("article", { className: `rk-doc-html ${className ?? ""}`, dangerouslySetInnerHTML: { __html: content } });
+}
+export function renderMarkdown(source, options) {
+    return _jsx(MarkdownRenderer, { source: source, ...options });
+}
+export function renderHtml(html, options) {
+    return _jsx(HtmlRenderer, { html: html, ...options });
+}

package/dist/security.d.ts

@@ -0,0 +1,12 @@
+/** Allow only links that can leave the application through an explicit host adapter. */
+export declare function safeLinkHref(href?: string): string | undefined;
+/** Relative image references are safe in a host-controlled document root; remote images use the
+ * same strict URL policy as links. Data URLs are intentionally unavailable. */
+export declare function safeImageHref(href?: string): string | undefined;
+/** Sanitize raw HTML before it reaches a React HTML boundary. Browser DOMPurify is used when a
+ * DOM exists; with no DOM (SSR/node) the markup is escaped to inert text. */
+export declare function sanitizeHtml(html: string): string;
+export declare function sanitizeMarkdownHtml(html: string, options?: {
+    safeMode?: boolean;
+}): string;
+export declare function isSafeUri(uri: string): boolean;

package/dist/security.js

@@ -0,0 +1,78 @@
+import DOMPurify from "dompurify";
+function hasControlCharacter(value) {
+    for (const char of value) {
+        const code = char.charCodeAt(0);
+        if (code <= 31 || code === 127)
+            return true;
+    }
+    return false;
+}
+/** Allow only links that can leave the application through an explicit host adapter. */
+export function safeLinkHref(href) {
+    if (!href)
+        return undefined;
+    const trimmed = href.trim();
+    if (!trimmed || hasControlCharacter(trimmed))
+        return undefined;
+    const protocolMatch = trimmed.match(/^([a-z][a-z0-9+.-]*):/i);
+    if (!protocolMatch)
+        return undefined;
+    const protocol = protocolMatch[1].toLowerCase();
+    if (protocol !== "http" && protocol !== "https" && protocol !== "mailto")
+        return undefined;
+    if ((protocol === "http" || protocol === "https") && !/^https?:\/\//i.test(trimmed))
+        return undefined;
+    try {
+        const parsed = new URL(trimmed);
+        return parsed.protocol === `${protocol}:` ? trimmed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Relative image references are safe in a host-controlled document root; remote images use the
+ * same strict URL policy as links. Data URLs are intentionally unavailable. */
+export function safeImageHref(href) {
+    if (!href)
+        return undefined;
+    const trimmed = href.trim();
+    if (!trimmed || hasControlCharacter(trimmed) || /^data:|^javascript:|^vbscript:/i.test(trimmed))
+        return undefined;
+    if (/^[a-z][a-z0-9+.-]*:/i.test(trimmed))
+        return safeLinkHref(trimmed);
+    if (trimmed.startsWith("//") || trimmed.startsWith("\\\\"))
+        return undefined;
+    return trimmed;
+}
+const FORBIDDEN_TAGS = ["script", "style", "iframe", "object", "embed", "form", "base", "meta", "link", "template", "svg", "math", "canvas"];
+const URI_ATTRIBUTES = new Set(["href", "src", "action", "formaction", "xlink:href"]);
+/** Without a DOM there is no trustworthy HTML parser, so fail closed: render the raw markup as
+ * inert text. Regex sanitizing is never a security boundary (e.g. `<img src=x/onerror=...>`). */
+function escapeHtml(html) {
+    return html.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+/** Sanitize raw HTML before it reaches a React HTML boundary. Browser DOMPurify is used when a
+ * DOM exists; with no DOM (SSR/node) the markup is escaped to inert text. */
+export function sanitizeHtml(html) {
+    if (typeof document === "undefined" || !DOMPurify.isSupported)
+        return escapeHtml(html);
+    return DOMPurify.sanitize(html, {
+        ALLOWED_TAGS: ["a", "abbr", "b", "blockquote", "br", "code", "del", "div", "em", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "i", "img", "li", "ol", "p", "pre", "section", "small", "span", "strong", "sub", "sup", "table", "tbody", "td", "th", "thead", "tr", "u", "ul"],
+        ALLOWED_ATTR: ["alt", "class", "colspan", "height", "href", "id", "rel", "rowspan", "src", "target", "title", "width"],
+        FORBID_TAGS: FORBIDDEN_TAGS,
+        FORBID_ATTR: ["style", "srcdoc"],
+        ALLOW_UNKNOWN_PROTOCOLS: false,
+        RETURN_TRUSTED_TYPE: false,
+        ADD_ATTR: ["target", "rel"],
+        ALLOW_DATA_ATTR: false,
+    }).replace(/\s+(href|src)=(['"])([^'"\s]*)\2/gi, (full, attribute, quote, value) => {
+        const safe = URI_ATTRIBUTES.has(attribute.toLowerCase()) && (attribute.toLowerCase() === "src" ? safeImageHref(value) : safeLinkHref(value));
+        return safe ? ` ${attribute}=${quote}${safe}${quote}` : "";
+    });
+}
+export function sanitizeMarkdownHtml(html, options = {}) {
+    return options.safeMode === false ? html : sanitizeHtml(html);
+}
+export function isSafeUri(uri) {
+    return Boolean(safeLinkHref(uri) ?? safeImageHref(uri));
+}

package/dist/shikiHighlighter.d.ts

@@ -0,0 +1,26 @@
+import type { HighlighterCore } from "shiki/core";
+/**
+ * The one Shiki highlighter shared by the Markdown preview (`CodeBlock`), the hybrid editor's
+ * code-fence decorations and the language validator.
+ *
+ * Built on `shiki/core` rather than `shiki/bundle/web` so the build ships only what is listed here:
+ * two themes and a curated grammar set, each grammar its own lazy chunk. Oniguruma stays the regex
+ * engine — the JavaScript engine tokenizes identically but transpiling a grammar's patterns made the
+ * first highlight of a fence several times slower (≈1.6–2 s vs ≈0.3 s for a 40-line TS/C++ fence).
+ * Its WASM ships as a binary asset fetched on first use, not as a base64 JS module that has to be
+ * parsed. When WebAssembly is unavailable (macOS Lockdown Mode) the JavaScript engine takes over.
+ */
+export declare const SHIKI_LIGHT_THEME = "github-light";
+export declare const SHIKI_DARK_THEME = "github-dark";
+/**
+ * Canonical Shiki language id for a fence info string, `"text"` for the plain-text names, or
+ * `null` when the language is not in the curated set.
+ */
+export declare function resolveShikiLanguage(language: string | null | undefined): string | null;
+/** Lazy singleton — Shiki, its engine and the two themes load when the first code block needs them. */
+export declare function getShikiHighlighter(): Promise<HighlighterCore>;
+/**
+ * Loads the grammar for `language` into `highlighter` and returns the id to pass to Shiki, or
+ * `null` when the language is unknown or its grammar failed to load (callers render plain text).
+ */
+export declare function ensureShikiLanguage(highlighter: HighlighterCore, language: string): Promise<string | null>;