@twip/web 0.0.0-canary-f16fa12

package/dist/editor.js

@@ -0,0 +1,460 @@
+import { createCommands } from './commands.js';
+import { EditorError } from './errors.js';
+import { FontLibrary, useEngine } from './fonts/library.js';
+import { claim } from './host/dom.js';
+import { mountHost } from './host/mount.js';
+import { createMountedReview, createReview } from './review.js';
+import { createAccessibility, createShortcuts } from './services/accessibility.js';
+import { createDialogs } from './services/dialogs.js';
+import { createDataParts, createElements } from './services/elements.js';
+import { createFind } from './services/find.js';
+import { createMenus } from './services/menus.js';
+import { createNavigation, createStyles } from './services/navigation.js';
+import { createRuler } from './services/ruler.js';
+import { createSpelling } from './services/spelling.js';
+import { createGestures } from './services/view.js';
+import { directTransport } from './transport/direct.js';
+import { chooseExecution, workerTransport } from './transport/worker.js';
+import { decodeEvent, Kind, Method } from './transport/protocol.js';
+function destroyed() {
+    return new EditorError('destroyed', 'the editor was destroyed');
+}
+function aborted() {
+    return new EditorError('aborted', 'the operation was aborted');
+}
+/** Bytes as standard base64, as the engine takes them. */
+function base64(bytes) {
+    let s = '';
+    for (let i = 0; i < bytes.length; i += 0x8000)
+        s += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+    return btoa(s);
+}
+/** A request in the engine's JSON shape: bytes travel as base64. */
+export function toWire(value) {
+    if (value instanceof Uint8Array)
+        return base64(value);
+    if (Array.isArray(value))
+        return value.map(toWire);
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, toWire(v)]));
+    return value;
+}
+function deepFreeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const v of Object.values(value))
+            deepFreeze(v);
+    }
+    return value;
+}
+/** One editor's session over a transport: the state cache, the listeners and the calls. Internal. */
+export class Session {
+    transport;
+    id;
+    state;
+    catalog;
+    destroyed = false;
+    #subscribers = new Set();
+    #listeners = new Map();
+    /** Mounted hosts listen for frame and host requests here. */
+    hostListeners = new Set();
+    /** A mounted host's view of an engine event before it is emitted: its viewport points become client points. */
+    adjust;
+    /** Run once on destroy, last added first. */
+    disposers = [];
+    #closing;
+    /** Set by a fatal `error` event: later operations reject with it. */
+    #fault;
+    /** Commits waiting for the state cache to reach their revision. */
+    #waiting = [];
+    constructor(transport, id, state, catalog) {
+        this.transport = transport;
+        this.id = id;
+        this.state = deepFreeze(state);
+        this.catalog = deepFreeze(catalog);
+        this.disposers.push(transport.listen(id, (m) => this.#receive(m)));
+    }
+    /** Creates a session on the page's engine: on this thread, or in the page's engine worker. */
+    static async start(options = {}, execution = 'main') {
+        const { readOnly, mode, author, language, trackChanges } = options;
+        const transport = execution === 'worker' ? workerTransport() : await directTransport();
+        useEngine(transport);
+        const id = await transport.createSession({ readOnly, mode, author, language, trackChanges });
+        try {
+            const state = (await transport.call(id, Method.State));
+            const catalog = (await transport.call(id, Method.Catalog).catch((e) => {
+                // shortcut: an engine without the catalog call gives an empty catalog; drop once every engine has it.
+                if (e instanceof EditorError && e.code === 'unsupported')
+                    return [];
+                throw e;
+            }));
+            const session = new Session(transport, id, state, catalog);
+            for (const dictionary of options.dictionaries ?? [])
+                await session.call(Method.SpellingAddDictionary, dictionary);
+            return session;
+        }
+        catch (e) {
+            await transport.closeSession(id).catch(() => { });
+            throw e;
+        }
+    }
+    /** Rejects `destroyed` once destroyed, or with the fault after one, else runs `call`. */
+    guard(call) {
+        if (this.destroyed)
+            return Promise.reject(destroyed());
+        return this.#fault ? Promise.reject(this.#fault) : call();
+    }
+    /** A structured call, with the request in the engine's JSON shape. */
+    call(method, request) {
+        return this.guard(() => this.transport.call(this.id, method, toWire(request)));
+    }
+    /** A call that commits: resolves with its value once the state cache holds the revision it committed. */
+    async commit(method, request) {
+        const commit = await this.call(method, request);
+        const revision = commit?.record?.revision;
+        if (revision !== undefined && this.state.revision < revision && !this.destroyed) {
+            await new Promise((resolve) => this.#waiting.push({ revision, resolve }));
+        }
+        return (commit?.value ?? undefined);
+    }
+    run(op) {
+        return this.commit(Method.Run, op);
+    }
+    input(input) {
+        return this.guard(() => this.transport.input(this.id, input));
+    }
+    frame(width, height) {
+        return this.guard(() => this.transport.frame(this.id, width, height));
+    }
+    subscribe(listener) {
+        this.#subscribers.add(listener);
+        this.#isolate(() => listener(this.state));
+        return () => this.#subscribers.delete(listener);
+    }
+    on(type, listener) {
+        let set = this.#listeners.get(type);
+        if (!set)
+            this.#listeners.set(type, (set = new Set()));
+        set.add(listener);
+        return () => set.delete(listener);
+    }
+    /** Whether anything listens to `type`. */
+    listening(type) {
+        return (this.#listeners.get(type)?.size ?? 0) > 0;
+    }
+    emit(type, event) {
+        const listeners = [...(this.#listeners.get(type) ?? [])];
+        if (type === 'error' && !listeners.length)
+            console.error(event);
+        for (const listener of listeners) {
+            if (this.destroyed)
+                return;
+            if (type === 'error') {
+                try {
+                    listener(event);
+                }
+                catch (e) {
+                    globalThis.reportError?.(e);
+                }
+            }
+            else
+                this.#isolate(() => listener(event));
+        }
+    }
+    destroy() {
+        return (this.#closing ??= (async () => {
+            this.destroyed = true;
+            for (const { resolve } of this.#waiting.splice(0))
+                resolve();
+            for (const dispose of this.disposers.splice(0).reverse())
+                this.#isolate(dispose);
+            await this.transport.closeSession(this.id).catch(() => { });
+        })());
+    }
+    /** Runs application code: an exception is reported on `error`, never thrown into the engine or other listeners. */
+    #isolate(code) {
+        try {
+            code();
+        }
+        catch (cause) {
+            this.emit('error', new EditorError('internal', `a listener threw: ${String(cause)}`, { cause }));
+        }
+    }
+    #receive(message) {
+        if (this.destroyed)
+            return;
+        switch (message.kind) {
+            case Kind.State: {
+                this.state = deepFreeze(message.payload);
+                const revision = this.state.revision;
+                for (const w of this.#waiting)
+                    if (w.revision <= revision)
+                        w.resolve();
+                this.#waiting = this.#waiting.filter((w) => w.revision > revision);
+                for (const listener of [...this.#subscribers])
+                    if (!this.destroyed)
+                        this.#isolate(() => listener(this.state));
+                break;
+            }
+            case Kind.Event: {
+                const { type, event } = decodeEvent(message.payload);
+                if (event instanceof EditorError && event.fatal)
+                    this.#fault = event;
+                const adjusted = this.adjust && !(event instanceof EditorError) ? this.adjust(type, event) : event;
+                this.emit(type, (adjusted instanceof EditorError ? adjusted : deepFreeze(adjusted)));
+                break;
+            }
+            default:
+                for (const listener of [...this.hostListeners])
+                    if (!this.destroyed)
+                        this.#isolate(() => listener(message));
+        }
+    }
+}
+const sessions = new WeakMap();
+let constructing;
+/** The session behind an editor. Internal: for the SDK's own hosts and tests. */
+export function sessionOf(editor) {
+    const session = sessions.get(editor);
+    if (!session)
+        throw new TypeError('not an editor');
+    return session;
+}
+/** Constructs an editor over `session`. */
+function build(session, make) {
+    constructing = session;
+    try {
+        return make();
+    }
+    finally {
+        constructing = undefined;
+    }
+}
+/** A session with no DOM: Node, workers, tests and servers. */
+export class HeadlessEditor {
+    /** Every edit, one method per command. */
+    commands;
+    /** Every command's id, label, group, shortcuts and undo grouping. */
+    catalog;
+    /** The context menu. */
+    menus;
+    /** The dialogs. */
+    dialogs;
+    /** Find and replace. */
+    find;
+    /** Spell checking. */
+    spelling;
+    /** The document's headings. */
+    navigation;
+    /** The document's styles. */
+    styles;
+    /** Tracked changes and comments. */
+    review;
+    /** The merge designer's elements. */
+    elements;
+    /** The custom XML data parts. */
+    data;
+    /** The ruler model. */
+    ruler;
+    /** The accessibility tree. */
+    accessibility;
+    /** Keyboard shortcuts. */
+    shortcuts;
+    /** Editors are made by {@link HeadlessEditor.create} and {@link Editor.mount}. */
+    constructor() {
+        const session = constructing;
+        if (!session)
+            throw new TypeError('use HeadlessEditor.create() or Editor.mount()');
+        constructing = undefined;
+        sessions.set(this, session);
+        this.commands = createCommands((op) => session.run(op));
+        this.catalog = session.catalog;
+        this.menus = createMenus(session);
+        this.dialogs = createDialogs(session);
+        this.find = createFind(session);
+        this.spelling = createSpelling(session);
+        this.navigation = createNavigation(session);
+        this.styles = createStyles(session);
+        this.review = createReview(session);
+        this.elements = createElements(session);
+        this.data = createDataParts(session);
+        this.ruler = { model: () => session.state.ruler };
+        this.accessibility = createAccessibility(session);
+        this.shortcuts = createShortcuts(session);
+    }
+    /** Creates a session with a blank document. */
+    static async create(options) {
+        const session = await Session.start(options);
+        return build(session, () => new HeadlessEditor());
+    }
+    /** Replaces the document, only after it was read successfully. Resolves with the read's warnings. */
+    open(bytes, options) {
+        const s = sessionOf(this);
+        const signal = options?.signal;
+        return s.guard(async () => {
+            if (signal?.aborted)
+                throw aborted();
+            const token = await s.transport.openPrepare(s.id, bytes);
+            // A task between the read and the replace, for an abort to land in.
+            await new Promise((resolve) => setTimeout(resolve));
+            if (signal?.aborted) {
+                await s.transport.openDiscard(s.id, token).catch(() => { });
+                throw aborted();
+            }
+            return { warnings: await s.guard(() => s.transport.openCommit(s.id, token)) };
+        });
+    }
+    /** Replaces the document with a blank one. */
+    newDocument() {
+        return sessionOf(this).call(Method.NewDocument);
+    }
+    /** Exports the document as DOCX or PDF, with the revision it captures. */
+    export(options) {
+        const s = sessionOf(this);
+        const { format, signal } = options;
+        return s.guard(async () => {
+            const result = await s.transport.export(s.id, { format }, signal);
+            if (signal?.aborted)
+                throw aborted();
+            return result;
+        });
+    }
+    /** Runs several commands atomically: one transaction and one undo step, or nothing when one fails. */
+    batch(ops, options) {
+        return sessionOf(this).commit(Method.Batch, { commands: ops, label: options?.label });
+    }
+    /** The latest state snapshot: synchronous and immutable. */
+    getState() {
+        return sessionOf(this).state;
+    }
+    /** Calls `listener` with the current state now, then after every change. Returns the unsubscribe function. */
+    subscribe(listener) {
+        return sessionOf(this).subscribe(listener);
+    }
+    /** Listens to an event. Returns the unsubscribe function. */
+    on(type, listener) {
+        return sessionOf(this).on(type, listener);
+    }
+    /** Makes the editor read only, or editable again, without reopening. */
+    setReadOnly(value) {
+        return this.#set(Method.SetReadOnly, value);
+    }
+    /** Switches between editing and design mode. */
+    setMode(mode) {
+        return this.#set(Method.SetMode, mode);
+    }
+    /** Sets who makes the next changes. */
+    setAuthor(author) {
+        return this.#set(Method.SetAuthor, author);
+    }
+    /** Counts words, characters, paragraphs, lines and pages. */
+    wordCount() {
+        return sessionOf(this).call(Method.WordCount);
+    }
+    /** Releases the editor. Idempotent; later calls reject `destroyed`. */
+    destroy() {
+        return sessionOf(this).destroy();
+    }
+    /** A setting: a structured call whose response is `null`. */
+    async #set(method, value) {
+        await sessionOf(this).call(method, value);
+    }
+}
+/** An editor mounted in a page: it owns input, rendering, scrolling and its DOM inside the container. */
+export class Editor extends HeadlessEditor {
+    /** The element the editor was mounted in. */
+    container;
+    /** Where the engine runs. */
+    executionMode;
+    /** The rulers: the model, the built-in rulers and the viewport mapping. */
+    ruler;
+    /** Review, with the markup pane and balloons. */
+    review;
+    /** Elements, with drop targets and hit testing. */
+    elements;
+    /** The view. */
+    view;
+    /** The pointer gestures. */
+    gestures;
+    #focus;
+    /** Editors are made by {@link Editor.mount}. */
+    constructor() {
+        const session = constructing;
+        super();
+        const { container, host, rulerView, gestures } = mounting;
+        this.container = container;
+        this.executionMode = mounting.execution;
+        this.#focus = host.focus;
+        this.ruler = createRuler(session, rulerView);
+        this.review = Object.assign(createReview(session), createMountedReview(session), {
+            setMarkupPaneWidth: host.setMarkupPaneWidth,
+            balloonLayer: host.balloonLayer,
+            attachBalloon: host.attachBalloon,
+        });
+        const { hitTest, dragOver, dragLeave, drop } = host;
+        this.elements = Object.assign(createElements(session), { hitTest, dragOver, dragLeave, drop });
+        this.view = host.view;
+        this.gestures = createGestures(session, gestures);
+        // A paste from the system clipboard is the host's: the browser's clipboard is read here.
+        this.commands = Object.freeze({ ...this.commands, paste: host.paste });
+        // So is the context menu's Paste.
+        const { invoke } = this.menus;
+        this.menus = Object.freeze({
+            ...this.menus,
+            invoke: (action) => {
+                const command = action.command;
+                return command?.type === 'paste' ? host.paste(command.as ? { as: command.as } : undefined) : invoke(action);
+            },
+        });
+    }
+    /** Mounts an editor in `container`, which must be empty of other editors. Resolves when it accepts commands. */
+    static async mount(container, options = {}) {
+        const release = claim(container);
+        let session;
+        try {
+            const execution = chooseExecution(options.execution);
+            const abort = () => {
+                if (options.signal?.aborted)
+                    throw new EditorError('aborted', 'the mount was aborted');
+            };
+            abort();
+            session = await Session.start(options, execution);
+            const s = session;
+            s.disposers.push(release);
+            abort();
+            // The shortcuts the editor claims, read through the editor's own lookup once it exists.
+            let lookup;
+            const host = await mountHost(container, s, options, (keys) => lookup?.(keys) != null);
+            const [rulerView, gestures] = await Promise.all([s.call(Method.HostRulerView), s.call(Method.GesturesBindings)]);
+            mounting = { container, execution, host, rulerView: s.adjust?.('rulerChanged', rulerView), gestures };
+            const editor = build(s, () => new Editor());
+            lookup = editor.shortcuts.lookup;
+            const { rulers, rulerUnit } = options;
+            if (rulers)
+                await editor.ruler.setVisible(rulers === true ? { horizontal: true, vertical: true } : rulers);
+            if (rulerUnit)
+                await editor.ruler.setUnit(rulerUnit);
+            if (options.document)
+                await editor.open(options.document, { signal: options.signal });
+            abort();
+            await host.ready();
+            abort();
+            return editor;
+        }
+        catch (e) {
+            if (session)
+                await session.destroy();
+            else
+                release();
+            throw e;
+        }
+        finally {
+            mounting = undefined;
+        }
+    }
+    /** Focuses the editor, keeping the selection. Mounting never takes focus by itself. */
+    focus() {
+        this.#focus();
+    }
+}
+let mounting;

package/dist/errors.d.ts

@@ -0,0 +1,21 @@
+/** The stable code of an {@link EditorError}. */
+export type ErrorCode = 'destroyed' | 'invalid-argument' | 'unavailable' | 'read-only' | 'import-failed' | 'export-failed' | 'aborted' | 'not-allowed' | 'unsupported' | 'internal';
+/** Why an operation failed. Every rejected promise of the API rejects with one. */
+export declare class EditorError extends Error {
+    /** The stable code: branch on this, not on the message. */
+    readonly code: ErrorCode;
+    /** Structured details, for some codes. */
+    readonly details?: unknown;
+    /** A fault: the editor rejects new operations and stays destroyable. */
+    readonly fatal: boolean;
+    /** Creates an error. Applications don't usually need to. */
+    constructor(code: ErrorCode, message: string, options?: {
+        details?: unknown;
+        fatal?: boolean;
+        cause?: unknown;
+    });
+}
+/** The error a member outside what this build implements rejects or throws with. */
+export declare function unsupported(what: string): EditorError;
+/** A rejected promise with {@link unsupported}. */
+export declare function rejectUnsupported(what: string): Promise<never>;

package/dist/errors.js

@@ -0,0 +1,26 @@
+/** Why an operation failed. Every rejected promise of the API rejects with one. */
+export class EditorError extends Error {
+    /** The stable code: branch on this, not on the message. */
+    code;
+    /** Structured details, for some codes. */
+    details;
+    /** A fault: the editor rejects new operations and stays destroyable. */
+    fatal;
+    /** Creates an error. Applications don't usually need to. */
+    constructor(code, message, options) {
+        super(message, options?.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'EditorError';
+        this.code = code;
+        if (options?.details !== undefined)
+            this.details = options.details;
+        this.fatal = options?.fatal ?? false;
+    }
+}
+/** The error a member outside what this build implements rejects or throws with. */
+export function unsupported(what) {
+    return new EditorError('unsupported', `${what} is not supported yet`);
+}
+/** A rejected promise with {@link unsupported}. */
+export function rejectUnsupported(what) {
+    return Promise.reject(unsupported(what));
+}

package/dist/events.d.ts

@@ -0,0 +1,126 @@
+import type { EditorError } from './errors.js';
+import type { BalloonPlacement, CommentAnchor } from './review.js';
+import type { DialogKind } from './services/dialogs.js';
+import type { ElementInfo } from './services/elements.js';
+import type { ContextMenuEvent } from './services/menus.js';
+import type { RulerView } from './services/ruler.js';
+import type { GestureEvent } from './services/view.js';
+import type { SelectionSummary } from './state.js';
+import type { Author, ClientPoint, ClientRect, CommentId, ElementId, RevisionId, Warning } from './types.js';
+/** Every event of `editor.on(type, listener)`, keyed by type. */
+export interface TwipEvents {
+    /** A transaction committed: exactly one per commit, in order, never coalesced. */
+    documentChanged: TransactionRecord;
+    /** The selection changed; coalesced per frame. */
+    selectionChanged: SelectionSummary;
+    /** A link was activated: a click when read only, Ctrl+click otherwise. */
+    linkActivated: {
+        address: string;
+        via: 'ctrlClick' | 'click';
+    };
+    /** An unfilled picture placeholder was clicked. */
+    placeholderActivated: {
+        key: string;
+        element: ElementId | null;
+    };
+    /** The user asked for a context menu. */
+    contextMenu: ContextMenuEvent;
+    /** A key or gesture asked for a dialog. */
+    dialogRequested: {
+        kind: DialogKind;
+    };
+    /** A key the application owns was pressed. */
+    hostCommand: {
+        command: HostCommand;
+    };
+    /** An application shortcut from `shortcuts.register` was pressed. */
+    shortcut: {
+        id: string;
+    };
+    /** Mounted only: a gesture bound to `'emit'`. */
+    gesture: GestureEvent;
+    /** A word was added to the user's dictionary: persist it. */
+    wordAdded: {
+        word: string;
+        language: string;
+    };
+    /** Fonts started or finished loading, or could not be found. */
+    fontsChanged: {
+        pending: string[];
+        unresolved: string[];
+    };
+    /** Design mode: Enter or double-click on an element. */
+    elementActivated: {
+        id: ElementId;
+    };
+    /** Elements were added, removed or changed. */
+    elementsChanged: {
+        added: ElementInfo[];
+        removed: ElementId[];
+        changed: ElementInfo[];
+    };
+    /** Fields the application computes need results: answer with `setFieldResults`. */
+    fieldsUpdateRequested: {
+        token: number;
+        fields: {
+            id: ElementId;
+            code: string;
+        }[];
+    };
+    /** The tracked revisions changed. */
+    revisionsChanged: {};
+    /** The comments changed. */
+    commentsChanged: {};
+    /** Mounted only: the visible comments, after layout, zoom or scroll. */
+    commentAnchors: CommentAnchor[];
+    /** Mounted only: the SDK placed the attached balloons. */
+    balloonsLaidOut: BalloonPlacement[];
+    /** Mounted only: the rulers changed; coalesced per frame. */
+    rulerChanged: RulerView;
+    /** Mounted only: hover over a link, element mark, revision or comment, or `null` when it ends. */
+    tooltip: Tooltip | null;
+    /** What the editor said to screen readers. */
+    announcement: {
+        text: string;
+    };
+    /** A fidelity warning outside an operation. */
+    warning: Warning;
+    /** A listener's exception, or a fault (then `fatal` is true). */
+    error: EditorError;
+}
+/** A committed transaction. */
+export interface TransactionRecord {
+    /** Unique per session. */
+    id: number;
+    /** The revision it committed. */
+    revision: number;
+    /** Who started it: the user's input, an API call, undo or redo. */
+    origin: 'user' | 'api' | 'undo' | 'redo';
+    /** The session's author at the time. */
+    author: Author;
+    /** When, ISO 8601 UTC. */
+    time: string;
+    /** The undo label. */
+    label: string;
+    /** What it touched. */
+    summary: {
+        paragraphs: number;
+        tables: number;
+        elements: ElementId[];
+        revisions: RevisionId[];
+        comments: CommentId[];
+    };
+}
+/** A key the application owns. */
+export type HostCommand = 'save' | 'saveAs' | 'print' | 'open' | 'new' | 'find' | 'replace' | 'goTo' | 'insertHyperlink' | 'nextMisspelling' | 'focusFont' | 'focusFontSize' | 'help';
+/** A hover tooltip to show. */
+export interface Tooltip {
+    /** What is hovered. */
+    kind: 'link' | 'mark' | 'revision' | 'comment';
+    /** The text to show. */
+    text: string;
+    /** The pointer. */
+    at: ClientPoint;
+    /** The hovered thing's box. */
+    rect: ClientRect;
+}

package/dist/events.js

@@ -0,0 +1 @@
+export {};

package/dist/fonts/google.d.ts

@@ -0,0 +1,3 @@
+import type { FaceInfo, FontSource } from './library.js';
+/** A source that adds a family's faces from Google Fonts, each family fetched once; `families` limits it to those. */
+export declare function googleFonts(add: (url: string, signal: AbortSignal) => Promise<FaceInfo[]>, families?: string[]): FontSource;

package/dist/fonts/google.js

@@ -0,0 +1,39 @@
+/** The styles asked for, most first: a family without italics or weights fails the fuller requests. */
+// shortcut: only regular, bold, italic and bold italic are requested
+const styles = [':ital,wght@0,400;0,700;1,400;1,700', ':wght@400;700', ''];
+/** A source that adds a family's faces from Google Fonts, each family fetched once; `families` limits it to those. */
+export function googleFonts(add, families) {
+    const only = families && new Set(families.map((f) => f.toLowerCase()));
+    const loads = new Map();
+    return (request, signal) => {
+        const key = request.family.toLowerCase();
+        if (only && !only.has(key))
+            return Promise.resolve(false);
+        let load = loads.get(key);
+        if (!load) {
+            loads.set(key, (load = fetchFamily(request.family, add, signal)));
+            load.catch(() => loads.delete(key));
+        }
+        return load;
+    };
+}
+/** Adds every face of `family` the stylesheet names; false when Google doesn't have the family. */
+async function fetchFamily(family, add, signal) {
+    const name = encodeURIComponent(family).replace(/%20/g, '+');
+    for (const style of styles) {
+        // Google answers a family it doesn't have with a 400 that has no CORS header, so in a browser the fetch rejects:
+        // a miss, not an error.
+        const css = await fetch(`https://fonts.googleapis.com/css2?family=${name}${style}`, { signal }).catch((e) => {
+            if (signal.aborted)
+                throw e;
+        });
+        if (!css)
+            return false;
+        if (!css.ok)
+            continue;
+        const urls = [...(await css.text()).matchAll(/src:\s*url\((['"]?)([^'")]+)\1\)/g)].map((m) => m[2]);
+        const faces = await Promise.all([...new Set(urls)].map((url) => add(url, signal)));
+        return faces.flat().length > 0;
+    }
+    return false;
+}