node_modules/@babel/parser/package.json

 {
   "name": "@babel/parser",
-  "version": "7.18.6",
+  "version": "7.18.8",
   "description": "A JavaScript parser",
   "author": "The Babel Team (https://babel.dev/team)",
   "homepage": "https://babel.dev/docs/en/next/babel-parser",

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) {
+function classPrivateProperty(key, value = null, decorators = null, _static = false) {
   return (0, _validateNode.default)({
     type: "ClassPrivateProperty",
     key,

node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js

@@ -9,8 +9,12 @@ var _generated = require("../generated");
 
 var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates");
 
+var _index = require("../../validators/generated/index");
+
 function createTSUnionType(typeAnnotations) {
-  const types = typeAnnotations.map(type => type.typeAnnotation);
+  const types = typeAnnotations.map(type => {
+    return (0, _index.isTSTypeAnnotation)(type) ? type.typeAnnotation : type;
+  });
   const flattened = (0, _removeTypeDuplicates.default)(types);
 
   if (flattened.length === 1) {

node_modules/@babel/types/lib/definitions/core.js

@@ -278,7 +278,8 @@ defineType("ForStatement", {
     }
   }
 });
-const functionCommon = {
+
+const functionCommon = () => ({
   params: {
     validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement")))
   },
@@ -288,9 +289,11 @@ const functionCommon = {
   async: {
     default: false
   }
-};
+});
+
 exports.functionCommon = functionCommon;
-const functionTypeAnnotationCommon = {
+
+const functionTypeAnnotationCommon = () => ({
   returnType: {
     validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
     optional: true
@@ -299,9 +302,11 @@ 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
@@ -311,11 +316,12 @@ 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")
     },
@@ -338,7 +344,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
@@ -352,21 +358,24 @@ 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")))
+    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+    optional: true
   }
-};
+});
+
 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;
@@ -587,7 +596,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 ? {
@@ -598,7 +607,7 @@ defineType("ObjectMethod", {
     },
     key: {
       validate: function () {
-        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
+        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral");
         const computed = (0, _utils.assertNodeType)("Expression");
 
         const validator = function (node, key, val) {
@@ -606,7 +615,7 @@ defineType("ObjectMethod", {
           validator(node, key, val);
         };
 
-        validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral"];
+        validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"];
         return validator;
       }()
     },
@@ -683,7 +692,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")
     },
@@ -910,7 +919,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")
     },
@@ -927,7 +936,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")))
     },
@@ -945,7 +954,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")
     },
@@ -1267,7 +1276,8 @@ defineType("MetaProperty", {
     }
   }
 });
-const classMethodOrPropertyCommon = {
+
+const classMethodOrPropertyCommon = () => ({
   abstract: {
     validate: (0, _utils.assertValueType)("boolean"),
     optional: true
@@ -1297,11 +1307,13 @@ const classMethodOrPropertyCommon = {
         const validator = node.computed ? computed : normal;
         validator(node, key, val);
       };
-    }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression"))
+    }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "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")))
   },
@@ -1318,12 +1330,13 @@ const classMethodOrDeclareMethodCommon = Object.assign({}, functionCommon, class
     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")
     }
@@ -1333,7 +1346,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")))
     }
@@ -1515,7 +1528,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
@@ -1550,16 +1563,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", "PrivateName");
+        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "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", "Expression", "PrivateName"))
+      }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression", "PrivateName"))
     },
     value: {
       validate: (0, _utils.assertNodeType)("Expression"),
@@ -1611,6 +1624,10 @@ 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
@@ -1629,7 +1646,11 @@ 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, {
+  fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), {
+    kind: {
+      validate: (0, _utils.assertOneOf)("get", "set", "method"),
+      default: "method"
+    },
     key: {
       validate: (0, _utils.assertNodeType)("PrivateName")
     },

node_modules/@babel/types/lib/definitions/typescript.js

@@ -8,7 +8,8 @@ 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
@@ -17,7 +18,8 @@ const tSFunctionTypeAnnotationCommon = {
     validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
     optional: true
   }
-};
+});
+
 defineType("TSParameterProperty", {
   aliases: ["LVal"],
   visitor: ["parameter"],
@@ -46,11 +48,11 @@ defineType("TSParameterProperty", {
 defineType("TSDeclareFunction", {
   aliases: ["Statement", "Declaration"],
   visitor: ["id", "typeParameters", "params", "returnType"],
-  fields: Object.assign({}, _core.functionDeclarationCommon, tSFunctionTypeAnnotationCommon)
+  fields: Object.assign({}, (0, _core.functionDeclarationCommon)(), tSFunctionTypeAnnotationCommon())
 });
 defineType("TSDeclareMethod", {
   visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
-  fields: Object.assign({}, _core.classMethodOrDeclareMethodCommon, tSFunctionTypeAnnotationCommon)
+  fields: Object.assign({}, (0, _core.classMethodOrDeclareMethodCommon)(), tSFunctionTypeAnnotationCommon())
 });
 defineType("TSQualifiedName", {
   aliases: ["TSEntityName"],
@@ -60,27 +62,33 @@ 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: (0, _utils.validate)(bool),
+  computed: {
+    default: false
+  },
   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"),
@@ -92,7 +100,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")
     }
@@ -128,10 +136,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)
   })
 }));

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;
+  key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral;
   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 | Expression;
+  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | 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 | Expression;
+  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | 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 | Expression | PrivateName;
+  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | 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: any;
+  static: boolean;
   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" | "constructor";
+  kind: "get" | "set" | "method";
   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 | Expression;
+  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | 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 | null;
+  computed: boolean;
   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 | null;
+  computed: boolean;
   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, 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 | BigIntLiteral, 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 | 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 | BigIntLiteral | 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 | 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 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 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 | 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 | BigIntLiteral | 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;

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;
+    key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral;
     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 | Expression;
+    kind: "get" | "set" | "method" | "constructor";
+    key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | 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 | Expression;
+    key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | 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 | Expression | PrivateName;
+    key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | 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: any;
+    static: boolean;
     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" | "constructor";
+    kind: "get" | "set" | "method";
     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 | Expression;
+    key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | 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 | null;
+    computed?: boolean;
     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 | null;
+    computed?: boolean;
     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;
+declare function createTSUnionType(typeAnnotations: Array<TSTypeAnnotation | TSType>): 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, 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 | BigIntLiteral, 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 | 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 | BigIntLiteral | 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 | 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 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 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 | 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 | BigIntLiteral | 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;
 

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;
+  key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral;
   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 | BabelNodeExpression;
+  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | 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 | BabelNodeExpression;
+  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | 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 | BabelNodeExpression | BabelNodePrivateName;
+  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | 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" | "constructor";
+  kind?: "get" | "set" | "method";
   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 | BabelNodeExpression;
+  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | 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, 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 | BabelNodeBigIntLiteral, 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 | 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 | BabelNodeBigIntLiteral | 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 | 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 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 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 | 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 | BabelNodeBigIntLiteral | 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;

node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js

@@ -12,8 +12,8 @@ function getQualifiedName(node) {
 }
 
 function removeTypeDuplicates(nodes) {
-  const generics = {};
-  const bases = {};
+  const generics = new Map();
+  const bases = new Map();
   const typeGroups = new Set();
   const types = [];
 
@@ -30,7 +30,7 @@ function removeTypeDuplicates(nodes) {
     }
 
     if ((0, _generated.isFlowBaseAnnotation)(node)) {
-      bases[node.type] = node;
+      bases.set(node.type, node);
       continue;
     }
 
@@ -46,8 +46,8 @@ function removeTypeDuplicates(nodes) {
     if ((0, _generated.isGenericTypeAnnotation)(node)) {
       const name = getQualifiedName(node.id);
 
-      if (generics[name]) {
-        let existing = generics[name];
+      if (generics.has(name)) {
+        let existing = generics.get(name);
 
         if (existing.typeParameters) {
           if (node.typeParameters) {
@@ -57,7 +57,7 @@ function removeTypeDuplicates(nodes) {
           existing = node.typeParameters;
         }
       } else {
-        generics[name] = node;
+        generics.set(name, node);
       }
 
       continue;
@@ -66,12 +66,12 @@ function removeTypeDuplicates(nodes) {
     types.push(node);
   }
 
-  for (const type of Object.keys(bases)) {
-    types.push(bases[type]);
+  for (const [, baseType] of bases) {
+    types.push(baseType);
   }
 
-  for (const name of Object.keys(generics)) {
-    types.push(generics[name]);
+  for (const [, genericName] of generics) {
+    types.push(genericName);
   }
 
   return types;

node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js

@@ -7,9 +7,13 @@ 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 = {};
-  const bases = {};
+  const generics = new Map();
+  const bases = new Map();
   const typeGroups = new Set();
   const types = [];
 
@@ -26,7 +30,7 @@ function removeTypeDuplicates(nodes) {
     }
 
     if ((0, _generated.isTSBaseType)(node)) {
-      bases[node.type] = node;
+      bases.set(node.type, node);
       continue;
     }
 
@@ -39,15 +43,35 @@ 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 type of Object.keys(bases)) {
-    types.push(bases[type]);
+  for (const [, baseType] of bases) {
+    types.push(baseType);
   }
 
-  for (const name of Object.keys(generics)) {
-    types.push(generics[name]);
+  for (const [, genericName] of generics) {
+    types.push(genericName);
   }
 
   return types;

node_modules/@babel/types/package.json

 {
   "name": "@babel/types",
-  "version": "7.18.7",
+  "version": "7.18.8",
   "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.6",
+    "@babel/parser": "^7.18.8",
     "chalk": "^4.1.0",
     "glob": "^7.1.7"
   },

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)
+

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.

node_modules/@eslint/eslintrc/README.md

+# ESLintRC Library
+
+This repository contains the legacy ESLintRC configuration file format for ESLint.
+
+**Note:** This package is not intended for use outside of the ESLint ecosystem. It is ESLint-specific and not intended for use in other programs.
+
+## Installation
+
+You can install the package as follows:
+
+```
+npm install @eslint/eslintrc --save-dev
+
+# or
+
+yarn add @eslint/eslintrc -D
+```
+
+## Future Usage
+
+**Note:** This package is not intended for public use at this time. The following is an example of how it will be used in the future.
+
+The primary class in this package is `FlatCompat`, which is a utility to translate ESLintRC-style configs into flat configs. Here's how you use it inside of your `eslint.config.js` file:
+
+```js
+import { FlatCompat } from "@eslint/eslintrc";
+
+const compat = new FlatCompat();
+
+export default [
+
+    // mimic ESLintRC-style extends
+    compat.extends("standard", "example"),
+
+    // mimic environments
+    compat.env({
+        es2020: true,
+        node: true
+    }),
+
+    // mimic plugins
+    compat.plugins("airbnb", "react"),
+
+    // translate an entire config
+    compat.config({
+        plugins: ["airbnb", "react"],
+        extends: "standard",
+        env: {
+            es2020: true,
+            node: true
+        },
+        rules: {
+            semi: "error"
+        }
+    })
+];
+```
+
+## License
+
+MIT License

node_modules/@eslint/eslintrc/conf/config-schema.js

+/**
+ * @fileoverview Defines a schema for configs.
+ * @author Sylvan Mably
+ */
+
+"use strict";
+
+const baseConfigProperties = {
+    $schema: { type: "string" },
+    env: { type: "object" },
+    extends: { $ref: "#/definitions/stringOrStrings" },
+    globals: { type: "object" },
+    overrides: {
+        type: "array",
+        items: { $ref: "#/definitions/overrideConfig" },
+        additionalItems: false
+    },
+    parser: { type: ["string", "null"] },
+    parserOptions: { type: "object" },
+    plugins: { type: "array" },
+    processor: { type: "string" },
+    rules: { type: "object" },
+    settings: { type: "object" },
+    noInlineConfig: { type: "boolean" },
+    reportUnusedDisableDirectives: { type: "boolean" },
+
+    ecmaFeatures: { type: "object" } // deprecated; logs a warning when used
+};
+
+const configSchema = {
+    definitions: {
+        stringOrStrings: {
+            oneOf: [
+                { type: "string" },
+                {
+                    type: "array",
+                    items: { type: "string" },
+                    additionalItems: false
+                }
+            ]
+        },
+        stringOrStringsRequired: {
+            oneOf: [
+                { type: "string" },
+                {
+                    type: "array",
+                    items: { type: "string" },
+                    additionalItems: false,
+                    minItems: 1
+                }
+            ]
+        },
+
+        // Config at top-level.
+        objectConfig: {
+            type: "object",
+            properties: {
+                root: { type: "boolean" },
+                ignorePatterns: { $ref: "#/definitions/stringOrStrings" },
+                ...baseConfigProperties
+            },
+            additionalProperties: false
+        },
+
+        // Config in `overrides`.
+        overrideConfig: {
+            type: "object",
+            properties: {
+                excludedFiles: { $ref: "#/definitions/stringOrStrings" },
+                files: { $ref: "#/definitions/stringOrStringsRequired" },
+                ...baseConfigProperties
+            },
+            required: ["files"],
+            additionalProperties: false
+        }
+    },
+
+    $ref: "#/definitions/objectConfig"
+};
+
+module.exports = configSchema;

node_modules/@eslint/eslintrc/conf/environments.js

+/**
+ * @fileoverview Defines environment settings and globals.
+ * @author Elan Shanker
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const globals = require("globals");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Get the object that has difference.
+ * @param {Record<string,boolean>} current The newer object.
+ * @param {Record<string,boolean>} prev The older object.
+ * @returns {Record<string,boolean>} The difference object.
+ */
+function getDiff(current, prev) {
+    const retv = {};
+
+    for (const [key, value] of Object.entries(current)) {
+        if (!Object.hasOwnProperty.call(prev, key)) {
+            retv[key] = value;
+        }
+    }
+
+    return retv;
+}
+
+const newGlobals2015 = getDiff(globals.es2015, globals.es5); // 19 variables such as Promise, Map, ...
+const newGlobals2017 = {
+    Atomics: false,
+    SharedArrayBuffer: false
+};
+const newGlobals2020 = {
+    BigInt: false,
+    BigInt64Array: false,
+    BigUint64Array: false,
+    globalThis: false
+};
+
+const newGlobals2021 = {
+    AggregateError: false,
+    FinalizationRegistry: false,
+    WeakRef: false
+};
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/** @type {Map<string, import("../lib/shared/types").Environment>} */
+module.exports = new Map(Object.entries({
+
+    // Language
+    builtin: {
+        globals: globals.es5
+    },
+    es6: {
+        globals: newGlobals2015,
+        parserOptions: {
+            ecmaVersion: 6
+        }
+    },
+    es2015: {
+        globals: newGlobals2015,
+        parserOptions: {
+            ecmaVersion: 6
+        }
+    },
+    es2017: {
+        globals: { ...newGlobals2015, ...newGlobals2017 },
+        parserOptions: {
+            ecmaVersion: 8
+        }
+    },
+    es2020: {
+        globals: { ...newGlobals2015, ...newGlobals2017, ...newGlobals2020 },
+        parserOptions: {
+            ecmaVersion: 11
+        }
+    },
+    es2021: {
+        globals: { ...newGlobals2015, ...newGlobals2017, ...newGlobals2020, ...newGlobals2021 },
+        parserOptions: {
+            ecmaVersion: 12
+        }
+    },
+
+    // Platforms
+    browser: {
+        globals: globals.browser
+    },
+    node: {
+        globals: globals.node,
+        parserOptions: {
+            ecmaFeatures: {
+                globalReturn: true
+            }
+        }
+    },
+    "shared-node-browser": {
+        globals: globals["shared-node-browser"]
+    },
+    worker: {
+        globals: globals.worker
+    },
+    serviceworker: {
+        globals: globals.serviceworker
+    },
+
+    // Frameworks
+    commonjs: {
+        globals: globals.commonjs,
+        parserOptions: {
+            ecmaFeatures: {
+                globalReturn: true
+            }
+        }
+    },
+    amd: {
+        globals: globals.amd
+    },
+    mocha: {
+        globals: globals.mocha
+    },
+    jasmine: {
+        globals: globals.jasmine
+    },
+    jest: {
+        globals: globals.jest
+    },
+    phantomjs: {
+        globals: globals.phantomjs
+    },
+    jquery: {
+        globals: globals.jquery
+    },
+    qunit: {
+        globals: globals.qunit
+    },
+    prototypejs: {
+        globals: globals.prototypejs
+    },
+    shelljs: {
+        globals: globals.shelljs
+    },
+    meteor: {
+        globals: globals.meteor
+    },
+    mongo: {
+        globals: globals.mongo
+    },
+    protractor: {
+        globals: globals.protractor
+    },
+    applescript: {
+        globals: globals.applescript
+    },
+    nashorn: {
+        globals: globals.nashorn
+    },
+    atomtest: {
+        globals: globals.atomtest
+    },
+    embertest: {
+        globals: globals.embertest
+    },
+    webextensions: {
+        globals: globals.webextensions
+    },
+    greasemonkey: {
+        globals: globals.greasemonkey
+    }
+}));

node_modules/@eslint/eslintrc/conf/eslint-all.js

+/**
+ * @fileoverview Stub eslint:all config
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+module.exports = {
+    settings: {
+        "eslint:all": true
+    }
+};

node_modules/@eslint/eslintrc/conf/eslint-recommended.js

+/**
+ * @fileoverview Stub eslint:recommended config
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+module.exports = {
+    settings: {
+        "eslint:recommended": true
+    }
+};