@addonova/browser 0.1.0 → 0.2.0

package/dist/testing/fake-browser.js

@@ -0,0 +1,994 @@
+import { clearAdapterCache } from '../browser/resolve.js';
+export function createFakeEvent() {
+    const listeners = new Set();
+    return {
+        addListener(listener) {
+            listeners.add(listener);
+        },
+        removeListener(listener) {
+            listeners.delete(listener);
+        },
+        hasListener(listener) {
+            return listeners.has(listener);
+        },
+        hasListeners() {
+            return listeners.size > 0;
+        },
+        emit(...args) {
+            this.dispatch(...args);
+        },
+        dispatch(...args) {
+            return [...listeners].map((listener) => listener(...args));
+        },
+        clear() {
+            listeners.clear();
+        },
+        get listenerCount() {
+            return listeners.size;
+        },
+    };
+}
+export function createFakeBrowser(options = {}) {
+    const target = options.target ?? 'chrome';
+    const id = options.id ?? 'fake-extension-id';
+    const manifest = {
+        manifest_version: 3,
+        name: 'Fake extension',
+        version: '1.0.0',
+        ...(options.messages === undefined
+            ? {}
+            : {
+                default_locale: 'en',
+            }),
+        ...options.manifest,
+    };
+    const state = {
+        storage: {
+            local: new Map(),
+            sync: new Map(),
+            session: new Map(),
+            managed: new Map(),
+        },
+        tabs: new Map(),
+        windows: new Map(),
+        currentWindowId: 1,
+        nextTabId: 1,
+        nextWindowId: 2,
+        nextNotificationId: 1,
+        alarms: new Map(),
+        permissions: new Set(options.permissions?.permissions ?? []),
+        origins: new Set(options.permissions?.origins ?? []),
+        notifications: new Map(),
+        badgeText: undefined,
+        title: undefined,
+    };
+    const events = [];
+    const event = () => {
+        const created = createFakeEvent();
+        events.push(created);
+        return created;
+    };
+    for (const [area, values] of Object.entries(options.initialStorage ?? {})) {
+        for (const [key, value] of Object.entries(values ?? {})) {
+            state.storage[area].set(key, value);
+        }
+    }
+    const onMessage = event();
+    const onInstalled = event();
+    const onStartup = event();
+    const onSuspend = event();
+    const storageOnChanged = event();
+    const onCreated = event();
+    const onUpdated = event();
+    const onRemoved = event();
+    const onActivated = event();
+    const actionOnClicked = event();
+    const onAlarm = event();
+    const permissionsOnAdded = event();
+    const permissionsOnRemoved = event();
+    const notificationsOnClicked = event();
+    const notificationsOnClosed = event();
+    const notificationsOnButtonClicked = event();
+    const commandsOnCommand = event();
+    const contextMenusOnClicked = event();
+    const cookiesOnChanged = event();
+    const downloadsOnChanged = event();
+    const sessionsOnChanged = event();
+    const defaultSender = {
+        id,
+        url: `chrome-extension://${id}/content.js`,
+    };
+    const runtime = {
+        id,
+        lastError: undefined,
+        getManifest() {
+            return manifest;
+        },
+        getURL(path) {
+            const prefix = target === 'firefox'
+                ? `moz-extension://${id}/`
+                : `chrome-extension://${id}/`;
+            return `${prefix}${path.replace(/^\//, '')}`;
+        },
+        sendMessage(...args) {
+            const callback = takeCallback(args);
+            const response = dispatchMessage(args[0]);
+            if (callback !== undefined) {
+                void response.then((value) => callback(value));
+            }
+            return response;
+        },
+        connect(connectInfo) {
+            const portOnMessage = createFakeEvent();
+            const portOnDisconnect = createFakeEvent();
+            let connected = true;
+            const port = {
+                name: connectInfo?.name ?? '',
+                sender: defaultSender,
+                postMessage() { },
+                disconnect() {
+                    if (connected) {
+                        connected = false;
+                        portOnDisconnect.emit(port);
+                    }
+                },
+                onMessage: portOnMessage,
+                onDisconnect: portOnDisconnect,
+            };
+            return port;
+        },
+        onMessage,
+        onInstalled,
+        onStartup,
+        onSuspend,
+    };
+    function dispatchMessage(message) {
+        return new Promise((resolve) => {
+            let settled = false;
+            let keepOpen = false;
+            const finish = (response) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                resolve(response);
+            };
+            const results = onMessage.dispatch(message, defaultSender, finish);
+            for (const result of results) {
+                if (result === true) {
+                    keepOpen = true;
+                }
+            }
+            if (!keepOpen) {
+                queueMicrotask(() => finish(undefined));
+            }
+        });
+    }
+    const storage = {
+        local: createArea('local'),
+        sync: createArea('sync'),
+        session: createArea('session'),
+        managed: createArea('managed'),
+        onChanged: storageOnChanged,
+    };
+    function createArea(area) {
+        const data = state.storage[area];
+        return {
+            get(...args) {
+                const callback = takeCallback(args);
+                const keys = args[0];
+                const value = readStorage(data, keys);
+                deliver(callback, value);
+                return Promise.resolve(value);
+            },
+            set(...args) {
+                const callback = takeCallback(args);
+                const items = args[0];
+                const changes = {};
+                for (const [key, value] of Object.entries(items)) {
+                    const change = data.has(key)
+                        ? { oldValue: data.get(key), newValue: value }
+                        : { newValue: value };
+                    changes[key] = change;
+                    data.set(key, value);
+                }
+                if (Object.keys(changes).length > 0) {
+                    storageOnChanged.emit(changes, area);
+                }
+                deliver(callback, undefined);
+                return Promise.resolve();
+            },
+            remove(...args) {
+                const callback = takeCallback(args);
+                const keys = args[0];
+                const names = normalizeKeys(keys);
+                const changes = {};
+                for (const key of names) {
+                    if (data.has(key)) {
+                        changes[key] = { oldValue: data.get(key) };
+                        data.delete(key);
+                    }
+                }
+                if (Object.keys(changes).length > 0) {
+                    storageOnChanged.emit(changes, area);
+                }
+                deliver(callback, undefined);
+                return Promise.resolve();
+            },
+            clear(...args) {
+                const callback = takeCallback(args);
+                const changes = {};
+                for (const [key, value] of data) {
+                    changes[key] = { oldValue: value };
+                }
+                data.clear();
+                if (Object.keys(changes).length > 0) {
+                    storageOnChanged.emit(changes, area);
+                }
+                deliver(callback, undefined);
+                return Promise.resolve();
+            },
+            getBytesInUse(...args) {
+                const callback = takeCallback(args);
+                const bytes = JSON.stringify(Object.fromEntries(data)).length;
+                deliver(callback, bytes);
+                return Promise.resolve(bytes);
+            },
+        };
+    }
+    const tabs = {
+        query(...args) {
+            const callback = takeCallback(args);
+            const queryInfo = args[0] ?? {};
+            const matches = [...state.tabs.values()].filter((tab) => matchesTab(tab, queryInfo));
+            deliver(callback, matches);
+            return Promise.resolve(matches);
+        },
+        get(...args) {
+            const callback = takeCallback(args);
+            const tabId = args[0];
+            const tab = requireTab(state, tabId);
+            deliver(callback, tab);
+            return Promise.resolve(tab);
+        },
+        create(...args) {
+            const callback = takeCallback(args);
+            const properties = args[0] ?? {};
+            const tab = addTab(state, properties);
+            if (tab.active) {
+                for (const other of state.tabs.values()) {
+                    if (other.windowId === tab.windowId && other.id !== tab.id) {
+                        setTabActive(other, false);
+                    }
+                }
+                onActivated.emit({ tabId: tab.id, windowId: tab.windowId });
+            }
+            onCreated.emit(tab);
+            deliver(callback, tab);
+            return Promise.resolve(tab);
+        },
+        update(...args) {
+            const callback = takeCallback(args);
+            const tabId = args[0];
+            const updates = args[1] ?? {};
+            const tab = requireTab(state, tabId);
+            const updated = { ...tab, ...updates };
+            state.tabs.set(tabId, updated);
+            if (updates.active === true) {
+                onActivated.emit({ tabId, windowId: updated.windowId });
+            }
+            onUpdated.emit(tabId, updates, updated);
+            deliver(callback, updated);
+            return Promise.resolve(updated);
+        },
+        remove(...args) {
+            const callback = takeCallback(args);
+            const tabIds = args[0];
+            const ids = Array.isArray(tabIds)
+                ? tabIds
+                : [tabIds];
+            for (const tabId of ids) {
+                if (state.tabs.delete(tabId)) {
+                    onRemoved.emit(tabId, { windowId: state.currentWindowId });
+                }
+            }
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        reload(...args) {
+            const callback = takeCallback(args);
+            const tabId = typeof args[0] === 'number'
+                ? args[0]
+                : [...state.tabs.values()].find((tab) => tab.active)?.id;
+            if (tabId === undefined) {
+                throw new Error('No tab to reload.');
+            }
+            const tab = requireTab(state, tabId);
+            onUpdated.emit(tabId, { status: 'loading' }, tab);
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        sendMessage(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, undefined);
+            return Promise.resolve(undefined);
+        },
+        onCreated,
+        onUpdated,
+        onRemoved,
+        onActivated,
+    };
+    const windows = {
+        getCurrent(...args) {
+            const callback = takeCallback(args);
+            const value = requireWindow(state, state.currentWindowId);
+            deliver(callback, value);
+            return Promise.resolve(value);
+        },
+        create(...args) {
+            const callback = takeCallback(args);
+            const properties = args[0] ?? {};
+            const window = {
+                id: state.nextWindowId,
+                focused: true,
+                type: 'normal',
+                state: 'normal',
+                ...properties,
+            };
+            state.nextWindowId += 1;
+            state.windows.set(window.id, window);
+            deliver(callback, window);
+            return Promise.resolve(window);
+        },
+        update(...args) {
+            const callback = takeCallback(args);
+            const windowId = args[0];
+            const updates = args[1] ?? {};
+            const window = {
+                ...requireWindow(state, windowId),
+                ...updates,
+            };
+            state.windows.set(windowId, window);
+            deliver(callback, window);
+            return Promise.resolve(window);
+        },
+        remove(...args) {
+            const callback = takeCallback(args);
+            state.windows.delete(args[0]);
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        getAll(...args) {
+            const callback = takeCallback(args);
+            const values = [...state.windows.values()];
+            deliver(callback, values);
+            return Promise.resolve(values);
+        },
+    };
+    const action = {
+        area: 'action',
+        setBadgeText(...args) {
+            const callback = takeCallback(args);
+            state.badgeText = args[0].text;
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        setBadgeBackgroundColor(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        setTitle(...args) {
+            const callback = takeCallback(args);
+            state.title = args[0].title;
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        setIcon(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        openPopup(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        onClicked: actionOnClicked,
+        get badgeText() {
+            return state.badgeText;
+        },
+        get title() {
+            return state.title;
+        },
+    };
+    const alarms = {
+        create(...args) {
+            const callback = takeCallback(args);
+            const [nameOrInfo, infoOrCallback] = args;
+            const name = typeof nameOrInfo === 'string' ? nameOrInfo : '';
+            const info = typeof nameOrInfo === 'string'
+                ? (infoOrCallback ?? {})
+                : (nameOrInfo ?? {});
+            const scheduledTime = typeof info.when === 'number'
+                ? info.when
+                : Date.now() + Number(info.delayInMinutes ?? 0) * 60_000;
+            state.alarms.set(name, {
+                name,
+                scheduledTime,
+                ...(info.periodInMinutes === undefined
+                    ? {}
+                    : { periodInMinutes: info.periodInMinutes }),
+            });
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        get(...args) {
+            const callback = takeCallback(args);
+            const value = state.alarms.get(args[0] ?? '');
+            deliver(callback, value);
+            return Promise.resolve(value);
+        },
+        getAll(...args) {
+            const callback = takeCallback(args);
+            const values = [...state.alarms.values()];
+            deliver(callback, values);
+            return Promise.resolve(values);
+        },
+        clear(...args) {
+            const callback = takeCallback(args);
+            const cleared = state.alarms.delete(args[0] ?? '');
+            deliver(callback, cleared);
+            return Promise.resolve(cleared);
+        },
+        clearAll(...args) {
+            const callback = takeCallback(args);
+            const cleared = state.alarms.size > 0;
+            state.alarms.clear();
+            deliver(callback, cleared);
+            return Promise.resolve(cleared);
+        },
+        onAlarm,
+    };
+    const messages = options.messages ?? {};
+    const i18n = {
+        getMessage(messageName, substitutions) {
+            const entry = messages[messageName];
+            const message = typeof entry === 'string' ? entry : entry?.message ?? '';
+            return applySubstitutions(message, substitutions);
+        },
+        getUILanguage() {
+            return options.uiLanguage ?? 'en-US';
+        },
+        detectLanguage() {
+            return Promise.resolve({
+                isReliable: true,
+                languages: [{ language: options.uiLanguage ?? 'en', percentage: 100 }],
+            });
+        },
+    };
+    const permissions = {
+        contains(...args) {
+            const callback = takeCallback(args);
+            const value = containsPermissions(state, args[0]);
+            deliver(callback, value);
+            return Promise.resolve(value);
+        },
+        request(...args) {
+            const callback = takeCallback(args);
+            const requested = args[0];
+            const added = addPermissions(state, requested);
+            if (added.permissions.length > 0 || added.origins.length > 0) {
+                permissionsOnAdded.emit(added);
+            }
+            deliver(callback, true);
+            return Promise.resolve(true);
+        },
+        remove(...args) {
+            const callback = takeCallback(args);
+            const removed = removePermissions(state, args[0]);
+            if (removed.permissions.length > 0 || removed.origins.length > 0) {
+                permissionsOnRemoved.emit(removed);
+            }
+            deliver(callback, true);
+            return Promise.resolve(true);
+        },
+        getAll(...args) {
+            const callback = takeCallback(args);
+            const value = {
+                permissions: [...state.permissions],
+                origins: [...state.origins],
+            };
+            deliver(callback, value);
+            return Promise.resolve(value);
+        },
+        onAdded: permissionsOnAdded,
+        onRemoved: permissionsOnRemoved,
+    };
+    const scripting = {
+        executeScript(...args) {
+            const callback = takeCallback(args);
+            const input = args[0];
+            const injections = Array.isArray(input) ? input : [input];
+            const results = [];
+            for (const injection of injections) {
+                const frameId = injection.target.frameIds?.[0] ?? 0;
+                try {
+                    const result = injection.func === undefined
+                        ? undefined
+                        : injection.func(...(injection.args ?? []));
+                    results.push(result === undefined
+                        ? { frameId }
+                        : { frameId, result });
+                }
+                catch (error) {
+                    results.push({
+                        frameId,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            deliver(callback, results);
+            return Promise.resolve(results);
+        },
+        insertCSS(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        removeCSS(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+    };
+    const notifications = {
+        create(...args) {
+            const callback = takeCallback(args);
+            const id = `notification-${state.nextNotificationId}`;
+            state.nextNotificationId += 1;
+            state.notifications.set(id, args[0] ?? {});
+            deliver(callback, id);
+            return Promise.resolve(id);
+        },
+        update(...args) {
+            const callback = takeCallback(args);
+            const id = args[0];
+            const updated = state.notifications.has(id);
+            if (updated) {
+                state.notifications.set(id, args[1]);
+            }
+            deliver(callback, updated);
+            return Promise.resolve(updated);
+        },
+        clear(...args) {
+            const callback = takeCallback(args);
+            const cleared = state.notifications.delete(args[0]);
+            deliver(callback, cleared);
+            return Promise.resolve(cleared);
+        },
+        getAll(...args) {
+            const callback = takeCallback(args);
+            const value = Object.fromEntries([...state.notifications.keys()].map((key) => [key, true]));
+            deliver(callback, value);
+            return Promise.resolve(value);
+        },
+        onClicked: notificationsOnClicked,
+        onClosed: notificationsOnClosed,
+        onButtonClicked: notificationsOnButtonClicked,
+    };
+    const commands = {
+        getAll(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, []);
+            return Promise.resolve([]);
+        },
+        onCommand: commandsOnCommand,
+    };
+    const contextMenus = {
+        create(...args) {
+            const id = args[0].id ?? 'context-menu';
+            takeCallback(args);
+            return id;
+        },
+        update(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        remove(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        removeAll(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        onClicked: contextMenusOnClicked,
+    };
+    const cookies = {
+        get(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, null);
+            return Promise.resolve(null);
+        },
+        getAll(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, []);
+            return Promise.resolve([]);
+        },
+        set(...args) {
+            const callback = takeCallback(args);
+            const value = args[0];
+            deliver(callback, value);
+            return Promise.resolve(value);
+        },
+        remove(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        onChanged: cookiesOnChanged,
+    };
+    const downloads = {
+        download(...args) {
+            const callback = takeCallback(args);
+            const id = state.nextNotificationId;
+            state.nextNotificationId += 1;
+            deliver(callback, id);
+            return Promise.resolve(id);
+        },
+        cancel(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        search(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, []);
+            return Promise.resolve([]);
+        },
+        onChanged: downloadsOnChanged,
+    };
+    const sessions = {
+        getRecentlyClosed(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, []);
+            return Promise.resolve([]);
+        },
+        restore(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, undefined);
+            return Promise.resolve(undefined);
+        },
+        onChanged: sessionsOnChanged,
+    };
+    const bookmarks = {
+        getTree(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, []);
+            return Promise.resolve([]);
+        },
+        search(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, []);
+            return Promise.resolve([]);
+        },
+        get(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, []);
+            return Promise.resolve([]);
+        },
+        getSubTree(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, []);
+            return Promise.resolve([]);
+        },
+        getChildren(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, []);
+            return Promise.resolve([]);
+        },
+        create(...args) {
+            const callback = takeCallback(args);
+            const value = args[0];
+            deliver(callback, value);
+            return Promise.resolve(value);
+        },
+        move(...args) {
+            const callback = takeCallback(args);
+            const value = args[0];
+            deliver(callback, value);
+            return Promise.resolve(value);
+        },
+        update(...args) {
+            const callback = takeCallback(args);
+            const value = args[0];
+            deliver(callback, value);
+            return Promise.resolve(value);
+        },
+        remove(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        removeTree(...args) {
+            const callback = takeCallback(args);
+            deliver(callback, undefined);
+            return Promise.resolve();
+        },
+        onCreated: event(),
+        onRemoved: event(),
+        onChanged: event(),
+        onMoved: event(),
+    };
+    const webNavigation = {
+        onBeforeNavigate: event(),
+        onCommitted: event(),
+        onDOMContentLoaded: event(),
+        onCompleted: event(),
+        onErrorOccurred: event(),
+        onCreatedNavigationTarget: event(),
+        onReferenceFragmentUpdated: event(),
+        onHistoryStateUpdated: event(),
+    };
+    const webRequest = {
+        onBeforeRequest: event(),
+        onBeforeSendHeaders: event(),
+        onSendHeaders: event(),
+        onHeadersReceived: event(),
+        onResponseStarted: event(),
+        onCompleted: event(),
+        onErrorOccurred: event(),
+    };
+    if (state.windows.size === 0) {
+        state.windows.set(state.currentWindowId, {
+            id: state.currentWindowId,
+            focused: true,
+            type: 'normal',
+            state: 'normal',
+        });
+    }
+    for (const tab of options.initialTabs ?? []) {
+        addTab(state, tab);
+    }
+    const fake = {
+        target,
+        runtime,
+        storage,
+        tabs,
+        windows,
+        action,
+        alarms,
+        i18n,
+        permissions,
+        scripting,
+        notifications,
+        commands,
+        contextMenus,
+        cookies,
+        downloads,
+        sessions,
+        bookmarks,
+        webNavigation,
+        webRequest,
+        reset() {
+            for (const area of Object.values(state.storage)) {
+                area.clear();
+            }
+            state.tabs.clear();
+            state.windows.clear();
+            state.windows.set(state.currentWindowId, {
+                id: state.currentWindowId,
+                focused: true,
+                type: 'normal',
+                state: 'normal',
+            });
+            state.nextTabId = 1;
+            state.nextWindowId = 2;
+            state.nextNotificationId = 1;
+            state.alarms.clear();
+            state.permissions.clear();
+            state.origins.clear();
+            state.notifications.clear();
+            state.badgeText = undefined;
+            state.title = undefined;
+            for (const created of events) {
+                created.clear();
+            }
+        },
+    };
+    return fake;
+}
+export const fakeBrowser = /*#__PURE__*/ createFakeBrowser();
+let installedFakeBrowser;
+export function resetFakeBrowser() {
+    (installedFakeBrowser ?? fakeBrowser).reset();
+}
+export function installFakeBrowser(options = {}) {
+    const scope = (options.scope ?? globalThis);
+    const fake = Object.keys(options).length === 0
+        ? fakeBrowser
+        : createFakeBrowser(options);
+    const target = options.target ?? fake.target;
+    if (target === 'firefox') {
+        scope.browser = fake;
+        delete scope.chrome;
+    }
+    else {
+        scope.chrome = fake;
+        scope.browser = fake;
+    }
+    installedFakeBrowser = fake;
+    clearAdapterCache();
+    return fake;
+}
+export function uninstallFakeBrowser(scope = globalThis) {
+    const value = scope;
+    delete value.browser;
+    delete value.chrome;
+    installedFakeBrowser = undefined;
+    clearAdapterCache();
+}
+function readStorage(data, keys) {
+    if (keys === undefined || keys === null || typeof keys === 'function') {
+        return Object.fromEntries(data);
+    }
+    if (typeof keys === 'string') {
+        return data.has(keys) ? { [keys]: data.get(keys) } : {};
+    }
+    if (Array.isArray(keys)) {
+        return Object.fromEntries(keys
+            .filter((key) => typeof key === 'string')
+            .filter((key) => data.has(key))
+            .map((key) => [key, data.get(key)]));
+    }
+    if (typeof keys === 'object') {
+        const result = {};
+        for (const [key, fallback] of Object.entries(keys)) {
+            result[key] = data.has(key) ? data.get(key) : fallback;
+        }
+        return result;
+    }
+    return {};
+}
+function normalizeKeys(keys) {
+    if (keys === undefined || keys === null) {
+        return [];
+    }
+    return Array.isArray(keys)
+        ? keys.filter((key) => typeof key === 'string')
+        : typeof keys === 'string'
+            ? [keys]
+            : [];
+}
+function takeCallback(args) {
+    const last = args[args.length - 1];
+    if (typeof last === 'function') {
+        args.pop();
+        return last;
+    }
+    return undefined;
+}
+function deliver(callback, value) {
+    if (callback !== undefined) {
+        queueMicrotask(() => callback(value));
+    }
+}
+function matchesTab(tab, query) {
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined ||
+            key === 'currentWindow' ||
+            key === 'lastFocusedWindow' ||
+            key === 'windowType' ||
+            key === 'populate') {
+            continue;
+        }
+        if (key === 'url') {
+            const urls = Array.isArray(value) ? value : [value];
+            if (!urls.some((url) => matchesPattern(String(url), tab.url ?? ''))) {
+                return false;
+            }
+            continue;
+        }
+        if (tab[key] !== value) {
+            return false;
+        }
+    }
+    return true;
+}
+function matchesPattern(pattern, value) {
+    if (pattern === value || pattern === '<all_urls>' || pattern === '*://*/*') {
+        return true;
+    }
+    const expression = pattern
+        .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+        .replaceAll('*', '.*');
+    return new RegExp(`^${expression}$`).test(value);
+}
+function addTab(state, properties) {
+    const id = typeof properties.id === 'number' ? properties.id : state.nextTabId;
+    state.nextTabId = Math.max(state.nextTabId, id + 1);
+    const windowId = typeof properties.windowId === 'number'
+        ? properties.windowId
+        : state.currentWindowId;
+    const index = typeof properties.index === 'number'
+        ? properties.index
+        : [...state.tabs.values()].filter((tab) => tab.windowId === windowId)
+            .length;
+    const tab = {
+        id,
+        index,
+        windowId,
+        active: properties.active === true,
+        highlighted: properties.highlighted === true,
+        pinned: properties.pinned === true,
+        incognito: properties.incognito === true,
+        ...properties,
+    };
+    state.tabs.set(id, tab);
+    return tab;
+}
+function setTabActive(tab, active) {
+    const mutable = tab;
+    mutable.active = active;
+}
+function requireTab(state, tabId) {
+    const tab = state.tabs.get(tabId);
+    if (tab === undefined) {
+        throw new Error(`No tab with id ${tabId}.`);
+    }
+    return tab;
+}
+function requireWindow(state, windowId) {
+    const window = state.windows.get(windowId);
+    if (window === undefined) {
+        throw new Error(`No window with id ${windowId}.`);
+    }
+    return window;
+}
+function containsPermissions(state, requested) {
+    const permissions = requested.permissions ?? [];
+    const origins = requested.origins ?? [];
+    return ((Array.isArray(permissions) &&
+        permissions.every((permission) => state.permissions.has(String(permission)))) &&
+        (Array.isArray(origins) &&
+            origins.every((origin) => state.origins.has(String(origin)))));
+}
+function addPermissions(state, requested) {
+    const permissions = [];
+    const origins = [];
+    for (const permission of toArray(requested.permissions)) {
+        if (!state.permissions.has(permission)) {
+            state.permissions.add(permission);
+            permissions.push(permission);
+        }
+    }
+    for (const origin of toArray(requested.origins)) {
+        if (!state.origins.has(origin)) {
+            state.origins.add(origin);
+            origins.push(origin);
+        }
+    }
+    return { permissions, origins };
+}
+function removePermissions(state, requested) {
+    const permissions = toArray(requested.permissions).filter((permission) => state.permissions.delete(permission));
+    const origins = toArray(requested.origins).filter((origin) => state.origins.delete(origin));
+    return { permissions, origins };
+}
+function toArray(value) {
+    return Array.isArray(value)
+        ? value.map((item) => String(item))
+        : [];
+}
+function applySubstitutions(message, substitutions) {
+    if (substitutions === undefined) {
+        return message;
+    }
+    const values = typeof substitutions === 'string' ? [substitutions] : substitutions;
+    return values.reduce((result, value, index) => result.replaceAll(`$${index + 1}`, value), message);
+}
+//# sourceMappingURL=fake-browser.js.map