first

node_modules/@babel/eslint-parser/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@babel/eslint-parser/README.md

@@ -0,0 +1,142 @@
+# @babel/eslint-parser [![npm](https://img.shields.io/npm/v/@babel/eslint-parser.svg)](https://www.npmjs.com/package/@babel/eslint-parser) [![travis](https://img.shields.io/travis/babel/@babel/eslint-parser/main.svg)](https://travis-ci.org/babel/@babel/eslint-parser) [![npm-downloads](https://img.shields.io/npm/dm/@babel/eslint-parser.svg)](https://www.npmjs.com/package/@babel/eslint-parser)
+
+**@babel/eslint-parser** allows you to lint **ALL** valid Babel code with the fantastic
+[ESLint](https://github.com/eslint/eslint).
+
+## When should I use @babel/eslint-parser?
+
+ESLint's default parser and core rules [only support the latest final ECMAScript standard](https://github.com/eslint/eslint/blob/a675c89573836adaf108a932696b061946abf1e6/README.md#what-about-experimental-features) and do not support experimental (such as new features) and non-standard (such as Flow or TypeScript types) syntax provided by Babel. @babel/eslint-parser is a parser that allows ESLint to run on source code that is transformed by Babel.
+
+**Note:** You only need to use @babel/eslint-parser if you are using Babel to transform your code. If this is not the case, please use the relevant parser for your chosen flavor of ECMAScript (note that the default parser supports all non-experimental syntax as well as JSX).
+
+## How does it work?
+
+ESLint allows for the use of [custom parsers](https://eslint.org/docs/developer-guide/working-with-custom-parsers). When using this plugin, your code is parsed by Babel's parser (using the configuration specified in your [Babel configuration file](https://babeljs.io/docs/en/configuration)) and the resulting AST is
+transformed into an [ESTree](https://github.com/estree/estree)-compliant structure that ESLint can understand. All location info such as line numbers,
+columns is also retained so you can track down errors with ease.
+
+**Note:** ESLint's core rules do not support experimental syntax and may therefore not work as expected when using `@babel/eslint-parser`. Please use the companion [`@babel/eslint-plugin`](https://github.com/babel/babel/tree/main/eslint/babel-eslint-plugin) plugin for core rules that you have issues with.
+
+## Usage
+
+### Installation
+
+```sh
+$ npm install eslint @babel/core @babel/eslint-parser --save-dev
+# or
+$ yarn add eslint @babel/core @babel/eslint-parser -D
+```
+
+**Note:** @babel/eslint-parser requires `@babel/core@>=7.2.0` and a valid Babel configuration file to run. If you do not have this already set up, please see the [Babel Usage Guide](https://babeljs.io/docs/en/usage).
+
+### Setup
+
+To use @babel/eslint-parser, `"@babel/eslint-parser"` must be specified as the `parser` in your ESLint configuration file (see [here](https://eslint.org/docs/user-guide/configuring/plugins#specifying-parser) for more detailed information).
+
+**.eslintrc.js**
+
+```js
+module.exports = {
+  parser: "@babel/eslint-parser",
+};
+```
+
+With the parser set, your configuration can be configured as described in the [Configuring ESLint](https://eslint.org/docs/user-guide/configuring) documentation.
+
+**Note:** The `parserOptions` described in the [official documentation](https://eslint.org/docs/user-guide/configuring/language-options#specifying-parser-options) are for the default parser and are not necessarily supported by @babel/eslint-parser. Please see the section directly below for supported `parserOptions`.
+
+### Additional parser configuration
+
+Additional configuration options can be set in your ESLint configuration under the `parserOptions` key. Please note that the `ecmaFeatures` config property may still be required for ESLint to work properly with features not in ECMAScript 5 by default.
+
+- `requireConfigFile` (default `true`) can be set to `false` to allow @babel/eslint-parser to run on files that do not have a Babel configuration associated with them. This can be useful for linting files that are not transformed by Babel (such as tooling configuration files), though we recommend using the default parser via [glob-based configuration](https://eslint.org/docs/user-guide/configuring/configuration-files#configuration-based-on-glob-patterns).
+  Note: When `requireConfigFile` is `false`, @babel/eslint-parser will still try to load the root babel config. If no configuration file is found, @babel/eslint-parser will not parse any experimental syntax. Though not recommended, if you have a babel config, but would like to prevent @babel/eslint-parser from loading Babel config, please specify
+  **.eslintrc.js**
+
+```js
+module.exports = {
+  parser: "@babel/eslint-parser",
+  parserOptions: {
+    requireConfigFile: false,
+    babelOptions: {
+      babelrc: false,
+      configFile: false,
+      // your babel options
+      presets: ["@babel/preset-env"],
+    },
+  },
+};
+```
+
+- `sourceType` can be set to `"module"`(default) or `"script"` if your code isn't using ECMAScript modules.
+<!-- TODO(Babel 8): Remove this -->
+- `allowImportExportEverywhere` (default `false`) can be set to `true` to allow import and export declarations to appear anywhere a statement is allowed if your build environment supports that. Otherwise import and export declarations can only appear at a program's top level.
+- `ecmaFeatures.globalReturn` (default `false`) allow return statements in the global scope when used with `sourceType: "script"`.
+- `babelOptions` is an object containing Babel configuration [options](https://babeljs.io/docs/en/options) that are passed to Babel's parser at runtime. For cases where users might not want to use a Babel configuration file or are running Babel through another tool (such as Webpack with `babel-loader`).
+
+**.eslintrc.js**
+
+```js
+module.exports = {
+  parser: "@babel/eslint-parser",
+  parserOptions: {
+    sourceType: "module",
+    allowImportExportEverywhere: false,
+    ecmaFeatures: {
+      globalReturn: false,
+    },
+    babelOptions: {
+      configFile: "path/to/config.js",
+    },
+  },
+};
+```
+
+**.eslintrc.js using glob-based configuration**
+
+This configuration would use the default parser for all files except for those found by the `"files/transformed/by/babel/*.js"` glob.
+
+```js
+module.exports = {
+  rules: {
+    indent: "error",
+  },
+  overrides: [
+    {
+      files: ["files/transformed/by/babel/*.js"],
+      parser: "@babel/eslint-parser",
+    },
+  ],
+};
+```
+
+**Monorepo configuration**
+
+This configuration is useful for monorepo, when you are running ESLint on every package and not from the monorepo root folder, as it avoids to repeat the Babel and ESLint configuration on every package.
+
+```js
+module.exports = {
+  parser: "@babel/eslint-parser",
+  parserOptions: {
+    babelOptions: {
+      rootMode: "upward",
+    },
+  },
+};
+```
+
+### Run
+
+```sh
+$ ./node_modules/.bin/eslint yourfile.js
+```
+
+## TypeScript
+
+While [`@babel/eslint-parser`](https://github.com/babel/babel/tree/main/eslint/babel-eslint-parser) can parse TypeScript, we don't currently support linting TypeScript using the rules in [`@babel/eslint-plugin`](https://github.com/babel/babel/tree/main/eslint/babel-eslint-plugin). This is because the TypeScript community has centered around [`@typescript-eslint`](https://github.com/typescript-eslint/typescript-eslint) and we want to avoid duplicate work. Additionally, since [`@typescript-eslint`](https://github.com/typescript-eslint/typescript-eslint) uses TypeScript under the hood, its rules can be made type-aware, which is something Babel doesn't have the ability to do.
+
+## Questions and support
+
+If you have an issue, please first check if it can be reproduced with the default parser and with the latest versions of `eslint` and `@babel/eslint-parser`. If it is not reproducible with the default parser, it is most likely an issue with `@babel/eslint-parser`.
+
+For questions and support please visit the [`#discussion`](https://babeljs.slack.com/messages/discussion/) Babel Slack channel (sign up [here](https://slack.babeljs.io/)) or the [ESLint Discord server](https://eslint.org/chat).

node_modules/@babel/eslint-parser/lib/analyze-scope.cjs

@@ -0,0 +1,306 @@
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+const {
+  Definition,
+  PatternVisitor: OriginalPatternVisitor,
+  Referencer: OriginalReferencer,
+  Scope,
+  ScopeManager
+} = require("@nicolo-ribaudo/eslint-scope-5-internals");
+const {
+  getKeys: fallback
+} = require("eslint-visitor-keys");
+let visitorKeysMap;
+function getVisitorValues(nodeType, client) {
+  if (visitorKeysMap) return visitorKeysMap[nodeType];
+  const {
+    FLOW_FLIPPED_ALIAS_KEYS,
+    VISITOR_KEYS
+  } = client.getTypesInfo();
+  const flowFlippedAliasKeys = FLOW_FLIPPED_ALIAS_KEYS.concat(["ArrayPattern", "ClassDeclaration", "ClassExpression", "FunctionDeclaration", "FunctionExpression", "Identifier", "ObjectPattern", "RestElement"]);
+  visitorKeysMap = Object.entries(VISITOR_KEYS).reduce((acc, [key, value]) => {
+    if (!flowFlippedAliasKeys.includes(value)) {
+      acc[key] = value;
+    }
+    return acc;
+  }, {});
+  return visitorKeysMap[nodeType];
+}
+const propertyTypes = {
+  callProperties: {
+    type: "loop",
+    values: ["value"]
+  },
+  indexers: {
+    type: "loop",
+    values: ["key", "value"]
+  },
+  properties: {
+    type: "loop",
+    values: ["argument", "value"]
+  },
+  types: {
+    type: "loop"
+  },
+  params: {
+    type: "loop"
+  },
+  argument: {
+    type: "single"
+  },
+  elementType: {
+    type: "single"
+  },
+  qualification: {
+    type: "single"
+  },
+  rest: {
+    type: "single"
+  },
+  returnType: {
+    type: "single"
+  },
+  typeAnnotation: {
+    type: "typeAnnotation"
+  },
+  typeParameters: {
+    type: "typeParameters"
+  },
+  id: {
+    type: "id"
+  }
+};
+class PatternVisitor extends OriginalPatternVisitor {
+  ArrayPattern(node) {
+    node.elements.forEach(this.visit, this);
+  }
+  ObjectPattern(node) {
+    node.properties.forEach(this.visit, this);
+  }
+}
+var _client = new WeakMap();
+class Referencer extends OriginalReferencer {
+  constructor(options, scopeManager, client) {
+    super(options, scopeManager);
+    _classPrivateFieldInitSpec(this, _client, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldSet(this, _client, client);
+  }
+  visitPattern(node, options, callback) {
+    if (!node) {
+      return;
+    }
+    this._checkIdentifierOrVisit(node.typeAnnotation);
+    if (node.type === "AssignmentPattern") {
+      this._checkIdentifierOrVisit(node.left.typeAnnotation);
+    }
+    if (typeof options === "function") {
+      callback = options;
+      options = {
+        processRightHandNodes: false
+      };
+    }
+    const visitor = new PatternVisitor(this.options, node, callback);
+    visitor.visit(node);
+    if (options.processRightHandNodes) {
+      visitor.rightHandNodes.forEach(this.visit, this);
+    }
+  }
+  visitClass(node) {
+    this._visitArray(node.decorators);
+    const typeParamScope = this._nestTypeParamScope(node);
+    this._visitTypeAnnotation(node.implements);
+    this._visitTypeAnnotation(node.superTypeParameters && node.superTypeParameters.params);
+    super.visitClass(node);
+    if (typeParamScope) {
+      this.close(node);
+    }
+  }
+  visitFunction(node) {
+    const typeParamScope = this._nestTypeParamScope(node);
+    this._checkIdentifierOrVisit(node.returnType);
+    super.visitFunction(node);
+    if (typeParamScope) {
+      this.close(node);
+    }
+  }
+  visitProperty(node) {
+    var _node$value;
+    if (((_node$value = node.value) == null ? void 0 : _node$value.type) === "TypeCastExpression") {
+      this._visitTypeAnnotation(node.value);
+    }
+    this._visitArray(node.decorators);
+    super.visitProperty(node);
+  }
+  InterfaceDeclaration(node) {
+    this._createScopeVariable(node, node.id);
+    const typeParamScope = this._nestTypeParamScope(node);
+    this._visitArray(node.extends);
+    this.visit(node.body);
+    if (typeParamScope) {
+      this.close(node);
+    }
+  }
+  TypeAlias(node) {
+    this._createScopeVariable(node, node.id);
+    const typeParamScope = this._nestTypeParamScope(node);
+    this.visit(node.right);
+    if (typeParamScope) {
+      this.close(node);
+    }
+  }
+  ClassProperty(node) {
+    this._visitClassProperty(node);
+  }
+  ClassPrivateProperty(node) {
+    this._visitClassProperty(node);
+  }
+  PropertyDefinition(node) {
+    this._visitClassProperty(node);
+  }
+  ClassPrivateMethod(node) {
+    super.MethodDefinition(node);
+  }
+  DeclareModule(node) {
+    this._visitDeclareX(node);
+  }
+  DeclareFunction(node) {
+    this._visitDeclareX(node);
+  }
+  DeclareVariable(node) {
+    this._visitDeclareX(node);
+  }
+  DeclareClass(node) {
+    this._visitDeclareX(node);
+  }
+  OptionalMemberExpression(node) {
+    super.MemberExpression(node);
+  }
+  _visitClassProperty(node) {
+    this._visitTypeAnnotation(node.typeAnnotation);
+    this.visitProperty(node);
+  }
+  _visitDeclareX(node) {
+    if (node.id) {
+      this._createScopeVariable(node, node.id);
+    }
+    const typeParamScope = this._nestTypeParamScope(node);
+    if (typeParamScope) {
+      this.close(node);
+    }
+  }
+  _createScopeVariable(node, name) {
+    this.currentScope().variableScope.__define(name, new Definition("Variable", name, node, null, null, null));
+  }
+  _nestTypeParamScope(node) {
+    if (!node.typeParameters) {
+      return null;
+    }
+    const parentScope = this.scopeManager.__currentScope;
+    const scope = new Scope(this.scopeManager, "type-parameters", parentScope, node, false);
+    this.scopeManager.__nestScope(scope);
+    for (let j = 0; j < node.typeParameters.params.length; j++) {
+      const name = node.typeParameters.params[j];
+      scope.__define(name, new Definition("TypeParameter", name, name));
+      if (name.typeAnnotation) {
+        this._checkIdentifierOrVisit(name);
+      }
+    }
+    scope.__define = function () {
+      return parentScope.__define.apply(parentScope, arguments);
+    };
+    return scope;
+  }
+  _visitTypeAnnotation(node) {
+    if (!node) {
+      return;
+    }
+    if (Array.isArray(node)) {
+      node.forEach(this._visitTypeAnnotation, this);
+      return;
+    }
+    const visitorValues = getVisitorValues(node.type, _classPrivateFieldGet(this, _client));
+    if (!visitorValues) {
+      return;
+    }
+    for (let i = 0; i < visitorValues.length; i++) {
+      const visitorValue = visitorValues[i];
+      const propertyType = propertyTypes[visitorValue];
+      const nodeProperty = node[visitorValue];
+      if (propertyType == null || nodeProperty == null) {
+        continue;
+      }
+      if (propertyType.type === "loop") {
+        for (let j = 0; j < nodeProperty.length; j++) {
+          if (Array.isArray(propertyType.values)) {
+            for (let k = 0; k < propertyType.values.length; k++) {
+              const loopPropertyNode = nodeProperty[j][propertyType.values[k]];
+              if (loopPropertyNode) {
+                this._checkIdentifierOrVisit(loopPropertyNode);
+              }
+            }
+          } else {
+            this._checkIdentifierOrVisit(nodeProperty[j]);
+          }
+        }
+      } else if (propertyType.type === "single") {
+        this._checkIdentifierOrVisit(nodeProperty);
+      } else if (propertyType.type === "typeAnnotation") {
+        this._visitTypeAnnotation(node.typeAnnotation);
+      } else if (propertyType.type === "typeParameters") {
+        for (let l = 0; l < node.typeParameters.params.length; l++) {
+          this._checkIdentifierOrVisit(node.typeParameters.params[l]);
+        }
+      } else if (propertyType.type === "id") {
+        if (node.id.type === "Identifier") {
+          this._checkIdentifierOrVisit(node.id);
+        } else {
+          this._visitTypeAnnotation(node.id);
+        }
+      }
+    }
+  }
+  _checkIdentifierOrVisit(node) {
+    if (node != null && node.typeAnnotation) {
+      this._visitTypeAnnotation(node.typeAnnotation);
+    } else if ((node == null ? void 0 : node.type) === "Identifier") {
+      this.visit(node);
+    } else {
+      this._visitTypeAnnotation(node);
+    }
+  }
+  _visitArray(nodeList) {
+    if (nodeList) {
+      for (const node of nodeList) {
+        this.visit(node);
+      }
+    }
+  }
+}
+module.exports = function analyzeScope(ast, parserOptions, client) {
+  var _parserOptions$ecmaFe;
+  const options = {
+    ignoreEval: true,
+    optimistic: false,
+    directive: false,
+    nodejsScope: ast.sourceType === "script" && ((_parserOptions$ecmaFe = parserOptions.ecmaFeatures) == null ? void 0 : _parserOptions$ecmaFe.globalReturn) === true,
+    impliedStrict: false,
+    sourceType: ast.sourceType,
+    ecmaVersion: parserOptions.ecmaVersion,
+    fallback
+  };
+  options.childVisitorKeys = client.getVisitorKeys();
+  const scopeManager = new ScopeManager(options);
+  const referencer = new Referencer(options, scopeManager, client);
+  referencer.visit(ast);
+  return scopeManager;
+};
+
+//# sourceMappingURL=analyze-scope.cjs.map

node_modules/@babel/eslint-parser/lib/client.cjs

@@ -0,0 +1,126 @@
+var _class, _worker, _worker_threads, _worker_threads_cache;
+function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { _classCheckPrivateStaticAccess(receiver, classConstructor); _classCheckPrivateStaticFieldDescriptor(descriptor, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { _classCheckPrivateStaticAccess(receiver, classConstructor); _classCheckPrivateStaticFieldDescriptor(descriptor, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classCheckPrivateStaticFieldDescriptor(descriptor, action) { if (descriptor === undefined) { throw new TypeError("attempted to " + action + " private static field before its declaration"); } }
+function _classCheckPrivateStaticAccess(receiver, classConstructor) { if (receiver !== classConstructor) { throw new TypeError("Private static access of wrong provenance"); } }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+const path = require("path");
+const ACTIONS = {
+  GET_VERSION: "GET_VERSION",
+  GET_TYPES_INFO: "GET_TYPES_INFO",
+  GET_VISITOR_KEYS: "GET_VISITOR_KEYS",
+  GET_TOKEN_LABELS: "GET_TOKEN_LABELS",
+  MAYBE_PARSE: "MAYBE_PARSE",
+  MAYBE_PARSE_SYNC: "MAYBE_PARSE_SYNC"
+};
+var _send = new WeakMap();
+var _vCache = new WeakMap();
+var _tiCache = new WeakMap();
+var _vkCache = new WeakMap();
+var _tlCache = new WeakMap();
+class Client {
+  constructor(send) {
+    _classPrivateFieldInitSpec(this, _send, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec(this, _vCache, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec(this, _tiCache, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec(this, _vkCache, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec(this, _tlCache, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldSet(this, _send, send);
+  }
+  getVersion() {
+    var _classPrivateFieldGet2;
+    return (_classPrivateFieldGet2 = _classPrivateFieldGet(this, _vCache)) != null ? _classPrivateFieldGet2 : _classPrivateFieldSet(this, _vCache, _classPrivateFieldGet(this, _send).call(this, ACTIONS.GET_VERSION, undefined));
+  }
+  getTypesInfo() {
+    var _classPrivateFieldGet3;
+    return (_classPrivateFieldGet3 = _classPrivateFieldGet(this, _tiCache)) != null ? _classPrivateFieldGet3 : _classPrivateFieldSet(this, _tiCache, _classPrivateFieldGet(this, _send).call(this, ACTIONS.GET_TYPES_INFO, undefined));
+  }
+  getVisitorKeys() {
+    var _classPrivateFieldGet4;
+    return (_classPrivateFieldGet4 = _classPrivateFieldGet(this, _vkCache)) != null ? _classPrivateFieldGet4 : _classPrivateFieldSet(this, _vkCache, _classPrivateFieldGet(this, _send).call(this, ACTIONS.GET_VISITOR_KEYS, undefined));
+  }
+  getTokLabels() {
+    var _classPrivateFieldGet5;
+    return (_classPrivateFieldGet5 = _classPrivateFieldGet(this, _tlCache)) != null ? _classPrivateFieldGet5 : _classPrivateFieldSet(this, _tlCache, _classPrivateFieldGet(this, _send).call(this, ACTIONS.GET_TOKEN_LABELS, undefined));
+  }
+  maybeParse(code, options) {
+    return _classPrivateFieldGet(this, _send).call(this, ACTIONS.MAYBE_PARSE, {
+      code,
+      options
+    });
+  }
+}
+exports.WorkerClient = (_worker = new WeakMap(), (_class = class WorkerClient extends Client {
+  constructor() {
+    super((action, payload) => {
+      const signal = new Int32Array(new SharedArrayBuffer(8));
+      const subChannel = new (_classStaticPrivateFieldSpecGet(WorkerClient, _class, _worker_threads).MessageChannel)();
+      _classPrivateFieldGet(this, _worker).postMessage({
+        signal,
+        port: subChannel.port1,
+        action,
+        payload
+      }, [subChannel.port1]);
+      Atomics.wait(signal, 0, 0);
+      const {
+        message
+      } = _classStaticPrivateFieldSpecGet(WorkerClient, _class, _worker_threads).receiveMessageOnPort(subChannel.port2);
+      if (message.error) throw Object.assign(message.error, message.errorData);else return message.result;
+    });
+    _classPrivateFieldInitSpec(this, _worker, {
+      writable: true,
+      value: new (_classStaticPrivateFieldSpecGet(WorkerClient, _class, _worker_threads).Worker)(path.resolve(__dirname, "../lib/worker/index.cjs"), {
+        env: _classStaticPrivateFieldSpecGet(WorkerClient, _class, _worker_threads).SHARE_ENV
+      })
+    });
+    _classPrivateFieldGet(this, _worker).unref();
+  }
+}, _worker_threads = {
+  get: _get_worker_threads,
+  set: void 0
+}, _worker_threads_cache = {
+  writable: true,
+  value: void 0
+}, _class));
+function _get_worker_threads() {
+  var _classStaticPrivateFi2;
+  return (_classStaticPrivateFi2 = _classStaticPrivateFieldSpecGet(_class, _class, _worker_threads_cache)) != null ? _classStaticPrivateFi2 : _classStaticPrivateFieldSpecSet(_class, _class, _worker_threads_cache, require("worker_threads"));
+}
+{
+  var _class2, _handleMessage;
+  exports.LocalClient = (_class2 = class LocalClient extends Client {
+    constructor() {
+      var _classStaticPrivateFi;
+      (_classStaticPrivateFi = _classStaticPrivateFieldSpecGet(LocalClient, _class2, _handleMessage)) != null ? _classStaticPrivateFi : _classStaticPrivateFieldSpecSet(LocalClient, _class2, _handleMessage, require("./worker/handle-message.cjs"));
+      super((action, payload) => {
+        return _classStaticPrivateFieldSpecGet(LocalClient, _class2, _handleMessage).call(LocalClient, action === ACTIONS.MAYBE_PARSE ? ACTIONS.MAYBE_PARSE_SYNC : action, payload);
+      });
+    }
+  }, _handleMessage = {
+    writable: true,
+    value: void 0
+  }, _class2);
+}
+
+//# sourceMappingURL=client.cjs.map

node_modules/@babel/eslint-parser/lib/configuration.cjs

@@ -0,0 +1,21 @@
+const _excluded = ["babelOptions", "ecmaVersion", "sourceType", "requireConfigFile"];
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+exports.normalizeESLintConfig = function (options) {
+  const {
+      babelOptions = {},
+      ecmaVersion = 2020,
+      sourceType = "module",
+      requireConfigFile = true
+    } = options,
+    otherOptions = _objectWithoutPropertiesLoose(options, _excluded);
+  return Object.assign({
+    babelOptions: Object.assign({
+      cwd: process.cwd()
+    }, babelOptions),
+    ecmaVersion: ecmaVersion === "latest" ? 1e8 : ecmaVersion,
+    sourceType,
+    requireConfigFile
+  }, otherOptions);
+};
+
+//# sourceMappingURL=configuration.cjs.map

node_modules/@babel/eslint-parser/lib/configuration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["exports","normalizeESLintConfig","options","babelOptions","ecmaVersion","sourceType","requireConfigFile","otherOptions","_objectWithoutPropertiesLoose","_excluded","Object","assign","cwd","process"],"sources":["../src/configuration.cjs"],"sourcesContent":["exports.normalizeESLintConfig = function (options) {\n  const {\n    babelOptions = {},\n    // ESLint sets ecmaVersion: undefined when ecmaVersion is not set in the config.\n    ecmaVersion = 2020,\n    sourceType = \"module\",\n    requireConfigFile = true,\n    ...otherOptions\n  } = options;\n\n  return {\n    babelOptions: { cwd: process.cwd(), ...babelOptions },\n    ecmaVersion: ecmaVersion === \"latest\" ? 1e8 : ecmaVersion,\n    sourceType,\n    requireConfigFile,\n    ...otherOptions,\n  };\n};\n"],"mappings":";;AAAAA,OAAO,CAACC,qBAAqB,GAAG,UAAUC,OAAO,EAAE;EACjD,MAAM;MACJC,YAAY,GAAG,CAAC,CAAC;MAEjBC,WAAW,GAAG,IAAI;MAClBC,UAAU,GAAG,QAAQ;MACrBC,iBAAiB,GAAG;IAEtB,CAAC,GAAGJ,OAAO;IADNK,YAAY,GAAAC,6BAAA,CACbN,OAAO,EAAAO,SAAA;EAEX,OAAAC,MAAA,CAAAC,MAAA;IACER,YAAY,EAAAO,MAAA,CAAAC,MAAA;MAAIC,GAAG,EAAEC,OAAO,CAACD,GAAG,CAAC;IAAC,GAAKT,YAAY,CAAE;IACrDC,WAAW,EAAEA,WAAW,KAAK,QAAQ,GAAG,GAAG,GAAGA,WAAW;IACzDC,UAAU;IACVC;EAAiB,GACdC,YAAY;AAEnB,CAAC"}

node_modules/@babel/eslint-parser/lib/convert/convertAST.cjs

@@ -0,0 +1,129 @@
+const ESLINT_VERSION = require("../utils/eslint-version.cjs");
+function* it(children) {
+  if (Array.isArray(children)) yield* children;else yield children;
+}
+function traverse(node, visitorKeys, visitor) {
+  const {
+    type
+  } = node;
+  if (!type) return;
+  const keys = visitorKeys[type];
+  if (!keys) return;
+  for (const key of keys) {
+    for (const child of it(node[key])) {
+      if (child && typeof child === "object") {
+        visitor.enter(child);
+        traverse(child, visitorKeys, visitor);
+        visitor.exit(child);
+      }
+    }
+  }
+}
+const convertNodesVisitor = {
+  enter(node) {
+    if (node.innerComments) {
+      delete node.innerComments;
+    }
+    if (node.trailingComments) {
+      delete node.trailingComments;
+    }
+    if (node.leadingComments) {
+      delete node.leadingComments;
+    }
+  },
+  exit(node) {
+    if (node.extra) {
+      delete node.extra;
+    }
+    if (node.loc.identifierName) {
+      delete node.loc.identifierName;
+    }
+    if (node.type === "TypeParameter") {
+      node.type = "Identifier";
+      node.typeAnnotation = node.bound;
+      delete node.bound;
+    }
+    if (node.type === "QualifiedTypeIdentifier") {
+      delete node.id;
+    }
+    if (node.type === "ObjectTypeProperty") {
+      delete node.key;
+    }
+    if (node.type === "ObjectTypeIndexer") {
+      delete node.id;
+    }
+    if (node.type === "FunctionTypeParam") {
+      delete node.name;
+    }
+    if (node.type === "ImportDeclaration") {
+      delete node.isType;
+    }
+    if (node.type === "TemplateLiteral") {
+      for (let i = 0; i < node.quasis.length; i++) {
+        const q = node.quasis[i];
+        q.range[0] -= 1;
+        if (q.tail) {
+          q.range[1] += 1;
+        } else {
+          q.range[1] += 2;
+        }
+        q.loc.start.column -= 1;
+        if (q.tail) {
+          q.loc.end.column += 1;
+        } else {
+          q.loc.end.column += 2;
+        }
+        if (ESLINT_VERSION >= 8) {
+          q.start -= 1;
+          if (q.tail) {
+            q.end += 1;
+          } else {
+            q.end += 2;
+          }
+        }
+      }
+    }
+  }
+};
+function convertNodes(ast, visitorKeys) {
+  traverse(ast, visitorKeys, convertNodesVisitor);
+}
+function convertProgramNode(ast) {
+  ast.type = "Program";
+  ast.sourceType = ast.program.sourceType;
+  ast.body = ast.program.body;
+  delete ast.program;
+  delete ast.errors;
+  if (ast.comments.length) {
+    const lastComment = ast.comments[ast.comments.length - 1];
+    if (ast.tokens.length) {
+      const lastToken = ast.tokens[ast.tokens.length - 1];
+      if (lastComment.end > lastToken.end) {
+        ast.range[1] = lastToken.end;
+        ast.loc.end.line = lastToken.loc.end.line;
+        ast.loc.end.column = lastToken.loc.end.column;
+        if (ESLINT_VERSION >= 8) {
+          ast.end = lastToken.end;
+        }
+      }
+    }
+  } else {
+    if (!ast.tokens.length) {
+      ast.loc.start.line = 1;
+      ast.loc.end.line = 1;
+    }
+  }
+  if (ast.body && ast.body.length > 0) {
+    ast.loc.start.line = ast.body[0].loc.start.line;
+    ast.range[0] = ast.body[0].start;
+    if (ESLINT_VERSION >= 8) {
+      ast.start = ast.body[0].start;
+    }
+  }
+}
+module.exports = function convertAST(ast, visitorKeys) {
+  convertNodes(ast, visitorKeys);
+  convertProgramNode(ast);
+};
+
+//# sourceMappingURL=convertAST.cjs.map

node_modules/@babel/eslint-parser/lib/convert/convertComments.cjs

@@ -0,0 +1,14 @@
+module.exports = function convertComments(comments) {
+  for (const comment of comments) {
+    if (comment.type === "CommentBlock") {
+      comment.type = "Block";
+    } else if (comment.type === "CommentLine") {
+      comment.type = "Line";
+    }
+    if (!comment.range) {
+      comment.range = [comment.start, comment.end];
+    }
+  }
+};
+
+//# sourceMappingURL=convertComments.cjs.map

node_modules/@babel/eslint-parser/lib/convert/convertComments.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["module","exports","convertComments","comments","comment","type","range","start","end"],"sources":["../../src/convert/convertComments.cjs"],"sourcesContent":["module.exports = function convertComments(comments) {\n  for (const comment of comments) {\n    if (comment.type === \"CommentBlock\") {\n      comment.type = \"Block\";\n    } else if (comment.type === \"CommentLine\") {\n      comment.type = \"Line\";\n    }\n    // sometimes comments don't get ranges computed,\n    // even with options.ranges === true\n    if (!comment.range) {\n      comment.range = [comment.start, comment.end];\n    }\n  }\n};\n"],"mappings":"AAAAA,MAAM,CAACC,OAAO,GAAG,SAASC,eAAeA,CAACC,QAAQ,EAAE;EAClD,KAAK,MAAMC,OAAO,IAAID,QAAQ,EAAE;IAC9B,IAAIC,OAAO,CAACC,IAAI,KAAK,cAAc,EAAE;MACnCD,OAAO,CAACC,IAAI,GAAG,OAAO;IACxB,CAAC,MAAM,IAAID,OAAO,CAACC,IAAI,KAAK,aAAa,EAAE;MACzCD,OAAO,CAACC,IAAI,GAAG,MAAM;IACvB;IAGA,IAAI,CAACD,OAAO,CAACE,KAAK,EAAE;MAClBF,OAAO,CAACE,KAAK,GAAG,CAACF,OAAO,CAACG,KAAK,EAAEH,OAAO,CAACI,GAAG,CAAC;IAC9C;EACF;AACF,CAAC"}

node_modules/@babel/eslint-parser/lib/convert/convertTokens.cjs

@@ -0,0 +1,159 @@
+const ESLINT_VERSION = require("../utils/eslint-version.cjs");
+function convertTemplateType(tokens, tl) {
+  let curlyBrace = null;
+  let templateTokens = [];
+  const result = [];
+  function addTemplateType() {
+    const start = templateTokens[0];
+    const end = templateTokens[templateTokens.length - 1];
+    const value = templateTokens.reduce((result, token) => {
+      if (token.value) {
+        result += token.value;
+      } else if (token.type.label !== tl.template) {
+        result += token.type.label;
+      }
+      return result;
+    }, "");
+    result.push({
+      type: "Template",
+      value: value,
+      start: start.start,
+      end: end.end,
+      loc: {
+        start: start.loc.start,
+        end: end.loc.end
+      }
+    });
+    templateTokens = [];
+  }
+  tokens.forEach(token => {
+    switch (token.type.label) {
+      case tl.backQuote:
+        if (curlyBrace) {
+          result.push(curlyBrace);
+          curlyBrace = null;
+        }
+        templateTokens.push(token);
+        if (templateTokens.length > 1) {
+          addTemplateType();
+        }
+        break;
+      case tl.dollarBraceL:
+        templateTokens.push(token);
+        addTemplateType();
+        break;
+      case tl.braceR:
+        if (curlyBrace) {
+          result.push(curlyBrace);
+        }
+        curlyBrace = token;
+        break;
+      case tl.template:
+        if (curlyBrace) {
+          templateTokens.push(curlyBrace);
+          curlyBrace = null;
+        }
+        templateTokens.push(token);
+        break;
+      default:
+        if (curlyBrace) {
+          result.push(curlyBrace);
+          curlyBrace = null;
+        }
+        result.push(token);
+    }
+  });
+  return result;
+}
+function convertToken(token, source, tl) {
+  const {
+    type
+  } = token;
+  const {
+    label
+  } = type;
+  token.range = [token.start, token.end];
+  if (label === tl.name) {
+    if (token.value === "static") {
+      token.type = "Keyword";
+    } else {
+      token.type = "Identifier";
+    }
+  } else if (label === tl.semi || label === tl.comma || label === tl.parenL || label === tl.parenR || label === tl.braceL || label === tl.braceR || label === tl.slash || label === tl.dot || label === tl.bracketL || label === tl.bracketR || label === tl.ellipsis || label === tl.arrow || label === tl.pipeline || label === tl.star || label === tl.incDec || label === tl.colon || label === tl.question || label === tl.template || label === tl.backQuote || label === tl.dollarBraceL || label === tl.at || label === tl.logicalOR || label === tl.logicalAND || label === tl.nullishCoalescing || label === tl.bitwiseOR || label === tl.bitwiseXOR || label === tl.bitwiseAND || label === tl.equality || label === tl.relational || label === tl.bitShift || label === tl.plusMin || label === tl.modulo || label === tl.exponent || label === tl.bang || label === tl.tilde || label === tl.doubleColon || label === tl.hash || label === tl.questionDot || label === tl.braceHashL || label === tl.braceBarL || label === tl.braceBarR || label === tl.bracketHashL || label === tl.bracketBarL || label === tl.bracketBarR || label === tl.doubleCaret || label === tl.doubleAt || type.isAssign) {
+    var _token$value;
+    token.type = "Punctuator";
+    (_token$value = token.value) != null ? _token$value : token.value = label;
+  } else if (label === tl.jsxTagStart) {
+    token.type = "Punctuator";
+    token.value = "<";
+  } else if (label === tl.jsxTagEnd) {
+    token.type = "Punctuator";
+    token.value = ">";
+  } else if (label === tl.jsxName) {
+    token.type = "JSXIdentifier";
+  } else if (label === tl.jsxText) {
+    token.type = "JSXText";
+  } else if (type.keyword === "null") {
+    token.type = "Null";
+  } else if (type.keyword === "false" || type.keyword === "true") {
+    token.type = "Boolean";
+  } else if (type.keyword) {
+    token.type = "Keyword";
+  } else if (label === tl.num) {
+    token.type = "Numeric";
+    token.value = source.slice(token.start, token.end);
+  } else if (label === tl.string) {
+    token.type = "String";
+    token.value = source.slice(token.start, token.end);
+  } else if (label === tl.regexp) {
+    token.type = "RegularExpression";
+    const value = token.value;
+    token.regex = {
+      pattern: value.pattern,
+      flags: value.flags
+    };
+    token.value = `/${value.pattern}/${value.flags}`;
+  } else if (label === tl.bigint) {
+    token.type = "Numeric";
+    token.value = `${token.value}n`;
+  } else if (label === tl.privateName) {
+    token.type = "PrivateIdentifier";
+  } else if (label === tl.templateNonTail || label === tl.templateTail) {
+    token.type = "Template";
+  }
+  if (typeof token.type !== "string") {
+    delete token.type.rightAssociative;
+  }
+}
+module.exports = function convertTokens(tokens, code, tl) {
+  const result = [];
+  const templateTypeMergedTokens = convertTemplateType(tokens, tl);
+  for (let i = 0, {
+      length
+    } = templateTypeMergedTokens; i < length - 1; i++) {
+    const token = templateTypeMergedTokens[i];
+    const tokenType = token.type;
+    if (tokenType === "CommentLine" || tokenType === "CommentBlock") {
+      continue;
+    }
+    {
+      if (ESLINT_VERSION >= 8 && i + 1 < length && tokenType.label === tl.hash) {
+        const nextToken = templateTypeMergedTokens[i + 1];
+        if (nextToken.type.label === tl.name && token.end === nextToken.start) {
+          i++;
+          nextToken.type = "PrivateIdentifier";
+          nextToken.start -= 1;
+          nextToken.loc.start.column -= 1;
+          nextToken.range = [nextToken.start, nextToken.end];
+          result.push(nextToken);
+          continue;
+        }
+      }
+    }
+    convertToken(token, code, tl);
+    result.push(token);
+  }
+  return result;
+};
+
+//# sourceMappingURL=convertTokens.cjs.map

node_modules/@babel/eslint-parser/lib/convert/index.cjs

@@ -0,0 +1,18 @@
+const convertTokens = require("./convertTokens.cjs");
+const convertComments = require("./convertComments.cjs");
+const convertAST = require("./convertAST.cjs");
+exports.ast = function convert(ast, code, tokLabels, visitorKeys) {
+  ast.tokens = convertTokens(ast.tokens, code, tokLabels);
+  convertComments(ast.comments);
+  convertAST(ast, visitorKeys);
+  return ast;
+};
+exports.error = function convertError(err) {
+  if (err instanceof SyntaxError) {
+    err.lineNumber = err.loc.line;
+    err.column = err.loc.column;
+  }
+  return err;
+};
+
+//# sourceMappingURL=index.cjs.map

node_modules/@babel/eslint-parser/lib/convert/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["convertTokens","require","convertComments","convertAST","exports","ast","convert","code","tokLabels","visitorKeys","tokens","comments","error","convertError","err","SyntaxError","lineNumber","loc","line","column"],"sources":["../../src/convert/index.cjs"],"sourcesContent":["const convertTokens = require(\"./convertTokens.cjs\");\nconst convertComments = require(\"./convertComments.cjs\");\nconst convertAST = require(\"./convertAST.cjs\");\n\nexports.ast = function convert(ast, code, tokLabels, visitorKeys) {\n  ast.tokens = convertTokens(ast.tokens, code, tokLabels);\n  convertComments(ast.comments);\n  convertAST(ast, visitorKeys);\n  return ast;\n};\n\nexports.error = function convertError(err) {\n  if (err instanceof SyntaxError) {\n    err.lineNumber = err.loc.line;\n    err.column = err.loc.column;\n  }\n  return err;\n};\n"],"mappings":"AAAA,MAAMA,aAAa,GAAGC,OAAO,CAAC,qBAAqB,CAAC;AACpD,MAAMC,eAAe,GAAGD,OAAO,CAAC,uBAAuB,CAAC;AACxD,MAAME,UAAU,GAAGF,OAAO,CAAC,kBAAkB,CAAC;AAE9CG,OAAO,CAACC,GAAG,GAAG,SAASC,OAAOA,CAACD,GAAG,EAAEE,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAE;EAChEJ,GAAG,CAACK,MAAM,GAAGV,aAAa,CAACK,GAAG,CAACK,MAAM,EAAEH,IAAI,EAAEC,SAAS,CAAC;EACvDN,eAAe,CAACG,GAAG,CAACM,QAAQ,CAAC;EAC7BR,UAAU,CAACE,GAAG,EAAEI,WAAW,CAAC;EAC5B,OAAOJ,GAAG;AACZ,CAAC;AAEDD,OAAO,CAACQ,KAAK,GAAG,SAASC,YAAYA,CAACC,GAAG,EAAE;EACzC,IAAIA,GAAG,YAAYC,WAAW,EAAE;IAC9BD,GAAG,CAACE,UAAU,GAAGF,GAAG,CAACG,GAAG,CAACC,IAAI;IAC7BJ,GAAG,CAACK,MAAM,GAAGL,GAAG,CAACG,GAAG,CAACE,MAAM;EAC7B;EACA,OAAOL,GAAG;AACZ,CAAC"}

node_modules/@babel/eslint-parser/lib/experimental-worker.cjs

@@ -0,0 +1,29 @@
+const [major, minor] = process.versions.node.split(".").map(Number);
+if (major < 12 || major === 12 && minor < 3) {
+  throw new Error("@babel/eslint-parser/experimental-worker requires Node.js >= 12.3.0");
+}
+const {
+  normalizeESLintConfig
+} = require("./configuration.cjs");
+const analyzeScope = require("./analyze-scope.cjs");
+const baseParse = require("./parse.cjs");
+const {
+  WorkerClient
+} = require("./client.cjs");
+const client = new WorkerClient();
+exports.meta = {
+  name: "@babel/eslint-parser/experimental-worker",
+  version: "7.22.10"
+};
+exports.parseForESLint = function (code, options = {}) {
+  const normalizedOptions = normalizeESLintConfig(options);
+  const ast = baseParse(code, normalizedOptions, client);
+  const scopeManager = analyzeScope(ast, normalizedOptions, client);
+  return {
+    ast,
+    scopeManager,
+    visitorKeys: client.getVisitorKeys()
+  };
+};
+
+//# sourceMappingURL=experimental-worker.cjs.map

node_modules/@babel/eslint-parser/lib/experimental-worker.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["major","minor","process","versions","node","split","map","Number","Error","normalizeESLintConfig","require","analyzeScope","baseParse","WorkerClient","client","exports","meta","name","version","parseForESLint","code","options","normalizedOptions","ast","scopeManager","visitorKeys","getVisitorKeys"],"sources":["../src/experimental-worker.cjs"],"sourcesContent":["const [major, minor] = process.versions.node.split(\".\").map(Number);\n\nif (major < 12 || (major === 12 && minor < 3)) {\n  throw new Error(\n    \"@babel/eslint-parser/experimental-worker requires Node.js >= 12.3.0\",\n  );\n}\n\nconst { normalizeESLintConfig } = require(\"./configuration.cjs\");\nconst analyzeScope = require(\"./analyze-scope.cjs\");\nconst baseParse = require(\"./parse.cjs\");\n\nconst { WorkerClient } = require(\"./client.cjs\");\nconst client = new WorkerClient();\n\nexports.meta = {\n  name: \"@babel/eslint-parser/experimental-worker\",\n  version: PACKAGE_JSON.version,\n};\n\nexports.parseForESLint = function (code, options = {}) {\n  const normalizedOptions = normalizeESLintConfig(options);\n  const ast = baseParse(code, normalizedOptions, client);\n  const scopeManager = analyzeScope(ast, normalizedOptions, client);\n\n  return { ast, scopeManager, visitorKeys: client.getVisitorKeys() };\n};\n"],"mappings":"AAAA,MAAM,CAACA,KAAK,EAAEC,KAAK,CAAC,GAAGC,OAAO,CAACC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAAC,GAAG,CAAC,CAACC,GAAG,CAACC,MAAM,CAAC;AAEnE,IAAIP,KAAK,GAAG,EAAE,IAAKA,KAAK,KAAK,EAAE,IAAIC,KAAK,GAAG,CAAE,EAAE;EAC7C,MAAM,IAAIO,KAAK,CACb,qEACF,CAAC;AACH;AAEA,MAAM;EAAEC;AAAsB,CAAC,GAAGC,OAAO,CAAC,qBAAqB,CAAC;AAChE,MAAMC,YAAY,GAAGD,OAAO,CAAC,qBAAqB,CAAC;AACnD,MAAME,SAAS,GAAGF,OAAO,CAAC,aAAa,CAAC;AAExC,MAAM;EAAEG;AAAa,CAAC,GAAGH,OAAO,CAAC,cAAc,CAAC;AAChD,MAAMI,MAAM,GAAG,IAAID,YAAY,CAAC,CAAC;AAEjCE,OAAO,CAACC,IAAI,GAAG;EACbC,IAAI,EAAE,0CAA0C;EAChDC,OAAO;AACT,CAAC;AAEDH,OAAO,CAACI,cAAc,GAAG,UAAUC,IAAI,EAAEC,OAAO,GAAG,CAAC,CAAC,EAAE;EACrD,MAAMC,iBAAiB,GAAGb,qBAAqB,CAACY,OAAO,CAAC;EACxD,MAAME,GAAG,GAAGX,SAAS,CAACQ,IAAI,EAAEE,iBAAiB,EAAER,MAAM,CAAC;EACtD,MAAMU,YAAY,GAAGb,YAAY,CAACY,GAAG,EAAED,iBAAiB,EAAER,MAAM,CAAC;EAEjE,OAAO;IAAES,GAAG;IAAEC,YAAY;IAAEC,WAAW,EAAEX,MAAM,CAACY,cAAc,CAAC;EAAE,CAAC;AACpE,CAAC"}

node_modules/@babel/eslint-parser/lib/index.cjs

@@ -0,0 +1,29 @@
+const {
+  normalizeESLintConfig
+} = require("./configuration.cjs");
+const analyzeScope = require("./analyze-scope.cjs");
+const baseParse = require("./parse.cjs");
+const {
+  LocalClient,
+  WorkerClient
+} = require("./client.cjs");
+const client = new LocalClient();
+exports.meta = {
+  name: "@babel/eslint-parser",
+  version: "7.22.10"
+};
+exports.parse = function (code, options = {}) {
+  return baseParse(code, normalizeESLintConfig(options), client);
+};
+exports.parseForESLint = function (code, options = {}) {
+  const normalizedOptions = normalizeESLintConfig(options);
+  const ast = baseParse(code, normalizedOptions, client);
+  const scopeManager = analyzeScope(ast, normalizedOptions, client);
+  return {
+    ast,
+    scopeManager,
+    visitorKeys: client.getVisitorKeys()
+  };
+};
+
+//# sourceMappingURL=index.cjs.map

node_modules/@babel/eslint-parser/lib/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["normalizeESLintConfig","require","analyzeScope","baseParse","LocalClient","WorkerClient","client","exports","meta","name","version","parse","code","options","parseForESLint","normalizedOptions","ast","scopeManager","visitorKeys","getVisitorKeys"],"sources":["../src/index.cjs"],"sourcesContent":["const { normalizeESLintConfig } = require(\"./configuration.cjs\");\nconst analyzeScope = require(\"./analyze-scope.cjs\");\nconst baseParse = require(\"./parse.cjs\");\n\nconst { LocalClient, WorkerClient } = require(\"./client.cjs\");\nconst client = new (USE_ESM ? WorkerClient : LocalClient)();\n\nexports.meta = {\n  name: PACKAGE_JSON.name,\n  version: PACKAGE_JSON.version,\n};\n\nexports.parse = function (code, options = {}) {\n  return baseParse(code, normalizeESLintConfig(options), client);\n};\n\nexports.parseForESLint = function (code, options = {}) {\n  const normalizedOptions = normalizeESLintConfig(options);\n  const ast = baseParse(code, normalizedOptions, client);\n  const scopeManager = analyzeScope(ast, normalizedOptions, client);\n\n  return { ast, scopeManager, visitorKeys: client.getVisitorKeys() };\n};\n"],"mappings":"AAAA,MAAM;EAAEA;AAAsB,CAAC,GAAGC,OAAO,CAAC,qBAAqB,CAAC;AAChE,MAAMC,YAAY,GAAGD,OAAO,CAAC,qBAAqB,CAAC;AACnD,MAAME,SAAS,GAAGF,OAAO,CAAC,aAAa,CAAC;AAExC,MAAM;EAAEG,WAAW;EAAEC;AAAa,CAAC,GAAGJ,OAAO,CAAC,cAAc,CAAC;AAC7D,MAAMK,MAAM,GAAG,IAA8BF,WAAW,CAAE,CAAC;AAE3DG,OAAO,CAACC,IAAI,GAAG;EACbC,IAAI,wBAAmB;EACvBC,OAAO;AACT,CAAC;AAEDH,OAAO,CAACI,KAAK,GAAG,UAAUC,IAAI,EAAEC,OAAO,GAAG,CAAC,CAAC,EAAE;EAC5C,OAAOV,SAAS,CAACS,IAAI,EAAEZ,qBAAqB,CAACa,OAAO,CAAC,EAAEP,MAAM,CAAC;AAChE,CAAC;AAEDC,OAAO,CAACO,cAAc,GAAG,UAAUF,IAAI,EAAEC,OAAO,GAAG,CAAC,CAAC,EAAE;EACrD,MAAME,iBAAiB,GAAGf,qBAAqB,CAACa,OAAO,CAAC;EACxD,MAAMG,GAAG,GAAGb,SAAS,CAACS,IAAI,EAAEG,iBAAiB,EAAET,MAAM,CAAC;EACtD,MAAMW,YAAY,GAAGf,YAAY,CAACc,GAAG,EAAED,iBAAiB,EAAET,MAAM,CAAC;EAEjE,OAAO;IAAEU,GAAG;IAAEC,YAAY;IAAEC,WAAW,EAAEZ,MAAM,CAACa,cAAc,CAAC;EAAE,CAAC;AACpE,CAAC"}

node_modules/@babel/eslint-parser/lib/parse.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+const semver = require("semver");
+const convert = require("./convert/index.cjs");
+const babelParser = require((((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, {
+  paths: [b]
+}, M = require("module")) => {
+  let f = M._findPath(r, M._nodeModulePaths(b).concat(b));
+  if (f) return f;
+  f = new Error(`Cannot resolve module '${r}'`);
+  f.code = "MODULE_NOT_FOUND";
+  throw f;
+})("@babel/parser", {
+  paths: [require.resolve("@babel/core/package.json")]
+}));
+let isRunningMinSupportedCoreVersion = null;
+module.exports = function parse(code, options, client) {
+  let minSupportedCoreVersion = ">=7.2.0";
+  ;
+  if (typeof isRunningMinSupportedCoreVersion !== "boolean") {
+    isRunningMinSupportedCoreVersion = semver.satisfies(client.getVersion(), minSupportedCoreVersion);
+  }
+  if (!isRunningMinSupportedCoreVersion) {
+    throw new Error(`@babel/eslint-parser@${"7.22.10"} does not support @babel/core@${client.getVersion()}. Please upgrade to @babel/core@${minSupportedCoreVersion}.`);
+  }
+  const {
+    ast,
+    parserOptions
+  } = client.maybeParse(code, options);
+  if (ast) return ast;
+  try {
+    return convert.ast(babelParser.parse(code, parserOptions), code, client.getTokLabels(), client.getVisitorKeys());
+  } catch (err) {
+    throw convert.error(err);
+  }
+};
+
+//# sourceMappingURL=parse.cjs.map

node_modules/@babel/eslint-parser/lib/parse.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["semver","require","convert","babelParser","v","w","split","process","versions","node","resolve","r","paths","b","M","f","_findPath","_nodeModulePaths","concat","Error","code","isRunningMinSupportedCoreVersion","module","exports","parse","options","client","minSupportedCoreVersion","satisfies","getVersion","ast","parserOptions","maybeParse","getTokLabels","getVisitorKeys","err","error"],"sources":["../src/parse.cjs"],"sourcesContent":["\"use strict\";\n\nconst semver = require(\"semver\");\nconst convert = require(\"./convert/index.cjs\");\n\nconst babelParser = require(require.resolve(\"@babel/parser\", {\n  paths: [require.resolve(\"@babel/core/package.json\")],\n}));\n\nlet isRunningMinSupportedCoreVersion = null;\n\nmodule.exports = function parse(code, options, client) {\n  // Ensure we're using a version of `@babel/core` that includes `parse()` and `tokTypes`.\n  let minSupportedCoreVersion = \">=7.2.0\";\n  // TODO(Babel 8): Update all the version checks\n  if (process.env.BABEL_8_BREAKING) {\n    minSupportedCoreVersion += \" || >=8.0.0-0\";\n  }\n\n  if (typeof isRunningMinSupportedCoreVersion !== \"boolean\") {\n    isRunningMinSupportedCoreVersion = semver.satisfies(\n      client.getVersion(),\n      minSupportedCoreVersion,\n    );\n  }\n\n  if (!isRunningMinSupportedCoreVersion) {\n    throw new Error(\n      `@babel/eslint-parser@${\n        PACKAGE_JSON.version\n      } does not support @babel/core@${client.getVersion()}. Please upgrade to @babel/core@${minSupportedCoreVersion}.`,\n    );\n  }\n\n  const { ast, parserOptions } = client.maybeParse(code, options);\n\n  if (ast) return ast;\n\n  try {\n    return convert.ast(\n      babelParser.parse(code, parserOptions),\n      code,\n      client.getTokLabels(),\n      client.getVisitorKeys(),\n    );\n  } catch (err) {\n    throw convert.error(err);\n  }\n};\n"],"mappings":"AAAA,YAAY;;AAEZ,MAAMA,MAAM,GAAGC,OAAO,CAAC,QAAQ,CAAC;AAChC,MAAMC,OAAO,GAAGD,OAAO,CAAC,qBAAqB,CAAC;AAE9C,MAAME,WAAW,GAAGF,OAAO,CAAC,GAAAG,CAAA,EAAAC,CAAA,MAAAD,CAAA,GAAAA,CAAA,CAAAE,KAAA,OAAAD,CAAA,GAAAA,CAAA,CAAAC,KAAA,QAAAF,CAAA,OAAAC,CAAA,OAAAD,CAAA,OAAAC,CAAA,QAAAD,CAAA,QAAAC,CAAA,MAAAE,OAAA,CAAAC,QAAA,CAAAC,IAAA,WAAAR,OAAA,CAAAS,OAAA,IAAAC,CAAA;EAAAC,KAAA,GAAAC,CAAA;AAAA,GAAAC,CAAA,GAAAb,OAAA;EAAA,IAAAc,CAAA,GAAAD,CAAA,CAAAE,SAAA,CAAAL,CAAA,EAAAG,CAAA,CAAAG,gBAAA,CAAAJ,CAAA,EAAAK,MAAA,CAAAL,CAAA;EAAA,IAAAE,CAAA,SAAAA,CAAA;EAAAA,CAAA,OAAAI,KAAA,2BAAAR,CAAA;EAAAI,CAAA,CAAAK,IAAA;EAAA,MAAAL,CAAA;AAAA,GAAgB,eAAe,EAAE;EAC3DH,KAAK,EAAE,CAACX,OAAO,CAACS,OAAO,CAAC,0BAA0B,CAAC;AACrD,CAAC,CAAC,CAAC;AAEH,IAAIW,gCAAgC,GAAG,IAAI;AAE3CC,MAAM,CAACC,OAAO,GAAG,SAASC,KAAKA,CAACJ,IAAI,EAAEK,OAAO,EAAEC,MAAM,EAAE;EAErD,IAAIC,uBAAuB,GAAG,SAAS;EAAC;EAMxC,IAAI,OAAON,gCAAgC,KAAK,SAAS,EAAE;IACzDA,gCAAgC,GAAGrB,MAAM,CAAC4B,SAAS,CACjDF,MAAM,CAACG,UAAU,CAAC,CAAC,EACnBF,uBACF,CAAC;EACH;EAEA,IAAI,CAACN,gCAAgC,EAAE;IACrC,MAAM,IAAIF,KAAK,CACZ,wBAAqB,SAErB,iCAAgCO,MAAM,CAACG,UAAU,CAAC,CAAE,mCAAkCF,uBAAwB,GACjH,CAAC;EACH;EAEA,MAAM;IAAEG,GAAG;IAAEC;EAAc,CAAC,GAAGL,MAAM,CAACM,UAAU,CAACZ,IAAI,EAAEK,OAAO,CAAC;EAE/D,IAAIK,GAAG,EAAE,OAAOA,GAAG;EAEnB,IAAI;IACF,OAAO5B,OAAO,CAAC4B,GAAG,CAChB3B,WAAW,CAACqB,KAAK,CAACJ,IAAI,EAAEW,aAAa,CAAC,EACtCX,IAAI,EACJM,MAAM,CAACO,YAAY,CAAC,CAAC,EACrBP,MAAM,CAACQ,cAAc,CAAC,CACxB,CAAC;EACH,CAAC,CAAC,OAAOC,GAAG,EAAE;IACZ,MAAMjC,OAAO,CAACkC,KAAK,CAACD,GAAG,CAAC;EAC1B;AACF,CAAC"}

node_modules/@babel/eslint-parser/lib/utils/eslint-version.cjs

@@ -0,0 +1,3 @@
+module.exports = parseInt(require("eslint/package.json").version, 10);
+
+//# sourceMappingURL=eslint-version.cjs.map

node_modules/@babel/eslint-parser/lib/utils/eslint-version.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["module","exports","parseInt","require","version"],"sources":["../../src/utils/eslint-version.cjs"],"sourcesContent":["module.exports = parseInt(require(\"eslint/package.json\").version, 10);\n"],"mappings":"AAAAA,MAAM,CAACC,OAAO,GAAGC,QAAQ,CAACC,OAAO,CAAC,qBAAqB,CAAC,CAACC,OAAO,EAAE,EAAE,CAAC"}

node_modules/@babel/eslint-parser/lib/worker/ast-info.cjs

@@ -0,0 +1,29 @@
+const ESLINT_VISITOR_KEYS = require("eslint-visitor-keys").KEYS;
+const babel = require("./babel-core.cjs");
+let visitorKeys;
+exports.getVisitorKeys = function getVisitorKeys() {
+  if (!visitorKeys) {
+    const newTypes = {
+      ChainExpression: ESLINT_VISITOR_KEYS.ChainExpression,
+      ImportExpression: ESLINT_VISITOR_KEYS.ImportExpression,
+      Literal: ESLINT_VISITOR_KEYS.Literal,
+      MethodDefinition: ["decorators"].concat(ESLINT_VISITOR_KEYS.MethodDefinition),
+      Property: ["decorators"].concat(ESLINT_VISITOR_KEYS.Property),
+      PropertyDefinition: ["decorators", "typeAnnotation"].concat(ESLINT_VISITOR_KEYS.PropertyDefinition)
+    };
+    const conflictTypes = {
+      ClassPrivateMethod: ["decorators"].concat(ESLINT_VISITOR_KEYS.MethodDefinition),
+      ExportAllDeclaration: ESLINT_VISITOR_KEYS.ExportAllDeclaration
+    };
+    visitorKeys = Object.assign({}, newTypes, babel.types.VISITOR_KEYS, conflictTypes);
+  }
+  return visitorKeys;
+};
+let tokLabels;
+exports.getTokLabels = function getTokLabels() {
+  return tokLabels || (tokLabels = (p => p.reduce((o, [k, v]) => Object.assign({}, o, {
+    [k]: v
+  }), {}))(Object.entries(babel.tokTypes).map(([key, tok]) => [key, tok.label])));
+};
+
+//# sourceMappingURL=ast-info.cjs.map

node_modules/@babel/eslint-parser/lib/worker/ast-info.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["ESLINT_VISITOR_KEYS","require","KEYS","babel","visitorKeys","exports","getVisitorKeys","newTypes","ChainExpression","ImportExpression","Literal","MethodDefinition","concat","Property","PropertyDefinition","conflictTypes","ClassPrivateMethod","ExportAllDeclaration","Object","assign","types","VISITOR_KEYS","tokLabels","getTokLabels","p","reduce","o","k","v","entries","tokTypes","map","key","tok","label"],"sources":["../../src/worker/ast-info.cjs"],"sourcesContent":["const ESLINT_VISITOR_KEYS = require(\"eslint-visitor-keys\").KEYS;\nconst babel = require(\"./babel-core.cjs\");\n\nlet visitorKeys;\nexports.getVisitorKeys = function getVisitorKeys() {\n  if (!visitorKeys) {\n    // AST Types that are not presented in Babel AST\n    const newTypes = {\n      ChainExpression: ESLINT_VISITOR_KEYS.ChainExpression,\n      ImportExpression: ESLINT_VISITOR_KEYS.ImportExpression,\n      Literal: ESLINT_VISITOR_KEYS.Literal,\n      MethodDefinition: [\"decorators\"].concat(\n        ESLINT_VISITOR_KEYS.MethodDefinition,\n      ),\n      Property: [\"decorators\"].concat(ESLINT_VISITOR_KEYS.Property),\n      PropertyDefinition: [\"decorators\", \"typeAnnotation\"].concat(\n        ESLINT_VISITOR_KEYS.PropertyDefinition,\n      ),\n    };\n\n    // AST Types that shares `\"type\"` property with Babel but have different shape\n    const conflictTypes = {\n      // todo: remove this when we drop Babel 7 support\n      ClassPrivateMethod: [\"decorators\"].concat(\n        ESLINT_VISITOR_KEYS.MethodDefinition,\n      ),\n      ExportAllDeclaration: ESLINT_VISITOR_KEYS.ExportAllDeclaration,\n    };\n\n    visitorKeys = {\n      ...newTypes,\n      ...babel.types.VISITOR_KEYS,\n      ...conflictTypes,\n    };\n  }\n  return visitorKeys;\n};\n\nlet tokLabels;\nexports.getTokLabels = function getTokLabels() {\n  return (tokLabels ||= (\n    process.env.BABEL_8_BREAKING\n      ? Object.fromEntries\n      : p => p.reduce((o, [k, v]) => ({ ...o, [k]: v }), {})\n  )(Object.entries(babel.tokTypes).map(([key, tok]) => [key, tok.label])));\n};\n"],"mappings":"AAAA,MAAMA,mBAAmB,GAAGC,OAAO,CAAC,qBAAqB,CAAC,CAACC,IAAI;AAC/D,MAAMC,KAAK,GAAGF,OAAO,CAAC,kBAAkB,CAAC;AAEzC,IAAIG,WAAW;AACfC,OAAO,CAACC,cAAc,GAAG,SAASA,cAAcA,CAAA,EAAG;EACjD,IAAI,CAACF,WAAW,EAAE;IAEhB,MAAMG,QAAQ,GAAG;MACfC,eAAe,EAAER,mBAAmB,CAACQ,eAAe;MACpDC,gBAAgB,EAAET,mBAAmB,CAACS,gBAAgB;MACtDC,OAAO,EAAEV,mBAAmB,CAACU,OAAO;MACpCC,gBAAgB,EAAE,CAAC,YAAY,CAAC,CAACC,MAAM,CACrCZ,mBAAmB,CAACW,gBACtB,CAAC;MACDE,QAAQ,EAAE,CAAC,YAAY,CAAC,CAACD,MAAM,CAACZ,mBAAmB,CAACa,QAAQ,CAAC;MAC7DC,kBAAkB,EAAE,CAAC,YAAY,EAAE,gBAAgB,CAAC,CAACF,MAAM,CACzDZ,mBAAmB,CAACc,kBACtB;IACF,CAAC;IAGD,MAAMC,aAAa,GAAG;MAEpBC,kBAAkB,EAAE,CAAC,YAAY,CAAC,CAACJ,MAAM,CACvCZ,mBAAmB,CAACW,gBACtB,CAAC;MACDM,oBAAoB,EAAEjB,mBAAmB,CAACiB;IAC5C,CAAC;IAEDb,WAAW,GAAAc,MAAA,CAAAC,MAAA,KACNZ,QAAQ,EACRJ,KAAK,CAACiB,KAAK,CAACC,YAAY,EACxBN,aAAa,CACjB;EACH;EACA,OAAOX,WAAW;AACpB,CAAC;AAED,IAAIkB,SAAS;AACbjB,OAAO,CAACkB,YAAY,GAAG,SAASA,YAAYA,CAAA,EAAG;EAC7C,OAAQD,SAAS,KAATA,SAAS,GAAK,CAGhBE,CAAC,IAAIA,CAAC,CAACC,MAAM,CAAC,CAACC,CAAC,EAAE,CAACC,CAAC,EAAEC,CAAC,CAAC,KAAAV,MAAA,CAAAC,MAAA,KAAWO,CAAC;IAAE,CAACC,CAAC,GAAGC;EAAC,EAAG,EAAE,CAAC,CAAC,CAAC,EACxDV,MAAM,CAACW,OAAO,CAAC1B,KAAK,CAAC2B,QAAQ,CAAC,CAACC,GAAG,CAAC,CAAC,CAACC,GAAG,EAAEC,GAAG,CAAC,KAAK,CAACD,GAAG,EAAEC,GAAG,CAACC,KAAK,CAAC,CAAC,CAAC;AACzE,CAAC"}

node_modules/@babel/eslint-parser/lib/worker/babel-core.cjs

@@ -0,0 +1,16 @@
+function initialize(babel) {
+  exports.init = null;
+  exports.version = babel.version;
+  exports.traverse = babel.traverse;
+  exports.types = babel.types;
+  exports.tokTypes = babel.tokTypes;
+  exports.parseSync = babel.parseSync;
+  exports.loadPartialConfigSync = babel.loadPartialConfigSync;
+  exports.loadPartialConfigAsync = babel.loadPartialConfigAsync;
+  exports.createConfigItem = babel.createConfigItem;
+}
+{
+  initialize(require("@babel/core"));
+}
+
+//# sourceMappingURL=babel-core.cjs.map

node_modules/@babel/eslint-parser/lib/worker/babel-core.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["initialize","babel","exports","init","version","traverse","types","tokTypes","parseSync","loadPartialConfigSync","loadPartialConfigAsync","createConfigItem","require"],"sources":["../../src/worker/babel-core.cjs"],"sourcesContent":["function initialize(babel) {\n  exports.init = null;\n  exports.version = babel.version;\n  exports.traverse = babel.traverse;\n  exports.types = babel.types;\n  exports.tokTypes = babel.tokTypes;\n  exports.parseSync = babel.parseSync;\n  exports.loadPartialConfigSync = babel.loadPartialConfigSync;\n  exports.loadPartialConfigAsync = babel.loadPartialConfigAsync;\n  exports.createConfigItem = babel.createConfigItem;\n}\n\nif (USE_ESM) {\n  exports.init = import(\"@babel/core\").then(initialize);\n} else {\n  initialize(require(\"@babel/core\"));\n}\n"],"mappings":"AAAA,SAASA,UAAUA,CAACC,KAAK,EAAE;EACzBC,OAAO,CAACC,IAAI,GAAG,IAAI;EACnBD,OAAO,CAACE,OAAO,GAAGH,KAAK,CAACG,OAAO;EAC/BF,OAAO,CAACG,QAAQ,GAAGJ,KAAK,CAACI,QAAQ;EACjCH,OAAO,CAACI,KAAK,GAAGL,KAAK,CAACK,KAAK;EAC3BJ,OAAO,CAACK,QAAQ,GAAGN,KAAK,CAACM,QAAQ;EACjCL,OAAO,CAACM,SAAS,GAAGP,KAAK,CAACO,SAAS;EACnCN,OAAO,CAACO,qBAAqB,GAAGR,KAAK,CAACQ,qBAAqB;EAC3DP,OAAO,CAACQ,sBAAsB,GAAGT,KAAK,CAACS,sBAAsB;EAC7DR,OAAO,CAACS,gBAAgB,GAAGV,KAAK,CAACU,gBAAgB;AACnD;AAIO;EACLX,UAAU,CAACY,OAAO,CAAC,aAAa,CAAC,CAAC;AACpC"}

node_modules/@babel/eslint-parser/lib/worker/configuration.cjs

@@ -0,0 +1,78 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+const babel = require("./babel-core.cjs");
+const ESLINT_VERSION = require("../utils/eslint-version.cjs");
+function getParserPlugins(babelOptions) {
+  var _babelOptions$parserO, _babelOptions$parserO2;
+  const babelParserPlugins = (_babelOptions$parserO = (_babelOptions$parserO2 = babelOptions.parserOpts) == null ? void 0 : _babelOptions$parserO2.plugins) != null ? _babelOptions$parserO : [];
+  const estreeOptions = {
+    classFeatures: ESLINT_VERSION >= 8
+  };
+  for (const plugin of babelParserPlugins) {
+    if (Array.isArray(plugin) && plugin[0] === "estree") {
+      Object.assign(estreeOptions, plugin[1]);
+      break;
+    }
+  }
+  return [["estree", estreeOptions], ...babelParserPlugins];
+}
+function normalizeParserOptions(options) {
+  var _options$allowImportE, _options$ecmaFeatures, _options$ecmaFeatures2;
+  return Object.assign({
+    sourceType: options.sourceType,
+    filename: options.filePath
+  }, options.babelOptions, {
+    parserOpts: Object.assign({}, {
+      allowImportExportEverywhere: (_options$allowImportE = options.allowImportExportEverywhere) != null ? _options$allowImportE : false,
+      allowSuperOutsideMethod: true
+    }, {
+      allowReturnOutsideFunction: (_options$ecmaFeatures = (_options$ecmaFeatures2 = options.ecmaFeatures) == null ? void 0 : _options$ecmaFeatures2.globalReturn) != null ? _options$ecmaFeatures : true
+    }, options.babelOptions.parserOpts, {
+      plugins: getParserPlugins(options.babelOptions),
+      attachComment: false,
+      ranges: true,
+      tokens: true
+    }),
+    caller: Object.assign({
+      name: "@babel/eslint-parser"
+    }, options.babelOptions.caller)
+  });
+}
+function validateResolvedConfig(config, options, parseOptions) {
+  if (config !== null) {
+    if (options.requireConfigFile !== false) {
+      if (!config.hasFilesystemConfig()) {
+        let error = `No Babel config file detected for ${config.options.filename}. Either disable config file checking with requireConfigFile: false, or configure Babel so that it can find the config files.`;
+        if (config.options.filename.includes("node_modules")) {
+          error += `\nIf you have a .babelrc.js file or use package.json#babel, keep in mind that it's not used when parsing dependencies. If you want your config to be applied to your whole app, consider using babel.config.js or babel.config.json instead.`;
+        }
+        throw new Error(error);
+      }
+    }
+    if (config.options) return config.options;
+  }
+  return getDefaultParserOptions(parseOptions);
+}
+function getDefaultParserOptions(options) {
+  return Object.assign({
+    plugins: []
+  }, options, {
+    babelrc: false,
+    configFile: false,
+    browserslistConfigFile: false,
+    ignore: null,
+    only: null
+  });
+}
+exports.normalizeBabelParseConfig = _asyncToGenerator(function* (options) {
+  const parseOptions = normalizeParserOptions(options);
+  const config = yield babel.loadPartialConfigAsync(parseOptions);
+  return validateResolvedConfig(config, options, parseOptions);
+});
+exports.normalizeBabelParseConfigSync = function (options) {
+  const parseOptions = normalizeParserOptions(options);
+  const config = babel.loadPartialConfigSync(parseOptions);
+  return validateResolvedConfig(config, options, parseOptions);
+};
+
+//# sourceMappingURL=configuration.cjs.map

node_modules/@babel/eslint-parser/lib/worker/extract-parser-options-plugin.cjs

@@ -0,0 +1,9 @@
+module.exports = function extractParserOptionsPlugin() {
+  return {
+    parserOverride(code, opts) {
+      return opts;
+    }
+  };
+};
+
+//# sourceMappingURL=extract-parser-options-plugin.cjs.map

node_modules/@babel/eslint-parser/lib/worker/extract-parser-options-plugin.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["module","exports","extractParserOptionsPlugin","parserOverride","code","opts"],"sources":["../../src/worker/extract-parser-options-plugin.cjs"],"sourcesContent":["module.exports = function extractParserOptionsPlugin() {\n  return {\n    parserOverride(code, opts) {\n      return opts;\n    },\n  };\n};\n"],"mappings":"AAAAA,MAAM,CAACC,OAAO,GAAG,SAASC,0BAA0BA,CAAA,EAAG;EACrD,OAAO;IACLC,cAAcA,CAACC,IAAI,EAAEC,IAAI,EAAE;MACzB,OAAOA,IAAI;IACb;EACF,CAAC;AACH,CAAC"}

node_modules/@babel/eslint-parser/lib/worker/handle-message.cjs

@@ -0,0 +1,34 @@
+const babel = require("./babel-core.cjs");
+const maybeParse = require("./maybeParse.cjs");
+const {
+  getVisitorKeys,
+  getTokLabels
+} = require("./ast-info.cjs");
+const {
+  normalizeBabelParseConfig,
+  normalizeBabelParseConfigSync
+} = require("./configuration.cjs");
+module.exports = function handleMessage(action, payload) {
+  switch (action) {
+    case "GET_VERSION":
+      return babel.version;
+    case "GET_TYPES_INFO":
+      return {
+        FLOW_FLIPPED_ALIAS_KEYS: babel.types.FLIPPED_ALIAS_KEYS.Flow,
+        VISITOR_KEYS: babel.types.VISITOR_KEYS
+      };
+    case "GET_TOKEN_LABELS":
+      return getTokLabels();
+    case "GET_VISITOR_KEYS":
+      return getVisitorKeys();
+    case "MAYBE_PARSE":
+      return normalizeBabelParseConfig(payload.options).then(options => maybeParse(payload.code, options));
+    case "MAYBE_PARSE_SYNC":
+      {
+        return maybeParse(payload.code, normalizeBabelParseConfigSync(payload.options));
+      }
+  }
+  throw new Error(`Unknown internal parser worker action: ${action}`);
+};
+
+//# sourceMappingURL=handle-message.cjs.map

node_modules/@babel/eslint-parser/lib/worker/handle-message.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["babel","require","maybeParse","getVisitorKeys","getTokLabels","normalizeBabelParseConfig","normalizeBabelParseConfigSync","module","exports","handleMessage","action","payload","version","FLOW_FLIPPED_ALIAS_KEYS","types","FLIPPED_ALIAS_KEYS","Flow","VISITOR_KEYS","options","then","code","Error"],"sources":["../../src/worker/handle-message.cjs"],"sourcesContent":["const babel = require(\"./babel-core.cjs\");\nconst maybeParse = require(\"./maybeParse.cjs\");\nconst { getVisitorKeys, getTokLabels } = require(\"./ast-info.cjs\");\nconst {\n  normalizeBabelParseConfig,\n  normalizeBabelParseConfigSync,\n} = require(\"./configuration.cjs\");\n\nmodule.exports = function handleMessage(action, payload) {\n  switch (action) {\n    case \"GET_VERSION\":\n      return babel.version;\n    case \"GET_TYPES_INFO\":\n      return {\n        FLOW_FLIPPED_ALIAS_KEYS: babel.types.FLIPPED_ALIAS_KEYS.Flow,\n        VISITOR_KEYS: babel.types.VISITOR_KEYS,\n      };\n    case \"GET_TOKEN_LABELS\":\n      return getTokLabels();\n    case \"GET_VISITOR_KEYS\":\n      return getVisitorKeys();\n    case \"MAYBE_PARSE\":\n      return normalizeBabelParseConfig(payload.options).then(options =>\n        maybeParse(payload.code, options),\n      );\n    case \"MAYBE_PARSE_SYNC\":\n      if (!USE_ESM) {\n        return maybeParse(\n          payload.code,\n          normalizeBabelParseConfigSync(payload.options),\n        );\n      }\n  }\n\n  throw new Error(`Unknown internal parser worker action: ${action}`);\n};\n"],"mappings":"AAAA,MAAMA,KAAK,GAAGC,OAAO,CAAC,kBAAkB,CAAC;AACzC,MAAMC,UAAU,GAAGD,OAAO,CAAC,kBAAkB,CAAC;AAC9C,MAAM;EAAEE,cAAc;EAAEC;AAAa,CAAC,GAAGH,OAAO,CAAC,gBAAgB,CAAC;AAClE,MAAM;EACJI,yBAAyB;EACzBC;AACF,CAAC,GAAGL,OAAO,CAAC,qBAAqB,CAAC;AAElCM,MAAM,CAACC,OAAO,GAAG,SAASC,aAAaA,CAACC,MAAM,EAAEC,OAAO,EAAE;EACvD,QAAQD,MAAM;IACZ,KAAK,aAAa;MAChB,OAAOV,KAAK,CAACY,OAAO;IACtB,KAAK,gBAAgB;MACnB,OAAO;QACLC,uBAAuB,EAAEb,KAAK,CAACc,KAAK,CAACC,kBAAkB,CAACC,IAAI;QAC5DC,YAAY,EAAEjB,KAAK,CAACc,KAAK,CAACG;MAC5B,CAAC;IACH,KAAK,kBAAkB;MACrB,OAAOb,YAAY,CAAC,CAAC;IACvB,KAAK,kBAAkB;MACrB,OAAOD,cAAc,CAAC,CAAC;IACzB,KAAK,aAAa;MAChB,OAAOE,yBAAyB,CAACM,OAAO,CAACO,OAAO,CAAC,CAACC,IAAI,CAACD,OAAO,IAC5DhB,UAAU,CAACS,OAAO,CAACS,IAAI,EAAEF,OAAO,CAClC,CAAC;IACH,KAAK,kBAAkB;MACP;QACZ,OAAOhB,UAAU,CACfS,OAAO,CAACS,IAAI,EACZd,6BAA6B,CAACK,OAAO,CAACO,OAAO,CAC/C,CAAC;MACH;EACJ;EAEA,MAAM,IAAIG,KAAK,CAAE,0CAAyCX,MAAO,EAAC,CAAC;AACrE,CAAC"}

node_modules/@babel/eslint-parser/lib/worker/index.cjs

@@ -0,0 +1,39 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+const babel = require("./babel-core.cjs");
+const handleMessage = require("./handle-message.cjs");
+const {
+  parentPort
+} = require("worker_threads");
+parentPort.addListener("message", _asyncToGenerator(function* ({
+  signal,
+  port,
+  action,
+  payload
+}) {
+  let response;
+  try {
+    if (babel.init) yield babel.init;
+    response = {
+      result: yield handleMessage(action, payload)
+    };
+  } catch (error) {
+    response = {
+      error,
+      errorData: Object.assign({}, error)
+    };
+  }
+  try {
+    port.postMessage(response);
+  } catch (_unused) {
+    port.postMessage({
+      error: new Error("Cannot serialize worker response")
+    });
+  } finally {
+    port.close();
+    Atomics.store(signal, 0, 1);
+    Atomics.notify(signal, 0);
+  }
+}));
+
+//# sourceMappingURL=index.cjs.map

node_modules/@babel/eslint-parser/lib/worker/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["babel","require","handleMessage","parentPort","addListener","_asyncToGenerator","signal","port","action","payload","response","init","result","error","errorData","Object","assign","postMessage","_unused","Error","close","Atomics","store","notify"],"sources":["../../src/worker/index.cjs"],"sourcesContent":["const babel = require(\"./babel-core.cjs\");\nconst handleMessage = require(\"./handle-message.cjs\");\n\nconst { parentPort } = require(\"worker_threads\");\n\nparentPort.addListener(\"message\", async ({ signal, port, action, payload }) => {\n  let response;\n\n  try {\n    if (babel.init) await babel.init;\n\n    response = { result: await handleMessage(action, payload) };\n  } catch (error) {\n    response = { error, errorData: { ...error } };\n  }\n\n  try {\n    port.postMessage(response);\n  } catch {\n    port.postMessage({\n      error: new Error(\"Cannot serialize worker response\"),\n    });\n  } finally {\n    port.close();\n    Atomics.store(signal, 0, 1);\n    Atomics.notify(signal, 0);\n  }\n});\n"],"mappings":";;AAAA,MAAMA,KAAK,GAAGC,OAAO,CAAC,kBAAkB,CAAC;AACzC,MAAMC,aAAa,GAAGD,OAAO,CAAC,sBAAsB,CAAC;AAErD,MAAM;EAAEE;AAAW,CAAC,GAAGF,OAAO,CAAC,gBAAgB,CAAC;AAEhDE,UAAU,CAACC,WAAW,CAAC,SAAS,EAAAC,iBAAA,CAAE,WAAO;EAAEC,MAAM;EAAEC,IAAI;EAAEC,MAAM;EAAEC;AAAQ,CAAC,EAAK;EAC7E,IAAIC,QAAQ;EAEZ,IAAI;IACF,IAAIV,KAAK,CAACW,IAAI,EAAE,MAAMX,KAAK,CAACW,IAAI;IAEhCD,QAAQ,GAAG;MAAEE,MAAM,QAAQV,aAAa,CAACM,MAAM,EAAEC,OAAO;IAAE,CAAC;EAC7D,CAAC,CAAC,OAAOI,KAAK,EAAE;IACdH,QAAQ,GAAG;MAAEG,KAAK;MAAEC,SAAS,EAAAC,MAAA,CAAAC,MAAA,KAAOH,KAAK;IAAG,CAAC;EAC/C;EAEA,IAAI;IACFN,IAAI,CAACU,WAAW,CAACP,QAAQ,CAAC;EAC5B,CAAC,CAAC,OAAAQ,OAAA,EAAM;IACNX,IAAI,CAACU,WAAW,CAAC;MACfJ,KAAK,EAAE,IAAIM,KAAK,CAAC,kCAAkC;IACrD,CAAC,CAAC;EACJ,CAAC,SAAS;IACRZ,IAAI,CAACa,KAAK,CAAC,CAAC;IACZC,OAAO,CAACC,KAAK,CAAChB,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;IAC3Be,OAAO,CAACE,MAAM,CAACjB,MAAM,EAAE,CAAC,CAAC;EAC3B;AACF,CAAC,EAAC"}

node_modules/@babel/eslint-parser/lib/worker/maybeParse.cjs

@@ -0,0 +1,45 @@
+const babel = require("./babel-core.cjs");
+const convert = require("../convert/index.cjs");
+const {
+  getVisitorKeys,
+  getTokLabels
+} = require("./ast-info.cjs");
+const extractParserOptionsPlugin = require("./extract-parser-options-plugin.cjs");
+const ref = {};
+let extractParserOptionsConfigItem;
+const MULTIPLE_OVERRIDES = /More than one plugin attempted to override parsing/;
+module.exports = function maybeParse(code, options) {
+  if (!extractParserOptionsConfigItem) {
+    extractParserOptionsConfigItem = babel.createConfigItem([extractParserOptionsPlugin, ref], {
+      dirname: __dirname,
+      type: "plugin"
+    });
+  }
+  const {
+    plugins
+  } = options;
+  options.plugins = plugins.concat(extractParserOptionsConfigItem);
+  try {
+    return {
+      parserOptions: babel.parseSync(code, options),
+      ast: null
+    };
+  } catch (err) {
+    if (!MULTIPLE_OVERRIDES.test(err.message)) {
+      throw err;
+    }
+  }
+  options.plugins = plugins;
+  let ast;
+  try {
+    ast = babel.parseSync(code, options);
+  } catch (err) {
+    throw convert.error(err);
+  }
+  return {
+    ast: convert.ast(ast, code, getTokLabels(), getVisitorKeys()),
+    parserOptions: null
+  };
+};
+
+//# sourceMappingURL=maybeParse.cjs.map

node_modules/@babel/eslint-parser/lib/worker/maybeParse.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["babel","require","convert","getVisitorKeys","getTokLabels","extractParserOptionsPlugin","ref","extractParserOptionsConfigItem","MULTIPLE_OVERRIDES","module","exports","maybeParse","code","options","createConfigItem","dirname","__dirname","type","plugins","concat","parserOptions","parseSync","ast","err","test","message","error"],"sources":["../../src/worker/maybeParse.cjs"],"sourcesContent":["const babel = require(\"./babel-core.cjs\");\nconst convert = require(\"../convert/index.cjs\");\nconst { getVisitorKeys, getTokLabels } = require(\"./ast-info.cjs\");\nconst extractParserOptionsPlugin = require(\"./extract-parser-options-plugin.cjs\");\n\nconst ref = {};\nlet extractParserOptionsConfigItem;\n\nconst MULTIPLE_OVERRIDES = /More than one plugin attempted to override parsing/;\n\nmodule.exports = function maybeParse(code, options) {\n  if (!extractParserOptionsConfigItem) {\n    extractParserOptionsConfigItem = babel.createConfigItem(\n      [extractParserOptionsPlugin, ref],\n      { dirname: __dirname, type: \"plugin\" },\n    );\n  }\n  const { plugins } = options;\n  options.plugins = plugins.concat(extractParserOptionsConfigItem);\n\n  try {\n    return {\n      parserOptions: babel.parseSync(code, options),\n      ast: null,\n    };\n  } catch (err) {\n    if (!MULTIPLE_OVERRIDES.test(err.message)) {\n      throw err;\n    }\n  }\n\n  // There was already a parserOverride, so remove our plugin.\n  options.plugins = plugins;\n\n  let ast;\n  try {\n    ast = babel.parseSync(code, options);\n  } catch (err) {\n    throw convert.error(err);\n  }\n\n  return {\n    ast: convert.ast(ast, code, getTokLabels(), getVisitorKeys()),\n    parserOptions: null,\n  };\n};\n"],"mappings":"AAAA,MAAMA,KAAK,GAAGC,OAAO,CAAC,kBAAkB,CAAC;AACzC,MAAMC,OAAO,GAAGD,OAAO,CAAC,sBAAsB,CAAC;AAC/C,MAAM;EAAEE,cAAc;EAAEC;AAAa,CAAC,GAAGH,OAAO,CAAC,gBAAgB,CAAC;AAClE,MAAMI,0BAA0B,GAAGJ,OAAO,CAAC,qCAAqC,CAAC;AAEjF,MAAMK,GAAG,GAAG,CAAC,CAAC;AACd,IAAIC,8BAA8B;AAElC,MAAMC,kBAAkB,GAAG,oDAAoD;AAE/EC,MAAM,CAACC,OAAO,GAAG,SAASC,UAAUA,CAACC,IAAI,EAAEC,OAAO,EAAE;EAClD,IAAI,CAACN,8BAA8B,EAAE;IACnCA,8BAA8B,GAAGP,KAAK,CAACc,gBAAgB,CACrD,CAACT,0BAA0B,EAAEC,GAAG,CAAC,EACjC;MAAES,OAAO,EAAEC,SAAS;MAAEC,IAAI,EAAE;IAAS,CACvC,CAAC;EACH;EACA,MAAM;IAAEC;EAAQ,CAAC,GAAGL,OAAO;EAC3BA,OAAO,CAACK,OAAO,GAAGA,OAAO,CAACC,MAAM,CAACZ,8BAA8B,CAAC;EAEhE,IAAI;IACF,OAAO;MACLa,aAAa,EAAEpB,KAAK,CAACqB,SAAS,CAACT,IAAI,EAAEC,OAAO,CAAC;MAC7CS,GAAG,EAAE;IACP,CAAC;EACH,CAAC,CAAC,OAAOC,GAAG,EAAE;IACZ,IAAI,CAACf,kBAAkB,CAACgB,IAAI,CAACD,GAAG,CAACE,OAAO,CAAC,EAAE;MACzC,MAAMF,GAAG;IACX;EACF;EAGAV,OAAO,CAACK,OAAO,GAAGA,OAAO;EAEzB,IAAII,GAAG;EACP,IAAI;IACFA,GAAG,GAAGtB,KAAK,CAACqB,SAAS,CAACT,IAAI,EAAEC,OAAO,CAAC;EACtC,CAAC,CAAC,OAAOU,GAAG,EAAE;IACZ,MAAMrB,OAAO,CAACwB,KAAK,CAACH,GAAG,CAAC;EAC1B;EAEA,OAAO;IACLD,GAAG,EAAEpB,OAAO,CAACoB,GAAG,CAACA,GAAG,EAAEV,IAAI,EAAER,YAAY,CAAC,CAAC,EAAED,cAAc,CAAC,CAAC,CAAC;IAC7DiB,aAAa,EAAE;EACjB,CAAC;AACH,CAAC"}

node_modules/@babel/eslint-parser/node_modules/.bin/eslint

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../../../../eslint/bin/eslint.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/../../../../eslint/bin/eslint.js" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/@babel/eslint-parser/node_modules/.bin/eslint.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\..\..\..\eslint\bin\eslint.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\..\..\..\eslint\bin\eslint.js" %*
+)

node_modules/@babel/eslint-parser/node_modules/.bin/semver

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../../../../semver/bin/semver.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/../../../../semver/bin/semver.js" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/@babel/eslint-parser/node_modules/.bin/semver.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\..\..\..\semver\bin\semver.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\..\..\..\semver\bin\semver.js" %*
+)

node_modules/@babel/eslint-parser/package.json

@@ -0,0 +1,72 @@
+{
+  "_from": "@babel/eslint-parser@7.22.10",
+  "_id": "@babel/eslint-parser@7.22.10",
+  "_inBundle": false,
+  "_integrity": "sha512-0J8DNPRXQRLeR9rPaUMM3fA+RbixjnVLe/MRMYCkp3hzgsSuxCHQ8NN8xQG1wIHKJ4a1DTROTvFJdW+B5/eOsg==",
+  "_location": "/@babel/eslint-parser",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "@babel/eslint-parser@7.22.10",
+    "name": "@babel/eslint-parser",
+    "escapedName": "@babel%2feslint-parser",
+    "scope": "@babel",
+    "rawSpec": "7.22.10",
+    "saveSpec": null,
+    "fetchSpec": "7.22.10"
+  },
+  "_requiredBy": [
+    "#DEV:/"
+  ],
+  "_resolved": "https://registry.npmjs.org/@babel/eslint-parser/-/eslint-parser-7.22.10.tgz",
+  "_shasum": "bfdf3d1b32ad573fe7c1c3447e0b485e3a41fd09",
+  "_spec": "@babel/eslint-parser@7.22.10",
+  "_where": "C:\\Users\\zhouxueli\\Desktop\\scheduling-app",
+  "author": {
+    "name": "The Babel Team",
+    "url": "https://babel.dev/team"
+  },
+  "bugs": {
+    "url": "https://github.com/babel/babel/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "@nicolo-ribaudo/eslint-scope-5-internals": "5.1.1-v1",
+    "eslint-visitor-keys": "^2.1.0",
+    "semver": "^6.3.1"
+  },
+  "deprecated": false,
+  "description": "ESLint parser that allows for linting of experimental syntax transformed by Babel",
+  "devDependencies": {
+    "@babel/core": "^7.22.10",
+    "dedent": "^0.7.0",
+    "eslint": "^8.22.0"
+  },
+  "engines": {
+    "node": "^10.13.0 || ^12.13.0 || >=14.0.0"
+  },
+  "exports": {
+    ".": "./lib/index.cjs",
+    "./experimental-worker": "./lib/experimental-worker.cjs",
+    "./package.json": "./package.json"
+  },
+  "homepage": "https://babel.dev/",
+  "license": "MIT",
+  "main": "./lib/index.cjs",
+  "name": "@babel/eslint-parser",
+  "peerDependencies": {
+    "@babel/core": "^7.11.0",
+    "eslint": "^7.5.0 || ^8.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/babel/babel.git",
+    "directory": "eslint/babel-eslint-parser"
+  },
+  "type": "commonjs",
+  "version": "7.22.10"
+}