bitz-react-admin-ui 2.10.7-beta.1 → 2.10.7-beta.2

package/dist/node_modules/@babel/types/lib/definitions/core.mjs

@@ -1,1556 +0,0 @@
-import { __exports as p } from "../../../../../_virtual/core.mjs";
-import { __require as x } from "../validators/is.mjs";
-import "../validators/isValidIdentifier.mjs";
-import "../../../helper-validator-identifier/lib/index.mjs";
-import "../../../helper-string-parser/lib/index.mjs";
-import "../constants/index.mjs";
-import { __require as h } from "./utils.mjs";
-import { __exports as P } from "../../../../../_virtual/isValidIdentifier.mjs";
-import { __exports as g } from "../../../../../_virtual/index18.mjs";
-import { __exports as I } from "../../../../../_virtual/index20.mjs";
-import { __exports as A } from "../../../../../_virtual/index12.mjs";
-var N;
-function M() {
-  if (N)
-    return p;
-  N = 1, Object.defineProperty(p, "__esModule", {
-    value: !0
-  }), p.patternLikeCommon = p.functionTypeAnnotationCommon = p.functionDeclarationCommon = p.functionCommon = p.classMethodOrPropertyCommon = p.classMethodOrDeclareMethodCommon = void 0;
-  var l = x(), b = P, m = g, S = I, v = A, e = h();
-  const t = (0, e.defineAliasedType)("Standardized");
-  t("ArrayExpression", {
-    fields: {
-      elements: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
-        default: process.env.BABEL_TYPES_8_BREAKING ? void 0 : []
-      }
-    },
-    visitor: ["elements"],
-    aliases: ["Expression"]
-  }), t("AssignmentExpression", {
-    fields: {
-      operator: {
-        validate: function() {
-          if (!process.env.BABEL_TYPES_8_BREAKING)
-            return (0, e.assertValueType)("string");
-          const r = (0, e.assertOneOf)(...v.ASSIGNMENT_OPERATORS), i = (0, e.assertOneOf)("=");
-          return function(a, s, o) {
-            ((0, l.default)("Pattern", a.left) ? i : r)(a, s, o);
-          };
-        }()
-      },
-      left: {
-        validate: process.env.BABEL_TYPES_8_BREAKING ? (0, e.assertNodeType)("Identifier", "MemberExpression", "OptionalMemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression") : (0, e.assertNodeType)("LVal", "OptionalMemberExpression")
-      },
-      right: {
-        validate: (0, e.assertNodeType)("Expression")
-      }
-    },
-    builder: ["operator", "left", "right"],
-    visitor: ["left", "right"],
-    aliases: ["Expression"]
-  }), t("BinaryExpression", {
-    builder: ["operator", "left", "right"],
-    fields: {
-      operator: {
-        validate: (0, e.assertOneOf)(...v.BINARY_OPERATORS)
-      },
-      left: {
-        validate: function() {
-          const r = (0, e.assertNodeType)("Expression"), i = (0, e.assertNodeType)("Expression", "PrivateName");
-          return Object.assign(function(s, o, n) {
-            (s.operator === "in" ? i : r)(s, o, n);
-          }, {
-            oneOfNodeTypes: ["Expression", "PrivateName"]
-          });
-        }()
-      },
-      right: {
-        validate: (0, e.assertNodeType)("Expression")
-      }
-    },
-    visitor: ["left", "right"],
-    aliases: ["Binary", "Expression"]
-  }), t("InterpreterDirective", {
-    builder: ["value"],
-    fields: {
-      value: {
-        validate: (0, e.assertValueType)("string")
-      }
-    }
-  }), t("Directive", {
-    visitor: ["value"],
-    fields: {
-      value: {
-        validate: (0, e.assertNodeType)("DirectiveLiteral")
-      }
-    }
-  }), t("DirectiveLiteral", {
-    builder: ["value"],
-    fields: {
-      value: {
-        validate: (0, e.assertValueType)("string")
-      }
-    }
-  }), t("BlockStatement", {
-    builder: ["body", "directives"],
-    visitor: ["directives", "body"],
-    fields: {
-      directives: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Directive"))),
-        default: []
-      },
-      body: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Statement")))
-      }
-    },
-    aliases: ["Scopable", "BlockParent", "Block", "Statement"]
-  }), t("BreakStatement", {
-    visitor: ["label"],
-    fields: {
-      label: {
-        validate: (0, e.assertNodeType)("Identifier"),
-        optional: !0
-      }
-    },
-    aliases: ["Statement", "Terminatorless", "CompletionStatement"]
-  }), t("CallExpression", {
-    visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
-    builder: ["callee", "arguments"],
-    aliases: ["Expression"],
-    fields: Object.assign({
-      callee: {
-        validate: (0, e.assertNodeType)("Expression", "Super", "V8IntrinsicIdentifier")
-      },
-      arguments: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Expression", "SpreadElement", "ArgumentPlaceholder")))
-      }
-    }, process.env.BABEL_TYPES_8_BREAKING ? {} : {
-      optional: {
-        validate: (0, e.assertOneOf)(!0, !1),
-        optional: !0
-      }
-    }, {
-      typeArguments: {
-        validate: (0, e.assertNodeType)("TypeParameterInstantiation"),
-        optional: !0
-      },
-      typeParameters: {
-        validate: (0, e.assertNodeType)("TSTypeParameterInstantiation"),
-        optional: !0
-      }
-    })
-  }), t("CatchClause", {
-    visitor: ["param", "body"],
-    fields: {
-      param: {
-        validate: (0, e.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"),
-        optional: !0
-      },
-      body: {
-        validate: (0, e.assertNodeType)("BlockStatement")
-      }
-    },
-    aliases: ["Scopable", "BlockParent"]
-  }), t("ConditionalExpression", {
-    visitor: ["test", "consequent", "alternate"],
-    fields: {
-      test: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      consequent: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      alternate: {
-        validate: (0, e.assertNodeType)("Expression")
-      }
-    },
-    aliases: ["Expression", "Conditional"]
-  }), t("ContinueStatement", {
-    visitor: ["label"],
-    fields: {
-      label: {
-        validate: (0, e.assertNodeType)("Identifier"),
-        optional: !0
-      }
-    },
-    aliases: ["Statement", "Terminatorless", "CompletionStatement"]
-  }), t("DebuggerStatement", {
-    aliases: ["Statement"]
-  }), t("DoWhileStatement", {
-    builder: ["test", "body"],
-    visitor: ["body", "test"],
-    fields: {
-      test: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      body: {
-        validate: (0, e.assertNodeType)("Statement")
-      }
-    },
-    aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]
-  }), t("EmptyStatement", {
-    aliases: ["Statement"]
-  }), t("ExpressionStatement", {
-    visitor: ["expression"],
-    fields: {
-      expression: {
-        validate: (0, e.assertNodeType)("Expression")
-      }
-    },
-    aliases: ["Statement", "ExpressionWrapper"]
-  }), t("File", {
-    builder: ["program", "comments", "tokens"],
-    visitor: ["program"],
-    fields: {
-      program: {
-        validate: (0, e.assertNodeType)("Program")
-      },
-      comments: {
-        validate: process.env.BABEL_TYPES_8_BREAKING ? (0, e.assertEach)((0, e.assertNodeType)("CommentBlock", "CommentLine")) : Object.assign(() => {
-        }, {
-          each: {
-            oneOfNodeTypes: ["CommentBlock", "CommentLine"]
-          }
-        }),
-        optional: !0
-      },
-      tokens: {
-        validate: (0, e.assertEach)(Object.assign(() => {
-        }, {
-          type: "any"
-        })),
-        optional: !0
-      }
-    }
-  }), t("ForInStatement", {
-    visitor: ["left", "right", "body"],
-    aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
-    fields: {
-      left: {
-        validate: process.env.BABEL_TYPES_8_BREAKING ? (0, e.assertNodeType)("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression") : (0, e.assertNodeType)("VariableDeclaration", "LVal")
-      },
-      right: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      body: {
-        validate: (0, e.assertNodeType)("Statement")
-      }
-    }
-  }), t("ForStatement", {
-    visitor: ["init", "test", "update", "body"],
-    aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"],
-    fields: {
-      init: {
-        validate: (0, e.assertNodeType)("VariableDeclaration", "Expression"),
-        optional: !0
-      },
-      test: {
-        validate: (0, e.assertNodeType)("Expression"),
-        optional: !0
-      },
-      update: {
-        validate: (0, e.assertNodeType)("Expression"),
-        optional: !0
-      },
-      body: {
-        validate: (0, e.assertNodeType)("Statement")
-      }
-    }
-  });
-  const c = () => ({
-    params: {
-      validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Identifier", "Pattern", "RestElement")))
-    },
-    generator: {
-      default: !1
-    },
-    async: {
-      default: !1
-    }
-  });
-  p.functionCommon = c;
-  const d = () => ({
-    returnType: {
-      validate: (0, e.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
-      optional: !0
-    },
-    typeParameters: {
-      validate: (0, e.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
-      optional: !0
-    }
-  });
-  p.functionTypeAnnotationCommon = d;
-  const E = () => Object.assign({}, c(), {
-    declare: {
-      validate: (0, e.assertValueType)("boolean"),
-      optional: !0
-    },
-    id: {
-      validate: (0, e.assertNodeType)("Identifier"),
-      optional: !0
-    }
-  });
-  p.functionDeclarationCommon = E, t("FunctionDeclaration", {
-    builder: ["id", "params", "body", "generator", "async"],
-    visitor: ["id", "typeParameters", "params", "returnType", "body"],
-    fields: Object.assign({}, E(), d(), {
-      body: {
-        validate: (0, e.assertNodeType)("BlockStatement")
-      },
-      predicate: {
-        validate: (0, e.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
-        optional: !0
-      }
-    }),
-    aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"],
-    validate: function() {
-      if (!process.env.BABEL_TYPES_8_BREAKING)
-        return () => {
-        };
-      const r = (0, e.assertNodeType)("Identifier");
-      return function(i, a, s) {
-        (0, l.default)("ExportDefaultDeclaration", i) || r(s, "id", s.id);
-      };
-    }()
-  }), t("FunctionExpression", {
-    inherits: "FunctionDeclaration",
-    aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
-    fields: Object.assign({}, c(), d(), {
-      id: {
-        validate: (0, e.assertNodeType)("Identifier"),
-        optional: !0
-      },
-      body: {
-        validate: (0, e.assertNodeType)("BlockStatement")
-      },
-      predicate: {
-        validate: (0, e.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
-        optional: !0
-      }
-    })
-  });
-  const u = () => ({
-    typeAnnotation: {
-      validate: (0, e.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
-      optional: !0
-    },
-    optional: {
-      validate: (0, e.assertValueType)("boolean"),
-      optional: !0
-    },
-    decorators: {
-      validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Decorator"))),
-      optional: !0
-    }
-  });
-  p.patternLikeCommon = u, t("Identifier", {
-    builder: ["name"],
-    visitor: ["typeAnnotation", "decorators"],
-    aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"],
-    fields: Object.assign({}, u(), {
-      name: {
-        validate: (0, e.chain)((0, e.assertValueType)("string"), Object.assign(function(r, i, a) {
-          if (process.env.BABEL_TYPES_8_BREAKING && !(0, b.default)(a, !1))
-            throw new TypeError(`"${a}" is not a valid identifier name`);
-        }, {
-          type: "string"
-        }))
-      }
-    }),
-    validate(r, i, a) {
-      if (!process.env.BABEL_TYPES_8_BREAKING)
-        return;
-      const s = /\.(\w+)$/.exec(i);
-      if (!s)
-        return;
-      const [, o] = s, n = {
-        computed: !1
-      };
-      if (o === "property") {
-        if ((0, l.default)("MemberExpression", r, n) || (0, l.default)("OptionalMemberExpression", r, n))
-          return;
-      } else if (o === "key") {
-        if ((0, l.default)("Property", r, n) || (0, l.default)("Method", r, n))
-          return;
-      } else if (o === "exported") {
-        if ((0, l.default)("ExportSpecifier", r))
-          return;
-      } else if (o === "imported") {
-        if ((0, l.default)("ImportSpecifier", r, {
-          imported: a
-        }))
-          return;
-      } else if (o === "meta" && (0, l.default)("MetaProperty", r, {
-        meta: a
-      }))
-        return;
-      if (((0, m.isKeyword)(a.name) || (0, m.isReservedWord)(a.name, !1)) && a.name !== "this")
-        throw new TypeError(`"${a.name}" is not a valid identifier`);
-    }
-  }), t("IfStatement", {
-    visitor: ["test", "consequent", "alternate"],
-    aliases: ["Statement", "Conditional"],
-    fields: {
-      test: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      consequent: {
-        validate: (0, e.assertNodeType)("Statement")
-      },
-      alternate: {
-        optional: !0,
-        validate: (0, e.assertNodeType)("Statement")
-      }
-    }
-  }), t("LabeledStatement", {
-    visitor: ["label", "body"],
-    aliases: ["Statement"],
-    fields: {
-      label: {
-        validate: (0, e.assertNodeType)("Identifier")
-      },
-      body: {
-        validate: (0, e.assertNodeType)("Statement")
-      }
-    }
-  }), t("StringLiteral", {
-    builder: ["value"],
-    fields: {
-      value: {
-        validate: (0, e.assertValueType)("string")
-      }
-    },
-    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
-  }), t("NumericLiteral", {
-    builder: ["value"],
-    deprecatedAlias: "NumberLiteral",
-    fields: {
-      value: {
-        validate: (0, e.chain)((0, e.assertValueType)("number"), Object.assign(function(r, i, a) {
-        }, {
-          type: "number"
-        }))
-      }
-    },
-    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
-  }), t("NullLiteral", {
-    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
-  }), t("BooleanLiteral", {
-    builder: ["value"],
-    fields: {
-      value: {
-        validate: (0, e.assertValueType)("boolean")
-      }
-    },
-    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
-  }), t("RegExpLiteral", {
-    builder: ["pattern", "flags"],
-    deprecatedAlias: "RegexLiteral",
-    aliases: ["Expression", "Pureish", "Literal"],
-    fields: {
-      pattern: {
-        validate: (0, e.assertValueType)("string")
-      },
-      flags: {
-        validate: (0, e.chain)((0, e.assertValueType)("string"), Object.assign(function(r, i, a) {
-          if (!process.env.BABEL_TYPES_8_BREAKING)
-            return;
-          const s = /[^gimsuy]/.exec(a);
-          if (s)
-            throw new TypeError(`"${s[0]}" is not a valid RegExp flag`);
-        }, {
-          type: "string"
-        })),
-        default: ""
-      }
-    }
-  }), t("LogicalExpression", {
-    builder: ["operator", "left", "right"],
-    visitor: ["left", "right"],
-    aliases: ["Binary", "Expression"],
-    fields: {
-      operator: {
-        validate: (0, e.assertOneOf)(...v.LOGICAL_OPERATORS)
-      },
-      left: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      right: {
-        validate: (0, e.assertNodeType)("Expression")
-      }
-    }
-  }), t("MemberExpression", {
-    builder: ["object", "property", "computed", ...process.env.BABEL_TYPES_8_BREAKING ? [] : ["optional"]],
-    visitor: ["object", "property"],
-    aliases: ["Expression", "LVal"],
-    fields: Object.assign({
-      object: {
-        validate: (0, e.assertNodeType)("Expression", "Super")
-      },
-      property: {
-        validate: function() {
-          const r = (0, e.assertNodeType)("Identifier", "PrivateName"), i = (0, e.assertNodeType)("Expression"), a = function(s, o, n) {
-            (s.computed ? i : r)(s, o, n);
-          };
-          return a.oneOfNodeTypes = ["Expression", "Identifier", "PrivateName"], a;
-        }()
-      },
-      computed: {
-        default: !1
-      }
-    }, process.env.BABEL_TYPES_8_BREAKING ? {} : {
-      optional: {
-        validate: (0, e.assertOneOf)(!0, !1),
-        optional: !0
-      }
-    })
-  }), t("NewExpression", {
-    inherits: "CallExpression"
-  }), t("Program", {
-    visitor: ["directives", "body"],
-    builder: ["body", "directives", "sourceType", "interpreter"],
-    fields: {
-      sourceType: {
-        validate: (0, e.assertOneOf)("script", "module"),
-        default: "script"
-      },
-      interpreter: {
-        validate: (0, e.assertNodeType)("InterpreterDirective"),
-        default: null,
-        optional: !0
-      },
-      directives: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Directive"))),
-        default: []
-      },
-      body: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Statement")))
-      }
-    },
-    aliases: ["Scopable", "BlockParent", "Block"]
-  }), t("ObjectExpression", {
-    visitor: ["properties"],
-    aliases: ["Expression"],
-    fields: {
-      properties: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement")))
-      }
-    }
-  }), t("ObjectMethod", {
-    builder: ["kind", "key", "params", "body", "computed", "generator", "async"],
-    visitor: ["decorators", "key", "typeParameters", "params", "returnType", "body"],
-    fields: Object.assign({}, c(), d(), {
-      kind: Object.assign({
-        validate: (0, e.assertOneOf)("method", "get", "set")
-      }, process.env.BABEL_TYPES_8_BREAKING ? {} : {
-        default: "method"
-      }),
-      computed: {
-        default: !1
-      },
-      key: {
-        validate: function() {
-          const r = (0, e.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"), i = (0, e.assertNodeType)("Expression"), a = function(s, o, n) {
-            (s.computed ? i : r)(s, o, n);
-          };
-          return a.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"], a;
-        }()
-      },
-      decorators: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Decorator"))),
-        optional: !0
-      },
-      body: {
-        validate: (0, e.assertNodeType)("BlockStatement")
-      }
-    }),
-    aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"]
-  }), t("ObjectProperty", {
-    builder: ["key", "value", "computed", "shorthand", ...process.env.BABEL_TYPES_8_BREAKING ? [] : ["decorators"]],
-    fields: {
-      computed: {
-        default: !1
-      },
-      key: {
-        validate: function() {
-          const r = (0, e.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName"), i = (0, e.assertNodeType)("Expression");
-          return Object.assign(function(s, o, n) {
-            (s.computed ? i : r)(s, o, n);
-          }, {
-            oneOfNodeTypes: ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName"]
-          });
-        }()
-      },
-      value: {
-        validate: (0, e.assertNodeType)("Expression", "PatternLike")
-      },
-      shorthand: {
-        validate: (0, e.chain)((0, e.assertValueType)("boolean"), Object.assign(function(r, i, a) {
-          if (process.env.BABEL_TYPES_8_BREAKING && a && r.computed)
-            throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true");
-        }, {
-          type: "boolean"
-        }), function(r, i, a) {
-          if (process.env.BABEL_TYPES_8_BREAKING && a && !(0, l.default)("Identifier", r.key))
-            throw new TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier");
-        }),
-        default: !1
-      },
-      decorators: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Decorator"))),
-        optional: !0
-      }
-    },
-    visitor: ["key", "value", "decorators"],
-    aliases: ["UserWhitespacable", "Property", "ObjectMember"],
-    validate: function() {
-      const r = (0, e.assertNodeType)("Identifier", "Pattern", "TSAsExpression", "TSSatisfiesExpression", "TSNonNullExpression", "TSTypeAssertion"), i = (0, e.assertNodeType)("Expression");
-      return function(a, s, o) {
-        if (!process.env.BABEL_TYPES_8_BREAKING)
-          return;
-        ((0, l.default)("ObjectPattern", a) ? r : i)(o, "value", o.value);
-      };
-    }()
-  }), t("RestElement", {
-    visitor: ["argument", "typeAnnotation"],
-    builder: ["argument"],
-    aliases: ["LVal", "PatternLike"],
-    deprecatedAlias: "RestProperty",
-    fields: Object.assign({}, u(), {
-      argument: {
-        validate: process.env.BABEL_TYPES_8_BREAKING ? (0, e.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression") : (0, e.assertNodeType)("LVal")
-      }
-    }),
-    validate(r, i) {
-      if (!process.env.BABEL_TYPES_8_BREAKING)
-        return;
-      const a = /(\w+)\[(\d+)\]/.exec(i);
-      if (!a)
-        throw new Error("Internal Babel error: malformed key.");
-      const [, s, o] = a;
-      if (r[s].length > +o + 1)
-        throw new TypeError(`RestElement must be last element of ${s}`);
-    }
-  }), t("ReturnStatement", {
-    visitor: ["argument"],
-    aliases: ["Statement", "Terminatorless", "CompletionStatement"],
-    fields: {
-      argument: {
-        validate: (0, e.assertNodeType)("Expression"),
-        optional: !0
-      }
-    }
-  }), t("SequenceExpression", {
-    visitor: ["expressions"],
-    fields: {
-      expressions: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Expression")))
-      }
-    },
-    aliases: ["Expression"]
-  }), t("ParenthesizedExpression", {
-    visitor: ["expression"],
-    aliases: ["Expression", "ExpressionWrapper"],
-    fields: {
-      expression: {
-        validate: (0, e.assertNodeType)("Expression")
-      }
-    }
-  }), t("SwitchCase", {
-    visitor: ["test", "consequent"],
-    fields: {
-      test: {
-        validate: (0, e.assertNodeType)("Expression"),
-        optional: !0
-      },
-      consequent: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Statement")))
-      }
-    }
-  }), t("SwitchStatement", {
-    visitor: ["discriminant", "cases"],
-    aliases: ["Statement", "BlockParent", "Scopable"],
-    fields: {
-      discriminant: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      cases: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("SwitchCase")))
-      }
-    }
-  }), t("ThisExpression", {
-    aliases: ["Expression"]
-  }), t("ThrowStatement", {
-    visitor: ["argument"],
-    aliases: ["Statement", "Terminatorless", "CompletionStatement"],
-    fields: {
-      argument: {
-        validate: (0, e.assertNodeType)("Expression")
-      }
-    }
-  }), t("TryStatement", {
-    visitor: ["block", "handler", "finalizer"],
-    aliases: ["Statement"],
-    fields: {
-      block: {
-        validate: (0, e.chain)((0, e.assertNodeType)("BlockStatement"), Object.assign(function(r) {
-          if (process.env.BABEL_TYPES_8_BREAKING && !r.handler && !r.finalizer)
-            throw new TypeError("TryStatement expects either a handler or finalizer, or both");
-        }, {
-          oneOfNodeTypes: ["BlockStatement"]
-        }))
-      },
-      handler: {
-        optional: !0,
-        validate: (0, e.assertNodeType)("CatchClause")
-      },
-      finalizer: {
-        optional: !0,
-        validate: (0, e.assertNodeType)("BlockStatement")
-      }
-    }
-  }), t("UnaryExpression", {
-    builder: ["operator", "argument", "prefix"],
-    fields: {
-      prefix: {
-        default: !0
-      },
-      argument: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      operator: {
-        validate: (0, e.assertOneOf)(...v.UNARY_OPERATORS)
-      }
-    },
-    visitor: ["argument"],
-    aliases: ["UnaryLike", "Expression"]
-  }), t("UpdateExpression", {
-    builder: ["operator", "argument", "prefix"],
-    fields: {
-      prefix: {
-        default: !1
-      },
-      argument: {
-        validate: process.env.BABEL_TYPES_8_BREAKING ? (0, e.assertNodeType)("Identifier", "MemberExpression") : (0, e.assertNodeType)("Expression")
-      },
-      operator: {
-        validate: (0, e.assertOneOf)(...v.UPDATE_OPERATORS)
-      }
-    },
-    visitor: ["argument"],
-    aliases: ["Expression"]
-  }), t("VariableDeclaration", {
-    builder: ["kind", "declarations"],
-    visitor: ["declarations"],
-    aliases: ["Statement", "Declaration"],
-    fields: {
-      declare: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      kind: {
-        validate: (0, e.assertOneOf)("var", "let", "const", "using", "await using")
-      },
-      declarations: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("VariableDeclarator")))
-      }
-    },
-    validate(r, i, a) {
-      if (process.env.BABEL_TYPES_8_BREAKING && (0, l.default)("ForXStatement", r, {
-        left: a
-      }) && a.declarations.length !== 1)
-        throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${r.type}`);
-    }
-  }), t("VariableDeclarator", {
-    visitor: ["id", "init"],
-    fields: {
-      id: {
-        validate: function() {
-          if (!process.env.BABEL_TYPES_8_BREAKING)
-            return (0, e.assertNodeType)("LVal");
-          const r = (0, e.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"), i = (0, e.assertNodeType)("Identifier");
-          return function(a, s, o) {
-            (a.init ? r : i)(a, s, o);
-          };
-        }()
-      },
-      definite: {
-        optional: !0,
-        validate: (0, e.assertValueType)("boolean")
-      },
-      init: {
-        optional: !0,
-        validate: (0, e.assertNodeType)("Expression")
-      }
-    }
-  }), t("WhileStatement", {
-    visitor: ["test", "body"],
-    aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"],
-    fields: {
-      test: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      body: {
-        validate: (0, e.assertNodeType)("Statement")
-      }
-    }
-  }), t("WithStatement", {
-    visitor: ["object", "body"],
-    aliases: ["Statement"],
-    fields: {
-      object: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      body: {
-        validate: (0, e.assertNodeType)("Statement")
-      }
-    }
-  }), t("AssignmentPattern", {
-    visitor: ["left", "right", "decorators"],
-    builder: ["left", "right"],
-    aliases: ["Pattern", "PatternLike", "LVal"],
-    fields: Object.assign({}, u(), {
-      left: {
-        validate: (0, e.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
-      },
-      right: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      decorators: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Decorator"))),
-        optional: !0
-      }
-    })
-  }), t("ArrayPattern", {
-    visitor: ["elements", "typeAnnotation"],
-    builder: ["elements"],
-    aliases: ["Pattern", "PatternLike", "LVal"],
-    fields: Object.assign({}, u(), {
-      elements: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeOrValueType)("null", "PatternLike", "LVal")))
-      }
-    })
-  }), t("ArrowFunctionExpression", {
-    builder: ["params", "body", "async"],
-    visitor: ["typeParameters", "params", "returnType", "body"],
-    aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
-    fields: Object.assign({}, c(), d(), {
-      expression: {
-        validate: (0, e.assertValueType)("boolean")
-      },
-      body: {
-        validate: (0, e.assertNodeType)("BlockStatement", "Expression")
-      },
-      predicate: {
-        validate: (0, e.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
-        optional: !0
-      }
-    })
-  }), t("ClassBody", {
-    visitor: ["body"],
-    fields: {
-      body: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "ClassAccessorProperty", "TSDeclareMethod", "TSIndexSignature", "StaticBlock")))
-      }
-    }
-  }), t("ClassExpression", {
-    builder: ["id", "superClass", "body", "decorators"],
-    visitor: ["decorators", "id", "typeParameters", "superClass", "superTypeParameters", "mixins", "implements", "body"],
-    aliases: ["Scopable", "Class", "Expression"],
-    fields: {
-      id: {
-        validate: (0, e.assertNodeType)("Identifier"),
-        optional: !0
-      },
-      typeParameters: {
-        validate: (0, e.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
-        optional: !0
-      },
-      body: {
-        validate: (0, e.assertNodeType)("ClassBody")
-      },
-      superClass: {
-        optional: !0,
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      superTypeParameters: {
-        validate: (0, e.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
-        optional: !0
-      },
-      implements: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
-        optional: !0
-      },
-      decorators: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Decorator"))),
-        optional: !0
-      },
-      mixins: {
-        validate: (0, e.assertNodeType)("InterfaceExtends"),
-        optional: !0
-      }
-    }
-  }), t("ClassDeclaration", {
-    inherits: "ClassExpression",
-    aliases: ["Scopable", "Class", "Statement", "Declaration"],
-    fields: {
-      id: {
-        validate: (0, e.assertNodeType)("Identifier"),
-        optional: !0
-      },
-      typeParameters: {
-        validate: (0, e.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
-        optional: !0
-      },
-      body: {
-        validate: (0, e.assertNodeType)("ClassBody")
-      },
-      superClass: {
-        optional: !0,
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      superTypeParameters: {
-        validate: (0, e.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
-        optional: !0
-      },
-      implements: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
-        optional: !0
-      },
-      decorators: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Decorator"))),
-        optional: !0
-      },
-      mixins: {
-        validate: (0, e.assertNodeType)("InterfaceExtends"),
-        optional: !0
-      },
-      declare: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      abstract: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      }
-    },
-    validate: function() {
-      const r = (0, e.assertNodeType)("Identifier");
-      return function(i, a, s) {
-        process.env.BABEL_TYPES_8_BREAKING && ((0, l.default)("ExportDefaultDeclaration", i) || r(s, "id", s.id));
-      };
-    }()
-  }), t("ExportAllDeclaration", {
-    builder: ["source"],
-    visitor: ["source", "attributes", "assertions"],
-    aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"],
-    fields: {
-      source: {
-        validate: (0, e.assertNodeType)("StringLiteral")
-      },
-      exportKind: (0, e.validateOptional)((0, e.assertOneOf)("type", "value")),
-      attributes: {
-        optional: !0,
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("ImportAttribute")))
-      },
-      assertions: {
-        optional: !0,
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("ImportAttribute")))
-      }
-    }
-  }), t("ExportDefaultDeclaration", {
-    visitor: ["declaration"],
-    aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"],
-    fields: {
-      declaration: {
-        validate: (0, e.assertNodeType)("TSDeclareFunction", "FunctionDeclaration", "ClassDeclaration", "Expression")
-      },
-      exportKind: (0, e.validateOptional)((0, e.assertOneOf)("value"))
-    }
-  }), t("ExportNamedDeclaration", {
-    builder: ["declaration", "specifiers", "source"],
-    visitor: ["declaration", "specifiers", "source", "attributes", "assertions"],
-    aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"],
-    fields: {
-      declaration: {
-        optional: !0,
-        validate: (0, e.chain)((0, e.assertNodeType)("Declaration"), Object.assign(function(r, i, a) {
-          if (process.env.BABEL_TYPES_8_BREAKING && a && r.specifiers.length)
-            throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration");
-        }, {
-          oneOfNodeTypes: ["Declaration"]
-        }), function(r, i, a) {
-          if (process.env.BABEL_TYPES_8_BREAKING && a && r.source)
-            throw new TypeError("Cannot export a declaration from a source");
-        })
-      },
-      attributes: {
-        optional: !0,
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("ImportAttribute")))
-      },
-      assertions: {
-        optional: !0,
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("ImportAttribute")))
-      },
-      specifiers: {
-        default: [],
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)(function() {
-          const r = (0, e.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier"), i = (0, e.assertNodeType)("ExportSpecifier");
-          return process.env.BABEL_TYPES_8_BREAKING ? function(a, s, o) {
-            (a.source ? r : i)(a, s, o);
-          } : r;
-        }()))
-      },
-      source: {
-        validate: (0, e.assertNodeType)("StringLiteral"),
-        optional: !0
-      },
-      exportKind: (0, e.validateOptional)((0, e.assertOneOf)("type", "value"))
-    }
-  }), t("ExportSpecifier", {
-    visitor: ["local", "exported"],
-    aliases: ["ModuleSpecifier"],
-    fields: {
-      local: {
-        validate: (0, e.assertNodeType)("Identifier")
-      },
-      exported: {
-        validate: (0, e.assertNodeType)("Identifier", "StringLiteral")
-      },
-      exportKind: {
-        validate: (0, e.assertOneOf)("type", "value"),
-        optional: !0
-      }
-    }
-  }), t("ForOfStatement", {
-    visitor: ["left", "right", "body"],
-    builder: ["left", "right", "body", "await"],
-    aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
-    fields: {
-      left: {
-        validate: function() {
-          if (!process.env.BABEL_TYPES_8_BREAKING)
-            return (0, e.assertNodeType)("VariableDeclaration", "LVal");
-          const r = (0, e.assertNodeType)("VariableDeclaration"), i = (0, e.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression");
-          return function(a, s, o) {
-            (0, l.default)("VariableDeclaration", o) ? r(a, s, o) : i(a, s, o);
-          };
-        }()
-      },
-      right: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      body: {
-        validate: (0, e.assertNodeType)("Statement")
-      },
-      await: {
-        default: !1
-      }
-    }
-  }), t("ImportDeclaration", {
-    builder: ["specifiers", "source"],
-    visitor: ["specifiers", "source", "attributes", "assertions"],
-    aliases: ["Statement", "Declaration", "ImportOrExportDeclaration"],
-    fields: {
-      attributes: {
-        optional: !0,
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("ImportAttribute")))
-      },
-      assertions: {
-        optional: !0,
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("ImportAttribute")))
-      },
-      module: {
-        optional: !0,
-        validate: (0, e.assertValueType)("boolean")
-      },
-      phase: {
-        default: null,
-        validate: (0, e.assertOneOf)("source", "defer")
-      },
-      specifiers: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier")))
-      },
-      source: {
-        validate: (0, e.assertNodeType)("StringLiteral")
-      },
-      importKind: {
-        validate: (0, e.assertOneOf)("type", "typeof", "value"),
-        optional: !0
-      }
-    }
-  }), t("ImportDefaultSpecifier", {
-    visitor: ["local"],
-    aliases: ["ModuleSpecifier"],
-    fields: {
-      local: {
-        validate: (0, e.assertNodeType)("Identifier")
-      }
-    }
-  }), t("ImportNamespaceSpecifier", {
-    visitor: ["local"],
-    aliases: ["ModuleSpecifier"],
-    fields: {
-      local: {
-        validate: (0, e.assertNodeType)("Identifier")
-      }
-    }
-  }), t("ImportSpecifier", {
-    visitor: ["imported", "local"],
-    builder: ["local", "imported"],
-    aliases: ["ModuleSpecifier"],
-    fields: {
-      local: {
-        validate: (0, e.assertNodeType)("Identifier")
-      },
-      imported: {
-        validate: (0, e.assertNodeType)("Identifier", "StringLiteral")
-      },
-      importKind: {
-        validate: (0, e.assertOneOf)("type", "typeof", "value"),
-        optional: !0
-      }
-    }
-  }), t("ImportExpression", {
-    visitor: ["source", "options"],
-    aliases: ["Expression"],
-    fields: {
-      phase: {
-        default: null,
-        validate: (0, e.assertOneOf)("source", "defer")
-      },
-      source: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      options: {
-        validate: (0, e.assertNodeType)("Expression"),
-        optional: !0
-      }
-    }
-  }), t("MetaProperty", {
-    visitor: ["meta", "property"],
-    aliases: ["Expression"],
-    fields: {
-      meta: {
-        validate: (0, e.chain)((0, e.assertNodeType)("Identifier"), Object.assign(function(r, i, a) {
-          if (!process.env.BABEL_TYPES_8_BREAKING)
-            return;
-          let s;
-          switch (a.name) {
-            case "function":
-              s = "sent";
-              break;
-            case "new":
-              s = "target";
-              break;
-            case "import":
-              s = "meta";
-              break;
-          }
-          if (!(0, l.default)("Identifier", r.property, {
-            name: s
-          }))
-            throw new TypeError("Unrecognised MetaProperty");
-        }, {
-          oneOfNodeTypes: ["Identifier"]
-        }))
-      },
-      property: {
-        validate: (0, e.assertNodeType)("Identifier")
-      }
-    }
-  });
-  const f = () => ({
-    abstract: {
-      validate: (0, e.assertValueType)("boolean"),
-      optional: !0
-    },
-    accessibility: {
-      validate: (0, e.assertOneOf)("public", "private", "protected"),
-      optional: !0
-    },
-    static: {
-      default: !1
-    },
-    override: {
-      default: !1
-    },
-    computed: {
-      default: !1
-    },
-    optional: {
-      validate: (0, e.assertValueType)("boolean"),
-      optional: !0
-    },
-    key: {
-      validate: (0, e.chain)(function() {
-        const r = (0, e.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"), i = (0, e.assertNodeType)("Expression");
-        return function(a, s, o) {
-          (a.computed ? i : r)(a, s, o);
-        };
-      }(), (0, e.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression"))
-    }
-  });
-  p.classMethodOrPropertyCommon = f;
-  const T = () => Object.assign({}, c(), f(), {
-    params: {
-      validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty")))
-    },
-    kind: {
-      validate: (0, e.assertOneOf)("get", "set", "method", "constructor"),
-      default: "method"
-    },
-    access: {
-      validate: (0, e.chain)((0, e.assertValueType)("string"), (0, e.assertOneOf)("public", "private", "protected")),
-      optional: !0
-    },
-    decorators: {
-      validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Decorator"))),
-      optional: !0
-    }
-  });
-  return p.classMethodOrDeclareMethodCommon = T, t("ClassMethod", {
-    aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
-    builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"],
-    visitor: ["decorators", "key", "typeParameters", "params", "returnType", "body"],
-    fields: Object.assign({}, T(), d(), {
-      body: {
-        validate: (0, e.assertNodeType)("BlockStatement")
-      }
-    })
-  }), t("ObjectPattern", {
-    visitor: ["properties", "typeAnnotation", "decorators"],
-    builder: ["properties"],
-    aliases: ["Pattern", "PatternLike", "LVal"],
-    fields: Object.assign({}, u(), {
-      properties: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("RestElement", "ObjectProperty")))
-      }
-    })
-  }), t("SpreadElement", {
-    visitor: ["argument"],
-    aliases: ["UnaryLike"],
-    deprecatedAlias: "SpreadProperty",
-    fields: {
-      argument: {
-        validate: (0, e.assertNodeType)("Expression")
-      }
-    }
-  }), t("Super", {
-    aliases: ["Expression"]
-  }), t("TaggedTemplateExpression", {
-    visitor: ["tag", "typeParameters", "quasi"],
-    builder: ["tag", "quasi"],
-    aliases: ["Expression"],
-    fields: {
-      tag: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      quasi: {
-        validate: (0, e.assertNodeType)("TemplateLiteral")
-      },
-      typeParameters: {
-        validate: (0, e.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
-        optional: !0
-      }
-    }
-  }), t("TemplateElement", {
-    builder: ["value", "tail"],
-    fields: {
-      value: {
-        validate: (0, e.chain)((0, e.assertShape)({
-          raw: {
-            validate: (0, e.assertValueType)("string")
-          },
-          cooked: {
-            validate: (0, e.assertValueType)("string"),
-            optional: !0
-          }
-        }), function(i) {
-          const a = i.value.raw;
-          let s = !1;
-          const o = () => {
-            throw new Error("Internal @babel/types error.");
-          }, {
-            str: n,
-            firstInvalidLoc: y
-          } = (0, S.readStringContents)("template", a, 0, 0, 0, {
-            unterminated() {
-              s = !0;
-            },
-            strictNumericEscape: o,
-            invalidEscapeSequence: o,
-            numericSeparatorInEscapeSequence: o,
-            unexpectedNumericSeparator: o,
-            invalidDigit: o,
-            invalidCodePoint: o
-          });
-          if (!s)
-            throw new Error("Invalid raw");
-          i.value.cooked = y ? null : n;
-        })
-      },
-      tail: {
-        default: !1
-      }
-    }
-  }), t("TemplateLiteral", {
-    visitor: ["quasis", "expressions"],
-    aliases: ["Expression", "Literal"],
-    fields: {
-      quasis: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("TemplateElement")))
-      },
-      expressions: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Expression", "TSType")), function(r, i, a) {
-          if (r.quasis.length !== a.length + 1)
-            throw new TypeError(`Number of ${r.type} quasis should be exactly one more than the number of expressions.
-Expected ${a.length + 1} quasis but got ${r.quasis.length}`);
-        })
-      }
-    }
-  }), t("YieldExpression", {
-    builder: ["argument", "delegate"],
-    visitor: ["argument"],
-    aliases: ["Expression", "Terminatorless"],
-    fields: {
-      delegate: {
-        validate: (0, e.chain)((0, e.assertValueType)("boolean"), Object.assign(function(r, i, a) {
-          if (process.env.BABEL_TYPES_8_BREAKING && a && !r.argument)
-            throw new TypeError("Property delegate of YieldExpression cannot be true if there is no argument");
-        }, {
-          type: "boolean"
-        })),
-        default: !1
-      },
-      argument: {
-        optional: !0,
-        validate: (0, e.assertNodeType)("Expression")
-      }
-    }
-  }), t("AwaitExpression", {
-    builder: ["argument"],
-    visitor: ["argument"],
-    aliases: ["Expression", "Terminatorless"],
-    fields: {
-      argument: {
-        validate: (0, e.assertNodeType)("Expression")
-      }
-    }
-  }), t("Import", {
-    aliases: ["Expression"]
-  }), t("BigIntLiteral", {
-    builder: ["value"],
-    fields: {
-      value: {
-        validate: (0, e.assertValueType)("string")
-      }
-    },
-    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
-  }), t("ExportNamespaceSpecifier", {
-    visitor: ["exported"],
-    aliases: ["ModuleSpecifier"],
-    fields: {
-      exported: {
-        validate: (0, e.assertNodeType)("Identifier")
-      }
-    }
-  }), t("OptionalMemberExpression", {
-    builder: ["object", "property", "computed", "optional"],
-    visitor: ["object", "property"],
-    aliases: ["Expression"],
-    fields: {
-      object: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      property: {
-        validate: function() {
-          const r = (0, e.assertNodeType)("Identifier"), i = (0, e.assertNodeType)("Expression");
-          return Object.assign(function(s, o, n) {
-            (s.computed ? i : r)(s, o, n);
-          }, {
-            oneOfNodeTypes: ["Expression", "Identifier"]
-          });
-        }()
-      },
-      computed: {
-        default: !1
-      },
-      optional: {
-        validate: process.env.BABEL_TYPES_8_BREAKING ? (0, e.chain)((0, e.assertValueType)("boolean"), (0, e.assertOptionalChainStart)()) : (0, e.assertValueType)("boolean")
-      }
-    }
-  }), t("OptionalCallExpression", {
-    visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
-    builder: ["callee", "arguments", "optional"],
-    aliases: ["Expression"],
-    fields: {
-      callee: {
-        validate: (0, e.assertNodeType)("Expression")
-      },
-      arguments: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Expression", "SpreadElement", "ArgumentPlaceholder")))
-      },
-      optional: {
-        validate: process.env.BABEL_TYPES_8_BREAKING ? (0, e.chain)((0, e.assertValueType)("boolean"), (0, e.assertOptionalChainStart)()) : (0, e.assertValueType)("boolean")
-      },
-      typeArguments: {
-        validate: (0, e.assertNodeType)("TypeParameterInstantiation"),
-        optional: !0
-      },
-      typeParameters: {
-        validate: (0, e.assertNodeType)("TSTypeParameterInstantiation"),
-        optional: !0
-      }
-    }
-  }), t("ClassProperty", {
-    visitor: ["decorators", "key", "typeAnnotation", "value"],
-    builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
-    aliases: ["Property"],
-    fields: Object.assign({}, f(), {
-      value: {
-        validate: (0, e.assertNodeType)("Expression"),
-        optional: !0
-      },
-      definite: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      typeAnnotation: {
-        validate: (0, e.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
-        optional: !0
-      },
-      decorators: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Decorator"))),
-        optional: !0
-      },
-      readonly: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      declare: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      variance: {
-        validate: (0, e.assertNodeType)("Variance"),
-        optional: !0
-      }
-    })
-  }), t("ClassAccessorProperty", {
-    visitor: ["decorators", "key", "typeAnnotation", "value"],
-    builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
-    aliases: ["Property", "Accessor"],
-    fields: Object.assign({}, f(), {
-      key: {
-        validate: (0, e.chain)(function() {
-          const r = (0, e.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName"), i = (0, e.assertNodeType)("Expression");
-          return function(a, s, o) {
-            (a.computed ? i : r)(a, s, o);
-          };
-        }(), (0, e.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression", "PrivateName"))
-      },
-      value: {
-        validate: (0, e.assertNodeType)("Expression"),
-        optional: !0
-      },
-      definite: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      typeAnnotation: {
-        validate: (0, e.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
-        optional: !0
-      },
-      decorators: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Decorator"))),
-        optional: !0
-      },
-      readonly: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      declare: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      variance: {
-        validate: (0, e.assertNodeType)("Variance"),
-        optional: !0
-      }
-    })
-  }), t("ClassPrivateProperty", {
-    visitor: ["decorators", "key", "typeAnnotation", "value"],
-    builder: ["key", "value", "decorators", "static"],
-    aliases: ["Property", "Private"],
-    fields: {
-      key: {
-        validate: (0, e.assertNodeType)("PrivateName")
-      },
-      value: {
-        validate: (0, e.assertNodeType)("Expression"),
-        optional: !0
-      },
-      typeAnnotation: {
-        validate: (0, e.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
-        optional: !0
-      },
-      decorators: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Decorator"))),
-        optional: !0
-      },
-      static: {
-        validate: (0, e.assertValueType)("boolean"),
-        default: !1
-      },
-      readonly: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      definite: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      variance: {
-        validate: (0, e.assertNodeType)("Variance"),
-        optional: !0
-      }
-    }
-  }), t("ClassPrivateMethod", {
-    builder: ["kind", "key", "params", "body", "static"],
-    visitor: ["decorators", "key", "typeParameters", "params", "returnType", "body"],
-    aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"],
-    fields: Object.assign({}, T(), d(), {
-      kind: {
-        validate: (0, e.assertOneOf)("get", "set", "method"),
-        default: "method"
-      },
-      key: {
-        validate: (0, e.assertNodeType)("PrivateName")
-      },
-      body: {
-        validate: (0, e.assertNodeType)("BlockStatement")
-      }
-    })
-  }), t("PrivateName", {
-    visitor: ["id"],
-    aliases: ["Private"],
-    fields: {
-      id: {
-        validate: (0, e.assertNodeType)("Identifier")
-      }
-    }
-  }), t("StaticBlock", {
-    visitor: ["body"],
-    fields: {
-      body: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Statement")))
-      }
-    },
-    aliases: ["Scopable", "BlockParent", "FunctionParent"]
-  }), p;
-}
-export {
-  M as __require
-};