import { __exports as p } from "../../../../../../../../_virtual/core.js";
import { __require as S } from "../validators/is.js";
import "../validators/isValidIdentifier.js";
import "../../../../../../@babel_helper-validator-identifier@7.18.6/node_modules/@babel/helper-validator-identifier/lib/index.js";
import "../constants/index.js";
import { __require as h } from "./utils.js";
import { __exports as x } from "../../../../../../../../_virtual/isValidIdentifier.js";
import { __exports as P } from "../../../../../../../../_virtual/index25.js";
import { __exports as g } from "../../../../../../../../_virtual/index34.js";
var N;
function C() {
  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 = S(), b = x, m = P, y = g, e = h();
  const a = (0, e.defineAliasedType)("Standardized");
  a("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"]
  }), a("AssignmentExpression", {
    fields: {
      operator: {
        validate: function() {
          if (!process.env.BABEL_TYPES_8_BREAKING)
            return (0, e.assertValueType)("string");
          const r = (0, e.assertOneOf)(...y.ASSIGNMENT_OPERATORS), i = (0, e.assertOneOf)("=");
          return function(t, s, o) {
            ((0, l.default)("Pattern", t.left) ? i : r)(t, s, o);
          };
        }()
      },
      left: {
        validate: process.env.BABEL_TYPES_8_BREAKING ? (0, e.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression") : (0, e.assertNodeType)("LVal")
      },
      right: {
        validate: (0, e.assertNodeType)("Expression")
      }
    },
    builder: ["operator", "left", "right"],
    visitor: ["left", "right"],
    aliases: ["Expression"]
  }), a("BinaryExpression", {
    builder: ["operator", "left", "right"],
    fields: {
      operator: {
        validate: (0, e.assertOneOf)(...y.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"]
  }), a("InterpreterDirective", {
    builder: ["value"],
    fields: {
      value: {
        validate: (0, e.assertValueType)("string")
      }
    }
  }), a("Directive", {
    visitor: ["value"],
    fields: {
      value: {
        validate: (0, e.assertNodeType)("DirectiveLiteral")
      }
    }
  }), a("DirectiveLiteral", {
    builder: ["value"],
    fields: {
      value: {
        validate: (0, e.assertValueType)("string")
      }
    }
  }), a("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"]
  }), a("BreakStatement", {
    visitor: ["label"],
    fields: {
      label: {
        validate: (0, e.assertNodeType)("Identifier"),
        optional: !0
      }
    },
    aliases: ["Statement", "Terminatorless", "CompletionStatement"]
  }), a("CallExpression", {
    visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
    builder: ["callee", "arguments"],
    aliases: ["Expression"],
    fields: Object.assign({
      callee: {
        validate: (0, e.assertNodeType)("Expression", "V8IntrinsicIdentifier")
      },
      arguments: {
        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "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
      }
    })
  }), a("CatchClause", {
    visitor: ["param", "body"],
    fields: {
      param: {
        validate: (0, e.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"),
        optional: !0
      },
      body: {
        validate: (0, e.assertNodeType)("BlockStatement")
      }
    },
    aliases: ["Scopable", "BlockParent"]
  }), a("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"]
  }), a("ContinueStatement", {
    visitor: ["label"],
    fields: {
      label: {
        validate: (0, e.assertNodeType)("Identifier"),
        optional: !0
      }
    },
    aliases: ["Statement", "Terminatorless", "CompletionStatement"]
  }), a("DebuggerStatement", {
    aliases: ["Statement"]
  }), a("DoWhileStatement", {
    visitor: ["test", "body"],
    fields: {
      test: {
        validate: (0, e.assertNodeType)("Expression")
      },
      body: {
        validate: (0, e.assertNodeType)("Statement")
      }
    },
    aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]
  }), a("EmptyStatement", {
    aliases: ["Statement"]
  }), a("ExpressionStatement", {
    visitor: ["expression"],
    fields: {
      expression: {
        validate: (0, e.assertNodeType)("Expression")
      }
    },
    aliases: ["Statement", "ExpressionWrapper"]
  }), a("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
      }
    }
  }), a("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", "TSTypeAssertion", "TSNonNullExpression") : (0, e.assertNodeType)("VariableDeclaration", "LVal")
      },
      right: {
        validate: (0, e.assertNodeType)("Expression")
      },
      body: {
        validate: (0, e.assertNodeType)("Statement")
      }
    }
  }), a("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, a("FunctionDeclaration", {
    builder: ["id", "params", "body", "generator", "async"],
    visitor: ["id", "params", "body", "returnType", "typeParameters"],
    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, t, s) {
        (0, l.default)("ExportDefaultDeclaration", i) || r(s, "id", s.id);
      };
    }()
  }), a("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
    },
    decorators: {
      validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Decorator")))
    }
  };
  p.patternLikeCommon = u, a("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, t) {
          if (!!process.env.BABEL_TYPES_8_BREAKING && !(0, b.default)(t, !1))
            throw new TypeError(`"${t}" is not a valid identifier name`);
        }, {
          type: "string"
        }))
      },
      optional: {
        validate: (0, e.assertValueType)("boolean"),
        optional: !0
      }
    }),
    validate(r, i, t) {
      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: t
        }))
          return;
      } else if (o === "meta" && (0, l.default)("MetaProperty", r, {
        meta: t
      }))
        return;
      if (((0, m.isKeyword)(t.name) || (0, m.isReservedWord)(t.name, !1)) && t.name !== "this")
        throw new TypeError(`"${t.name}" is not a valid identifier`);
    }
  }), a("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")
      }
    }
  }), a("LabeledStatement", {
    visitor: ["label", "body"],
    aliases: ["Statement"],
    fields: {
      label: {
        validate: (0, e.assertNodeType)("Identifier")
      },
      body: {
        validate: (0, e.assertNodeType)("Statement")
      }
    }
  }), a("StringLiteral", {
    builder: ["value"],
    fields: {
      value: {
        validate: (0, e.assertValueType)("string")
      }
    },
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  }), a("NumericLiteral", {
    builder: ["value"],
    deprecatedAlias: "NumberLiteral",
    fields: {
      value: {
        validate: (0, e.assertValueType)("number")
      }
    },
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  }), a("NullLiteral", {
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  }), a("BooleanLiteral", {
    builder: ["value"],
    fields: {
      value: {
        validate: (0, e.assertValueType)("boolean")
      }
    },
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  }), a("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, t) {
          if (!process.env.BABEL_TYPES_8_BREAKING)
            return;
          const s = /[^gimsuy]/.exec(t);
          if (s)
            throw new TypeError(`"${s[0]}" is not a valid RegExp flag`);
        }, {
          type: "string"
        })),
        default: ""
      }
    }
  }), a("LogicalExpression", {
    builder: ["operator", "left", "right"],
    visitor: ["left", "right"],
    aliases: ["Binary", "Expression"],
    fields: {
      operator: {
        validate: (0, e.assertOneOf)(...y.LOGICAL_OPERATORS)
      },
      left: {
        validate: (0, e.assertNodeType)("Expression")
      },
      right: {
        validate: (0, e.assertNodeType)("Expression")
      }
    }
  }), a("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")
      },
      property: {
        validate: function() {
          const r = (0, e.assertNodeType)("Identifier", "PrivateName"), i = (0, e.assertNodeType)("Expression"), t = function(s, o, n) {
            (s.computed ? i : r)(s, o, n);
          };
          return t.oneOfNodeTypes = ["Expression", "Identifier", "PrivateName"], t;
        }()
      },
      computed: {
        default: !1
      }
    }, process.env.BABEL_TYPES_8_BREAKING ? {} : {
      optional: {
        validate: (0, e.assertOneOf)(!0, !1),
        optional: !0
      }
    })
  }), a("NewExpression", {
    inherits: "CallExpression"
  }), a("Program", {
    visitor: ["directives", "body"],
    builder: ["body", "directives", "sourceType", "interpreter"],
    fields: {
      sourceFile: {
        validate: (0, e.assertValueType)("string")
      },
      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"]
  }), a("ObjectExpression", {
    visitor: ["properties"],
    aliases: ["Expression"],
    fields: {
      properties: {
        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement")))
      }
    }
  }), a("ObjectMethod", {
    builder: ["kind", "key", "params", "body", "computed", "generator", "async"],
    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"), i = (0, e.assertNodeType)("Expression"), t = function(s, o, n) {
            (s.computed ? i : r)(s, o, n);
          };
          return t.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral"], t;
        }()
      },
      decorators: {
        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Decorator"))),
        optional: !0
      },
      body: {
        validate: (0, e.assertNodeType)("BlockStatement")
      }
    }),
    visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
    aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"]
  }), a("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, t) {
          if (!!process.env.BABEL_TYPES_8_BREAKING && t && r.computed)
            throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true");
        }, {
          type: "boolean"
        }), function(r, i, t) {
          if (!!process.env.BABEL_TYPES_8_BREAKING && t && !(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", "TSNonNullExpression", "TSTypeAssertion"), i = (0, e.assertNodeType)("Expression");
      return function(t, s, o) {
        if (!process.env.BABEL_TYPES_8_BREAKING)
          return;
        ((0, l.default)("ObjectPattern", t) ? r : i)(o, "value", o.value);
      };
    }()
  }), a("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", "TSTypeAssertion", "TSNonNullExpression") : (0, e.assertNodeType)("LVal")
      },
      optional: {
        validate: (0, e.assertValueType)("boolean"),
        optional: !0
      }
    }),
    validate(r, i) {
      if (!process.env.BABEL_TYPES_8_BREAKING)
        return;
      const t = /(\w+)\[(\d+)\]/.exec(i);
      if (!t)
        throw new Error("Internal Babel error: malformed key.");
      const [, s, o] = t;
      if (r[s].length > +o + 1)
        throw new TypeError(`RestElement must be last element of ${s}`);
    }
  }), a("ReturnStatement", {
    visitor: ["argument"],
    aliases: ["Statement", "Terminatorless", "CompletionStatement"],
    fields: {
      argument: {
        validate: (0, e.assertNodeType)("Expression"),
        optional: !0
      }
    }
  }), a("SequenceExpression", {
    visitor: ["expressions"],
    fields: {
      expressions: {
        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Expression")))
      }
    },
    aliases: ["Expression"]
  }), a("ParenthesizedExpression", {
    visitor: ["expression"],
    aliases: ["Expression", "ExpressionWrapper"],
    fields: {
      expression: {
        validate: (0, e.assertNodeType)("Expression")
      }
    }
  }), a("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")))
      }
    }
  }), a("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")))
      }
    }
  }), a("ThisExpression", {
    aliases: ["Expression"]
  }), a("ThrowStatement", {
    visitor: ["argument"],
    aliases: ["Statement", "Terminatorless", "CompletionStatement"],
    fields: {
      argument: {
        validate: (0, e.assertNodeType)("Expression")
      }
    }
  }), a("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")
      }
    }
  }), a("UnaryExpression", {
    builder: ["operator", "argument", "prefix"],
    fields: {
      prefix: {
        default: !0
      },
      argument: {
        validate: (0, e.assertNodeType)("Expression")
      },
      operator: {
        validate: (0, e.assertOneOf)(...y.UNARY_OPERATORS)
      }
    },
    visitor: ["argument"],
    aliases: ["UnaryLike", "Expression"]
  }), a("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)(...y.UPDATE_OPERATORS)
      }
    },
    visitor: ["argument"],
    aliases: ["Expression"]
  }), a("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")
      },
      declarations: {
        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("VariableDeclarator")))
      }
    },
    validate(r, i, t) {
      if (!!process.env.BABEL_TYPES_8_BREAKING && !!(0, l.default)("ForXStatement", r, {
        left: t
      }) && t.declarations.length !== 1)
        throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${r.type}`);
    }
  }), a("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(t, s, o) {
            (t.init ? r : i)(t, s, o);
          };
        }()
      },
      definite: {
        optional: !0,
        validate: (0, e.assertValueType)("boolean")
      },
      init: {
        optional: !0,
        validate: (0, e.assertNodeType)("Expression")
      }
    }
  }), a("WhileStatement", {
    visitor: ["test", "body"],
    aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"],
    fields: {
      test: {
        validate: (0, e.assertNodeType)("Expression")
      },
      body: {
        validate: (0, e.assertNodeType)("Statement")
      }
    }
  }), a("WithStatement", {
    visitor: ["object", "body"],
    aliases: ["Statement"],
    fields: {
      object: {
        validate: (0, e.assertNodeType)("Expression")
      },
      body: {
        validate: (0, e.assertNodeType)("Statement")
      }
    }
  }), a("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", "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
      }
    })
  }), a("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")))
      },
      decorators: {
        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Decorator"))),
        optional: !0
      },
      optional: {
        validate: (0, e.assertValueType)("boolean"),
        optional: !0
      }
    })
  }), a("ArrowFunctionExpression", {
    builder: ["params", "body", "async"],
    visitor: ["params", "body", "returnType", "typeParameters"],
    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
      }
    })
  }), a("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")))
      }
    }
  }), a("ClassExpression", {
    builder: ["id", "superClass", "body", "decorators"],
    visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"],
    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
      }
    }
  }), a("ClassDeclaration", {
    inherits: "ClassExpression",
    aliases: ["Scopable", "Class", "Statement", "Declaration"],
    fields: {
      id: {
        validate: (0, e.assertNodeType)("Identifier")
      },
      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, t, s) {
        !process.env.BABEL_TYPES_8_BREAKING || (0, l.default)("ExportDefaultDeclaration", i) || r(s, "id", s.id);
      };
    }()
  }), a("ExportAllDeclaration", {
    visitor: ["source"],
    aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
    fields: {
      source: {
        validate: (0, e.assertNodeType)("StringLiteral")
      },
      exportKind: (0, e.validateOptional)((0, e.assertOneOf)("type", "value")),
      assertions: {
        optional: !0,
        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("ImportAttribute")))
      }
    }
  }), a("ExportDefaultDeclaration", {
    visitor: ["declaration"],
    aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
    fields: {
      declaration: {
        validate: (0, e.assertNodeType)("FunctionDeclaration", "ClassDeclaration", "Expression")
      },
      exportKind: (0, e.validateOptional)((0, e.assertOneOf)("value"))
    }
  }), a("ExportNamedDeclaration", {
    visitor: ["declaration", "specifiers", "source"],
    aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
    fields: {
      declaration: {
        optional: !0,
        validate: (0, e.chain)((0, e.assertNodeType)("Declaration"), Object.assign(function(r, i, t) {
          if (!!process.env.BABEL_TYPES_8_BREAKING && t && r.specifiers.length)
            throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration");
        }, {
          oneOfNodeTypes: ["Declaration"]
        }), function(r, i, t) {
          if (!!process.env.BABEL_TYPES_8_BREAKING && t && r.source)
            throw new TypeError("Cannot export a declaration from a source");
        })
      },
      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(t, s, o) {
            (t.source ? r : i)(t, s, o);
          } : r;
        }()))
      },
      source: {
        validate: (0, e.assertNodeType)("StringLiteral"),
        optional: !0
      },
      exportKind: (0, e.validateOptional)((0, e.assertOneOf)("type", "value"))
    }
  }), a("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
      }
    }
  }), a("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", "TSTypeAssertion", "TSNonNullExpression");
          return function(t, s, o) {
            (0, l.default)("VariableDeclaration", o) ? r(t, s, o) : i(t, s, o);
          };
        }()
      },
      right: {
        validate: (0, e.assertNodeType)("Expression")
      },
      body: {
        validate: (0, e.assertNodeType)("Statement")
      },
      await: {
        default: !1
      }
    }
  }), a("ImportDeclaration", {
    visitor: ["specifiers", "source"],
    aliases: ["Statement", "Declaration", "ModuleDeclaration"],
    fields: {
      assertions: {
        optional: !0,
        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("ImportAttribute")))
      },
      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
      }
    }
  }), a("ImportDefaultSpecifier", {
    visitor: ["local"],
    aliases: ["ModuleSpecifier"],
    fields: {
      local: {
        validate: (0, e.assertNodeType)("Identifier")
      }
    }
  }), a("ImportNamespaceSpecifier", {
    visitor: ["local"],
    aliases: ["ModuleSpecifier"],
    fields: {
      local: {
        validate: (0, e.assertNodeType)("Identifier")
      }
    }
  }), a("ImportSpecifier", {
    visitor: ["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
      }
    }
  }), a("MetaProperty", {
    visitor: ["meta", "property"],
    aliases: ["Expression"],
    fields: {
      meta: {
        validate: (0, e.chain)((0, e.assertNodeType)("Identifier"), Object.assign(function(r, i, t) {
          if (!process.env.BABEL_TYPES_8_BREAKING)
            return;
          let s;
          switch (t.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 v = {
    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"), i = (0, e.assertNodeType)("Expression");
        return function(t, s, o) {
          (t.computed ? i : r)(t, s, o);
        };
      }(), (0, e.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression"))
    }
  };
  p.classMethodOrPropertyCommon = v;
  const f = Object.assign({}, c, v, {
    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 = f, a("ClassMethod", {
    aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
    builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"],
    visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
    fields: Object.assign({}, f, d, {
      body: {
        validate: (0, e.assertNodeType)("BlockStatement")
      }
    })
  }), a("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")))
      }
    })
  }), a("SpreadElement", {
    visitor: ["argument"],
    aliases: ["UnaryLike"],
    deprecatedAlias: "SpreadProperty",
    fields: {
      argument: {
        validate: (0, e.assertNodeType)("Expression")
      }
    }
  }), a("Super", {
    aliases: ["Expression"]
  }), a("TaggedTemplateExpression", {
    visitor: ["tag", "quasi", "typeParameters"],
    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
      }
    }
  }), a("TemplateElement", {
    builder: ["value", "tail"],
    fields: {
      value: {
        validate: (0, e.assertShape)({
          raw: {
            validate: (0, e.assertValueType)("string")
          },
          cooked: {
            validate: (0, e.assertValueType)("string"),
            optional: !0
          }
        })
      },
      tail: {
        default: !1
      }
    }
  }), a("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, t) {
          if (r.quasis.length !== t.length + 1)
            throw new TypeError(`Number of ${r.type} quasis should be exactly one more than the number of expressions.
Expected ${t.length + 1} quasis but got ${r.quasis.length}`);
        })
      }
    }
  }), a("YieldExpression", {
    builder: ["argument", "delegate"],
    visitor: ["argument"],
    aliases: ["Expression", "Terminatorless"],
    fields: {
      delegate: {
        validate: (0, e.chain)((0, e.assertValueType)("boolean"), Object.assign(function(r, i, t) {
          if (!!process.env.BABEL_TYPES_8_BREAKING && t && !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")
      }
    }
  }), a("AwaitExpression", {
    builder: ["argument"],
    visitor: ["argument"],
    aliases: ["Expression", "Terminatorless"],
    fields: {
      argument: {
        validate: (0, e.assertNodeType)("Expression")
      }
    }
  }), a("Import", {
    aliases: ["Expression"]
  }), a("BigIntLiteral", {
    builder: ["value"],
    fields: {
      value: {
        validate: (0, e.assertValueType)("string")
      }
    },
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  }), a("ExportNamespaceSpecifier", {
    visitor: ["exported"],
    aliases: ["ModuleSpecifier"],
    fields: {
      exported: {
        validate: (0, e.assertNodeType)("Identifier")
      }
    }
  }), a("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")
      }
    }
  }), a("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", "JSXNamespacedName", "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
      }
    }
  }), a("ClassProperty", {
    visitor: ["key", "value", "typeAnnotation", "decorators"],
    builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
    aliases: ["Property"],
    fields: Object.assign({}, v, {
      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
      }
    })
  }), a("ClassAccessorProperty", {
    visitor: ["key", "value", "typeAnnotation", "decorators"],
    builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
    aliases: ["Property", "Accessor"],
    fields: Object.assign({}, v, {
      key: {
        validate: (0, e.chain)(function() {
          const r = (0, e.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "PrivateName"), i = (0, e.assertNodeType)("Expression");
          return function(t, s, o) {
            (t.computed ? i : r)(t, s, o);
          };
        }(), (0, e.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "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
      }
    })
  }), a("ClassPrivateProperty", {
    visitor: ["key", "value", "decorators", "typeAnnotation"],
    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
      },
      readonly: {
        validate: (0, e.assertValueType)("boolean"),
        optional: !0
      },
      definite: {
        validate: (0, e.assertValueType)("boolean"),
        optional: !0
      },
      variance: {
        validate: (0, e.assertNodeType)("Variance"),
        optional: !0
      }
    }
  }), a("ClassPrivateMethod", {
    builder: ["kind", "key", "params", "body", "static"],
    visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
    aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"],
    fields: Object.assign({}, f, d, {
      key: {
        validate: (0, e.assertNodeType)("PrivateName")
      },
      body: {
        validate: (0, e.assertNodeType)("BlockStatement")
      }
    })
  }), a("PrivateName", {
    visitor: ["id"],
    aliases: ["Private"],
    fields: {
      id: {
        validate: (0, e.assertNodeType)("Identifier")
      }
    }
  }), a("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 {
  C as __require
};
//# sourceMappingURL=core.js.map
