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

package/dist/node_modules/@babel/types/lib/asserts/generated/index.mjs

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