MLAB-677: Update modules

24e3ee4b · Rosanny Sihombing · 60ea96ad · 60ea96ad · 60ea96ad · 60ea96ad
Commit 24e3ee4b authored 2 years ago by Rosanny Sihombing
Hide whitespace changes
Inline Side-by-side

Showing

with 130 additions and 473 deletions
+130 -473
--- a/node_modules/.bin/rimraf.ps1
+++ b/node_modules/.bin/rimraf.ps1
-#!/usr/bin/env pwsh
-$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
-
-$exe=""
-if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
-  # Fix case when both the Windows and Linux builds of Node
-  # are installed in the same directory
-  $exe=".exe"
-}
-$ret=0
-if (Test-Path "$basedir/node$exe") {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "$basedir/node$exe"  "$basedir/../rimraf/bin.js" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../rimraf/bin.js" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../rimraf/bin.js" $args
-  } else {
-    & "node$exe"  "$basedir/../rimraf/bin.js" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret
--- a/node_modules/@babel/highlight/LICENSE
+++ b/node_modules/@babel/highlight/LICENSE
-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.
--- a/node_modules/@babel/highlight/README.md
+++ b/node_modules/@babel/highlight/README.md
-# @babel/highlight
-
-> Syntax highlight JavaScript strings for output in terminals.
-
-See our website [@babel/highlight](https://babeljs.io/docs/en/babel-highlight) for more information.
-
-## Install
-
-Using npm:
-
-```sh
-npm install --save-dev @babel/highlight
-```
-
-or using yarn:
-
-```sh
-yarn add @babel/highlight --dev
-```
--- a/node_modules/@babel/highlight/lib/index.js
+++ b/node_modules/@babel/highlight/lib/index.js
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = highlight;
-exports.getChalk = getChalk;
-exports.shouldHighlight = shouldHighlight;
-
-var _jsTokens = require("js-tokens");
-
-var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
-
-var _chalk = require("chalk");
-
-const sometimesKeywords = new Set(["as", "async", "from", "get", "of", "set"]);
-
-function getDefs(chalk) {
-  return {
-    keyword: chalk.cyan,
-    capitalized: chalk.yellow,
-    jsxIdentifier: chalk.yellow,
-    punctuator: chalk.yellow,
-    number: chalk.magenta,
-    string: chalk.green,
-    regex: chalk.magenta,
-    comment: chalk.grey,
-    invalid: chalk.white.bgRed.bold
-  };
-}
-
-const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
-const BRACKET = /^[()[\]{}]$/;
-let tokenize;
-{
-  const JSX_TAG = /^[a-z][\w-]*$/i;
-
-  const getTokenType = function (token, offset, text) {
-    if (token.type === "name") {
-      if ((0, _helperValidatorIdentifier.isKeyword)(token.value) || (0, _helperValidatorIdentifier.isStrictReservedWord)(token.value, true) || sometimesKeywords.has(token.value)) {
-        return "keyword";
-      }
-
-      if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) == "</")) {
-        return "jsxIdentifier";
-      }
-
-      if (token.value[0] !== token.value[0].toLowerCase()) {
-        return "capitalized";
-      }
-    }
-
-    if (token.type === "punctuator" && BRACKET.test(token.value)) {
-      return "bracket";
-    }
-
-    if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
-      return "punctuator";
-    }
-
-    return token.type;
-  };
-
-  tokenize = function* (text) {
-    let match;
-
-    while (match = _jsTokens.default.exec(text)) {
-      const token = _jsTokens.matchToToken(match);
-
-      yield {
-        type: getTokenType(token, match.index, text),
-        value: token.value
-      };
-    }
-  };
-}
-
-function highlightTokens(defs, text) {
-  let highlighted = "";
-
-  for (const {
-    type,
-    value
-  } of tokenize(text)) {
-    const colorize = defs[type];
-
-    if (colorize) {
-      highlighted += value.split(NEWLINE).map(str => colorize(str)).join("\n");
-    } else {
-      highlighted += value;
-    }
-  }
-
-  return highlighted;
-}
-
-function shouldHighlight(options) {
-  return !!_chalk.supportsColor || options.forceColor;
-}
-
-function getChalk(options) {
-  return options.forceColor ? new _chalk.constructor({
-    enabled: true,
-    level: 1
-  }) : _chalk;
-}
-
-function highlight(code, options = {}) {
-  if (code !== "" && shouldHighlight(options)) {
-    const chalk = getChalk(options);
-    const defs = getDefs(chalk);
-    return highlightTokens(defs, code);
-  } else {
-    return code;
-  }
-}
\ No newline at end of file
--- a/node_modules/@babel/highlight/package.json
+++ b/node_modules/@babel/highlight/package.json
-{
-  "name": "@babel/highlight",
-  "version": "7.18.6",
-  "description": "Syntax highlight JavaScript strings for output in terminals.",
-  "author": "The Babel Team (https://babel.dev/team)",
-  "homepage": "https://babel.dev/docs/en/next/babel-highlight",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/babel/babel.git",
-    "directory": "packages/babel-highlight"
-  },
-  "main": "./lib/index.js",
-  "dependencies": {
-    "@babel/helper-validator-identifier": "^7.18.6",
-    "chalk": "^2.0.0",
-    "js-tokens": "^4.0.0"
-  },
-  "devDependencies": {
-    "@types/chalk": "^2.0.0",
-    "strip-ansi": "^4.0.0"
-  },
-  "engines": {
-    "node": ">=6.9.0"
-  },
-  "type": "commonjs"
-}
\ No newline at end of file
--- a/node_modules/@babel/parser/lib/index.js
+++ b/node_modules/@babel/parser/lib/index.js
@@ -14840,7 +14840,7 @@ class StatementParser extends ExpressionParser {
  }

  parseDecorator() {
-    this.expectOnePlugin(["decorators", "decorators-legacy"]);
+    this.expectOnePlugin(["decorators-legacy", "decorators"]);
    const node = this.startNode();
    this.next();


--- a/node_modules/@babel/parser/lib/index.js.map
+++ b/node_modules/@babel/parser/lib/index.js.map
--- a/node_modules/@babel/parser/package.json
+++ b/node_modules/@babel/parser/package.json
 {
  "name": "@babel/parser",
-  "version": "7.18.8",
+  "version": "7.18.6",
  "description": "A JavaScript parser",
  "author": "The Babel Team (https://babel.dev/team)",
  "homepage": "https://babel.dev/docs/en/next/babel-parser",

--- a/node_modules/@babel/types/lib/builders/generated/index.js
+++ b/node_modules/@babel/types/lib/builders/generated/index.js
@@ -939,7 +939,7 @@ function classAccessorProperty(key, value = null, typeAnnotation = null, decorat
  });
 }

-function classPrivateProperty(key, value = null, decorators = null, _static = false) {
+function classPrivateProperty(key, value = null, decorators = null, _static) {
  return (0, _validateNode.default)({
    type: "ClassPrivateProperty",
    key,

--- a/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js
+++ b/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js
@@ -9,12 +9,8 @@ var _generated = require("../generated");

 var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates");

-var _index = require("../../validators/generated/index");
-
 function createTSUnionType(typeAnnotations) {
-  const types = typeAnnotations.map(type => {
-    return (0, _index.isTSTypeAnnotation)(type) ? type.typeAnnotation : type;
-  });
+  const types = typeAnnotations.map(type => type.typeAnnotation);
  const flattened = (0, _removeTypeDuplicates.default)(types);

  if (flattened.length === 1) {

--- a/node_modules/@babel/types/lib/definitions/core.js
+++ b/node_modules/@babel/types/lib/definitions/core.js
@@ -278,8 +278,7 @@ defineType("ForStatement", {
    }
  }
 });
-
-const functionCommon = () => ({
+const functionCommon = {
  params: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement")))
  },
@@ -289,11 +288,9 @@ const functionCommon = () => ({
  async: {
    default: false
  }
-});
-
+};
 exports.functionCommon = functionCommon;
-
-const functionTypeAnnotationCommon = () => ({
+const functionTypeAnnotationCommon = {
  returnType: {
    validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
    optional: true
@@ -302,11 +299,9 @@ const functionTypeAnnotationCommon = () => ({
    validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
    optional: true
  }
-});
-
+};
 exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon;
-
-const functionDeclarationCommon = () => Object.assign({}, functionCommon(), {
+const functionDeclarationCommon = Object.assign({}, functionCommon, {
  declare: {
    validate: (0, _utils.assertValueType)("boolean"),
    optional: true
@@ -316,12 +311,11 @@ const functionDeclarationCommon = () => Object.assign({}, functionCommon(), {
    optional: true
  }
 });
-
 exports.functionDeclarationCommon = functionDeclarationCommon;
 defineType("FunctionDeclaration", {
  builder: ["id", "params", "body", "generator", "async"],
  visitor: ["id", "params", "body", "returnType", "typeParameters"],
-  fields: Object.assign({}, functionDeclarationCommon(), functionTypeAnnotationCommon(), {
+  fields: Object.assign({}, functionDeclarationCommon, functionTypeAnnotationCommon, {
    body: {
      validate: (0, _utils.assertNodeType)("BlockStatement")
    },
@@ -344,7 +338,7 @@ defineType("FunctionDeclaration", {
 defineType("FunctionExpression", {
  inherits: "FunctionDeclaration",
  aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
-  fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {
+  fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
    id: {
      validate: (0, _utils.assertNodeType)("Identifier"),
      optional: true
@@ -358,24 +352,21 @@ defineType("FunctionExpression", {
    }
  })
 });
-
-const patternLikeCommon = () => ({
+const patternLikeCommon = {
  typeAnnotation: {
    validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
    optional: true
  },
  decorators: {
-    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
-    optional: true
+    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
  }
-});
-
+};
 exports.patternLikeCommon = patternLikeCommon;
 defineType("Identifier", {
  builder: ["name"],
  visitor: ["typeAnnotation", "decorators"],
  aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"],
-  fields: Object.assign({}, patternLikeCommon(), {
+  fields: Object.assign({}, patternLikeCommon, {
    name: {
      validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) {
        if (!process.env.BABEL_TYPES_8_BREAKING) return;
@@ -596,7 +587,7 @@ defineType("ObjectExpression", {
 });
 defineType("ObjectMethod", {
  builder: ["kind", "key", "params", "body", "computed", "generator", "async"],
-  fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {
+  fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
    kind: Object.assign({
      validate: (0, _utils.assertOneOf)("method", "get", "set")
    }, !process.env.BABEL_TYPES_8_BREAKING ? {
@@ -607,7 +598,7 @@ defineType("ObjectMethod", {
    },
    key: {
      validate: function () {
-        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral");
+        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
        const computed = (0, _utils.assertNodeType)("Expression");

        const validator = function (node, key, val) {
@@ -615,7 +606,7 @@ defineType("ObjectMethod", {
          validator(node, key, val);
        };

-        validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"];
+        validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral"];
        return validator;
      }()
    },
@@ -692,7 +683,7 @@ defineType("RestElement", {
  builder: ["argument"],
  aliases: ["LVal", "PatternLike"],
  deprecatedAlias: "RestProperty",
-  fields: Object.assign({}, patternLikeCommon(), {
+  fields: Object.assign({}, patternLikeCommon, {
    argument: {
      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression")
    },
@@ -919,7 +910,7 @@ defineType("AssignmentPattern", {
  visitor: ["left", "right", "decorators"],
  builder: ["left", "right"],
  aliases: ["Pattern", "PatternLike", "LVal"],
-  fields: Object.assign({}, patternLikeCommon(), {
+  fields: Object.assign({}, patternLikeCommon, {
    left: {
      validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression")
    },
@@ -936,7 +927,7 @@ defineType("ArrayPattern", {
  visitor: ["elements", "typeAnnotation"],
  builder: ["elements"],
  aliases: ["Pattern", "PatternLike", "LVal"],
-  fields: Object.assign({}, patternLikeCommon(), {
+  fields: Object.assign({}, patternLikeCommon, {
    elements: {
      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "PatternLike")))
    },
@@ -954,7 +945,7 @@ defineType("ArrowFunctionExpression", {
  builder: ["params", "body", "async"],
  visitor: ["params", "body", "returnType", "typeParameters"],
  aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
-  fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {
+  fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
    expression: {
      validate: (0, _utils.assertValueType)("boolean")
    },
@@ -1276,8 +1267,7 @@ defineType("MetaProperty", {
    }
  }
 });
-
-const classMethodOrPropertyCommon = () => ({
+const classMethodOrPropertyCommon = {
  abstract: {
    validate: (0, _utils.assertValueType)("boolean"),
    optional: true
@@ -1307,13 +1297,11 @@ const classMethodOrPropertyCommon = () => ({
        const validator = node.computed ? computed : normal;
        validator(node, key, val);
      };
-    }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression"))
+    }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression"))
  }
-});
-
+};
 exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon;
-
-const classMethodOrDeclareMethodCommon = () => Object.assign({}, functionCommon(), classMethodOrPropertyCommon(), {
+const classMethodOrDeclareMethodCommon = Object.assign({}, functionCommon, classMethodOrPropertyCommon, {
  params: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty")))
  },
@@ -1330,13 +1318,12 @@ const classMethodOrDeclareMethodCommon = () => Object.assign({}, functionCommon(
    optional: true
  }
 });
-
 exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon;
 defineType("ClassMethod", {
  aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
  builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"],
  visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
-  fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), {
+  fields: Object.assign({}, classMethodOrDeclareMethodCommon, functionTypeAnnotationCommon, {
    body: {
      validate: (0, _utils.assertNodeType)("BlockStatement")
    }
@@ -1346,7 +1333,7 @@ defineType("ObjectPattern", {
  visitor: ["properties", "typeAnnotation", "decorators"],
  builder: ["properties"],
  aliases: ["Pattern", "PatternLike", "LVal"],
-  fields: Object.assign({}, patternLikeCommon(), {
+  fields: Object.assign({}, patternLikeCommon, {
    properties: {
      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty")))
    }
@@ -1528,7 +1515,7 @@ defineType("ClassProperty", {
  visitor: ["key", "value", "typeAnnotation", "decorators"],
  builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
  aliases: ["Property"],
-  fields: Object.assign({}, classMethodOrPropertyCommon(), {
+  fields: Object.assign({}, classMethodOrPropertyCommon, {
    value: {
      validate: (0, _utils.assertNodeType)("Expression"),
      optional: true
@@ -1563,16 +1550,16 @@ defineType("ClassAccessorProperty", {
  visitor: ["key", "value", "typeAnnotation", "decorators"],
  builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
  aliases: ["Property", "Accessor"],
-  fields: Object.assign({}, classMethodOrPropertyCommon(), {
+  fields: Object.assign({}, classMethodOrPropertyCommon, {
    key: {
      validate: (0, _utils.chain)(function () {
-        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName");
+        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "PrivateName");
        const computed = (0, _utils.assertNodeType)("Expression");
        return function (node, key, val) {
          const validator = node.computed ? computed : normal;
          validator(node, key, val);
        };
-      }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression", "PrivateName"))
+      }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression", "PrivateName"))
    },
    value: {
      validate: (0, _utils.assertNodeType)("Expression"),
@@ -1624,10 +1611,6 @@ defineType("ClassPrivateProperty", {
      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
      optional: true
    },
-    static: {
-      validate: (0, _utils.assertValueType)("boolean"),
-      default: false
-    },
    readonly: {
      validate: (0, _utils.assertValueType)("boolean"),
      optional: true
@@ -1646,11 +1629,7 @@ defineType("ClassPrivateMethod", {
  builder: ["kind", "key", "params", "body", "static"],
  visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
  aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"],
-  fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), {
-    kind: {
-      validate: (0, _utils.assertOneOf)("get", "set", "method"),
-      default: "method"
-    },
+  fields: Object.assign({}, classMethodOrDeclareMethodCommon, functionTypeAnnotationCommon, {
    key: {
      validate: (0, _utils.assertNodeType)("PrivateName")
    },

--- a/node_modules/@babel/types/lib/definitions/typescript.js
+++ b/node_modules/@babel/types/lib/definitions/typescript.js
@@ -8,8 +8,7 @@ var _is = require("../validators/is");

 const defineType = (0, _utils.defineAliasedType)("TypeScript");
 const bool = (0, _utils.assertValueType)("boolean");
-
-const tSFunctionTypeAnnotationCommon = () => ({
+const tSFunctionTypeAnnotationCommon = {
  returnType: {
    validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"),
    optional: true
@@ -18,8 +17,7 @@ const tSFunctionTypeAnnotationCommon = () => ({
    validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
    optional: true
  }
-});
-
+};
 defineType("TSParameterProperty", {
  aliases: ["LVal"],
  visitor: ["parameter"],
@@ -48,11 +46,11 @@ defineType("TSParameterProperty", {
 defineType("TSDeclareFunction", {
  aliases: ["Statement", "Declaration"],
  visitor: ["id", "typeParameters", "params", "returnType"],
-  fields: Object.assign({}, (0, _core.functionDeclarationCommon)(), tSFunctionTypeAnnotationCommon())
+  fields: Object.assign({}, _core.functionDeclarationCommon, tSFunctionTypeAnnotationCommon)
 });
 defineType("TSDeclareMethod", {
  visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
-  fields: Object.assign({}, (0, _core.classMethodOrDeclareMethodCommon)(), tSFunctionTypeAnnotationCommon())
+  fields: Object.assign({}, _core.classMethodOrDeclareMethodCommon, tSFunctionTypeAnnotationCommon)
 });
 defineType("TSQualifiedName", {
  aliases: ["TSEntityName"],
@@ -62,33 +60,27 @@ defineType("TSQualifiedName", {
    right: (0, _utils.validateType)("Identifier")
  }
 });
-
-const signatureDeclarationCommon = () => ({
+const signatureDeclarationCommon = {
  typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
  ["parameters"]: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]),
  ["typeAnnotation"]: (0, _utils.validateOptionalType)("TSTypeAnnotation")
-});
-
+};
 const callConstructSignatureDeclaration = {
  aliases: ["TSTypeElement"],
  visitor: ["typeParameters", "parameters", "typeAnnotation"],
-  fields: signatureDeclarationCommon()
+  fields: signatureDeclarationCommon
 };
 defineType("TSCallSignatureDeclaration", callConstructSignatureDeclaration);
 defineType("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
-
-const namedTypeElementCommon = () => ({
+const namedTypeElementCommon = {
  key: (0, _utils.validateType)("Expression"),
-  computed: {
-    default: false
-  },
+  computed: (0, _utils.validate)(bool),
  optional: (0, _utils.validateOptional)(bool)
-});
-
+};
 defineType("TSPropertySignature", {
  aliases: ["TSTypeElement"],
  visitor: ["key", "typeAnnotation", "initializer"],
-  fields: Object.assign({}, namedTypeElementCommon(), {
+  fields: Object.assign({}, namedTypeElementCommon, {
    readonly: (0, _utils.validateOptional)(bool),
    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
    initializer: (0, _utils.validateOptionalType)("Expression"),
@@ -100,7 +92,7 @@ defineType("TSPropertySignature", {
 defineType("TSMethodSignature", {
  aliases: ["TSTypeElement"],
  visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
-  fields: Object.assign({}, signatureDeclarationCommon(), namedTypeElementCommon(), {
+  fields: Object.assign({}, signatureDeclarationCommon, namedTypeElementCommon, {
    kind: {
      validate: (0, _utils.assertOneOf)("method", "get", "set")
    }
@@ -136,10 +128,10 @@ const fnOrCtrBase = {
  visitor: ["typeParameters", "parameters", "typeAnnotation"]
 };
 defineType("TSFunctionType", Object.assign({}, fnOrCtrBase, {
-  fields: signatureDeclarationCommon()
+  fields: signatureDeclarationCommon
 }));
 defineType("TSConstructorType", Object.assign({}, fnOrCtrBase, {
-  fields: Object.assign({}, signatureDeclarationCommon(), {
+  fields: Object.assign({}, signatureDeclarationCommon, {
    abstract: (0, _utils.validateOptional)(bool)
  })
 }));

--- a/node_modules/@babel/types/lib/index-legacy.d.ts
+++ b/node_modules/@babel/types/lib/index-legacy.d.ts
@@ -269,7 +269,7 @@ export interface ObjectExpression extends BaseNode {
 export interface ObjectMethod extends BaseNode {
  type: "ObjectMethod";
  kind: "method" | "get" | "set";
-  key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral;
+  key: Expression | Identifier | StringLiteral | NumericLiteral;
  params: Array<Identifier | Pattern | RestElement>;
  body: BlockStatement;
  computed: boolean;
@@ -510,7 +510,7 @@ export interface MetaProperty extends BaseNode {
 export interface ClassMethod extends BaseNode {
  type: "ClassMethod";
  kind: "get" | "set" | "method" | "constructor";
-  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
+  key: Identifier | StringLiteral | NumericLiteral | Expression;
  params: Array<Identifier | Pattern | RestElement | TSParameterProperty>;
  body: BlockStatement;
  computed: boolean;
@@ -606,7 +606,7 @@ export interface OptionalCallExpression extends BaseNode {

 export interface ClassProperty extends BaseNode {
  type: "ClassProperty";
-  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
+  key: Identifier | StringLiteral | NumericLiteral | Expression;
  value: Expression | null;
  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
  decorators: Array<Decorator> | null;
@@ -624,7 +624,7 @@ export interface ClassProperty extends BaseNode {

 export interface ClassAccessorProperty extends BaseNode {
  type: "ClassAccessorProperty";
-  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName;
+  key: Identifier | StringLiteral | NumericLiteral | Expression | PrivateName;
  value: Expression | null;
  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
  decorators: Array<Decorator> | null;
@@ -645,7 +645,7 @@ export interface ClassPrivateProperty extends BaseNode {
  key: PrivateName;
  value: Expression | null;
  decorators: Array<Decorator> | null;
-  static: boolean;
+  static: any;
  definite: boolean | null;
  readonly: boolean | null;
  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
@@ -654,7 +654,7 @@ export interface ClassPrivateProperty extends BaseNode {

 export interface ClassPrivateMethod extends BaseNode {
  type: "ClassPrivateMethod";
-  kind: "get" | "set" | "method";
+  kind: "get" | "set" | "method" | "constructor";
  key: PrivateName;
  params: Array<Identifier | Pattern | RestElement | TSParameterProperty>;
  body: BlockStatement;
@@ -1268,7 +1268,7 @@ export interface TSDeclareFunction extends BaseNode {
 export interface TSDeclareMethod extends BaseNode {
  type: "TSDeclareMethod";
  decorators: Array<Decorator> | null;
-  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
+  key: Identifier | StringLiteral | NumericLiteral | Expression;
  typeParameters: TSTypeParameterDeclaration | Noop | null;
  params: Array<Identifier | Pattern | RestElement | TSParameterProperty>;
  returnType: TSTypeAnnotation | Noop | null;
@@ -1309,7 +1309,7 @@ export interface TSPropertySignature extends BaseNode {
  key: Expression;
  typeAnnotation: TSTypeAnnotation | null;
  initializer: Expression | null;
-  computed: boolean;
+  computed: boolean | null;
  kind: "get" | "set";
  optional: boolean | null;
  readonly: boolean | null;
@@ -1321,7 +1321,7 @@ export interface TSMethodSignature extends BaseNode {
  typeParameters: TSTypeParameterDeclaration | null;
  parameters: Array<Identifier | RestElement>;
  typeAnnotation: TSTypeAnnotation | null;
-  computed: boolean;
+  computed: boolean | null;
  kind: "method" | "get" | "set";
  optional: boolean | null;
 }
@@ -1799,7 +1799,7 @@ export function memberExpression(object: Expression, property: Expression | Iden
 export function newExpression(callee: Expression | V8IntrinsicIdentifier, _arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>): NewExpression;
 export function program(body: Array<Statement>, directives?: Array<Directive>, sourceType?: "script" | "module", interpreter?: InterpreterDirective | null): Program;
 export function objectExpression(properties: Array<ObjectMethod | ObjectProperty | SpreadElement>): ObjectExpression;
-export function objectMethod(kind: "method" | "get" | "set" | undefined, key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral, params: Array<Identifier | Pattern | RestElement>, body: BlockStatement, computed?: boolean, generator?: boolean, async?: boolean): ObjectMethod;
+export function objectMethod(kind: "method" | "get" | "set" | undefined, key: Expression | Identifier | StringLiteral | NumericLiteral, params: Array<Identifier | Pattern | RestElement>, body: BlockStatement, computed?: boolean, generator?: boolean, async?: boolean): ObjectMethod;
 export function objectProperty(key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | PrivateName, value: Expression | PatternLike, computed?: boolean, shorthand?: boolean, decorators?: Array<Decorator> | null): ObjectProperty;
 export function restElement(argument: LVal): RestElement;
 export function returnStatement(argument?: Expression | null): ReturnStatement;
@@ -1832,7 +1832,7 @@ export function importDefaultSpecifier(local: Identifier): ImportDefaultSpecifie
 export function importNamespaceSpecifier(local: Identifier): ImportNamespaceSpecifier;
 export function importSpecifier(local: Identifier, imported: Identifier | StringLiteral): ImportSpecifier;
 export function metaProperty(meta: Identifier, property: Identifier): MetaProperty;
-export function classMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, body: BlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): ClassMethod;
+export function classMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: Identifier | StringLiteral | NumericLiteral | Expression, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, body: BlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): ClassMethod;
 export function objectPattern(properties: Array<RestElement | ObjectProperty>): ObjectPattern;
 export function spreadElement(argument: Expression): SpreadElement;
 declare function _super(): Super;
@@ -1848,10 +1848,10 @@ export function bigIntLiteral(value: string): BigIntLiteral;
 export function exportNamespaceSpecifier(exported: Identifier): ExportNamespaceSpecifier;
 export function optionalMemberExpression(object: Expression, property: Expression | Identifier, computed: boolean | undefined, optional: boolean): OptionalMemberExpression;
 export function optionalCallExpression(callee: Expression, _arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>, optional: boolean): OptionalCallExpression;
-export function classProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassProperty;
-export function classAccessorProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassAccessorProperty;
-export function classPrivateProperty(key: PrivateName, value?: Expression | null, decorators?: Array<Decorator> | null, _static?: boolean): ClassPrivateProperty;
-export function classPrivateMethod(kind: "get" | "set" | "method" | undefined, key: PrivateName, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, body: BlockStatement, _static?: boolean): ClassPrivateMethod;
+export function classProperty(key: Identifier | StringLiteral | NumericLiteral | Expression, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassProperty;
+export function classAccessorProperty(key: Identifier | StringLiteral | NumericLiteral | Expression | PrivateName, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassAccessorProperty;
+export function classPrivateProperty(key: PrivateName, value: Expression | null | undefined, decorators: Array<Decorator> | null | undefined, _static: any): ClassPrivateProperty;
+export function classPrivateMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: PrivateName, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, body: BlockStatement, _static?: boolean): ClassPrivateMethod;
 export function privateName(id: Identifier): PrivateName;
 export function staticBlock(body: Array<Statement>): StaticBlock;
 export function anyTypeAnnotation(): AnyTypeAnnotation;
@@ -1953,7 +1953,7 @@ export function pipelineBareFunction(callee: Expression): PipelineBareFunction;
 export function pipelinePrimaryTopicReference(): PipelinePrimaryTopicReference;
 export function tsParameterProperty(parameter: Identifier | AssignmentPattern): TSParameterProperty;
 export function tsDeclareFunction(id: Identifier | null | undefined, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<Identifier | Pattern | RestElement>, returnType?: TSTypeAnnotation | Noop | null): TSDeclareFunction;
-export function tsDeclareMethod(decorators: Array<Decorator> | null | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, returnType?: TSTypeAnnotation | Noop | null): TSDeclareMethod;
+export function tsDeclareMethod(decorators: Array<Decorator> | null | undefined, key: Identifier | StringLiteral | NumericLiteral | Expression, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, returnType?: TSTypeAnnotation | Noop | null): TSDeclareMethod;
 export function tsQualifiedName(left: TSEntityName, right: Identifier): TSQualifiedName;
 export function tsCallSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSCallSignatureDeclaration;
 export function tsConstructSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSConstructSignatureDeclaration;

--- a/node_modules/@babel/types/lib/index.d.ts
+++ b/node_modules/@babel/types/lib/index.d.ts
@@ -135,8 +135,8 @@ interface FunctionDeclaration extends BaseNode {
    id?: Identifier | null;
    params: Array<Identifier | Pattern | RestElement>;
    body: BlockStatement;
-    generator: boolean;
-    async: boolean;
+    generator?: boolean;
+    async?: boolean;
    declare?: boolean | null;
    predicate?: DeclaredPredicate | InferredPredicate | null;
    returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
@@ -147,8 +147,8 @@ interface FunctionExpression extends BaseNode {
    id?: Identifier | null;
    params: Array<Identifier | Pattern | RestElement>;
    body: BlockStatement;
-    generator: boolean;
-    async: boolean;
+    generator?: boolean;
+    async?: boolean;
    predicate?: DeclaredPredicate | InferredPredicate | null;
    returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
    typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
@@ -242,12 +242,12 @@ interface ObjectExpression extends BaseNode {
 interface ObjectMethod extends BaseNode {
    type: "ObjectMethod";
    kind: "method" | "get" | "set";
-    key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral;
+    key: Expression | Identifier | StringLiteral | NumericLiteral;
    params: Array<Identifier | Pattern | RestElement>;
    body: BlockStatement;
    computed: boolean;
-    generator: boolean;
-    async: boolean;
+    generator?: boolean;
+    async?: boolean;
    decorators?: Array<Decorator> | null;
    returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
    typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
@@ -364,7 +364,7 @@ interface ArrowFunctionExpression extends BaseNode {
    type: "ArrowFunctionExpression";
    params: Array<Identifier | Pattern | RestElement>;
    body: BlockStatement | Expression;
-    async: boolean;
+    async?: boolean;
    expression: boolean;
    generator?: boolean;
    predicate?: DeclaredPredicate | InferredPredicate | null;
@@ -459,14 +459,14 @@ interface MetaProperty extends BaseNode {
 }
 interface ClassMethod extends BaseNode {
    type: "ClassMethod";
-    kind: "get" | "set" | "method" | "constructor";
-    key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
+    kind?: "get" | "set" | "method" | "constructor";
+    key: Identifier | StringLiteral | NumericLiteral | Expression;
    params: Array<Identifier | Pattern | RestElement | TSParameterProperty>;
    body: BlockStatement;
-    computed: boolean;
-    static: boolean;
-    generator: boolean;
-    async: boolean;
+    computed?: boolean;
+    static?: boolean;
+    generator?: boolean;
+    async?: boolean;
    abstract?: boolean | null;
    access?: "public" | "private" | "protected" | null;
    accessibility?: "public" | "private" | "protected" | null;
@@ -552,12 +552,12 @@ interface OptionalCallExpression extends BaseNode {
 }
 interface ClassProperty extends BaseNode {
    type: "ClassProperty";
-    key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
+    key: Identifier | StringLiteral | NumericLiteral | Expression;
    value?: Expression | null;
    typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
    decorators?: Array<Decorator> | null;
-    computed: boolean;
-    static: boolean;
+    computed?: boolean;
+    static?: boolean;
    abstract?: boolean | null;
    accessibility?: "public" | "private" | "protected" | null;
    declare?: boolean | null;
@@ -569,12 +569,12 @@ interface ClassProperty extends BaseNode {
 }
 interface ClassAccessorProperty extends BaseNode {
    type: "ClassAccessorProperty";
-    key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName;
+    key: Identifier | StringLiteral | NumericLiteral | Expression | PrivateName;
    value?: Expression | null;
    typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
    decorators?: Array<Decorator> | null;
-    computed: boolean;
-    static: boolean;
+    computed?: boolean;
+    static?: boolean;
    abstract?: boolean | null;
    accessibility?: "public" | "private" | "protected" | null;
    declare?: boolean | null;
@@ -589,7 +589,7 @@ interface ClassPrivateProperty extends BaseNode {
    key: PrivateName;
    value?: Expression | null;
    decorators?: Array<Decorator> | null;
-    static: boolean;
+    static: any;
    definite?: boolean | null;
    readonly?: boolean | null;
    typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
@@ -597,11 +597,11 @@ interface ClassPrivateProperty extends BaseNode {
 }
 interface ClassPrivateMethod extends BaseNode {
    type: "ClassPrivateMethod";
-    kind: "get" | "set" | "method";
+    kind?: "get" | "set" | "method" | "constructor";
    key: PrivateName;
    params: Array<Identifier | Pattern | RestElement | TSParameterProperty>;
    body: BlockStatement;
-    static: boolean;
+    static?: boolean;
    abstract?: boolean | null;
    access?: "public" | "private" | "protected" | null;
    accessibility?: "public" | "private" | "protected" | null;
@@ -1109,7 +1109,7 @@ interface TSDeclareFunction extends BaseNode {
 interface TSDeclareMethod extends BaseNode {
    type: "TSDeclareMethod";
    decorators?: Array<Decorator> | null;
-    key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
+    key: Identifier | StringLiteral | NumericLiteral | Expression;
    typeParameters?: TSTypeParameterDeclaration | Noop | null;
    params: Array<Identifier | Pattern | RestElement | TSParameterProperty>;
    returnType?: TSTypeAnnotation | Noop | null;
@@ -1146,7 +1146,7 @@ interface TSPropertySignature extends BaseNode {
    key: Expression;
    typeAnnotation?: TSTypeAnnotation | null;
    initializer?: Expression | null;
-    computed?: boolean;
+    computed?: boolean | null;
    kind: "get" | "set";
    optional?: boolean | null;
    readonly?: boolean | null;
@@ -1157,7 +1157,7 @@ interface TSMethodSignature extends BaseNode {
    typeParameters?: TSTypeParameterDeclaration | null;
    parameters: Array<Identifier | RestElement>;
    typeAnnotation?: TSTypeAnnotation | null;
-    computed?: boolean;
+    computed?: boolean | null;
    kind: "method" | "get" | "set";
    optional?: boolean | null;
 }
@@ -1855,7 +1855,7 @@ declare function createFlowUnionType<T extends FlowType>(types: [T] | Array<T>):
 * Takes an array of `types` and flattens them, removing duplicates and
 * returns a `UnionTypeAnnotation` node containing them.
 */
-declare function createTSUnionType(typeAnnotations: Array<TSTypeAnnotation | TSType>): TSType;
+declare function createTSUnionType(typeAnnotations: Array<TSTypeAnnotation>): TSType;

 declare function arrayExpression(elements?: Array<null | Expression | SpreadElement>): ArrayExpression;
 declare function assignmentExpression(operator: string, left: LVal, right: Expression): AssignmentExpression;
@@ -1891,7 +1891,7 @@ declare function memberExpression(object: Expression, property: Expression | Ide
 declare function newExpression(callee: Expression | V8IntrinsicIdentifier, _arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>): NewExpression;
 declare function program(body: Array<Statement>, directives?: Array<Directive>, sourceType?: "script" | "module", interpreter?: InterpreterDirective | null): Program;
 declare function objectExpression(properties: Array<ObjectMethod | ObjectProperty | SpreadElement>): ObjectExpression;
-declare function objectMethod(kind: "method" | "get" | "set" | undefined, key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral, params: Array<Identifier | Pattern | RestElement>, body: BlockStatement, computed?: boolean, generator?: boolean, async?: boolean): ObjectMethod;
+declare function objectMethod(kind: "method" | "get" | "set" | undefined, key: Expression | Identifier | StringLiteral | NumericLiteral, params: Array<Identifier | Pattern | RestElement>, body: BlockStatement, computed?: boolean, generator?: boolean, async?: boolean): ObjectMethod;
 declare function objectProperty(key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | PrivateName, value: Expression | PatternLike, computed?: boolean, shorthand?: boolean, decorators?: Array<Decorator> | null): ObjectProperty;
 declare function restElement(argument: LVal): RestElement;
 declare function returnStatement(argument?: Expression | null): ReturnStatement;
@@ -1924,7 +1924,7 @@ declare function importDefaultSpecifier(local: Identifier): ImportDefaultSpecifi
 declare function importNamespaceSpecifier(local: Identifier): ImportNamespaceSpecifier;
 declare function importSpecifier(local: Identifier, imported: Identifier | StringLiteral): ImportSpecifier;
 declare function metaProperty(meta: Identifier, property: Identifier): MetaProperty;
-declare function classMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, body: BlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): ClassMethod;
+declare function classMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: Identifier | StringLiteral | NumericLiteral | Expression, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, body: BlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): ClassMethod;
 declare function objectPattern(properties: Array<RestElement | ObjectProperty>): ObjectPattern;
 declare function spreadElement(argument: Expression): SpreadElement;
 declare function _super(): Super;
@@ -1943,10 +1943,10 @@ declare function bigIntLiteral(value: string): BigIntLiteral;
 declare function exportNamespaceSpecifier(exported: Identifier): ExportNamespaceSpecifier;
 declare function optionalMemberExpression(object: Expression, property: Expression | Identifier, computed: boolean | undefined, optional: boolean): OptionalMemberExpression;
 declare function optionalCallExpression(callee: Expression, _arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>, optional: boolean): OptionalCallExpression;
-declare function classProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassProperty;
-declare function classAccessorProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassAccessorProperty;
-declare function classPrivateProperty(key: PrivateName, value?: Expression | null, decorators?: Array<Decorator> | null, _static?: boolean): ClassPrivateProperty;
-declare function classPrivateMethod(kind: "get" | "set" | "method" | undefined, key: PrivateName, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, body: BlockStatement, _static?: boolean): ClassPrivateMethod;
+declare function classProperty(key: Identifier | StringLiteral | NumericLiteral | Expression, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassProperty;
+declare function classAccessorProperty(key: Identifier | StringLiteral | NumericLiteral | Expression | PrivateName, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassAccessorProperty;
+declare function classPrivateProperty(key: PrivateName, value: Expression | null | undefined, decorators: Array<Decorator> | null | undefined, _static: any): ClassPrivateProperty;
+declare function classPrivateMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: PrivateName, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, body: BlockStatement, _static?: boolean): ClassPrivateMethod;
 declare function privateName(id: Identifier): PrivateName;
 declare function staticBlock(body: Array<Statement>): StaticBlock;
 declare function anyTypeAnnotation(): AnyTypeAnnotation;
@@ -2065,7 +2065,7 @@ declare function tsParameterProperty(parameter: Identifier | AssignmentPattern):

 declare function tsDeclareFunction(id: Identifier | null | undefined, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<Identifier | Pattern | RestElement>, returnType?: TSTypeAnnotation | Noop | null): TSDeclareFunction;

-declare function tsDeclareMethod(decorators: Array<Decorator> | null | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, returnType?: TSTypeAnnotation | Noop | null): TSDeclareMethod;
+declare function tsDeclareMethod(decorators: Array<Decorator> | null | undefined, key: Identifier | StringLiteral | NumericLiteral | Expression, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, returnType?: TSTypeAnnotation | Noop | null): TSDeclareMethod;

 declare function tsQualifiedName(left: TSEntityName, right: Identifier): TSQualifiedName;


--- a/node_modules/@babel/types/lib/index.js.flow
+++ b/node_modules/@babel/types/lib/index.js.flow
@@ -263,7 +263,7 @@ declare class BabelNodeObjectExpression extends BabelNode {
 declare class BabelNodeObjectMethod extends BabelNode {
  type: "ObjectMethod";
  kind?: "method" | "get" | "set";
-  key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral;
+  key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral;
  params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement>;
  body: BabelNodeBlockStatement;
  computed?: boolean;
@@ -501,7 +501,7 @@ declare class BabelNodeMetaProperty extends BabelNode {
 declare class BabelNodeClassMethod extends BabelNode {
  type: "ClassMethod";
  kind?: "get" | "set" | "method" | "constructor";
-  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression;
+  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression;
  params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>;
  body: BabelNodeBlockStatement;
  computed?: boolean;
@@ -596,7 +596,7 @@ declare class BabelNodeOptionalCallExpression extends BabelNode {

 declare class BabelNodeClassProperty extends BabelNode {
  type: "ClassProperty";
-  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression;
+  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression;
  value?: BabelNodeExpression;
  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
  decorators?: Array<BabelNodeDecorator>;
@@ -613,7 +613,7 @@ declare class BabelNodeClassProperty extends BabelNode {

 declare class BabelNodeClassAccessorProperty extends BabelNode {
  type: "ClassAccessorProperty";
-  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression | BabelNodePrivateName;
+  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression | BabelNodePrivateName;
  value?: BabelNodeExpression;
  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
  decorators?: Array<BabelNodeDecorator>;
@@ -641,7 +641,7 @@ declare class BabelNodeClassPrivateProperty extends BabelNode {

 declare class BabelNodeClassPrivateMethod extends BabelNode {
  type: "ClassPrivateMethod";
-  kind?: "get" | "set" | "method";
+  kind?: "get" | "set" | "method" | "constructor";
  key: BabelNodePrivateName;
  params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>;
  body: BabelNodeBlockStatement;
@@ -1240,7 +1240,7 @@ declare class BabelNodeTSDeclareFunction extends BabelNode {
 declare class BabelNodeTSDeclareMethod extends BabelNode {
  type: "TSDeclareMethod";
  decorators?: Array<BabelNodeDecorator>;
-  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression;
+  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression;
  typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
  params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>;
  returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop;
@@ -1694,7 +1694,7 @@ declare module "@babel/types" {
  declare export function newExpression(callee: BabelNodeExpression | BabelNodeV8IntrinsicIdentifier, _arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeJSXNamespacedName | BabelNodeArgumentPlaceholder>): BabelNodeNewExpression;
  declare export function program(body: Array<BabelNodeStatement>, directives?: Array<BabelNodeDirective>, sourceType?: "script" | "module", interpreter?: BabelNodeInterpreterDirective): BabelNodeProgram;
  declare export function objectExpression(properties: Array<BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeSpreadElement>): BabelNodeObjectExpression;
-  declare export function objectMethod(kind?: "method" | "get" | "set", key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement>, body: BabelNodeBlockStatement, computed?: boolean, generator?: boolean, async?: boolean): BabelNodeObjectMethod;
+  declare export function objectMethod(kind?: "method" | "get" | "set", key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement>, body: BabelNodeBlockStatement, computed?: boolean, generator?: boolean, async?: boolean): BabelNodeObjectMethod;
  declare export function objectProperty(key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeDecimalLiteral | BabelNodePrivateName, value: BabelNodeExpression | BabelNodePatternLike, computed?: boolean, shorthand?: boolean, decorators?: Array<BabelNodeDecorator>): BabelNodeObjectProperty;
  declare export function restElement(argument: BabelNodeLVal): BabelNodeRestElement;
  declare export function returnStatement(argument?: BabelNodeExpression): BabelNodeReturnStatement;
@@ -1727,7 +1727,7 @@ declare module "@babel/types" {
  declare export function importNamespaceSpecifier(local: BabelNodeIdentifier): BabelNodeImportNamespaceSpecifier;
  declare export function importSpecifier(local: BabelNodeIdentifier, imported: BabelNodeIdentifier | BabelNodeStringLiteral): BabelNodeImportSpecifier;
  declare export function metaProperty(meta: BabelNodeIdentifier, property: BabelNodeIdentifier): BabelNodeMetaProperty;
-  declare export function classMethod(kind?: "get" | "set" | "method" | "constructor", key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>, body: BabelNodeBlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): BabelNodeClassMethod;
+  declare export function classMethod(kind?: "get" | "set" | "method" | "constructor", key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>, body: BabelNodeBlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): BabelNodeClassMethod;
  declare export function objectPattern(properties: Array<BabelNodeRestElement | BabelNodeObjectProperty>): BabelNodeObjectPattern;
  declare export function spreadElement(argument: BabelNodeExpression): BabelNodeSpreadElement;
  declare function _super(): BabelNodeSuper;
@@ -1743,10 +1743,10 @@ declare module "@babel/types" {
  declare export function exportNamespaceSpecifier(exported: BabelNodeIdentifier): BabelNodeExportNamespaceSpecifier;
  declare export function optionalMemberExpression(object: BabelNodeExpression, property: BabelNodeExpression | BabelNodeIdentifier, computed?: boolean, optional: boolean): BabelNodeOptionalMemberExpression;
  declare export function optionalCallExpression(callee: BabelNodeExpression, _arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeJSXNamespacedName | BabelNodeArgumentPlaceholder>, optional: boolean): BabelNodeOptionalCallExpression;
-  declare export function classProperty(key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression, value?: BabelNodeExpression, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, decorators?: Array<BabelNodeDecorator>, computed?: boolean, _static?: boolean): BabelNodeClassProperty;
-  declare export function classAccessorProperty(key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression | BabelNodePrivateName, value?: BabelNodeExpression, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, decorators?: Array<BabelNodeDecorator>, computed?: boolean, _static?: boolean): BabelNodeClassAccessorProperty;
-  declare export function classPrivateProperty(key: BabelNodePrivateName, value?: BabelNodeExpression, decorators?: Array<BabelNodeDecorator>, _static?: boolean): BabelNodeClassPrivateProperty;
-  declare export function classPrivateMethod(kind?: "get" | "set" | "method", key: BabelNodePrivateName, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>, body: BabelNodeBlockStatement, _static?: boolean): BabelNodeClassPrivateMethod;
+  declare export function classProperty(key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression, value?: BabelNodeExpression, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, decorators?: Array<BabelNodeDecorator>, computed?: boolean, _static?: boolean): BabelNodeClassProperty;
+  declare export function classAccessorProperty(key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression | BabelNodePrivateName, value?: BabelNodeExpression, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, decorators?: Array<BabelNodeDecorator>, computed?: boolean, _static?: boolean): BabelNodeClassAccessorProperty;
+  declare export function classPrivateProperty(key: BabelNodePrivateName, value?: BabelNodeExpression, decorators?: Array<BabelNodeDecorator>, _static: any): BabelNodeClassPrivateProperty;
+  declare export function classPrivateMethod(kind?: "get" | "set" | "method" | "constructor", key: BabelNodePrivateName, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>, body: BabelNodeBlockStatement, _static?: boolean): BabelNodeClassPrivateMethod;
  declare export function privateName(id: BabelNodeIdentifier): BabelNodePrivateName;
  declare export function staticBlock(body: Array<BabelNodeStatement>): BabelNodeStaticBlock;
  declare export function anyTypeAnnotation(): BabelNodeAnyTypeAnnotation;
@@ -1848,7 +1848,7 @@ declare module "@babel/types" {
  declare export function pipelinePrimaryTopicReference(): BabelNodePipelinePrimaryTopicReference;
  declare export function tsParameterProperty(parameter: BabelNodeIdentifier | BabelNodeAssignmentPattern): BabelNodeTSParameterProperty;
  declare export function tsDeclareFunction(id?: BabelNodeIdentifier, typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement>, returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop): BabelNodeTSDeclareFunction;
-  declare export function tsDeclareMethod(decorators?: Array<BabelNodeDecorator>, key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression, typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>, returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop): BabelNodeTSDeclareMethod;
+  declare export function tsDeclareMethod(decorators?: Array<BabelNodeDecorator>, key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression, typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>, returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop): BabelNodeTSDeclareMethod;
  declare export function tsQualifiedName(left: BabelNodeTSEntityName, right: BabelNodeIdentifier): BabelNodeTSQualifiedName;
  declare export function tsCallSignatureDeclaration(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: Array<BabelNodeIdentifier | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSCallSignatureDeclaration;
  declare export function tsConstructSignatureDeclaration(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: Array<BabelNodeIdentifier | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSConstructSignatureDeclaration;

--- a/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js
+++ b/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js
@@ -12,8 +12,8 @@ function getQualifiedName(node) {
 }

 function removeTypeDuplicates(nodes) {
-  const generics = new Map();
-  const bases = new Map();
+  const generics = {};
+  const bases = {};
  const typeGroups = new Set();
  const types = [];

@@ -30,7 +30,7 @@ function removeTypeDuplicates(nodes) {
    }

    if ((0, _generated.isFlowBaseAnnotation)(node)) {
-      bases.set(node.type, node);
+      bases[node.type] = node;
      continue;
    }

@@ -46,8 +46,8 @@ function removeTypeDuplicates(nodes) {
    if ((0, _generated.isGenericTypeAnnotation)(node)) {
      const name = getQualifiedName(node.id);

-      if (generics.has(name)) {
-        let existing = generics.get(name);
+      if (generics[name]) {
+        let existing = generics[name];

        if (existing.typeParameters) {
          if (node.typeParameters) {
@@ -57,7 +57,7 @@ function removeTypeDuplicates(nodes) {
          existing = node.typeParameters;
        }
      } else {
-        generics.set(name, node);
+        generics[name] = node;
      }

      continue;
@@ -66,12 +66,12 @@ function removeTypeDuplicates(nodes) {
    types.push(node);
  }

-  for (const [, baseType] of bases) {
-    types.push(baseType);
+  for (const type of Object.keys(bases)) {
+    types.push(bases[type]);
  }

-  for (const [, genericName] of generics) {
-    types.push(genericName);
+  for (const name of Object.keys(generics)) {
+    types.push(generics[name]);
  }

  return types;

--- a/node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js
+++ b/node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js
@@ -7,13 +7,9 @@ exports.default = removeTypeDuplicates;

 var _generated = require("../../validators/generated");

-function getQualifiedName(node) {
-  return (0, _generated.isIdentifier)(node) ? node.name : `${node.right.name}.${getQualifiedName(node.left)}`;
-}
-
 function removeTypeDuplicates(nodes) {
-  const generics = new Map();
-  const bases = new Map();
+  const generics = {};
+  const bases = {};
  const typeGroups = new Set();
  const types = [];

@@ -30,7 +26,7 @@ function removeTypeDuplicates(nodes) {
    }

    if ((0, _generated.isTSBaseType)(node)) {
-      bases.set(node.type, node);
+      bases[node.type] = node;
      continue;
    }

@@ -43,35 +39,15 @@ function removeTypeDuplicates(nodes) {
      continue;
    }

-    if ((0, _generated.isTSTypeReference)(node) && node.typeParameters) {
-      const name = getQualifiedName(node.typeName);
-
-      if (generics.has(name)) {
-        let existing = generics.get(name);
-
-        if (existing.typeParameters) {
-          if (node.typeParameters) {
-            existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node.typeParameters.params));
-          }
-        } else {
-          existing = node.typeParameters;
-        }
-      } else {
-        generics.set(name, node);
-      }
-
-      continue;
-    }
-
    types.push(node);
  }

-  for (const [, baseType] of bases) {
-    types.push(baseType);
+  for (const type of Object.keys(bases)) {
+    types.push(bases[type]);
  }

-  for (const [, genericName] of generics) {
-    types.push(genericName);
+  for (const name of Object.keys(generics)) {
+    types.push(generics[name]);
  }

  return types;

--- a/node_modules/@babel/types/package.json
+++ b/node_modules/@babel/types/package.json
 {
  "name": "@babel/types",
-  "version": "7.18.8",
+  "version": "7.18.7",
  "description": "Babel Types is a Lodash-esque utility library for AST nodes",
  "author": "The Babel Team (https://babel.dev/team)",
  "homepage": "https://babel.dev/docs/en/next/babel-types",
@@ -29,7 +29,7 @@
  },
  "devDependencies": {
    "@babel/generator": "^7.18.7",
-    "@babel/parser": "^7.18.8",
+    "@babel/parser": "^7.18.6",
    "chalk": "^4.1.0",
    "glob": "^7.1.7"
  },

--- a/node_modules/@eslint/eslintrc/CHANGELOG.md
+++ b/node_modules/@eslint/eslintrc/CHANGELOG.md
-v0.4.3 - July 17, 2021
-
-* [`ce78027`](https://github.com/eslint/eslintrc/commit/ce78027f6a319a29fdf0b78ac1e7071373acffc4) Fix: ensure config files are files (#42) (Tom Jenkinson)
-* [`95b1c9b`](https://github.com/eslint/eslintrc/commit/95b1c9b30267479a75cd07768f8f9e9cfa63c105) Chore: pin fs-teardown@0.1.1 (#45) (Milos Djermanovic)
-* [`593fbe3`](https://github.com/eslint/eslintrc/commit/593fbe3c2c1c5f723f71810963ed21a56caed4c1) Chore: fix failing test (#44) (Tom Jenkinson)
-
-v0.4.2 - June 4, 2021
-
-* [`cc79a4d`](https://github.com/eslint/eslintrc/commit/cc79a4db45a2ca0236a846ed8eba28eea07d4db5) Upgrade: update globals to version 13.6 (#32) (Rouven Weßling)
-
-v0.4.1 - May 7, 2021
-
-* [`aa38ef4`](https://github.com/eslint/eslintrc/commit/aa38ef40c3123f8f534c7f9b0b7c306f5f011dce) Fix: Properly export module resolver (#34) (Richie Bendall)
-* [`62ea4bd`](https://github.com/eslint/eslintrc/commit/62ea4bd74b78fbeff12ffb21f1f978817601d4d1) Build: add node v16 (#33) (薛定谔的猫)
-* [`7c43d77`](https://github.com/eslint/eslintrc/commit/7c43d7784e39cf0b7b102af64f703cade11252bb) Chore: add tests for built-in rules config schema validation (fixes #15) (#31) (Milos Djermanovic)
-* [`d8ea601`](https://github.com/eslint/eslintrc/commit/d8ea601ecb4b9f81cdc332b012b6b1bbc984366c) Chore: Test on Node 15.x (#30) (Milos Djermanovic)
-* [`0b2f80d`](https://github.com/eslint/eslintrc/commit/0b2f80d6f6b33e4c5e168b08468867653f726754) Chore: lint test files (#18) (Milos Djermanovic)
-
-v0.4.0 - February 27, 2021
-
-* [`d9a527b`](https://github.com/eslint/eslintrc/commit/d9a527bdb16af46a28d37fa9022131149970a438) New: Implement DotCompat class (#20) (Nicholas C. Zakas)
-* [`dac76c0`](https://github.com/eslint/eslintrc/commit/dac76c035a9ab9d315050f688867373966aab288) Chore: Replace usage of lodash with cache set (#29) (Tim van der Lippe)
-* [`3ae2d77`](https://github.com/eslint/eslintrc/commit/3ae2d770cb810c026de817e6861e25dac111da9f) Update: add AggregateError global to es2021 environment (#28) (Milos Djermanovic)
-
-v0.3.0 - January 15, 2021
-
-* [`5184490`](https://github.com/eslint/eslintrc/commit/51844902bc4132f264f05a0614f2cdeb89290f68) Upgrade: lodash@4.17.20 (#24) (Milos Djermanovic)
-* [`f1179c5`](https://github.com/eslint/eslintrc/commit/f1179c587ae09fabb5c3402598363cfcec2494f7) Update: Implement missing functionality from ESLint port (fixes #12) (#23) (Nicholas C. Zakas)
-
-v0.2.2 - December 5, 2020
-
-* [`1746840`](https://github.com/eslint/eslintrc/commit/17468407c1baf05747cb261c91f7f7b7c2a82422) Fix: include loadRules in internalSlotsMap cache (#19) (Henry Q. Dineen)
-* [`f30bb49`](https://github.com/eslint/eslintrc/commit/f30bb4935aaf3f4c1b268490da495a59647e58d8) Chore: Test fixes for CascadingConfigArrayFactory (#17) (Nicholas C. Zakas)
-* [`4440df8`](https://github.com/eslint/eslintrc/commit/4440df8237a127e15cbde5c697353e1224f12ec1) Chore: Fix config-array tests (#16) (Nicholas C. Zakas)
-* [`7890e02`](https://github.com/eslint/eslintrc/commit/7890e027df530a0fb53bcf5751c8c7a008b2a494) Chore: Test fixes for config-array-factory.js (#13) (Nicholas C. Zakas)
-
-v0.2.1 - October 26, 2020
-
-* [`8b202ff`](https://github.com/eslint/eslintrc/commit/8b202ff866a39efdaad6394fde9f88372afbfca8) Fix: validate schema for built-in rules (#14) (Milos Djermanovic)
-* [`04f3cae`](https://github.com/eslint/eslintrc/commit/04f3cae17fe07b2fd0b74fd3e88482b3094e75e3) Fix: cache compiled config schema (#9) (Milos Djermanovic)
-
-v0.2.0 - October 16, 2020
-
-* [`cb12255`](https://github.com/eslint/eslintrc/commit/cb12255b85390e932e1942e479c2c97310149390) Update: Allow eslint:all and eslint:recommended paths to be passed in (#11) (Nicholas C. Zakas)
-* [`a75bacd`](https://github.com/eslint/eslintrc/commit/a75bacd9a743a7bbcdb8c59e5d4f9de3dc8b0f20) Chore: use GitHub Actions (#10) (Milos Djermanovic)
-
-v0.1.3 - September 1, 2020
-
-* [`8647a61`](https://github.com/eslint/eslintrc/commit/8647a61991fe121f923d33e96232475209b78210) Fix: version number and eslint-release version (refs #6) (Nicholas C. Zakas)
-
--- a/node_modules/@eslint/eslintrc/LICENSE
+++ b/node_modules/@eslint/eslintrc/LICENSE
-MIT License
-
-Copyright (c) 2020 ESLint
-
-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.