@jsse/eslint-config 0.1.2 → 0.1.3

package/dist/index.cjs

@@ -118,8 +118,8 @@ var require_sort_keys_fix = __commonJS({
         const isValidOrder = isValidOrders[order + (insensitive ? "I" : "") + (natural ? "N" : "")];
         const minKeys = Number(options && options.minKeys) || 2;
         let stack = null;
-        const SpreadElement = (node2) => {
-          if (node2.parent.type === "ObjectExpression") {
+        const SpreadElement = (node) => {
+          if (node.parent.type === "ObjectExpression") {
             stack.prevName = null;
           }
         };
@@ -136,27 +136,27 @@ var require_sort_keys_fix = __commonJS({
           "ObjectExpression:exit"() {
             stack = stack.upper;
           },
-          Property(node2) {
-            if (node2.parent.type === "ObjectPattern") {
+          Property(node) {
+            if (node.parent.type === "ObjectPattern") {
               return;
             }
-            if (node2.parent.properties.length < minKeys) {
+            if (node.parent.properties.length < minKeys) {
               return;
             }
             const prevName = stack.prevName;
             const prevNode = stack.prevNode;
-            const thisName = getPropertyName(node2);
+            const thisName = getPropertyName(node);
             if (thisName !== null) {
               stack.prevName = thisName;
-              stack.prevNode = node2 || prevNode;
+              stack.prevNode = node || prevNode;
             }
             if (prevName === null || thisName === null) {
               return;
             }
             if (!isValidOrder(prevName, thisName)) {
               ctx.report({
-                node: node2,
-                loc: node2.key.loc,
+                node,
+                loc: node.key.loc,
                 messageId: "sortKeys",
                 data: {
                   thisName,
@@ -166,13 +166,13 @@ var require_sort_keys_fix = __commonJS({
                   natural: natural ? "natural " : ""
                 },
                 fix(fixer) {
-                  if (node2.parent.__alreadySorted || node2.parent.properties.__alreadySorted) {
+                  if (node.parent.__alreadySorted || node.parent.properties.__alreadySorted) {
                     return [];
                   }
-                  node2.parent.__alreadySorted = true;
-                  node2.parent.properties.__alreadySorted = true;
+                  node.parent.__alreadySorted = true;
+                  node.parent.properties.__alreadySorted = true;
                   const src = ctx.getSourceCode();
-                  const props = node2.parent.properties;
+                  const props = node.parent.properties;
                   const parts = [];
                   let part = [];
                   props.forEach((p) => {
@@ -243,21 +243,21 @@ var require_sort_keys_fix = __commonJS({
       }
       return fixes;
     };
-    var findTokenPrevLine = (node2, src) => {
-      let t = src.getTokenBefore(node2);
+    var findTokenPrevLine = (node, src) => {
+      let t = src.getTokenBefore(node);
       while (true) {
-        if (!t || t.range[0] < node2.parent.range[0]) {
+        if (!t || t.range[0] < node.parent.range[0]) {
           return null;
         }
-        if (t.loc.end.line < node2.loc.start.line) {
+        if (t.loc.end.line < node.loc.start.line) {
           return t;
         }
         t = src.getTokenBefore(t);
       }
     };
-    var findCommaSameLine = (node2, src) => {
-      const t = src.getTokenAfter(node2);
-      return t && t.value === "," && node2.loc.end.line === t.loc.start.line ? t : null;
+    var findCommaSameLine = (node, src) => {
+      const t = src.getTokenAfter(node);
+      return t && t.value === "," && node.loc.end.line === t.loc.start.line ? t : null;
     };
     var isValidOrders = {
       asc: (a, b) => a <= b,
@@ -269,15 +269,15 @@ var require_sort_keys_fix = __commonJS({
       descN: (a, b) => isValidOrders.ascN(b, a),
       descIN: (a, b) => isValidOrders.ascIN(b, a)
     };
-    var getPropertyName = (node2) => {
+    var getPropertyName = (node) => {
       let prop;
-      switch (node2 && node2.type) {
+      switch (node && node.type) {
         case "Property":
         case "MethodDefinition":
-          prop = node2.key;
+          prop = node.key;
           break;
         case "MemberExpression":
-          prop = node2.property;
+          prop = node.property;
           break;
       }
       switch (prop && prop.type) {
@@ -289,12 +289,12 @@ var require_sort_keys_fix = __commonJS({
           }
           break;
         case "Identifier":
-          if (!node2.computed) {
+          if (!node.computed) {
             return prop.name;
           }
           break;
       }
-      return node2.key && node2.key.name || null;
+      return node.key && node.key.name || null;
     };
   }
 });
@@ -2345,6 +2345,7 @@ __export(src_exports, {
   GLOB_TSX: () => GLOB_TSX,
   GLOB_YAML: () => GLOB_YAML,
   combine: () => combine,
+  combineAsync: () => combineAsync,
   comments: () => comments,
   default: () => jsse,
   eslintConfigPrettierRules: () => eslintConfigPrettierRules,
@@ -2359,10 +2360,11 @@ __export(src_exports, {
   jsse: () => jsse,
   jsseReact: () => jsseReact,
   jssestd: () => jssestd,
-  node: () => node,
+  n: () => n,
   parserJsonc: () => import_jsonc_eslint_parser.default,
   parserTs: () => parserTs,
   perfectionist: () => perfectionist,
+  pluginAntfu: () => import_eslint_plugin_antfu.default,
   pluginEslintComments: () => import_eslint_plugin_eslint_comments.default,
   pluginImport: () => pluginImport,
   pluginJsdoc: () => import_eslint_plugin_jsdoc.default,
@@ -2398,42 +2400,41 @@ module.exports = __toCommonJS(src_exports);
 var import_eslint_plugin = __toESM(require("@stylistic/eslint-plugin"), 1);
 var import_eslint_plugin2 = __toESM(require("@typescript-eslint/eslint-plugin"), 1);
 var parserTs = __toESM(require("@typescript-eslint/parser"), 1);
+var import_eslint_plugin_antfu = __toESM(require("eslint-plugin-antfu"), 1);
 var import_eslint_plugin_eslint_comments = __toESM(require("eslint-plugin-eslint-comments"), 1);
 var pluginImport = __toESM(require("eslint-plugin-i"), 1);
 var import_eslint_plugin_jsdoc = __toESM(require("eslint-plugin-jsdoc"), 1);
 var pluginJsonc = __toESM(require("eslint-plugin-jsonc"), 1);
+var import_eslint_plugin_markdown = __toESM(require("eslint-plugin-markdown"), 1);
 var import_eslint_plugin_n = __toESM(require("eslint-plugin-n"), 1);
 var import_eslint_plugin_no_only_tests = __toESM(require("eslint-plugin-no-only-tests"), 1);
+var import_eslint_plugin_perfectionist = __toESM(require("eslint-plugin-perfectionist"), 1);
 var import_eslint_plugin_react = __toESM(require("eslint-plugin-react"), 1);
 var import_eslint_plugin_react_hooks = __toESM(require("eslint-plugin-react-hooks"), 1);
 var pluginReactRefresh = __toESM(require("eslint-plugin-react-refresh"), 1);
 var pluginSortKeys = __toESM(require_eslint_plugin_sort_keys(), 1);
+var import_eslint_plugin_tailwindcss = __toESM(require("eslint-plugin-tailwindcss"), 1);
 var import_eslint_plugin_unicorn = __toESM(require("eslint-plugin-unicorn"), 1);
 var import_eslint_plugin_unused_imports = __toESM(require("eslint-plugin-unused-imports"), 1);
-var import_eslint_plugin_tailwindcss = __toESM(require("eslint-plugin-tailwindcss"), 1);
 var import_eslint_plugin_vitest = __toESM(require("eslint-plugin-vitest"), 1);
 var import_jsonc_eslint_parser = __toESM(require("jsonc-eslint-parser"), 1);
-var import_eslint_plugin_markdown = __toESM(require("eslint-plugin-markdown"), 1);
-var import_eslint_plugin_perfectionist = __toESM(require("eslint-plugin-perfectionist"), 1);
 
 // src/configs/comments.ts
-function comments() {
-  return [
-    {
-      name: "jsse:eslint-comments",
-      plugins: {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        "eslint-comments": import_eslint_plugin_eslint_comments.default
-      },
-      rules: {
-        "eslint-comments/no-aggregating-enable": "error",
-        "eslint-comments/no-duplicate-disable": "error",
-        "eslint-comments/no-unlimited-disable": "error",
-        "eslint-comments/no-unused-enable": "error"
-      }
+var comments = async () => [
+  {
+    name: "jsse:eslint-comments",
+    plugins: {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      "eslint-comments": import_eslint_plugin_eslint_comments.default
+    },
+    rules: {
+      "eslint-comments/no-aggregating-enable": "error",
+      "eslint-comments/no-duplicate-disable": "error",
+      "eslint-comments/no-unlimited-disable": "error",
+      "eslint-comments/no-unused-enable": "error"
     }
-  ];
-}
+  }
+];
 
 // src/globs.ts
 var GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
@@ -2504,17 +2505,17 @@ var GLOB_EXCLUDE = [
 ];
 
 // src/configs/ignores.ts
-function ignores() {
+var ignores = async () => {
   return [
     {
       ignores: GLOB_EXCLUDE
     }
   ];
-}
+};
 
 // src/configs/imports.ts
-function imports(options = {}) {
-  const { stylistic: stylistic2 = true } = options;
+var imports = async (options) => {
+  const { stylistic: stylistic2 = true } = options ?? {};
   return [
     {
       name: "jsse:imports",
@@ -2539,13 +2540,17 @@ function imports(options = {}) {
       }
     }
   ];
-}
+};
 
 // src/configs/javascript.ts
 var import_js = __toESM(require("@eslint/js"), 1);
 var import_globals = __toESM(require_globals2(), 1);
-function javascript(options = {}) {
-  const { isInEditor: isInEditor2 = false, overrides = {} } = options;
+var javascript = async (options) => {
+  const {
+    isInEditor: isInEditor2 = false,
+    overrides = {},
+    reportUnusedDisableDirectives = true
+  } = options ?? {};
   return [
     {
       languageOptions: {
@@ -2568,7 +2573,7 @@ function javascript(options = {}) {
         sourceType: "module"
       },
       linterOptions: {
-        reportUnusedDisableDirectives: options.reportUnusedDisableDirectives ?? true
+        reportUnusedDisableDirectives
       },
       name: "jsse:javascript",
       plugins: {
@@ -2796,10 +2801,10 @@ function javascript(options = {}) {
       }
     }
   ];
-}
+};
 
 // src/configs/jsdoc.ts
-function jsdoc() {
+var jsdoc = async () => {
   return [
     {
       name: "jsse:jsdoc",
@@ -2828,11 +2833,11 @@ function jsdoc() {
       }
     }
   ];
-}
+};
 
 // src/configs/jsonc.ts
-function jsonc(options = {}) {
-  const { overrides = {}, stylistic: stylistic2 = true } = options;
+var jsonc = async (options) => {
+  const { overrides = {}, stylistic: stylistic2 = true } = options ?? {};
   const { indent = 2 } = typeof stylistic2 === "boolean" ? {} : stylistic2;
   return [
     {
@@ -2900,30 +2905,42 @@ function jsonc(options = {}) {
       }
     }
   ];
-}
+};
 
 // src/configs/n.ts
-function node() {
+var n = async () => {
   return [
     {
       name: "jsse:n",
       plugins: {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        node: import_eslint_plugin_n.default
+        n: import_eslint_plugin_n.default
       },
       rules: {
-        "node/handle-callback-err": ["error", "^(err|error)$"],
-        "node/no-deprecated-api": "error",
-        "node/no-exports-assign": "error",
-        "node/no-new-require": "error",
-        "node/no-path-concat": "error",
-        "node/prefer-global/buffer": ["error", "never"],
-        "node/prefer-global/process": ["error", "never"],
-        "node/process-exit-as-throw": "error"
+        "n/handle-callback-err": ["error", "^(err|error)$"],
+        "n/no-deprecated-api": "error",
+        "n/no-exports-assign": "error",
+        "n/no-new-require": "error",
+        "n/no-path-concat": "error",
+        "n/prefer-global/buffer": ["error", "never"],
+        "n/prefer-global/process": ["error", "never"],
+        "n/process-exit-as-throw": "error"
       }
     }
   ];
-}
+};
+
+// src/configs/perfectionist.ts
+var perfectionist = async () => {
+  return [
+    {
+      name: "jsse:perfectionist",
+      plugins: {
+        perfectionist: import_eslint_plugin_perfectionist.default
+      }
+    }
+  ];
+};
 
 // src/configs/prettier.ts
 function eslintConfigPrettierRules() {
@@ -3040,16 +3057,14 @@ function eslintConfigPrettierRules() {
     "yield-star-spacing": "off"
   };
 }
-function prettier() {
+var prettier = async () => {
   return [
     {
       name: "jsse:prettier",
-      rules: {
-        ...eslintConfigPrettierRules()
-      }
+      rules: eslintConfigPrettierRules()
     }
   ];
-}
+};
 
 // src/configs/ts/typescript-language-options.ts
 var import_node_process = __toESM(require("process"), 1);
@@ -3308,7 +3323,7 @@ function reactRecomendedRules() {
     "react/require-render-return": 2
   };
 }
-function react(options) {
+var react = async (options) => {
   const {
     componentExts,
     parserOptions = {},
@@ -3353,10 +3368,10 @@ function react(options) {
     config.push(...reactRefreshFlatConfigs());
   }
   return config;
-}
+};
 
 // src/configs/sort.ts
-function sortPackageJson() {
+var sortPackageJson = async () => {
   return [
     {
       files: ["**/package.json"],
@@ -3439,8 +3454,8 @@ function sortPackageJson() {
       }
     }
   ];
-}
-function sortTsconfig() {
+};
+var sortTsconfig = async () => {
   return [
     {
       files: ["**/tsconfig.json", "**/tsconfig.*.json"],
@@ -3564,7 +3579,7 @@ function sortTsconfig() {
       }
     }
   ];
-}
+};
 
 // src/utils.ts
 var import_node_process2 = __toESM(require("process"), 1);
@@ -3573,6 +3588,12 @@ function combine(...configs) {
     (config) => Array.isArray(config) ? config : [config]
   );
 }
+async function combineAsync(...configs) {
+  const resolved = await Promise.all(configs);
+  return resolved.flatMap(
+    (config) => Array.isArray(config) ? config : [config]
+  );
+}
 function renameRules(rules, from, to) {
   if (from === to) {
     return rules;
@@ -3598,7 +3619,7 @@ function isInEditor() {
 }
 
 // src/configs/test.ts
-function test(options = {}) {
+var test = async (options = {}) => {
   const { isInEditor: isInEditor2 = false, overrides = {} } = options;
   return [
     {
@@ -3625,7 +3646,7 @@ function test(options = {}) {
       }
     }
   ];
-}
+};
 
 // src/configs/ts/typescript-rules.ts
 function typescriptRulesTypeAware() {
@@ -4152,7 +4173,7 @@ function unicornOff() {
     // Super insanely annoying rule
   };
 }
-function unicorn() {
+var unicorn = async () => {
   return [
     {
       name: "jsse:unicorn",
@@ -4233,19 +4254,7 @@ function unicorn() {
       }
     }
   ];
-}
-
-// src/configs/perfectionist.ts
-function perfectionist() {
-  return [
-    {
-      name: "jsse:perfectionist",
-      plugins: {
-        perfectionist: import_eslint_plugin_perfectionist.default
-      }
-    }
-  ];
-}
+};
 
 // src/factory.ts
 var import_node_fs3 = __toESM(require("fs"), 1);
@@ -4503,8 +4512,8 @@ var Position = function Position2(line, col) {
   this.line = line;
   this.column = col;
 };
-Position.prototype.offset = function offset(n) {
-  return new Position(this.line, this.column + n);
+Position.prototype.offset = function offset(n2) {
+  return new Position(this.line, this.column + n2);
 };
 var SourceLocation = function SourceLocation2(p, start, end) {
   this.start = start;
@@ -4740,9 +4749,9 @@ var Parser = function Parser2(options, input, startPos) {
 };
 var prototypeAccessors = { inFunction: { configurable: true }, inGenerator: { configurable: true }, inAsync: { configurable: true }, canAwait: { configurable: true }, allowSuper: { configurable: true }, allowDirectSuper: { configurable: true }, treatFunctionsAsVar: { configurable: true }, allowNewDotTarget: { configurable: true }, inClassStaticBlock: { configurable: true } };
 Parser.prototype.parse = function parse() {
-  var node2 = this.options.program || this.startNode();
+  var node = this.options.program || this.startNode();
   this.nextToken();
-  return this.parseTopLevel(node2);
+  return this.parseTopLevel(node);
 };
 prototypeAccessors.inFunction.get = function() {
   return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0;
@@ -4937,14 +4946,14 @@ pp$9.isSimpleAssignTarget = function(expr) {
   return expr.type === "Identifier" || expr.type === "MemberExpression";
 };
 var pp$8 = Parser.prototype;
-pp$8.parseTopLevel = function(node2) {
+pp$8.parseTopLevel = function(node) {
   var exports2 = /* @__PURE__ */ Object.create(null);
-  if (!node2.body) {
-    node2.body = [];
+  if (!node.body) {
+    node.body = [];
   }
   while (this.type !== types$1.eof) {
     var stmt = this.parseStatement(null, true, exports2);
-    node2.body.push(stmt);
+    node.body.push(stmt);
   }
   if (this.inModule) {
     for (var i = 0, list = Object.keys(this.undefinedExports); i < list.length; i += 1) {
@@ -4952,10 +4961,10 @@ pp$8.parseTopLevel = function(node2) {
       this.raiseRecoverable(this.undefinedExports[name].start, "Export '" + name + "' is not defined");
     }
   }
-  this.adaptDirectivePrologue(node2.body);
+  this.adaptDirectivePrologue(node.body);
   this.next();
-  node2.sourceType = this.options.sourceType;
-  return this.finishNode(node2, "Program");
+  node.sourceType = this.options.sourceType;
+  return this.finishNode(node, "Program");
 };
 var loopLabel = { kind: "loop" };
 var switchLabel = { kind: "switch" };
@@ -5000,7 +5009,7 @@ pp$8.isAsyncFunction = function() {
   return !lineBreak.test(this.input.slice(this.pos, next)) && this.input.slice(next, next + 8) === "function" && (next + 8 === this.input.length || !(isIdentifierChar(after = this.input.charCodeAt(next + 8)) || after > 55295 && after < 56320));
 };
 pp$8.parseStatement = function(context, topLevel, exports2) {
-  var starttype = this.type, node2 = this.startNode(), kind;
+  var starttype = this.type, node = this.startNode(), kind;
   if (this.isLet(context)) {
     starttype = types$1._var;
     kind = "let";
@@ -5008,48 +5017,48 @@ pp$8.parseStatement = function(context, topLevel, exports2) {
   switch (starttype) {
     case types$1._break:
     case types$1._continue:
-      return this.parseBreakContinueStatement(node2, starttype.keyword);
+      return this.parseBreakContinueStatement(node, starttype.keyword);
     case types$1._debugger:
-      return this.parseDebuggerStatement(node2);
+      return this.parseDebuggerStatement(node);
     case types$1._do:
-      return this.parseDoStatement(node2);
+      return this.parseDoStatement(node);
     case types$1._for:
-      return this.parseForStatement(node2);
+      return this.parseForStatement(node);
     case types$1._function:
       if (context && (this.strict || context !== "if" && context !== "label") && this.options.ecmaVersion >= 6) {
         this.unexpected();
       }
-      return this.parseFunctionStatement(node2, false, !context);
+      return this.parseFunctionStatement(node, false, !context);
     case types$1._class:
       if (context) {
         this.unexpected();
       }
-      return this.parseClass(node2, true);
+      return this.parseClass(node, true);
     case types$1._if:
-      return this.parseIfStatement(node2);
+      return this.parseIfStatement(node);
     case types$1._return:
-      return this.parseReturnStatement(node2);
+      return this.parseReturnStatement(node);
     case types$1._switch:
-      return this.parseSwitchStatement(node2);
+      return this.parseSwitchStatement(node);
     case types$1._throw:
-      return this.parseThrowStatement(node2);
+      return this.parseThrowStatement(node);
     case types$1._try:
-      return this.parseTryStatement(node2);
+      return this.parseTryStatement(node);
     case types$1._const:
     case types$1._var:
       kind = kind || this.value;
       if (context && kind !== "var") {
         this.unexpected();
       }
-      return this.parseVarStatement(node2, kind);
+      return this.parseVarStatement(node, kind);
     case types$1._while:
-      return this.parseWhileStatement(node2);
+      return this.parseWhileStatement(node);
     case types$1._with:
-      return this.parseWithStatement(node2);
+      return this.parseWithStatement(node);
     case types$1.braceL:
-      return this.parseBlock(true, node2);
+      return this.parseBlock(true, node);
     case types$1.semi:
-      return this.parseEmptyStatement(node2);
+      return this.parseEmptyStatement(node);
     case types$1._export:
     case types$1._import:
       if (this.options.ecmaVersion > 10 && starttype === types$1._import) {
@@ -5057,7 +5066,7 @@ pp$8.parseStatement = function(context, topLevel, exports2) {
         var skip = skipWhiteSpace.exec(this.input);
         var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
         if (nextCh === 40 || nextCh === 46) {
-          return this.parseExpressionStatement(node2, this.parseExpression());
+          return this.parseExpressionStatement(node, this.parseExpression());
         }
       }
       if (!this.options.allowImportExportEverywhere) {
@@ -5068,71 +5077,71 @@ pp$8.parseStatement = function(context, topLevel, exports2) {
           this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
         }
       }
-      return starttype === types$1._import ? this.parseImport(node2) : this.parseExport(node2, exports2);
+      return starttype === types$1._import ? this.parseImport(node) : this.parseExport(node, exports2);
     default:
       if (this.isAsyncFunction()) {
         if (context) {
           this.unexpected();
         }
         this.next();
-        return this.parseFunctionStatement(node2, true, !context);
+        return this.parseFunctionStatement(node, true, !context);
       }
       var maybeName = this.value, expr = this.parseExpression();
       if (starttype === types$1.name && expr.type === "Identifier" && this.eat(types$1.colon)) {
-        return this.parseLabeledStatement(node2, maybeName, expr, context);
+        return this.parseLabeledStatement(node, maybeName, expr, context);
       } else {
-        return this.parseExpressionStatement(node2, expr);
+        return this.parseExpressionStatement(node, expr);
       }
   }
 };
-pp$8.parseBreakContinueStatement = function(node2, keyword) {
+pp$8.parseBreakContinueStatement = function(node, keyword) {
   var isBreak = keyword === "break";
   this.next();
   if (this.eat(types$1.semi) || this.insertSemicolon()) {
-    node2.label = null;
+    node.label = null;
   } else if (this.type !== types$1.name) {
     this.unexpected();
   } else {
-    node2.label = this.parseIdent();
+    node.label = this.parseIdent();
     this.semicolon();
   }
   var i = 0;
   for (; i < this.labels.length; ++i) {
     var lab = this.labels[i];
-    if (node2.label == null || lab.name === node2.label.name) {
+    if (node.label == null || lab.name === node.label.name) {
       if (lab.kind != null && (isBreak || lab.kind === "loop")) {
         break;
       }
-      if (node2.label && isBreak) {
+      if (node.label && isBreak) {
         break;
       }
     }
   }
   if (i === this.labels.length) {
-    this.raise(node2.start, "Unsyntactic " + keyword);
+    this.raise(node.start, "Unsyntactic " + keyword);
   }
-  return this.finishNode(node2, isBreak ? "BreakStatement" : "ContinueStatement");
+  return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
 };
-pp$8.parseDebuggerStatement = function(node2) {
+pp$8.parseDebuggerStatement = function(node) {
   this.next();
   this.semicolon();
-  return this.finishNode(node2, "DebuggerStatement");
+  return this.finishNode(node, "DebuggerStatement");
 };
-pp$8.parseDoStatement = function(node2) {
+pp$8.parseDoStatement = function(node) {
   this.next();
   this.labels.push(loopLabel);
-  node2.body = this.parseStatement("do");
+  node.body = this.parseStatement("do");
   this.labels.pop();
   this.expect(types$1._while);
-  node2.test = this.parseParenExpression();
+  node.test = this.parseParenExpression();
   if (this.options.ecmaVersion >= 6) {
     this.eat(types$1.semi);
   } else {
     this.semicolon();
   }
-  return this.finishNode(node2, "DoWhileStatement");
+  return this.finishNode(node, "DoWhileStatement");
 };
-pp$8.parseForStatement = function(node2) {
+pp$8.parseForStatement = function(node) {
   this.next();
   var awaitAt = this.options.ecmaVersion >= 9 && this.canAwait && this.eatContextual("await") ? this.lastTokStart : -1;
   this.labels.push(loopLabel);
@@ -5142,7 +5151,7 @@ pp$8.parseForStatement = function(node2) {
     if (awaitAt > -1) {
       this.unexpected(awaitAt);
     }
-    return this.parseFor(node2, null);
+    return this.parseFor(node, null);
   }
   var isLet = this.isLet();
   if (this.type === types$1._var || this.type === types$1._const || isLet) {
@@ -5157,15 +5166,15 @@ pp$8.parseForStatement = function(node2) {
             this.unexpected(awaitAt);
           }
         } else {
-          node2.await = awaitAt > -1;
+          node.await = awaitAt > -1;
         }
       }
-      return this.parseForIn(node2, init$1);
+      return this.parseForIn(node, init$1);
     }
     if (awaitAt > -1) {
       this.unexpected(awaitAt);
     }
-    return this.parseFor(node2, init$1);
+    return this.parseFor(node, init$1);
   }
   var startsWithLet = this.isContextual("let"), isForOf = false;
   var refDestructuringErrors = new DestructuringErrors();
@@ -5177,7 +5186,7 @@ pp$8.parseForStatement = function(node2) {
           this.unexpected(awaitAt);
         }
       } else {
-        node2.await = awaitAt > -1;
+        node.await = awaitAt > -1;
       }
     }
     if (startsWithLet && isForOf) {
@@ -5185,43 +5194,43 @@ pp$8.parseForStatement = function(node2) {
     }
     this.toAssignable(init, false, refDestructuringErrors);
     this.checkLValPattern(init);
-    return this.parseForIn(node2, init);
+    return this.parseForIn(node, init);
   } else {
     this.checkExpressionErrors(refDestructuringErrors, true);
   }
   if (awaitAt > -1) {
     this.unexpected(awaitAt);
   }
-  return this.parseFor(node2, init);
+  return this.parseFor(node, init);
 };
-pp$8.parseFunctionStatement = function(node2, isAsync, declarationPosition) {
+pp$8.parseFunctionStatement = function(node, isAsync, declarationPosition) {
   this.next();
-  return this.parseFunction(node2, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync);
+  return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync);
 };
-pp$8.parseIfStatement = function(node2) {
+pp$8.parseIfStatement = function(node) {
   this.next();
-  node2.test = this.parseParenExpression();
-  node2.consequent = this.parseStatement("if");
-  node2.alternate = this.eat(types$1._else) ? this.parseStatement("if") : null;
-  return this.finishNode(node2, "IfStatement");
+  node.test = this.parseParenExpression();
+  node.consequent = this.parseStatement("if");
+  node.alternate = this.eat(types$1._else) ? this.parseStatement("if") : null;
+  return this.finishNode(node, "IfStatement");
 };
-pp$8.parseReturnStatement = function(node2) {
+pp$8.parseReturnStatement = function(node) {
   if (!this.inFunction && !this.options.allowReturnOutsideFunction) {
     this.raise(this.start, "'return' outside of function");
   }
   this.next();
   if (this.eat(types$1.semi) || this.insertSemicolon()) {
-    node2.argument = null;
+    node.argument = null;
   } else {
-    node2.argument = this.parseExpression();
+    node.argument = this.parseExpression();
     this.semicolon();
   }
-  return this.finishNode(node2, "ReturnStatement");
+  return this.finishNode(node, "ReturnStatement");
 };
-pp$8.parseSwitchStatement = function(node2) {
+pp$8.parseSwitchStatement = function(node) {
   this.next();
-  node2.discriminant = this.parseParenExpression();
-  node2.cases = [];
+  node.discriminant = this.parseParenExpression();
+  node.cases = [];
   this.expect(types$1.braceL);
   this.labels.push(switchLabel);
   this.enterScope(0);
@@ -5232,7 +5241,7 @@ pp$8.parseSwitchStatement = function(node2) {
       if (cur) {
         this.finishNode(cur, "SwitchCase");
       }
-      node2.cases.push(cur = this.startNode());
+      node.cases.push(cur = this.startNode());
       cur.consequent = [];
       this.next();
       if (isCase) {
@@ -5258,16 +5267,16 @@ pp$8.parseSwitchStatement = function(node2) {
   }
   this.next();
   this.labels.pop();
-  return this.finishNode(node2, "SwitchStatement");
+  return this.finishNode(node, "SwitchStatement");
 };
-pp$8.parseThrowStatement = function(node2) {
+pp$8.parseThrowStatement = function(node) {
   this.next();
   if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) {
     this.raise(this.lastTokEnd, "Illegal newline after throw");
   }
-  node2.argument = this.parseExpression();
+  node.argument = this.parseExpression();
   this.semicolon();
-  return this.finishNode(node2, "ThrowStatement");
+  return this.finishNode(node, "ThrowStatement");
 };
 var empty$1 = [];
 pp$8.parseCatchClauseParam = function() {
@@ -5278,10 +5287,10 @@ pp$8.parseCatchClauseParam = function() {
   this.expect(types$1.parenR);
   return param;
 };
-pp$8.parseTryStatement = function(node2) {
+pp$8.parseTryStatement = function(node) {
   this.next();
-  node2.block = this.parseBlock();
-  node2.handler = null;
+  node.block = this.parseBlock();
+  node.handler = null;
   if (this.type === types$1._catch) {
     var clause = this.startNode();
     this.next();
@@ -5296,42 +5305,42 @@ pp$8.parseTryStatement = function(node2) {
     }
     clause.body = this.parseBlock(false);
     this.exitScope();
-    node2.handler = this.finishNode(clause, "CatchClause");
+    node.handler = this.finishNode(clause, "CatchClause");
   }
-  node2.finalizer = this.eat(types$1._finally) ? this.parseBlock() : null;
-  if (!node2.handler && !node2.finalizer) {
-    this.raise(node2.start, "Missing catch or finally clause");
+  node.finalizer = this.eat(types$1._finally) ? this.parseBlock() : null;
+  if (!node.handler && !node.finalizer) {
+    this.raise(node.start, "Missing catch or finally clause");
   }
-  return this.finishNode(node2, "TryStatement");
+  return this.finishNode(node, "TryStatement");
 };
-pp$8.parseVarStatement = function(node2, kind, allowMissingInitializer) {
+pp$8.parseVarStatement = function(node, kind, allowMissingInitializer) {
   this.next();
-  this.parseVar(node2, false, kind, allowMissingInitializer);
+  this.parseVar(node, false, kind, allowMissingInitializer);
   this.semicolon();
-  return this.finishNode(node2, "VariableDeclaration");
+  return this.finishNode(node, "VariableDeclaration");
 };
-pp$8.parseWhileStatement = function(node2) {
+pp$8.parseWhileStatement = function(node) {
   this.next();
-  node2.test = this.parseParenExpression();
+  node.test = this.parseParenExpression();
   this.labels.push(loopLabel);
-  node2.body = this.parseStatement("while");
+  node.body = this.parseStatement("while");
   this.labels.pop();
-  return this.finishNode(node2, "WhileStatement");
+  return this.finishNode(node, "WhileStatement");
 };
-pp$8.parseWithStatement = function(node2) {
+pp$8.parseWithStatement = function(node) {
   if (this.strict) {
     this.raise(this.start, "'with' in strict mode");
   }
   this.next();
-  node2.object = this.parseParenExpression();
-  node2.body = this.parseStatement("with");
-  return this.finishNode(node2, "WithStatement");
+  node.object = this.parseParenExpression();
+  node.body = this.parseStatement("with");
+  return this.finishNode(node, "WithStatement");
 };
-pp$8.parseEmptyStatement = function(node2) {
+pp$8.parseEmptyStatement = function(node) {
   this.next();
-  return this.finishNode(node2, "EmptyStatement");
+  return this.finishNode(node, "EmptyStatement");
 };
-pp$8.parseLabeledStatement = function(node2, maybeName, expr, context) {
+pp$8.parseLabeledStatement = function(node, maybeName, expr, context) {
   for (var i$1 = 0, list = this.labels; i$1 < list.length; i$1 += 1) {
     var label = list[i$1];
     if (label.name === maybeName) {
@@ -5341,7 +5350,7 @@ pp$8.parseLabeledStatement = function(node2, maybeName, expr, context) {
   var kind = this.type.isLoop ? "loop" : this.type === types$1._switch ? "switch" : null;
   for (var i = this.labels.length - 1; i >= 0; i--) {
     var label$1 = this.labels[i];
-    if (label$1.statementStart === node2.start) {
+    if (label$1.statementStart === node.start) {
       label$1.statementStart = this.start;
       label$1.kind = kind;
     } else {
@@ -5349,29 +5358,29 @@ pp$8.parseLabeledStatement = function(node2, maybeName, expr, context) {
     }
   }
   this.labels.push({ name: maybeName, kind, statementStart: this.start });
-  node2.body = this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label");
+  node.body = this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label");
   this.labels.pop();
-  node2.label = expr;
-  return this.finishNode(node2, "LabeledStatement");
+  node.label = expr;
+  return this.finishNode(node, "LabeledStatement");
 };
-pp$8.parseExpressionStatement = function(node2, expr) {
-  node2.expression = expr;
+pp$8.parseExpressionStatement = function(node, expr) {
+  node.expression = expr;
   this.semicolon();
-  return this.finishNode(node2, "ExpressionStatement");
+  return this.finishNode(node, "ExpressionStatement");
 };
-pp$8.parseBlock = function(createNewLexicalScope, node2, exitStrict) {
+pp$8.parseBlock = function(createNewLexicalScope, node, exitStrict) {
   if (createNewLexicalScope === void 0)
     createNewLexicalScope = true;
-  if (node2 === void 0)
-    node2 = this.startNode();
-  node2.body = [];
+  if (node === void 0)
+    node = this.startNode();
+  node.body = [];
   this.expect(types$1.braceL);
   if (createNewLexicalScope) {
     this.enterScope(0);
   }
   while (this.type !== types$1.braceR) {
     var stmt = this.parseStatement(null);
-    node2.body.push(stmt);
+    node.body.push(stmt);
   }
   if (exitStrict) {
     this.strict = false;
@@ -5380,21 +5389,21 @@ pp$8.parseBlock = function(createNewLexicalScope, node2, exitStrict) {
   if (createNewLexicalScope) {
     this.exitScope();
   }
-  return this.finishNode(node2, "BlockStatement");
+  return this.finishNode(node, "BlockStatement");
 };
-pp$8.parseFor = function(node2, init) {
-  node2.init = init;
+pp$8.parseFor = function(node, init) {
+  node.init = init;
   this.expect(types$1.semi);
-  node2.test = this.type === types$1.semi ? null : this.parseExpression();
+  node.test = this.type === types$1.semi ? null : this.parseExpression();
   this.expect(types$1.semi);
-  node2.update = this.type === types$1.parenR ? null : this.parseExpression();
+  node.update = this.type === types$1.parenR ? null : this.parseExpression();
   this.expect(types$1.parenR);
-  node2.body = this.parseStatement("for");
+  node.body = this.parseStatement("for");
   this.exitScope();
   this.labels.pop();
-  return this.finishNode(node2, "ForStatement");
+  return this.finishNode(node, "ForStatement");
 };
-pp$8.parseForIn = function(node2, init) {
+pp$8.parseForIn = function(node, init) {
   var isForIn = this.type === types$1._in;
   this.next();
   if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || this.options.ecmaVersion < 8 || this.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
@@ -5403,17 +5412,17 @@ pp$8.parseForIn = function(node2, init) {
       (isForIn ? "for-in" : "for-of") + " loop variable declaration may not have an initializer"
     );
   }
-  node2.left = init;
-  node2.right = isForIn ? this.parseExpression() : this.parseMaybeAssign();
+  node.left = init;
+  node.right = isForIn ? this.parseExpression() : this.parseMaybeAssign();
   this.expect(types$1.parenR);
-  node2.body = this.parseStatement("for");
+  node.body = this.parseStatement("for");
   this.exitScope();
   this.labels.pop();
-  return this.finishNode(node2, isForIn ? "ForInStatement" : "ForOfStatement");
+  return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement");
 };
-pp$8.parseVar = function(node2, isFor, kind, allowMissingInitializer) {
-  node2.declarations = [];
-  node2.kind = kind;
+pp$8.parseVar = function(node, isFor, kind, allowMissingInitializer) {
+  node.declarations = [];
+  node.kind = kind;
   for (; ; ) {
     var decl = this.startNode();
     this.parseVarId(decl, kind);
@@ -5426,12 +5435,12 @@ pp$8.parseVar = function(node2, isFor, kind, allowMissingInitializer) {
     } else {
       decl.init = null;
     }
-    node2.declarations.push(this.finishNode(decl, "VariableDeclarator"));
+    node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
     if (!this.eat(types$1.comma)) {
       break;
     }
   }
-  return node2;
+  return node;
 };
 pp$8.parseVarId = function(decl, kind) {
   decl.id = this.parseBindingAtom();
@@ -5440,56 +5449,56 @@ pp$8.parseVarId = function(decl, kind) {
 var FUNC_STATEMENT = 1;
 var FUNC_HANGING_STATEMENT = 2;
 var FUNC_NULLABLE_ID = 4;
-pp$8.parseFunction = function(node2, statement, allowExpressionBody, isAsync, forInit) {
-  this.initFunction(node2);
+pp$8.parseFunction = function(node, statement, allowExpressionBody, isAsync, forInit) {
+  this.initFunction(node);
   if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync) {
     if (this.type === types$1.star && statement & FUNC_HANGING_STATEMENT) {
       this.unexpected();
     }
-    node2.generator = this.eat(types$1.star);
+    node.generator = this.eat(types$1.star);
   }
   if (this.options.ecmaVersion >= 8) {
-    node2.async = !!isAsync;
+    node.async = !!isAsync;
   }
   if (statement & FUNC_STATEMENT) {
-    node2.id = statement & FUNC_NULLABLE_ID && this.type !== types$1.name ? null : this.parseIdent();
-    if (node2.id && !(statement & FUNC_HANGING_STATEMENT)) {
-      this.checkLValSimple(node2.id, this.strict || node2.generator || node2.async ? this.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION);
+    node.id = statement & FUNC_NULLABLE_ID && this.type !== types$1.name ? null : this.parseIdent();
+    if (node.id && !(statement & FUNC_HANGING_STATEMENT)) {
+      this.checkLValSimple(node.id, this.strict || node.generator || node.async ? this.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION);
     }
   }
   var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
   this.yieldPos = 0;
   this.awaitPos = 0;
   this.awaitIdentPos = 0;
-  this.enterScope(functionFlags(node2.async, node2.generator));
+  this.enterScope(functionFlags(node.async, node.generator));
   if (!(statement & FUNC_STATEMENT)) {
-    node2.id = this.type === types$1.name ? this.parseIdent() : null;
+    node.id = this.type === types$1.name ? this.parseIdent() : null;
   }
-  this.parseFunctionParams(node2);
-  this.parseFunctionBody(node2, allowExpressionBody, false, forInit);
+  this.parseFunctionParams(node);
+  this.parseFunctionBody(node, allowExpressionBody, false, forInit);
   this.yieldPos = oldYieldPos;
   this.awaitPos = oldAwaitPos;
   this.awaitIdentPos = oldAwaitIdentPos;
-  return this.finishNode(node2, statement & FUNC_STATEMENT ? "FunctionDeclaration" : "FunctionExpression");
+  return this.finishNode(node, statement & FUNC_STATEMENT ? "FunctionDeclaration" : "FunctionExpression");
 };
-pp$8.parseFunctionParams = function(node2) {
+pp$8.parseFunctionParams = function(node) {
   this.expect(types$1.parenL);
-  node2.params = this.parseBindingList(types$1.parenR, false, this.options.ecmaVersion >= 8);
+  node.params = this.parseBindingList(types$1.parenR, false, this.options.ecmaVersion >= 8);
   this.checkYieldAwaitInDefaultParams();
 };
-pp$8.parseClass = function(node2, isStatement) {
+pp$8.parseClass = function(node, isStatement) {
   this.next();
   var oldStrict = this.strict;
   this.strict = true;
-  this.parseClassId(node2, isStatement);
-  this.parseClassSuper(node2);
+  this.parseClassId(node, isStatement);
+  this.parseClassSuper(node);
   var privateNameMap = this.enterClassBody();
   var classBody = this.startNode();
   var hadConstructor = false;
   classBody.body = [];
   this.expect(types$1.braceL);
   while (this.type !== types$1.braceR) {
-    var element = this.parseClassElement(node2.superClass !== null);
+    var element = this.parseClassElement(node.superClass !== null);
     if (element) {
       classBody.body.push(element);
       if (element.type === "MethodDefinition" && element.kind === "constructor") {
@@ -5504,16 +5513,16 @@ pp$8.parseClass = function(node2, isStatement) {
   }
   this.strict = oldStrict;
   this.next();
-  node2.body = this.finishNode(classBody, "ClassBody");
+  node.body = this.finishNode(classBody, "ClassBody");
   this.exitClassBody();
-  return this.finishNode(node2, isStatement ? "ClassDeclaration" : "ClassExpression");
+  return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
 };
 pp$8.parseClassElement = function(constructorAllowsSuper) {
   if (this.eat(types$1.semi)) {
     return null;
   }
   var ecmaVersion = this.options.ecmaVersion;
-  var node2 = this.startNode();
+  var node = this.startNode();
   var keyName = "";
   var isGenerator = false;
   var isAsync = false;
@@ -5521,8 +5530,8 @@ pp$8.parseClassElement = function(constructorAllowsSuper) {
   var isStatic = false;
   if (this.eatContextual("static")) {
     if (ecmaVersion >= 13 && this.eat(types$1.braceL)) {
-      this.parseClassStaticBlock(node2);
-      return node2;
+      this.parseClassStaticBlock(node);
+      return node;
     }
     if (this.isClassElementNameStart() || this.type === types$1.star) {
       isStatic = true;
@@ -5530,7 +5539,7 @@ pp$8.parseClassElement = function(constructorAllowsSuper) {
       keyName = "static";
     }
   }
-  node2.static = isStatic;
+  node.static = isStatic;
   if (!keyName && ecmaVersion >= 8 && this.eatContextual("async")) {
     if ((this.isClassElementNameStart() || this.type === types$1.star) && !this.canInsertSemicolon()) {
       isAsync = true;
@@ -5552,25 +5561,25 @@ pp$8.parseClassElement = function(constructorAllowsSuper) {
     }
   }
   if (keyName) {
-    node2.computed = false;
-    node2.key = this.startNodeAt(this.lastTokStart, this.lastTokStartLoc);
-    node2.key.name = keyName;
-    this.finishNode(node2.key, "Identifier");
+    node.computed = false;
+    node.key = this.startNodeAt(this.lastTokStart, this.lastTokStartLoc);
+    node.key.name = keyName;
+    this.finishNode(node.key, "Identifier");
   } else {
-    this.parseClassElementName(node2);
+    this.parseClassElementName(node);
   }
   if (ecmaVersion < 13 || this.type === types$1.parenL || kind !== "method" || isGenerator || isAsync) {
-    var isConstructor = !node2.static && checkKeyName(node2, "constructor");
+    var isConstructor = !node.static && checkKeyName(node, "constructor");
     var allowsDirectSuper = isConstructor && constructorAllowsSuper;
     if (isConstructor && kind !== "method") {
-      this.raise(node2.key.start, "Constructor can't have get/set modifier");
+      this.raise(node.key.start, "Constructor can't have get/set modifier");
     }
-    node2.kind = isConstructor ? "constructor" : kind;
-    this.parseClassMethod(node2, isGenerator, isAsync, allowsDirectSuper);
+    node.kind = isConstructor ? "constructor" : kind;
+    this.parseClassMethod(node, isGenerator, isAsync, allowsDirectSuper);
   } else {
-    this.parseClassField(node2);
+    this.parseClassField(node);
   }
-  return node2;
+  return node;
 };
 pp$8.isClassElementNameStart = function() {
   return this.type === types$1.name || this.type === types$1.privateId || this.type === types$1.num || this.type === types$1.string || this.type === types$1.bracketL || this.type.keyword;
@@ -5628,35 +5637,35 @@ pp$8.parseClassField = function(field) {
   this.semicolon();
   return this.finishNode(field, "PropertyDefinition");
 };
-pp$8.parseClassStaticBlock = function(node2) {
-  node2.body = [];
+pp$8.parseClassStaticBlock = function(node) {
+  node.body = [];
   var oldLabels = this.labels;
   this.labels = [];
   this.enterScope(SCOPE_CLASS_STATIC_BLOCK | SCOPE_SUPER);
   while (this.type !== types$1.braceR) {
     var stmt = this.parseStatement(null);
-    node2.body.push(stmt);
+    node.body.push(stmt);
   }
   this.next();
   this.exitScope();
   this.labels = oldLabels;
-  return this.finishNode(node2, "StaticBlock");
+  return this.finishNode(node, "StaticBlock");
 };
-pp$8.parseClassId = function(node2, isStatement) {
+pp$8.parseClassId = function(node, isStatement) {
   if (this.type === types$1.name) {
-    node2.id = this.parseIdent();
+    node.id = this.parseIdent();
     if (isStatement) {
-      this.checkLValSimple(node2.id, BIND_LEXICAL, false);
+      this.checkLValSimple(node.id, BIND_LEXICAL, false);
     }
   } else {
     if (isStatement === true) {
       this.unexpected();
     }
-    node2.id = null;
+    node.id = null;
   }
 };
-pp$8.parseClassSuper = function(node2) {
-  node2.superClass = this.eat(types$1._extends) ? this.parseExprSubscripts(null, false) : null;
+pp$8.parseClassSuper = function(node) {
+  node.superClass = this.eat(types$1._extends) ? this.parseExprSubscripts(null, false) : null;
 };
 pp$8.enterClassBody = function() {
   var element = { declared: /* @__PURE__ */ Object.create(null), used: [] };
@@ -5700,57 +5709,57 @@ function isPrivateNameConflicted(privateNameMap, element) {
     return true;
   }
 }
-function checkKeyName(node2, name) {
-  var computed = node2.computed;
-  var key = node2.key;
+function checkKeyName(node, name) {
+  var computed = node.computed;
+  var key = node.key;
   return !computed && (key.type === "Identifier" && key.name === name || key.type === "Literal" && key.value === name);
 }
-pp$8.parseExportAllDeclaration = function(node2, exports2) {
+pp$8.parseExportAllDeclaration = function(node, exports2) {
   if (this.options.ecmaVersion >= 11) {
     if (this.eatContextual("as")) {
-      node2.exported = this.parseModuleExportName();
-      this.checkExport(exports2, node2.exported, this.lastTokStart);
+      node.exported = this.parseModuleExportName();
+      this.checkExport(exports2, node.exported, this.lastTokStart);
     } else {
-      node2.exported = null;
+      node.exported = null;
     }
   }
   this.expectContextual("from");
   if (this.type !== types$1.string) {
     this.unexpected();
   }
-  node2.source = this.parseExprAtom();
+  node.source = this.parseExprAtom();
   this.semicolon();
-  return this.finishNode(node2, "ExportAllDeclaration");
+  return this.finishNode(node, "ExportAllDeclaration");
 };
-pp$8.parseExport = function(node2, exports2) {
+pp$8.parseExport = function(node, exports2) {
   this.next();
   if (this.eat(types$1.star)) {
-    return this.parseExportAllDeclaration(node2, exports2);
+    return this.parseExportAllDeclaration(node, exports2);
   }
   if (this.eat(types$1._default)) {
     this.checkExport(exports2, "default", this.lastTokStart);
-    node2.declaration = this.parseExportDefaultDeclaration();
-    return this.finishNode(node2, "ExportDefaultDeclaration");
+    node.declaration = this.parseExportDefaultDeclaration();
+    return this.finishNode(node, "ExportDefaultDeclaration");
   }
   if (this.shouldParseExportStatement()) {
-    node2.declaration = this.parseExportDeclaration(node2);
-    if (node2.declaration.type === "VariableDeclaration") {
-      this.checkVariableExport(exports2, node2.declaration.declarations);
+    node.declaration = this.parseExportDeclaration(node);
+    if (node.declaration.type === "VariableDeclaration") {
+      this.checkVariableExport(exports2, node.declaration.declarations);
     } else {
-      this.checkExport(exports2, node2.declaration.id, node2.declaration.id.start);
+      this.checkExport(exports2, node.declaration.id, node.declaration.id.start);
     }
-    node2.specifiers = [];
-    node2.source = null;
+    node.specifiers = [];
+    node.source = null;
   } else {
-    node2.declaration = null;
-    node2.specifiers = this.parseExportSpecifiers(exports2);
+    node.declaration = null;
+    node.specifiers = this.parseExportSpecifiers(exports2);
     if (this.eatContextual("from")) {
       if (this.type !== types$1.string) {
         this.unexpected();
       }
-      node2.source = this.parseExprAtom();
+      node.source = this.parseExprAtom();
     } else {
-      for (var i = 0, list = node2.specifiers; i < list.length; i += 1) {
+      for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
         var spec = list[i];
         this.checkUnreserved(spec.local);
         this.checkLocalExport(spec.local);
@@ -5758,13 +5767,13 @@ pp$8.parseExport = function(node2, exports2) {
           this.raise(spec.local.start, "A string literal cannot be used as an exported binding without `from`.");
         }
       }
-      node2.source = null;
+      node.source = null;
     }
     this.semicolon();
   }
-  return this.finishNode(node2, "ExportNamedDeclaration");
+  return this.finishNode(node, "ExportNamedDeclaration");
 };
-pp$8.parseExportDeclaration = function(node2) {
+pp$8.parseExportDeclaration = function(node) {
   return this.parseStatement(null);
 };
 pp$8.parseExportDefaultDeclaration = function() {
@@ -5834,15 +5843,15 @@ pp$8.shouldParseExportStatement = function() {
   return this.type.keyword === "var" || this.type.keyword === "const" || this.type.keyword === "class" || this.type.keyword === "function" || this.isLet() || this.isAsyncFunction();
 };
 pp$8.parseExportSpecifier = function(exports2) {
-  var node2 = this.startNode();
-  node2.local = this.parseModuleExportName();
-  node2.exported = this.eatContextual("as") ? this.parseModuleExportName() : node2.local;
+  var node = this.startNode();
+  node.local = this.parseModuleExportName();
+  node.exported = this.eatContextual("as") ? this.parseModuleExportName() : node.local;
   this.checkExport(
     exports2,
-    node2.exported,
-    node2.exported.start
+    node.exported,
+    node.exported.start
   );
-  return this.finishNode(node2, "ExportSpecifier");
+  return this.finishNode(node, "ExportSpecifier");
 };
 pp$8.parseExportSpecifiers = function(exports2) {
   var nodes = [], first = true;
@@ -5860,44 +5869,44 @@ pp$8.parseExportSpecifiers = function(exports2) {
   }
   return nodes;
 };
-pp$8.parseImport = function(node2) {
+pp$8.parseImport = function(node) {
   this.next();
   if (this.type === types$1.string) {
-    node2.specifiers = empty$1;
-    node2.source = this.parseExprAtom();
+    node.specifiers = empty$1;
+    node.source = this.parseExprAtom();
   } else {
-    node2.specifiers = this.parseImportSpecifiers();
+    node.specifiers = this.parseImportSpecifiers();
     this.expectContextual("from");
-    node2.source = this.type === types$1.string ? this.parseExprAtom() : this.unexpected();
+    node.source = this.type === types$1.string ? this.parseExprAtom() : this.unexpected();
   }
   this.semicolon();
-  return this.finishNode(node2, "ImportDeclaration");
+  return this.finishNode(node, "ImportDeclaration");
 };
 pp$8.parseImportSpecifier = function() {
-  var node2 = this.startNode();
-  node2.imported = this.parseModuleExportName();
+  var node = this.startNode();
+  node.imported = this.parseModuleExportName();
   if (this.eatContextual("as")) {
-    node2.local = this.parseIdent();
+    node.local = this.parseIdent();
   } else {
-    this.checkUnreserved(node2.imported);
-    node2.local = node2.imported;
+    this.checkUnreserved(node.imported);
+    node.local = node.imported;
   }
-  this.checkLValSimple(node2.local, BIND_LEXICAL);
-  return this.finishNode(node2, "ImportSpecifier");
+  this.checkLValSimple(node.local, BIND_LEXICAL);
+  return this.finishNode(node, "ImportSpecifier");
 };
 pp$8.parseImportDefaultSpecifier = function() {
-  var node2 = this.startNode();
-  node2.local = this.parseIdent();
-  this.checkLValSimple(node2.local, BIND_LEXICAL);
-  return this.finishNode(node2, "ImportDefaultSpecifier");
+  var node = this.startNode();
+  node.local = this.parseIdent();
+  this.checkLValSimple(node.local, BIND_LEXICAL);
+  return this.finishNode(node, "ImportDefaultSpecifier");
 };
 pp$8.parseImportNamespaceSpecifier = function() {
-  var node2 = this.startNode();
+  var node = this.startNode();
   this.next();
   this.expectContextual("as");
-  node2.local = this.parseIdent();
-  this.checkLValSimple(node2.local, BIND_LEXICAL);
-  return this.finishNode(node2, "ImportNamespaceSpecifier");
+  node.local = this.parseIdent();
+  this.checkLValSimple(node.local, BIND_LEXICAL);
+  return this.finishNode(node, "ImportNamespaceSpecifier");
 };
 pp$8.parseImportSpecifiers = function() {
   var nodes = [], first = true;
@@ -5945,12 +5954,12 @@ pp$8.isDirectiveCandidate = function(statement) {
   (this.input[statement.start] === '"' || this.input[statement.start] === "'");
 };
 var pp$7 = Parser.prototype;
-pp$7.toAssignable = function(node2, isBinding, refDestructuringErrors) {
-  if (this.options.ecmaVersion >= 6 && node2) {
-    switch (node2.type) {
+pp$7.toAssignable = function(node, isBinding, refDestructuringErrors) {
+  if (this.options.ecmaVersion >= 6 && node) {
+    switch (node.type) {
       case "Identifier":
-        if (this.inAsync && node2.name === "await") {
-          this.raise(node2.start, "Cannot use 'await' as identifier inside an async function");
+        if (this.inAsync && node.name === "await") {
+          this.raise(node.start, "Cannot use 'await' as identifier inside an async function");
         }
         break;
       case "ObjectPattern":
@@ -5959,11 +5968,11 @@ pp$7.toAssignable = function(node2, isBinding, refDestructuringErrors) {
       case "RestElement":
         break;
       case "ObjectExpression":
-        node2.type = "ObjectPattern";
+        node.type = "ObjectPattern";
         if (refDestructuringErrors) {
           this.checkPatternErrors(refDestructuringErrors, true);
         }
-        for (var i = 0, list = node2.properties; i < list.length; i += 1) {
+        for (var i = 0, list = node.properties; i < list.length; i += 1) {
           var prop = list[i];
           this.toAssignable(prop, isBinding);
           if (prop.type === "RestElement" && (prop.argument.type === "ArrayPattern" || prop.argument.type === "ObjectPattern")) {
@@ -5972,50 +5981,50 @@ pp$7.toAssignable = function(node2, isBinding, refDestructuringErrors) {
         }
         break;
       case "Property":
-        if (node2.kind !== "init") {
-          this.raise(node2.key.start, "Object pattern can't contain getter or setter");
+        if (node.kind !== "init") {
+          this.raise(node.key.start, "Object pattern can't contain getter or setter");
         }
-        this.toAssignable(node2.value, isBinding);
+        this.toAssignable(node.value, isBinding);
         break;
       case "ArrayExpression":
-        node2.type = "ArrayPattern";
+        node.type = "ArrayPattern";
         if (refDestructuringErrors) {
           this.checkPatternErrors(refDestructuringErrors, true);
         }
-        this.toAssignableList(node2.elements, isBinding);
+        this.toAssignableList(node.elements, isBinding);
         break;
       case "SpreadElement":
-        node2.type = "RestElement";
-        this.toAssignable(node2.argument, isBinding);
-        if (node2.argument.type === "AssignmentPattern") {
-          this.raise(node2.argument.start, "Rest elements cannot have a default value");
+        node.type = "RestElement";
+        this.toAssignable(node.argument, isBinding);
+        if (node.argument.type === "AssignmentPattern") {
+          this.raise(node.argument.start, "Rest elements cannot have a default value");
         }
         break;
       case "AssignmentExpression":
-        if (node2.operator !== "=") {
-          this.raise(node2.left.end, "Only '=' operator can be used for specifying default value.");
+        if (node.operator !== "=") {
+          this.raise(node.left.end, "Only '=' operator can be used for specifying default value.");
         }
-        node2.type = "AssignmentPattern";
-        delete node2.operator;
-        this.toAssignable(node2.left, isBinding);
+        node.type = "AssignmentPattern";
+        delete node.operator;
+        this.toAssignable(node.left, isBinding);
         break;
       case "ParenthesizedExpression":
-        this.toAssignable(node2.expression, isBinding, refDestructuringErrors);
+        this.toAssignable(node.expression, isBinding, refDestructuringErrors);
         break;
       case "ChainExpression":
-        this.raiseRecoverable(node2.start, "Optional chaining cannot appear in left-hand side");
+        this.raiseRecoverable(node.start, "Optional chaining cannot appear in left-hand side");
         break;
       case "MemberExpression":
         if (!isBinding) {
           break;
         }
       default:
-        this.raise(node2.start, "Assigning to rvalue");
+        this.raise(node.start, "Assigning to rvalue");
     }
   } else if (refDestructuringErrors) {
     this.checkPatternErrors(refDestructuringErrors, true);
   }
-  return node2;
+  return node;
 };
 pp$7.toAssignableList = function(exprList, isBinding) {
   var end = exprList.length;
@@ -6034,28 +6043,28 @@ pp$7.toAssignableList = function(exprList, isBinding) {
   return exprList;
 };
 pp$7.parseSpread = function(refDestructuringErrors) {
-  var node2 = this.startNode();
+  var node = this.startNode();
   this.next();
-  node2.argument = this.parseMaybeAssign(false, refDestructuringErrors);
-  return this.finishNode(node2, "SpreadElement");
+  node.argument = this.parseMaybeAssign(false, refDestructuringErrors);
+  return this.finishNode(node, "SpreadElement");
 };
 pp$7.parseRestBinding = function() {
-  var node2 = this.startNode();
+  var node = this.startNode();
   this.next();
   if (this.options.ecmaVersion === 6 && this.type !== types$1.name) {
     this.unexpected();
   }
-  node2.argument = this.parseBindingAtom();
-  return this.finishNode(node2, "RestElement");
+  node.argument = this.parseBindingAtom();
+  return this.finishNode(node, "RestElement");
 };
 pp$7.parseBindingAtom = function() {
   if (this.options.ecmaVersion >= 6) {
     switch (this.type) {
       case types$1.bracketL:
-        var node2 = this.startNode();
+        var node = this.startNode();
         this.next();
-        node2.elements = this.parseBindingList(types$1.bracketR, true, true);
-        return this.finishNode(node2, "ArrayPattern");
+        node.elements = this.parseBindingList(types$1.bracketR, true, true);
+        return this.finishNode(node, "ArrayPattern");
       case types$1.braceL:
         return this.parseObj(true);
     }
@@ -6102,10 +6111,10 @@ pp$7.parseMaybeDefault = function(startPos, startLoc, left) {
   if (this.options.ecmaVersion < 6 || !this.eat(types$1.eq)) {
     return left;
   }
-  var node2 = this.startNodeAt(startPos, startLoc);
-  node2.left = left;
-  node2.right = this.parseMaybeAssign();
-  return this.finishNode(node2, "AssignmentPattern");
+  var node = this.startNodeAt(startPos, startLoc);
+  node.left = left;
+  node.right = this.parseMaybeAssign();
+  return this.finishNode(node, "AssignmentPattern");
 };
 pp$7.checkLValSimple = function(expr, bindingType, checkClashes) {
   if (bindingType === void 0)
@@ -6390,12 +6399,12 @@ pp$5.parseExpression = function(forInit, refDestructuringErrors) {
   var startPos = this.start, startLoc = this.startLoc;
   var expr = this.parseMaybeAssign(forInit, refDestructuringErrors);
   if (this.type === types$1.comma) {
-    var node2 = this.startNodeAt(startPos, startLoc);
-    node2.expressions = [expr];
+    var node = this.startNodeAt(startPos, startLoc);
+    node.expressions = [expr];
     while (this.eat(types$1.comma)) {
-      node2.expressions.push(this.parseMaybeAssign(forInit, refDestructuringErrors));
+      node.expressions.push(this.parseMaybeAssign(forInit, refDestructuringErrors));
     }
-    return this.finishNode(node2, "SequenceExpression");
+    return this.finishNode(node, "SequenceExpression");
   }
   return expr;
 };
@@ -6427,8 +6436,8 @@ pp$5.parseMaybeAssign = function(forInit, refDestructuringErrors, afterLeftParse
     left = afterLeftParse.call(this, left, startPos, startLoc);
   }
   if (this.type.isAssign) {
-    var node2 = this.startNodeAt(startPos, startLoc);
-    node2.operator = this.value;
+    var node = this.startNodeAt(startPos, startLoc);
+    node.operator = this.value;
     if (this.type === types$1.eq) {
       left = this.toAssignable(left, false, refDestructuringErrors);
     }
@@ -6443,13 +6452,13 @@ pp$5.parseMaybeAssign = function(forInit, refDestructuringErrors, afterLeftParse
     } else {
       this.checkLValSimple(left);
     }
-    node2.left = left;
+    node.left = left;
     this.next();
-    node2.right = this.parseMaybeAssign(forInit);
+    node.right = this.parseMaybeAssign(forInit);
     if (oldDoubleProto > -1) {
       refDestructuringErrors.doubleProto = oldDoubleProto;
     }
-    return this.finishNode(node2, "AssignmentExpression");
+    return this.finishNode(node, "AssignmentExpression");
   } else {
     if (ownDestructuringErrors) {
       this.checkExpressionErrors(refDestructuringErrors, true);
@@ -6470,12 +6479,12 @@ pp$5.parseMaybeConditional = function(forInit, refDestructuringErrors) {
     return expr;
   }
   if (this.eat(types$1.question)) {
-    var node2 = this.startNodeAt(startPos, startLoc);
-    node2.test = expr;
-    node2.consequent = this.parseMaybeAssign();
+    var node = this.startNodeAt(startPos, startLoc);
+    node.test = expr;
+    node.consequent = this.parseMaybeAssign();
     this.expect(types$1.colon);
-    node2.alternate = this.parseMaybeAssign(forInit);
-    return this.finishNode(node2, "ConditionalExpression");
+    node.alternate = this.parseMaybeAssign(forInit);
+    return this.finishNode(node, "ConditionalExpression");
   }
   return expr;
 };
@@ -6500,11 +6509,11 @@ pp$5.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, forInit)
       this.next();
       var startPos = this.start, startLoc = this.startLoc;
       var right = this.parseExprOp(this.parseMaybeUnary(null, false, false, forInit), startPos, startLoc, prec, forInit);
-      var node2 = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical || coalesce);
+      var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical || coalesce);
       if (logical && this.type === types$1.coalesce || coalesce && (this.type === types$1.logicalOR || this.type === types$1.logicalAND)) {
         this.raiseRecoverable(this.start, "Logical expressions and coalesce expressions cannot be mixed. Wrap either by parentheses");
       }
-      return this.parseExprOp(node2, leftStartPos, leftStartLoc, minPrec, forInit);
+      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, forInit);
     }
   }
   return left;
@@ -6513,11 +6522,11 @@ pp$5.buildBinary = function(startPos, startLoc, left, right, op, logical) {
   if (right.type === "PrivateIdentifier") {
     this.raise(right.start, "Private identifier can only be left side of binary expression");
   }
-  var node2 = this.startNodeAt(startPos, startLoc);
-  node2.left = left;
-  node2.operator = op;
-  node2.right = right;
-  return this.finishNode(node2, logical ? "LogicalExpression" : "BinaryExpression");
+  var node = this.startNodeAt(startPos, startLoc);
+  node.left = left;
+  node.operator = op;
+  node.right = right;
+  return this.finishNode(node, logical ? "LogicalExpression" : "BinaryExpression");
 };
 pp$5.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec, forInit) {
   var startPos = this.start, startLoc = this.startLoc, expr;
@@ -6525,22 +6534,22 @@ pp$5.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec, forIni
     expr = this.parseAwait(forInit);
     sawUnary = true;
   } else if (this.type.prefix) {
-    var node2 = this.startNode(), update = this.type === types$1.incDec;
-    node2.operator = this.value;
-    node2.prefix = true;
+    var node = this.startNode(), update = this.type === types$1.incDec;
+    node.operator = this.value;
+    node.prefix = true;
     this.next();
-    node2.argument = this.parseMaybeUnary(null, true, update, forInit);
+    node.argument = this.parseMaybeUnary(null, true, update, forInit);
     this.checkExpressionErrors(refDestructuringErrors, true);
     if (update) {
-      this.checkLValSimple(node2.argument);
-    } else if (this.strict && node2.operator === "delete" && node2.argument.type === "Identifier") {
-      this.raiseRecoverable(node2.start, "Deleting local variable in strict mode");
-    } else if (node2.operator === "delete" && isPrivateFieldAccess(node2.argument)) {
-      this.raiseRecoverable(node2.start, "Private fields can not be deleted");
+      this.checkLValSimple(node.argument);
+    } else if (this.strict && node.operator === "delete" && node.argument.type === "Identifier") {
+      this.raiseRecoverable(node.start, "Deleting local variable in strict mode");
+    } else if (node.operator === "delete" && isPrivateFieldAccess(node.argument)) {
+      this.raiseRecoverable(node.start, "Private fields can not be deleted");
     } else {
       sawUnary = true;
     }
-    expr = this.finishNode(node2, update ? "UpdateExpression" : "UnaryExpression");
+    expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
   } else if (!sawUnary && this.type === types$1.privateId) {
     if ((forInit || this.privateNameStack.length === 0) && this.options.checkPrivateFields) {
       this.unexpected();
@@ -6574,8 +6583,8 @@ pp$5.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec, forIni
     return expr;
   }
 };
-function isPrivateFieldAccess(node2) {
-  return node2.type === "MemberExpression" && node2.property.type === "PrivateIdentifier" || node2.type === "ChainExpression" && isPrivateFieldAccess(node2.expression);
+function isPrivateFieldAccess(node) {
+  return node.type === "MemberExpression" && node.property.type === "PrivateIdentifier" || node.type === "ChainExpression" && isPrivateFieldAccess(node.expression);
 }
 pp$5.parseExprSubscripts = function(refDestructuringErrors, forInit) {
   var startPos = this.start, startLoc = this.startLoc;
@@ -6630,21 +6639,21 @@ pp$5.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArro
   }
   var computed = this.eat(types$1.bracketL);
   if (computed || optional && this.type !== types$1.parenL && this.type !== types$1.backQuote || this.eat(types$1.dot)) {
-    var node2 = this.startNodeAt(startPos, startLoc);
-    node2.object = base;
+    var node = this.startNodeAt(startPos, startLoc);
+    node.object = base;
     if (computed) {
-      node2.property = this.parseExpression();
+      node.property = this.parseExpression();
       this.expect(types$1.bracketR);
     } else if (this.type === types$1.privateId && base.type !== "Super") {
-      node2.property = this.parsePrivateIdent();
+      node.property = this.parsePrivateIdent();
     } else {
-      node2.property = this.parseIdent(this.options.allowReserved !== "never");
+      node.property = this.parseIdent(this.options.allowReserved !== "never");
     }
-    node2.computed = !!computed;
+    node.computed = !!computed;
     if (optionalSupported) {
-      node2.optional = optional;
+      node.optional = optional;
     }
-    base = this.finishNode(node2, "MemberExpression");
+    base = this.finishNode(node, "MemberExpression");
   } else if (!noCalls && this.eat(types$1.parenL)) {
     var refDestructuringErrors = new DestructuringErrors(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
     this.yieldPos = 0;
@@ -6688,25 +6697,25 @@ pp$5.parseExprAtom = function(refDestructuringErrors, forInit, forNew) {
   if (this.type === types$1.slash) {
     this.readRegexp();
   }
-  var node2, canBeArrow = this.potentialArrowAt === this.start;
+  var node, canBeArrow = this.potentialArrowAt === this.start;
   switch (this.type) {
     case types$1._super:
       if (!this.allowSuper) {
         this.raise(this.start, "'super' keyword outside a method");
       }
-      node2 = this.startNode();
+      node = this.startNode();
       this.next();
       if (this.type === types$1.parenL && !this.allowDirectSuper) {
-        this.raise(node2.start, "super() call outside constructor of a subclass");
+        this.raise(node.start, "super() call outside constructor of a subclass");
       }
       if (this.type !== types$1.dot && this.type !== types$1.bracketL && this.type !== types$1.parenL) {
         this.unexpected();
       }
-      return this.finishNode(node2, "Super");
+      return this.finishNode(node, "Super");
     case types$1._this:
-      node2 = this.startNode();
+      node = this.startNode();
       this.next();
-      return this.finishNode(node2, "ThisExpression");
+      return this.finishNode(node, "ThisExpression");
     case types$1.name:
       var startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc;
       var id = this.parseIdent(false);
@@ -6729,20 +6738,20 @@ pp$5.parseExprAtom = function(refDestructuringErrors, forInit, forNew) {
       return id;
     case types$1.regexp:
       var value = this.value;
-      node2 = this.parseLiteral(value.value);
-      node2.regex = { pattern: value.pattern, flags: value.flags };
-      return node2;
+      node = this.parseLiteral(value.value);
+      node.regex = { pattern: value.pattern, flags: value.flags };
+      return node;
     case types$1.num:
     case types$1.string:
       return this.parseLiteral(this.value);
     case types$1._null:
     case types$1._true:
     case types$1._false:
-      node2 = this.startNode();
-      node2.value = this.type === types$1._null ? null : this.type === types$1._true;
-      node2.raw = this.type.keyword;
+      node = this.startNode();
+      node.value = this.type === types$1._null ? null : this.type === types$1._true;
+      node.raw = this.type.keyword;
       this.next();
-      return this.finishNode(node2, "Literal");
+      return this.finishNode(node, "Literal");
     case types$1.parenL:
       var start = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow, forInit);
       if (refDestructuringErrors) {
@@ -6755,17 +6764,17 @@ pp$5.parseExprAtom = function(refDestructuringErrors, forInit, forNew) {
       }
       return expr;
     case types$1.bracketL:
-      node2 = this.startNode();
+      node = this.startNode();
       this.next();
-      node2.elements = this.parseExprList(types$1.bracketR, true, true, refDestructuringErrors);
-      return this.finishNode(node2, "ArrayExpression");
+      node.elements = this.parseExprList(types$1.bracketR, true, true, refDestructuringErrors);
+      return this.finishNode(node, "ArrayExpression");
     case types$1.braceL:
       this.overrideContext(types.b_expr);
       return this.parseObj(false, refDestructuringErrors);
     case types$1._function:
-      node2 = this.startNode();
+      node = this.startNode();
       this.next();
-      return this.parseFunction(node2, 0);
+      return this.parseFunction(node, 0);
     case types$1._class:
       return this.parseClass(this.startNode(), false);
     case types$1._new:
@@ -6786,25 +6795,25 @@ pp$5.parseExprAtomDefault = function() {
   this.unexpected();
 };
 pp$5.parseExprImport = function(forNew) {
-  var node2 = this.startNode();
+  var node = this.startNode();
   if (this.containsEsc) {
     this.raiseRecoverable(this.start, "Escape sequence in keyword import");
   }
   this.next();
   if (this.type === types$1.parenL && !forNew) {
-    return this.parseDynamicImport(node2);
+    return this.parseDynamicImport(node);
   } else if (this.type === types$1.dot) {
-    var meta = this.startNodeAt(node2.start, node2.loc && node2.loc.start);
+    var meta = this.startNodeAt(node.start, node.loc && node.loc.start);
     meta.name = "import";
-    node2.meta = this.finishNode(meta, "Identifier");
-    return this.parseImportMeta(node2);
+    node.meta = this.finishNode(meta, "Identifier");
+    return this.parseImportMeta(node);
   } else {
     this.unexpected();
   }
 };
-pp$5.parseDynamicImport = function(node2) {
+pp$5.parseDynamicImport = function(node) {
   this.next();
-  node2.source = this.parseMaybeAssign();
+  node.source = this.parseMaybeAssign();
   if (!this.eat(types$1.parenR)) {
     var errorPos = this.start;
     if (this.eat(types$1.comma) && this.eat(types$1.parenR)) {
@@ -6813,32 +6822,32 @@ pp$5.parseDynamicImport = function(node2) {
       this.unexpected(errorPos);
     }
   }
-  return this.finishNode(node2, "ImportExpression");
+  return this.finishNode(node, "ImportExpression");
 };
-pp$5.parseImportMeta = function(node2) {
+pp$5.parseImportMeta = function(node) {
   this.next();
   var containsEsc = this.containsEsc;
-  node2.property = this.parseIdent(true);
-  if (node2.property.name !== "meta") {
-    this.raiseRecoverable(node2.property.start, "The only valid meta property for import is 'import.meta'");
+  node.property = this.parseIdent(true);
+  if (node.property.name !== "meta") {
+    this.raiseRecoverable(node.property.start, "The only valid meta property for import is 'import.meta'");
   }
   if (containsEsc) {
-    this.raiseRecoverable(node2.start, "'import.meta' must not contain escaped characters");
+    this.raiseRecoverable(node.start, "'import.meta' must not contain escaped characters");
   }
   if (this.options.sourceType !== "module" && !this.options.allowImportExportEverywhere) {
-    this.raiseRecoverable(node2.start, "Cannot use 'import.meta' outside a module");
+    this.raiseRecoverable(node.start, "Cannot use 'import.meta' outside a module");
   }
-  return this.finishNode(node2, "MetaProperty");
+  return this.finishNode(node, "MetaProperty");
 };
 pp$5.parseLiteral = function(value) {
-  var node2 = this.startNode();
-  node2.value = value;
-  node2.raw = this.input.slice(this.start, this.end);
-  if (node2.raw.charCodeAt(node2.raw.length - 1) === 110) {
-    node2.bigint = node2.raw.slice(0, -1).replace(/_/g, "");
+  var node = this.startNode();
+  node.value = value;
+  node.raw = this.input.slice(this.start, this.end);
+  if (node.raw.charCodeAt(node.raw.length - 1) === 110) {
+    node.bigint = node.raw.slice(0, -1).replace(/_/g, "");
   }
   this.next();
-  return this.finishNode(node2, "Literal");
+  return this.finishNode(node, "Literal");
 };
 pp$5.parseParenExpression = function() {
   this.expect(types$1.parenL);
@@ -6924,34 +6933,34 @@ pp$5.parseNew = function() {
   if (this.containsEsc) {
     this.raiseRecoverable(this.start, "Escape sequence in keyword new");
   }
-  var node2 = this.startNode();
+  var node = this.startNode();
   this.next();
   if (this.options.ecmaVersion >= 6 && this.type === types$1.dot) {
-    var meta = this.startNodeAt(node2.start, node2.loc && node2.loc.start);
+    var meta = this.startNodeAt(node.start, node.loc && node.loc.start);
     meta.name = "new";
-    node2.meta = this.finishNode(meta, "Identifier");
+    node.meta = this.finishNode(meta, "Identifier");
     this.next();
     var containsEsc = this.containsEsc;
-    node2.property = this.parseIdent(true);
-    if (node2.property.name !== "target") {
-      this.raiseRecoverable(node2.property.start, "The only valid meta property for new is 'new.target'");
+    node.property = this.parseIdent(true);
+    if (node.property.name !== "target") {
+      this.raiseRecoverable(node.property.start, "The only valid meta property for new is 'new.target'");
     }
     if (containsEsc) {
-      this.raiseRecoverable(node2.start, "'new.target' must not contain escaped characters");
+      this.raiseRecoverable(node.start, "'new.target' must not contain escaped characters");
     }
     if (!this.allowNewDotTarget) {
-      this.raiseRecoverable(node2.start, "'new.target' can only be used in functions and class static block");
+      this.raiseRecoverable(node.start, "'new.target' can only be used in functions and class static block");
     }
-    return this.finishNode(node2, "MetaProperty");
+    return this.finishNode(node, "MetaProperty");
   }
   var startPos = this.start, startLoc = this.startLoc;
-  node2.callee = this.parseSubscripts(this.parseExprAtom(null, false, true), startPos, startLoc, true, false);
+  node.callee = this.parseSubscripts(this.parseExprAtom(null, false, true), startPos, startLoc, true, false);
   if (this.eat(types$1.parenL)) {
-    node2.arguments = this.parseExprList(types$1.parenR, this.options.ecmaVersion >= 8, false);
+    node.arguments = this.parseExprList(types$1.parenR, this.options.ecmaVersion >= 8, false);
   } else {
-    node2.arguments = empty;
+    node.arguments = empty;
   }
-  return this.finishNode(node2, "NewExpression");
+  return this.finishNode(node, "NewExpression");
 };
 pp$5.parseTemplateElement = function(ref2) {
   var isTagged = ref2.isTagged;
@@ -6980,29 +6989,29 @@ pp$5.parseTemplate = function(ref2) {
   var isTagged = ref2.isTagged;
   if (isTagged === void 0)
     isTagged = false;
-  var node2 = this.startNode();
+  var node = this.startNode();
   this.next();
-  node2.expressions = [];
+  node.expressions = [];
   var curElt = this.parseTemplateElement({ isTagged });
-  node2.quasis = [curElt];
+  node.quasis = [curElt];
   while (!curElt.tail) {
     if (this.type === types$1.eof) {
       this.raise(this.pos, "Unterminated template literal");
     }
     this.expect(types$1.dollarBraceL);
-    node2.expressions.push(this.parseExpression());
+    node.expressions.push(this.parseExpression());
     this.expect(types$1.braceR);
-    node2.quasis.push(curElt = this.parseTemplateElement({ isTagged }));
+    node.quasis.push(curElt = this.parseTemplateElement({ isTagged }));
   }
   this.next();
-  return this.finishNode(node2, "TemplateLiteral");
+  return this.finishNode(node, "TemplateLiteral");
 };
 pp$5.isAsyncProp = function(prop) {
   return !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" && (this.type === types$1.name || this.type === types$1.num || this.type === types$1.string || this.type === types$1.bracketL || this.type.keyword || this.options.ecmaVersion >= 9 && this.type === types$1.star) && !lineBreak.test(this.input.slice(this.lastTokEnd, this.start));
 };
 pp$5.parseObj = function(isPattern, refDestructuringErrors) {
-  var node2 = this.startNode(), first = true, propHash = {};
-  node2.properties = [];
+  var node = this.startNode(), first = true, propHash = {};
+  node.properties = [];
   this.next();
   while (!this.eat(types$1.braceR)) {
     if (!first) {
@@ -7017,9 +7026,9 @@ pp$5.parseObj = function(isPattern, refDestructuringErrors) {
     if (!isPattern) {
       this.checkPropClash(prop, propHash, refDestructuringErrors);
     }
-    node2.properties.push(prop);
+    node.properties.push(prop);
   }
-  return this.finishNode(node2, isPattern ? "ObjectPattern" : "ObjectExpression");
+  return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");
 };
 pp$5.parseProperty = function(isPattern, refDestructuringErrors) {
   var prop = this.startNode(), isGenerator, isAsync, startPos, startLoc;
@@ -7134,67 +7143,67 @@ pp$5.parsePropertyName = function(prop) {
   }
   return prop.key = this.type === types$1.num || this.type === types$1.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never");
 };
-pp$5.initFunction = function(node2) {
-  node2.id = null;
+pp$5.initFunction = function(node) {
+  node.id = null;
   if (this.options.ecmaVersion >= 6) {
-    node2.generator = node2.expression = false;
+    node.generator = node.expression = false;
   }
   if (this.options.ecmaVersion >= 8) {
-    node2.async = false;
+    node.async = false;
   }
 };
 pp$5.parseMethod = function(isGenerator, isAsync, allowDirectSuper) {
-  var node2 = this.startNode(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
-  this.initFunction(node2);
+  var node = this.startNode(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
+  this.initFunction(node);
   if (this.options.ecmaVersion >= 6) {
-    node2.generator = isGenerator;
+    node.generator = isGenerator;
   }
   if (this.options.ecmaVersion >= 8) {
-    node2.async = !!isAsync;
+    node.async = !!isAsync;
   }
   this.yieldPos = 0;
   this.awaitPos = 0;
   this.awaitIdentPos = 0;
-  this.enterScope(functionFlags(isAsync, node2.generator) | SCOPE_SUPER | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));
+  this.enterScope(functionFlags(isAsync, node.generator) | SCOPE_SUPER | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));
   this.expect(types$1.parenL);
-  node2.params = this.parseBindingList(types$1.parenR, false, this.options.ecmaVersion >= 8);
+  node.params = this.parseBindingList(types$1.parenR, false, this.options.ecmaVersion >= 8);
   this.checkYieldAwaitInDefaultParams();
-  this.parseFunctionBody(node2, false, true, false);
+  this.parseFunctionBody(node, false, true, false);
   this.yieldPos = oldYieldPos;
   this.awaitPos = oldAwaitPos;
   this.awaitIdentPos = oldAwaitIdentPos;
-  return this.finishNode(node2, "FunctionExpression");
+  return this.finishNode(node, "FunctionExpression");
 };
-pp$5.parseArrowExpression = function(node2, params, isAsync, forInit) {
+pp$5.parseArrowExpression = function(node, params, isAsync, forInit) {
   var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
   this.enterScope(functionFlags(isAsync, false) | SCOPE_ARROW);
-  this.initFunction(node2);
+  this.initFunction(node);
   if (this.options.ecmaVersion >= 8) {
-    node2.async = !!isAsync;
+    node.async = !!isAsync;
   }
   this.yieldPos = 0;
   this.awaitPos = 0;
   this.awaitIdentPos = 0;
-  node2.params = this.toAssignableList(params, true);
-  this.parseFunctionBody(node2, true, false, forInit);
+  node.params = this.toAssignableList(params, true);
+  this.parseFunctionBody(node, true, false, forInit);
   this.yieldPos = oldYieldPos;
   this.awaitPos = oldAwaitPos;
   this.awaitIdentPos = oldAwaitIdentPos;
-  return this.finishNode(node2, "ArrowFunctionExpression");
+  return this.finishNode(node, "ArrowFunctionExpression");
 };
-pp$5.parseFunctionBody = function(node2, isArrowFunction, isMethod, forInit) {
+pp$5.parseFunctionBody = function(node, isArrowFunction, isMethod, forInit) {
   var isExpression = isArrowFunction && this.type !== types$1.braceL;
   var oldStrict = this.strict, useStrict = false;
   if (isExpression) {
-    node2.body = this.parseMaybeAssign(forInit);
-    node2.expression = true;
-    this.checkParams(node2, false);
+    node.body = this.parseMaybeAssign(forInit);
+    node.expression = true;
+    this.checkParams(node, false);
   } else {
-    var nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node2.params);
+    var nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params);
     if (!oldStrict || nonSimple) {
       useStrict = this.strictDirective(this.end);
       if (useStrict && nonSimple) {
-        this.raiseRecoverable(node2.start, "Illegal 'use strict' directive in function with non-simple parameter list");
+        this.raiseRecoverable(node.start, "Illegal 'use strict' directive in function with non-simple parameter list");
       }
     }
     var oldLabels = this.labels;
@@ -7202,13 +7211,13 @@ pp$5.parseFunctionBody = function(node2, isArrowFunction, isMethod, forInit) {
     if (useStrict) {
       this.strict = true;
     }
-    this.checkParams(node2, !oldStrict && !useStrict && !isArrowFunction && !isMethod && this.isSimpleParamList(node2.params));
-    if (this.strict && node2.id) {
-      this.checkLValSimple(node2.id, BIND_OUTSIDE);
+    this.checkParams(node, !oldStrict && !useStrict && !isArrowFunction && !isMethod && this.isSimpleParamList(node.params));
+    if (this.strict && node.id) {
+      this.checkLValSimple(node.id, BIND_OUTSIDE);
     }
-    node2.body = this.parseBlock(false, void 0, useStrict && !oldStrict);
-    node2.expression = false;
-    this.adaptDirectivePrologue(node2.body.body);
+    node.body = this.parseBlock(false, void 0, useStrict && !oldStrict);
+    node.expression = false;
+    this.adaptDirectivePrologue(node.body.body);
     this.labels = oldLabels;
   }
   this.exitScope();
@@ -7222,9 +7231,9 @@ pp$5.isSimpleParamList = function(params) {
   }
   return true;
 };
-pp$5.checkParams = function(node2, allowDuplicates) {
+pp$5.checkParams = function(node, allowDuplicates) {
   var nameHash = /* @__PURE__ */ Object.create(null);
-  for (var i = 0, list = node2.params; i < list.length; i += 1) {
+  for (var i = 0, list = node.params; i < list.length; i += 1) {
     var param = list[i];
     this.checkLValInnerPattern(param, BIND_VAR, allowDuplicates ? null : nameHash);
   }
@@ -7286,73 +7295,73 @@ pp$5.checkUnreserved = function(ref2) {
   }
 };
 pp$5.parseIdent = function(liberal) {
-  var node2 = this.parseIdentNode();
+  var node = this.parseIdentNode();
   this.next(!!liberal);
-  this.finishNode(node2, "Identifier");
+  this.finishNode(node, "Identifier");
   if (!liberal) {
-    this.checkUnreserved(node2);
-    if (node2.name === "await" && !this.awaitIdentPos) {
-      this.awaitIdentPos = node2.start;
+    this.checkUnreserved(node);
+    if (node.name === "await" && !this.awaitIdentPos) {
+      this.awaitIdentPos = node.start;
     }
   }
-  return node2;
+  return node;
 };
 pp$5.parseIdentNode = function() {
-  var node2 = this.startNode();
+  var node = this.startNode();
   if (this.type === types$1.name) {
-    node2.name = this.value;
+    node.name = this.value;
   } else if (this.type.keyword) {
-    node2.name = this.type.keyword;
-    if ((node2.name === "class" || node2.name === "function") && (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {
+    node.name = this.type.keyword;
+    if ((node.name === "class" || node.name === "function") && (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {
       this.context.pop();
     }
     this.type = types$1.name;
   } else {
     this.unexpected();
   }
-  return node2;
+  return node;
 };
 pp$5.parsePrivateIdent = function() {
-  var node2 = this.startNode();
+  var node = this.startNode();
   if (this.type === types$1.privateId) {
-    node2.name = this.value;
+    node.name = this.value;
   } else {
     this.unexpected();
   }
   this.next();
-  this.finishNode(node2, "PrivateIdentifier");
+  this.finishNode(node, "PrivateIdentifier");
   if (this.options.checkPrivateFields) {
     if (this.privateNameStack.length === 0) {
-      this.raise(node2.start, "Private field '#" + node2.name + "' must be declared in an enclosing class");
+      this.raise(node.start, "Private field '#" + node.name + "' must be declared in an enclosing class");
     } else {
-      this.privateNameStack[this.privateNameStack.length - 1].used.push(node2);
+      this.privateNameStack[this.privateNameStack.length - 1].used.push(node);
     }
   }
-  return node2;
+  return node;
 };
 pp$5.parseYield = function(forInit) {
   if (!this.yieldPos) {
     this.yieldPos = this.start;
   }
-  var node2 = this.startNode();
+  var node = this.startNode();
   this.next();
   if (this.type === types$1.semi || this.canInsertSemicolon() || this.type !== types$1.star && !this.type.startsExpr) {
-    node2.delegate = false;
-    node2.argument = null;
+    node.delegate = false;
+    node.argument = null;
   } else {
-    node2.delegate = this.eat(types$1.star);
-    node2.argument = this.parseMaybeAssign(forInit);
+    node.delegate = this.eat(types$1.star);
+    node.argument = this.parseMaybeAssign(forInit);
   }
-  return this.finishNode(node2, "YieldExpression");
+  return this.finishNode(node, "YieldExpression");
 };
 pp$5.parseAwait = function(forInit) {
   if (!this.awaitPos) {
     this.awaitPos = this.start;
   }
-  var node2 = this.startNode();
+  var node = this.startNode();
   this.next();
-  node2.argument = this.parseMaybeUnary(null, true, false, forInit);
-  return this.finishNode(node2, "AwaitExpression");
+  node.argument = this.parseMaybeUnary(null, true, false, forInit);
+  return this.finishNode(node, "AwaitExpression");
 };
 var pp$4 = Parser.prototype;
 pp$4.raise = function(pos, message) {
@@ -7472,27 +7481,27 @@ pp$2.startNode = function() {
 pp$2.startNodeAt = function(pos, loc) {
   return new Node(this, pos, loc);
 };
-function finishNodeAt(node2, type, pos, loc) {
-  node2.type = type;
-  node2.end = pos;
+function finishNodeAt(node, type, pos, loc) {
+  node.type = type;
+  node.end = pos;
   if (this.options.locations) {
-    node2.loc.end = loc;
+    node.loc.end = loc;
   }
   if (this.options.ranges) {
-    node2.range[1] = pos;
+    node.range[1] = pos;
   }
-  return node2;
+  return node;
 }
-pp$2.finishNode = function(node2, type) {
-  return finishNodeAt.call(this, node2, type, this.lastTokEnd, this.lastTokEndLoc);
+pp$2.finishNode = function(node, type) {
+  return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc);
 };
-pp$2.finishNodeAt = function(node2, type, pos, loc) {
-  return finishNodeAt.call(this, node2, type, pos, loc);
+pp$2.finishNodeAt = function(node, type, pos, loc) {
+  return finishNodeAt.call(this, node, type, pos, loc);
 };
-pp$2.copyNode = function(node2) {
-  var newNode = new Node(this, node2.start, this.startLoc);
-  for (var prop in node2) {
-    newNode[prop] = node2[prop];
+pp$2.copyNode = function(node) {
+  var newNode = new Node(this, node.start, this.startLoc);
+  for (var prop in node) {
+    newNode[prop] = node[prop];
   }
   return newNode;
 };
@@ -8086,14 +8095,14 @@ pp$1.regexp_eatAtomEscape = function(state) {
 pp$1.regexp_eatBackReference = function(state) {
   var start = state.pos;
   if (this.regexp_eatDecimalEscape(state)) {
-    var n = state.lastIntValue;
+    var n2 = state.lastIntValue;
     if (state.switchU) {
-      if (n > state.maxBackReference) {
-        state.maxBackReference = n;
+      if (n2 > state.maxBackReference) {
+        state.maxBackReference = n2;
       }
       return true;
     }
-    if (n <= state.numCapturingParens) {
+    if (n2 <= state.numCapturingParens) {
       return true;
     }
     state.pos = start;
@@ -9536,11 +9545,11 @@ pp.readEscapedChar = function(inTemplate) {
 };
 pp.readHexChar = function(len) {
   var codePos = this.pos;
-  var n = this.readInt(16, len);
-  if (n === null) {
+  var n2 = this.readInt(16, len);
+  if (n2 === null) {
     this.invalidStringToken(codePos, "Bad character escape sequence");
   }
-  return n;
+  return n2;
 };
 pp.readWord1 = function() {
   this.containsEsc = false;
@@ -11045,75 +11054,41 @@ function resolvePackage(name, options = {}) {
   }
 }
 
-// src/configs/tailwind.ts
-function tailwind() {
+// src/configs/antfu.ts
+var antfu = async () => {
   return [
     {
-      name: "jsse:tailwind",
+      name: "jsse:antfu",
       plugins: {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        tailwindcss: import_eslint_plugin_tailwindcss.default
+        antfu: import_eslint_plugin_antfu.default
       },
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       rules: {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        ...import_eslint_plugin_tailwindcss.default.configs.recommended.rules
+        "antfu/no-import-node-modules-by-path": "error",
+        "antfu/top-level-function": "error"
       }
-    }
-  ];
-}
-
-// src/configs/stylistic.ts
-function jsxStylistic({
-  indent
-}) {
-  return {
-    "@stylistic/jsx-curly-brace-presence": [
-      "error",
-      { propElementValues: "always" }
-    ],
-    "@stylistic/jsx-indent": [
-      "error",
-      indent,
-      { checkAttributes: true, indentLogicalExpressions: true }
-    ],
-    "@stylistic/jsx-quotes": "error"
-  };
-}
-function stylistic(options = {}) {
-  const { indent = 2, jsx = true, quotes = "double" } = options;
-  return [
+    },
     {
-      name: "jsse:stylistic",
-      plugins: {
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        "@stylistic": import_eslint_plugin.default
-      },
+      files: ["**/src/**/*"],
+      name: "jsse:antfu:bin",
       rules: {
-        "@stylistic/quote-props": ["error", "as-needed"],
-        "@stylistic/quotes": [
-          "error",
-          quotes,
-          { allowTemplateLiterals: false, avoidEscape: true }
-        ],
-        ...jsx ? jsxStylistic({ indent }) : {}
+        "antfu/no-import-dist": "error"
+      }
+    },
+    {
+      files: ["**/bin/**/*", `**/bin.${GLOB_SRC_EXT}`],
+      name: "jsse:antfu:bin",
+      rules: {
+        "antfu/no-import-dist": "off",
+        "antfu/no-import-node-modules-by-path": "off"
       }
     }
   ];
-}
-
-// src/slow.ts
-var slowRules = [
-  "@typescript-eslint/no-misused-promises",
-  "@typescript-eslint/no-unsafe-assignment",
-  "@typescript-eslint/no-unsafe-call",
-  "@typescript-eslint/no-unsafe-member-access",
-  "@typescript-eslint/no-unsafe-return"
-];
+};
 
 // src/configs/md.ts
-function markdown(options = {}) {
-  const { componentExts = [], overrides = {} } = options;
+var markdown = async (options) => {
+  const { componentExts = [], overrides = {} } = options ?? {};
   const tsRulesOff = Object.fromEntries(
     // @ts-expect-error - undefined
     Object.keys(typescriptRulesTypeAware()).map((key) => [
@@ -11173,11 +11148,72 @@ function markdown(options = {}) {
       }
     }
   ];
+};
+
+// src/configs/stylistic.ts
+function jsxStylistic({
+  indent
+}) {
+  return {
+    "@stylistic/jsx-curly-brace-presence": [
+      "error",
+      { propElementValues: "always" }
+    ],
+    "@stylistic/jsx-indent": [
+      "error",
+      indent,
+      { checkAttributes: true, indentLogicalExpressions: true }
+    ],
+    "@stylistic/jsx-quotes": "error"
+  };
 }
+var stylistic = async (options) => {
+  const { indent = 2, jsx = true, quotes = "double" } = options ?? {};
+  return [
+    {
+      name: "jsse:stylistic",
+      plugins: {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        "@stylistic": import_eslint_plugin.default
+      },
+      rules: {
+        "@stylistic/quote-props": ["error", "as-needed"],
+        "@stylistic/quotes": [
+          "error",
+          quotes,
+          { allowTemplateLiterals: false, avoidEscape: true }
+        ],
+        ...jsx ? jsxStylistic({ indent }) : {}
+      }
+    }
+  ];
+};
+
+// src/configs/tailwind.ts
+var tailwind = async () => {
+  return [
+    {
+      name: "jsse:tailwind",
+      plugins: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        tailwindcss: import_eslint_plugin_tailwindcss.default
+      },
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      rules: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        ...import_eslint_plugin_tailwindcss.default.configs.recommended.rules
+      }
+    }
+  ];
+};
 
 // src/configs/yml.ts
-async function yml(options = {}) {
-  const { files = [GLOB_YAML], overrides = {}, stylistic: stylistic2 = true } = options;
+var yml = async (options) => {
+  const {
+    files = [GLOB_YAML],
+    overrides = {},
+    stylistic: stylistic2 = true
+  } = options ?? {};
   const { indent = 2, quotes = "single" } = typeof stylistic2 === "boolean" ? {} : stylistic2;
   const [pluginYaml, parserYaml] = await Promise.all([
     interopDefault(import("eslint-plugin-yml")),
@@ -11222,7 +11258,16 @@ async function yml(options = {}) {
       }
     }
   ];
-}
+};
+
+// src/slow.ts
+var slowRules = [
+  "@typescript-eslint/no-misused-promises",
+  "@typescript-eslint/no-unsafe-assignment",
+  "@typescript-eslint/no-unsafe-call",
+  "@typescript-eslint/no-unsafe-member-access",
+  "@typescript-eslint/no-unsafe-return"
+];
 
 // src/factory.ts
 var flatConfigProps = [
@@ -11310,12 +11355,13 @@ async function jsse(options = {}, ...userConfigs) {
       reportUnusedDisableDirectives
     }),
     comments(),
-    node(),
+    n(),
     jsdoc(),
     imports({
       stylistic: stylisticOptions
     }),
     unicorn(),
+    antfu(),
     perfectionist()
   );
   if (enableTypeScript) {
@@ -11355,7 +11401,7 @@ async function jsse(options = {}, ...userConfigs) {
   }
   if (normalizedOptions.test) {
     configs.push(
-      test({
+      await test({
         isInEditor: isInEditor2,
         overrides: overrides.test
       })
@@ -11393,7 +11439,15 @@ async function jsse(options = {}, ...userConfigs) {
       }))
     );
   }
-  return combine(...configs, ...userConfigs);
+  const combinedConfigs = await combineAsync(...configs, ...userConfigs);
+  if (normalizedOptions.preReturn) {
+    const preReturned = normalizedOptions.preReturn(combinedConfigs);
+    if (preReturned instanceof Promise) {
+      return await preReturned;
+    }
+    return preReturned;
+  }
+  return combinedConfigs;
 }
 
 // src/presets.ts
@@ -11435,6 +11489,7 @@ function jsseReact() {
   GLOB_TSX,
   GLOB_YAML,
   combine,
+  combineAsync,
   comments,
   eslintConfigPrettierRules,
   ignores,
@@ -11448,10 +11503,11 @@ function jsseReact() {
   jsse,
   jsseReact,
   jssestd,
-  node,
+  n,
   parserJsonc,
   parserTs,
   perfectionist,
+  pluginAntfu,
   pluginEslintComments,
   pluginImport,
   pluginJsdoc,