antigravity-mobile-proxy 0.1.2 → 0.1.4

package/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/util/Function.js

@@ -1,70 +0,0 @@
-/**
- * @license
- * Copyright 2023 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-const createdFunctions = new Map();
-/**
- * Creates a function from a string.
- *
- * @internal
- */
-export const createFunction = (functionValue) => {
-    let fn = createdFunctions.get(functionValue);
-    if (fn) {
-        return fn;
-    }
-    fn = new Function(`return ${functionValue}`)();
-    createdFunctions.set(functionValue, fn);
-    return fn;
-};
-/**
- * @internal
- */
-export function stringifyFunction(fn) {
-    let value = fn.toString();
-    if (value.match(/^(async )*function(\(|\s)/) ||
-        value.match(/^(async )*function\s*\*\s*/)) {
-        return value;
-    }
-    const isArrow = value.startsWith('(') ||
-        value.match(/^async\s*\(/) ||
-        value.match(/^(async)*\s*(?:[$_\p{ID_Start}])(?:[$\u200C\u200D\p{ID_Continue}])*\s*=>/u);
-    if (isArrow) {
-        return value;
-    }
-    // This means we might have a function shorthand (e.g. `test(){}`). Let's
-    // try prefixing.
-    let prefix = 'function ';
-    if (value.startsWith('async ')) {
-        prefix = `async ${prefix}`;
-        value = value.substring('async '.length);
-    }
-    return `${prefix}${value}`;
-}
-/**
- * Replaces `PLACEHOLDER`s with the given replacements.
- *
- * All replacements must be valid JS code.
- *
- * @example
- *
- * ```ts
- * interpolateFunction(() => PLACEHOLDER('test'), {test: 'void 0'});
- * // Equivalent to () => void 0
- * ```
- *
- * @internal
- */
-export const interpolateFunction = (fn, replacements) => {
-    let value = stringifyFunction(fn);
-    for (const [name, jsValue] of Object.entries(replacements)) {
-        value = value.replace(new RegExp(`PLACEHOLDER\\(\\s*(?:'${name}'|"${name}")\\s*\\)`, 'g'), 
-        // Wrapping this ensures tersers that accidentally inline PLACEHOLDER calls
-        // are still valid. Without, we may get calls like ()=>{...}() which is
-        // not valid.
-        `(${jsValue})`);
-    }
-    return createFunction(value);
-};
-//# sourceMappingURL=Function.js.map

package/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/util/Mutex.js

@@ -1,46 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Deferred } from './Deferred.js';
-import { disposeSymbol } from './disposable.js';
-/**
- * @internal
- */
-export class Mutex {
-    static Guard = class Guard {
-        #mutex;
-        #onRelease;
-        constructor(mutex, onRelease) {
-            this.#mutex = mutex;
-            this.#onRelease = onRelease;
-        }
-        [disposeSymbol]() {
-            this.#onRelease?.();
-            return this.#mutex.release();
-        }
-    };
-    #locked = false;
-    #acquirers = [];
-    // This is FIFO.
-    async acquire(onRelease) {
-        if (!this.#locked) {
-            this.#locked = true;
-            return new Mutex.Guard(this);
-        }
-        const deferred = Deferred.create();
-        this.#acquirers.push(deferred.resolve.bind(deferred));
-        await deferred.valueOrThrow();
-        return new Mutex.Guard(this, onRelease);
-    }
-    release() {
-        const resolve = this.#acquirers.shift();
-        if (!resolve) {
-            this.#locked = false;
-            return;
-        }
-        resolve();
-    }
-}
-//# sourceMappingURL=Mutex.js.map

package/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/util/assert.js

@@ -1,18 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * Asserts that the given value is truthy.
- * @param value - some conditional statement
- * @param message - the error message to throw if the value is not truthy.
- *
- * @internal
- */
-export const assert = (value, message) => {
-    if (!value) {
-        throw new Error(message);
-    }
-};
-//# sourceMappingURL=assert.js.map

package/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/util/decorators.js

@@ -1,232 +0,0 @@
-/**
- * @license
- * Copyright 2023 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 { asyncDisposeSymbol, disposeSymbol } from './disposable.js';
-import { Mutex } from './Mutex.js';
-const instances = new WeakSet();
-export function moveable(Class, _) {
-    let hasDispose = false;
-    if (Class.prototype[disposeSymbol]) {
-        const dispose = Class.prototype[disposeSymbol];
-        Class.prototype[disposeSymbol] = function () {
-            if (instances.has(this)) {
-                instances.delete(this);
-                return;
-            }
-            return dispose.call(this);
-        };
-        hasDispose = true;
-    }
-    if (Class.prototype[asyncDisposeSymbol]) {
-        const asyncDispose = Class.prototype[asyncDisposeSymbol];
-        Class.prototype[asyncDisposeSymbol] = function () {
-            if (instances.has(this)) {
-                instances.delete(this);
-                return;
-            }
-            return asyncDispose.call(this);
-        };
-        hasDispose = true;
-    }
-    if (hasDispose) {
-        Class.prototype.move = function () {
-            instances.add(this);
-            return this;
-        };
-    }
-    return Class;
-}
-export function throwIfDisposed(message = value => {
-    return `Attempted to use disposed ${value.constructor.name}.`;
-}) {
-    return (target, _) => {
-        return function (...args) {
-            if (this.disposed) {
-                throw new Error(message(this));
-            }
-            return target.call(this, ...args);
-        };
-    };
-}
-export function inertIfDisposed(target, _) {
-    return function (...args) {
-        if (this.disposed) {
-            return;
-        }
-        return target.call(this, ...args);
-    };
-}
-/**
- * The decorator only invokes the target if the target has not been invoked with
- * the same arguments before. The decorated method throws an error if it's
- * invoked with a different number of elements: if you decorate a method, it
- * should have the same number of arguments
- *
- * @internal
- */
-export function invokeAtMostOnceForArguments(target, _) {
-    const cache = new WeakMap();
-    let cacheDepth = -1;
-    return function (...args) {
-        if (cacheDepth === -1) {
-            cacheDepth = args.length;
-        }
-        if (cacheDepth !== args.length) {
-            throw new Error('Memoized method was called with the wrong number of arguments');
-        }
-        let freshArguments = false;
-        let cacheIterator = cache;
-        for (const arg of args) {
-            if (cacheIterator.has(arg)) {
-                cacheIterator = cacheIterator.get(arg);
-            }
-            else {
-                freshArguments = true;
-                cacheIterator.set(arg, new WeakMap());
-                cacheIterator = cacheIterator.get(arg);
-            }
-        }
-        if (!freshArguments) {
-            return;
-        }
-        return target.call(this, ...args);
-    };
-}
-export function guarded(getKey = function () {
-    return this;
-}) {
-    return (target, _) => {
-        const mutexes = new WeakMap();
-        return async function (...args) {
-            const env_1 = { stack: [], error: void 0, hasError: false };
-            try {
-                const key = getKey.call(this);
-                let mutex = mutexes.get(key);
-                if (!mutex) {
-                    mutex = new Mutex();
-                    mutexes.set(key, mutex);
-                }
-                const _ = __addDisposableResource(env_1, await mutex.acquire(), true);
-                return await target.call(this, ...args);
-            }
-            catch (e_1) {
-                env_1.error = e_1;
-                env_1.hasError = true;
-            }
-            finally {
-                const result_1 = __disposeResources(env_1);
-                if (result_1)
-                    await result_1;
-            }
-        };
-    };
-}
-const bubbleHandlers = new WeakMap();
-const bubbleInitializer = function (events) {
-    const handlers = bubbleHandlers.get(this) ?? new Map();
-    if (handlers.has(events)) {
-        return;
-    }
-    const handler = events !== undefined
-        ? (type, event) => {
-            if (events.includes(type)) {
-                this.emit(type, event);
-            }
-        }
-        : (type, event) => {
-            this.emit(type, event);
-        };
-    handlers.set(events, handler);
-    bubbleHandlers.set(this, handlers);
-};
-/**
- * Event emitter fields marked with `bubble` will have their events bubble up
- * the field owner.
- */
-// The type is too complicated to type.
-export function bubble(events) {
-    return ({ set, get }, context) => {
-        context.addInitializer(function () {
-            return bubbleInitializer.apply(this, [events]);
-        });
-        return {
-            set(emitter) {
-                const handler = bubbleHandlers.get(this).get(events);
-                // In case we are re-setting.
-                const oldEmitter = get.call(this);
-                if (oldEmitter !== undefined) {
-                    oldEmitter.off('*', handler);
-                }
-                if (emitter === undefined) {
-                    return;
-                }
-                emitter.on('*', handler);
-                set.call(this, emitter);
-            },
-            init(emitter) {
-                if (emitter === undefined) {
-                    return emitter;
-                }
-                bubbleInitializer.apply(this, [events]);
-                const handler = bubbleHandlers.get(this).get(events);
-                emitter.on('*', handler);
-                return emitter;
-            },
-        };
-    };
-}
-//# sourceMappingURL=decorators.js.map

package/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/util/disposable.js

@@ -1,342 +0,0 @@
-/**
- * @license
- * Copyright 2023 Google Inc.
- * SPDX-License-Identifier: Apache-2.0
- */
-Symbol.dispose ??= Symbol('dispose');
-Symbol.asyncDispose ??= Symbol('asyncDispose');
-/**
- * @internal
- */
-export const disposeSymbol = Symbol.dispose;
-/**
- * @internal
- */
-export const asyncDisposeSymbol = Symbol.asyncDispose;
-/**
- * @internal
- */
-export class DisposableStackPolyfill {
-    #disposed = false;
-    #stack = [];
-    /**
-     * Returns a value indicating whether the stack has been disposed.
-     */
-    get disposed() {
-        return this.#disposed;
-    }
-    /**
-     * Alias for `[Symbol.dispose]()`.
-     */
-    dispose() {
-        this[disposeSymbol]();
-    }
-    /**
-     * Adds a disposable resource to the top of stack, returning the resource.
-     * Has no effect if provided `null` or `undefined`.
-     *
-     * @param value - A `Disposable` object, `null`, or `undefined`.
-     * `null` and `undefined` will not be added, but will be returned.
-     * @returns The provided `value`.
-     */
-    use(value) {
-        if (value && typeof value[disposeSymbol] === 'function') {
-            this.#stack.push(value);
-        }
-        return value;
-    }
-    /**
-     * Adds a non-disposable resource and a disposal callback to the top of the stack.
-     *
-     * @param value - A resource to be disposed.
-     * @param onDispose - A callback invoked to dispose the provided value.
-     * Will be invoked with `value` as the first parameter.
-     * @returns The provided `value`.
-     */
-    adopt(value, onDispose) {
-        this.#stack.push({
-            [disposeSymbol]() {
-                onDispose(value);
-            },
-        });
-        return value;
-    }
-    /**
-     * Add a disposal callback to the top of the stack to be invoked when stack is disposed.
-     * @param onDispose - A callback to invoke when this object is disposed.
-     */
-    defer(onDispose) {
-        this.#stack.push({
-            [disposeSymbol]() {
-                onDispose();
-            },
-        });
-    }
-    /**
-     * Move all resources out of this stack and into a new `DisposableStack`, and
-     * marks this stack as disposed.
-     * @returns The new `DisposableStack`.
-     *
-     * @example
-     *
-     * ```ts
-     * class C {
-     *   #res1: Disposable;
-     *   #res2: Disposable;
-     *   #disposables: DisposableStack;
-     *   constructor() {
-     *     // stack will be disposed when exiting constructor for any reason
-     *     using stack = new DisposableStack();
-     *
-     *     // get first resource
-     *     this.#res1 = stack.use(getResource1());
-     *
-     *     // get second resource. If this fails, both `stack` and `#res1` will be disposed.
-     *     this.#res2 = stack.use(getResource2());
-     *
-     *     // all operations succeeded, move resources out of `stack` so that
-     *     // they aren't disposed when constructor exits
-     *     this.#disposables = stack.move();
-     *   }
-     *
-     *   [disposeSymbol]() {
-     *     this.#disposables.dispose();
-     *   }
-     * }
-     * ```
-     */
-    move() {
-        if (this.#disposed) {
-            throw new ReferenceError('A disposed stack can not use anything new');
-        }
-        const stack = new DisposableStackPolyfill();
-        stack.#stack = this.#stack;
-        this.#stack = [];
-        this.#disposed = true;
-        return stack;
-    }
-    /**
-     * Disposes each resource in the stack in last-in-first-out (LIFO) manner.
-     */
-    [disposeSymbol]() {
-        if (this.#disposed) {
-            return;
-        }
-        this.#disposed = true;
-        const errors = [];
-        for (const resource of this.#stack.reverse()) {
-            try {
-                resource[disposeSymbol]();
-            }
-            catch (e) {
-                errors.push(e);
-            }
-        }
-        if (errors.length === 1) {
-            throw errors[0];
-        }
-        else if (errors.length > 1) {
-            let suppressed = null;
-            for (const error of errors) {
-                if (suppressed === null) {
-                    suppressed = error;
-                }
-                else {
-                    suppressed = new SuppressedErrorPolyfill(error, suppressed);
-                }
-            }
-            throw suppressed;
-        }
-    }
-    [Symbol.toStringTag] = 'DisposableStack';
-}
-/**
- * @internal
- */
-export const DisposableStack = globalThis.DisposableStack ?? DisposableStackPolyfill;
-/**
- * @internal
- */
-export class AsyncDisposableStackPolyfill {
-    #disposed = false;
-    #stack = [];
-    /**
-     * Returns a value indicating whether the stack has been disposed.
-     */
-    get disposed() {
-        return this.#disposed;
-    }
-    /**
-     * Alias for `[Symbol.asyncDispose]()`.
-     */
-    async disposeAsync() {
-        await this[asyncDisposeSymbol]();
-    }
-    /**
-     * Adds a AsyncDisposable resource to the top of stack, returning the resource.
-     * Has no effect if provided `null` or `undefined`.
-     *
-     * @param value - A `AsyncDisposable` object, `null`, or `undefined`.
-     * `null` and `undefined` will not be added, but will be returned.
-     * @returns The provided `value`.
-     */
-    use(value) {
-        if (value) {
-            const asyncDispose = value[asyncDisposeSymbol];
-            const dispose = value[disposeSymbol];
-            if (typeof asyncDispose === 'function') {
-                this.#stack.push(value);
-            }
-            else if (typeof dispose === 'function') {
-                this.#stack.push({
-                    [asyncDisposeSymbol]: async () => {
-                        value[disposeSymbol]();
-                    },
-                });
-            }
-        }
-        return value;
-    }
-    /**
-     * Adds a non-disposable resource and a disposal callback to the top of the stack.
-     *
-     * @param value - A resource to be disposed.
-     * @param onDispose - A callback invoked to dispose the provided value.
-     * Will be invoked with `value` as the first parameter.
-     * @returns The provided `value`.
-     */
-    adopt(value, onDispose) {
-        this.#stack.push({
-            [asyncDisposeSymbol]() {
-                return onDispose(value);
-            },
-        });
-        return value;
-    }
-    /**
-     * Add a disposal callback to the top of the stack to be invoked when stack is disposed.
-     * @param onDispose - A callback to invoke when this object is disposed.
-     */
-    defer(onDispose) {
-        this.#stack.push({
-            [asyncDisposeSymbol]() {
-                return onDispose();
-            },
-        });
-    }
-    /**
-     * Move all resources out of this stack and into a new `DisposableStack`, and
-     * marks this stack as disposed.
-     * @returns The new `AsyncDisposableStack`.
-     *
-     * @example
-     *
-     * ```ts
-     * class C {
-     *   #res1: Disposable;
-     *   #res2: Disposable;
-     *   #disposables: DisposableStack;
-     *   constructor() {
-     *     // stack will be disposed when exiting constructor for any reason
-     *     using stack = new DisposableStack();
-     *
-     *     // get first resource
-     *     this.#res1 = stack.use(getResource1());
-     *
-     *     // get second resource. If this fails, both `stack` and `#res1` will be disposed.
-     *     this.#res2 = stack.use(getResource2());
-     *
-     *     // all operations succeeded, move resources out of `stack` so that
-     *     // they aren't disposed when constructor exits
-     *     this.#disposables = stack.move();
-     *   }
-     *
-     *   [disposeSymbol]() {
-     *     this.#disposables.dispose();
-     *   }
-     * }
-     * ```
-     */
-    move() {
-        if (this.#disposed) {
-            throw new ReferenceError('A disposed stack can not use anything new');
-        }
-        const stack = new AsyncDisposableStackPolyfill();
-        stack.#stack = this.#stack;
-        this.#stack = [];
-        this.#disposed = true;
-        return stack;
-    }
-    /**
-     * Disposes each resource in the stack in last-in-first-out (LIFO) manner.
-     */
-    async [asyncDisposeSymbol]() {
-        if (this.#disposed) {
-            return;
-        }
-        this.#disposed = true;
-        const errors = [];
-        for (const resource of this.#stack.reverse()) {
-            try {
-                await resource[asyncDisposeSymbol]();
-            }
-            catch (e) {
-                errors.push(e);
-            }
-        }
-        if (errors.length === 1) {
-            throw errors[0];
-        }
-        else if (errors.length > 1) {
-            let suppressed = null;
-            for (const error of errors) {
-                if (suppressed === null) {
-                    suppressed = error;
-                }
-                else {
-                    suppressed = new SuppressedErrorPolyfill(error, suppressed);
-                }
-            }
-            throw suppressed;
-        }
-    }
-    [Symbol.toStringTag] = 'AsyncDisposableStack';
-}
-/**
- * @internal
- */
-export const AsyncDisposableStack = globalThis.AsyncDisposableStack ?? AsyncDisposableStackPolyfill;
-/**
- * @internal
- * Represents an error that occurs when multiple errors are thrown during
- * the disposal of resources. This class encapsulates the primary error and
- * any suppressed errors that occurred subsequently.
- */
-class SuppressedErrorPolyfill extends Error {
-    #error;
-    #suppressed;
-    constructor(error, suppressed, message = 'An error was suppressed during disposal') {
-        super(message);
-        this.name = 'SuppressedError';
-        this.#error = error;
-        this.#suppressed = suppressed;
-    }
-    /**
-     * The primary error that occurred during disposal.
-     */
-    get error() {
-        return this.#error;
-    }
-    /**
-     * The suppressed error i.e. the error that was suppressed
-     * because it occurred later in the flow after the original error.
-     */
-    get suppressed() {
-        return this.#suppressed;
-    }
-}
-/**
- * @internal
- */
-export const SuppressedError = globalThis.SuppressedError ?? SuppressedErrorPolyfill;
-//# sourceMappingURL=disposable.js.map