@jsse/eslint-config 0.1.0 → 0.1.3

package/dist/index.cjs

@@ -5,7 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -30,40 +29,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateWrapper = (obj, member, setter, getter) => ({
-  set _(value) {
-    __privateSet(obj, member, value, setter);
-  },
-  get _() {
-    return __privateGet(obj, member, getter);
-  }
-});
 
 // node_modules/.pnpm/natural-compare@1.4.0/node_modules/natural-compare/index.js
 var require_natural_compare = __commonJS({
-  "node_modules/.pnpm/natural-compare@1.4.0/node_modules/natural-compare/index.js"(exports, module2) {
+  "node_modules/.pnpm/natural-compare@1.4.0/node_modules/natural-compare/index.js"(exports2, module2) {
     "use strict";
     var naturalCompare = function(a, b) {
       var i, codeA, codeB = 1, posA = 0, posB = 0, alphabet = String.alphabet;
@@ -100,7 +69,7 @@ var require_natural_compare = __commonJS({
 
 // node_modules/.pnpm/eslint-plugin-sort-keys@2.3.5/node_modules/eslint-plugin-sort-keys/rules/sort-keys-fix.js
 var require_sort_keys_fix = __commonJS({
-  "node_modules/.pnpm/eslint-plugin-sort-keys@2.3.5/node_modules/eslint-plugin-sort-keys/rules/sort-keys-fix.js"(exports, module2) {
+  "node_modules/.pnpm/eslint-plugin-sort-keys@2.3.5/node_modules/eslint-plugin-sort-keys/rules/sort-keys-fix.js"(exports2, module2) {
     "use strict";
     var naturalCompare = require_natural_compare();
     module2.exports = {
@@ -149,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;
           }
         };
@@ -167,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,
@@ -197,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) => {
@@ -274,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,
@@ -300,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) {
@@ -320,19 +289,19 @@ 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;
     };
   }
 });
 
 // node_modules/.pnpm/eslint-plugin-sort-keys@2.3.5/node_modules/eslint-plugin-sort-keys/index.js
 var require_eslint_plugin_sort_keys = __commonJS({
-  "node_modules/.pnpm/eslint-plugin-sort-keys@2.3.5/node_modules/eslint-plugin-sort-keys/index.js"(exports, module2) {
+  "node_modules/.pnpm/eslint-plugin-sort-keys@2.3.5/node_modules/eslint-plugin-sort-keys/index.js"(exports2, module2) {
     "use strict";
     module2.exports.rules = {
       "sort-keys-fix": require_sort_keys_fix()
@@ -340,9 +309,9 @@ var require_eslint_plugin_sort_keys = __commonJS({
   }
 });
 
-// node_modules/.pnpm/globals@13.24.0/node_modules/globals/globals.json
+// node_modules/.pnpm/globals@14.0.0/node_modules/globals/globals.json
 var require_globals = __commonJS({
-  "node_modules/.pnpm/globals@13.24.0/node_modules/globals/globals.json"(exports, module2) {
+  "node_modules/.pnpm/globals@14.0.0/node_modules/globals/globals.json"(exports2, module2) {
     module2.exports = {
       builtin: {
         AggregateError: false,
@@ -2344,9 +2313,9 @@ var require_globals = __commonJS({
   }
 });
 
-// node_modules/.pnpm/globals@13.24.0/node_modules/globals/index.js
+// node_modules/.pnpm/globals@14.0.0/node_modules/globals/index.js
 var require_globals2 = __commonJS({
-  "node_modules/.pnpm/globals@13.24.0/node_modules/globals/index.js"(exports, module2) {
+  "node_modules/.pnpm/globals@14.0.0/node_modules/globals/index.js"(exports2, module2) {
     "use strict";
     module2.exports = require_globals();
   }
@@ -2376,11 +2345,13 @@ __export(src_exports, {
   GLOB_TSX: () => GLOB_TSX,
   GLOB_YAML: () => GLOB_YAML,
   combine: () => combine,
+  combineAsync: () => combineAsync,
   comments: () => comments,
   default: () => jsse,
   eslintConfigPrettierRules: () => eslintConfigPrettierRules,
   ignores: () => ignores,
   imports: () => imports,
+  interopDefault: () => interopDefault,
   isCI: () => isCI,
   isInEditor: () => isInEditor,
   javascript: () => javascript,
@@ -2389,17 +2360,18 @@ __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,
   pluginJsonc: () => pluginJsonc,
   pluginMarkdown: () => import_eslint_plugin_markdown.default,
+  pluginN: () => import_eslint_plugin_n.default,
   pluginNoOnlyTests: () => import_eslint_plugin_no_only_tests.default,
-  pluginNode: () => import_eslint_plugin_n.default,
   pluginPerfectionist: () => import_eslint_plugin_perfectionist.default,
   pluginReact: () => import_eslint_plugin_react.default,
   pluginReactHooks: () => import_eslint_plugin_react_hooks.default,
@@ -2428,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)";
@@ -2534,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",
@@ -2569,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: {
@@ -2598,7 +2573,7 @@ function javascript(options = {}) {
         sourceType: "module"
       },
       linterOptions: {
-        reportUnusedDisableDirectives: options.reportUnusedDisableDirectives ?? true
+        reportUnusedDisableDirectives
       },
       name: "jsse:javascript",
       plugins: {
@@ -2826,11 +2801,10 @@ function javascript(options = {}) {
       }
     }
   ];
-}
+};
 
 // src/configs/jsdoc.ts
-function jsdoc(options = {}) {
-  const { stylistic: stylistic2 = true } = options;
+var jsdoc = async () => {
   return [
     {
       name: "jsse:jsdoc",
@@ -2840,11 +2814,13 @@ function jsdoc(options = {}) {
       },
       rules: {
         "jsdoc/check-access": "warn",
+        "jsdoc/check-alignment": "warn",
         "jsdoc/check-param-names": "warn",
         "jsdoc/check-property-names": "warn",
         "jsdoc/check-types": "warn",
         "jsdoc/empty-tags": "warn",
         "jsdoc/implements-on-classes": "warn",
+        "jsdoc/multiline-blocks": "warn",
         "jsdoc/no-defaults": "warn",
         "jsdoc/no-multi-asterisks": "warn",
         "jsdoc/require-param-name": "warn",
@@ -2853,19 +2829,15 @@ function jsdoc(options = {}) {
         "jsdoc/require-property-name": "warn",
         "jsdoc/require-returns-check": "warn",
         "jsdoc/require-returns-description": "warn",
-        "jsdoc/require-yields-check": "warn",
-        ...stylistic2 ? {
-          "jsdoc/check-alignment": "warn",
-          "jsdoc/multiline-blocks": "warn"
-        } : {}
+        "jsdoc/require-yields-check": "warn"
       }
     }
   ];
-}
+};
 
 // 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 [
     {
@@ -2933,30 +2905,42 @@ function jsonc(options = {}) {
       }
     }
   ];
-}
+};
 
-// src/configs/node.ts
-function node() {
+// src/configs/n.ts
+var n = async () => {
   return [
     {
-      name: "jsse:node",
+      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() {
@@ -3073,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);
@@ -3341,7 +3323,7 @@ function reactRecomendedRules() {
     "react/require-render-return": 2
   };
 }
-function react(options) {
+var react = async (options) => {
   const {
     componentExts,
     parserOptions = {},
@@ -3386,10 +3368,10 @@ function react(options) {
     config.push(...reactRefreshFlatConfigs());
   }
   return config;
-}
+};
 
 // src/configs/sort.ts
-function sortPackageJson() {
+var sortPackageJson = async () => {
   return [
     {
       files: ["**/package.json"],
@@ -3472,8 +3454,8 @@ function sortPackageJson() {
       }
     }
   ];
-}
-function sortTsconfig() {
+};
+var sortTsconfig = async () => {
   return [
     {
       files: ["**/tsconfig.json", "**/tsconfig.*.json"],
@@ -3597,7 +3579,7 @@ function sortTsconfig() {
       }
     }
   ];
-}
+};
 
 // src/utils.ts
 var import_node_process2 = __toESM(require("process"), 1);
@@ -3606,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;
@@ -3619,6 +3607,10 @@ function renameRules(rules, from, to) {
     })
   );
 }
+async function interopDefault(m) {
+  const resolved = await m;
+  return resolved.default || resolved;
+}
 function isCI() {
   return !!import_node_process2.default.env.CI;
 }
@@ -3627,7 +3619,7 @@ function isInEditor() {
 }
 
 // src/configs/test.ts
-function test(options = {}) {
+var test = async (options = {}) => {
   const { isInEditor: isInEditor2 = false, overrides = {} } = options;
   return [
     {
@@ -3654,7 +3646,7 @@ function test(options = {}) {
       }
     }
   ];
-}
+};
 
 // src/configs/ts/typescript-rules.ts
 function typescriptRulesTypeAware() {
@@ -4086,7 +4078,7 @@ function typescriptRules(props) {
 }
 
 // src/configs/ts/typescript.ts
-function typescript(options) {
+async function typescript(options) {
   const {
     componentExts = [],
     overrides = {},
@@ -4119,6 +4111,7 @@ function typescript(options) {
         [tsPrefixTo]: import_eslint_plugin2.default
       }
     },
+    // ...tseslint.configs.recommended,
     {
       // use ts parser for js files as well!
       files: [GLOB_SRC, ...componentExts.map((ext) => `**/*.${ext}`)],
@@ -4180,7 +4173,7 @@ function unicornOff() {
     // Super insanely annoying rule
   };
 }
-function unicorn() {
+var unicorn = async () => {
   return [
     {
       name: "jsse:unicorn",
@@ -4261,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);
@@ -4531,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;
@@ -4768,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;
@@ -4965,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) {
-  var exports = /* @__PURE__ */ Object.create(null);
-  if (!node2.body) {
-    node2.body = [];
+pp$8.parseTopLevel = function(node) {
+  var exports2 = /* @__PURE__ */ Object.create(null);
+  if (!node.body) {
+    node.body = [];
   }
   while (this.type !== types$1.eof) {
-    var stmt = this.parseStatement(null, true, exports);
-    node2.body.push(stmt);
+    var stmt = this.parseStatement(null, true, exports2);
+    node.body.push(stmt);
   }
   if (this.inModule) {
     for (var i = 0, list = Object.keys(this.undefinedExports); i < list.length; i += 1) {
@@ -4980,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" };
@@ -5027,8 +5008,8 @@ pp$8.isAsyncFunction = function() {
   var next = this.pos + skip[0].length, after;
   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, exports) {
-  var starttype = this.type, node2 = this.startNode(), kind;
+pp$8.parseStatement = function(context, topLevel, exports2) {
+  var starttype = this.type, node = this.startNode(), kind;
   if (this.isLet(context)) {
     starttype = types$1._var;
     kind = "let";
@@ -5036,48 +5017,48 @@ pp$8.parseStatement = function(context, topLevel, exports) {
   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) {
@@ -5085,7 +5066,7 @@ pp$8.parseStatement = function(context, topLevel, exports) {
         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) {
@@ -5096,71 +5077,71 @@ pp$8.parseStatement = function(context, topLevel, exports) {
           this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
         }
       }
-      return starttype === types$1._import ? this.parseImport(node2) : this.parseExport(node2, exports);
+      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);
@@ -5170,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) {
@@ -5185,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();
@@ -5205,7 +5186,7 @@ pp$8.parseForStatement = function(node2) {
           this.unexpected(awaitAt);
         }
       } else {
-        node2.await = awaitAt > -1;
+        node.await = awaitAt > -1;
       }
     }
     if (startsWithLet && isForOf) {
@@ -5213,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);
@@ -5260,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) {
@@ -5286,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() {
@@ -5306,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();
@@ -5324,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) {
@@ -5369,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 {
@@ -5377,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;
@@ -5408,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")) {
@@ -5431,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);
@@ -5454,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();
@@ -5468,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") {
@@ -5532,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;
@@ -5549,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;
@@ -5558,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;
@@ -5580,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;
@@ -5656,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: [] };
@@ -5728,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, exports) {
+pp$8.parseExportAllDeclaration = function(node, exports2) {
   if (this.options.ecmaVersion >= 11) {
     if (this.eatContextual("as")) {
-      node2.exported = this.parseModuleExportName();
-      this.checkExport(exports, 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, exports) {
+pp$8.parseExport = function(node, exports2) {
   this.next();
   if (this.eat(types$1.star)) {
-    return this.parseExportAllDeclaration(node2, exports);
+    return this.parseExportAllDeclaration(node, exports2);
   }
   if (this.eat(types$1._default)) {
-    this.checkExport(exports, "default", this.lastTokStart);
-    node2.declaration = this.parseExportDefaultDeclaration();
-    return this.finishNode(node2, "ExportDefaultDeclaration");
+    this.checkExport(exports2, "default", this.lastTokStart);
+    node.declaration = this.parseExportDefaultDeclaration();
+    return this.finishNode(node, "ExportDefaultDeclaration");
   }
   if (this.shouldParseExportStatement()) {
-    node2.declaration = this.parseExportDeclaration(node2);
-    if (node2.declaration.type === "VariableDeclaration") {
-      this.checkVariableExport(exports, node2.declaration.declarations);
+    node.declaration = this.parseExportDeclaration(node);
+    if (node.declaration.type === "VariableDeclaration") {
+      this.checkVariableExport(exports2, node.declaration.declarations);
     } else {
-      this.checkExport(exports, 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(exports);
+    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);
@@ -5786,13 +5767,13 @@ pp$8.parseExport = function(node2, exports) {
           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() {
@@ -5813,66 +5794,66 @@ pp$8.parseExportDefaultDeclaration = function() {
     return declaration;
   }
 };
-pp$8.checkExport = function(exports, name, pos) {
-  if (!exports) {
+pp$8.checkExport = function(exports2, name, pos) {
+  if (!exports2) {
     return;
   }
   if (typeof name !== "string") {
     name = name.type === "Identifier" ? name.name : name.value;
   }
-  if (hasOwn(exports, name)) {
+  if (hasOwn(exports2, name)) {
     this.raiseRecoverable(pos, "Duplicate export '" + name + "'");
   }
-  exports[name] = true;
+  exports2[name] = true;
 };
-pp$8.checkPatternExport = function(exports, pat) {
+pp$8.checkPatternExport = function(exports2, pat) {
   var type = pat.type;
   if (type === "Identifier") {
-    this.checkExport(exports, pat, pat.start);
+    this.checkExport(exports2, pat, pat.start);
   } else if (type === "ObjectPattern") {
     for (var i = 0, list = pat.properties; i < list.length; i += 1) {
       var prop = list[i];
-      this.checkPatternExport(exports, prop);
+      this.checkPatternExport(exports2, prop);
     }
   } else if (type === "ArrayPattern") {
     for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) {
       var elt = list$1[i$1];
       if (elt) {
-        this.checkPatternExport(exports, elt);
+        this.checkPatternExport(exports2, elt);
       }
     }
   } else if (type === "Property") {
-    this.checkPatternExport(exports, pat.value);
+    this.checkPatternExport(exports2, pat.value);
   } else if (type === "AssignmentPattern") {
-    this.checkPatternExport(exports, pat.left);
+    this.checkPatternExport(exports2, pat.left);
   } else if (type === "RestElement") {
-    this.checkPatternExport(exports, pat.argument);
+    this.checkPatternExport(exports2, pat.argument);
   }
 };
-pp$8.checkVariableExport = function(exports, decls) {
-  if (!exports) {
+pp$8.checkVariableExport = function(exports2, decls) {
+  if (!exports2) {
     return;
   }
   for (var i = 0, list = decls; i < list.length; i += 1) {
     var decl = list[i];
-    this.checkPatternExport(exports, decl.id);
+    this.checkPatternExport(exports2, decl.id);
   }
 };
 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(exports) {
-  var node2 = this.startNode();
-  node2.local = this.parseModuleExportName();
-  node2.exported = this.eatContextual("as") ? this.parseModuleExportName() : node2.local;
+pp$8.parseExportSpecifier = function(exports2) {
+  var node = this.startNode();
+  node.local = this.parseModuleExportName();
+  node.exported = this.eatContextual("as") ? this.parseModuleExportName() : node.local;
   this.checkExport(
-    exports,
-    node2.exported,
-    node2.exported.start
+    exports2,
+    node.exported,
+    node.exported.start
   );
-  return this.finishNode(node2, "ExportSpecifier");
+  return this.finishNode(node, "ExportSpecifier");
 };
-pp$8.parseExportSpecifiers = function(exports) {
+pp$8.parseExportSpecifiers = function(exports2) {
   var nodes = [], first = true;
   this.expect(types$1.braceL);
   while (!this.eat(types$1.braceR)) {
@@ -5884,48 +5865,48 @@ pp$8.parseExportSpecifiers = function(exports) {
     } else {
       first = false;
     }
-    nodes.push(this.parseExportSpecifier(exports));
+    nodes.push(this.parseExportSpecifier(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;
@@ -5973,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":
@@ -5987,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")) {
@@ -6000,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;
@@ -6062,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);
     }
@@ -6130,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)
@@ -6418,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;
 };
@@ -6455,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);
     }
@@ -6471,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);
@@ -6498,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;
 };
@@ -6528,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;
@@ -6541,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;
@@ -6553,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();
@@ -6602,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;
@@ -6658,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;
@@ -6716,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);
@@ -6757,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) {
@@ -6783,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:
@@ -6814,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)) {
@@ -6841,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);
@@ -6952,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;
@@ -7008,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) {
@@ -7045,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;
@@ -7162,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;
@@ -7230,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();
@@ -7250,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);
   }
@@ -7314,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) {
@@ -7500,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;
 };
@@ -8114,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;
@@ -9564,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;
@@ -9630,14 +9611,15 @@ Parser.acorn = {
   nonASCIIwhitespace
 };
 
-// node_modules/.pnpm/mlly@1.4.2/node_modules/mlly/dist/index.mjs
+// node_modules/.pnpm/mlly@1.5.0/node_modules/mlly/dist/index.mjs
 var import_node_module = require("module");
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_url = require("url");
 
-// node_modules/.pnpm/ufo@1.3.2/node_modules/ufo/dist/index.mjs
+// node_modules/.pnpm/ufo@1.4.0/node_modules/ufo/dist/index.mjs
 var r = String.fromCharCode;
 var TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
+var JOIN_LEADING_SLASH_RE = /^\.?\//;
 function hasTrailingSlash(input = "", respectQueryAndFragment) {
   if (!respectQueryAndFragment) {
     return input.endsWith("/");
@@ -9667,7 +9649,6 @@ function withTrailingSlash(input = "", respectQueryAndFragment) {
 function isNonEmptyURL(url) {
   return url && url !== "/";
 }
-var JOIN_LEADING_SLASH_RE = /^\.?\//;
 function joinURL(base, ...input) {
   let url = base || "";
   for (const segment of input.filter((url2) => isNonEmptyURL(url2))) {
@@ -9680,6 +9661,7 @@ function joinURL(base, ...input) {
   }
   return url;
 }
+var protocolRelative = Symbol.for("ufo:protocolRelative");
 
 // node_modules/.pnpm/pathe@1.1.2/node_modules/pathe/dist/shared/pathe.ff20891b.mjs
 var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
@@ -9687,7 +9669,7 @@ var isAbsolute = function(p) {
   return _IS_ABSOLUTE_RE.test(p);
 };
 
-// node_modules/.pnpm/mlly@1.4.2/node_modules/mlly/dist/index.mjs
+// node_modules/.pnpm/mlly@1.5.0/node_modules/mlly/dist/index.mjs
 var import_node_assert = __toESM(require("assert"), 1);
 var import_node_process3 = __toESM(require("process"), 1);
 var import_node_path = __toESM(require("path"), 1);
@@ -9697,7 +9679,6 @@ var BUILTIN_MODULES = new Set(import_node_module.builtinModules);
 function normalizeSlash(string_) {
   return string_.replace(/\\/g, "/");
 }
-var isWindows = import_node_process3.default.platform === "win32";
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
 var kTypes = /* @__PURE__ */ new Set([
@@ -9843,10 +9824,10 @@ codes.ERR_MODULE_NOT_FOUND = createError(
   /**
    * @param {string} path
    * @param {string} base
-   * @param {string} [type]
+   * @param {boolean} [exactUrl]
    */
-  (path4, base, type = "package") => {
-    return `Cannot find ${type} '${path4}' imported from ${base}`;
+  (path4, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path4}' imported from ${base}`;
   },
   Error
 );
@@ -9916,24 +9897,6 @@ codes.ERR_INVALID_ARG_VALUE = createError(
   // Note: extra classes have been shaken out.
   // , RangeError
 );
-codes.ERR_UNSUPPORTED_ESM_URL_SCHEME = createError(
-  "ERR_UNSUPPORTED_ESM_URL_SCHEME",
-  /**
-   * @param {URL} url
-   * @param {Array<string>} supported
-   */
-  (url, supported) => {
-    let message = `Only URLs with a scheme in: ${formatList(
-      supported
-    )} are supported by the default ESM loader`;
-    if (isWindows && url.protocol.length === 2) {
-      message += ". On Windows, absolute paths must be valid file:// URLs";
-    }
-    message += `. Received protocol '${url.protocol}'`;
-    return message;
-  },
-  Error
-);
 function createError(sym, value, def) {
   messages.set(sym, value);
   return makeNodeErrorWithCode(def, sym);
@@ -10051,96 +10014,98 @@ function determineSpecificType(value) {
   }
   return `type ${typeof value} (${inspected})`;
 }
+var hasOwnProperty$1 = {}.hasOwnProperty;
+var { ERR_INVALID_PACKAGE_CONFIG: ERR_INVALID_PACKAGE_CONFIG$1 } = codes;
+var cache = /* @__PURE__ */ new Map();
 var reader = { read };
 var packageJsonReader = reader;
-function read(jsonPath) {
-  try {
-    const string = import_node_fs.default.readFileSync(
-      import_node_path.default.toNamespacedPath(import_node_path.default.join(import_node_path.default.dirname(jsonPath), "package.json")),
-      "utf8"
-    );
-    return { string };
-  } catch (error) {
-    const exception = (
-      /** @type {ErrnoException} */
-      error
-    );
-    if (exception.code === "ENOENT") {
-      return { string: void 0 };
-    }
-    throw exception;
-  }
-}
-var { ERR_INVALID_PACKAGE_CONFIG: ERR_INVALID_PACKAGE_CONFIG$1 } = codes;
-var packageJsonCache = /* @__PURE__ */ new Map();
-function getPackageConfig(path4, specifier, base) {
-  const existing = packageJsonCache.get(path4);
-  if (existing !== void 0) {
+function read(jsonPath, { base, specifier }) {
+  const existing = cache.get(jsonPath);
+  if (existing) {
     return existing;
   }
-  const source = packageJsonReader.read(path4).string;
-  if (source === void 0) {
-    const packageConfig2 = {
-      pjsonPath: path4,
-      exists: false,
-      main: void 0,
-      name: void 0,
-      type: "none",
-      exports: void 0,
-      imports: void 0
-    };
-    packageJsonCache.set(path4, packageConfig2);
-    return packageConfig2;
-  }
-  let packageJson;
+  let string;
   try {
-    packageJson = JSON.parse(source);
+    string = import_node_fs.default.readFileSync(import_node_path.default.toNamespacedPath(jsonPath), "utf8");
   } catch (error) {
     const exception = (
       /** @type {ErrnoException} */
       error
     );
-    throw new ERR_INVALID_PACKAGE_CONFIG$1(
-      path4,
-      (base ? `"${specifier}" from ` : "") + (0, import_node_url.fileURLToPath)(base || specifier),
-      exception.message
-    );
+    if (exception.code !== "ENOENT") {
+      throw exception;
+    }
   }
-  const { exports, imports: imports2, main, name, type } = packageJson;
-  const packageConfig = {
-    pjsonPath: path4,
-    exists: true,
-    main: typeof main === "string" ? main : void 0,
-    name: typeof name === "string" ? name : void 0,
-    type: type === "module" || type === "commonjs" ? type : "none",
-    // @ts-expect-error Assume `Record<string, unknown>`.
-    exports,
-    // @ts-expect-error Assume `Record<string, unknown>`.
-    imports: imports2 && typeof imports2 === "object" ? imports2 : void 0
+  const result = {
+    exists: false,
+    pjsonPath: jsonPath,
+    main: void 0,
+    name: void 0,
+    type: "none",
+    // Ignore unknown types for forwards compatibility
+    exports: void 0,
+    imports: void 0
   };
-  packageJsonCache.set(path4, packageConfig);
-  return packageConfig;
+  if (string !== void 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(string);
+    } catch (error_) {
+      const cause = (
+        /** @type {ErrnoException} */
+        error_
+      );
+      const error = new ERR_INVALID_PACKAGE_CONFIG$1(
+        jsonPath,
+        (base ? `"${specifier}" from ` : "") + (0, import_node_url.fileURLToPath)(base || specifier),
+        cause.message
+      );
+      error.cause = cause;
+      throw error;
+    }
+    result.exists = true;
+    if (hasOwnProperty$1.call(parsed, "name") && typeof parsed.name === "string") {
+      result.name = parsed.name;
+    }
+    if (hasOwnProperty$1.call(parsed, "main") && typeof parsed.main === "string") {
+      result.main = parsed.main;
+    }
+    if (hasOwnProperty$1.call(parsed, "exports")) {
+      result.exports = parsed.exports;
+    }
+    if (hasOwnProperty$1.call(parsed, "imports")) {
+      result.imports = parsed.imports;
+    }
+    if (hasOwnProperty$1.call(parsed, "type") && (parsed.type === "commonjs" || parsed.type === "module")) {
+      result.type = parsed.type;
+    }
+  }
+  cache.set(jsonPath, result);
+  return result;
 }
 function getPackageScopeConfig(resolved) {
-  let packageJsonUrl = new import_node_url.URL("package.json", resolved);
+  let packageJSONUrl = new import_node_url.URL("package.json", resolved);
   while (true) {
-    const packageJsonPath2 = packageJsonUrl.pathname;
-    if (packageJsonPath2.endsWith("node_modules/package.json"))
+    const packageJSONPath2 = packageJSONUrl.pathname;
+    if (packageJSONPath2.endsWith("node_modules/package.json")) {
       break;
-    const packageConfig2 = getPackageConfig(
-      (0, import_node_url.fileURLToPath)(packageJsonUrl),
-      resolved
+    }
+    const packageConfig = packageJsonReader.read(
+      (0, import_node_url.fileURLToPath)(packageJSONUrl),
+      { specifier: resolved }
     );
-    if (packageConfig2.exists)
-      return packageConfig2;
-    const lastPackageJsonUrl = packageJsonUrl;
-    packageJsonUrl = new import_node_url.URL("../package.json", packageJsonUrl);
-    if (packageJsonUrl.pathname === lastPackageJsonUrl.pathname)
+    if (packageConfig.exists) {
+      return packageConfig;
+    }
+    const lastPackageJSONUrl = packageJSONUrl;
+    packageJSONUrl = new import_node_url.URL("../package.json", packageJSONUrl);
+    if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) {
       break;
+    }
   }
-  const packageJsonPath = (0, import_node_url.fileURLToPath)(packageJsonUrl);
-  const packageConfig = {
-    pjsonPath: packageJsonPath,
+  const packageJSONPath = (0, import_node_url.fileURLToPath)(packageJSONUrl);
+  return {
+    pjsonPath: packageJSONPath,
     exists: false,
     main: void 0,
     name: void 0,
@@ -10148,8 +10113,6 @@ function getPackageScopeConfig(resolved) {
     exports: void 0,
     imports: void 0
   };
-  packageJsonCache.set(packageJsonPath, packageConfig);
-  return packageConfig;
 }
 function getPackageType(url) {
   const packageConfig = getPackageScopeConfig(url);
@@ -10206,7 +10169,18 @@ function extname2(url) {
 function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
   const ext = extname2(url);
   if (ext === ".js") {
-    return getPackageType(url) === "module" ? "module" : "commonjs";
+    const packageType = getPackageType(url);
+    if (packageType !== "none") {
+      return packageType;
+    }
+    return "commonjs";
+  }
+  if (ext === "") {
+    const packageType = getPackageType(url);
+    if (packageType === "none" || packageType === "commonjs") {
+      return "commonjs";
+    }
+    return "module";
   }
   const format3 = extensionFormatMap[ext];
   if (format3)
@@ -10220,10 +10194,11 @@ function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
 function getHttpProtocolModuleFormat() {
 }
 function defaultGetFormatWithoutErrors(url, context) {
-  if (!hasOwnProperty2.call(protocolHandlers, url.protocol)) {
+  const protocol = url.protocol;
+  if (!hasOwnProperty2.call(protocolHandlers, protocol)) {
     return null;
   }
-  return protocolHandlers[url.protocol](url, context, true) || null;
+  return protocolHandlers[protocol](url, context, true) || null;
 }
 var RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
 var {
@@ -10234,8 +10209,7 @@ var {
   ERR_MODULE_NOT_FOUND,
   ERR_PACKAGE_IMPORT_NOT_DEFINED,
   ERR_PACKAGE_PATH_NOT_EXPORTED,
-  ERR_UNSUPPORTED_DIR_IMPORT,
-  ERR_UNSUPPORTED_ESM_URL_SCHEME
+  ERR_UNSUPPORTED_DIR_IMPORT
 } = codes;
 var own = {}.hasOwnProperty;
 var invalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i;
@@ -10246,6 +10220,9 @@ var encodedSepRegEx = /%2f|%5c/i;
 var emittedPackageWarnings = /* @__PURE__ */ new Set();
 var doubleSlashRegEx = /[/\\]{2}/;
 function emitInvalidSegmentDeprecation(target, request, match, packageJsonUrl, internal, base, isTarget) {
+  if (import_node_process3.default.noDeprecation) {
+    return;
+  }
   const pjsonPath = (0, import_node_url.fileURLToPath)(packageJsonUrl);
   const double = doubleSlashRegEx.exec(isTarget ? target : request) !== null;
   import_node_process3.default.emitWarning(
@@ -10255,30 +10232,34 @@ function emitInvalidSegmentDeprecation(target, request, match, packageJsonUrl, i
   );
 }
 function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
+  if (import_node_process3.default.noDeprecation) {
+    return;
+  }
   const format3 = defaultGetFormatWithoutErrors(url, { parentURL: base.href });
   if (format3 !== "module")
     return;
-  const path4 = (0, import_node_url.fileURLToPath)(url.href);
+  const urlPath = (0, import_node_url.fileURLToPath)(url.href);
   const pkgPath = (0, import_node_url.fileURLToPath)(new import_node_url.URL(".", packageJsonUrl));
   const basePath = (0, import_node_url.fileURLToPath)(base);
-  if (main)
+  if (!main) {
     import_node_process3.default.emitWarning(
-      `Package ${pkgPath} has a "main" field set to ${JSON.stringify(main)}, excluding the full filename and extension to the resolved file at "${path4.slice(
+      `No "main" or "exports" field defined in the package.json for ${pkgPath} resolving the main entry point "${urlPath.slice(
         pkgPath.length
       )}", imported from ${basePath}.
- Automatic extension resolution of the "main" field isdeprecated for ES modules.`,
+Default "index" lookups for the main are deprecated for ES modules.`,
       "DeprecationWarning",
       "DEP0151"
     );
-  else
+  } else if (import_node_path.default.resolve(pkgPath, main) !== urlPath) {
     import_node_process3.default.emitWarning(
-      `No "main" or "exports" field defined in the package.json for ${pkgPath} resolving the main entry point "${path4.slice(
+      `Package ${pkgPath} has a "main" field set to "${main}", excluding the full filename and extension to the resolved file at "${urlPath.slice(
         pkgPath.length
       )}", imported from ${basePath}.
-Default "index" lookups for the main are deprecated for ES modules.`,
+ Automatic extension resolution of the "main" field is deprecated for ES modules.`,
       "DeprecationWarning",
       "DEP0151"
     );
+  }
 }
 function tryStatSync(path4) {
   try {
@@ -10341,13 +10322,25 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
   );
 }
 function finalizeResolution(resolved, base, preserveSymlinks) {
-  if (encodedSepRegEx.exec(resolved.pathname) !== null)
+  if (encodedSepRegEx.exec(resolved.pathname) !== null) {
     throw new ERR_INVALID_MODULE_SPECIFIER(
       resolved.pathname,
       'must not include encoded "/" or "\\" characters',
       (0, import_node_url.fileURLToPath)(base)
     );
-  const filePath = (0, import_node_url.fileURLToPath)(resolved);
+  }
+  let filePath;
+  try {
+    filePath = (0, import_node_url.fileURLToPath)(resolved);
+  } catch (error) {
+    const cause = (
+      /** @type {ErrnoException} */
+      error
+    );
+    Object.defineProperty(cause, "input", { value: String(resolved) });
+    Object.defineProperty(cause, "module", { value: String(base) });
+    throw cause;
+  }
   const stats = tryStatSync(
     filePath.endsWith("/") ? filePath.slice(-1) : filePath
   );
@@ -10357,11 +10350,13 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
     throw error;
   }
   if (!stats.isFile()) {
-    throw new ERR_MODULE_NOT_FOUND(
+    const error = new ERR_MODULE_NOT_FOUND(
       filePath || resolved.pathname,
       base && (0, import_node_url.fileURLToPath)(base),
-      "module"
+      true
     );
+    error.url = String(resolved);
+    throw error;
   }
   if (!preserveSymlinks) {
     const real = (0, import_node_fs.realpathSync)(filePath);
@@ -10604,12 +10599,12 @@ function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, b
     base
   );
 }
-function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
-  if (typeof exports === "string" || Array.isArray(exports))
+function isConditionalExportsMainSugar(exports2, packageJsonUrl, base) {
+  if (typeof exports2 === "string" || Array.isArray(exports2))
     return true;
-  if (typeof exports !== "object" || exports === null)
+  if (typeof exports2 !== "object" || exports2 === null)
     return false;
-  const keys = Object.getOwnPropertyNames(exports);
+  const keys = Object.getOwnPropertyNames(exports2);
   let isConditionalSugar = false;
   let i = 0;
   let j = -1;
@@ -10629,6 +10624,9 @@ function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
   return isConditionalSugar;
 }
 function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
+  if (import_node_process3.default.noDeprecation) {
+    return;
+  }
   const pjsonPath = (0, import_node_url.fileURLToPath)(pjsonUrl);
   if (emittedPackageWarnings.has(pjsonPath + "|" + match))
     return;
@@ -10640,12 +10638,12 @@ function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
   );
 }
 function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions) {
-  let exports = packageConfig.exports;
-  if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) {
-    exports = { ".": exports };
+  let exports2 = packageConfig.exports;
+  if (isConditionalExportsMainSugar(exports2, packageJsonUrl, base)) {
+    exports2 = { ".": exports2 };
   }
-  if (own.call(exports, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
-    const target = exports[packageSubpath];
+  if (own.call(exports2, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
+    const target = exports2[packageSubpath];
     const resolveResult = resolvePackageTarget(
       packageJsonUrl,
       target,
@@ -10664,7 +10662,7 @@ function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, ba
   }
   let bestMatch = "";
   let bestMatchSubpath = "";
-  const keys = Object.getOwnPropertyNames(exports);
+  const keys = Object.getOwnPropertyNames(exports2);
   let i = -1;
   while (++i < keys.length) {
     const key = keys[i];
@@ -10690,7 +10688,7 @@ function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, ba
   if (bestMatch) {
     const target = (
       /** @type {unknown} */
-      exports[bestMatch]
+      exports2[bestMatch]
     );
     const resolveResult = resolvePackageTarget(
       packageJsonUrl,
@@ -10860,7 +10858,10 @@ function packageResolve(specifier, base, conditions) {
       packageJsonPath = (0, import_node_url.fileURLToPath)(packageJsonUrl);
       continue;
     }
-    const packageConfig2 = getPackageConfig(packageJsonPath, specifier, base);
+    const packageConfig2 = packageJsonReader.read(packageJsonPath, {
+      base,
+      specifier
+    });
     if (packageConfig2.exports !== void 0 && packageConfig2.exports !== null) {
       return packageExportsResolve(
         packageJsonUrl,
@@ -10875,7 +10876,7 @@ function packageResolve(specifier, base, conditions) {
     }
     return new import_node_url.URL(packageSubpath, packageJsonUrl);
   } while (packageJsonPath.length !== lastPath.length);
-  throw new ERR_MODULE_NOT_FOUND(packageName, (0, import_node_url.fileURLToPath)(base));
+  throw new ERR_MODULE_NOT_FOUND(packageName, (0, import_node_url.fileURLToPath)(base), false);
 }
 function isRelativeSpecifier(specifier) {
   if (specifier[0] === ".") {
@@ -11025,60 +11026,6 @@ function resolvePathSync(id, options) {
 
 // node_modules/.pnpm/local-pkg@0.5.0/node_modules/local-pkg/dist/index.mjs
 var import_node_url2 = require("url");
-var Node3 = class {
-  constructor(value) {
-    __publicField(this, "value");
-    __publicField(this, "next");
-    this.value = value;
-  }
-};
-var _head, _tail, _size;
-var Queue = class {
-  constructor() {
-    __privateAdd(this, _head, void 0);
-    __privateAdd(this, _tail, void 0);
-    __privateAdd(this, _size, void 0);
-    this.clear();
-  }
-  enqueue(value) {
-    const node2 = new Node3(value);
-    if (__privateGet(this, _head)) {
-      __privateGet(this, _tail).next = node2;
-      __privateSet(this, _tail, node2);
-    } else {
-      __privateSet(this, _head, node2);
-      __privateSet(this, _tail, node2);
-    }
-    __privateWrapper(this, _size)._++;
-  }
-  dequeue() {
-    const current2 = __privateGet(this, _head);
-    if (!current2) {
-      return;
-    }
-    __privateSet(this, _head, __privateGet(this, _head).next);
-    __privateWrapper(this, _size)._--;
-    return current2.value;
-  }
-  clear() {
-    __privateSet(this, _head, void 0);
-    __privateSet(this, _tail, void 0);
-    __privateSet(this, _size, 0);
-  }
-  get size() {
-    return __privateGet(this, _size);
-  }
-  *[Symbol.iterator]() {
-    let current2 = __privateGet(this, _head);
-    while (current2) {
-      yield current2.value;
-      current2 = current2.next;
-    }
-  }
-};
-_head = new WeakMap();
-_tail = new WeakMap();
-_size = new WeakMap();
 var findUpStop = Symbol("findUpStop");
 function _resolve2(path4, options = {}) {
   if (options.platform === "auto" || !options.platform)
@@ -11107,23 +11054,101 @@ 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"
+      }
+    },
+    {
+      files: ["**/src/**/*"],
+      name: "jsse:antfu:bin",
+      rules: {
+        "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/configs/md.ts
+var markdown = async (options) => {
+  const { componentExts = [], overrides = {} } = options ?? {};
+  const tsRulesOff = Object.fromEntries(
+    // @ts-expect-error - undefined
+    Object.keys(typescriptRulesTypeAware()).map((key) => [
+      `@typescript-eslint/${key}`,
+      "off"
+    ])
+  );
+  return [
+    {
+      name: "jsse:markdown:setup",
+      plugins: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        markdown: import_eslint_plugin_markdown.default
+      }
+    },
+    {
+      files: [GLOB_MARKDOWN],
+      name: "jsse:markdown:processor",
+      processor: "markdown/markdown"
+    },
+    {
+      files: [
+        GLOB_MARKDOWN_CODE,
+        ...componentExts.map((ext) => `${GLOB_MARKDOWN}/**/*.${ext}`)
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            impliedStrict: true
+          }
+        }
+      },
+      name: "jsse:markdown:rules",
+      rules: {
+        "@typescript-eslint/consistent-type-imports": "off",
+        "@typescript-eslint/no-namespace": "off",
+        "@typescript-eslint/no-redeclare": "off",
+        "@typescript-eslint/no-require-imports": "off",
+        "@typescript-eslint/no-unused-vars": "off",
+        "@typescript-eslint/no-use-before-define": "off",
+        "@typescript-eslint/no-var-requires": "off",
+        "no-alert": "off",
+        "no-console": "off",
+        "no-undef": "off",
+        "no-unused-expressions": "off",
+        "no-unused-vars": "off",
+        "node/prefer-global/process": "off",
+        // Type aware rules
+        "object-curly-newline": "off",
+        "style/comma-dangle": "off",
+        "style/eol-last": "off",
+        "unicode-bom": "off",
+        "unused-imports/no-unused-imports": "off",
+        "unused-imports/no-unused-vars": "off",
+        ...tsRulesOff,
+        ...overrides
+      }
+    }
+  ];
+};
 
 // src/configs/stylistic.ts
 function jsxStylistic({
@@ -11142,8 +11167,8 @@ function jsxStylistic({
     "@stylistic/jsx-quotes": "error"
   };
 }
-function stylistic(options = {}) {
-  const { indent = 2, jsx = true, quotes = "double" } = options;
+var stylistic = async (options) => {
+  const { indent = 2, jsx = true, quotes = "double" } = options ?? {};
   return [
     {
       name: "jsse:stylistic",
@@ -11162,7 +11187,78 @@ function stylistic(options = {}) {
       }
     }
   ];
-}
+};
+
+// 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
+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")),
+    interopDefault(import("yaml-eslint-parser"))
+  ]);
+  return [
+    {
+      name: "jsse:yaml:setup",
+      plugins: {
+        yaml: pluginYaml
+      }
+    },
+    {
+      files,
+      languageOptions: {
+        parser: parserYaml
+      },
+      name: "antfu:yaml:rules",
+      rules: {
+        "style/spaced-comment": "off",
+        "yaml/block-mapping": "error",
+        "yaml/block-sequence": "error",
+        "yaml/no-empty-key": "error",
+        "yaml/no-empty-sequence-entry": "error",
+        "yaml/no-irregular-whitespace": "error",
+        "yaml/plain-scalar": "error",
+        "yaml/vue-custom-block/no-parsing-error": "error",
+        ...stylistic2 ? {
+          "yaml/block-mapping-question-indicator-newline": "error",
+          "yaml/block-sequence-hyphen-indicator-newline": "error",
+          "yaml/flow-mapping-curly-newline": "error",
+          "yaml/flow-mapping-curly-spacing": "error",
+          "yaml/flow-sequence-bracket-newline": "error",
+          "yaml/flow-sequence-bracket-spacing": "error",
+          "yaml/indent": ["error", indent === "tab" ? 2 : indent],
+          "yaml/key-spacing": "error",
+          "yaml/no-tab-indent": "error",
+          "yaml/quotes": ["error", { avoidEscape: false, prefer: quotes }],
+          "yaml/spaced-comment": "error"
+        } : {},
+        ...overrides
+      }
+    }
+  ];
+};
 
 // src/slow.ts
 var slowRules = [
@@ -11192,6 +11288,7 @@ function defaultOptions2() {
     gitignore: true,
     isInEditor: isInEditor(),
     jsonc: true,
+    markdown: false,
     off: [],
     overrides: {},
     prettier: true,
@@ -11224,7 +11321,7 @@ function normalizeOptions(options = {}) {
     stylistic: stylisticOptions
   };
 }
-function jsse(options = {}, ...userConfigs) {
+async function jsse(options = {}, ...userConfigs) {
   const normalizedOptions = normalizeOptions(options);
   const {
     componentExts,
@@ -11258,35 +11355,41 @@ function jsse(options = {}, ...userConfigs) {
       reportUnusedDisableDirectives
     }),
     comments(),
-    node(),
-    jsdoc({
-      stylistic: stylisticOptions
-    }),
+    n(),
+    jsdoc(),
     imports({
       stylistic: stylisticOptions
     }),
     unicorn(),
+    antfu(),
     perfectionist()
   );
   if (enableTypeScript) {
-    configs.push(
-      typescript({
-        ...typeof enableTypeScript === "boolean" ? {} : enableTypeScript,
-        componentExts,
-        overrides: overrides.typescript,
-        prefix: {
-          from: "@typescript-eslint",
-          to: tsPrefix ?? "@typescript-eslint"
-        },
-        react: enableReact,
-        typeAware
-      })
-    );
+    const tscfg = await typescript({
+      ...typeof enableTypeScript === "boolean" ? {} : enableTypeScript,
+      componentExts,
+      overrides: overrides.typescript,
+      prefix: {
+        from: "@typescript-eslint",
+        to: tsPrefix ?? "@typescript-eslint"
+      },
+      react: enableReact,
+      typeAware
+    });
+    configs.push(tscfg);
+  }
+  if (normalizedOptions.markdown) {
+    configs.push(markdown());
+  }
+  if (normalizedOptions.yaml) {
+    const ymlConfig = await yml();
+    configs.push(ymlConfig);
   }
   if (normalizedOptions.react) {
     configs.push(
       react({
-        reactRefresh: options.reactRefresh
+        // use react refresh if not explicitly disabled w/ 'false'
+        reactRefresh: normalizedOptions.reactRefresh !== false
       })
     );
   }
@@ -11298,7 +11401,7 @@ function jsse(options = {}, ...userConfigs) {
   }
   if (normalizedOptions.test) {
     configs.push(
-      test({
+      await test({
         isInEditor: isInEditor2,
         overrides: overrides.test
       })
@@ -11336,7 +11439,15 @@ 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
@@ -11378,10 +11489,12 @@ function jsseReact() {
   GLOB_TSX,
   GLOB_YAML,
   combine,
+  combineAsync,
   comments,
   eslintConfigPrettierRules,
   ignores,
   imports,
+  interopDefault,
   isCI,
   isInEditor,
   javascript,
@@ -11390,17 +11503,18 @@ function jsseReact() {
   jsse,
   jsseReact,
   jssestd,
-  node,
+  n,
   parserJsonc,
   parserTs,
   perfectionist,
+  pluginAntfu,
   pluginEslintComments,
   pluginImport,
   pluginJsdoc,
   pluginJsonc,
   pluginMarkdown,
+  pluginN,
   pluginNoOnlyTests,
-  pluginNode,
   pluginPerfectionist,
   pluginReact,
   pluginReactHooks,