antigravity-mobile-proxy 0.1.2 → 0.1.4

package/.next/standalone/node_modules/basic-ftp/dist/FileInfo.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileInfo = exports.FileType = void 0;
-var FileType;
-(function (FileType) {
-    FileType[FileType["Unknown"] = 0] = "Unknown";
-    FileType[FileType["File"] = 1] = "File";
-    FileType[FileType["Directory"] = 2] = "Directory";
-    FileType[FileType["SymbolicLink"] = 3] = "SymbolicLink";
-})(FileType || (exports.FileType = FileType = {}));
-/**
- * Describes a file, directory or symbolic link.
- */
-class FileInfo {
-    constructor(name) {
-        this.name = name;
-        this.type = FileType.Unknown;
-        this.size = 0;
-        /**
-         * Unparsed, raw modification date as a string.
-         *
-         * If `modifiedAt` is undefined, the FTP server you're connected to doesn't support the more modern
-         * MLSD command for machine-readable directory listings. The older command LIST is then used returning
-         * results that vary a lot between servers as the format hasn't been standardized. Here, directory listings
-         * and especially modification dates were meant to be human-readable first.
-         *
-         * Be careful when still trying to parse this by yourself. Parsing dates from listings using LIST is
-         * unreliable. This library decides to offer parsed dates only when they're absolutely reliable and safe to
-         * use e.g. for comparisons.
-         */
-        this.rawModifiedAt = "";
-        /**
-         * Parsed modification date.
-         *
-         * Available if the FTP server supports the MLSD command. Only MLSD guarantees dates than can be reliably
-         * parsed with the correct timezone and a resolution down to seconds. See `rawModifiedAt` property for the unparsed
-         * date that is always available.
-         */
-        this.modifiedAt = undefined;
-        /**
-         * Unix permissions if present. If the underlying FTP server is not running on Unix this will be undefined.
-         * If set, you might be able to edit permissions with the FTP command `SITE CHMOD`.
-         */
-        this.permissions = undefined;
-        /**
-         * Hard link count if available.
-         */
-        this.hardLinkCount = undefined;
-        /**
-         * Link name for symbolic links if available.
-         */
-        this.link = undefined;
-        /**
-         * Unix group if available.
-         */
-        this.group = undefined;
-        /**
-         * Unix user if available.
-         */
-        this.user = undefined;
-        /**
-         * Unique ID if available.
-         */
-        this.uniqueID = undefined;
-        this.name = name;
-    }
-    get isDirectory() {
-        return this.type === FileType.Directory;
-    }
-    get isSymbolicLink() {
-        return this.type === FileType.SymbolicLink;
-    }
-    get isFile() {
-        return this.type === FileType.File;
-    }
-    /**
-     * Deprecated, legacy API. Use `rawModifiedAt` instead.
-     * @deprecated
-     */
-    get date() {
-        return this.rawModifiedAt;
-    }
-    set date(rawModifiedAt) {
-        this.rawModifiedAt = rawModifiedAt;
-    }
-}
-exports.FileInfo = FileInfo;
-FileInfo.UnixPermission = {
-    Read: 4,
-    Write: 2,
-    Execute: 1
-};

package/.next/standalone/node_modules/basic-ftp/dist/FtpContext.js

@@ -1,365 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FTPContext = exports.FTPError = void 0;
-const net_1 = require("net");
-const parseControlResponse_1 = require("./parseControlResponse");
-/**
- * Describes an FTP server error response including the FTP response code.
- */
-class FTPError extends Error {
-    constructor(res) {
-        super(res.message);
-        this.name = this.constructor.name;
-        this.code = res.code;
-    }
-}
-exports.FTPError = FTPError;
-function doNothing() {
-    /** Do nothing */
-}
-/**
- * FTPContext holds the control and data sockets of an FTP connection and provides a
- * simplified way to interact with an FTP server, handle responses, errors and timeouts.
- *
- * It doesn't implement or use any FTP commands. It's only a foundation to make writing an FTP
- * client as easy as possible. You won't usually instantiate this, but use `Client`.
- */
-class FTPContext {
-    /**
-     * Instantiate an FTP context.
-     *
-     * @param timeout - Timeout in milliseconds to apply to control and data connections. Use 0 for no timeout.
-     * @param encoding - Encoding to use for control connection. UTF-8 by default. Use "latin1" for older servers.
-     */
-    constructor(timeout = 0, encoding = "utf8") {
-        this.timeout = timeout;
-        /** Debug-level logging of all socket communication. */
-        this.verbose = false;
-        /** IP version to prefer (4: IPv4, 6: IPv6, undefined: automatic). */
-        this.ipFamily = undefined;
-        /** Options for TLS connections. */
-        this.tlsOptions = {};
-        /** A multiline response might be received as multiple chunks. */
-        this._partialResponse = "";
-        this._encoding = encoding;
-        // Help Typescript understand that we do indeed set _socket in the constructor but use the setter method to do so.
-        this._socket = this.socket = this._newSocket();
-        this._dataSocket = undefined;
-    }
-    /**
-     * Close the context.
-     */
-    close() {
-        // Internally, closing a context is always described with an error. If there is still a task running, it will
-        // abort with an exception that the user closed the client during a task. If no task is running, no exception is
-        // thrown but all newly submitted tasks after that will abort the exception that the client has been closed.
-        // In addition the user will get a stack trace pointing to where exactly the client has been closed. So in any
-        // case use _closingError to determine whether a context is closed. This also allows us to have a single code-path
-        // for closing a context making the implementation easier.
-        const message = this._task ? "User closed client during task" : "User closed client";
-        const err = new Error(message);
-        this.closeWithError(err);
-    }
-    /**
-     * Close the context with an error.
-     */
-    closeWithError(err) {
-        // If this context already has been closed, don't overwrite the reason.
-        if (this._closingError) {
-            return;
-        }
-        this._closingError = err;
-        // Close the sockets but don't fully reset this context to preserve `this._closingError`.
-        this._closeControlSocket();
-        this._closeSocket(this._dataSocket);
-        // Give the user's task a chance to react, maybe cleanup resources.
-        this._passToHandler(err);
-        // The task might not have been rejected by the user after receiving the error.
-        this._stopTrackingTask();
-    }
-    /**
-     * Returns true if this context has been closed or hasn't been connected yet. You can reopen it with `access`.
-     */
-    get closed() {
-        return this.socket.remoteAddress === undefined || this._closingError !== undefined;
-    }
-    /**
-     * Reset this contex and all of its state.
-     */
-    reset() {
-        this.socket = this._newSocket();
-    }
-    /**
-     * Get the FTP control socket.
-     */
-    get socket() {
-        return this._socket;
-    }
-    /**
-     * Set the socket for the control connection. This will only close the current control socket
-     * if the new one is not an upgrade to the current one.
-     */
-    set socket(socket) {
-        // No data socket should be open in any case where the control socket is set or upgraded.
-        this.dataSocket = undefined;
-        // This being a reset, reset any other state apart from the socket.
-        this.tlsOptions = {};
-        this._partialResponse = "";
-        if (this._socket) {
-            const newSocketUpgradesExisting = socket.localPort === this._socket.localPort;
-            if (newSocketUpgradesExisting) {
-                this._removeSocketListeners(this.socket);
-            }
-            else {
-                this._closeControlSocket();
-            }
-        }
-        if (socket) {
-            // Setting a completely new control socket is in essence something like a reset. That's
-            // why we also close any open data connection above. We can go one step further and reset
-            // a possible closing error. That means that a closed FTPContext can be "reopened" by
-            // setting a new control socket.
-            this._closingError = undefined;
-            // Don't set a timeout yet. Timeout for control sockets is only active during a task, see handle() below.
-            socket.setTimeout(0);
-            socket.setEncoding(this._encoding);
-            socket.setKeepAlive(true);
-            socket.on("data", data => this._onControlSocketData(data));
-            // Server sending a FIN packet is treated as an error.
-            socket.on("end", () => this.closeWithError(new Error("Server sent FIN packet unexpectedly, closing connection.")));
-            // Control being closed without error by server is treated as an error.
-            socket.on("close", hadError => { if (!hadError)
-                this.closeWithError(new Error("Server closed connection unexpectedly.")); });
-            this._setupDefaultErrorHandlers(socket, "control socket");
-        }
-        this._socket = socket;
-    }
-    /**
-     * Get the current FTP data connection if present.
-     */
-    get dataSocket() {
-        return this._dataSocket;
-    }
-    /**
-     * Set the socket for the data connection. This will automatically close the former data socket.
-     */
-    set dataSocket(socket) {
-        this._closeSocket(this._dataSocket);
-        if (socket) {
-            // Don't set a timeout yet. Timeout data socket should be activated when data transmission starts
-            // and timeout on control socket is deactivated.
-            socket.setTimeout(0);
-            this._setupDefaultErrorHandlers(socket, "data socket");
-        }
-        this._dataSocket = socket;
-    }
-    /**
-     * Get the currently used encoding.
-     */
-    get encoding() {
-        return this._encoding;
-    }
-    /**
-     * Set the encoding used for the control socket.
-     *
-     * See https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings for what encodings
-     * are supported by Node.
-     */
-    set encoding(encoding) {
-        this._encoding = encoding;
-        if (this.socket) {
-            this.socket.setEncoding(encoding);
-        }
-    }
-    /**
-     * Send an FTP command without waiting for or handling the result.
-     */
-    send(command) {
-        const containsPassword = command.startsWith("PASS");
-        const message = containsPassword ? "> PASS ###" : `> ${command}`;
-        this.log(message);
-        this._socket.write(command + "\r\n", this.encoding);
-    }
-    /**
-     * Send an FTP command and handle the first response. Use this if you have a simple
-     * request-response situation.
-     */
-    request(command) {
-        return this.handle(command, (res, task) => {
-            if (res instanceof Error) {
-                task.reject(res);
-            }
-            else {
-                task.resolve(res);
-            }
-        });
-    }
-    /**
-     * Send an FTP command and handle any response until you resolve/reject. Use this if you expect multiple responses
-     * to a request. This returns a Promise that will hold whatever the response handler passed on when resolving/rejecting its task.
-     */
-    handle(command, responseHandler) {
-        if (this._task) {
-            const err = new Error("User launched a task while another one is still running. Forgot to use 'await' or '.then()'?");
-            err.stack += `\nRunning task launched at: ${this._task.stack}`;
-            this.closeWithError(err);
-            // Don't return here, continue with returning the Promise that will then be rejected
-            // because the context closed already. That way, users will receive an exception where
-            // they called this method by mistake.
-        }
-        return new Promise((resolveTask, rejectTask) => {
-            this._task = {
-                stack: new Error().stack || "Unknown call stack",
-                responseHandler,
-                resolver: {
-                    resolve: arg => {
-                        this._stopTrackingTask();
-                        resolveTask(arg);
-                    },
-                    reject: err => {
-                        this._stopTrackingTask();
-                        rejectTask(err);
-                    }
-                }
-            };
-            if (this._closingError) {
-                // This client has been closed. Provide an error that describes this one as being caused
-                // by `_closingError`, include stack traces for both.
-                const err = new Error(`Client is closed because ${this._closingError.message}`); // Type 'Error' is not correctly defined, doesn't have 'code'.
-                err.stack += `\nClosing reason: ${this._closingError.stack}`;
-                err.code = this._closingError.code !== undefined ? this._closingError.code : "0";
-                this._passToHandler(err);
-                return;
-            }
-            // Only track control socket timeout during the lifecycle of a task. This avoids timeouts on idle sockets,
-            // the default socket behaviour which is not expected by most users.
-            this.socket.setTimeout(this.timeout);
-            if (command) {
-                this.send(command);
-            }
-        });
-    }
-    /**
-     * Log message if set to be verbose.
-     */
-    log(message) {
-        if (this.verbose) {
-            // tslint:disable-next-line no-console
-            console.log(message);
-        }
-    }
-    /**
-     * Return true if the control socket is using TLS. This does not mean that a session
-     * has already been negotiated.
-     */
-    get hasTLS() {
-        return "encrypted" in this._socket;
-    }
-    /**
-     * Removes reference to current task and handler. This won't resolve or reject the task.
-     * @protected
-     */
-    _stopTrackingTask() {
-        // Disable timeout on control socket if there is no task active.
-        this.socket.setTimeout(0);
-        this._task = undefined;
-    }
-    /**
-     * Handle incoming data on the control socket. The chunk is going to be of type `string`
-     * because we let `socket` handle encoding with `setEncoding`.
-     * @protected
-     */
-    _onControlSocketData(chunk) {
-        this.log(`< ${chunk}`);
-        // This chunk might complete an earlier partial response.
-        const completeResponse = this._partialResponse + chunk;
-        const parsed = (0, parseControlResponse_1.parseControlResponse)(completeResponse);
-        // Remember any incomplete remainder.
-        this._partialResponse = parsed.rest;
-        // Each response group is passed along individually.
-        for (const message of parsed.messages) {
-            const code = parseInt(message.substr(0, 3), 10);
-            const response = { code, message };
-            const err = code >= 400 ? new FTPError(response) : undefined;
-            this._passToHandler(err ? err : response);
-        }
-    }
-    /**
-     * Send the current handler a response. This is usually a control socket response
-     * or a socket event, like an error or timeout.
-     * @protected
-     */
-    _passToHandler(response) {
-        if (this._task) {
-            this._task.responseHandler(response, this._task.resolver);
-        }
-        // Errors other than FTPError always close the client. If there isn't an active task to handle the error,
-        // the next one submitted will receive it using `_closingError`.
-        // There is only one edge-case: If there is an FTPError while no task is active, the error will be dropped.
-        // But that means that the user sent an FTP command with no intention of handling the result. So why should the
-        // error be handled? Maybe log it at least? Debug logging will already do that and the client stays useable after
-        // FTPError. So maybe no need to do anything here.
-    }
-    /**
-     * Setup all error handlers for a socket.
-     * @protected
-     */
-    _setupDefaultErrorHandlers(socket, identifier) {
-        socket.once("error", error => {
-            error.message += ` (${identifier})`;
-            this.closeWithError(error);
-        });
-        socket.once("close", hadError => {
-            if (hadError) {
-                this.closeWithError(new Error(`Socket closed due to transmission error (${identifier})`));
-            }
-        });
-        socket.once("timeout", () => {
-            socket.destroy();
-            this.closeWithError(new Error(`Timeout (${identifier})`));
-        });
-    }
-    /**
-     * Close the control socket. Sends QUIT, then FIN, and ignores any response or error.
-     */
-    _closeControlSocket() {
-        this._removeSocketListeners(this._socket);
-        this._socket.on("error", doNothing);
-        this.send("QUIT");
-        this._closeSocket(this._socket);
-    }
-    /**
-     * Close a socket, ignores any error.
-     * @protected
-     */
-    _closeSocket(socket) {
-        if (socket) {
-            this._removeSocketListeners(socket);
-            socket.on("error", doNothing);
-            socket.destroy();
-        }
-    }
-    /**
-     * Remove all default listeners for socket.
-     * @protected
-     */
-    _removeSocketListeners(socket) {
-        socket.removeAllListeners();
-        // Before Node.js 10.3.0, using `socket.removeAllListeners()` without any name did not work: https://github.com/nodejs/node/issues/20923.
-        socket.removeAllListeners("timeout");
-        socket.removeAllListeners("data");
-        socket.removeAllListeners("end");
-        socket.removeAllListeners("error");
-        socket.removeAllListeners("close");
-        socket.removeAllListeners("connect");
-    }
-    /**
-     * Provide a new socket instance.
-     *
-     * Internal use only, replaced for unit tests.
-     */
-    _newSocket() {
-        return new net_1.Socket();
-    }
-}
-exports.FTPContext = FTPContext;

package/.next/standalone/node_modules/basic-ftp/dist/ProgressTracker.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProgressTracker = void 0;
-/**
- * Tracks progress of one socket data transfer at a time.
- */
-class ProgressTracker {
-    constructor() {
-        this.bytesOverall = 0;
-        this.intervalMs = 500;
-        this.onStop = noop;
-        this.onHandle = noop;
-    }
-    /**
-     * Register a new handler for progress info. Use `undefined` to disable reporting.
-     */
-    reportTo(onHandle = noop) {
-        this.onHandle = onHandle;
-    }
-    /**
-     * Start tracking transfer progress of a socket.
-     *
-     * @param socket  The socket to observe.
-     * @param name  A name associated with this progress tracking, e.g. a filename.
-     * @param type  The type of the transfer, typically "upload" or "download".
-     */
-    start(socket, name, type) {
-        let lastBytes = 0;
-        this.onStop = poll(this.intervalMs, () => {
-            const bytes = socket.bytesRead + socket.bytesWritten;
-            this.bytesOverall += bytes - lastBytes;
-            lastBytes = bytes;
-            this.onHandle({
-                name,
-                type,
-                bytes,
-                bytesOverall: this.bytesOverall
-            });
-        });
-    }
-    /**
-     * Stop tracking transfer progress.
-     */
-    stop() {
-        this.onStop(false);
-    }
-    /**
-     * Call the progress handler one more time, then stop tracking.
-     */
-    updateAndStop() {
-        this.onStop(true);
-    }
-}
-exports.ProgressTracker = ProgressTracker;
-/**
- * Starts calling a callback function at a regular interval. The first call will go out
- * immediately. The function returns a function to stop the polling.
- */
-function poll(intervalMs, updateFunc) {
-    const id = setInterval(updateFunc, intervalMs);
-    const stopFunc = (stopWithUpdate) => {
-        clearInterval(id);
-        if (stopWithUpdate) {
-            updateFunc();
-        }
-        // Prevent repeated calls to stop calling handler.
-        updateFunc = noop;
-    };
-    updateFunc();
-    return stopFunc;
-}
-function noop() { }

package/.next/standalone/node_modules/basic-ftp/dist/StringEncoding.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/.next/standalone/node_modules/basic-ftp/dist/StringWriter.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringWriter = void 0;
-const stream_1 = require("stream");
-class StringWriter extends stream_1.Writable {
-    constructor() {
-        super(...arguments);
-        this.buf = Buffer.alloc(0);
-    }
-    _write(chunk, _, callback) {
-        if (chunk instanceof Buffer) {
-            this.buf = Buffer.concat([this.buf, chunk]);
-            callback(null);
-        }
-        else {
-            callback(new Error("StringWriter expects chunks of type 'Buffer'."));
-        }
-    }
-    getText(encoding) {
-        return this.buf.toString(encoding);
-    }
-}
-exports.StringWriter = StringWriter;

package/.next/standalone/node_modules/basic-ftp/dist/index.js

@@ -1,28 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.enterPassiveModeIPv6 = exports.enterPassiveModeIPv4 = void 0;
-/**
- * Public API
- */
-__exportStar(require("./Client"), exports);
-__exportStar(require("./FtpContext"), exports);
-__exportStar(require("./FileInfo"), exports);
-__exportStar(require("./parseList"), exports);
-__exportStar(require("./StringEncoding"), exports);
-var transfer_1 = require("./transfer");
-Object.defineProperty(exports, "enterPassiveModeIPv4", { enumerable: true, get: function () { return transfer_1.enterPassiveModeIPv4; } });
-Object.defineProperty(exports, "enterPassiveModeIPv6", { enumerable: true, get: function () { return transfer_1.enterPassiveModeIPv6; } });

package/.next/standalone/node_modules/basic-ftp/dist/netUtils.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.describeTLS = describeTLS;
-exports.describeAddress = describeAddress;
-exports.upgradeSocket = upgradeSocket;
-exports.ipIsPrivateV4Address = ipIsPrivateV4Address;
-const tls_1 = require("tls");
-/**
- * Returns a string describing the encryption on a given socket instance.
- */
-function describeTLS(socket) {
-    if (socket instanceof tls_1.TLSSocket) {
-        const protocol = socket.getProtocol();
-        return protocol ? protocol : "Server socket or disconnected client socket";
-    }
-    return "No encryption";
-}
-/**
- * Returns a string describing the remote address of a socket.
- */
-function describeAddress(socket) {
-    if (socket.remoteFamily === "IPv6") {
-        return `[${socket.remoteAddress}]:${socket.remotePort}`;
-    }
-    return `${socket.remoteAddress}:${socket.remotePort}`;
-}
-/**
- * Upgrade a socket connection with TLS.
- */
-function upgradeSocket(socket, options) {
-    return new Promise((resolve, reject) => {
-        const tlsOptions = Object.assign({}, options, {
-            socket
-        });
-        const tlsSocket = (0, tls_1.connect)(tlsOptions, () => {
-            const expectCertificate = tlsOptions.rejectUnauthorized !== false;
-            if (expectCertificate && !tlsSocket.authorized) {
-                reject(tlsSocket.authorizationError);
-            }
-            else {
-                // Remove error listener added below.
-                tlsSocket.removeAllListeners("error");
-                resolve(tlsSocket);
-            }
-        }).once("error", error => {
-            reject(error);
-        });
-    });
-}
-/**
- * Returns true if an IP is a private address according to https://tools.ietf.org/html/rfc1918#section-3.
- * This will handle IPv4-mapped IPv6 addresses correctly but return false for all other IPv6 addresses.
- *
- * @param ip  The IP as a string, e.g. "192.168.0.1"
- */
-function ipIsPrivateV4Address(ip = "") {
-    // Handle IPv4-mapped IPv6 addresses like ::ffff:192.168.0.1
-    if (ip.startsWith("::ffff:")) {
-        ip = ip.substr(7); // Strip ::ffff: prefix
-    }
-    const octets = ip.split(".").map(o => parseInt(o, 10));
-    return octets[0] === 10 // 10.0.0.0 - 10.255.255.255
-        || (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31) // 172.16.0.0 - 172.31.255.255
-        || (octets[0] === 192 && octets[1] === 168) // 192.168.0.0 - 192.168.255.255
-        || ip === "127.0.0.1";
-}