antigravity-mobile-proxy 0.1.2 → 0.1.4

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

@@ -1,192 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google Inc.
- * SPDX-License-Identifier: Apache-2.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;
-});
-import { WEB_PERMISSION_TO_PROTOCOL_PERMISSION, } from '../api/Browser.js';
-import { BrowserContext } from '../api/BrowserContext.js';
-import { assert } from '../util/assert.js';
-import { convertCookiesPartitionKeyFromPuppeteerToCdp, convertSameSiteFromPuppeteerToCdp, } from './Page.js';
-/**
- * @internal
- */
-export class CdpBrowserContext extends BrowserContext {
-    #connection;
-    #browser;
-    #id;
-    constructor(connection, browser, contextId) {
-        super();
-        this.#connection = connection;
-        this.#browser = browser;
-        this.#id = contextId;
-    }
-    get id() {
-        return this.#id;
-    }
-    targets() {
-        return this.#browser.targets().filter(target => {
-            return target.browserContext() === this;
-        });
-    }
-    async pages(includeAll = false) {
-        const pages = await Promise.all(this.targets()
-            .filter(target => {
-            return (target.type() === 'page' ||
-                ((target.type() === 'other' || includeAll) &&
-                    this.#browser._getIsPageTargetCallback()?.(target)));
-        })
-            .map(target => {
-            return target.page();
-        }));
-        return pages.filter((page) => {
-            return !!page;
-        });
-    }
-    async overridePermissions(origin, permissions) {
-        const protocolPermissions = permissions.map(permission => {
-            const protocolPermission = WEB_PERMISSION_TO_PROTOCOL_PERMISSION.get(permission);
-            if (!protocolPermission) {
-                throw new Error('Unknown permission: ' + permission);
-            }
-            return protocolPermission;
-        });
-        await this.#connection.send('Browser.grantPermissions', {
-            origin,
-            browserContextId: this.#id || undefined,
-            permissions: protocolPermissions,
-        });
-    }
-    async setPermission(origin, ...permissions) {
-        await Promise.all(permissions.map(async (permission) => {
-            const protocolPermission = {
-                name: permission.permission.name,
-                userVisibleOnly: permission.permission.userVisibleOnly,
-                sysex: permission.permission.sysex,
-                allowWithoutSanitization: permission.permission.allowWithoutSanitization,
-                panTiltZoom: permission.permission.panTiltZoom,
-            };
-            await this.#connection.send('Browser.setPermission', {
-                origin: origin === '*' ? undefined : origin,
-                browserContextId: this.#id || undefined,
-                permission: protocolPermission,
-                setting: permission.state,
-            });
-        }));
-    }
-    async clearPermissionOverrides() {
-        await this.#connection.send('Browser.resetPermissions', {
-            browserContextId: this.#id || undefined,
-        });
-    }
-    async newPage(options) {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _guard = __addDisposableResource(env_1, await this.waitForScreenshotOperations(), false);
-            return await this.#browser._createPageInContext(this.#id, options);
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
-        }
-    }
-    browser() {
-        return this.#browser;
-    }
-    async close() {
-        assert(this.#id, 'Default BrowserContext cannot be closed!');
-        await this.#browser._disposeContext(this.#id);
-    }
-    async cookies() {
-        const { cookies } = await this.#connection.send('Storage.getCookies', {
-            browserContextId: this.#id,
-        });
-        return cookies.map(cookie => {
-            return {
-                ...cookie,
-                partitionKey: cookie.partitionKey
-                    ? {
-                        sourceOrigin: cookie.partitionKey.topLevelSite,
-                        hasCrossSiteAncestor: cookie.partitionKey.hasCrossSiteAncestor,
-                    }
-                    : undefined,
-                // TODO: remove sameParty as it is removed from Chrome.
-                sameParty: false,
-            };
-        });
-    }
-    async setCookie(...cookies) {
-        return await this.#connection.send('Storage.setCookies', {
-            browserContextId: this.#id,
-            cookies: cookies.map(cookie => {
-                return {
-                    ...cookie,
-                    partitionKey: convertCookiesPartitionKeyFromPuppeteerToCdp(cookie.partitionKey),
-                    sameSite: convertSameSiteFromPuppeteerToCdp(cookie.sameSite),
-                };
-            }),
-        });
-    }
-    async setDownloadBehavior(downloadBehavior) {
-        await this.#connection.send('Browser.setDownloadBehavior', {
-            behavior: downloadBehavior.policy,
-            downloadPath: downloadBehavior.downloadPath,
-            browserContextId: this.#id,
-        });
-    }
-}
-//# sourceMappingURL=BrowserContext.js.map

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

@@ -1,39 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * @internal
- */
-export class CdpPreloadScript {
-    /**
-     * This is the ID of the preload script returned by
-     * Page.addScriptToEvaluateOnNewDocument in the main frame.
-     *
-     * Sub-frames would get a different CDP ID because
-     * addScriptToEvaluateOnNewDocument is called for each subframe. But
-     * users only see this ID and subframe IDs are internal to Puppeteer.
-     */
-    #id;
-    #source;
-    #frameToId = new WeakMap();
-    constructor(mainFrame, id, source) {
-        this.#id = id;
-        this.#source = source;
-        this.#frameToId.set(mainFrame, id);
-    }
-    get id() {
-        return this.#id;
-    }
-    get source() {
-        return this.#source;
-    }
-    getIdForFrame(frame) {
-        return this.#frameToId.get(frame);
-    }
-    setIdForFrame(frame, identifier) {
-        this.#frameToId.set(frame, identifier);
-    }
-}
-//# sourceMappingURL=CdpPreloadScript.js.map

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

@@ -1,129 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { CDPSession, CDPSessionEvent, } from '../api/CDPSession.js';
-import { CallbackRegistry } from '../common/CallbackRegistry.js';
-import { TargetCloseError } from '../common/Errors.js';
-import { assert } from '../util/assert.js';
-import { createProtocolErrorMessage } from '../util/ErrorLike.js';
-/**
- * @internal
- */
-export class CdpCDPSession extends CDPSession {
-    #sessionId;
-    #targetType;
-    #callbacks;
-    #connection;
-    #parentSessionId;
-    #target;
-    #rawErrors = false;
-    #detached = false;
-    /**
-     * @internal
-     */
-    constructor(connection, targetType, sessionId, parentSessionId, rawErrors) {
-        super();
-        this.#connection = connection;
-        this.#targetType = targetType;
-        this.#callbacks = new CallbackRegistry(connection._idGenerator);
-        this.#sessionId = sessionId;
-        this.#parentSessionId = parentSessionId;
-        this.#rawErrors = rawErrors;
-    }
-    /**
-     * Sets the {@link CdpTarget} associated with the session instance.
-     *
-     * @internal
-     */
-    setTarget(target) {
-        this.#target = target;
-    }
-    /**
-     * Gets the {@link CdpTarget} associated with the session instance.
-     *
-     * @internal
-     */
-    target() {
-        assert(this.#target, 'Target must exist');
-        return this.#target;
-    }
-    connection() {
-        return this.#connection;
-    }
-    get detached() {
-        return this.#connection._closed || this.#detached;
-    }
-    parentSession() {
-        if (!this.#parentSessionId) {
-            // In some cases, e.g., DevTools pages there is no parent session. In this
-            // case, we treat the current session as the parent session.
-            return this;
-        }
-        const parent = this.#connection?.session(this.#parentSessionId);
-        return parent ?? undefined;
-    }
-    send(method, params, options) {
-        if (this.detached) {
-            return Promise.reject(new TargetCloseError(`Protocol error (${method}): Session closed. Most likely the ${this.#targetType} has been closed.`));
-        }
-        return this.#connection._rawSend(this.#callbacks, method, params, this.#sessionId, options);
-    }
-    /**
-     * @internal
-     */
-    onMessage(object) {
-        if (object.id) {
-            if (object.error) {
-                if (this.#rawErrors) {
-                    this.#callbacks.rejectRaw(object.id, object.error);
-                }
-                else {
-                    this.#callbacks.reject(object.id, createProtocolErrorMessage(object), object.error.message);
-                }
-            }
-            else {
-                this.#callbacks.resolve(object.id, object.result);
-            }
-        }
-        else {
-            assert(!object.id);
-            this.emit(object.method, object.params);
-        }
-    }
-    /**
-     * Detaches the cdpSession from the target. Once detached, the cdpSession object
-     * won't emit any events and can't be used to send messages.
-     */
-    async detach() {
-        if (this.detached) {
-            throw new Error(`Session already detached. Most likely the ${this.#targetType} has been closed.`);
-        }
-        await this.#connection.send('Target.detachFromTarget', {
-            sessionId: this.#sessionId,
-        });
-        this.#detached = true;
-    }
-    /**
-     * @internal
-     */
-    onClosed() {
-        this.#callbacks.clear();
-        this.#detached = true;
-        this.emit(CDPSessionEvent.Disconnected, undefined);
-    }
-    /**
-     * Returns the session's id.
-     */
-    id() {
-        return this.#sessionId;
-    }
-    /**
-     * @internal
-     */
-    getPendingProtocolErrors() {
-        return this.#callbacks.getPendingProtocolErrors();
-    }
-}
-//# sourceMappingURL=CdpSession.js.map

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

@@ -1,244 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { CDPSessionEvent, } from '../api/CDPSession.js';
-import { CallbackRegistry } from '../common/CallbackRegistry.js';
-import { debug } from '../common/Debug.js';
-import { ConnectionClosedError, TargetCloseError } from '../common/Errors.js';
-import { EventEmitter } from '../common/EventEmitter.js';
-import { createProtocolErrorMessage } from '../util/ErrorLike.js';
-import { createIncrementalIdGenerator, } from '../util/incremental-id-generator.js';
-import { CdpCDPSession } from './CdpSession.js';
-const debugProtocolSend = debug('puppeteer:protocol:SEND ►');
-const debugProtocolReceive = debug('puppeteer:protocol:RECV ◀');
-/**
- * @public
- */
-export class Connection extends EventEmitter {
-    #url;
-    #transport;
-    #delay;
-    #timeout;
-    #sessions = new Map();
-    #closed = false;
-    #manuallyAttached = new Set();
-    #callbacks;
-    #rawErrors = false;
-    #idGenerator;
-    constructor(url, transport, delay = 0, timeout, rawErrors = false, idGenerator = createIncrementalIdGenerator()) {
-        super();
-        this.#rawErrors = rawErrors;
-        this.#idGenerator = idGenerator;
-        this.#callbacks = new CallbackRegistry(idGenerator);
-        this.#url = url;
-        this.#delay = delay;
-        this.#timeout = timeout ?? 180_000;
-        this.#transport = transport;
-        this.#transport.onmessage = this.onMessage.bind(this);
-        this.#transport.onclose = this.#onClose.bind(this);
-    }
-    static fromSession(session) {
-        return session.connection();
-    }
-    /**
-     * @internal
-     */
-    get delay() {
-        return this.#delay;
-    }
-    get timeout() {
-        return this.#timeout;
-    }
-    /**
-     * @internal
-     */
-    get _closed() {
-        return this.#closed;
-    }
-    /**
-     * @internal
-     */
-    get _idGenerator() {
-        return this.#idGenerator;
-    }
-    /**
-     * @internal
-     */
-    get _sessions() {
-        return this.#sessions;
-    }
-    /**
-     * @internal
-     */
-    _session(sessionId) {
-        return this.#sessions.get(sessionId) || null;
-    }
-    /**
-     * @param sessionId - The session id
-     * @returns The current CDP session if it exists
-     */
-    session(sessionId) {
-        return this._session(sessionId);
-    }
-    url() {
-        return this.#url;
-    }
-    send(method, params, options) {
-        // There is only ever 1 param arg passed, but the Protocol defines it as an
-        // array of 0 or 1 items See this comment:
-        // https://github.com/ChromeDevTools/devtools-protocol/pull/113#issuecomment-412603285
-        // which explains why the protocol defines the params this way for better
-        // type-inference.
-        // So now we check if there are any params or not and deal with them accordingly.
-        return this._rawSend(this.#callbacks, method, params, undefined, options);
-    }
-    /**
-     * @internal
-     */
-    _rawSend(callbacks, method, params, sessionId, options) {
-        if (this.#closed) {
-            return Promise.reject(new ConnectionClosedError('Connection closed.'));
-        }
-        return callbacks.create(method, options?.timeout ?? this.#timeout, id => {
-            const stringifiedMessage = JSON.stringify({
-                method,
-                params,
-                id,
-                sessionId,
-            });
-            debugProtocolSend(stringifiedMessage);
-            this.#transport.send(stringifiedMessage);
-        });
-    }
-    /**
-     * @internal
-     */
-    async closeBrowser() {
-        await this.send('Browser.close');
-    }
-    /**
-     * @internal
-     */
-    async onMessage(message) {
-        if (this.#delay) {
-            await new Promise(r => {
-                return setTimeout(r, this.#delay);
-            });
-        }
-        debugProtocolReceive(message);
-        const object = JSON.parse(message);
-        if (object.method === 'Target.attachedToTarget') {
-            const sessionId = object.params.sessionId;
-            const session = new CdpCDPSession(this, object.params.targetInfo.type, sessionId, object.sessionId, this.#rawErrors);
-            this.#sessions.set(sessionId, session);
-            this.emit(CDPSessionEvent.SessionAttached, session);
-            const parentSession = this.#sessions.get(object.sessionId);
-            if (parentSession) {
-                parentSession.emit(CDPSessionEvent.SessionAttached, session);
-            }
-        }
-        else if (object.method === 'Target.detachedFromTarget') {
-            const session = this.#sessions.get(object.params.sessionId);
-            if (session) {
-                session.onClosed();
-                this.#sessions.delete(object.params.sessionId);
-                this.emit(CDPSessionEvent.SessionDetached, session);
-                const parentSession = this.#sessions.get(object.sessionId);
-                if (parentSession) {
-                    parentSession.emit(CDPSessionEvent.SessionDetached, session);
-                }
-            }
-        }
-        if (object.sessionId) {
-            const session = this.#sessions.get(object.sessionId);
-            if (session) {
-                session.onMessage(object);
-            }
-        }
-        else if (object.id) {
-            if (object.error) {
-                if (this.#rawErrors) {
-                    this.#callbacks.rejectRaw(object.id, object.error);
-                }
-                else {
-                    this.#callbacks.reject(object.id, createProtocolErrorMessage(object), object.error.message);
-                }
-            }
-            else {
-                this.#callbacks.resolve(object.id, object.result);
-            }
-        }
-        else {
-            this.emit(object.method, object.params);
-        }
-    }
-    #onClose() {
-        if (this.#closed) {
-            return;
-        }
-        this.#closed = true;
-        this.#transport.onmessage = undefined;
-        this.#transport.onclose = undefined;
-        this.#callbacks.clear();
-        for (const session of this.#sessions.values()) {
-            session.onClosed();
-        }
-        this.#sessions.clear();
-        this.emit(CDPSessionEvent.Disconnected, undefined);
-    }
-    dispose() {
-        this.#onClose();
-        this.#transport.close();
-    }
-    /**
-     * @internal
-     */
-    isAutoAttached(targetId) {
-        return !this.#manuallyAttached.has(targetId);
-    }
-    /**
-     * @internal
-     */
-    async _createSession(targetInfo, isAutoAttachEmulated = true) {
-        if (!isAutoAttachEmulated) {
-            this.#manuallyAttached.add(targetInfo.targetId);
-        }
-        const { sessionId } = await this.send('Target.attachToTarget', {
-            targetId: targetInfo.targetId,
-            flatten: true,
-        });
-        this.#manuallyAttached.delete(targetInfo.targetId);
-        const session = this.#sessions.get(sessionId);
-        if (!session) {
-            throw new Error('CDPSession creation failed.');
-        }
-        return session;
-    }
-    /**
-     * @param targetInfo - The target info
-     * @returns The CDP session that is created
-     */
-    async createSession(targetInfo) {
-        return await this._createSession(targetInfo, false);
-    }
-    /**
-     * @internal
-     */
-    getPendingProtocolErrors() {
-        const result = [];
-        result.push(...this.#callbacks.getPendingProtocolErrors());
-        for (const session of this.#sessions.values()) {
-            result.push(...session.getPendingProtocolErrors());
-        }
-        return result;
-    }
-}
-/**
- * @internal
- */
-export function isTargetClosedError(error) {
-    return error instanceof TargetCloseError;
-}
-//# sourceMappingURL=Connection.js.map