antigravity-mobile-proxy 0.1.2 → 0.1.3

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

@@ -1,69 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * A list of pre-defined network conditions to be used with
- * {@link Page.emulateNetworkConditions}.
- *
- * @example
- *
- * ```ts
- * import {PredefinedNetworkConditions} from 'puppeteer';
- * const browser = await puppeteer.launch();
- * const page = await browser.newPage();
- * await page.emulateNetworkConditions(PredefinedNetworkConditions['Slow 3G']);
- * await page.goto('https://www.google.com');
- * await page.emulateNetworkConditions(PredefinedNetworkConditions['Fast 3G']);
- * await page.goto('https://www.google.com');
- * // alias to Fast 3G.
- * await page.emulateNetworkConditions(PredefinedNetworkConditions['Slow 4G']);
- * await page.goto('https://www.google.com');
- * await page.emulateNetworkConditions(PredefinedNetworkConditions['Fast 4G']);
- * await page.goto('https://www.google.com');
- * // other actions...
- * await browser.close();
- * ```
- *
- * @public
- */
-export const PredefinedNetworkConditions = Object.freeze({
-    // Generally aligned with DevTools
-    // https://source.chromium.org/chromium/chromium/src/+/main:third_party/devtools-frontend/src/front_end/core/sdk/NetworkManager.ts;l=398;drc=225e1240f522ca684473f541ae6dae6cd766dd33.
-    'Slow 3G': {
-        // ~500Kbps down
-        download: ((500 * 1000) / 8) * 0.8,
-        // ~500Kbps up
-        upload: ((500 * 1000) / 8) * 0.8,
-        // 400ms RTT
-        latency: 400 * 5,
-    },
-    'Fast 3G': {
-        // ~1.6 Mbps down
-        download: ((1.6 * 1000 * 1000) / 8) * 0.9,
-        // ~0.75 Mbps up
-        upload: ((750 * 1000) / 8) * 0.9,
-        // 150ms RTT
-        latency: 150 * 3.75,
-    },
-    // alias to Fast 3G to align with Lighthouse (crbug.com/342406608)
-    // and DevTools (crbug.com/342406608),
-    'Slow 4G': {
-        // ~1.6 Mbps down
-        download: ((1.6 * 1000 * 1000) / 8) * 0.9,
-        // ~0.75 Mbps up
-        upload: ((750 * 1000) / 8) * 0.9,
-        // 150ms RTT
-        latency: 150 * 3.75,
-    },
-    'Fast 4G': {
-        // 9 Mbps down
-        download: ((9 * 1000 * 1000) / 8) * 0.9,
-        // 1.5 Mbps up
-        upload: ((1.5 * 1000 * 1000) / 8) * 0.9,
-        // 60ms RTT
-        latency: 60 * 2.75,
-    },
-});
-//# sourceMappingURL=PredefinedNetworkConditions.js.map

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

@@ -1,243 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Target, TargetType } from '../api/Target.js';
-import { debugError } from '../common/util.js';
-import { Deferred } from '../util/Deferred.js';
-import { CdpPage } from './Page.js';
-import { CdpWebWorker } from './WebWorker.js';
-/**
- * @internal
- */
-export var InitializationStatus;
-(function (InitializationStatus) {
-    InitializationStatus["SUCCESS"] = "success";
-    InitializationStatus["ABORTED"] = "aborted";
-})(InitializationStatus || (InitializationStatus = {}));
-/**
- * @internal
- */
-export class CdpTarget extends Target {
-    #browserContext;
-    #session;
-    #targetInfo;
-    #targetManager;
-    #sessionFactory;
-    #childTargets = new Set();
-    _initializedDeferred = Deferred.create();
-    _isClosedDeferred = Deferred.create();
-    _targetId;
-    /**
-     * To initialize the target for use, call initialize.
-     *
-     * @internal
-     */
-    constructor(targetInfo, session, browserContext, targetManager, sessionFactory) {
-        super();
-        this.#session = session;
-        this.#targetManager = targetManager;
-        this.#targetInfo = targetInfo;
-        this.#browserContext = browserContext;
-        this._targetId = targetInfo.targetId;
-        this.#sessionFactory = sessionFactory;
-        if (this.#session) {
-            this.#session.setTarget(this);
-        }
-    }
-    async asPage() {
-        const session = this._session();
-        if (!session) {
-            return await this.createCDPSession().then(client => {
-                return CdpPage._create(client, this, null);
-            });
-        }
-        return await CdpPage._create(session, this, null);
-    }
-    _subtype() {
-        return this.#targetInfo.subtype;
-    }
-    _session() {
-        return this.#session;
-    }
-    _addChildTarget(target) {
-        this.#childTargets.add(target);
-    }
-    _removeChildTarget(target) {
-        this.#childTargets.delete(target);
-    }
-    _childTargets() {
-        return this.#childTargets;
-    }
-    _sessionFactory() {
-        if (!this.#sessionFactory) {
-            throw new Error('sessionFactory is not initialized');
-        }
-        return this.#sessionFactory;
-    }
-    createCDPSession() {
-        if (!this.#sessionFactory) {
-            throw new Error('sessionFactory is not initialized');
-        }
-        return this.#sessionFactory(false).then(session => {
-            session.setTarget(this);
-            return session;
-        });
-    }
-    url() {
-        return this.#targetInfo.url;
-    }
-    type() {
-        const type = this.#targetInfo.type;
-        switch (type) {
-            case 'page':
-                return TargetType.PAGE;
-            case 'background_page':
-                return TargetType.BACKGROUND_PAGE;
-            case 'service_worker':
-                return TargetType.SERVICE_WORKER;
-            case 'shared_worker':
-                return TargetType.SHARED_WORKER;
-            case 'browser':
-                return TargetType.BROWSER;
-            case 'webview':
-                return TargetType.WEBVIEW;
-            case 'tab':
-                return TargetType.TAB;
-            default:
-                return TargetType.OTHER;
-        }
-    }
-    _targetManager() {
-        if (!this.#targetManager) {
-            throw new Error('targetManager is not initialized');
-        }
-        return this.#targetManager;
-    }
-    _getTargetInfo() {
-        return this.#targetInfo;
-    }
-    browser() {
-        if (!this.#browserContext) {
-            throw new Error('browserContext is not initialized');
-        }
-        return this.#browserContext.browser();
-    }
-    browserContext() {
-        if (!this.#browserContext) {
-            throw new Error('browserContext is not initialized');
-        }
-        return this.#browserContext;
-    }
-    opener() {
-        const { openerId } = this.#targetInfo;
-        if (!openerId) {
-            return;
-        }
-        return this.browser()
-            .targets()
-            .find(target => {
-            return target._targetId === openerId;
-        });
-    }
-    _targetInfoChanged(targetInfo) {
-        this.#targetInfo = targetInfo;
-        this._checkIfInitialized();
-    }
-    _initialize() {
-        this._initializedDeferred.resolve(InitializationStatus.SUCCESS);
-    }
-    _isTargetExposed() {
-        return this.type() !== TargetType.TAB && !this._subtype();
-    }
-    _checkIfInitialized() {
-        if (!this._initializedDeferred.resolved()) {
-            this._initializedDeferred.resolve(InitializationStatus.SUCCESS);
-        }
-    }
-}
-/**
- * @internal
- */
-export class PageTarget extends CdpTarget {
-    #defaultViewport;
-    pagePromise;
-    constructor(targetInfo, session, browserContext, targetManager, sessionFactory, defaultViewport) {
-        super(targetInfo, session, browserContext, targetManager, sessionFactory);
-        this.#defaultViewport = defaultViewport ?? undefined;
-    }
-    _initialize() {
-        this._initializedDeferred
-            .valueOrThrow()
-            .then(async (result) => {
-            if (result === InitializationStatus.ABORTED) {
-                return;
-            }
-            const opener = this.opener();
-            if (!(opener instanceof PageTarget)) {
-                return;
-            }
-            if (!opener || !opener.pagePromise || this.type() !== 'page') {
-                return true;
-            }
-            const openerPage = await opener.pagePromise;
-            if (!openerPage.listenerCount("popup" /* PageEvent.Popup */)) {
-                return true;
-            }
-            const popupPage = await this.page();
-            openerPage.emit("popup" /* PageEvent.Popup */, popupPage);
-            return true;
-        })
-            .catch(debugError);
-        this._checkIfInitialized();
-    }
-    async page() {
-        if (!this.pagePromise) {
-            const session = this._session();
-            this.pagePromise = (session
-                ? Promise.resolve(session)
-                : this._sessionFactory()(/* isAutoAttachEmulated=*/ false)).then(client => {
-                return CdpPage._create(client, this, this.#defaultViewport ?? null);
-            });
-        }
-        return (await this.pagePromise) ?? null;
-    }
-    _checkIfInitialized() {
-        if (this._initializedDeferred.resolved()) {
-            return;
-        }
-        if (this._getTargetInfo().url !== '') {
-            this._initializedDeferred.resolve(InitializationStatus.SUCCESS);
-        }
-    }
-}
-/**
- * @internal
- */
-export class DevToolsTarget extends PageTarget {
-}
-/**
- * @internal
- */
-export class WorkerTarget extends CdpTarget {
-    #workerPromise;
-    async worker() {
-        if (!this.#workerPromise) {
-            const session = this._session();
-            // TODO(einbinder): Make workers send their console logs.
-            this.#workerPromise = (session
-                ? Promise.resolve(session)
-                : this._sessionFactory()(/* isAutoAttachEmulated=*/ false)).then(client => {
-                return new CdpWebWorker(client, this._getTargetInfo().url, this._targetId, this.type(), () => { } /* consoleAPICalled */, () => { } /* exceptionThrown */, undefined /* networkManager */);
-            });
-        }
-        return await this.#workerPromise;
-    }
-}
-/**
- * @internal
- */
-export class OtherTarget extends CdpTarget {
-}
-//# sourceMappingURL=Target.js.map

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

@@ -1,7 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-export {};
-//# sourceMappingURL=TargetManageEvents.js.map

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

@@ -1,320 +0,0 @@
-/**
- * @license
- * Copyright 2022 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { CDPSessionEvent } from '../api/CDPSession.js';
-import { EventEmitter } from '../common/EventEmitter.js';
-import { debugError } from '../common/util.js';
-import { assert } from '../util/assert.js';
-import { Deferred } from '../util/Deferred.js';
-import { CdpCDPSession } from './CdpSession.js';
-import { InitializationStatus } from './Target.js';
-function isPageTargetBecomingPrimary(target, newTargetInfo) {
-    return Boolean(target._subtype()) && !newTargetInfo.subtype;
-}
-/**
- * TargetManager encapsulates all interactions with CDP targets and is
- * responsible for coordinating the configuration of targets with the rest of
- * Puppeteer. Code outside of this class should not subscribe `Target.*` events
- * and only use the TargetManager events.
- *
- * TargetManager uses the CDP's auto-attach mechanism to intercept
- * new targets and allow the rest of Puppeteer to configure listeners while
- * the target is paused.
- *
- * @internal
- */
-export class TargetManager extends EventEmitter {
-    #connection;
-    /**
-     * Keeps track of the following events: 'Target.targetCreated',
-     * 'Target.targetDestroyed', 'Target.targetInfoChanged'.
-     *
-     * A target becomes discovered when 'Target.targetCreated' is received.
-     * A target is removed from this map once 'Target.targetDestroyed' is
-     * received.
-     *
-     * `targetFilterCallback` has no effect on this map.
-     */
-    #discoveredTargetsByTargetId = new Map();
-    /**
-     * A target is added to this map once TargetManager has created
-     * a Target and attached at least once to it.
-     */
-    #attachedTargetsByTargetId = new Map();
-    /**
-     * Tracks which sessions attach to which target.
-     */
-    #attachedTargetsBySessionId = new Map();
-    /**
-     * If a target was filtered out by `targetFilterCallback`, we still receive
-     * events about it from CDP, but we don't forward them to the rest of Puppeteer.
-     */
-    #ignoredTargets = new Set();
-    #targetFilterCallback;
-    #targetFactory;
-    #attachedToTargetListenersBySession = new WeakMap();
-    #detachedFromTargetListenersBySession = new WeakMap();
-    #initializeDeferred = Deferred.create();
-    #waitForInitiallyDiscoveredTargets = true;
-    #discoveryFilter = [{}];
-    // IDs of tab targets detected while running the initial Target.setAutoAttach
-    // request. These are the targets whose initialization we want to await for
-    // before resolving puppeteer.connect() or launch() to avoid flakiness.
-    // Whenever a sub-target whose parent is a tab target is attached, we remove
-    // the tab target from this list. Once the list is empty, we resolve the
-    // initializeDeferred.
-    #targetsIdsForInit = new Set();
-    // This is false until the connection-level Target.setAutoAttach request is
-    // done. It indicates whethere we are running the initial auto-attach step or
-    // if we are handling targets after that.
-    #initialAttachDone = false;
-    constructor(connection, targetFactory, targetFilterCallback, waitForInitiallyDiscoveredTargets = true) {
-        super();
-        this.#connection = connection;
-        this.#targetFilterCallback = targetFilterCallback;
-        this.#targetFactory = targetFactory;
-        this.#waitForInitiallyDiscoveredTargets = waitForInitiallyDiscoveredTargets;
-        this.#connection.on('Target.targetCreated', this.#onTargetCreated);
-        this.#connection.on('Target.targetDestroyed', this.#onTargetDestroyed);
-        this.#connection.on('Target.targetInfoChanged', this.#onTargetInfoChanged);
-        this.#connection.on(CDPSessionEvent.SessionDetached, this.#onSessionDetached);
-        this.#setupAttachmentListeners(this.#connection);
-    }
-    async initialize() {
-        await this.#connection.send('Target.setDiscoverTargets', {
-            discover: true,
-            filter: this.#discoveryFilter,
-        });
-        await this.#connection.send('Target.setAutoAttach', {
-            waitForDebuggerOnStart: true,
-            flatten: true,
-            autoAttach: true,
-            filter: [
-                {
-                    type: 'page',
-                    exclude: true,
-                },
-                ...this.#discoveryFilter,
-            ],
-        });
-        this.#initialAttachDone = true;
-        this.#finishInitializationIfReady();
-        await this.#initializeDeferred.valueOrThrow();
-    }
-    getChildTargets(target) {
-        return target._childTargets();
-    }
-    dispose() {
-        this.#connection.off('Target.targetCreated', this.#onTargetCreated);
-        this.#connection.off('Target.targetDestroyed', this.#onTargetDestroyed);
-        this.#connection.off('Target.targetInfoChanged', this.#onTargetInfoChanged);
-        this.#connection.off(CDPSessionEvent.SessionDetached, this.#onSessionDetached);
-        this.#removeAttachmentListeners(this.#connection);
-    }
-    getAvailableTargets() {
-        return this.#attachedTargetsByTargetId;
-    }
-    #setupAttachmentListeners(session) {
-        const listener = (event) => {
-            void this.#onAttachedToTarget(session, event);
-        };
-        assert(!this.#attachedToTargetListenersBySession.has(session));
-        this.#attachedToTargetListenersBySession.set(session, listener);
-        session.on('Target.attachedToTarget', listener);
-        const detachedListener = (event) => {
-            return this.#onDetachedFromTarget(session, event);
-        };
-        assert(!this.#detachedFromTargetListenersBySession.has(session));
-        this.#detachedFromTargetListenersBySession.set(session, detachedListener);
-        session.on('Target.detachedFromTarget', detachedListener);
-    }
-    #removeAttachmentListeners(session) {
-        const listener = this.#attachedToTargetListenersBySession.get(session);
-        if (listener) {
-            session.off('Target.attachedToTarget', listener);
-            this.#attachedToTargetListenersBySession.delete(session);
-        }
-        const detachedListener = this.#detachedFromTargetListenersBySession.get(session);
-        if (detachedListener) {
-            session.off('Target.detachedFromTarget', detachedListener);
-            this.#detachedFromTargetListenersBySession.delete(session);
-        }
-    }
-    #silentDetach = async (session, parentSession) => {
-        await session.send('Runtime.runIfWaitingForDebugger').catch(debugError);
-        // We don't use `session.detach()` because that dispatches all commands on
-        // the connection instead of the parent session.
-        await parentSession
-            .send('Target.detachFromTarget', {
-            sessionId: session.id(),
-        })
-            .catch(debugError);
-    };
-    #getParentTarget = (parentSession) => {
-        return parentSession instanceof CdpCDPSession
-            ? parentSession.target()
-            : null;
-    };
-    #onSessionDetached = (session) => {
-        this.#removeAttachmentListeners(session);
-    };
-    #onTargetCreated = async (event) => {
-        this.#discoveredTargetsByTargetId.set(event.targetInfo.targetId, event.targetInfo);
-        this.emit("targetDiscovered" /* TargetManagerEvent.TargetDiscovered */, event.targetInfo);
-        // The connection is already attached to the browser target implicitly,
-        // therefore, no new CDPSession is created and we have special handling
-        // here.
-        if (event.targetInfo.type === 'browser' && event.targetInfo.attached) {
-            if (this.#attachedTargetsByTargetId.has(event.targetInfo.targetId)) {
-                return;
-            }
-            const target = this.#targetFactory(event.targetInfo, undefined);
-            target._initialize();
-            this.#attachedTargetsByTargetId.set(event.targetInfo.targetId, target);
-        }
-    };
-    #onTargetDestroyed = (event) => {
-        const targetInfo = this.#discoveredTargetsByTargetId.get(event.targetId);
-        this.#discoveredTargetsByTargetId.delete(event.targetId);
-        this.#finishInitializationIfReady(event.targetId);
-        if (targetInfo?.type === 'service_worker') {
-            // Special case for service workers: report TargetGone event when
-            // the worker is destroyed.
-            const target = this.#attachedTargetsByTargetId.get(event.targetId);
-            if (target) {
-                this.emit("targetGone" /* TargetManagerEvent.TargetGone */, target);
-                this.#attachedTargetsByTargetId.delete(event.targetId);
-            }
-        }
-    };
-    #onTargetInfoChanged = (event) => {
-        this.#discoveredTargetsByTargetId.set(event.targetInfo.targetId, event.targetInfo);
-        if (this.#ignoredTargets.has(event.targetInfo.targetId) ||
-            !event.targetInfo.attached) {
-            return;
-        }
-        const target = this.#attachedTargetsByTargetId.get(event.targetInfo.targetId);
-        if (!target) {
-            return;
-        }
-        const previousURL = target.url();
-        const wasInitialized = target._initializedDeferred.value() === InitializationStatus.SUCCESS;
-        if (isPageTargetBecomingPrimary(target, event.targetInfo)) {
-            const session = target._session();
-            assert(session, 'Target that is being activated is missing a CDPSession.');
-            session.parentSession()?.emit(CDPSessionEvent.Swapped, session);
-        }
-        target._targetInfoChanged(event.targetInfo);
-        if (wasInitialized && previousURL !== target.url()) {
-            this.emit("targetChanged" /* TargetManagerEvent.TargetChanged */, {
-                target,
-                wasInitialized,
-                previousURL,
-            });
-        }
-    };
-    #onAttachedToTarget = async (parentSession, event) => {
-        const targetInfo = event.targetInfo;
-        const session = this.#connection._session(event.sessionId);
-        if (!session) {
-            throw new Error(`Session ${event.sessionId} was not created.`);
-        }
-        if (!this.#connection.isAutoAttached(targetInfo.targetId)) {
-            return;
-        }
-        // Special case for service workers: being attached to service workers will
-        // prevent them from ever being destroyed. Therefore, we silently detach
-        // from service workers unless the connection was manually created via
-        // `page.worker()`. To determine this, we use
-        // `this.#connection.isAutoAttached(targetInfo.targetId)`. In the future, we
-        // should determine if a target is auto-attached or not with the help of
-        // CDP.
-        if (targetInfo.type === 'service_worker') {
-            await this.#silentDetach(session, parentSession);
-            if (this.#attachedTargetsByTargetId.has(targetInfo.targetId)) {
-                return;
-            }
-            const target = this.#targetFactory(targetInfo);
-            target._initialize();
-            this.#attachedTargetsByTargetId.set(targetInfo.targetId, target);
-            this.emit("targetAvailable" /* TargetManagerEvent.TargetAvailable */, target);
-            return;
-        }
-        let target = this.#attachedTargetsByTargetId.get(targetInfo.targetId);
-        const isExistingTarget = target !== undefined;
-        if (!target) {
-            target = this.#targetFactory(targetInfo, session, parentSession instanceof CdpCDPSession ? parentSession : undefined);
-        }
-        const parentTarget = this.#getParentTarget(parentSession);
-        if (this.#targetFilterCallback && !this.#targetFilterCallback(target)) {
-            this.#ignoredTargets.add(targetInfo.targetId);
-            if (parentTarget?.type() === 'tab') {
-                this.#finishInitializationIfReady(parentTarget._targetId);
-            }
-            await this.#silentDetach(session, parentSession);
-            return;
-        }
-        if (this.#waitForInitiallyDiscoveredTargets &&
-            event.targetInfo.type === 'tab' &&
-            !this.#initialAttachDone) {
-            this.#targetsIdsForInit.add(event.targetInfo.targetId);
-        }
-        this.#setupAttachmentListeners(session);
-        if (isExistingTarget) {
-            session.setTarget(target);
-            this.#attachedTargetsBySessionId.set(session.id(), target);
-        }
-        else {
-            target._initialize();
-            this.#attachedTargetsByTargetId.set(targetInfo.targetId, target);
-            this.#attachedTargetsBySessionId.set(session.id(), target);
-        }
-        parentTarget?._addChildTarget(target);
-        parentSession.emit(CDPSessionEvent.Ready, session);
-        if (!isExistingTarget) {
-            this.emit("targetAvailable" /* TargetManagerEvent.TargetAvailable */, target);
-        }
-        if (parentTarget?.type() === 'tab') {
-            this.#finishInitializationIfReady(parentTarget._targetId);
-        }
-        // TODO: the browser might be shutting down here. What do we do with the
-        // error?
-        await Promise.all([
-            session.send('Target.setAutoAttach', {
-                waitForDebuggerOnStart: true,
-                flatten: true,
-                autoAttach: true,
-                filter: this.#discoveryFilter,
-            }),
-            session.send('Runtime.runIfWaitingForDebugger'),
-        ]).catch(debugError);
-    };
-    #finishInitializationIfReady(targetId) {
-        if (targetId !== undefined) {
-            this.#targetsIdsForInit.delete(targetId);
-        }
-        // If we are still initializing it might be that we have not learned about
-        // some targets yet.
-        if (!this.#initialAttachDone) {
-            return;
-        }
-        if (this.#targetsIdsForInit.size === 0) {
-            this.#initializeDeferred.resolve();
-        }
-    }
-    #onDetachedFromTarget = (parentSession, event) => {
-        const target = this.#attachedTargetsBySessionId.get(event.sessionId);
-        this.#attachedTargetsBySessionId.delete(event.sessionId);
-        if (!target) {
-            return;
-        }
-        if (parentSession instanceof CdpCDPSession) {
-            parentSession.target()._removeChildTarget(target);
-        }
-        this.#attachedTargetsByTargetId.delete(target._targetId);
-        this.emit("targetGone" /* TargetManagerEvent.TargetGone */, target);
-    };
-}
-//# sourceMappingURL=TargetManager.js.map