import { __exports as s } from "../../../../../../../../../_virtual/index32.js";
import { __exports as Vr } from "../../../../../../../../../_virtual/index32.js";
import { __require as a } from "../../validators/is.js";
Object.defineProperty(s, "__esModule", {
  value: !0
});
s.assertAccessor = Ar;
s.assertAnyTypeAnnotation = ke;
s.assertArgumentPlaceholder = ys;
s.assertArrayExpression = i;
s.assertArrayPattern = ae;
s.assertArrayTypeAnnotation = ve;
s.assertArrowFunctionExpression = oe;
s.assertAssignmentExpression = c;
s.assertAssignmentPattern = re;
s.assertAwaitExpression = he;
s.assertBigIntLiteral = Ne;
s.assertBinary = Un;
s.assertBinaryExpression = p;
s.assertBindExpression = ms;
s.assertBlock = qn;
s.assertBlockParent = Wn;
s.assertBlockStatement = S;
s.assertBooleanLiteral = O;
s.assertBooleanLiteralTypeAnnotation = Ve;
s.assertBooleanTypeAnnotation = Ue;
s.assertBreakStatement = f;
s.assertCallExpression = y;
s.assertCatchClause = m;
s.assertClass = mr;
s.assertClassAccessorProperty = Xe;
s.assertClassBody = ie;
s.assertClassDeclaration = pe;
s.assertClassExpression = ce;
s.assertClassImplements = qe;
s.assertClassMethod = Ae;
s.assertClassPrivateMethod = Ke;
s.assertClassPrivateProperty = Je;
s.assertClassProperty = Oe;
s.assertCompletionStatement = _n;
s.assertConditional = Gn;
s.assertConditionalExpression = d;
s.assertContinueStatement = E;
s.assertDebuggerStatement = x;
s.assertDecimalLiteral = bs;
s.assertDeclaration = rr;
s.assertDeclareClass = ze;
s.assertDeclareExportAllDeclaration = tt;
s.assertDeclareExportDeclaration = et;
s.assertDeclareFunction = Qe;
s.assertDeclareInterface = _e;
s.assertDeclareModule = Ge;
s.assertDeclareModuleExports = Ye;
s.assertDeclareOpaqueType = He;
s.assertDeclareTypeAlias = $e;
s.assertDeclareVariable = Ze;
s.assertDeclaredPredicate = st;
s.assertDecorator = Es;
s.assertDirective = u;
s.assertDirectiveLiteral = T;
s.assertDoExpression = xs;
s.assertDoWhileStatement = A;
s.assertEmptyStatement = D;
s.assertEmptyTypeAnnotation = St;
s.assertEnumBody = Mr;
s.assertEnumBooleanBody = vt;
s.assertEnumBooleanMember = qt;
s.assertEnumDeclaration = kt;
s.assertEnumDefaultedMember = _t;
s.assertEnumMember = hr;
s.assertEnumNumberBody = Ut;
s.assertEnumNumberMember = zt;
s.assertEnumStringBody = Vt;
s.assertEnumStringMember = Qt;
s.assertEnumSymbolBody = Wt;
s.assertExistsTypeAnnotation = nt;
s.assertExportAllDeclaration = le;
s.assertExportDeclaration = Er;
s.assertExportDefaultDeclaration = ue;
s.assertExportDefaultSpecifier = As;
s.assertExportNamedDeclaration = Te;
s.assertExportNamespaceSpecifier = we;
s.assertExportSpecifier = Se;
s.assertExpression = vn;
s.assertExpressionStatement = P;
s.assertExpressionWrapper = Hn;
s.assertFile = b;
s.assertFlow = Pr;
s.assertFlowBaseAnnotation = Ir;
s.assertFlowDeclaration = gr;
s.assertFlowPredicate = Cr;
s.assertFlowType = br;
s.assertFor = Zn;
s.assertForInStatement = I;
s.assertForOfStatement = fe;
s.assertForStatement = g;
s.assertForXStatement = er;
s.assertFunction = tr;
s.assertFunctionDeclaration = C;
s.assertFunctionExpression = M;
s.assertFunctionParent = sr;
s.assertFunctionTypeAnnotation = rt;
s.assertFunctionTypeParam = at;
s.assertGenericTypeAnnotation = ot;
s.assertIdentifier = h;
s.assertIfStatement = B;
s.assertImmutable = pr;
s.assertImport = Be;
s.assertImportAttribute = ds;
s.assertImportDeclaration = ye;
s.assertImportDefaultSpecifier = me;
s.assertImportNamespaceSpecifier = de;
s.assertImportSpecifier = Ee;
s.assertIndexedAccessType = Gt;
s.assertInferredPredicate = it;
s.assertInterfaceDeclaration = pt;
s.assertInterfaceExtends = ct;
s.assertInterfaceTypeAnnotation = lt;
s.assertInterpreterDirective = l;
s.assertIntersectionTypeAnnotation = ut;
s.assertJSX = Br;
s.assertJSXAttribute = $t;
s.assertJSXClosingElement = Ht;
s.assertJSXClosingFragment = us;
s.assertJSXElement = Zt;
s.assertJSXEmptyExpression = es;
s.assertJSXExpressionContainer = ts;
s.assertJSXFragment = ps;
s.assertJSXIdentifier = ns;
s.assertJSXMemberExpression = rs;
s.assertJSXNamespacedName = as;
s.assertJSXOpeningElement = os;
s.assertJSXOpeningFragment = ls;
s.assertJSXSpreadAttribute = is;
s.assertJSXSpreadChild = ss;
s.assertJSXText = cs;
s.assertLVal = or;
s.assertLabeledStatement = N;
s.assertLiteral = cr;
s.assertLogicalExpression = J;
s.assertLoop = Yn;
s.assertMemberExpression = K;
s.assertMetaProperty = xe;
s.assertMethod = ur;
s.assertMiscellaneous = Nr;
s.assertMixedTypeAnnotation = Tt;
s.assertModuleDeclaration = dr;
s.assertModuleExpression = Is;
s.assertModuleSpecifier = xr;
s.assertNewExpression = j;
s.assertNoop = Ts;
s.assertNullLiteral = F;
s.assertNullLiteralTypeAnnotation = We;
s.assertNullableTypeAnnotation = ft;
s.assertNumberLiteral = Xr;
s.assertNumberLiteralTypeAnnotation = yt;
s.assertNumberTypeAnnotation = mt;
s.assertNumericLiteral = L;
s.assertObjectExpression = k;
s.assertObjectMember = Tr;
s.assertObjectMethod = v;
s.assertObjectPattern = De;
s.assertObjectProperty = U;
s.assertObjectTypeAnnotation = dt;
s.assertObjectTypeCallProperty = xt;
s.assertObjectTypeIndexer = At;
s.assertObjectTypeInternalSlot = Et;
s.assertObjectTypeProperty = Dt;
s.assertObjectTypeSpreadProperty = Pt;
s.assertOpaqueType = bt;
s.assertOptionalCallExpression = Fe;
s.assertOptionalIndexedAccessType = Yt;
s.assertOptionalMemberExpression = Le;
s.assertParenthesizedExpression = z;
s.assertPattern = yr;
s.assertPatternLike = ar;
s.assertPipelineBareFunction = Ms;
s.assertPipelinePrimaryTopicReference = hs;
s.assertPipelineTopicExpression = Cs;
s.assertPlaceholder = Ss;
s.assertPrivate = Dr;
s.assertPrivateName = je;
s.assertProgram = R;
s.assertProperty = Sr;
s.assertPureish = nr;
s.assertQualifiedTypeIdentifier = It;
s.assertRecordExpression = Ds;
s.assertRegExpLiteral = X;
s.assertRegexLiteral = Jr;
s.assertRestElement = V;
s.assertRestProperty = Kr;
s.assertReturnStatement = W;
s.assertScopable = Vn;
s.assertSequenceExpression = q;
s.assertSpreadElement = Pe;
s.assertSpreadProperty = jr;
s.assertStandardized = kn;
s.assertStatement = zn;
s.assertStaticBlock = Re;
s.assertStringLiteral = w;
s.assertStringLiteralTypeAnnotation = gt;
s.assertStringTypeAnnotation = Ct;
s.assertSuper = be;
s.assertSwitchCase = Q;
s.assertSwitchStatement = _;
s.assertSymbolTypeAnnotation = Mt;
s.assertTSAnyKeyword = js;
s.assertTSArrayType = rn;
s.assertTSAsExpression = In;
s.assertTSBaseType = Or;
s.assertTSBigIntKeyword = ks;
s.assertTSBooleanKeyword = Rs;
s.assertTSCallSignatureDeclaration = Fs;
s.assertTSConditionalType = Tn;
s.assertTSConstructSignatureDeclaration = Os;
s.assertTSConstructorType = Zs;
s.assertTSDeclareFunction = Ns;
s.assertTSDeclareMethod = ws;
s.assertTSEntityName = ir;
s.assertTSEnumDeclaration = Cn;
s.assertTSEnumMember = Mn;
s.assertTSExportAssignment = On;
s.assertTSExpressionWithTypeArguments = xn;
s.assertTSExternalModuleReference = Ln;
s.assertTSFunctionType = Hs;
s.assertTSImportEqualsDeclaration = wn;
s.assertTSImportType = Nn;
s.assertTSIndexSignature = Ks;
s.assertTSIndexedAccessType = mn;
s.assertTSInferType = Sn;
s.assertTSInstantiationExpression = bn;
s.assertTSInterfaceBody = Dn;
s.assertTSInterfaceDeclaration = An;
s.assertTSIntersectionType = un;
s.assertTSIntrinsicKeyword = vs;
s.assertTSLiteralType = En;
s.assertTSMappedType = dn;
s.assertTSMethodSignature = Js;
s.assertTSModuleBlock = Bn;
s.assertTSModuleDeclaration = hn;
s.assertTSNamedTupleMember = pn;
s.assertTSNamespaceExportDeclaration = Xn;
s.assertTSNeverKeyword = Us;
s.assertTSNonNullExpression = Fn;
s.assertTSNullKeyword = Vs;
s.assertTSNumberKeyword = Ws;
s.assertTSObjectKeyword = qs;
s.assertTSOptionalType = on;
s.assertTSParameterProperty = Bs;
s.assertTSParenthesizedType = fn;
s.assertTSPropertySignature = Xs;
s.assertTSQualifiedName = Ls;
s.assertTSRestType = cn;
s.assertTSStringKeyword = zs;
s.assertTSSymbolKeyword = Qs;
s.assertTSThisType = $s;
s.assertTSTupleType = an;
s.assertTSType = Fr;
s.assertTSTypeAliasDeclaration = Pn;
s.assertTSTypeAnnotation = Jn;
s.assertTSTypeAssertion = gn;
s.assertTSTypeElement = Lr;
s.assertTSTypeLiteral = nn;
s.assertTSTypeOperator = yn;
s.assertTSTypeParameter = Rn;
s.assertTSTypeParameterDeclaration = jn;
s.assertTSTypeParameterInstantiation = Kn;
s.assertTSTypePredicate = tn;
s.assertTSTypeQuery = sn;
s.assertTSTypeReference = en;
s.assertTSUndefinedKeyword = _s;
s.assertTSUnionType = ln;
s.assertTSUnknownKeyword = Gs;
s.assertTSVoidKeyword = Ys;
s.assertTaggedTemplateExpression = Ie;
s.assertTemplateElement = ge;
s.assertTemplateLiteral = Ce;
s.assertTerminatorless = Qn;
s.assertThisExpression = G;
s.assertThisTypeAnnotation = ht;
s.assertThrowStatement = Y;
s.assertTopicReference = gs;
s.assertTryStatement = $;
s.assertTupleExpression = Ps;
s.assertTupleTypeAnnotation = Bt;
s.assertTypeAlias = wt;
s.assertTypeAnnotation = Lt;
s.assertTypeCastExpression = Ft;
s.assertTypeParameter = Ot;
s.assertTypeParameterDeclaration = Xt;
s.assertTypeParameterInstantiation = Jt;
s.assertTypeScript = wr;
s.assertTypeofTypeAnnotation = Nt;
s.assertUnaryExpression = H;
s.assertUnaryLike = fr;
s.assertUnionTypeAnnotation = Kt;
s.assertUpdateExpression = Z;
s.assertUserWhitespacable = lr;
s.assertV8IntrinsicIdentifier = fs;
s.assertVariableDeclaration = ee;
s.assertVariableDeclarator = te;
s.assertVariance = jt;
s.assertVoidTypeAnnotation = Rt;
s.assertWhile = $n;
s.assertWhileStatement = se;
s.assertWithStatement = ne;
s.assertYieldExpression = Me;
var o = a();
function n(e, t, r) {
  if (!(0, o.default)(e, t, r))
    throw new Error(`Expected type "${e}" with option ${JSON.stringify(r)}, but instead got "${t.type}".`);
}
function i(e, t) {
  n("ArrayExpression", e, t);
}
function c(e, t) {
  n("AssignmentExpression", e, t);
}
function p(e, t) {
  n("BinaryExpression", e, t);
}
function l(e, t) {
  n("InterpreterDirective", e, t);
}
function u(e, t) {
  n("Directive", e, t);
}
function T(e, t) {
  n("DirectiveLiteral", e, t);
}
function S(e, t) {
  n("BlockStatement", e, t);
}
function f(e, t) {
  n("BreakStatement", e, t);
}
function y(e, t) {
  n("CallExpression", e, t);
}
function m(e, t) {
  n("CatchClause", e, t);
}
function d(e, t) {
  n("ConditionalExpression", e, t);
}
function E(e, t) {
  n("ContinueStatement", e, t);
}
function x(e, t) {
  n("DebuggerStatement", e, t);
}
function A(e, t) {
  n("DoWhileStatement", e, t);
}
function D(e, t) {
  n("EmptyStatement", e, t);
}
function P(e, t) {
  n("ExpressionStatement", e, t);
}
function b(e, t) {
  n("File", e, t);
}
function I(e, t) {
  n("ForInStatement", e, t);
}
function g(e, t) {
  n("ForStatement", e, t);
}
function C(e, t) {
  n("FunctionDeclaration", e, t);
}
function M(e, t) {
  n("FunctionExpression", e, t);
}
function h(e, t) {
  n("Identifier", e, t);
}
function B(e, t) {
  n("IfStatement", e, t);
}
function N(e, t) {
  n("LabeledStatement", e, t);
}
function w(e, t) {
  n("StringLiteral", e, t);
}
function L(e, t) {
  n("NumericLiteral", e, t);
}
function F(e, t) {
  n("NullLiteral", e, t);
}
function O(e, t) {
  n("BooleanLiteral", e, t);
}
function X(e, t) {
  n("RegExpLiteral", e, t);
}
function J(e, t) {
  n("LogicalExpression", e, t);
}
function K(e, t) {
  n("MemberExpression", e, t);
}
function j(e, t) {
  n("NewExpression", e, t);
}
function R(e, t) {
  n("Program", e, t);
}
function k(e, t) {
  n("ObjectExpression", e, t);
}
function v(e, t) {
  n("ObjectMethod", e, t);
}
function U(e, t) {
  n("ObjectProperty", e, t);
}
function V(e, t) {
  n("RestElement", e, t);
}
function W(e, t) {
  n("ReturnStatement", e, t);
}
function q(e, t) {
  n("SequenceExpression", e, t);
}
function z(e, t) {
  n("ParenthesizedExpression", e, t);
}
function Q(e, t) {
  n("SwitchCase", e, t);
}
function _(e, t) {
  n("SwitchStatement", e, t);
}
function G(e, t) {
  n("ThisExpression", e, t);
}
function Y(e, t) {
  n("ThrowStatement", e, t);
}
function $(e, t) {
  n("TryStatement", e, t);
}
function H(e, t) {
  n("UnaryExpression", e, t);
}
function Z(e, t) {
  n("UpdateExpression", e, t);
}
function ee(e, t) {
  n("VariableDeclaration", e, t);
}
function te(e, t) {
  n("VariableDeclarator", e, t);
}
function se(e, t) {
  n("WhileStatement", e, t);
}
function ne(e, t) {
  n("WithStatement", e, t);
}
function re(e, t) {
  n("AssignmentPattern", e, t);
}
function ae(e, t) {
  n("ArrayPattern", e, t);
}
function oe(e, t) {
  n("ArrowFunctionExpression", e, t);
}
function ie(e, t) {
  n("ClassBody", e, t);
}
function ce(e, t) {
  n("ClassExpression", e, t);
}
function pe(e, t) {
  n("ClassDeclaration", e, t);
}
function le(e, t) {
  n("ExportAllDeclaration", e, t);
}
function ue(e, t) {
  n("ExportDefaultDeclaration", e, t);
}
function Te(e, t) {
  n("ExportNamedDeclaration", e, t);
}
function Se(e, t) {
  n("ExportSpecifier", e, t);
}
function fe(e, t) {
  n("ForOfStatement", e, t);
}
function ye(e, t) {
  n("ImportDeclaration", e, t);
}
function me(e, t) {
  n("ImportDefaultSpecifier", e, t);
}
function de(e, t) {
  n("ImportNamespaceSpecifier", e, t);
}
function Ee(e, t) {
  n("ImportSpecifier", e, t);
}
function xe(e, t) {
  n("MetaProperty", e, t);
}
function Ae(e, t) {
  n("ClassMethod", e, t);
}
function De(e, t) {
  n("ObjectPattern", e, t);
}
function Pe(e, t) {
  n("SpreadElement", e, t);
}
function be(e, t) {
  n("Super", e, t);
}
function Ie(e, t) {
  n("TaggedTemplateExpression", e, t);
}
function ge(e, t) {
  n("TemplateElement", e, t);
}
function Ce(e, t) {
  n("TemplateLiteral", e, t);
}
function Me(e, t) {
  n("YieldExpression", e, t);
}
function he(e, t) {
  n("AwaitExpression", e, t);
}
function Be(e, t) {
  n("Import", e, t);
}
function Ne(e, t) {
  n("BigIntLiteral", e, t);
}
function we(e, t) {
  n("ExportNamespaceSpecifier", e, t);
}
function Le(e, t) {
  n("OptionalMemberExpression", e, t);
}
function Fe(e, t) {
  n("OptionalCallExpression", e, t);
}
function Oe(e, t) {
  n("ClassProperty", e, t);
}
function Xe(e, t) {
  n("ClassAccessorProperty", e, t);
}
function Je(e, t) {
  n("ClassPrivateProperty", e, t);
}
function Ke(e, t) {
  n("ClassPrivateMethod", e, t);
}
function je(e, t) {
  n("PrivateName", e, t);
}
function Re(e, t) {
  n("StaticBlock", e, t);
}
function ke(e, t) {
  n("AnyTypeAnnotation", e, t);
}
function ve(e, t) {
  n("ArrayTypeAnnotation", e, t);
}
function Ue(e, t) {
  n("BooleanTypeAnnotation", e, t);
}
function Ve(e, t) {
  n("BooleanLiteralTypeAnnotation", e, t);
}
function We(e, t) {
  n("NullLiteralTypeAnnotation", e, t);
}
function qe(e, t) {
  n("ClassImplements", e, t);
}
function ze(e, t) {
  n("DeclareClass", e, t);
}
function Qe(e, t) {
  n("DeclareFunction", e, t);
}
function _e(e, t) {
  n("DeclareInterface", e, t);
}
function Ge(e, t) {
  n("DeclareModule", e, t);
}
function Ye(e, t) {
  n("DeclareModuleExports", e, t);
}
function $e(e, t) {
  n("DeclareTypeAlias", e, t);
}
function He(e, t) {
  n("DeclareOpaqueType", e, t);
}
function Ze(e, t) {
  n("DeclareVariable", e, t);
}
function et(e, t) {
  n("DeclareExportDeclaration", e, t);
}
function tt(e, t) {
  n("DeclareExportAllDeclaration", e, t);
}
function st(e, t) {
  n("DeclaredPredicate", e, t);
}
function nt(e, t) {
  n("ExistsTypeAnnotation", e, t);
}
function rt(e, t) {
  n("FunctionTypeAnnotation", e, t);
}
function at(e, t) {
  n("FunctionTypeParam", e, t);
}
function ot(e, t) {
  n("GenericTypeAnnotation", e, t);
}
function it(e, t) {
  n("InferredPredicate", e, t);
}
function ct(e, t) {
  n("InterfaceExtends", e, t);
}
function pt(e, t) {
  n("InterfaceDeclaration", e, t);
}
function lt(e, t) {
  n("InterfaceTypeAnnotation", e, t);
}
function ut(e, t) {
  n("IntersectionTypeAnnotation", e, t);
}
function Tt(e, t) {
  n("MixedTypeAnnotation", e, t);
}
function St(e, t) {
  n("EmptyTypeAnnotation", e, t);
}
function ft(e, t) {
  n("NullableTypeAnnotation", e, t);
}
function yt(e, t) {
  n("NumberLiteralTypeAnnotation", e, t);
}
function mt(e, t) {
  n("NumberTypeAnnotation", e, t);
}
function dt(e, t) {
  n("ObjectTypeAnnotation", e, t);
}
function Et(e, t) {
  n("ObjectTypeInternalSlot", e, t);
}
function xt(e, t) {
  n("ObjectTypeCallProperty", e, t);
}
function At(e, t) {
  n("ObjectTypeIndexer", e, t);
}
function Dt(e, t) {
  n("ObjectTypeProperty", e, t);
}
function Pt(e, t) {
  n("ObjectTypeSpreadProperty", e, t);
}
function bt(e, t) {
  n("OpaqueType", e, t);
}
function It(e, t) {
  n("QualifiedTypeIdentifier", e, t);
}
function gt(e, t) {
  n("StringLiteralTypeAnnotation", e, t);
}
function Ct(e, t) {
  n("StringTypeAnnotation", e, t);
}
function Mt(e, t) {
  n("SymbolTypeAnnotation", e, t);
}
function ht(e, t) {
  n("ThisTypeAnnotation", e, t);
}
function Bt(e, t) {
  n("TupleTypeAnnotation", e, t);
}
function Nt(e, t) {
  n("TypeofTypeAnnotation", e, t);
}
function wt(e, t) {
  n("TypeAlias", e, t);
}
function Lt(e, t) {
  n("TypeAnnotation", e, t);
}
function Ft(e, t) {
  n("TypeCastExpression", e, t);
}
function Ot(e, t) {
  n("TypeParameter", e, t);
}
function Xt(e, t) {
  n("TypeParameterDeclaration", e, t);
}
function Jt(e, t) {
  n("TypeParameterInstantiation", e, t);
}
function Kt(e, t) {
  n("UnionTypeAnnotation", e, t);
}
function jt(e, t) {
  n("Variance", e, t);
}
function Rt(e, t) {
  n("VoidTypeAnnotation", e, t);
}
function kt(e, t) {
  n("EnumDeclaration", e, t);
}
function vt(e, t) {
  n("EnumBooleanBody", e, t);
}
function Ut(e, t) {
  n("EnumNumberBody", e, t);
}
function Vt(e, t) {
  n("EnumStringBody", e, t);
}
function Wt(e, t) {
  n("EnumSymbolBody", e, t);
}
function qt(e, t) {
  n("EnumBooleanMember", e, t);
}
function zt(e, t) {
  n("EnumNumberMember", e, t);
}
function Qt(e, t) {
  n("EnumStringMember", e, t);
}
function _t(e, t) {
  n("EnumDefaultedMember", e, t);
}
function Gt(e, t) {
  n("IndexedAccessType", e, t);
}
function Yt(e, t) {
  n("OptionalIndexedAccessType", e, t);
}
function $t(e, t) {
  n("JSXAttribute", e, t);
}
function Ht(e, t) {
  n("JSXClosingElement", e, t);
}
function Zt(e, t) {
  n("JSXElement", e, t);
}
function es(e, t) {
  n("JSXEmptyExpression", e, t);
}
function ts(e, t) {
  n("JSXExpressionContainer", e, t);
}
function ss(e, t) {
  n("JSXSpreadChild", e, t);
}
function ns(e, t) {
  n("JSXIdentifier", e, t);
}
function rs(e, t) {
  n("JSXMemberExpression", e, t);
}
function as(e, t) {
  n("JSXNamespacedName", e, t);
}
function os(e, t) {
  n("JSXOpeningElement", e, t);
}
function is(e, t) {
  n("JSXSpreadAttribute", e, t);
}
function cs(e, t) {
  n("JSXText", e, t);
}
function ps(e, t) {
  n("JSXFragment", e, t);
}
function ls(e, t) {
  n("JSXOpeningFragment", e, t);
}
function us(e, t) {
  n("JSXClosingFragment", e, t);
}
function Ts(e, t) {
  n("Noop", e, t);
}
function Ss(e, t) {
  n("Placeholder", e, t);
}
function fs(e, t) {
  n("V8IntrinsicIdentifier", e, t);
}
function ys(e, t) {
  n("ArgumentPlaceholder", e, t);
}
function ms(e, t) {
  n("BindExpression", e, t);
}
function ds(e, t) {
  n("ImportAttribute", e, t);
}
function Es(e, t) {
  n("Decorator", e, t);
}
function xs(e, t) {
  n("DoExpression", e, t);
}
function As(e, t) {
  n("ExportDefaultSpecifier", e, t);
}
function Ds(e, t) {
  n("RecordExpression", e, t);
}
function Ps(e, t) {
  n("TupleExpression", e, t);
}
function bs(e, t) {
  n("DecimalLiteral", e, t);
}
function Is(e, t) {
  n("ModuleExpression", e, t);
}
function gs(e, t) {
  n("TopicReference", e, t);
}
function Cs(e, t) {
  n("PipelineTopicExpression", e, t);
}
function Ms(e, t) {
  n("PipelineBareFunction", e, t);
}
function hs(e, t) {
  n("PipelinePrimaryTopicReference", e, t);
}
function Bs(e, t) {
  n("TSParameterProperty", e, t);
}
function Ns(e, t) {
  n("TSDeclareFunction", e, t);
}
function ws(e, t) {
  n("TSDeclareMethod", e, t);
}
function Ls(e, t) {
  n("TSQualifiedName", e, t);
}
function Fs(e, t) {
  n("TSCallSignatureDeclaration", e, t);
}
function Os(e, t) {
  n("TSConstructSignatureDeclaration", e, t);
}
function Xs(e, t) {
  n("TSPropertySignature", e, t);
}
function Js(e, t) {
  n("TSMethodSignature", e, t);
}
function Ks(e, t) {
  n("TSIndexSignature", e, t);
}
function js(e, t) {
  n("TSAnyKeyword", e, t);
}
function Rs(e, t) {
  n("TSBooleanKeyword", e, t);
}
function ks(e, t) {
  n("TSBigIntKeyword", e, t);
}
function vs(e, t) {
  n("TSIntrinsicKeyword", e, t);
}
function Us(e, t) {
  n("TSNeverKeyword", e, t);
}
function Vs(e, t) {
  n("TSNullKeyword", e, t);
}
function Ws(e, t) {
  n("TSNumberKeyword", e, t);
}
function qs(e, t) {
  n("TSObjectKeyword", e, t);
}
function zs(e, t) {
  n("TSStringKeyword", e, t);
}
function Qs(e, t) {
  n("TSSymbolKeyword", e, t);
}
function _s(e, t) {
  n("TSUndefinedKeyword", e, t);
}
function Gs(e, t) {
  n("TSUnknownKeyword", e, t);
}
function Ys(e, t) {
  n("TSVoidKeyword", e, t);
}
function $s(e, t) {
  n("TSThisType", e, t);
}
function Hs(e, t) {
  n("TSFunctionType", e, t);
}
function Zs(e, t) {
  n("TSConstructorType", e, t);
}
function en(e, t) {
  n("TSTypeReference", e, t);
}
function tn(e, t) {
  n("TSTypePredicate", e, t);
}
function sn(e, t) {
  n("TSTypeQuery", e, t);
}
function nn(e, t) {
  n("TSTypeLiteral", e, t);
}
function rn(e, t) {
  n("TSArrayType", e, t);
}
function an(e, t) {
  n("TSTupleType", e, t);
}
function on(e, t) {
  n("TSOptionalType", e, t);
}
function cn(e, t) {
  n("TSRestType", e, t);
}
function pn(e, t) {
  n("TSNamedTupleMember", e, t);
}
function ln(e, t) {
  n("TSUnionType", e, t);
}
function un(e, t) {
  n("TSIntersectionType", e, t);
}
function Tn(e, t) {
  n("TSConditionalType", e, t);
}
function Sn(e, t) {
  n("TSInferType", e, t);
}
function fn(e, t) {
  n("TSParenthesizedType", e, t);
}
function yn(e, t) {
  n("TSTypeOperator", e, t);
}
function mn(e, t) {
  n("TSIndexedAccessType", e, t);
}
function dn(e, t) {
  n("TSMappedType", e, t);
}
function En(e, t) {
  n("TSLiteralType", e, t);
}
function xn(e, t) {
  n("TSExpressionWithTypeArguments", e, t);
}
function An(e, t) {
  n("TSInterfaceDeclaration", e, t);
}
function Dn(e, t) {
  n("TSInterfaceBody", e, t);
}
function Pn(e, t) {
  n("TSTypeAliasDeclaration", e, t);
}
function bn(e, t) {
  n("TSInstantiationExpression", e, t);
}
function In(e, t) {
  n("TSAsExpression", e, t);
}
function gn(e, t) {
  n("TSTypeAssertion", e, t);
}
function Cn(e, t) {
  n("TSEnumDeclaration", e, t);
}
function Mn(e, t) {
  n("TSEnumMember", e, t);
}
function hn(e, t) {
  n("TSModuleDeclaration", e, t);
}
function Bn(e, t) {
  n("TSModuleBlock", e, t);
}
function Nn(e, t) {
  n("TSImportType", e, t);
}
function wn(e, t) {
  n("TSImportEqualsDeclaration", e, t);
}
function Ln(e, t) {
  n("TSExternalModuleReference", e, t);
}
function Fn(e, t) {
  n("TSNonNullExpression", e, t);
}
function On(e, t) {
  n("TSExportAssignment", e, t);
}
function Xn(e, t) {
  n("TSNamespaceExportDeclaration", e, t);
}
function Jn(e, t) {
  n("TSTypeAnnotation", e, t);
}
function Kn(e, t) {
  n("TSTypeParameterInstantiation", e, t);
}
function jn(e, t) {
  n("TSTypeParameterDeclaration", e, t);
}
function Rn(e, t) {
  n("TSTypeParameter", e, t);
}
function kn(e, t) {
  n("Standardized", e, t);
}
function vn(e, t) {
  n("Expression", e, t);
}
function Un(e, t) {
  n("Binary", e, t);
}
function Vn(e, t) {
  n("Scopable", e, t);
}
function Wn(e, t) {
  n("BlockParent", e, t);
}
function qn(e, t) {
  n("Block", e, t);
}
function zn(e, t) {
  n("Statement", e, t);
}
function Qn(e, t) {
  n("Terminatorless", e, t);
}
function _n(e, t) {
  n("CompletionStatement", e, t);
}
function Gn(e, t) {
  n("Conditional", e, t);
}
function Yn(e, t) {
  n("Loop", e, t);
}
function $n(e, t) {
  n("While", e, t);
}
function Hn(e, t) {
  n("ExpressionWrapper", e, t);
}
function Zn(e, t) {
  n("For", e, t);
}
function er(e, t) {
  n("ForXStatement", e, t);
}
function tr(e, t) {
  n("Function", e, t);
}
function sr(e, t) {
  n("FunctionParent", e, t);
}
function nr(e, t) {
  n("Pureish", e, t);
}
function rr(e, t) {
  n("Declaration", e, t);
}
function ar(e, t) {
  n("PatternLike", e, t);
}
function or(e, t) {
  n("LVal", e, t);
}
function ir(e, t) {
  n("TSEntityName", e, t);
}
function cr(e, t) {
  n("Literal", e, t);
}
function pr(e, t) {
  n("Immutable", e, t);
}
function lr(e, t) {
  n("UserWhitespacable", e, t);
}
function ur(e, t) {
  n("Method", e, t);
}
function Tr(e, t) {
  n("ObjectMember", e, t);
}
function Sr(e, t) {
  n("Property", e, t);
}
function fr(e, t) {
  n("UnaryLike", e, t);
}
function yr(e, t) {
  n("Pattern", e, t);
}
function mr(e, t) {
  n("Class", e, t);
}
function dr(e, t) {
  n("ModuleDeclaration", e, t);
}
function Er(e, t) {
  n("ExportDeclaration", e, t);
}
function xr(e, t) {
  n("ModuleSpecifier", e, t);
}
function Ar(e, t) {
  n("Accessor", e, t);
}
function Dr(e, t) {
  n("Private", e, t);
}
function Pr(e, t) {
  n("Flow", e, t);
}
function br(e, t) {
  n("FlowType", e, t);
}
function Ir(e, t) {
  n("FlowBaseAnnotation", e, t);
}
function gr(e, t) {
  n("FlowDeclaration", e, t);
}
function Cr(e, t) {
  n("FlowPredicate", e, t);
}
function Mr(e, t) {
  n("EnumBody", e, t);
}
function hr(e, t) {
  n("EnumMember", e, t);
}
function Br(e, t) {
  n("JSX", e, t);
}
function Nr(e, t) {
  n("Miscellaneous", e, t);
}
function wr(e, t) {
  n("TypeScript", e, t);
}
function Lr(e, t) {
  n("TSTypeElement", e, t);
}
function Fr(e, t) {
  n("TSType", e, t);
}
function Or(e, t) {
  n("TSBaseType", e, t);
}
function Xr(e, t) {
  console.trace("The node type NumberLiteral has been renamed to NumericLiteral"), n("NumberLiteral", e, t);
}
function Jr(e, t) {
  console.trace("The node type RegexLiteral has been renamed to RegExpLiteral"), n("RegexLiteral", e, t);
}
function Kr(e, t) {
  console.trace("The node type RestProperty has been renamed to RestElement"), n("RestProperty", e, t);
}
function jr(e, t) {
  console.trace("The node type SpreadProperty has been renamed to SpreadElement"), n("SpreadProperty", e, t);
}
export {
  Vr as default
};
//# sourceMappingURL=index.js.map
