antigravity-mobile-proxy 0.1.2 → 0.1.4

package/.next/standalone/node_modules/ast-types/lib/path-visitor.js

@@ -1,343 +0,0 @@
-"use strict";;
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var types_1 = tslib_1.__importDefault(require("./types"));
-var node_path_1 = tslib_1.__importDefault(require("./node-path"));
-var hasOwn = Object.prototype.hasOwnProperty;
-function pathVisitorPlugin(fork) {
-    var types = fork.use(types_1.default);
-    var NodePath = fork.use(node_path_1.default);
-    var isArray = types.builtInTypes.array;
-    var isObject = types.builtInTypes.object;
-    var isFunction = types.builtInTypes.function;
-    var undefined;
-    var PathVisitor = function PathVisitor() {
-        if (!(this instanceof PathVisitor)) {
-            throw new Error("PathVisitor constructor cannot be invoked without 'new'");
-        }
-        // Permanent state.
-        this._reusableContextStack = [];
-        this._methodNameTable = computeMethodNameTable(this);
-        this._shouldVisitComments =
-            hasOwn.call(this._methodNameTable, "Block") ||
-                hasOwn.call(this._methodNameTable, "Line");
-        this.Context = makeContextConstructor(this);
-        // State reset every time PathVisitor.prototype.visit is called.
-        this._visiting = false;
-        this._changeReported = false;
-    };
-    function computeMethodNameTable(visitor) {
-        var typeNames = Object.create(null);
-        for (var methodName in visitor) {
-            if (/^visit[A-Z]/.test(methodName)) {
-                typeNames[methodName.slice("visit".length)] = true;
-            }
-        }
-        var supertypeTable = types.computeSupertypeLookupTable(typeNames);
-        var methodNameTable = Object.create(null);
-        var typeNameKeys = Object.keys(supertypeTable);
-        var typeNameCount = typeNameKeys.length;
-        for (var i = 0; i < typeNameCount; ++i) {
-            var typeName = typeNameKeys[i];
-            methodName = "visit" + supertypeTable[typeName];
-            if (isFunction.check(visitor[methodName])) {
-                methodNameTable[typeName] = methodName;
-            }
-        }
-        return methodNameTable;
-    }
-    PathVisitor.fromMethodsObject = function fromMethodsObject(methods) {
-        if (methods instanceof PathVisitor) {
-            return methods;
-        }
-        if (!isObject.check(methods)) {
-            // An empty visitor?
-            return new PathVisitor;
-        }
-        var Visitor = function Visitor() {
-            if (!(this instanceof Visitor)) {
-                throw new Error("Visitor constructor cannot be invoked without 'new'");
-            }
-            PathVisitor.call(this);
-        };
-        var Vp = Visitor.prototype = Object.create(PVp);
-        Vp.constructor = Visitor;
-        extend(Vp, methods);
-        extend(Visitor, PathVisitor);
-        isFunction.assert(Visitor.fromMethodsObject);
-        isFunction.assert(Visitor.visit);
-        return new Visitor;
-    };
-    function extend(target, source) {
-        for (var property in source) {
-            if (hasOwn.call(source, property)) {
-                target[property] = source[property];
-            }
-        }
-        return target;
-    }
-    PathVisitor.visit = function visit(node, methods) {
-        return PathVisitor.fromMethodsObject(methods).visit(node);
-    };
-    var PVp = PathVisitor.prototype;
-    PVp.visit = function () {
-        if (this._visiting) {
-            throw new Error("Recursively calling visitor.visit(path) resets visitor state. " +
-                "Try this.visit(path) or this.traverse(path) instead.");
-        }
-        // Private state that needs to be reset before every traversal.
-        this._visiting = true;
-        this._changeReported = false;
-        this._abortRequested = false;
-        var argc = arguments.length;
-        var args = new Array(argc);
-        for (var i = 0; i < argc; ++i) {
-            args[i] = arguments[i];
-        }
-        if (!(args[0] instanceof NodePath)) {
-            args[0] = new NodePath({ root: args[0] }).get("root");
-        }
-        // Called with the same arguments as .visit.
-        this.reset.apply(this, args);
-        var didNotThrow;
-        try {
-            var root = this.visitWithoutReset(args[0]);
-            didNotThrow = true;
-        }
-        finally {
-            this._visiting = false;
-            if (!didNotThrow && this._abortRequested) {
-                // If this.visitWithoutReset threw an exception and
-                // this._abortRequested was set to true, return the root of
-                // the AST instead of letting the exception propagate, so that
-                // client code does not have to provide a try-catch block to
-                // intercept the AbortRequest exception.  Other kinds of
-                // exceptions will propagate without being intercepted and
-                // rethrown by a catch block, so their stacks will accurately
-                // reflect the original throwing context.
-                return args[0].value;
-            }
-        }
-        return root;
-    };
-    PVp.AbortRequest = function AbortRequest() { };
-    PVp.abort = function () {
-        var visitor = this;
-        visitor._abortRequested = true;
-        var request = new visitor.AbortRequest();
-        // If you decide to catch this exception and stop it from propagating,
-        // make sure to call its cancel method to avoid silencing other
-        // exceptions that might be thrown later in the traversal.
-        request.cancel = function () {
-            visitor._abortRequested = false;
-        };
-        throw request;
-    };
-    PVp.reset = function (_path /*, additional arguments */) {
-        // Empty stub; may be reassigned or overridden by subclasses.
-    };
-    PVp.visitWithoutReset = function (path) {
-        if (this instanceof this.Context) {
-            // Since this.Context.prototype === this, there's a chance we
-            // might accidentally call context.visitWithoutReset. If that
-            // happens, re-invoke the method against context.visitor.
-            return this.visitor.visitWithoutReset(path);
-        }
-        if (!(path instanceof NodePath)) {
-            throw new Error("");
-        }
-        var value = path.value;
-        var methodName = value &&
-            typeof value === "object" &&
-            typeof value.type === "string" &&
-            this._methodNameTable[value.type];
-        if (methodName) {
-            var context = this.acquireContext(path);
-            try {
-                return context.invokeVisitorMethod(methodName);
-            }
-            finally {
-                this.releaseContext(context);
-            }
-        }
-        else {
-            // If there was no visitor method to call, visit the children of
-            // this node generically.
-            return visitChildren(path, this);
-        }
-    };
-    function visitChildren(path, visitor) {
-        if (!(path instanceof NodePath)) {
-            throw new Error("");
-        }
-        if (!(visitor instanceof PathVisitor)) {
-            throw new Error("");
-        }
-        var value = path.value;
-        if (isArray.check(value)) {
-            path.each(visitor.visitWithoutReset, visitor);
-        }
-        else if (!isObject.check(value)) {
-            // No children to visit.
-        }
-        else {
-            var childNames = types.getFieldNames(value);
-            // The .comments field of the Node type is hidden, so we only
-            // visit it if the visitor defines visitBlock or visitLine, and
-            // value.comments is defined.
-            if (visitor._shouldVisitComments &&
-                value.comments &&
-                childNames.indexOf("comments") < 0) {
-                childNames.push("comments");
-            }
-            var childCount = childNames.length;
-            var childPaths = [];
-            for (var i = 0; i < childCount; ++i) {
-                var childName = childNames[i];
-                if (!hasOwn.call(value, childName)) {
-                    value[childName] = types.getFieldValue(value, childName);
-                }
-                childPaths.push(path.get(childName));
-            }
-            for (var i = 0; i < childCount; ++i) {
-                visitor.visitWithoutReset(childPaths[i]);
-            }
-        }
-        return path.value;
-    }
-    PVp.acquireContext = function (path) {
-        if (this._reusableContextStack.length === 0) {
-            return new this.Context(path);
-        }
-        return this._reusableContextStack.pop().reset(path);
-    };
-    PVp.releaseContext = function (context) {
-        if (!(context instanceof this.Context)) {
-            throw new Error("");
-        }
-        this._reusableContextStack.push(context);
-        context.currentPath = null;
-    };
-    PVp.reportChanged = function () {
-        this._changeReported = true;
-    };
-    PVp.wasChangeReported = function () {
-        return this._changeReported;
-    };
-    function makeContextConstructor(visitor) {
-        function Context(path) {
-            if (!(this instanceof Context)) {
-                throw new Error("");
-            }
-            if (!(this instanceof PathVisitor)) {
-                throw new Error("");
-            }
-            if (!(path instanceof NodePath)) {
-                throw new Error("");
-            }
-            Object.defineProperty(this, "visitor", {
-                value: visitor,
-                writable: false,
-                enumerable: true,
-                configurable: false
-            });
-            this.currentPath = path;
-            this.needToCallTraverse = true;
-            Object.seal(this);
-        }
-        if (!(visitor instanceof PathVisitor)) {
-            throw new Error("");
-        }
-        // Note that the visitor object is the prototype of Context.prototype,
-        // so all visitor methods are inherited by context objects.
-        var Cp = Context.prototype = Object.create(visitor);
-        Cp.constructor = Context;
-        extend(Cp, sharedContextProtoMethods);
-        return Context;
-    }
-    // Every PathVisitor has a different this.Context constructor and
-    // this.Context.prototype object, but those prototypes can all use the
-    // same reset, invokeVisitorMethod, and traverse function objects.
-    var sharedContextProtoMethods = Object.create(null);
-    sharedContextProtoMethods.reset =
-        function reset(path) {
-            if (!(this instanceof this.Context)) {
-                throw new Error("");
-            }
-            if (!(path instanceof NodePath)) {
-                throw new Error("");
-            }
-            this.currentPath = path;
-            this.needToCallTraverse = true;
-            return this;
-        };
-    sharedContextProtoMethods.invokeVisitorMethod =
-        function invokeVisitorMethod(methodName) {
-            if (!(this instanceof this.Context)) {
-                throw new Error("");
-            }
-            if (!(this.currentPath instanceof NodePath)) {
-                throw new Error("");
-            }
-            var result = this.visitor[methodName].call(this, this.currentPath);
-            if (result === false) {
-                // Visitor methods return false to indicate that they have handled
-                // their own traversal needs, and we should not complain if
-                // this.needToCallTraverse is still true.
-                this.needToCallTraverse = false;
-            }
-            else if (result !== undefined) {
-                // Any other non-undefined value returned from the visitor method
-                // is interpreted as a replacement value.
-                this.currentPath = this.currentPath.replace(result)[0];
-                if (this.needToCallTraverse) {
-                    // If this.traverse still hasn't been called, visit the
-                    // children of the replacement node.
-                    this.traverse(this.currentPath);
-                }
-            }
-            if (this.needToCallTraverse !== false) {
-                throw new Error("Must either call this.traverse or return false in " + methodName);
-            }
-            var path = this.currentPath;
-            return path && path.value;
-        };
-    sharedContextProtoMethods.traverse =
-        function traverse(path, newVisitor) {
-            if (!(this instanceof this.Context)) {
-                throw new Error("");
-            }
-            if (!(path instanceof NodePath)) {
-                throw new Error("");
-            }
-            if (!(this.currentPath instanceof NodePath)) {
-                throw new Error("");
-            }
-            this.needToCallTraverse = false;
-            return visitChildren(path, PathVisitor.fromMethodsObject(newVisitor || this.visitor));
-        };
-    sharedContextProtoMethods.visit =
-        function visit(path, newVisitor) {
-            if (!(this instanceof this.Context)) {
-                throw new Error("");
-            }
-            if (!(path instanceof NodePath)) {
-                throw new Error("");
-            }
-            if (!(this.currentPath instanceof NodePath)) {
-                throw new Error("");
-            }
-            this.needToCallTraverse = false;
-            return PathVisitor.fromMethodsObject(newVisitor || this.visitor).visitWithoutReset(path);
-        };
-    sharedContextProtoMethods.reportChanged = function reportChanged() {
-        this.visitor.reportChanged();
-    };
-    sharedContextProtoMethods.abort = function abort() {
-        this.needToCallTraverse = false;
-        this.visitor.abort();
-    };
-    return PathVisitor;
-}
-exports.default = pathVisitorPlugin;
-module.exports = exports["default"];

package/.next/standalone/node_modules/ast-types/lib/path.js

@@ -1,331 +0,0 @@
-"use strict";;
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var types_1 = tslib_1.__importDefault(require("./types"));
-var Op = Object.prototype;
-var hasOwn = Op.hasOwnProperty;
-function pathPlugin(fork) {
-    var types = fork.use(types_1.default);
-    var isArray = types.builtInTypes.array;
-    var isNumber = types.builtInTypes.number;
-    var Path = function Path(value, parentPath, name) {
-        if (!(this instanceof Path)) {
-            throw new Error("Path constructor cannot be invoked without 'new'");
-        }
-        if (parentPath) {
-            if (!(parentPath instanceof Path)) {
-                throw new Error("");
-            }
-        }
-        else {
-            parentPath = null;
-            name = null;
-        }
-        // The value encapsulated by this Path, generally equal to
-        // parentPath.value[name] if we have a parentPath.
-        this.value = value;
-        // The immediate parent Path of this Path.
-        this.parentPath = parentPath;
-        // The name of the property of parentPath.value through which this
-        // Path's value was reached.
-        this.name = name;
-        // Calling path.get("child") multiple times always returns the same
-        // child Path object, for both performance and consistency reasons.
-        this.__childCache = null;
-    };
-    var Pp = Path.prototype;
-    function getChildCache(path) {
-        // Lazily create the child cache. This also cheapens cache
-        // invalidation, since you can just reset path.__childCache to null.
-        return path.__childCache || (path.__childCache = Object.create(null));
-    }
-    function getChildPath(path, name) {
-        var cache = getChildCache(path);
-        var actualChildValue = path.getValueProperty(name);
-        var childPath = cache[name];
-        if (!hasOwn.call(cache, name) ||
-            // Ensure consistency between cache and reality.
-            childPath.value !== actualChildValue) {
-            childPath = cache[name] = new path.constructor(actualChildValue, path, name);
-        }
-        return childPath;
-    }
-    // This method is designed to be overridden by subclasses that need to
-    // handle missing properties, etc.
-    Pp.getValueProperty = function getValueProperty(name) {
-        return this.value[name];
-    };
-    Pp.get = function get() {
-        var names = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            names[_i] = arguments[_i];
-        }
-        var path = this;
-        var count = names.length;
-        for (var i = 0; i < count; ++i) {
-            path = getChildPath(path, names[i]);
-        }
-        return path;
-    };
-    Pp.each = function each(callback, context) {
-        var childPaths = [];
-        var len = this.value.length;
-        var i = 0;
-        // Collect all the original child paths before invoking the callback.
-        for (var i = 0; i < len; ++i) {
-            if (hasOwn.call(this.value, i)) {
-                childPaths[i] = this.get(i);
-            }
-        }
-        // Invoke the callback on just the original child paths, regardless of
-        // any modifications made to the array by the callback. I chose these
-        // semantics over cleverly invoking the callback on new elements because
-        // this way is much easier to reason about.
-        context = context || this;
-        for (i = 0; i < len; ++i) {
-            if (hasOwn.call(childPaths, i)) {
-                callback.call(context, childPaths[i]);
-            }
-        }
-    };
-    Pp.map = function map(callback, context) {
-        var result = [];
-        this.each(function (childPath) {
-            result.push(callback.call(this, childPath));
-        }, context);
-        return result;
-    };
-    Pp.filter = function filter(callback, context) {
-        var result = [];
-        this.each(function (childPath) {
-            if (callback.call(this, childPath)) {
-                result.push(childPath);
-            }
-        }, context);
-        return result;
-    };
-    function emptyMoves() { }
-    function getMoves(path, offset, start, end) {
-        isArray.assert(path.value);
-        if (offset === 0) {
-            return emptyMoves;
-        }
-        var length = path.value.length;
-        if (length < 1) {
-            return emptyMoves;
-        }
-        var argc = arguments.length;
-        if (argc === 2) {
-            start = 0;
-            end = length;
-        }
-        else if (argc === 3) {
-            start = Math.max(start, 0);
-            end = length;
-        }
-        else {
-            start = Math.max(start, 0);
-            end = Math.min(end, length);
-        }
-        isNumber.assert(start);
-        isNumber.assert(end);
-        var moves = Object.create(null);
-        var cache = getChildCache(path);
-        for (var i = start; i < end; ++i) {
-            if (hasOwn.call(path.value, i)) {
-                var childPath = path.get(i);
-                if (childPath.name !== i) {
-                    throw new Error("");
-                }
-                var newIndex = i + offset;
-                childPath.name = newIndex;
-                moves[newIndex] = childPath;
-                delete cache[i];
-            }
-        }
-        delete cache.length;
-        return function () {
-            for (var newIndex in moves) {
-                var childPath = moves[newIndex];
-                if (childPath.name !== +newIndex) {
-                    throw new Error("");
-                }
-                cache[newIndex] = childPath;
-                path.value[newIndex] = childPath.value;
-            }
-        };
-    }
-    Pp.shift = function shift() {
-        var move = getMoves(this, -1);
-        var result = this.value.shift();
-        move();
-        return result;
-    };
-    Pp.unshift = function unshift() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var move = getMoves(this, args.length);
-        var result = this.value.unshift.apply(this.value, args);
-        move();
-        return result;
-    };
-    Pp.push = function push() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        isArray.assert(this.value);
-        delete getChildCache(this).length;
-        return this.value.push.apply(this.value, args);
-    };
-    Pp.pop = function pop() {
-        isArray.assert(this.value);
-        var cache = getChildCache(this);
-        delete cache[this.value.length - 1];
-        delete cache.length;
-        return this.value.pop();
-    };
-    Pp.insertAt = function insertAt(index) {
-        var argc = arguments.length;
-        var move = getMoves(this, argc - 1, index);
-        if (move === emptyMoves && argc <= 1) {
-            return this;
-        }
-        index = Math.max(index, 0);
-        for (var i = 1; i < argc; ++i) {
-            this.value[index + i - 1] = arguments[i];
-        }
-        move();
-        return this;
-    };
-    Pp.insertBefore = function insertBefore() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var pp = this.parentPath;
-        var argc = args.length;
-        var insertAtArgs = [this.name];
-        for (var i = 0; i < argc; ++i) {
-            insertAtArgs.push(args[i]);
-        }
-        return pp.insertAt.apply(pp, insertAtArgs);
-    };
-    Pp.insertAfter = function insertAfter() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var pp = this.parentPath;
-        var argc = args.length;
-        var insertAtArgs = [this.name + 1];
-        for (var i = 0; i < argc; ++i) {
-            insertAtArgs.push(args[i]);
-        }
-        return pp.insertAt.apply(pp, insertAtArgs);
-    };
-    function repairRelationshipWithParent(path) {
-        if (!(path instanceof Path)) {
-            throw new Error("");
-        }
-        var pp = path.parentPath;
-        if (!pp) {
-            // Orphan paths have no relationship to repair.
-            return path;
-        }
-        var parentValue = pp.value;
-        var parentCache = getChildCache(pp);
-        // Make sure parentCache[path.name] is populated.
-        if (parentValue[path.name] === path.value) {
-            parentCache[path.name] = path;
-        }
-        else if (isArray.check(parentValue)) {
-            // Something caused path.name to become out of date, so attempt to
-            // recover by searching for path.value in parentValue.
-            var i = parentValue.indexOf(path.value);
-            if (i >= 0) {
-                parentCache[path.name = i] = path;
-            }
-        }
-        else {
-            // If path.value disagrees with parentValue[path.name], and
-            // path.name is not an array index, let path.value become the new
-            // parentValue[path.name] and update parentCache accordingly.
-            parentValue[path.name] = path.value;
-            parentCache[path.name] = path;
-        }
-        if (parentValue[path.name] !== path.value) {
-            throw new Error("");
-        }
-        if (path.parentPath.get(path.name) !== path) {
-            throw new Error("");
-        }
-        return path;
-    }
-    Pp.replace = function replace(replacement) {
-        var results = [];
-        var parentValue = this.parentPath.value;
-        var parentCache = getChildCache(this.parentPath);
-        var count = arguments.length;
-        repairRelationshipWithParent(this);
-        if (isArray.check(parentValue)) {
-            var originalLength = parentValue.length;
-            var move = getMoves(this.parentPath, count - 1, this.name + 1);
-            var spliceArgs = [this.name, 1];
-            for (var i = 0; i < count; ++i) {
-                spliceArgs.push(arguments[i]);
-            }
-            var splicedOut = parentValue.splice.apply(parentValue, spliceArgs);
-            if (splicedOut[0] !== this.value) {
-                throw new Error("");
-            }
-            if (parentValue.length !== (originalLength - 1 + count)) {
-                throw new Error("");
-            }
-            move();
-            if (count === 0) {
-                delete this.value;
-                delete parentCache[this.name];
-                this.__childCache = null;
-            }
-            else {
-                if (parentValue[this.name] !== replacement) {
-                    throw new Error("");
-                }
-                if (this.value !== replacement) {
-                    this.value = replacement;
-                    this.__childCache = null;
-                }
-                for (i = 0; i < count; ++i) {
-                    results.push(this.parentPath.get(this.name + i));
-                }
-                if (results[0] !== this) {
-                    throw new Error("");
-                }
-            }
-        }
-        else if (count === 1) {
-            if (this.value !== replacement) {
-                this.__childCache = null;
-            }
-            this.value = parentValue[this.name] = replacement;
-            results.push(this);
-        }
-        else if (count === 0) {
-            delete parentValue[this.name];
-            delete this.value;
-            this.__childCache = null;
-            // Leave this path cached as parentCache[this.name], even though
-            // it no longer has a value defined.
-        }
-        else {
-            throw new Error("Could not replace path");
-        }
-        return results;
-    };
-    return Path;
-}
-exports.default = pathPlugin;
-module.exports = exports["default"];