faster-babel-types/dist/esm/development/index.mjs

Faster `@babel/types`

// src/comment.ts
function addComments(node, type, comments) {
  const key = `${type}Comments`;
  if (node[key]) {
    if (type === "leading") {
      node[key] = comments.concat(node[key]);
    } else {
      node[key].push.apply(node[key], comments);
    }
  } else {
    node[key] = comments;
  }
  return node;
}
function addComment(node, type, comment) {
  return addComments(node, type, [comment]);
}

// src/is-node-type.ts
function is(type, node) {
  return node != null && node.type === type;
}

// src/assert-node-type.ts
function assert(type, node) {
  if (is(type, node)) {
    throw new Error(
      'Expected type "' + type + '" but instead got "' + node.type + '".'
    );
  }
}

// src/nodes/flow/expressions/typecast-expression.ts
var TYPE = "TypeCastExpression";
function typeCastExpression(expression, typeAnnotation2) {
  return {
    type: TYPE,
    expression,
    typeAnnotation: typeAnnotation2
  };
}
function isTypeCastExpression(node) {
  return is(TYPE, node);
}
function assertTypeCastExpression(node) {
  assert(TYPE, node);
}

// src/nodes/flow/misc/any-type-annotation.ts
var TYPE2 = "AnyTypeAnnotation";
function anyTypeAnnotation() {
  return {
    type: TYPE2
  };
}
function isAnyTypeAnnotation(node) {
  return is(TYPE2, node);
}
function assertAnyTypeAnnotation(node) {
  assert(TYPE2, node);
}

// src/nodes/flow/misc/array-type-annotation.ts
var TYPE3 = "ArrayTypeAnnotation";
function arrayTypeAnnotation(elementType) {
  return {
    type: TYPE3,
    elementType
  };
}
function isArrayTypeAnnotation(node) {
  return is(TYPE3, node);
}
function assertArrayTypeAnnotation(node) {
  assert(TYPE3, node);
}

// src/nodes/flow/misc/boolean-literal-type-annotation.ts
var TYPE4 = "BooleanLiteralTypeAnnotation";
function booleanLiteralTypeAnnotation(value) {
  return {
    type: TYPE4,
    value
  };
}
function isBooleanLiteralTypeAnnotation(node) {
  return is(TYPE4, node);
}
function assertBooleanLiteralTypeAnnotation(node) {
  assert(TYPE4, node);
}

// src/nodes/flow/misc/boolean-type-annotation.ts
var TYPE5 = "BooleanTypeAnnotation";
function booleanTypeAnnotation() {
  return {
    type: TYPE5
  };
}
function isBooleanTypeAnnotation(node) {
  return is(TYPE5, node);
}
function assertBooleanTypeAnnotation(node) {
  assert(TYPE5, node);
}

// src/nodes/flow/misc/empty-type-annotation.ts
var TYPE6 = "EmptyTypeAnnotation";
function emptyTypeAnnotation() {
  return {
    type: TYPE6
  };
}
function isEmptyTypeAnnotation(node) {
  return is(TYPE6, node);
}
function assertEmptyTypeAnnotation(node) {
  assert(TYPE6, node);
}

// src/nodes/flow/misc/enum-boolean-body.ts
var TYPE7 = "EnumBooleanBody";
function enumBooleanBody(members) {
  return {
    type: TYPE7,
    members,
    explicitType: false,
    hasUnknownMembers: false
  };
}
function isEnumBooleanBody(node) {
  return is(TYPE7, node);
}
function assertEnumBooleanBody(node) {
  assert(TYPE7, node);
}

// src/nodes/flow/misc/enum-boolean-member.ts
var TYPE8 = "EnumBooleanMember";
function enumBooleanMember(id) {
  return {
    type: TYPE8,
    id,
    init: null
  };
}
function isEnumBooleanMember(node) {
  return is(TYPE8, node);
}
function assertEnumBooleanMember(node) {
  assert(TYPE8, node);
}

// src/nodes/flow/misc/enum-defaulted-member.ts
var TYPE9 = "EnumDefaultedMember";
function enumDefaultedMember(id) {
  return {
    type: TYPE9,
    id
  };
}
function isEnumDefaultedMember(node) {
  return is(TYPE9, node);
}
function assertEnumDefaultedMember(node) {
  assert(TYPE9, node);
}

// src/nodes/flow/misc/enum-number-body.ts
var TYPE10 = "EnumNumberBody";
function enumNumberBody(members) {
  return {
    type: TYPE10,
    members,
    explicitType: false,
    hasUnknownMembers: false
  };
}
function isEnumNumberBody(node) {
  return is(TYPE10, node);
}
function assertEnumNumberBody(node) {
  assert(TYPE10, node);
}

// src/nodes/flow/misc/enum-number-member.ts
var TYPE11 = "EnumNumberMember";
function enumNumberMember(id, init) {
  return {
    type: TYPE11,
    id,
    init
  };
}
function isEnumNumberMember(node) {
  return is(TYPE11, node);
}
function assertEnumNumberMember(node) {
  assert(TYPE11, node);
}

// src/nodes/flow/misc/enum-string-body.ts
var TYPE12 = "EnumStringBody";
function enumStringBody(members) {
  return {
    type: TYPE12,
    members,
    explicitType: false,
    hasUnknownMembers: false
  };
}
function isEnumStringBody(node) {
  return is(TYPE12, node);
}
function assertEnumStringBody(node) {
  assert(TYPE12, node);
}

// src/nodes/flow/misc/enum-string-member.ts
var TYPE13 = "EnumStringMember";
function enumStringMember(id, init) {
  return {
    type: TYPE13,
    id,
    init
  };
}
function isEnumStringMember(node) {
  return is(TYPE13, node);
}
function assertEnumStringMember(node) {
  assert(TYPE13, node);
}

// src/nodes/flow/misc/enum-symbol-body.ts
var TYPE14 = "EnumSymbolBody";
function enumSymbolBody(members) {
  return {
    type: TYPE14,
    members,
    hasUnknownMembers: false
  };
}
function isEnumSymbolBody(node) {
  return is(TYPE14, node);
}
function assertEnumSymbolBody(node) {
  assert(TYPE14, node);
}

// src/nodes/flow/misc/exists-type-annotation.ts
var TYPE15 = "ExistsTypeAnnotation";
function existsTypeAnnotation() {
  return {
    type: TYPE15
  };
}
function isExistsTypeAnnotation(node) {
  return is(TYPE15, node);
}
function assertExistsTypeAnnotation(node) {
  assert(TYPE15, node);
}

// src/nodes/flow/misc/function-type-annotation.ts
var TYPE16 = "FunctionTypeAnnotation";
function functionTypeAnnotation(typeParameters, params, rest, returnType) {
  return {
    type: TYPE16,
    typeParameters,
    params,
    rest,
    returnType
  };
}
function isFunctionTypeAnnotation(node) {
  return is(TYPE16, node);
}
function assertFunctionTypeAnnotation(node) {
  assert(TYPE16, node);
}

// src/nodes/flow/misc/function-type-param.ts
var TYPE17 = "FunctionTypeParam";
function functionTypeParam(name, typeAnnotation2) {
  return {
    type: TYPE17,
    name,
    typeAnnotation: typeAnnotation2
  };
}
function isFunctionTypeParam(node) {
  return is(TYPE17, node);
}
function assertFunctionTypeParam(node) {
  assert(TYPE17, node);
}

// src/nodes/flow/misc/generic-type-annotation.ts
var TYPE18 = "GenericTypeAnnotation";
function genericTypeAnnotation(id, typeParameters = null) {
  return {
    type: TYPE18,
    id,
    typeParameters
  };
}
function isGenericTypeAnnotation(node) {
  return is(TYPE18, node);
}
function assertGenericTypeAnnotation(node) {
  assert(TYPE18, node);
}

// src/nodes/flow/misc/indexed-access-type.ts
var TYPE19 = "IndexedAccessType";
function indexedAccessType(objectType, indexType) {
  return {
    type: TYPE19,
    objectType,
    indexType
  };
}
function isIndexedAccessType(node) {
  return is(TYPE19, node);
}
function assertIndexedAccessType(node) {
  assert(TYPE19, node);
}

// src/nodes/flow/misc/interface-extends.ts
var TYPE20 = "InterfaceExtends";
function interfaceExtends(id, typeParameters = null) {
  return {
    type: TYPE20,
    id,
    typeParameters
  };
}
function isInterfaceExtends(node) {
  return is(TYPE20, node);
}
function assertInterfaceExtends(node) {
  assert(TYPE20, node);
}

// src/nodes/flow/misc/interface-type-annotation.ts
var TYPE21 = "InterfaceTypeAnnotation";
function interfaceTypeAnnotation(interfaceExtends2, body) {
  return {
    type: TYPE21,
    extends: interfaceExtends2,
    body
  };
}
function isInterfaceTypeAnnotation(node) {
  return is(TYPE21, node);
}
function assertInterfaceTypeAnnotation(node) {
  assert(TYPE21, node);
}

// src/nodes/flow/misc/intersection-type-annotation.ts
var TYPE22 = "IntersectionTypeAnnotation";
function intersectionTypeAnnotation(types) {
  return {
    type: TYPE22,
    types
  };
}
function isIntersectionTypeAnnotation(node) {
  return is(TYPE22, node);
}
function assertIntersectionTypeAnnotation(node) {
  assert(TYPE22, node);
}

// src/nodes/flow/misc/mixed-type-annotation.ts
var TYPE23 = "MixedTypeAnnotation";
function mixedTypeAnnotation() {
  return {
    type: TYPE23
  };
}
function isMixedTypeAnnotation(node) {
  return is(TYPE23, node);
}
function assertMixedTypeAnnotation(node) {
  assert(TYPE23, node);
}

// src/nodes/flow/misc/null-literal-type-annotation.ts
var TYPE24 = "NullLiteralTypeAnnotation";
function nullLiteralTypeAnnotation() {
  return {
    type: TYPE24
  };
}
function isNullLiteralTypeAnnotation(node) {
  return is(TYPE24, node);
}
function assertNullLiteralTypeAnnotation(node) {
  assert(TYPE24, node);
}

// src/nodes/flow/misc/nullable-type-annotation.ts
var TYPE25 = "NullableTypeAnnotation";
function nullableTypeAnnotation(typeAnnotation2) {
  return {
    type: TYPE25,
    typeAnnotation: typeAnnotation2
  };
}
function isNullableTypeAnnotation(node) {
  return is(TYPE25, node);
}
function assertNullableTypeAnnotation(node) {
  assert(TYPE25, node);
}

// src/nodes/flow/misc/number-literal-type-annotation.ts
var TYPE26 = "NumberLiteralTypeAnnotation";
function numberLiteralTypeAnnotation(value) {
  return {
    type: TYPE26,
    value
  };
}
function isNumberLiteralTypeAnnotation(node) {
  return is(TYPE26, node);
}
function assertNumberLiteralTypeAnnotation(node) {
  assert(TYPE26, node);
}

// src/nodes/flow/misc/number-type-annotation.ts
var TYPE27 = "NumberTypeAnnotation";
function numberTypeAnnotation() {
  return {
    type: TYPE27
  };
}
function isNumberTypeAnnotation(node) {
  return is(TYPE27, node);
}
function assertNumberTypeAnnotation(node) {
  assert(TYPE27, node);
}

// src/nodes/flow/misc/object-type-annotation.ts
var TYPE28 = "ObjectTypeAnnotation";
function objectTypeAnnotation(properties, indexers = [], callProperties = [], internalSlots = [], exact = false) {
  return {
    type: TYPE28,
    properties,
    indexers,
    callProperties,
    internalSlots,
    exact
  };
}
function isObjectTypeAnnotation(node) {
  return is(TYPE28, node);
}
function assertObjectTypeAnnotation(node) {
  assert(TYPE28, node);
}

// src/nodes/flow/misc/object-type-call-property.ts
var TYPE29 = "ObjectTypeCallProperty";
function objectTypeCallProperty(value) {
  return {
    type: TYPE29,
    value,
    static: false
  };
}
function isObjectTypeCallProperty(node) {
  return is(TYPE29, node);
}
function assertObjectTypeCallProperty(node) {
  assert(TYPE29, node);
}

// src/nodes/flow/misc/object-type-indexer.ts
var TYPE30 = "ObjectTypeIndexer";
function objectTypeIndexer(id, key, value, variance2 = null) {
  return {
    type: TYPE30,
    id,
    key,
    value,
    variance: variance2,
    static: false
  };
}
function isObjectTypeIndexer(node) {
  return is(TYPE30, node);
}
function assertObjectTypeIndexer(node) {
  assert(TYPE30, node);
}

// src/nodes/flow/misc/object-type-internal-slot.ts
var TYPE31 = "ObjectTypeInternalSlot";
function objectTypeInternalSlot(id, value, optional, isStatic, method) {
  return {
    type: TYPE31,
    id,
    value,
    optional,
    static: isStatic,
    method
  };
}
function isObjectTypeInternalSlot(node) {
  return is(TYPE31, node);
}
function assertObjectTypeInternalSlot(node) {
  assert(TYPE31, node);
}

// src/nodes/flow/misc/object-type-property.ts
var TYPE32 = "ObjectTypeProperty";
function objectTypeProperty(key, value, variance2 = null) {
  return {
    type: TYPE32,
    key,
    value,
    variance: variance2,
    kind: "init",
    method: false,
    optional: false,
    proto: false,
    static: false
  };
}
function isObjectTypeProperty(node) {
  return is(TYPE32, node);
}
function assertObjectTypeProperty(node) {
  assert(TYPE32, node);
}

// src/nodes/flow/misc/object-type-spread-property.ts
var TYPE33 = "ObjectTypeSpreadProperty";
function objectTypeSpreadProperty(argument) {
  return {
    type: TYPE33,
    argument
  };
}
function isObjectTypeSpreadProperty(node) {
  return is(TYPE33, node);
}
function assertObjectTypeSpreadProperty(node) {
  assert(TYPE33, node);
}

// src/nodes/flow/misc/optional-indexed-access-type.ts
var TYPE34 = "OptionalIndexedAccessType";
function optionalIndexedAccessType(objectType, indexType) {
  return {
    type: TYPE34,
    objectType,
    indexType,
    optional: false
  };
}
function isOptionalIndexedAccessType(node) {
  return is(TYPE34, node);
}
function assertOptionalIndexedAccessType(node) {
  assert(TYPE34, node);
}

// src/nodes/flow/misc/qualified-type-identifier.ts
var TYPE35 = "QualifiedTypeIdentifier";
function qualifiedTypeIdentifier(id, qualification) {
  return {
    type: TYPE35,
    id,
    qualification
  };
}
function isQualifiedTypeIdentifier(node) {
  return is(TYPE35, node);
}
function assertQualifiedTypeIdentifier(node) {
  assert(TYPE35, node);
}

// src/nodes/flow/misc/string-literal-type-annotation.ts
var TYPE36 = "StringLiteralTypeAnnotation";
function stringLiteralTypeAnnotation(value) {
  return {
    type: TYPE36,
    value
  };
}
function isStringLiteralTypeAnnotation(node) {
  return is(TYPE36, node);
}
function assertStringLiteralTypeAnnotation(node) {
  assert(TYPE36, node);
}

// src/nodes/flow/misc/string-type-annotation.ts
var TYPE37 = "StringTypeAnnotation";
function stringTypeAnnotation() {
  return {
    type: TYPE37
  };
}
function isStringTypeAnnotation(node) {
  return is(TYPE37, node);
}
function assertStringTypeAnnotation(node) {
  assert(TYPE37, node);
}

// src/nodes/flow/misc/symbol-type-annotation.ts
var TYPE38 = "SymbolTypeAnnotation";
function symbolTypeAnnotation() {
  return {
    type: TYPE38
  };
}
function isSymbolTypeAnnotation(node) {
  return is(TYPE38, node);
}
function assertSymbolTypeAnnotation(node) {
  assert(TYPE38, node);
}

// src/nodes/flow/misc/this-type-annotation.ts
var TYPE39 = "ThisTypeAnnotation";
function thisTypeAnnotation() {
  return {
    type: TYPE39
  };
}
function isThisTypeAnnotation(node) {
  return is(TYPE39, node);
}
function assertThisTypeAnnotation(node) {
  assert(TYPE39, node);
}

// src/nodes/flow/misc/tuple-type-annotation.ts
var TYPE40 = "TupleTypeAnnotation";
function tupleTypeAnnotation(types) {
  return {
    type: TYPE40,
    types
  };
}
function isTupleTypeAnnotation(node) {
  return is(TYPE40, node);
}
function assertTupleTypeAnnotation(node) {
  assert(TYPE40, node);
}

// src/nodes/flow/misc/type-annotation.ts
var TYPE41 = "TypeAnnotation";
function typeAnnotation(typeAnnotation2) {
  return {
    type: TYPE41,
    typeAnnotation: typeAnnotation2
  };
}
function isTypeAnnotation(node) {
  return is(TYPE41, node);
}
function assertTypeAnnotation(node) {
  assert(TYPE41, node);
}

// src/nodes/flow/misc/typeof-type-annotation.ts
var TYPE42 = "TypeofTypeAnnotation";
function typeofTypeAnnotation(argument) {
  return {
    type: TYPE42,
    argument
  };
}
function isTypeofTypeAnnotation(node) {
  return is(TYPE42, node);
}
function assertTypeofTypeAnnotation(node) {
  assert(TYPE42, node);
}

// src/nodes/flow/misc/union-type-annotation.ts
var TYPE43 = "UnionTypeAnnotation";
function unionTypeAnnotation(types) {
  return {
    type: TYPE43,
    types
  };
}
function isUnionTypeAnnotation(node) {
  return is(TYPE43, node);
}
function assertUnionTypeAnnotation(node) {
  assert(TYPE43, node);
}

// src/nodes/flow/misc/variance.ts
var TYPE44 = "Variance";
function variance(kind) {
  return {
    type: TYPE44,
    kind
  };
}
function isVariance(node) {
  return is(TYPE44, node);
}
function assertVariance(node) {
  assert(TYPE44, node);
}

// src/nodes/flow/misc/void-type-annotation.ts
var TYPE45 = "VoidTypeAnnotation";
function voidTypeAnnotation() {
  return {
    type: TYPE45
  };
}
function isVoidTypeAnnotation(node) {
  return is(TYPE45, node);
}
function assertVoidTypeAnnotation(node) {
  assert(TYPE45, node);
}

// src/nodes/flow/statements/declare-class.ts
var TYPE46 = "DeclareClass";
function declareClass(id, typeParameters, interfaceExtends2, body) {
  return {
    type: TYPE46,
    id,
    typeParameters,
    extends: interfaceExtends2,
    body
  };
}
function isDeclareClass(node) {
  return is(TYPE46, node);
}
function assertDeclareClass(node) {
  assert(TYPE46, node);
}

// src/nodes/flow/statements/declare-export-all-declaration.ts
var TYPE47 = "DeclareExportAllDeclaration";
function declareExportAllDeclaration(source) {
  return {
    type: TYPE47,
    source
  };
}
function isDeclareExportAllDeclaration(node) {
  return is(TYPE47, node);
}
function assertDeclareExportAllDeclaration(node) {
  assert(TYPE47, node);
}

// src/nodes/flow/statements/declare-export-declaration.ts
var TYPE48 = "DeclareExportDeclaration";
function declareExportDeclaration(declaration, specifiers, source) {
  return {
    type: TYPE48,
    declaration,
    specifiers,
    source
  };
}
function isDeclareExportDeclaration(node) {
  return is(TYPE48, node);
}
function assertDeclareExportDeclaration(node) {
  assert(TYPE48, node);
}

// src/nodes/flow/statements/declare-function.ts
var TYPE49 = "DeclareFunction";
function declareFunction(id) {
  return {
    type: TYPE49,
    id
  };
}
function isDeclareFunction(node) {
  return is(TYPE49, node);
}
function assertDeclareFunction(node) {
  assert(TYPE49, node);
}

// src/nodes/flow/statements/declare-interface.ts
var TYPE50 = "DeclareInterface";
function declareInterface(id, typeParameters, interfaceExtends2, body) {
  return {
    type: TYPE50,
    id,
    typeParameters,
    extends: interfaceExtends2,
    body
  };
}
function isDeclareInterface(node) {
  return is(TYPE50, node);
}
function assertDeclareInterface(node) {
  assert(TYPE50, node);
}

// src/nodes/flow/statements/declare-module.ts
var TYPE51 = "DeclareModule";
function declareModule(id, body, kind) {
  return {
    type: TYPE51,
    id,
    body,
    kind
  };
}
function isDeclareModule(node) {
  return is(TYPE51, node);
}
function assertDeclareModule(node) {
  assert(TYPE51, node);
}

// src/nodes/flow/statements/declare-module-exports.ts
var TYPE52 = "DeclareModuleExports";
function declareModuleExports(typeAnnotation2) {
  return {
    type: TYPE52,
    typeAnnotation: typeAnnotation2
  };
}
function isDeclareModuleExports(node) {
  return is(TYPE52, node);
}
function assertDeclareModuleExports(node) {
  assert(TYPE52, node);
}

// src/nodes/flow/statements/declare-opaque-type.ts
var TYPE53 = "DeclareOpaqueType";
function declareOpaqueType(id, typeParameters, supertype) {
  return {
    type: TYPE53,
    id,
    typeParameters,
    supertype
  };
}
function isDeclareOpaqueType(node) {
  return is(TYPE53, node);
}
function assertDeclareOpaqueType(node) {
  assert(TYPE53, node);
}

// src/nodes/flow/statements/declare-type-alias.ts
var TYPE54 = "DeclareTypeAlias";
function declareTypeAlias(id, typeParameters, right) {
  return {
    type: TYPE54,
    id,
    typeParameters,
    right
  };
}
function isDeclareTypeAlias(node) {
  return is(TYPE54, node);
}
function assertDeclareTypeAlias(node) {
  assert(TYPE54, node);
}

// src/nodes/flow/statements/declare-variable.ts
var TYPE55 = "DeclareVariable";
function declareVariable(id) {
  return {
    type: TYPE55,
    id
  };
}
function isDeclareVariable(node) {
  return is(TYPE55, node);
}
function assertDeclareVariable(node) {
  assert(TYPE55, node);
}

// src/nodes/flow/statements/enum-declaration.ts
var TYPE56 = "EnumDeclaration";
function enumDeclaration(id, body) {
  return {
    type: TYPE56,
    id,
    body
  };
}
function isEnumDeclaration(node) {
  return is(TYPE56, node);
}
function assertEnumDeclaration(node) {
  assert(TYPE56, node);
}

// src/nodes/flow/statements/interface-declaration.ts
var TYPE57 = "InterfaceDeclaration";
function interfaceDeclaration(id, typeParameters, interfaceExtends2, body) {
  return {
    type: TYPE57,
    id,
    typeParameters,
    extends: interfaceExtends2,
    body
  };
}
function isInterfaceDeclaration(node) {
  return is(TYPE57, node);
}
function assertInterfaceDeclaration(node) {
  assert(TYPE57, node);
}

// src/nodes/flow/statements/opaque-type.ts
var TYPE58 = "OpaqueType";
function opaqueType(id, typeParameters, supertype, impltype) {
  return {
    type: TYPE58,
    id,
    typeParameters,
    supertype,
    impltype
  };
}
function isOpaqueType(node) {
  return is(TYPE58, node);
}
function assertOpaqueType(node) {
  assert(TYPE58, node);
}

// src/nodes/flow/statements/type-alias.ts
var TYPE59 = "TypeAlias";
function typeAlias(id, typeParameters, right) {
  return {
    type: TYPE59,
    id,
    typeParameters,
    right
  };
}
function isTypeAlias(node) {
  return is(TYPE59, node);
}
function assertTypeAlias(node) {
  assert(TYPE59, node);
}

// src/nodes/javascript/expressions/array-expression.ts
var TYPE60 = "ArrayExpression";
function arrayExpression(elements = []) {
  return {
    type: TYPE60,
    elements
  };
}
function isArrayExpression(node) {
  return is(TYPE60, node);
}
function assertArrayExpression(node) {
  assert(TYPE60, node);
}

// src/nodes/javascript/expressions/arrow-function-expression.ts
var TYPE61 = "ArrowFunctionExpression";
function arrowFunctionExpression(params, body, async = false) {
  return {
    type: TYPE61,
    params,
    body,
    async,
    expression: null
    // ??? originally they use null
  };
}
function isArrowFunctionExpression(node) {
  return is(TYPE61, node);
}
function assertArrowFunctionExpression(node) {
  assert(TYPE61, node);
}

// src/nodes/javascript/expressions/assignment-expression.ts
var TYPE62 = "AssignmentExpression";
function assignmentExpression(operator, left, right) {
  return {
    type: TYPE62,
    operator,
    left,
    right
  };
}
function isAssignmentExpression(node) {
  return is(TYPE62, node);
}
function assertAssignmentExpression(node) {
  assert(TYPE62, node);
}

// src/nodes/javascript/expressions/await-expression.ts
var TYPE63 = "AwaitExpression";
function awaitExpression(argument) {
  return {
    type: TYPE63,
    argument
  };
}
function isAwaitExpression(node) {
  return is(TYPE63, node);
}
function assertAwaitExpression(node) {
  assert(TYPE63, node);
}

// src/nodes/javascript/expressions/bigint-literal.ts
var TYPE64 = "BigIntLiteral";
function bigIntLiteral(value) {
  return {
    type: TYPE64,
    value
  };
}
function isBigIntLiteral(node) {
  return is(TYPE64, node);
}
function assertBigIntLiteral(node) {
  assert(TYPE64, node);
}

// src/nodes/javascript/expressions/binary-expression.ts
var TYPE65 = "BinaryExpression";
function binaryExpression(operator, left, right) {
  return {
    type: TYPE65,
    operator,
    left,
    right
  };
}
function isBinaryExpression(node) {
  return is(TYPE65, node);
}
function assertBinaryExpression(node) {
  assert(TYPE65, node);
}

// src/nodes/javascript/expressions/bind-expression.ts
var TYPE66 = "BindExpression";
function bindExpression(object, callee) {
  return {
    type: TYPE66,
    object,
    callee
  };
}
function isBindExpression(node) {
  return is(TYPE66, node);
}
function assertBindExpression(node) {
  assert(TYPE66, node);
}

// src/nodes/javascript/expressions/boolean-literal.ts
var TYPE67 = "BooleanLiteral";
function booleanLiteral(value) {
  return {
    type: TYPE67,
    value
  };
}
function isBooleanLiteral(node) {
  return is(TYPE67, node);
}
function assertBooleanLiteral(node) {
  assert(TYPE67, node);
}

// src/nodes/javascript/expressions/call-expression.ts
var TYPE68 = "CallExpression";
function callExpression(callee, args) {
  return {
    type: TYPE68,
    callee,
    arguments: args
  };
}
function isCallExpression(node) {
  return is(TYPE68, node);
}
function assertCallExpression(node) {
  assert(TYPE68, node);
}

// src/nodes/javascript/expressions/class-expression.ts
var TYPE69 = "ClassExpression";
function classExpression(id, superClass, body, decorators = null) {
  return {
    type: TYPE69,
    id,
    superClass,
    body,
    decorators
  };
}
function isClassExpression(node) {
  return is(TYPE69, node);
}
function assertClassExpression(node) {
  assert(TYPE69, node);
}

// src/nodes/javascript/expressions/conditional-expression.ts
var TYPE70 = "ConditionalExpression";
function conditionalExpression(test, consequent, alternate) {
  return {
    type: TYPE70,
    test,
    consequent,
    alternate
  };
}
function isConditionalExpression(node) {
  return is(TYPE70, node);
}
function assertConditionalExpression(node) {
  assert(TYPE70, node);
}

// src/nodes/javascript/expressions/decimal-literal.ts
var TYPE71 = "DecimalLiteral";
function decimalLiteral(value) {
  return {
    type: TYPE71,
    value
  };
}
function isDecimalLiteral(node) {
  return is(TYPE71, node);
}
function assertDecimalLiteral(node) {
  assert(TYPE71, node);
}

// src/nodes/javascript/expressions/do-expression.ts
var TYPE72 = "DoExpression";
function doExpression(body, async = false) {
  return {
    type: TYPE72,
    body,
    async
  };
}
function isDoExpression(node) {
  return is(TYPE72, node);
}
function assertDoExpression(node) {
  assert(TYPE72, node);
}

// src/nodes/javascript/expressions/function-expression.ts
var TYPE73 = "FunctionExpression";
function functionExpression(id, params, body, generator = false, async = false) {
  return {
    type: TYPE73,
    id,
    params,
    body,
    generator,
    async
  };
}
function isFunctionExpression(node) {
  return is(TYPE73, node);
}
function assertFunctionExpression(node) {
  assert(TYPE73, node);
}

// src/nodes/javascript/expressions/identifier.ts
var TYPE74 = "Identifier";
function identifier(name) {
  return {
    type: TYPE74,
    name
  };
}
function isIdentifier(node) {
  return is(TYPE74, node);
}
function assertIdentifier(node) {
  assert(TYPE74, node);
}

// src/nodes/javascript/expressions/import.ts
var TYPE75 = "Import";
function _import() {
  return {
    type: TYPE75
  };
}
function isImport(node) {
  return is(TYPE75, node);
}
function assertImport(node) {
  assert(TYPE75, node);
}

// src/nodes/javascript/expressions/import-expression.ts
var TYPE76 = "ImportExpression";
function importExpression(source, options = null) {
  return {
    type: TYPE76,
    source,
    options
  };
}
function isImportExpression(node) {
  return is(TYPE76, node);
}
function assertImportExpression(node) {
  assert(TYPE76, node);
}

// src/nodes/javascript/expressions/logical-expression.ts
var TYPE77 = "LogicalExpression";
function logicalExpression(operator, left, right) {
  return {
    type: TYPE77,
    operator,
    left,
    right
  };
}
function isLogicalExpression(node) {
  return is(TYPE77, node);
}
function assertLogicalExpression(node) {
  assert(TYPE77, node);
}

// src/nodes/javascript/expressions/member-expression.ts
var TYPE78 = "MemberExpression";
function memberExpression(object, property, computed = false, optional = false) {
  return {
    type: TYPE78,
    object,
    property,
    computed,
    optional
  };
}
function isMemberExpression(node) {
  return is(TYPE78, node);
}
function assertMemberExpression(node) {
  assert(TYPE78, node);
}

// src/nodes/javascript/expressions/meta-property.ts
var TYPE79 = "MetaProperty";
function metaProperty(meta, property) {
  return {
    type: TYPE79,
    meta,
    property
  };
}
function isMetaProperty(node) {
  return is(TYPE79, node);
}
function assertMetaProperty(node) {
  assert(TYPE79, node);
}

// src/nodes/javascript/expressions/module-expression.ts
var TYPE80 = "ModuleExpression";
function moduleExpression(body) {
  return {
    type: TYPE80,
    body
  };
}
function isModuleExpression(node) {
  return is(TYPE80, node);
}
function assertModuleExpression(node) {
  assert(TYPE80, node);
}

// src/nodes/javascript/expressions/new-expression.ts
var TYPE81 = "NewExpression";
function newExpression(callee, args) {
  return {
    type: TYPE81,
    callee,
    arguments: args
  };
}
function isNewExpression(node) {
  return is(TYPE81, node);
}
function assertNewExpression(node) {
  assert(TYPE81, node);
}

// src/nodes/javascript/expressions/null-literal.ts
var TYPE82 = "NullLiteral";
function nullLiteral() {
  return {
    type: TYPE82
  };
}
function isNullLiteral(node) {
  return is(TYPE82, node);
}
function assertNullLiteral(node) {
  assert(TYPE82, node);
}

// src/nodes/javascript/expressions/numeric-literal.ts
var TYPE83 = "NumericLiteral";
function numericLiteral(value) {
  return {
    type: TYPE83,
    value
  };
}
function isNumericLiteral(node) {
  return is(TYPE83, node);
}
function assertNumericLiteral(node) {
  assert(TYPE83, node);
}

// src/nodes/javascript/expressions/object-expression.ts
var TYPE84 = "ObjectExpression";
function objectExpression(properties) {
  return {
    type: TYPE84,
    properties
  };
}
function isObjectExpression(node) {
  return is(TYPE84, node);
}
function assertObjectExpression(node) {
  assert(TYPE84, node);
}

// src/nodes/javascript/expressions/optional-call-expression.ts
var TYPE85 = "OptionalCallExpression";
function optionalCallExpression(callee, args, optional) {
  return {
    type: TYPE85,
    callee,
    arguments: args,
    optional
  };
}
function isOptionalCallExpression(node) {
  return is(TYPE85, node);
}
function assertOptionalCallExpression(node) {
  assert(TYPE85, node);
}

// src/nodes/javascript/expressions/optional-member-expression.ts
var TYPE86 = "OptionalMemberExpression";
function optionalMemberExpression(object, property, computed = false, optional = false) {
  return {
    type: TYPE86,
    object,
    property,
    computed,
    optional
  };
}
function isOptionalMemberExpression(node) {
  return is(TYPE86, node);
}
function assertOptionalMemberExpression(node) {
  assert(TYPE86, node);
}

// src/nodes/javascript/expressions/parenthesized-expression.ts
var TYPE87 = "ParenthesizedExpression";
function parenthesizedExpression(expression) {
  return {
    type: TYPE87,
    expression
  };
}
function isParenthesizedExpression(node) {
  return is(TYPE87, node);
}
function assertParenthesizedExpression(node) {
  assert(TYPE87, node);
}

// src/nodes/javascript/expressions/pipeline-bare-function.ts
var TYPE88 = "PipelineBareFunction";
function pipelineBareFunction(callee) {
  return {
    type: TYPE88,
    callee
  };
}
function isPipelineBareFunction(node) {
  return is(TYPE88, node);
}
function assertPipelineBareFunction(node) {
  assert(TYPE88, node);
}

// src/nodes/javascript/expressions/pipeline-primary-topic-reference.ts
var TYPE89 = "PipelinePrimaryTopicReference";
function pipelinePrimaryTopicReference() {
  return {
    type: TYPE89
  };
}
function isPipelinePrimaryTopicReference(node) {
  return is(TYPE89, node);
}
function assertPipelinePrimaryTopicReference(node) {
  assert(TYPE89, node);
}

// src/nodes/javascript/expressions/pipeline-topic-expression.ts
var TYPE90 = "PipelineTopicExpression";
function pipelineTopicExpression(expression) {
  return {
    type: TYPE90,
    expression
  };
}
function isPipelineTopicExpression(node) {
  return is(TYPE90, node);
}
function assertPipelineTopicExpression(node) {
  assert(TYPE90, node);
}

// src/nodes/javascript/expressions/record-expression.ts
var TYPE91 = "RecordExpression";
function recordExpression(properties) {
  return {
    type: TYPE91,
    properties
  };
}
function isRecordExpression(node) {
  return is(TYPE91, node);
}
function assertRecordExpression(node) {
  assert(TYPE91, node);
}

// src/nodes/javascript/expressions/regexp-literal.ts
var TYPE92 = "RegExpLiteral";
function regExpLiteral(pattern, flags = "") {
  return {
    type: TYPE92,
    pattern,
    flags
  };
}
function isRegExpLiteral(node) {
  return is(TYPE92, node);
}
function assertRegExpLiteral(node) {
  assert(TYPE92, node);
}

// src/nodes/javascript/expressions/sequence-expression.ts
var TYPE93 = "SequenceExpression";
function sequenceExpression(expressions) {
  return {
    type: TYPE93,
    expressions
  };
}
function isSequenceExpression(node) {
  return is(TYPE93, node);
}
function assertSequenceExpression(node) {
  assert(TYPE93, node);
}

// src/nodes/javascript/expressions/string-literal.ts
var TYPE94 = "StringLiteral";
function stringLiteral(value) {
  return {
    type: TYPE94,
    value
  };
}
function isStringLiteral(node) {
  return is(TYPE94, node);
}
function assertStringLiteral(node) {
  assert(TYPE94, node);
}

// src/nodes/javascript/expressions/super.ts
var TYPE95 = "Super";
function _super() {
  return {
    type: TYPE95
  };
}
function isSuper(node) {
  return is(TYPE95, node);
}
function assertSuper(node) {
  assert(TYPE95, node);
}

// src/nodes/javascript/expressions/tagged-template-expression.ts
var TYPE96 = "TaggedTemplateExpression";
function taggedTemplateExpression(tag, quasi) {
  return {
    type: TYPE96,
    tag,
    quasi
  };
}
function isTaggedTemplateExpression(node) {
  return is(TYPE96, node);
}
function assertTaggedTemplateExpression(node) {
  assert(TYPE96, node);
}

// src/nodes/javascript/expressions/template-literal.ts
var TYPE97 = "TemplateLiteral";
function templateLiteral(quasis, expressions) {
  return {
    type: TYPE97,
    quasis,
    expressions
  };
}
function isTemplateLiteral(node) {
  return is(TYPE97, node);
}
function assertTemplateLiteral(node) {
  assert(TYPE97, node);
}

// src/nodes/javascript/expressions/this-expression.ts
var TYPE98 = "ThisExpression";
function thisExpression() {
  return {
    type: TYPE98
  };
}
function isThisExpression(node) {
  return is(TYPE98, node);
}
function assertThisExpression(node) {
  assert(TYPE98, node);
}

// src/nodes/javascript/expressions/topic-reference.ts
var TYPE99 = "TopicReference";
function topicReference() {
  return {
    type: TYPE99
  };
}
function isTopicReference(node) {
  return is(TYPE99, node);
}
function assertTopicReference(node) {
  assert(TYPE99, node);
}

// src/nodes/javascript/expressions/tuple-expression.ts
var TYPE100 = "TupleExpression";
function tupleExpression(elements = []) {
  return {
    type: TYPE100,
    elements
  };
}
function isTupleExpression(node) {
  return is(TYPE100, node);
}
function assertTupleExpression(node) {
  assert(TYPE100, node);
}

// src/nodes/javascript/expressions/unary-expression.ts
var TYPE101 = "UnaryExpression";
function unaryExpression(operator, argument, prefix = true) {
  return {
    type: TYPE101,
    operator,
    argument,
    prefix
  };
}
function isUnaryExpression(node) {
  return is(TYPE101, node);
}
function assertUnaryExpression(node) {
  assert(TYPE101, node);
}

// src/nodes/javascript/expressions/update-expression.ts
var TYPE102 = "UpdateExpression";
function updateExpression(operator, argument, prefix = false) {
  return {
    type: TYPE102,
    operator,
    argument,
    prefix
  };
}
function isUpdateExpression(node) {
  return is(TYPE102, node);
}
function assertUpdateExpression(node) {
  assert(TYPE102, node);
}

// src/nodes/javascript/expressions/yield-expression.ts
var TYPE103 = "YieldExpression";
function yieldExpression(argument = null, delegate = false) {
  return {
    type: TYPE103,
    argument,
    delegate
  };
}
function isYieldExpression(node) {
  return is(TYPE103, node);
}
function assertYieldExpression(node) {
  assert(TYPE103, node);
}

// src/nodes/javascript/misc/argument-placeholder.ts
var TYPE104 = "ArgumentPlaceholder";
function argumentPlaceholder() {
  return {
    type: TYPE104
  };
}
function isArgumentPlaceholder(node) {
  return is(TYPE104, node);
}
function assertArgumentPlaceholder(node) {
  assert(TYPE104, node);
}

// src/nodes/javascript/misc/array-pattern.ts
var TYPE105 = "ArrayPattern";
function arrayPattern(elements) {
  return {
    type: TYPE105,
    elements
  };
}
function isArrayPattern(node) {
  return is(TYPE105, node);
}
function assertArrayPattern(node) {
  assert(TYPE105, node);
}

// src/nodes/javascript/misc/assignment-pattern.ts
var TYPE106 = "AssignmentPattern";
function assignmentPattern(left, right) {
  return {
    type: TYPE106,
    left,
    right
  };
}
function isAssignmentPattern(node) {
  return is(TYPE106, node);
}
function assertAssignmentPattern(node) {
  assert(TYPE106, node);
}

// src/nodes/javascript/misc/catch-clause.ts
var TYPE107 = "CatchClause";
function catchClause(param, body) {
  return {
    type: TYPE107,
    param,
    body
  };
}
function isCatchClause(node) {
  return is(TYPE107, node);
}
function assertCatchClause(node) {
  assert(TYPE107, node);
}

// src/nodes/javascript/misc/class-accessor-property.ts
var TYPE108 = "ClassAccessorProperty";
function classAccessorProperty(key, value = null, typeAnnotation2 = null, decorators = null, computed = false, isStatic = false) {
  return {
    type: TYPE108,
    key,
    value,
    typeAnnotation: typeAnnotation2,
    decorators,
    computed,
    static: isStatic
  };
}
function isClassAccessorProperty(node) {
  return is(TYPE108, node);
}
function assertClassAccessorProperty(node) {
  assert(TYPE108, node);
}

// src/nodes/javascript/misc/class-body.ts
var TYPE109 = "ClassBody";
function classBody(body) {
  return {
    type: TYPE109,
    body
  };
}
function isClassBody(node) {
  return is(TYPE109, node);
}
function assertClassBody(node) {
  assert(TYPE109, node);
}

// src/nodes/javascript/misc/class-method.ts
var TYPE110 = "ClassMethod";
function classMethod(kind, key, params, body, computed = false, isStatic = false, generator = false, async = false) {
  return {
    type: TYPE110,
    kind,
    key,
    params,
    body,
    computed,
    static: isStatic,
    generator,
    async
  };
}
function isClassMethod(node) {
  return is(TYPE110, node);
}
function assertClassMethod(node) {
  assert(TYPE110, node);
}

// src/nodes/javascript/misc/class-private-method.ts
var TYPE111 = "ClassPrivateMethod";
function classPrivateMethod(kind, key, params, body, computed = false, isStatic = false, generator = false, async = false) {
  return {
    type: TYPE111,
    kind,
    key,
    params,
    body,
    computed,
    static: isStatic,
    generator,
    async
  };
}
function isClassPrivateMethod(node) {
  return is(TYPE111, node);
}
function assertClassPrivateMethod(node) {
  assert(TYPE111, node);
}

// src/nodes/javascript/misc/class-private-property.ts
var TYPE112 = "ClassPrivateProperty";
function classPrivateProperty(key, value, decorators, isStatic = false) {
  return {
    type: TYPE112,
    key,
    value,
    decorators,
    static: isStatic
  };
}
function isClassPrivateProperty(node) {
  return is(TYPE112, node);
}
function assertClassPrivateProperty(node) {
  assert(TYPE112, node);
}

// src/nodes/javascript/misc/class-property.ts
var TYPE113 = "ClassProperty";
function classProperty(key, value, typeAnnotation2, decorators, computed = false, isStatic = false) {
  return {
    type: TYPE113,
    key,
    value,
    typeAnnotation: typeAnnotation2,
    decorators,
    computed,
    static: isStatic
  };
}
function isClassProperty(node) {
  return is(TYPE113, node);
}
function assertClassProperty(node) {
  assert(TYPE113, node);
}

// src/nodes/javascript/misc/decorator.ts
var TYPE114 = "Decorator";
function decorator(expression) {
  return {
    type: TYPE114,
    expression
  };
}
function isDecorator(node) {
  return is(TYPE114, node);
}
function assertDecorator(node) {
  assert(TYPE114, node);
}

// src/nodes/javascript/misc/directive.ts
var TYPE115 = "Directive";
function directive(value) {
  return {
    type: TYPE115,
    value
  };
}
function isDirective(node) {
  return is(TYPE115, node);
}
function assertDirective(node) {
  assert(TYPE115, node);
}

// src/nodes/javascript/misc/directive-literal.ts
var TYPE116 = "DirectiveLiteral";
function directiveLiteral(value) {
  return {
    type: TYPE116,
    value
  };
}
function isDirectiveLiteral(node) {
  return is(TYPE116, node);
}
function assertDirectiveLiteral(node) {
  assert(TYPE116, node);
}

// src/nodes/javascript/misc/export-default-specifier.ts
var TYPE117 = "ExportDefaultSpecifier";
function exportDefaultSpecifier(exported) {
  return {
    type: TYPE117,
    exported
  };
}
function isExportDefaultSpecifier(node) {
  return is(TYPE117, node);
}
function assertExportDefaultSpecifier(node) {
  assert(TYPE117, node);
}

// src/nodes/javascript/misc/export-namespace-specifier.ts
var TYPE118 = "ExportNamespaceSpecifier";
function exportNamespaceSpecifier(exported) {
  return {
    type: TYPE118,
    exported
  };
}
function isExportNamespaceSpecifier(node) {
  return is(TYPE118, node);
}
function assertExportNamespaceSpecifier(node) {
  assert(TYPE118, node);
}

// src/nodes/javascript/misc/export-specifier.ts
var TYPE119 = "ExportSpecifier";
function exportSpecifier(local, exported) {
  return {
    type: TYPE119,
    local,
    exported
  };
}
function isExportSpecifier(node) {
  return is(TYPE119, node);
}
function assertExportSpecifier(node) {
  assert(TYPE119, node);
}

// src/nodes/javascript/misc/import-default-specifier.ts
var TYPE120 = "ImportDefaultSpecifier";
function importDefaultSpecifier(local) {
  return {
    type: TYPE120,
    local
  };
}
function isImportDefaultSpecifier(node) {
  return is(TYPE120, node);
}
function assertImportDefaultSpecifier(node) {
  assert(TYPE120, node);
}

// src/nodes/javascript/misc/import-namespace-specifier.ts
var TYPE121 = "ImportNamespaceSpecifier";
function importNamespaceSpecifier(local) {
  return {
    type: TYPE121,
    local
  };
}
function isImportNamespaceSpecifier(node) {
  return is(TYPE121, node);
}
function assertImportNamespaceSpecifier(node) {
  assert(TYPE121, node);
}

// src/nodes/javascript/misc/import-specifier.ts
var TYPE122 = "ImportSpecifier";
function importSpecifier(local, imported) {
  return {
    type: TYPE122,
    local,
    imported
  };
}
function isImportSpecifier(node) {
  return is(TYPE122, node);
}
function assertImportSpecifier(node) {
  assert(TYPE122, node);
}

// src/nodes/javascript/misc/object-method.ts
var TYPE123 = "ObjectMethod";
function objectMethod(kind, key, params, body, computed = false, generator = false, async = false) {
  return {
    type: TYPE123,
    kind,
    key,
    params,
    body,
    computed,
    generator,
    async
  };
}
function isObjectMethod(node) {
  return is(TYPE123, node);
}
function assertObjectMethod(node) {
  assert(TYPE123, node);
}

// src/nodes/javascript/misc/object-pattern.ts
var TYPE124 = "ObjectPattern";
function objectPattern(properties) {
  return {
    type: TYPE124,
    properties
  };
}
function isObjectPattern(node) {
  return is(TYPE124, node);
}
function assertObjectPattern(node) {
  assert(TYPE124, node);
}

// src/nodes/javascript/misc/object-property.ts
var TYPE125 = "ObjectProperty";
function objectProperty(key, value, computed = false, shorthand = false, decorators = null) {
  return {
    type: TYPE125,
    key,
    value,
    computed,
    shorthand,
    decorators
  };
}
function isObjectProperty(node) {
  return is(TYPE125, node);
}
function assertObjectProperty(node) {
  assert(TYPE125, node);
}

// src/nodes/javascript/misc/private-name.ts
var TYPE126 = "PrivateName";
function privateName(id) {
  return {
    type: TYPE126,
    id
  };
}
function isPrivateName(node) {
  return is(TYPE126, node);
}
function assertPrivateName(node) {
  assert(TYPE126, node);
}

// src/nodes/javascript/misc/rest-element.ts
var TYPE127 = "RestElement";
function restElement(argument) {
  return {
    type: TYPE127,
    argument
  };
}
function isRestElement(node) {
  return is(TYPE127, node);
}
function assertRestElement(node) {
  assert(TYPE127, node);
}

// src/nodes/javascript/misc/spread-element.ts
var TYPE128 = "SpreadElement";
function spreadElement(argument) {
  return {
    type: TYPE128,
    argument
  };
}
function isSpreadElement(node) {
  return is(TYPE128, node);
}
function assertSpreadElement(node) {
  assert(TYPE128, node);
}

// src/nodes/javascript/misc/static-block.ts
var TYPE129 = "StaticBlock";
function staticBlock(body) {
  return {
    type: TYPE129,
    body
  };
}
function isStaticBlock(node) {
  return is(TYPE129, node);
}
function assertStaticBlock(node) {
  assert(TYPE129, node);
}

// src/nodes/javascript/misc/switch-case.ts
var TYPE130 = "SwitchCase";
function switchCase(test, consequent) {
  return {
    type: TYPE130,
    test,
    consequent
  };
}
function isSwitchCase(node) {
  return is(TYPE130, node);
}
function assertSwitchCase(node) {
  assert(TYPE130, node);
}

// src/nodes/javascript/misc/template-element.ts
var TYPE131 = "TemplateElement";
function templateElement(value, tail = false) {
  return {
    type: TYPE131,
    value,
    tail
  };
}
function isTemplateElement(node) {
  return is(TYPE131, node);
}
function assertTemplateElement(node) {
  assert(TYPE131, node);
}

// src/nodes/javascript/misc/v8-intrinsic-identifier.ts
var TYPE132 = "V8IntrinsicIdentifier";
function v8IntrinsicIdentifier(name) {
  return {
    type: TYPE132,
    name
  };
}
function isV8IntrinsicIdentifier(node) {
  return is(TYPE132, node);
}
function assertV8IntrinsicIdentifier(node) {
  assert(TYPE132, node);
}

// src/nodes/javascript/misc/variable-declarator.ts
var TYPE133 = "VariableDeclarator";
function variableDeclarator(id, init = null) {
  return {
    type: TYPE133,
    id,
    init
  };
}
function isVariableDeclarator(node) {
  return is(TYPE133, node);
}
function assertVariableDeclarator(node) {
  assert(TYPE133, node);
}

// src/nodes/javascript/statements/block-statement.ts
var TYPE134 = "BlockStatement";
function blockStatement(body, directives = []) {
  return {
    type: TYPE134,
    body,
    directives
  };
}
function isBlockStatement(node) {
  return is(TYPE134, node);
}
function assertBlockStatement(node) {
  assert(TYPE134, node);
}

// src/nodes/javascript/statements/break-statement.ts
var TYPE135 = "BreakStatement";
function breakStatement(label = null) {
  return {
    type: TYPE135,
    label
  };
}
function isBreakStatement(node) {
  return is(TYPE135, node);
}
function assertBreakStatement(node) {
  assert(TYPE135, node);
}

// src/nodes/javascript/statements/class-declaration.ts
var TYPE136 = "ClassDeclaration";
function classDeclaration(id, superClass, body, decorators = null) {
  return {
    type: TYPE136,
    id,
    superClass,
    body,
    decorators
  };
}
function isClassDeclaration(node) {
  return is(TYPE136, node);
}
function assertClassDeclaration(node) {
  assert(TYPE136, node);
}

// src/nodes/javascript/statements/continue-statement.ts
var TYPE137 = "ContinueStatement";
function continueStatement(label = null) {
  return {
    type: TYPE137,
    label
  };
}
function isContinueStatement(node) {
  return is(TYPE137, node);
}
function assertContinueStatement(node) {
  assert(TYPE137, node);
}

// src/nodes/javascript/statements/debugger-statement.ts
var TYPE138 = "DebuggerStatement";
function debuggerStatement() {
  return {
    type: TYPE138
  };
}
function isDebuggerStatement(node) {
  return is(TYPE138, node);
}
function assertDebuggerStatement(node) {
  assert(TYPE138, node);
}

// src/nodes/javascript/statements/do-while-statement.ts
var TYPE139 = "DoWhileStatement";
function doWhileStatement(test, body) {
  return {
    type: TYPE139,
    test,
    body
  };
}
function isDoWhileStatement(node) {
  return is(TYPE139, node);
}
function assertDoWhileStatement(node) {
  assert(TYPE139, node);
}

// src/nodes/javascript/statements/empty-statement.ts
var TYPE140 = "EmptyStatement";
function emptyStatement() {
  return {
    type: TYPE140
  };
}
function isEmptyStatement(node) {
  return is(TYPE140, node);
}
function assertEmptyStatement(node) {
  assert(TYPE140, node);
}

// src/nodes/javascript/statements/export-all-declaration.ts
var TYPE141 = "ExportAllDeclaration";
function exportAllDeclaration(source) {
  return {
    type: TYPE141,
    source
  };
}
function isExportAllDeclaration(node) {
  return is(TYPE141, node);
}
function assertExportAllDeclaration(node) {
  assert(TYPE141, node);
}

// src/nodes/javascript/statements/export-named-declaration.ts
var TYPE142 = "ExportNamedDeclaration";
function exportNamedDeclaration(declaration = null, specifiers = [], source = null) {
  return {
    type: TYPE142,
    declaration,
    specifiers,
    source
  };
}
function isExportNamedDeclaration(node) {
  return is(TYPE142, node);
}
function assertExportNamedDeclaration(node) {
  assert(TYPE142, node);
}

// src/nodes/javascript/statements/expression-statement.ts
var TYPE143 = "ExpressionStatement";
function expressionStatement(expression) {
  return {
    type: TYPE143,
    expression
  };
}
function isExpressionStatement(node) {
  return is(TYPE143, node);
}
function assertExpressionStatement(node) {
  assert(TYPE143, node);
}

// src/nodes/javascript/statements/for-in-statement.ts
var TYPE144 = "ForInStatement";
function forInStatement(left, right, body) {
  return {
    type: TYPE144,
    left,
    right,
    body
  };
}
function isForInStatement(node) {
  return is(TYPE144, node);
}
function assertForInStatement(node) {
  assert(TYPE144, node);
}

// src/nodes/javascript/statements/for-of-statement.ts
var TYPE145 = "ForOfStatement";
function forOfStatement(left, right, body, isAwait) {
  return {
    type: TYPE145,
    left,
    right,
    body,
    await: isAwait
  };
}
function isForOfStatement(node) {
  return is(TYPE145, node);
}
function assertForOfStatement(node) {
  assert(TYPE145, node);
}

// src/nodes/javascript/statements/for-statement.ts
var TYPE146 = "ForStatement";
function forStatement(init, test, update, body) {
  return {
    type: TYPE146,
    init,
    test,
    update,
    body
  };
}
function isForStatement(node) {
  return is(TYPE146, node);
}
function assertForStatement(node) {
  assert(TYPE146, node);
}

// src/nodes/javascript/statements/function-declaration.ts
var TYPE147 = "FunctionDeclaration";
function functionDeclaration(id, params, body, generator = false, async = false) {
  return {
    type: TYPE147,
    id,
    params,
    body,
    generator,
    async
  };
}
function isFunctionDeclaration(node) {
  return is(TYPE147, node);
}
function assertFunctionDeclaration(node) {
  assert(TYPE147, node);
}

// src/nodes/javascript/statements/if-statement.ts
var TYPE148 = "IfStatement";
function ifStatement(test, consequent, alternate = null) {
  return {
    type: TYPE148,
    test,
    consequent,
    alternate
  };
}
function isIfStatement(node) {
  return is(TYPE148, node);
}
function assertIfStatement(node)