@whoj/eslint-config 2.2.1 → 2.2.2

package/dist/chunk-DLJMV7EV.js

@@ -1,626 +0,0 @@
-import {
-  __commonJS,
-  init_esm_shims
-} from "./chunk-MKNYKNDN.js";
-
-// node_modules/.pnpm/estraverse@5.3.0/node_modules/estraverse/estraverse.js
-var require_estraverse = __commonJS({
-  "node_modules/.pnpm/estraverse@5.3.0/node_modules/estraverse/estraverse.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    (function clone(exports2) {
-      "use strict";
-      var Syntax, VisitorOption, VisitorKeys, BREAK, SKIP, REMOVE;
-      function deepCopy(obj) {
-        var ret = {}, key, val;
-        for (key in obj) {
-          if (obj.hasOwnProperty(key)) {
-            val = obj[key];
-            if (typeof val === "object" && val !== null) {
-              ret[key] = deepCopy(val);
-            } else {
-              ret[key] = val;
-            }
-          }
-        }
-        return ret;
-      }
-      function upperBound(array, func) {
-        var diff, len, i, current;
-        len = array.length;
-        i = 0;
-        while (len) {
-          diff = len >>> 1;
-          current = i + diff;
-          if (func(array[current])) {
-            len = diff;
-          } else {
-            i = current + 1;
-            len -= diff + 1;
-          }
-        }
-        return i;
-      }
-      Syntax = {
-        AssignmentExpression: "AssignmentExpression",
-        AssignmentPattern: "AssignmentPattern",
-        ArrayExpression: "ArrayExpression",
-        ArrayPattern: "ArrayPattern",
-        ArrowFunctionExpression: "ArrowFunctionExpression",
-        AwaitExpression: "AwaitExpression",
-        // CAUTION: It's deferred to ES7.
-        BlockStatement: "BlockStatement",
-        BinaryExpression: "BinaryExpression",
-        BreakStatement: "BreakStatement",
-        CallExpression: "CallExpression",
-        CatchClause: "CatchClause",
-        ChainExpression: "ChainExpression",
-        ClassBody: "ClassBody",
-        ClassDeclaration: "ClassDeclaration",
-        ClassExpression: "ClassExpression",
-        ComprehensionBlock: "ComprehensionBlock",
-        // CAUTION: It's deferred to ES7.
-        ComprehensionExpression: "ComprehensionExpression",
-        // CAUTION: It's deferred to ES7.
-        ConditionalExpression: "ConditionalExpression",
-        ContinueStatement: "ContinueStatement",
-        DebuggerStatement: "DebuggerStatement",
-        DirectiveStatement: "DirectiveStatement",
-        DoWhileStatement: "DoWhileStatement",
-        EmptyStatement: "EmptyStatement",
-        ExportAllDeclaration: "ExportAllDeclaration",
-        ExportDefaultDeclaration: "ExportDefaultDeclaration",
-        ExportNamedDeclaration: "ExportNamedDeclaration",
-        ExportSpecifier: "ExportSpecifier",
-        ExpressionStatement: "ExpressionStatement",
-        ForStatement: "ForStatement",
-        ForInStatement: "ForInStatement",
-        ForOfStatement: "ForOfStatement",
-        FunctionDeclaration: "FunctionDeclaration",
-        FunctionExpression: "FunctionExpression",
-        GeneratorExpression: "GeneratorExpression",
-        // CAUTION: It's deferred to ES7.
-        Identifier: "Identifier",
-        IfStatement: "IfStatement",
-        ImportExpression: "ImportExpression",
-        ImportDeclaration: "ImportDeclaration",
-        ImportDefaultSpecifier: "ImportDefaultSpecifier",
-        ImportNamespaceSpecifier: "ImportNamespaceSpecifier",
-        ImportSpecifier: "ImportSpecifier",
-        Literal: "Literal",
-        LabeledStatement: "LabeledStatement",
-        LogicalExpression: "LogicalExpression",
-        MemberExpression: "MemberExpression",
-        MetaProperty: "MetaProperty",
-        MethodDefinition: "MethodDefinition",
-        ModuleSpecifier: "ModuleSpecifier",
-        NewExpression: "NewExpression",
-        ObjectExpression: "ObjectExpression",
-        ObjectPattern: "ObjectPattern",
-        PrivateIdentifier: "PrivateIdentifier",
-        Program: "Program",
-        Property: "Property",
-        PropertyDefinition: "PropertyDefinition",
-        RestElement: "RestElement",
-        ReturnStatement: "ReturnStatement",
-        SequenceExpression: "SequenceExpression",
-        SpreadElement: "SpreadElement",
-        Super: "Super",
-        SwitchStatement: "SwitchStatement",
-        SwitchCase: "SwitchCase",
-        TaggedTemplateExpression: "TaggedTemplateExpression",
-        TemplateElement: "TemplateElement",
-        TemplateLiteral: "TemplateLiteral",
-        ThisExpression: "ThisExpression",
-        ThrowStatement: "ThrowStatement",
-        TryStatement: "TryStatement",
-        UnaryExpression: "UnaryExpression",
-        UpdateExpression: "UpdateExpression",
-        VariableDeclaration: "VariableDeclaration",
-        VariableDeclarator: "VariableDeclarator",
-        WhileStatement: "WhileStatement",
-        WithStatement: "WithStatement",
-        YieldExpression: "YieldExpression"
-      };
-      VisitorKeys = {
-        AssignmentExpression: ["left", "right"],
-        AssignmentPattern: ["left", "right"],
-        ArrayExpression: ["elements"],
-        ArrayPattern: ["elements"],
-        ArrowFunctionExpression: ["params", "body"],
-        AwaitExpression: ["argument"],
-        // CAUTION: It's deferred to ES7.
-        BlockStatement: ["body"],
-        BinaryExpression: ["left", "right"],
-        BreakStatement: ["label"],
-        CallExpression: ["callee", "arguments"],
-        CatchClause: ["param", "body"],
-        ChainExpression: ["expression"],
-        ClassBody: ["body"],
-        ClassDeclaration: ["id", "superClass", "body"],
-        ClassExpression: ["id", "superClass", "body"],
-        ComprehensionBlock: ["left", "right"],
-        // CAUTION: It's deferred to ES7.
-        ComprehensionExpression: ["blocks", "filter", "body"],
-        // CAUTION: It's deferred to ES7.
-        ConditionalExpression: ["test", "consequent", "alternate"],
-        ContinueStatement: ["label"],
-        DebuggerStatement: [],
-        DirectiveStatement: [],
-        DoWhileStatement: ["body", "test"],
-        EmptyStatement: [],
-        ExportAllDeclaration: ["source"],
-        ExportDefaultDeclaration: ["declaration"],
-        ExportNamedDeclaration: ["declaration", "specifiers", "source"],
-        ExportSpecifier: ["exported", "local"],
-        ExpressionStatement: ["expression"],
-        ForStatement: ["init", "test", "update", "body"],
-        ForInStatement: ["left", "right", "body"],
-        ForOfStatement: ["left", "right", "body"],
-        FunctionDeclaration: ["id", "params", "body"],
-        FunctionExpression: ["id", "params", "body"],
-        GeneratorExpression: ["blocks", "filter", "body"],
-        // CAUTION: It's deferred to ES7.
-        Identifier: [],
-        IfStatement: ["test", "consequent", "alternate"],
-        ImportExpression: ["source"],
-        ImportDeclaration: ["specifiers", "source"],
-        ImportDefaultSpecifier: ["local"],
-        ImportNamespaceSpecifier: ["local"],
-        ImportSpecifier: ["imported", "local"],
-        Literal: [],
-        LabeledStatement: ["label", "body"],
-        LogicalExpression: ["left", "right"],
-        MemberExpression: ["object", "property"],
-        MetaProperty: ["meta", "property"],
-        MethodDefinition: ["key", "value"],
-        ModuleSpecifier: [],
-        NewExpression: ["callee", "arguments"],
-        ObjectExpression: ["properties"],
-        ObjectPattern: ["properties"],
-        PrivateIdentifier: [],
-        Program: ["body"],
-        Property: ["key", "value"],
-        PropertyDefinition: ["key", "value"],
-        RestElement: ["argument"],
-        ReturnStatement: ["argument"],
-        SequenceExpression: ["expressions"],
-        SpreadElement: ["argument"],
-        Super: [],
-        SwitchStatement: ["discriminant", "cases"],
-        SwitchCase: ["test", "consequent"],
-        TaggedTemplateExpression: ["tag", "quasi"],
-        TemplateElement: [],
-        TemplateLiteral: ["quasis", "expressions"],
-        ThisExpression: [],
-        ThrowStatement: ["argument"],
-        TryStatement: ["block", "handler", "finalizer"],
-        UnaryExpression: ["argument"],
-        UpdateExpression: ["argument"],
-        VariableDeclaration: ["declarations"],
-        VariableDeclarator: ["id", "init"],
-        WhileStatement: ["test", "body"],
-        WithStatement: ["object", "body"],
-        YieldExpression: ["argument"]
-      };
-      BREAK = {};
-      SKIP = {};
-      REMOVE = {};
-      VisitorOption = {
-        Break: BREAK,
-        Skip: SKIP,
-        Remove: REMOVE
-      };
-      function Reference(parent, key) {
-        this.parent = parent;
-        this.key = key;
-      }
-      Reference.prototype.replace = function replace2(node) {
-        this.parent[this.key] = node;
-      };
-      Reference.prototype.remove = function remove() {
-        if (Array.isArray(this.parent)) {
-          this.parent.splice(this.key, 1);
-          return true;
-        } else {
-          this.replace(null);
-          return false;
-        }
-      };
-      function Element(node, path, wrap, ref) {
-        this.node = node;
-        this.path = path;
-        this.wrap = wrap;
-        this.ref = ref;
-      }
-      function Controller() {
-      }
-      Controller.prototype.path = function path() {
-        var i, iz, j, jz, result, element;
-        function addToPath(result2, path2) {
-          if (Array.isArray(path2)) {
-            for (j = 0, jz = path2.length; j < jz; ++j) {
-              result2.push(path2[j]);
-            }
-          } else {
-            result2.push(path2);
-          }
-        }
-        if (!this.__current.path) {
-          return null;
-        }
-        result = [];
-        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
-          element = this.__leavelist[i];
-          addToPath(result, element.path);
-        }
-        addToPath(result, this.__current.path);
-        return result;
-      };
-      Controller.prototype.type = function() {
-        var node = this.current();
-        return node.type || this.__current.wrap;
-      };
-      Controller.prototype.parents = function parents() {
-        var i, iz, result;
-        result = [];
-        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
-          result.push(this.__leavelist[i].node);
-        }
-        return result;
-      };
-      Controller.prototype.current = function current() {
-        return this.__current.node;
-      };
-      Controller.prototype.__execute = function __execute(callback, element) {
-        var previous, result;
-        result = void 0;
-        previous = this.__current;
-        this.__current = element;
-        this.__state = null;
-        if (callback) {
-          result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
-        }
-        this.__current = previous;
-        return result;
-      };
-      Controller.prototype.notify = function notify(flag) {
-        this.__state = flag;
-      };
-      Controller.prototype.skip = function() {
-        this.notify(SKIP);
-      };
-      Controller.prototype["break"] = function() {
-        this.notify(BREAK);
-      };
-      Controller.prototype.remove = function() {
-        this.notify(REMOVE);
-      };
-      Controller.prototype.__initialize = function(root, visitor) {
-        this.visitor = visitor;
-        this.root = root;
-        this.__worklist = [];
-        this.__leavelist = [];
-        this.__current = null;
-        this.__state = null;
-        this.__fallback = null;
-        if (visitor.fallback === "iteration") {
-          this.__fallback = Object.keys;
-        } else if (typeof visitor.fallback === "function") {
-          this.__fallback = visitor.fallback;
-        }
-        this.__keys = VisitorKeys;
-        if (visitor.keys) {
-          this.__keys = Object.assign(Object.create(this.__keys), visitor.keys);
-        }
-      };
-      function isNode(node) {
-        if (node == null) {
-          return false;
-        }
-        return typeof node === "object" && typeof node.type === "string";
-      }
-      function isProperty(nodeType, key) {
-        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && "properties" === key;
-      }
-      function candidateExistsInLeaveList(leavelist, candidate) {
-        for (var i = leavelist.length - 1; i >= 0; --i) {
-          if (leavelist[i].node === candidate) {
-            return true;
-          }
-        }
-        return false;
-      }
-      Controller.prototype.traverse = function traverse2(root, visitor) {
-        var worklist, leavelist, element, node, nodeType, ret, key, current, current2, candidates, candidate, sentinel;
-        this.__initialize(root, visitor);
-        sentinel = {};
-        worklist = this.__worklist;
-        leavelist = this.__leavelist;
-        worklist.push(new Element(root, null, null, null));
-        leavelist.push(new Element(null, null, null, null));
-        while (worklist.length) {
-          element = worklist.pop();
-          if (element === sentinel) {
-            element = leavelist.pop();
-            ret = this.__execute(visitor.leave, element);
-            if (this.__state === BREAK || ret === BREAK) {
-              return;
-            }
-            continue;
-          }
-          if (element.node) {
-            ret = this.__execute(visitor.enter, element);
-            if (this.__state === BREAK || ret === BREAK) {
-              return;
-            }
-            worklist.push(sentinel);
-            leavelist.push(element);
-            if (this.__state === SKIP || ret === SKIP) {
-              continue;
-            }
-            node = element.node;
-            nodeType = node.type || element.wrap;
-            candidates = this.__keys[nodeType];
-            if (!candidates) {
-              if (this.__fallback) {
-                candidates = this.__fallback(node);
-              } else {
-                throw new Error("Unknown node type " + nodeType + ".");
-              }
-            }
-            current = candidates.length;
-            while ((current -= 1) >= 0) {
-              key = candidates[current];
-              candidate = node[key];
-              if (!candidate) {
-                continue;
-              }
-              if (Array.isArray(candidate)) {
-                current2 = candidate.length;
-                while ((current2 -= 1) >= 0) {
-                  if (!candidate[current2]) {
-                    continue;
-                  }
-                  if (candidateExistsInLeaveList(leavelist, candidate[current2])) {
-                    continue;
-                  }
-                  if (isProperty(nodeType, candidates[current])) {
-                    element = new Element(candidate[current2], [key, current2], "Property", null);
-                  } else if (isNode(candidate[current2])) {
-                    element = new Element(candidate[current2], [key, current2], null, null);
-                  } else {
-                    continue;
-                  }
-                  worklist.push(element);
-                }
-              } else if (isNode(candidate)) {
-                if (candidateExistsInLeaveList(leavelist, candidate)) {
-                  continue;
-                }
-                worklist.push(new Element(candidate, key, null, null));
-              }
-            }
-          }
-        }
-      };
-      Controller.prototype.replace = function replace2(root, visitor) {
-        var worklist, leavelist, node, nodeType, target, element, current, current2, candidates, candidate, sentinel, outer, key;
-        function removeElem(element2) {
-          var i, key2, nextElem, parent;
-          if (element2.ref.remove()) {
-            key2 = element2.ref.key;
-            parent = element2.ref.parent;
-            i = worklist.length;
-            while (i--) {
-              nextElem = worklist[i];
-              if (nextElem.ref && nextElem.ref.parent === parent) {
-                if (nextElem.ref.key < key2) {
-                  break;
-                }
-                --nextElem.ref.key;
-              }
-            }
-          }
-        }
-        this.__initialize(root, visitor);
-        sentinel = {};
-        worklist = this.__worklist;
-        leavelist = this.__leavelist;
-        outer = {
-          root
-        };
-        element = new Element(root, null, null, new Reference(outer, "root"));
-        worklist.push(element);
-        leavelist.push(element);
-        while (worklist.length) {
-          element = worklist.pop();
-          if (element === sentinel) {
-            element = leavelist.pop();
-            target = this.__execute(visitor.leave, element);
-            if (target !== void 0 && target !== BREAK && target !== SKIP && target !== REMOVE) {
-              element.ref.replace(target);
-            }
-            if (this.__state === REMOVE || target === REMOVE) {
-              removeElem(element);
-            }
-            if (this.__state === BREAK || target === BREAK) {
-              return outer.root;
-            }
-            continue;
-          }
-          target = this.__execute(visitor.enter, element);
-          if (target !== void 0 && target !== BREAK && target !== SKIP && target !== REMOVE) {
-            element.ref.replace(target);
-            element.node = target;
-          }
-          if (this.__state === REMOVE || target === REMOVE) {
-            removeElem(element);
-            element.node = null;
-          }
-          if (this.__state === BREAK || target === BREAK) {
-            return outer.root;
-          }
-          node = element.node;
-          if (!node) {
-            continue;
-          }
-          worklist.push(sentinel);
-          leavelist.push(element);
-          if (this.__state === SKIP || target === SKIP) {
-            continue;
-          }
-          nodeType = node.type || element.wrap;
-          candidates = this.__keys[nodeType];
-          if (!candidates) {
-            if (this.__fallback) {
-              candidates = this.__fallback(node);
-            } else {
-              throw new Error("Unknown node type " + nodeType + ".");
-            }
-          }
-          current = candidates.length;
-          while ((current -= 1) >= 0) {
-            key = candidates[current];
-            candidate = node[key];
-            if (!candidate) {
-              continue;
-            }
-            if (Array.isArray(candidate)) {
-              current2 = candidate.length;
-              while ((current2 -= 1) >= 0) {
-                if (!candidate[current2]) {
-                  continue;
-                }
-                if (isProperty(nodeType, candidates[current])) {
-                  element = new Element(candidate[current2], [key, current2], "Property", new Reference(candidate, current2));
-                } else if (isNode(candidate[current2])) {
-                  element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
-                } else {
-                  continue;
-                }
-                worklist.push(element);
-              }
-            } else if (isNode(candidate)) {
-              worklist.push(new Element(candidate, key, null, new Reference(node, key)));
-            }
-          }
-        }
-        return outer.root;
-      };
-      function traverse(root, visitor) {
-        var controller = new Controller();
-        return controller.traverse(root, visitor);
-      }
-      function replace(root, visitor) {
-        var controller = new Controller();
-        return controller.replace(root, visitor);
-      }
-      function extendCommentRange(comment, tokens) {
-        var target;
-        target = upperBound(tokens, function search(token) {
-          return token.range[0] > comment.range[0];
-        });
-        comment.extendedRange = [comment.range[0], comment.range[1]];
-        if (target !== tokens.length) {
-          comment.extendedRange[1] = tokens[target].range[0];
-        }
-        target -= 1;
-        if (target >= 0) {
-          comment.extendedRange[0] = tokens[target].range[1];
-        }
-        return comment;
-      }
-      function attachComments(tree, providedComments, tokens) {
-        var comments = [], comment, len, i, cursor;
-        if (!tree.range) {
-          throw new Error("attachComments needs range information");
-        }
-        if (!tokens.length) {
-          if (providedComments.length) {
-            for (i = 0, len = providedComments.length; i < len; i += 1) {
-              comment = deepCopy(providedComments[i]);
-              comment.extendedRange = [0, tree.range[0]];
-              comments.push(comment);
-            }
-            tree.leadingComments = comments;
-          }
-          return tree;
-        }
-        for (i = 0, len = providedComments.length; i < len; i += 1) {
-          comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
-        }
-        cursor = 0;
-        traverse(tree, {
-          enter: function(node) {
-            var comment2;
-            while (cursor < comments.length) {
-              comment2 = comments[cursor];
-              if (comment2.extendedRange[1] > node.range[0]) {
-                break;
-              }
-              if (comment2.extendedRange[1] === node.range[0]) {
-                if (!node.leadingComments) {
-                  node.leadingComments = [];
-                }
-                node.leadingComments.push(comment2);
-                comments.splice(cursor, 1);
-              } else {
-                cursor += 1;
-              }
-            }
-            if (cursor === comments.length) {
-              return VisitorOption.Break;
-            }
-            if (comments[cursor].extendedRange[0] > node.range[1]) {
-              return VisitorOption.Skip;
-            }
-          }
-        });
-        cursor = 0;
-        traverse(tree, {
-          leave: function(node) {
-            var comment2;
-            while (cursor < comments.length) {
-              comment2 = comments[cursor];
-              if (node.range[1] < comment2.extendedRange[0]) {
-                break;
-              }
-              if (node.range[1] === comment2.extendedRange[0]) {
-                if (!node.trailingComments) {
-                  node.trailingComments = [];
-                }
-                node.trailingComments.push(comment2);
-                comments.splice(cursor, 1);
-              } else {
-                cursor += 1;
-              }
-            }
-            if (cursor === comments.length) {
-              return VisitorOption.Break;
-            }
-            if (comments[cursor].extendedRange[0] > node.range[1]) {
-              return VisitorOption.Skip;
-            }
-          }
-        });
-        return tree;
-      }
-      exports2.Syntax = Syntax;
-      exports2.traverse = traverse;
-      exports2.replace = replace;
-      exports2.attachComments = attachComments;
-      exports2.VisitorKeys = VisitorKeys;
-      exports2.VisitorOption = VisitorOption;
-      exports2.Controller = Controller;
-      exports2.cloneEnvironment = function() {
-        return clone({});
-      };
-      return exports2;
-    })(exports);
-  }
-});
-
-export {
-  require_estraverse
-};