antigravity-mobile-proxy 0.1.2 → 0.1.3

package/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Binding.js

@@ -1,162 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-/**
- * @license
- * Copyright 2024 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { JSHandle } from '../api/JSHandle.js';
-import { debugError } from '../common/util.js';
-import { DisposableStack } from '../util/disposable.js';
-import { isErrorLike } from '../util/ErrorLike.js';
-/**
- * @internal
- */
-export class Binding {
-    #name;
-    #fn;
-    #initSource;
-    constructor(name, fn, initSource) {
-        this.#name = name;
-        this.#fn = fn;
-        this.#initSource = initSource;
-    }
-    get name() {
-        return this.#name;
-    }
-    get initSource() {
-        return this.#initSource;
-    }
-    /**
-     * @param context - Context to run the binding in; the context should have
-     * the binding added to it beforehand.
-     * @param id - ID of the call. This should come from the CDP
-     * `onBindingCalled` response.
-     * @param args - Plain arguments from CDP.
-     */
-    async run(context, id, args, isTrivial) {
-        const stack = new DisposableStack();
-        try {
-            if (!isTrivial) {
-                const env_1 = { stack: [], error: void 0, hasError: false };
-                try {
-                    // Getting non-trivial arguments.
-                    const handles = __addDisposableResource(env_1, await context.evaluateHandle((name, seq) => {
-                        // @ts-expect-error Code is evaluated in a different context.
-                        return globalThis[name].args.get(seq);
-                    }, this.#name, id), false);
-                    const properties = await handles.getProperties();
-                    for (const [index, handle] of properties) {
-                        // This is not straight-forward since some arguments can stringify, but
-                        // aren't plain objects so add subtypes when the use-case arises.
-                        if (index in args) {
-                            switch (handle.remoteObject().subtype) {
-                                case 'node':
-                                    args[+index] = handle;
-                                    break;
-                                default:
-                                    stack.use(handle);
-                            }
-                        }
-                        else {
-                            stack.use(handle);
-                        }
-                    }
-                }
-                catch (e_1) {
-                    env_1.error = e_1;
-                    env_1.hasError = true;
-                }
-                finally {
-                    __disposeResources(env_1);
-                }
-            }
-            await context.evaluate((name, seq, result) => {
-                // @ts-expect-error Code is evaluated in a different context.
-                const callbacks = globalThis[name].callbacks;
-                callbacks.get(seq).resolve(result);
-                callbacks.delete(seq);
-            }, this.#name, id, await this.#fn(...args));
-            for (const arg of args) {
-                if (arg instanceof JSHandle) {
-                    stack.use(arg);
-                }
-            }
-        }
-        catch (error) {
-            if (isErrorLike(error)) {
-                await context
-                    .evaluate((name, seq, message, stack) => {
-                    const error = new Error(message);
-                    error.stack = stack;
-                    // @ts-expect-error Code is evaluated in a different context.
-                    const callbacks = globalThis[name].callbacks;
-                    callbacks.get(seq).reject(error);
-                    callbacks.delete(seq);
-                }, this.#name, id, error.message, error.stack)
-                    .catch(debugError);
-            }
-            else {
-                await context
-                    .evaluate((name, seq, error) => {
-                    // @ts-expect-error Code is evaluated in a different context.
-                    const callbacks = globalThis[name].callbacks;
-                    callbacks.get(seq).reject(error);
-                    callbacks.delete(seq);
-                }, this.#name, id, error)
-                    .catch(debugError);
-            }
-        }
-    }
-}
-//# sourceMappingURL=Binding.js.map

package/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/BluetoothEmulation.js

@@ -1,26 +0,0 @@
-/**
- * @internal
- */
-export class CdpBluetoothEmulation {
-    #connection;
-    constructor(connection) {
-        this.#connection = connection;
-    }
-    async emulateAdapter(state, leSupported = true) {
-        // Bluetooth spec requires overriding the existing adapter (step 6). From the CDP
-        // perspective, it means disabling the emulation first.
-        // https://webbluetoothcg.github.io/web-bluetooth/#bluetooth-simulateAdapter-command
-        await this.#connection.send('BluetoothEmulation.disable');
-        await this.#connection.send('BluetoothEmulation.enable', {
-            state,
-            leSupported,
-        });
-    }
-    async disableEmulation() {
-        await this.#connection.send('BluetoothEmulation.disable');
-    }
-    async simulatePreconnectedPeripheral(preconnectedPeripheral) {
-        await this.#connection.send('BluetoothEmulation.simulatePreconnectedPeripheral', preconnectedPeripheral);
-    }
-}
-//# sourceMappingURL=BluetoothEmulation.js.map

package/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Browser.js

@@ -1,327 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Browser as BrowserBase, } from '../api/Browser.js';
-import { CDPSessionEvent } from '../api/CDPSession.js';
-import { CdpBrowserContext } from './BrowserContext.js';
-import { DevToolsTarget, InitializationStatus, OtherTarget, PageTarget, WorkerTarget, } from './Target.js';
-import { TargetManager } from './TargetManager.js';
-/**
- * @internal
- */
-function isDevToolsPageTarget(url) {
-    return url.startsWith('devtools://devtools/bundled/devtools_app.html');
-}
-/**
- * @internal
- */
-export class CdpBrowser extends BrowserBase {
-    protocol = 'cdp';
-    static async _create(connection, contextIds, acceptInsecureCerts, defaultViewport, downloadBehavior, process, closeCallback, targetFilterCallback, isPageTargetCallback, waitForInitiallyDiscoveredTargets = true, networkEnabled = true, handleDevToolsAsPage = false) {
-        const browser = new CdpBrowser(connection, contextIds, defaultViewport, process, closeCallback, targetFilterCallback, isPageTargetCallback, waitForInitiallyDiscoveredTargets, networkEnabled, handleDevToolsAsPage);
-        if (acceptInsecureCerts) {
-            await connection.send('Security.setIgnoreCertificateErrors', {
-                ignore: true,
-            });
-        }
-        await browser._attach(downloadBehavior);
-        return browser;
-    }
-    #defaultViewport;
-    #process;
-    #connection;
-    #closeCallback;
-    #targetFilterCallback;
-    #isPageTargetCallback;
-    #defaultContext;
-    #contexts = new Map();
-    #networkEnabled = true;
-    #targetManager;
-    #handleDevToolsAsPage = false;
-    constructor(connection, contextIds, defaultViewport, process, closeCallback, targetFilterCallback, isPageTargetCallback, waitForInitiallyDiscoveredTargets = true, networkEnabled = true, handleDevToolsAsPage = false) {
-        super();
-        this.#networkEnabled = networkEnabled;
-        this.#defaultViewport = defaultViewport;
-        this.#process = process;
-        this.#connection = connection;
-        this.#closeCallback = closeCallback || (() => { });
-        this.#targetFilterCallback =
-            targetFilterCallback ||
-                (() => {
-                    return true;
-                });
-        this.#handleDevToolsAsPage = handleDevToolsAsPage;
-        this.#setIsPageTargetCallback(isPageTargetCallback);
-        this.#targetManager = new TargetManager(connection, this.#createTarget, this.#targetFilterCallback, waitForInitiallyDiscoveredTargets);
-        this.#defaultContext = new CdpBrowserContext(this.#connection, this);
-        for (const contextId of contextIds) {
-            this.#contexts.set(contextId, new CdpBrowserContext(this.#connection, this, contextId));
-        }
-    }
-    #emitDisconnected = () => {
-        this.emit("disconnected" /* BrowserEvent.Disconnected */, undefined);
-    };
-    async _attach(downloadBehavior) {
-        this.#connection.on(CDPSessionEvent.Disconnected, this.#emitDisconnected);
-        if (downloadBehavior) {
-            await this.#defaultContext.setDownloadBehavior(downloadBehavior);
-        }
-        this.#targetManager.on("targetAvailable" /* TargetManagerEvent.TargetAvailable */, this.#onAttachedToTarget);
-        this.#targetManager.on("targetGone" /* TargetManagerEvent.TargetGone */, this.#onDetachedFromTarget);
-        this.#targetManager.on("targetChanged" /* TargetManagerEvent.TargetChanged */, this.#onTargetChanged);
-        this.#targetManager.on("targetDiscovered" /* TargetManagerEvent.TargetDiscovered */, this.#onTargetDiscovered);
-        await this.#targetManager.initialize();
-    }
-    _detach() {
-        this.#connection.off(CDPSessionEvent.Disconnected, this.#emitDisconnected);
-        this.#targetManager.off("targetAvailable" /* TargetManagerEvent.TargetAvailable */, this.#onAttachedToTarget);
-        this.#targetManager.off("targetGone" /* TargetManagerEvent.TargetGone */, this.#onDetachedFromTarget);
-        this.#targetManager.off("targetChanged" /* TargetManagerEvent.TargetChanged */, this.#onTargetChanged);
-        this.#targetManager.off("targetDiscovered" /* TargetManagerEvent.TargetDiscovered */, this.#onTargetDiscovered);
-    }
-    process() {
-        return this.#process ?? null;
-    }
-    _targetManager() {
-        return this.#targetManager;
-    }
-    #setIsPageTargetCallback(isPageTargetCallback) {
-        this.#isPageTargetCallback =
-            isPageTargetCallback ||
-                ((target) => {
-                    return (target.type() === 'page' ||
-                        target.type() === 'background_page' ||
-                        target.type() === 'webview' ||
-                        (this.#handleDevToolsAsPage &&
-                            target.type() === 'other' &&
-                            isDevToolsPageTarget(target.url())));
-                });
-    }
-    _getIsPageTargetCallback() {
-        return this.#isPageTargetCallback;
-    }
-    async createBrowserContext(options = {}) {
-        const { proxyServer, proxyBypassList, downloadBehavior } = options;
-        const { browserContextId } = await this.#connection.send('Target.createBrowserContext', {
-            proxyServer,
-            proxyBypassList: proxyBypassList && proxyBypassList.join(','),
-        });
-        const context = new CdpBrowserContext(this.#connection, this, browserContextId);
-        if (downloadBehavior) {
-            await context.setDownloadBehavior(downloadBehavior);
-        }
-        this.#contexts.set(browserContextId, context);
-        return context;
-    }
-    browserContexts() {
-        return [this.#defaultContext, ...Array.from(this.#contexts.values())];
-    }
-    defaultBrowserContext() {
-        return this.#defaultContext;
-    }
-    async _disposeContext(contextId) {
-        if (!contextId) {
-            return;
-        }
-        await this.#connection.send('Target.disposeBrowserContext', {
-            browserContextId: contextId,
-        });
-        this.#contexts.delete(contextId);
-    }
-    #createTarget = (targetInfo, session) => {
-        const { browserContextId } = targetInfo;
-        const context = browserContextId && this.#contexts.has(browserContextId)
-            ? this.#contexts.get(browserContextId)
-            : this.#defaultContext;
-        if (!context) {
-            throw new Error('Missing browser context');
-        }
-        const createSession = (isAutoAttachEmulated) => {
-            return this.#connection._createSession(targetInfo, isAutoAttachEmulated);
-        };
-        const otherTarget = new OtherTarget(targetInfo, session, context, this.#targetManager, createSession);
-        if (targetInfo.url && isDevToolsPageTarget(targetInfo.url)) {
-            return new DevToolsTarget(targetInfo, session, context, this.#targetManager, createSession, this.#defaultViewport ?? null);
-        }
-        if (this.#isPageTargetCallback(otherTarget)) {
-            return new PageTarget(targetInfo, session, context, this.#targetManager, createSession, this.#defaultViewport ?? null);
-        }
-        if (targetInfo.type === 'service_worker' ||
-            targetInfo.type === 'shared_worker') {
-            return new WorkerTarget(targetInfo, session, context, this.#targetManager, createSession);
-        }
-        return otherTarget;
-    };
-    #onAttachedToTarget = async (target) => {
-        if (target._isTargetExposed() &&
-            (await target._initializedDeferred.valueOrThrow()) ===
-                InitializationStatus.SUCCESS) {
-            this.emit("targetcreated" /* BrowserEvent.TargetCreated */, target);
-            target.browserContext().emit("targetcreated" /* BrowserContextEvent.TargetCreated */, target);
-        }
-    };
-    #onDetachedFromTarget = async (target) => {
-        target._initializedDeferred.resolve(InitializationStatus.ABORTED);
-        target._isClosedDeferred.resolve();
-        if (target._isTargetExposed() &&
-            (await target._initializedDeferred.valueOrThrow()) ===
-                InitializationStatus.SUCCESS) {
-            this.emit("targetdestroyed" /* BrowserEvent.TargetDestroyed */, target);
-            target.browserContext().emit("targetdestroyed" /* BrowserContextEvent.TargetDestroyed */, target);
-        }
-    };
-    #onTargetChanged = ({ target }) => {
-        this.emit("targetchanged" /* BrowserEvent.TargetChanged */, target);
-        target.browserContext().emit("targetchanged" /* BrowserContextEvent.TargetChanged */, target);
-    };
-    #onTargetDiscovered = (targetInfo) => {
-        this.emit("targetdiscovered" /* BrowserEvent.TargetDiscovered */, targetInfo);
-    };
-    wsEndpoint() {
-        return this.#connection.url();
-    }
-    async newPage(options) {
-        return await this.#defaultContext.newPage(options);
-    }
-    async _createPageInContext(contextId, options) {
-        const hasTargets = this.targets().filter(t => {
-            return t.browserContext().id === contextId;
-        }).length > 0;
-        const windowBounds = options?.type === 'window' ? options.windowBounds : undefined;
-        const { targetId } = await this.#connection.send('Target.createTarget', {
-            url: 'about:blank',
-            browserContextId: contextId || undefined,
-            left: windowBounds?.left,
-            top: windowBounds?.top,
-            width: windowBounds?.width,
-            height: windowBounds?.height,
-            windowState: windowBounds?.windowState,
-            // Works around crbug.com/454825274.
-            newWindow: hasTargets && options?.type === 'window' ? true : undefined,
-            background: options?.background,
-        });
-        const target = (await this.waitForTarget(t => {
-            return t._targetId === targetId;
-        }));
-        if (!target) {
-            throw new Error(`Missing target for page (id = ${targetId})`);
-        }
-        const initialized = (await target._initializedDeferred.valueOrThrow()) ===
-            InitializationStatus.SUCCESS;
-        if (!initialized) {
-            throw new Error(`Failed to create target for page (id = ${targetId})`);
-        }
-        const page = await target.page();
-        if (!page) {
-            throw new Error(`Failed to create a page for context (id = ${contextId})`);
-        }
-        return page;
-    }
-    async _createDevToolsPage(pageTargetId) {
-        const openDevToolsResponse = await this.#connection.send('Target.openDevTools', {
-            targetId: pageTargetId,
-        });
-        const target = (await this.waitForTarget(t => {
-            return t._targetId === openDevToolsResponse.targetId;
-        }));
-        if (!target) {
-            throw new Error(`Missing target for DevTools page (id = ${pageTargetId})`);
-        }
-        const initialized = (await target._initializedDeferred.valueOrThrow()) ===
-            InitializationStatus.SUCCESS;
-        if (!initialized) {
-            throw new Error(`Failed to create target for DevTools page (id = ${pageTargetId})`);
-        }
-        const page = await target.page();
-        if (!page) {
-            throw new Error(`Failed to create a DevTools Page for target (id = ${pageTargetId})`);
-        }
-        return page;
-    }
-    async _hasDevToolsTarget(pageTargetId) {
-        const response = await this.#connection.send('Target.getDevToolsTarget', {
-            targetId: pageTargetId,
-        });
-        return response.targetId;
-    }
-    async installExtension(path) {
-        const { id } = await this.#connection.send('Extensions.loadUnpacked', { path });
-        return id;
-    }
-    uninstallExtension(id) {
-        return this.#connection.send('Extensions.uninstall', { id });
-    }
-    async screens() {
-        const { screenInfos } = await this.#connection.send('Emulation.getScreenInfos');
-        return screenInfos;
-    }
-    async addScreen(params) {
-        const { screenInfo } = await this.#connection.send('Emulation.addScreen', params);
-        return screenInfo;
-    }
-    async removeScreen(screenId) {
-        return await this.#connection.send('Emulation.removeScreen', { screenId });
-    }
-    async getWindowBounds(windowId) {
-        const { bounds } = await this.#connection.send('Browser.getWindowBounds', {
-            windowId: Number(windowId),
-        });
-        return bounds;
-    }
-    async setWindowBounds(windowId, windowBounds) {
-        await this.#connection.send('Browser.setWindowBounds', {
-            windowId: Number(windowId),
-            bounds: windowBounds,
-        });
-    }
-    targets() {
-        return Array.from(this.#targetManager.getAvailableTargets().values()).filter(target => {
-            return (target._isTargetExposed() &&
-                target._initializedDeferred.value() === InitializationStatus.SUCCESS);
-        });
-    }
-    target() {
-        const browserTarget = this.targets().find(target => {
-            return target.type() === 'browser';
-        });
-        if (!browserTarget) {
-            throw new Error('Browser target is not found');
-        }
-        return browserTarget;
-    }
-    async version() {
-        const version = await this.#getVersion();
-        return version.product;
-    }
-    async userAgent() {
-        const version = await this.#getVersion();
-        return version.userAgent;
-    }
-    async close() {
-        await this.#closeCallback.call(null);
-        await this.disconnect();
-    }
-    disconnect() {
-        this.#targetManager.dispose();
-        this.#connection.dispose();
-        this._detach();
-        return Promise.resolve();
-    }
-    get connected() {
-        return !this.#connection._closed;
-    }
-    #getVersion() {
-        return this.#connection.send('Browser.getVersion');
-    }
-    get debugInfo() {
-        return {
-            pendingProtocolErrors: this.#connection.getPendingProtocolErrors(),
-        };
-    }
-    isNetworkEnabled() {
-        return this.#networkEnabled;
-    }
-}
-//# sourceMappingURL=Browser.js.map

package/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/BrowserConnector.js

@@ -1,26 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { debugError, DEFAULT_VIEWPORT } from '../common/util.js';
-import { createIncrementalIdGenerator } from '../util/incremental-id-generator.js';
-import { CdpBrowser } from './Browser.js';
-import { Connection } from './Connection.js';
-/**
- * Users should never call this directly; it's called when calling
- * `puppeteer.connect` with `protocol: 'cdp'`.
- *
- * @internal
- */
-export async function _connectToCdpBrowser(connectionTransport, url, options) {
-    const { acceptInsecureCerts = false, networkEnabled = true, defaultViewport = DEFAULT_VIEWPORT, downloadBehavior, targetFilter, _isPageTarget: isPageTarget, slowMo = 0, protocolTimeout, handleDevToolsAsPage, idGenerator = createIncrementalIdGenerator(), } = options;
-    const connection = new Connection(url, connectionTransport, slowMo, protocolTimeout, 
-    /* rawErrors */ false, idGenerator);
-    const { browserContextIds } = await connection.send('Target.getBrowserContexts');
-    const browser = await CdpBrowser._create(connection, browserContextIds, acceptInsecureCerts, defaultViewport, downloadBehavior, undefined, () => {
-        return connection.send('Browser.close').catch(debugError);
-    }, targetFilter, isPageTarget, undefined, networkEnabled, handleDevToolsAsPage);
-    return browser;
-}
-//# sourceMappingURL=BrowserConnector.js.map