conductor-oss 0.3.4 → 0.4.0

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

@@ -0,0 +1,343 @@
+"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/web/.next/standalone/node_modules/ast-types/lib/path.js

@@ -0,0 +1,331 @@
+"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"];