autokap 1.0.7 → 1.0.8

package/dist/cursor-overlay-script.js

@@ -0,0 +1,169 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+// SVG files are the single source of truth — edit web/public/cursors/*.svg directly.
+function loadCursorSvg(name) {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const candidatePaths = [
+        // From dist/ → ../web/public/cursors/
+        path.resolve(currentDir, '../web/public/cursors', `${name}.svg`),
+        // From package/dist/ → ../../web/public/cursors/
+        path.resolve(currentDir, '../../web/public/cursors', `${name}.svg`),
+        // Bundled alongside dist in package/assets/cursors/
+        path.resolve(currentDir, '../assets/cursors', `${name}.svg`),
+        // Fallback: same directory
+        path.resolve(currentDir, './web/public/cursors', `${name}.svg`),
+    ];
+    for (const candidatePath of candidatePaths) {
+        if (fs.existsSync(candidatePath)) {
+            return fs.readFileSync(candidatePath, 'utf-8').trim();
+        }
+    }
+    throw new Error(`Cursor asset "${name}.svg" not found. Looked in: ${candidatePaths.join(', ')}`);
+}
+const CURSOR_THEME_SVGS = {};
+function getCursorThemeSvg(theme) {
+    if (!CURSOR_THEME_SVGS[theme]) {
+        CURSOR_THEME_SVGS[theme] = loadCursorSvg(theme);
+    }
+    return CURSOR_THEME_SVGS[theme];
+}
+/**
+ * JavaScript injected via `context.addInitScript()` to show a visible animated
+ * cursor in Playwright video recordings (the native OS cursor is invisible).
+ */
+export function buildCursorOverlayScript(theme = 'minimal') {
+    const cursorSvg = theme === 'minimal' ? null : getCursorThemeSvg(theme);
+    return `
+(function() {
+  function injectCursor() {
+    if (document.getElementById('__ak_cursor__')) return;
+    const cursorTheme = ${JSON.stringify(theme)};
+    const cursorSvg = ${JSON.stringify(cursorSvg)};
+
+    const style = document.createElement('style');
+    style.textContent = [
+      '*, *::before, *::after { cursor: none !important; }',
+      '#__ak_cursor__ { mix-blend-mode: normal; }',
+      '#__ak_cursor__ svg { width: 100%; height: 100%; display: block; overflow: visible; }',
+      '#__ak_cursor__[data-theme="macos"], #__ak_cursor__[data-theme="windows"] { width: 28px !important; height: 28px !important; background: transparent !important; border: 0 !important; border-radius: 0 !important; box-shadow: none !important; }',
+      '#__ak_cursor__.__ak_pressed { transform: translate(-50%, -50%) scale(0.72) !important; box-shadow: 0 0 0 8px rgba(37, 99, 235, 0.18), 0 4px 18px rgba(0,0,0,0.28) !important; background: rgba(255,255,255,0.98) !important; border-color: rgba(30,41,59,0.92) !important; }',
+      '#__ak_cursor__[data-theme="macos"].__ak_pressed, #__ak_cursor__[data-theme="windows"].__ak_pressed { background: transparent !important; border-color: transparent !important; box-shadow: none !important; filter: drop-shadow(0 0 0 rgba(37, 99, 235, 0)) drop-shadow(0 0 0 rgba(37, 99, 235, 0)) !important; }',
+      '#__ak_cursor__[data-theme="macos"].__ak_pressed svg, #__ak_cursor__[data-theme="windows"].__ak_pressed svg { filter: drop-shadow(0 0 0.5px rgba(255,255,255,0.9)) drop-shadow(0 0 10px rgba(37, 99, 235, 0.45)); }',
+      '#__ak_cursor_click_pulse__ { position: fixed; width: 20px; height: 20px; border-radius: 9999px; pointer-events: none; z-index: 2147483646; border: 3px solid rgba(37, 99, 235, 0.75); box-shadow: 0 0 0 1px rgba(255,255,255,0.45) inset; transform: translate(-50%, -50%) scale(0.55); opacity: 0; }',
+      '#__ak_cursor_click_pulse__.__ak_active { animation: __ak_cursor_pulse__ 340ms cubic-bezier(0.16, 1, 0.3, 1) forwards; }',
+      '@keyframes __ak_cursor_pulse__ { 0% { opacity: 0.95; transform: translate(-50%, -50%) scale(0.55); } 100% { opacity: 0; transform: translate(-50%, -50%) scale(2.6); } }',
+    ].join('\\n');
+    document.head.appendChild(style);
+
+    const cursor = document.createElement('div');
+    cursor.id = '__ak_cursor__';
+    cursor.dataset.theme = cursorTheme;
+    cursor.style.cssText = [
+      'position: fixed',
+      'top: -100px',
+      'left: -100px',
+      'width: 20px',
+      'height: 20px',
+      'background: rgba(255, 255, 255, 0.95)',
+      'border: 2.5px solid rgba(0, 0, 0, 0.8)',
+      'border-radius: 50%',
+      'pointer-events: none',
+      'z-index: 2147483647',
+      'transform: translate(-50%, -50%)',
+      'box-shadow: 0 2px 8px rgba(0,0,0,0.4)',
+      'transition: transform 0.09s ease, box-shadow 0.12s ease, background 0.12s ease, border-color 0.12s ease',
+      'will-change: left, top',
+    ].join(';');
+    if (cursorSvg) cursor.innerHTML = cursorSvg;
+
+    const pulse = document.createElement('div');
+    pulse.id = '__ak_cursor_click_pulse__';
+
+    document.body.appendChild(cursor);
+    document.body.appendChild(pulse);
+
+    let pulseResetTimer = null;
+
+    function setCursorPosition(x, y) {
+      cursor.style.left = x + 'px';
+      cursor.style.top = y + 'px';
+      pulse.style.left = x + 'px';
+      pulse.style.top = y + 'px';
+    }
+
+    function triggerPulse() {
+      pulse.classList.remove('__ak_active');
+      void pulse.offsetWidth;
+      pulse.classList.add('__ak_active');
+      if (pulseResetTimer) clearTimeout(pulseResetTimer);
+      pulseResetTimer = setTimeout(function() {
+        pulse.classList.remove('__ak_active');
+      }, 380);
+    }
+
+    // CDP mouse events (page.mouse.move) don't fire DOM mousemove events in
+    // Playwright video recording. Expose global helpers so the runner can
+    // position the cursor directly via page.evaluate().
+    window.__akMoveCursor = function(x, y) { setCursorPosition(x, y); };
+    window.__akPressCursor = function() { cursor.classList.add('__ak_pressed'); };
+    window.__akReleaseCursor = function() { cursor.classList.remove('__ak_pressed'); };
+    window.__akClickPulse = function(x, y) {
+      setCursorPosition(x, y);
+      triggerPulse();
+    };
+
+    // Keep DOM event listeners as fallback for real mouse events (headed mode)
+    document.addEventListener('mousemove', function(e) {
+      setCursorPosition(e.clientX, e.clientY);
+    }, { passive: true });
+
+    window.addEventListener('mousedown', function(e) {
+      setCursorPosition(e.clientX, e.clientY);
+      cursor.classList.add('__ak_pressed');
+      triggerPulse();
+    }, true);
+    window.addEventListener('mouseup', function(e) {
+      setCursorPosition(e.clientX, e.clientY);
+      cursor.classList.remove('__ak_pressed');
+    }, true);
+    window.addEventListener('click', function(e) {
+      setCursorPosition(e.clientX, e.clientY);
+      triggerPulse();
+    }, true);
+  }
+
+  // Inject immediately and re-inject if a framework (React, Next.js, etc.)
+  // replaces the body during hydration and removes our cursor element.
+  function ensureCursor() {
+    if (!document.getElementById('__ak_cursor__')) {
+      if (document.body) injectCursor();
+    }
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', ensureCursor);
+  } else {
+    ensureCursor();
+  }
+
+  // Re-inject when frameworks replace body content during hydration.
+  var observer = new MutationObserver(function() {
+    if (document.body && !document.getElementById('__ak_cursor__')) {
+      injectCursor();
+    }
+  });
+  function startObserving() {
+    if (document.body) {
+      observer.observe(document.body, { childList: true });
+    } else {
+      document.addEventListener('DOMContentLoaded', function() {
+        observer.observe(document.body, { childList: true });
+      });
+    }
+  }
+  startObserving();
+})();
+`;
+}
+//# sourceMappingURL=cursor-overlay-script.js.map

package/dist/dom-css-purger.d.ts

@@ -0,0 +1,65 @@
+/**
+ * DOM CSS Purger — AUT-121 Interactive Demos, Phase 3
+ *
+ * Walks captured HTML, collects every tag/class/id present in the DOM, then
+ * walks each inline `<style>` block and drops CSS rules whose selectors
+ * never match any element. Designed to shrink captured DOMs by 60-80% per
+ * the Linear estimate.
+ *
+ * Conservative on purpose — better to keep a few unused bytes than break a
+ * captured layout. Specifically, the purger PRESERVES:
+ *   - All at-rules: @media, @supports, @keyframes, @font-face, @import,
+ *     @charset, @namespace, @page (passed through unchanged for the rules
+ *     inside @media/@supports, recursively pruned)
+ *   - Selectors that only contain pseudo-classes (`:hover`, `:focus`, etc.)
+ *     since they may match elements only in interactive states
+ *   - Universal selector `*`
+ *   - Attribute selectors (parsed but not validated against the DOM —
+ *     `[data-state]` would require a DOM walk to verify, kept for safety)
+ *
+ * For Phase 3 minimum viable, only inline `<style>` blocks are purged.
+ * External `<link rel="stylesheet">` files would require server-side
+ * fetching of the asset bytes — that's left to a follow-up.
+ *
+ * No regex CSS parser is perfect, but the trade-off is:
+ *  - dependency-free (we already pay for parse5 in dom-serializer)
+ *  - small footprint (~150 LOC)
+ *  - good enough for the 95% of CSS that captures produce
+ *
+ * Worst case: a malformed CSS block is left untouched.
+ */
+export interface PurgeStats {
+    /** Number of `<style>` blocks processed */
+    blocks: number;
+    /** Bytes of CSS before purging */
+    preBytes: number;
+    /** Bytes of CSS after purging */
+    postBytes: number;
+    /** Number of rules removed */
+    rulesRemoved: number;
+}
+export interface PurgeResult {
+    html: string;
+    stats: PurgeStats;
+}
+/**
+ * Walk an HTML document, find every `<style>` block, and purge each one
+ * against the set of tags/classes/ids actually present in the document.
+ */
+export declare function purgeInlineStyleBlocks(html: string): PurgeResult;
+interface DomPresence {
+    tags: Set<string>;
+    classes: Set<string>;
+    ids: Set<string>;
+}
+interface PurgedCss {
+    css: string;
+    removed: number;
+}
+/**
+ * Tokenize CSS into a flat sequence of `at-rule` / `rule` blocks and walk
+ * each rule to decide whether to keep it. At-rules are preserved verbatim
+ * — `@media`/`@supports` bodies are recursively purged.
+ */
+export declare function purgeCss(input: string, presence: DomPresence): PurgedCss;
+export {};

package/dist/dom-css-purger.js

@@ -0,0 +1,333 @@
+/**
+ * DOM CSS Purger — AUT-121 Interactive Demos, Phase 3
+ *
+ * Walks captured HTML, collects every tag/class/id present in the DOM, then
+ * walks each inline `<style>` block and drops CSS rules whose selectors
+ * never match any element. Designed to shrink captured DOMs by 60-80% per
+ * the Linear estimate.
+ *
+ * Conservative on purpose — better to keep a few unused bytes than break a
+ * captured layout. Specifically, the purger PRESERVES:
+ *   - All at-rules: @media, @supports, @keyframes, @font-face, @import,
+ *     @charset, @namespace, @page (passed through unchanged for the rules
+ *     inside @media/@supports, recursively pruned)
+ *   - Selectors that only contain pseudo-classes (`:hover`, `:focus`, etc.)
+ *     since they may match elements only in interactive states
+ *   - Universal selector `*`
+ *   - Attribute selectors (parsed but not validated against the DOM —
+ *     `[data-state]` would require a DOM walk to verify, kept for safety)
+ *
+ * For Phase 3 minimum viable, only inline `<style>` blocks are purged.
+ * External `<link rel="stylesheet">` files would require server-side
+ * fetching of the asset bytes — that's left to a follow-up.
+ *
+ * No regex CSS parser is perfect, but the trade-off is:
+ *  - dependency-free (we already pay for parse5 in dom-serializer)
+ *  - small footprint (~150 LOC)
+ *  - good enough for the 95% of CSS that captures produce
+ *
+ * Worst case: a malformed CSS block is left untouched.
+ */
+import { parse, serialize, defaultTreeAdapter } from 'parse5';
+/**
+ * Walk an HTML document, find every `<style>` block, and purge each one
+ * against the set of tags/classes/ids actually present in the document.
+ */
+export function purgeInlineStyleBlocks(html) {
+    const document = parse(html);
+    const presence = collectPresence(document);
+    const stats = {
+        blocks: 0,
+        preBytes: 0,
+        postBytes: 0,
+        rulesRemoved: 0,
+    };
+    walk(document, (node) => {
+        if (!isElement(node) || node.tagName !== 'style')
+            return;
+        const text = readText(node);
+        if (!text)
+            return;
+        stats.blocks += 1;
+        stats.preBytes += Buffer.byteLength(text, 'utf8');
+        const purged = purgeCss(text, presence);
+        stats.postBytes += Buffer.byteLength(purged.css, 'utf8');
+        stats.rulesRemoved += purged.removed;
+        setText(node, purged.css);
+    });
+    return {
+        html: serialize(document),
+        stats,
+    };
+}
+function collectPresence(root) {
+    const presence = {
+        tags: new Set(),
+        classes: new Set(),
+        ids: new Set(),
+    };
+    walk(root, (node) => {
+        if (!isElement(node))
+            return;
+        presence.tags.add(node.tagName);
+        for (const attr of node.attrs) {
+            if (attr.name === 'class') {
+                for (const cls of attr.value.split(/\s+/)) {
+                    if (cls)
+                        presence.classes.add(cls);
+                }
+            }
+            else if (attr.name === 'id' && attr.value) {
+                presence.ids.add(attr.value);
+            }
+        }
+    });
+    return presence;
+}
+/**
+ * Tokenize CSS into a flat sequence of `at-rule` / `rule` blocks and walk
+ * each rule to decide whether to keep it. At-rules are preserved verbatim
+ * — `@media`/`@supports` bodies are recursively purged.
+ */
+export function purgeCss(input, presence) {
+    const cleaned = stripComments(input);
+    const tokens = tokenize(cleaned);
+    let removed = 0;
+    const out = [];
+    for (const token of tokens) {
+        if (token.kind === 'at-rule') {
+            const lowerName = token.name.toLowerCase();
+            if (lowerName === 'keyframes' || lowerName === '-webkit-keyframes' || lowerName === 'font-face' ||
+                lowerName === 'page' || lowerName === 'charset' || lowerName === 'import' || lowerName === 'namespace') {
+                // Preserved as-is — keyframes/font-face/page selectors aren't DOM-bound.
+                out.push(token.raw);
+                continue;
+            }
+            if (lowerName === 'media' || lowerName === 'supports' || lowerName === 'container') {
+                // Recursively purge the body of conditional groups.
+                const innerPurged = purgeCss(token.body ?? '', presence);
+                removed += innerPurged.removed;
+                out.push(`@${token.name} ${token.prelude}{${innerPurged.css}}`);
+                continue;
+            }
+            // Any unknown at-rule: pass through.
+            out.push(token.raw);
+            continue;
+        }
+        // Regular rule — split selectors on commas (respecting parentheses)
+        const selectorList = splitSelectorList(token.selectors);
+        const kept = selectorList.filter((sel) => selectorMatches(sel, presence));
+        if (kept.length === 0) {
+            removed += 1;
+            continue;
+        }
+        out.push(`${kept.join(',')}{${token.body}}`);
+    }
+    return { css: out.join(''), removed };
+}
+function tokenize(input) {
+    const tokens = [];
+    let i = 0;
+    const len = input.length;
+    while (i < len) {
+        while (i < len && /\s/.test(input[i]))
+            i += 1;
+        if (i >= len)
+            break;
+        if (input[i] === '@') {
+            const start = i;
+            i += 1;
+            let nameStart = i;
+            while (i < len && /[\w-]/.test(input[i]))
+                i += 1;
+            const name = input.slice(nameStart, i);
+            let prelude = '';
+            while (i < len && input[i] !== '{' && input[i] !== ';') {
+                prelude += input[i];
+                i += 1;
+            }
+            if (i < len && input[i] === ';') {
+                const raw = input.slice(start, i + 1);
+                tokens.push({ kind: 'at-rule', name, prelude: prelude.trim(), raw });
+                i += 1;
+                continue;
+            }
+            // body block
+            if (i < len && input[i] === '{') {
+                i += 1;
+                const bodyStart = i;
+                const bodyEnd = findMatchingBrace(input, i);
+                const body = input.slice(bodyStart, bodyEnd);
+                i = bodyEnd + 1;
+                const raw = input.slice(start, i);
+                tokens.push({ kind: 'at-rule', name, prelude: prelude.trim(), body, raw });
+                continue;
+            }
+            // EOF without delimiter
+            tokens.push({ kind: 'at-rule', name, prelude: prelude.trim(), raw: input.slice(start, i) });
+            continue;
+        }
+        // Regular rule: read selectors until '{'
+        let selectors = '';
+        while (i < len && input[i] !== '{') {
+            selectors += input[i];
+            i += 1;
+        }
+        if (i >= len)
+            break;
+        i += 1; // skip {
+        const bodyStart = i;
+        const bodyEnd = findMatchingBrace(input, i);
+        const body = input.slice(bodyStart, bodyEnd);
+        i = bodyEnd + 1;
+        tokens.push({ kind: 'rule', selectors: selectors.trim(), body });
+    }
+    return tokens;
+}
+function findMatchingBrace(input, openIdx) {
+    let depth = 1;
+    let i = openIdx;
+    while (i < input.length && depth > 0) {
+        if (input[i] === '{')
+            depth += 1;
+        else if (input[i] === '}')
+            depth -= 1;
+        if (depth === 0)
+            return i;
+        i += 1;
+    }
+    return input.length;
+}
+function stripComments(input) {
+    return input.replace(/\/\*[\s\S]*?\*\//g, '');
+}
+function splitSelectorList(input) {
+    // Split top-level commas only (respect parentheses for `:is(...)`, `:not(...)`, etc.)
+    const result = [];
+    let depth = 0;
+    let current = '';
+    for (const char of input) {
+        if (char === '(' || char === '[')
+            depth += 1;
+        else if (char === ')' || char === ']')
+            depth -= 1;
+        if (char === ',' && depth === 0) {
+            const trimmed = current.trim();
+            if (trimmed)
+                result.push(trimmed);
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    const trimmed = current.trim();
+    if (trimmed)
+        result.push(trimmed);
+    return result;
+}
+// ── Selector matching ──────────────────────────────────────────────
+function selectorMatches(selector, presence) {
+    // Strip pseudo-elements (`::before`) and pseudo-classes (`:hover`) — keep
+    // their associated structural part for matching.
+    // Splits on the *last* compound selector since CSS targets that element.
+    const compounds = splitCompounds(selector);
+    const last = compounds[compounds.length - 1];
+    // If the last compound is empty after stripping pseudo-stuff, the selector
+    // is "container :hover"-style — keep it (conservative).
+    const structural = stripPseudo(last);
+    if (!structural)
+        return true;
+    // Universal selector — always present
+    if (structural === '*')
+        return true;
+    // Attribute selectors only — can't validate cheaply, keep
+    if (/^\[[^\]]+\]/.test(structural))
+        return true;
+    // Try matching ID > class > tag in this compound
+    const idMatch = structural.match(/#([\w-]+)/);
+    if (idMatch && presence.ids.has(idMatch[1]))
+        return true;
+    // If selector has an ID that's NOT present, drop it.
+    if (idMatch && !presence.ids.has(idMatch[1]))
+        return false;
+    const classMatches = Array.from(structural.matchAll(/\.([\w-]+)/g)).map((m) => m[1]);
+    if (classMatches.length > 0) {
+        return classMatches.every((cls) => presence.classes.has(cls));
+    }
+    const tagMatch = structural.match(/^([a-zA-Z][\w-]*)/);
+    if (tagMatch) {
+        return presence.tags.has(tagMatch[1].toLowerCase());
+    }
+    // Could not interpret — keep it (conservative)
+    return true;
+}
+function splitCompounds(selector) {
+    // Split on whitespace and combinators (`>`, `+`, `~`), keeping each
+    // compound (sequence of simple selectors).
+    const parts = [];
+    let current = '';
+    let depth = 0;
+    for (let i = 0; i < selector.length; i += 1) {
+        const c = selector[i];
+        if (c === '(' || c === '[')
+            depth += 1;
+        else if (c === ')' || c === ']')
+            depth -= 1;
+        if (depth === 0 && /[\s>+~]/.test(c)) {
+            if (current)
+                parts.push(current);
+            current = '';
+            continue;
+        }
+        current += c;
+    }
+    if (current)
+        parts.push(current);
+    return parts.length > 0 ? parts : [selector];
+}
+function stripPseudo(compound) {
+    // Remove pseudo-classes that take a parenthesised arg first.
+    let out = compound.replace(/:(?:is|where|not|has|nth-child|nth-of-type|lang|dir)\([^)]*\)/g, '');
+    // Then bare pseudo-classes / pseudo-elements.
+    out = out.replace(/::?[\w-]+/g, '');
+    return out.trim();
+}
+// ── parse5 helpers (mirrors dom-serializer.ts) ─────────────────────
+function isElement(node) {
+    return node.tagName !== undefined && node.attrs !== undefined;
+}
+function isParentNode(node) {
+    return Array.isArray(node.childNodes);
+}
+function walk(root, visit) {
+    const stack = [{ node: root, parent: null }];
+    while (stack.length > 0) {
+        const { node, parent } = stack.pop();
+        visit(node, parent);
+        if (!isParentNode(node))
+            continue;
+        const children = [...node.childNodes];
+        for (let i = children.length - 1; i >= 0; i -= 1) {
+            stack.push({ node: children[i], parent: node });
+        }
+    }
+}
+function readText(element) {
+    let text = '';
+    for (const child of element.childNodes) {
+        const node = child;
+        if (node.nodeName === '#text' && typeof node.value === 'string') {
+            text += node.value;
+        }
+    }
+    return text;
+}
+function setText(element, value) {
+    // Replace all child nodes with a single text node carrying `value`.
+    // Use defaultTreeAdapter to keep parent/child wiring sane.
+    for (let i = element.childNodes.length - 1; i >= 0; i -= 1) {
+        defaultTreeAdapter.detachNode(element.childNodes[i]);
+    }
+    defaultTreeAdapter.insertText(element, value);
+}
+//# sourceMappingURL=dom-css-purger.js.map

package/dist/dom-font-inliner.d.ts

@@ -0,0 +1,45 @@
+/**
+ * DOM Font Inliner — AUT-121 Interactive Demos, Phase 3.4
+ *
+ * Walks captured HTML, finds `@font-face { src: url(...) }` references inside
+ * inline `<style>` blocks, fetches each font, and base64-inlines fonts whose
+ * size is below a configurable threshold (default 100kb). Larger fonts are
+ * left untouched — the Linear issue mentions "Base64 OU stockage dédié" as
+ * alternatives, so the threshold lets the caller pick whichever fits.
+ *
+ * Pure module: the actual fetching is delegated via a `fetcher` callback so
+ * this file stays dependency-free and unit-testable. Server-side wiring
+ * passes a Supabase-aware fetcher.
+ */
+/** Maximum bytes a font can have to be inlined as base64. */
+export declare const DEFAULT_FONT_INLINE_THRESHOLD: number;
+export interface FontFetchResult {
+    buffer: Buffer;
+    mimeType: string;
+}
+export interface FontInlineOptions {
+    fetcher: (url: string) => Promise<FontFetchResult | null>;
+    baseUrl?: string;
+    thresholdBytes?: number;
+}
+export interface FontInlineStats {
+    scanned: number;
+    inlined: number;
+    skipped: number;
+    inlinedBytes: number;
+}
+export interface FontInlineResult {
+    html: string;
+    stats: FontInlineStats;
+}
+/**
+ * Walk an HTML document, scan every inline `<style>` block for `@font-face`
+ * `url(...)` references, fetch and base64-inline each one whose payload size
+ * is below the threshold.
+ */
+export declare function inlineFontFaceUrls(html: string, options: FontInlineOptions): Promise<FontInlineResult>;
+/**
+ * Extract every `url(...)` token that appears inside `@font-face { src: ... }`
+ * declarations. Returns the URLs in the order they appear.
+ */
+export declare function extractFontFaceUrls(css: string): string[];