antigravity-mobile-proxy 0.1.2 → 0.1.3

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

@@ -1,499 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Keyboard, Mouse, MouseButton, Touchscreen, } from '../api/Input.js';
-import { TouchError } from '../common/Errors.js';
-import { _keyDefinitions, } from '../common/USKeyboardLayout.js';
-import { assert } from '../util/assert.js';
-/**
- * @internal
- */
-export class CdpKeyboard extends Keyboard {
-    #client;
-    #pressedKeys = new Set();
-    _modifiers = 0;
-    constructor(client) {
-        super();
-        this.#client = client;
-    }
-    updateClient(client) {
-        this.#client = client;
-    }
-    async down(key, options = {
-        text: undefined,
-        commands: [],
-    }) {
-        const description = this.#keyDescriptionForString(key);
-        const autoRepeat = this.#pressedKeys.has(description.code);
-        this.#pressedKeys.add(description.code);
-        this._modifiers |= this.#modifierBit(description.key);
-        const text = options.text === undefined ? description.text : options.text;
-        await this.#client.send('Input.dispatchKeyEvent', {
-            type: text ? 'keyDown' : 'rawKeyDown',
-            modifiers: this._modifiers,
-            windowsVirtualKeyCode: description.keyCode,
-            code: description.code,
-            key: description.key,
-            text: text,
-            unmodifiedText: text,
-            autoRepeat,
-            location: description.location,
-            isKeypad: description.location === 3,
-            commands: options.commands,
-        });
-    }
-    #modifierBit(key) {
-        if (key === 'Alt') {
-            return 1;
-        }
-        if (key === 'Control') {
-            return 2;
-        }
-        if (key === 'Meta') {
-            return 4;
-        }
-        if (key === 'Shift') {
-            return 8;
-        }
-        return 0;
-    }
-    #keyDescriptionForString(keyString) {
-        const shift = this._modifiers & 8;
-        const description = {
-            key: '',
-            keyCode: 0,
-            code: '',
-            text: '',
-            location: 0,
-        };
-        const definition = _keyDefinitions[keyString];
-        assert(definition, `Unknown key: "${keyString}"`);
-        if (definition.key) {
-            description.key = definition.key;
-        }
-        if (shift && definition.shiftKey) {
-            description.key = definition.shiftKey;
-        }
-        if (definition.keyCode) {
-            description.keyCode = definition.keyCode;
-        }
-        if (shift && definition.shiftKeyCode) {
-            description.keyCode = definition.shiftKeyCode;
-        }
-        if (definition.code) {
-            description.code = definition.code;
-        }
-        if (definition.location) {
-            description.location = definition.location;
-        }
-        if (description.key.length === 1) {
-            description.text = description.key;
-        }
-        if (definition.text) {
-            description.text = definition.text;
-        }
-        if (shift && definition.shiftText) {
-            description.text = definition.shiftText;
-        }
-        // if any modifiers besides shift are pressed, no text should be sent
-        if (this._modifiers & ~8) {
-            description.text = '';
-        }
-        return description;
-    }
-    async up(key) {
-        const description = this.#keyDescriptionForString(key);
-        this._modifiers &= ~this.#modifierBit(description.key);
-        this.#pressedKeys.delete(description.code);
-        await this.#client.send('Input.dispatchKeyEvent', {
-            type: 'keyUp',
-            modifiers: this._modifiers,
-            key: description.key,
-            windowsVirtualKeyCode: description.keyCode,
-            code: description.code,
-            location: description.location,
-        });
-    }
-    async sendCharacter(char) {
-        await this.#client.send('Input.insertText', { text: char });
-    }
-    charIsKey(char) {
-        return !!_keyDefinitions[char];
-    }
-    async type(text, options = {}) {
-        const delay = options.delay || undefined;
-        for (const char of text) {
-            if (this.charIsKey(char)) {
-                await this.press(char, { delay });
-            }
-            else {
-                if (delay) {
-                    await new Promise(f => {
-                        return setTimeout(f, delay);
-                    });
-                }
-                await this.sendCharacter(char);
-            }
-        }
-    }
-    async press(key, options = {}) {
-        const { delay = null } = options;
-        await this.down(key, options);
-        if (delay) {
-            await new Promise(f => {
-                return setTimeout(f, options.delay);
-            });
-        }
-        await this.up(key);
-    }
-}
-const getFlag = (button) => {
-    switch (button) {
-        case MouseButton.Left:
-            return 1 /* MouseButtonFlag.Left */;
-        case MouseButton.Right:
-            return 2 /* MouseButtonFlag.Right */;
-        case MouseButton.Middle:
-            return 4 /* MouseButtonFlag.Middle */;
-        case MouseButton.Back:
-            return 8 /* MouseButtonFlag.Back */;
-        case MouseButton.Forward:
-            return 16 /* MouseButtonFlag.Forward */;
-    }
-};
-/**
- * This should match
- * https://source.chromium.org/chromium/chromium/src/+/refs/heads/main:content/browser/renderer_host/input/web_input_event_builders_mac.mm;drc=a61b95c63b0b75c1cfe872d9c8cdf927c226046e;bpv=1;bpt=1;l=221.
- */
-const getButtonFromPressedButtons = (buttons) => {
-    if (buttons & 1 /* MouseButtonFlag.Left */) {
-        return MouseButton.Left;
-    }
-    else if (buttons & 2 /* MouseButtonFlag.Right */) {
-        return MouseButton.Right;
-    }
-    else if (buttons & 4 /* MouseButtonFlag.Middle */) {
-        return MouseButton.Middle;
-    }
-    else if (buttons & 8 /* MouseButtonFlag.Back */) {
-        return MouseButton.Back;
-    }
-    else if (buttons & 16 /* MouseButtonFlag.Forward */) {
-        return MouseButton.Forward;
-    }
-    return 'none';
-};
-/**
- * @internal
- */
-export class CdpMouse extends Mouse {
-    #client;
-    #keyboard;
-    constructor(client, keyboard) {
-        super();
-        this.#client = client;
-        this.#keyboard = keyboard;
-    }
-    updateClient(client) {
-        this.#client = client;
-    }
-    #_state = {
-        position: { x: 0, y: 0 },
-        buttons: 0 /* MouseButtonFlag.None */,
-    };
-    get #state() {
-        return Object.assign({ ...this.#_state }, ...this.#transactions);
-    }
-    // Transactions can run in parallel, so we store each of thme in this array.
-    #transactions = [];
-    #createTransaction() {
-        const transaction = {};
-        this.#transactions.push(transaction);
-        const popTransaction = () => {
-            this.#transactions.splice(this.#transactions.indexOf(transaction), 1);
-        };
-        return {
-            update: (updates) => {
-                Object.assign(transaction, updates);
-            },
-            commit: () => {
-                this.#_state = { ...this.#_state, ...transaction };
-                popTransaction();
-            },
-            rollback: popTransaction,
-        };
-    }
-    /**
-     * This is a shortcut for a typical update, commit/rollback lifecycle based on
-     * the error of the action.
-     */
-    async #withTransaction(action) {
-        const { update, commit, rollback } = this.#createTransaction();
-        try {
-            await action(update);
-            commit();
-        }
-        catch (error) {
-            rollback();
-            throw error;
-        }
-    }
-    async reset() {
-        const actions = [];
-        for (const [flag, button] of [
-            [1 /* MouseButtonFlag.Left */, MouseButton.Left],
-            [4 /* MouseButtonFlag.Middle */, MouseButton.Middle],
-            [2 /* MouseButtonFlag.Right */, MouseButton.Right],
-            [16 /* MouseButtonFlag.Forward */, MouseButton.Forward],
-            [8 /* MouseButtonFlag.Back */, MouseButton.Back],
-        ]) {
-            if (this.#state.buttons & flag) {
-                actions.push(this.up({ button: button }));
-            }
-        }
-        if (this.#state.position.x !== 0 || this.#state.position.y !== 0) {
-            actions.push(this.move(0, 0));
-        }
-        await Promise.all(actions);
-    }
-    async move(x, y, options = {}) {
-        const { steps = 1 } = options;
-        const from = this.#state.position;
-        const to = { x, y };
-        for (let i = 1; i <= steps; i++) {
-            await this.#withTransaction(updateState => {
-                updateState({
-                    position: {
-                        x: from.x + (to.x - from.x) * (i / steps),
-                        y: from.y + (to.y - from.y) * (i / steps),
-                    },
-                });
-                const { buttons, position } = this.#state;
-                return this.#client.send('Input.dispatchMouseEvent', {
-                    type: 'mouseMoved',
-                    modifiers: this.#keyboard._modifiers,
-                    buttons,
-                    button: getButtonFromPressedButtons(buttons),
-                    ...position,
-                });
-            });
-        }
-    }
-    async down(options = {}) {
-        const { button = MouseButton.Left, clickCount = 1 } = options;
-        const flag = getFlag(button);
-        if (!flag) {
-            throw new Error(`Unsupported mouse button: ${button}`);
-        }
-        if (this.#state.buttons & flag) {
-            throw new Error(`'${button}' is already pressed.`);
-        }
-        await this.#withTransaction(updateState => {
-            updateState({
-                buttons: this.#state.buttons | flag,
-            });
-            const { buttons, position } = this.#state;
-            return this.#client.send('Input.dispatchMouseEvent', {
-                type: 'mousePressed',
-                modifiers: this.#keyboard._modifiers,
-                clickCount,
-                buttons,
-                button,
-                ...position,
-            });
-        });
-    }
-    async up(options = {}) {
-        const { button = MouseButton.Left, clickCount = 1 } = options;
-        const flag = getFlag(button);
-        if (!flag) {
-            throw new Error(`Unsupported mouse button: ${button}`);
-        }
-        if (!(this.#state.buttons & flag)) {
-            throw new Error(`'${button}' is not pressed.`);
-        }
-        await this.#withTransaction(updateState => {
-            updateState({
-                buttons: this.#state.buttons & ~flag,
-            });
-            const { buttons, position } = this.#state;
-            return this.#client.send('Input.dispatchMouseEvent', {
-                type: 'mouseReleased',
-                modifiers: this.#keyboard._modifiers,
-                clickCount,
-                buttons,
-                button,
-                ...position,
-            });
-        });
-    }
-    async click(x, y, options = {}) {
-        const { delay, count = 1, clickCount = count } = options;
-        if (count < 1) {
-            throw new Error('Click must occur a positive number of times.');
-        }
-        const actions = [this.move(x, y)];
-        if (clickCount === count) {
-            for (let i = 1; i < count; ++i) {
-                actions.push(this.down({ ...options, clickCount: i }), this.up({ ...options, clickCount: i }));
-            }
-        }
-        actions.push(this.down({ ...options, clickCount }));
-        if (typeof delay === 'number') {
-            await Promise.all(actions);
-            actions.length = 0;
-            await new Promise(resolve => {
-                setTimeout(resolve, delay);
-            });
-        }
-        actions.push(this.up({ ...options, clickCount }));
-        await Promise.all(actions);
-    }
-    async wheel(options = {}) {
-        const { deltaX = 0, deltaY = 0 } = options;
-        const { position, buttons } = this.#state;
-        await this.#client.send('Input.dispatchMouseEvent', {
-            type: 'mouseWheel',
-            pointerType: 'mouse',
-            modifiers: this.#keyboard._modifiers,
-            deltaY,
-            deltaX,
-            buttons,
-            ...position,
-        });
-    }
-    async drag(start, target) {
-        const promise = new Promise(resolve => {
-            this.#client.once('Input.dragIntercepted', event => {
-                return resolve(event.data);
-            });
-        });
-        await this.move(start.x, start.y);
-        await this.down();
-        await this.move(target.x, target.y);
-        return await promise;
-    }
-    async dragEnter(target, data) {
-        await this.#client.send('Input.dispatchDragEvent', {
-            type: 'dragEnter',
-            x: target.x,
-            y: target.y,
-            modifiers: this.#keyboard._modifiers,
-            data,
-        });
-    }
-    async dragOver(target, data) {
-        await this.#client.send('Input.dispatchDragEvent', {
-            type: 'dragOver',
-            x: target.x,
-            y: target.y,
-            modifiers: this.#keyboard._modifiers,
-            data,
-        });
-    }
-    async drop(target, data) {
-        await this.#client.send('Input.dispatchDragEvent', {
-            type: 'drop',
-            x: target.x,
-            y: target.y,
-            modifiers: this.#keyboard._modifiers,
-            data,
-        });
-    }
-    async dragAndDrop(start, target, options = {}) {
-        const { delay = null } = options;
-        const data = await this.drag(start, target);
-        await this.dragEnter(target, data);
-        await this.dragOver(target, data);
-        if (delay) {
-            await new Promise(resolve => {
-                return setTimeout(resolve, delay);
-            });
-        }
-        await this.drop(target, data);
-        await this.up();
-    }
-}
-/**
- * @internal
- */
-export class CdpTouchHandle {
-    #started = false;
-    #touchScreen;
-    #touchPoint;
-    #client;
-    #keyboard;
-    constructor(client, touchScreen, keyboard, touchPoint) {
-        this.#client = client;
-        this.#touchScreen = touchScreen;
-        this.#keyboard = keyboard;
-        this.#touchPoint = touchPoint;
-    }
-    updateClient(client) {
-        this.#client = client;
-    }
-    async start() {
-        if (this.#started) {
-            throw new TouchError('Touch has already started');
-        }
-        await this.#client.send('Input.dispatchTouchEvent', {
-            type: 'touchStart',
-            touchPoints: [this.#touchPoint],
-            modifiers: this.#keyboard._modifiers,
-        });
-        this.#started = true;
-    }
-    move(x, y) {
-        this.#touchPoint.x = Math.round(x);
-        this.#touchPoint.y = Math.round(y);
-        return this.#client.send('Input.dispatchTouchEvent', {
-            type: 'touchMove',
-            touchPoints: [this.#touchPoint],
-            modifiers: this.#keyboard._modifiers,
-        });
-    }
-    async end() {
-        await this.#client.send('Input.dispatchTouchEvent', {
-            type: 'touchEnd',
-            touchPoints: [this.#touchPoint],
-            modifiers: this.#keyboard._modifiers,
-        });
-        this.#touchScreen.removeHandle(this);
-    }
-}
-/**
- * @internal
- */
-export class CdpTouchscreen extends Touchscreen {
-    #client;
-    #keyboard;
-    constructor(client, keyboard) {
-        super();
-        this.#client = client;
-        this.#keyboard = keyboard;
-    }
-    updateClient(client) {
-        this.#client = client;
-        this.touches.forEach(t => {
-            t.updateClient(client);
-        });
-    }
-    async touchStart(x, y) {
-        const id = this.idGenerator();
-        const touchPoint = {
-            x: Math.round(x),
-            y: Math.round(y),
-            radiusX: 0.5,
-            radiusY: 0.5,
-            force: 0.5,
-            id,
-        };
-        const touch = new CdpTouchHandle(this.#client, this, this.#keyboard, touchPoint);
-        await touch.start();
-        this.touches.push(touch);
-        return touch;
-    }
-}
-//# sourceMappingURL=Input.js.map

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

@@ -1,157 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { firstValueFrom, map, raceWith } from '../../third_party/rxjs/rxjs.js';
-import { Realm } from '../api/Realm.js';
-import { EventEmitter } from '../common/EventEmitter.js';
-import { fromEmitterEvent, timeout, withSourcePuppeteerURLIfNone, } from '../common/util.js';
-import { disposeSymbol } from '../util/disposable.js';
-import { CdpElementHandle } from './ElementHandle.js';
-import { CdpJSHandle } from './JSHandle.js';
-/**
- * @internal
- */
-export class IsolatedWorld extends Realm {
-    #context;
-    #emitter = new EventEmitter();
-    #frameOrWorker;
-    constructor(frameOrWorker, timeoutSettings) {
-        super(timeoutSettings);
-        this.#frameOrWorker = frameOrWorker;
-    }
-    get environment() {
-        return this.#frameOrWorker;
-    }
-    get client() {
-        return this.#frameOrWorker.client;
-    }
-    get emitter() {
-        return this.#emitter;
-    }
-    setContext(context) {
-        this.#context?.[disposeSymbol]();
-        context.once('disposed', this.#onContextDisposed.bind(this));
-        context.on('consoleapicalled', this.#onContextConsoleApiCalled.bind(this));
-        context.on('bindingcalled', this.#onContextBindingCalled.bind(this));
-        this.#context = context;
-        this.#emitter.emit('context', context);
-        void this.taskManager.rerunAll();
-    }
-    #onContextDisposed() {
-        this.#context = undefined;
-        if ('clearDocumentHandle' in this.#frameOrWorker) {
-            this.#frameOrWorker.clearDocumentHandle();
-        }
-    }
-    #onContextConsoleApiCalled(event) {
-        this.#emitter.emit('consoleapicalled', event);
-    }
-    #onContextBindingCalled(event) {
-        this.#emitter.emit('bindingcalled', event);
-    }
-    hasContext() {
-        return !!this.#context;
-    }
-    get context() {
-        return this.#context;
-    }
-    #executionContext() {
-        if (this.disposed) {
-            throw new Error(`Execution context is not available in detached frame or worker "${this.environment.url()}" (are you trying to evaluate?)`);
-        }
-        return this.#context;
-    }
-    /**
-     * Waits for the next context to be set on the isolated world.
-     */
-    async #waitForExecutionContext() {
-        const error = new Error('Execution context was destroyed');
-        const result = await firstValueFrom(fromEmitterEvent(this.#emitter, 'context').pipe(raceWith(fromEmitterEvent(this.#emitter, 'disposed').pipe(map(() => {
-            // The message has to match the CDP message expected by the WaitTask class.
-            throw error;
-        })), timeout(this.timeoutSettings.timeout()))));
-        return result;
-    }
-    async evaluateHandle(pageFunction, ...args) {
-        pageFunction = withSourcePuppeteerURLIfNone(this.evaluateHandle.name, pageFunction);
-        // This code needs to schedule evaluateHandle call synchronously (at
-        // least when the context is there) so we cannot unconditionally
-        // await.
-        let context = this.#executionContext();
-        if (!context) {
-            context = await this.#waitForExecutionContext();
-        }
-        return await context.evaluateHandle(pageFunction, ...args);
-    }
-    async evaluate(pageFunction, ...args) {
-        pageFunction = withSourcePuppeteerURLIfNone(this.evaluate.name, pageFunction);
-        // This code needs to schedule evaluate call synchronously (at
-        // least when the context is there) so we cannot unconditionally
-        // await.
-        let context = this.#executionContext();
-        if (!context) {
-            context = await this.#waitForExecutionContext();
-        }
-        return await context.evaluate(pageFunction, ...args);
-    }
-    async adoptBackendNode(backendNodeId) {
-        // This code needs to schedule resolveNode call synchronously (at
-        // least when the context is there) so we cannot unconditionally
-        // await.
-        let context = this.#executionContext();
-        if (!context) {
-            context = await this.#waitForExecutionContext();
-        }
-        const { object } = await this.client.send('DOM.resolveNode', {
-            backendNodeId: backendNodeId,
-            executionContextId: context.id,
-        });
-        return this.createCdpHandle(object);
-    }
-    async adoptHandle(handle) {
-        if (handle.realm === this) {
-            // If the context has already adopted this handle, clone it so downstream
-            // disposal doesn't become an issue.
-            return (await handle.evaluateHandle(value => {
-                return value;
-            }));
-        }
-        const nodeInfo = await this.client.send('DOM.describeNode', {
-            objectId: handle.id,
-        });
-        return (await this.adoptBackendNode(nodeInfo.node.backendNodeId));
-    }
-    async transferHandle(handle) {
-        if (handle.realm === this) {
-            return handle;
-        }
-        // Implies it's a primitive value, probably.
-        if (handle.remoteObject().objectId === undefined) {
-            return handle;
-        }
-        const info = await this.client.send('DOM.describeNode', {
-            objectId: handle.remoteObject().objectId,
-        });
-        const newHandle = (await this.adoptBackendNode(info.node.backendNodeId));
-        await handle.dispose();
-        return newHandle;
-    }
-    /**
-     * @internal
-     */
-    createCdpHandle(remoteObject) {
-        if (remoteObject.subtype === 'node') {
-            return new CdpElementHandle(this, remoteObject);
-        }
-        return new CdpJSHandle(this, remoteObject);
-    }
-    [disposeSymbol]() {
-        this.#context?.[disposeSymbol]();
-        this.#emitter.emit('disposed', undefined);
-        super[disposeSymbol]();
-        this.#emitter.removeAllListeners();
-    }
-}
-//# sourceMappingURL=IsolatedWorld.js.map

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

@@ -1,20 +0,0 @@
-/**
- * @license
- * Copyright 2022 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * A unique key for {@link IsolatedWorldChart} to denote the default world.
- * Execution contexts are automatically created in the default world.
- *
- * @internal
- */
-export const MAIN_WORLD = Symbol('mainWorld');
-/**
- * A unique key for {@link IsolatedWorldChart} to denote the puppeteer world.
- * This world contains all puppeteer-internal bindings/code.
- *
- * @internal
- */
-export const PUPPETEER_WORLD = Symbol('puppeteerWorld');
-//# sourceMappingURL=IsolatedWorlds.js.map