@whoj/eslint-config 1.4.2 → 2.0.0

package/dist/chunk-G5WGJHBR.js

@@ -0,0 +1,149 @@
+import {
+  require_estraverse
+} from "./chunk-DLJMV7EV.js";
+import {
+  __commonJS,
+  init_esm_shims
+} from "./chunk-MKNYKNDN.js";
+
+// node_modules/.pnpm/esrecurse@4.3.0/node_modules/esrecurse/package.json
+var require_package = __commonJS({
+  "node_modules/.pnpm/esrecurse@4.3.0/node_modules/esrecurse/package.json"(exports, module) {
+    module.exports = {
+      name: "esrecurse",
+      description: "ECMAScript AST recursive visitor",
+      homepage: "https://github.com/estools/esrecurse",
+      main: "esrecurse.js",
+      version: "4.3.0",
+      engines: {
+        node: ">=4.0"
+      },
+      maintainers: [
+        {
+          name: "Yusuke Suzuki",
+          email: "utatane.tea@gmail.com",
+          web: "https://github.com/Constellation"
+        }
+      ],
+      repository: {
+        type: "git",
+        url: "https://github.com/estools/esrecurse.git"
+      },
+      dependencies: {
+        estraverse: "^5.2.0"
+      },
+      devDependencies: {
+        "babel-cli": "^6.24.1",
+        "babel-eslint": "^7.2.3",
+        "babel-preset-es2015": "^6.24.1",
+        "babel-register": "^6.24.1",
+        chai: "^4.0.2",
+        esprima: "^4.0.0",
+        gulp: "^3.9.0",
+        "gulp-bump": "^2.7.0",
+        "gulp-eslint": "^4.0.0",
+        "gulp-filter": "^5.0.0",
+        "gulp-git": "^2.4.1",
+        "gulp-mocha": "^4.3.1",
+        "gulp-tag-version": "^1.2.1",
+        jsdoc: "^3.3.0-alpha10",
+        minimist: "^1.1.0"
+      },
+      license: "BSD-2-Clause",
+      scripts: {
+        test: "gulp travis",
+        "unit-test": "gulp test",
+        lint: "gulp lint"
+      },
+      babel: {
+        presets: [
+          "es2015"
+        ]
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/esrecurse@4.3.0/node_modules/esrecurse/esrecurse.js
+var require_esrecurse = __commonJS({
+  "node_modules/.pnpm/esrecurse@4.3.0/node_modules/esrecurse/esrecurse.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    (function() {
+      "use strict";
+      var estraverse = require_estraverse();
+      function isNode(node) {
+        if (node == null) {
+          return false;
+        }
+        return typeof node === "object" && typeof node.type === "string";
+      }
+      function isProperty(nodeType, key) {
+        return (nodeType === estraverse.Syntax.ObjectExpression || nodeType === estraverse.Syntax.ObjectPattern) && key === "properties";
+      }
+      function Visitor(visitor, options) {
+        options = options || {};
+        this.__visitor = visitor || this;
+        this.__childVisitorKeys = options.childVisitorKeys ? Object.assign({}, estraverse.VisitorKeys, options.childVisitorKeys) : estraverse.VisitorKeys;
+        if (options.fallback === "iteration") {
+          this.__fallback = Object.keys;
+        } else if (typeof options.fallback === "function") {
+          this.__fallback = options.fallback;
+        }
+      }
+      Visitor.prototype.visitChildren = function(node) {
+        var type, children, i, iz, j, jz, child;
+        if (node == null) {
+          return;
+        }
+        type = node.type || estraverse.Syntax.Property;
+        children = this.__childVisitorKeys[type];
+        if (!children) {
+          if (this.__fallback) {
+            children = this.__fallback(node);
+          } else {
+            throw new Error("Unknown node type " + type + ".");
+          }
+        }
+        for (i = 0, iz = children.length; i < iz; ++i) {
+          child = node[children[i]];
+          if (child) {
+            if (Array.isArray(child)) {
+              for (j = 0, jz = child.length; j < jz; ++j) {
+                if (child[j]) {
+                  if (isNode(child[j]) || isProperty(type, children[i])) {
+                    this.visit(child[j]);
+                  }
+                }
+              }
+            } else if (isNode(child)) {
+              this.visit(child);
+            }
+          }
+        }
+      };
+      Visitor.prototype.visit = function(node) {
+        var type;
+        if (node == null) {
+          return;
+        }
+        type = node.type || estraverse.Syntax.Property;
+        if (this.__visitor[type]) {
+          this.__visitor[type].call(this, node);
+          return;
+        }
+        this.visitChildren(node);
+      };
+      exports.version = require_package().version;
+      exports.Visitor = Visitor;
+      exports.visit = function(node, visitor, options) {
+        var v = new Visitor(visitor, options);
+        v.visit(node);
+      };
+    })();
+  }
+});
+
+export {
+  require_esrecurse
+};

package/dist/chunk-IDB36RF3.js

@@ -0,0 +1,353 @@
+import {
+  __commonJS,
+  init_esm_shims
+} from "./chunk-MKNYKNDN.js";
+
+// node_modules/.pnpm/eslint-visitor-keys@3.4.3/node_modules/eslint-visitor-keys/dist/eslint-visitor-keys.cjs
+var require_eslint_visitor_keys = __commonJS({
+  "node_modules/.pnpm/eslint-visitor-keys@3.4.3/node_modules/eslint-visitor-keys/dist/eslint-visitor-keys.cjs"(exports) {
+    "use strict";
+    init_esm_shims();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var KEYS = {
+      ArrayExpression: [
+        "elements"
+      ],
+      ArrayPattern: [
+        "elements"
+      ],
+      ArrowFunctionExpression: [
+        "params",
+        "body"
+      ],
+      AssignmentExpression: [
+        "left",
+        "right"
+      ],
+      AssignmentPattern: [
+        "left",
+        "right"
+      ],
+      AwaitExpression: [
+        "argument"
+      ],
+      BinaryExpression: [
+        "left",
+        "right"
+      ],
+      BlockStatement: [
+        "body"
+      ],
+      BreakStatement: [
+        "label"
+      ],
+      CallExpression: [
+        "callee",
+        "arguments"
+      ],
+      CatchClause: [
+        "param",
+        "body"
+      ],
+      ChainExpression: [
+        "expression"
+      ],
+      ClassBody: [
+        "body"
+      ],
+      ClassDeclaration: [
+        "id",
+        "superClass",
+        "body"
+      ],
+      ClassExpression: [
+        "id",
+        "superClass",
+        "body"
+      ],
+      ConditionalExpression: [
+        "test",
+        "consequent",
+        "alternate"
+      ],
+      ContinueStatement: [
+        "label"
+      ],
+      DebuggerStatement: [],
+      DoWhileStatement: [
+        "body",
+        "test"
+      ],
+      EmptyStatement: [],
+      ExperimentalRestProperty: [
+        "argument"
+      ],
+      ExperimentalSpreadProperty: [
+        "argument"
+      ],
+      ExportAllDeclaration: [
+        "exported",
+        "source"
+      ],
+      ExportDefaultDeclaration: [
+        "declaration"
+      ],
+      ExportNamedDeclaration: [
+        "declaration",
+        "specifiers",
+        "source"
+      ],
+      ExportSpecifier: [
+        "exported",
+        "local"
+      ],
+      ExpressionStatement: [
+        "expression"
+      ],
+      ForInStatement: [
+        "left",
+        "right",
+        "body"
+      ],
+      ForOfStatement: [
+        "left",
+        "right",
+        "body"
+      ],
+      ForStatement: [
+        "init",
+        "test",
+        "update",
+        "body"
+      ],
+      FunctionDeclaration: [
+        "id",
+        "params",
+        "body"
+      ],
+      FunctionExpression: [
+        "id",
+        "params",
+        "body"
+      ],
+      Identifier: [],
+      IfStatement: [
+        "test",
+        "consequent",
+        "alternate"
+      ],
+      ImportDeclaration: [
+        "specifiers",
+        "source"
+      ],
+      ImportDefaultSpecifier: [
+        "local"
+      ],
+      ImportExpression: [
+        "source"
+      ],
+      ImportNamespaceSpecifier: [
+        "local"
+      ],
+      ImportSpecifier: [
+        "imported",
+        "local"
+      ],
+      JSXAttribute: [
+        "name",
+        "value"
+      ],
+      JSXClosingElement: [
+        "name"
+      ],
+      JSXClosingFragment: [],
+      JSXElement: [
+        "openingElement",
+        "children",
+        "closingElement"
+      ],
+      JSXEmptyExpression: [],
+      JSXExpressionContainer: [
+        "expression"
+      ],
+      JSXFragment: [
+        "openingFragment",
+        "children",
+        "closingFragment"
+      ],
+      JSXIdentifier: [],
+      JSXMemberExpression: [
+        "object",
+        "property"
+      ],
+      JSXNamespacedName: [
+        "namespace",
+        "name"
+      ],
+      JSXOpeningElement: [
+        "name",
+        "attributes"
+      ],
+      JSXOpeningFragment: [],
+      JSXSpreadAttribute: [
+        "argument"
+      ],
+      JSXSpreadChild: [
+        "expression"
+      ],
+      JSXText: [],
+      LabeledStatement: [
+        "label",
+        "body"
+      ],
+      Literal: [],
+      LogicalExpression: [
+        "left",
+        "right"
+      ],
+      MemberExpression: [
+        "object",
+        "property"
+      ],
+      MetaProperty: [
+        "meta",
+        "property"
+      ],
+      MethodDefinition: [
+        "key",
+        "value"
+      ],
+      NewExpression: [
+        "callee",
+        "arguments"
+      ],
+      ObjectExpression: [
+        "properties"
+      ],
+      ObjectPattern: [
+        "properties"
+      ],
+      PrivateIdentifier: [],
+      Program: [
+        "body"
+      ],
+      Property: [
+        "key",
+        "value"
+      ],
+      PropertyDefinition: [
+        "key",
+        "value"
+      ],
+      RestElement: [
+        "argument"
+      ],
+      ReturnStatement: [
+        "argument"
+      ],
+      SequenceExpression: [
+        "expressions"
+      ],
+      SpreadElement: [
+        "argument"
+      ],
+      StaticBlock: [
+        "body"
+      ],
+      Super: [],
+      SwitchCase: [
+        "test",
+        "consequent"
+      ],
+      SwitchStatement: [
+        "discriminant",
+        "cases"
+      ],
+      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"
+      ]
+    };
+    var NODE_TYPES = Object.keys(KEYS);
+    for (const type of NODE_TYPES) {
+      Object.freeze(KEYS[type]);
+    }
+    Object.freeze(KEYS);
+    var KEY_BLACKLIST = /* @__PURE__ */ new Set([
+      "parent",
+      "leadingComments",
+      "trailingComments"
+    ]);
+    function filterKey(key) {
+      return !KEY_BLACKLIST.has(key) && key[0] !== "_";
+    }
+    function getKeys(node) {
+      return Object.keys(node).filter(filterKey);
+    }
+    function unionWith(additionalKeys) {
+      const retv = (
+        /** @type {{
+            [type: string]: ReadonlyArray<string>
+        }} */
+        Object.assign({}, KEYS)
+      );
+      for (const type of Object.keys(additionalKeys)) {
+        if (Object.prototype.hasOwnProperty.call(retv, type)) {
+          const keys = new Set(additionalKeys[type]);
+          for (const key of retv[type]) {
+            keys.add(key);
+          }
+          retv[type] = Object.freeze(Array.from(keys));
+        } else {
+          retv[type] = Object.freeze(Array.from(additionalKeys[type]));
+        }
+      }
+      return Object.freeze(retv);
+    }
+    exports.KEYS = KEYS;
+    exports.getKeys = getKeys;
+    exports.unionWith = unionWith;
+  }
+});
+
+export {
+  require_eslint_visitor_keys
+};