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

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

@@ -0,0 +1,1556 @@
+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
+};