ether-code 0.1.6 → 0.1.8

package/parsers/ast-ts.js

@@ -1,1352 +0,0 @@
-class ASTNode {
-    constructor(type, loc = null) {
-        this.type = type
-        this.loc = loc
-    }
-}
-
-class Program extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('Program', loc)
-        this.body = body
-    }
-}
-
-class Identifier extends ASTNode {
-    constructor(name, loc = null) {
-        super('Identifier', loc)
-        this.name = name
-    }
-}
-
-class StringLiteral extends ASTNode {
-    constructor(value, raw = null, loc = null) {
-        super('StringLiteral', loc)
-        this.value = value
-        this.raw = raw || `"${value}"`
-    }
-}
-
-class NumericLiteral extends ASTNode {
-    constructor(value, raw = null, loc = null) {
-        super('NumericLiteral', loc)
-        this.value = value
-        this.raw = raw || String(value)
-    }
-}
-
-class BooleanLiteral extends ASTNode {
-    constructor(value, loc = null) {
-        super('BooleanLiteral', loc)
-        this.value = value
-    }
-}
-
-class NullLiteral extends ASTNode {
-    constructor(loc = null) {
-        super('NullLiteral', loc)
-        this.value = null
-    }
-}
-
-class UndefinedLiteral extends ASTNode {
-    constructor(loc = null) {
-        super('UndefinedLiteral', loc)
-    }
-}
-
-class BigIntLiteral extends ASTNode {
-    constructor(value, raw = null, loc = null) {
-        super('BigIntLiteral', loc)
-        this.value = value
-        this.raw = raw
-    }
-}
-
-class TemplateLiteral extends ASTNode {
-    constructor(quasis = [], expressions = [], loc = null) {
-        super('TemplateLiteral', loc)
-        this.quasis = quasis
-        this.expressions = expressions
-    }
-}
-
-class TemplateElement extends ASTNode {
-    constructor(value, tail = false, loc = null) {
-        super('TemplateElement', loc)
-        this.value = value
-        this.tail = tail
-    }
-}
-
-class RegExpLiteral extends ASTNode {
-    constructor(pattern, flags = '', loc = null) {
-        super('RegExpLiteral', loc)
-        this.pattern = pattern
-        this.flags = flags
-    }
-}
-
-class ArrayExpression extends ASTNode {
-    constructor(elements = [], loc = null) {
-        super('ArrayExpression', loc)
-        this.elements = elements
-    }
-}
-
-class ObjectExpression extends ASTNode {
-    constructor(properties = [], loc = null) {
-        super('ObjectExpression', loc)
-        this.properties = properties
-    }
-}
-
-class Property extends ASTNode {
-    constructor(key, value, kind = 'init', computed = false, shorthand = false, method = false, loc = null) {
-        super('Property', loc)
-        this.key = key
-        this.value = value
-        this.kind = kind
-        this.computed = computed
-        this.shorthand = shorthand
-        this.method = method
-    }
-}
-
-class SpreadElement extends ASTNode {
-    constructor(argument, loc = null) {
-        super('SpreadElement', loc)
-        this.argument = argument
-    }
-}
-
-class BinaryExpression extends ASTNode {
-    constructor(operator, left, right, loc = null) {
-        super('BinaryExpression', loc)
-        this.operator = operator
-        this.left = left
-        this.right = right
-    }
-}
-
-class UnaryExpression extends ASTNode {
-    constructor(operator, argument, prefix = true, loc = null) {
-        super('UnaryExpression', loc)
-        this.operator = operator
-        this.argument = argument
-        this.prefix = prefix
-    }
-}
-
-class UpdateExpression extends ASTNode {
-    constructor(operator, argument, prefix = true, loc = null) {
-        super('UpdateExpression', loc)
-        this.operator = operator
-        this.argument = argument
-        this.prefix = prefix
-    }
-}
-
-class AssignmentExpression extends ASTNode {
-    constructor(operator, left, right, loc = null) {
-        super('AssignmentExpression', loc)
-        this.operator = operator
-        this.left = left
-        this.right = right
-    }
-}
-
-class LogicalExpression extends ASTNode {
-    constructor(operator, left, right, loc = null) {
-        super('LogicalExpression', loc)
-        this.operator = operator
-        this.left = left
-        this.right = right
-    }
-}
-
-class ConditionalExpression extends ASTNode {
-    constructor(test, consequent, alternate, loc = null) {
-        super('ConditionalExpression', loc)
-        this.test = test
-        this.consequent = consequent
-        this.alternate = alternate
-    }
-}
-
-class CallExpression extends ASTNode {
-    constructor(callee, arguments_ = [], optional = false, loc = null) {
-        super('CallExpression', loc)
-        this.callee = callee
-        this.arguments = arguments_
-        this.optional = optional
-    }
-}
-
-class NewExpression extends ASTNode {
-    constructor(callee, arguments_ = [], loc = null) {
-        super('NewExpression', loc)
-        this.callee = callee
-        this.arguments = arguments_
-    }
-}
-
-class MemberExpression extends ASTNode {
-    constructor(object, property, computed = false, optional = false, loc = null) {
-        super('MemberExpression', loc)
-        this.object = object
-        this.property = property
-        this.computed = computed
-        this.optional = optional
-    }
-}
-
-class SequenceExpression extends ASTNode {
-    constructor(expressions = [], loc = null) {
-        super('SequenceExpression', loc)
-        this.expressions = expressions
-    }
-}
-
-class ArrowFunctionExpression extends ASTNode {
-    constructor(params = [], body, async = false, expression = false, returnType = null, typeParameters = null, loc = null) {
-        super('ArrowFunctionExpression', loc)
-        this.params = params
-        this.body = body
-        this.async = async
-        this.expression = expression
-        this.returnType = returnType
-        this.typeParameters = typeParameters
-    }
-}
-
-class FunctionExpression extends ASTNode {
-    constructor(id, params = [], body, async = false, generator = false, returnType = null, typeParameters = null, loc = null) {
-        super('FunctionExpression', loc)
-        this.id = id
-        this.params = params
-        this.body = body
-        this.async = async
-        this.generator = generator
-        this.returnType = returnType
-        this.typeParameters = typeParameters
-    }
-}
-
-class FunctionDeclaration extends ASTNode {
-    constructor(id, params = [], body, async = false, generator = false, returnType = null, typeParameters = null, loc = null) {
-        super('FunctionDeclaration', loc)
-        this.id = id
-        this.params = params
-        this.body = body
-        this.async = async
-        this.generator = generator
-        this.returnType = returnType
-        this.typeParameters = typeParameters
-    }
-}
-
-class VariableDeclaration extends ASTNode {
-    constructor(kind, declarations = [], loc = null) {
-        super('VariableDeclaration', loc)
-        this.kind = kind
-        this.declarations = declarations
-    }
-}
-
-class VariableDeclarator extends ASTNode {
-    constructor(id, init = null, loc = null) {
-        super('VariableDeclarator', loc)
-        this.id = id
-        this.init = init
-    }
-}
-
-class ClassDeclaration extends ASTNode {
-    constructor(id, body, superClass = null, implements_ = [], decorators = [], abstract = false, typeParameters = null, superTypeParameters = null, loc = null) {
-        super('ClassDeclaration', loc)
-        this.id = id
-        this.body = body
-        this.superClass = superClass
-        this.implements = implements_
-        this.decorators = decorators
-        this.abstract = abstract
-        this.typeParameters = typeParameters
-        this.superTypeParameters = superTypeParameters
-    }
-}
-
-class ClassExpression extends ASTNode {
-    constructor(id, body, superClass = null, implements_ = [], decorators = [], abstract = false, typeParameters = null, loc = null) {
-        super('ClassExpression', loc)
-        this.id = id
-        this.body = body
-        this.superClass = superClass
-        this.implements = implements_
-        this.decorators = decorators
-        this.abstract = abstract
-        this.typeParameters = typeParameters
-    }
-}
-
-class ClassBody extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('ClassBody', loc)
-        this.body = body
-    }
-}
-
-class MethodDefinition extends ASTNode {
-    constructor(key, value, kind = 'method', computed = false, isStatic = false, accessibility = null, abstract = false, override = false, decorators = [], loc = null) {
-        super('MethodDefinition', loc)
-        this.key = key
-        this.value = value
-        this.kind = kind
-        this.computed = computed
-        this.static = isStatic
-        this.accessibility = accessibility
-        this.abstract = abstract
-        this.override = override
-        this.decorators = decorators
-    }
-}
-
-class PropertyDefinition extends ASTNode {
-    constructor(key, value = null, computed = false, isStatic = false, accessibility = null, readonly = false, abstract = false, override = false, optional = false, definite = false, typeAnnotation = null, decorators = [], loc = null) {
-        super('PropertyDefinition', loc)
-        this.key = key
-        this.value = value
-        this.computed = computed
-        this.static = isStatic
-        this.accessibility = accessibility
-        this.readonly = readonly
-        this.abstract = abstract
-        this.override = override
-        this.optional = optional
-        this.definite = definite
-        this.typeAnnotation = typeAnnotation
-        this.decorators = decorators
-    }
-}
-
-class StaticBlock extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('StaticBlock', loc)
-        this.body = body
-    }
-}
-
-class PrivateIdentifier extends ASTNode {
-    constructor(name, loc = null) {
-        super('PrivateIdentifier', loc)
-        this.name = name
-    }
-}
-
-class BlockStatement extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('BlockStatement', loc)
-        this.body = body
-    }
-}
-
-class ExpressionStatement extends ASTNode {
-    constructor(expression, loc = null) {
-        super('ExpressionStatement', loc)
-        this.expression = expression
-    }
-}
-
-class EmptyStatement extends ASTNode {
-    constructor(loc = null) {
-        super('EmptyStatement', loc)
-    }
-}
-
-class IfStatement extends ASTNode {
-    constructor(test, consequent, alternate = null, loc = null) {
-        super('IfStatement', loc)
-        this.test = test
-        this.consequent = consequent
-        this.alternate = alternate
-    }
-}
-
-class SwitchStatement extends ASTNode {
-    constructor(discriminant, cases = [], loc = null) {
-        super('SwitchStatement', loc)
-        this.discriminant = discriminant
-        this.cases = cases
-    }
-}
-
-class SwitchCase extends ASTNode {
-    constructor(test, consequent = [], loc = null) {
-        super('SwitchCase', loc)
-        this.test = test
-        this.consequent = consequent
-    }
-}
-
-class ForStatement extends ASTNode {
-    constructor(init, test, update, body, loc = null) {
-        super('ForStatement', loc)
-        this.init = init
-        this.test = test
-        this.update = update
-        this.body = body
-    }
-}
-
-class ForInStatement extends ASTNode {
-    constructor(left, right, body, loc = null) {
-        super('ForInStatement', loc)
-        this.left = left
-        this.right = right
-        this.body = body
-    }
-}
-
-class ForOfStatement extends ASTNode {
-    constructor(left, right, body, await_ = false, loc = null) {
-        super('ForOfStatement', loc)
-        this.left = left
-        this.right = right
-        this.body = body
-        this.await = await_
-    }
-}
-
-class WhileStatement extends ASTNode {
-    constructor(test, body, loc = null) {
-        super('WhileStatement', loc)
-        this.test = test
-        this.body = body
-    }
-}
-
-class DoWhileStatement extends ASTNode {
-    constructor(body, test, loc = null) {
-        super('DoWhileStatement', loc)
-        this.body = body
-        this.test = test
-    }
-}
-
-class BreakStatement extends ASTNode {
-    constructor(label = null, loc = null) {
-        super('BreakStatement', loc)
-        this.label = label
-    }
-}
-
-class ContinueStatement extends ASTNode {
-    constructor(label = null, loc = null) {
-        super('ContinueStatement', loc)
-        this.label = label
-    }
-}
-
-class ReturnStatement extends ASTNode {
-    constructor(argument = null, loc = null) {
-        super('ReturnStatement', loc)
-        this.argument = argument
-    }
-}
-
-class ThrowStatement extends ASTNode {
-    constructor(argument, loc = null) {
-        super('ThrowStatement', loc)
-        this.argument = argument
-    }
-}
-
-class TryStatement extends ASTNode {
-    constructor(block, handler = null, finalizer = null, loc = null) {
-        super('TryStatement', loc)
-        this.block = block
-        this.handler = handler
-        this.finalizer = finalizer
-    }
-}
-
-class CatchClause extends ASTNode {
-    constructor(param, body, loc = null) {
-        super('CatchClause', loc)
-        this.param = param
-        this.body = body
-    }
-}
-
-class LabeledStatement extends ASTNode {
-    constructor(label, body, loc = null) {
-        super('LabeledStatement', loc)
-        this.label = label
-        this.body = body
-    }
-}
-
-class WithStatement extends ASTNode {
-    constructor(object, body, loc = null) {
-        super('WithStatement', loc)
-        this.object = object
-        this.body = body
-    }
-}
-
-class DebuggerStatement extends ASTNode {
-    constructor(loc = null) {
-        super('DebuggerStatement', loc)
-    }
-}
-
-class ImportDeclaration extends ASTNode {
-    constructor(specifiers = [], source, importKind = 'value', loc = null) {
-        super('ImportDeclaration', loc)
-        this.specifiers = specifiers
-        this.source = source
-        this.importKind = importKind
-    }
-}
-
-class ImportSpecifier extends ASTNode {
-    constructor(imported, local, importKind = 'value', loc = null) {
-        super('ImportSpecifier', loc)
-        this.imported = imported
-        this.local = local
-        this.importKind = importKind
-    }
-}
-
-class ImportDefaultSpecifier extends ASTNode {
-    constructor(local, loc = null) {
-        super('ImportDefaultSpecifier', loc)
-        this.local = local
-    }
-}
-
-class ImportNamespaceSpecifier extends ASTNode {
-    constructor(local, loc = null) {
-        super('ImportNamespaceSpecifier', loc)
-        this.local = local
-    }
-}
-
-class ExportNamedDeclaration extends ASTNode {
-    constructor(declaration, specifiers = [], source = null, exportKind = 'value', loc = null) {
-        super('ExportNamedDeclaration', loc)
-        this.declaration = declaration
-        this.specifiers = specifiers
-        this.source = source
-        this.exportKind = exportKind
-    }
-}
-
-class ExportDefaultDeclaration extends ASTNode {
-    constructor(declaration, loc = null) {
-        super('ExportDefaultDeclaration', loc)
-        this.declaration = declaration
-    }
-}
-
-class ExportAllDeclaration extends ASTNode {
-    constructor(source, exported = null, exportKind = 'value', loc = null) {
-        super('ExportAllDeclaration', loc)
-        this.source = source
-        this.exported = exported
-        this.exportKind = exportKind
-    }
-}
-
-class ExportSpecifier extends ASTNode {
-    constructor(local, exported, exportKind = 'value', loc = null) {
-        super('ExportSpecifier', loc)
-        this.local = local
-        this.exported = exported
-        this.exportKind = exportKind
-    }
-}
-
-class AwaitExpression extends ASTNode {
-    constructor(argument, loc = null) {
-        super('AwaitExpression', loc)
-        this.argument = argument
-    }
-}
-
-class YieldExpression extends ASTNode {
-    constructor(argument = null, delegate = false, loc = null) {
-        super('YieldExpression', loc)
-        this.argument = argument
-        this.delegate = delegate
-    }
-}
-
-class ThisExpression extends ASTNode {
-    constructor(loc = null) {
-        super('ThisExpression', loc)
-    }
-}
-
-class Super extends ASTNode {
-    constructor(loc = null) {
-        super('Super', loc)
-    }
-}
-
-class MetaProperty extends ASTNode {
-    constructor(meta, property, loc = null) {
-        super('MetaProperty', loc)
-        this.meta = meta
-        this.property = property
-    }
-}
-
-class TaggedTemplateExpression extends ASTNode {
-    constructor(tag, quasi, loc = null) {
-        super('TaggedTemplateExpression', loc)
-        this.tag = tag
-        this.quasi = quasi
-    }
-}
-
-class ChainExpression extends ASTNode {
-    constructor(expression, loc = null) {
-        super('ChainExpression', loc)
-        this.expression = expression
-    }
-}
-
-class ImportExpression extends ASTNode {
-    constructor(source, loc = null) {
-        super('ImportExpression', loc)
-        this.source = source
-    }
-}
-
-class AssignmentPattern extends ASTNode {
-    constructor(left, right, loc = null) {
-        super('AssignmentPattern', loc)
-        this.left = left
-        this.right = right
-    }
-}
-
-class ArrayPattern extends ASTNode {
-    constructor(elements = [], typeAnnotation = null, loc = null) {
-        super('ArrayPattern', loc)
-        this.elements = elements
-        this.typeAnnotation = typeAnnotation
-    }
-}
-
-class ObjectPattern extends ASTNode {
-    constructor(properties = [], typeAnnotation = null, loc = null) {
-        super('ObjectPattern', loc)
-        this.properties = properties
-        this.typeAnnotation = typeAnnotation
-    }
-}
-
-class RestElement extends ASTNode {
-    constructor(argument, typeAnnotation = null, loc = null) {
-        super('RestElement', loc)
-        this.argument = argument
-        this.typeAnnotation = typeAnnotation
-    }
-}
-
-class TSTypeAnnotation extends ASTNode {
-    constructor(typeAnnotation, loc = null) {
-        super('TSTypeAnnotation', loc)
-        this.typeAnnotation = typeAnnotation
-    }
-}
-
-class TSTypeParameterDeclaration extends ASTNode {
-    constructor(params = [], loc = null) {
-        super('TSTypeParameterDeclaration', loc)
-        this.params = params
-    }
-}
-
-class TSTypeParameter extends ASTNode {
-    constructor(name, constraint = null, default_ = null, in_ = false, out = false, const_ = false, loc = null) {
-        super('TSTypeParameter', loc)
-        this.name = name
-        this.constraint = constraint
-        this.default = default_
-        this.in = in_
-        this.out = out
-        this.const = const_
-    }
-}
-
-class TSTypeParameterInstantiation extends ASTNode {
-    constructor(params = [], loc = null) {
-        super('TSTypeParameterInstantiation', loc)
-        this.params = params
-    }
-}
-
-class TSTypeReference extends ASTNode {
-    constructor(typeName, typeParameters = null, loc = null) {
-        super('TSTypeReference', loc)
-        this.typeName = typeName
-        this.typeParameters = typeParameters
-    }
-}
-
-class TSQualifiedName extends ASTNode {
-    constructor(left, right, loc = null) {
-        super('TSQualifiedName', loc)
-        this.left = left
-        this.right = right
-    }
-}
-
-class TSStringKeyword extends ASTNode {
-    constructor(loc = null) {
-        super('TSStringKeyword', loc)
-    }
-}
-
-class TSNumberKeyword extends ASTNode {
-    constructor(loc = null) {
-        super('TSNumberKeyword', loc)
-    }
-}
-
-class TSBooleanKeyword extends ASTNode {
-    constructor(loc = null) {
-        super('TSBooleanKeyword', loc)
-    }
-}
-
-class TSBigIntKeyword extends ASTNode {
-    constructor(loc = null) {
-        super('TSBigIntKeyword', loc)
-    }
-}
-
-class TSSymbolKeyword extends ASTNode {
-    constructor(loc = null) {
-        super('TSSymbolKeyword', loc)
-    }
-}
-
-class TSObjectKeyword extends ASTNode {
-    constructor(loc = null) {
-        super('TSObjectKeyword', loc)
-    }
-}
-
-class TSAnyKeyword extends ASTNode {
-    constructor(loc = null) {
-        super('TSAnyKeyword', loc)
-    }
-}
-
-class TSUnknownKeyword extends ASTNode {
-    constructor(loc = null) {
-        super('TSUnknownKeyword', loc)
-    }
-}
-
-class TSNeverKeyword extends ASTNode {
-    constructor(loc = null) {
-        super('TSNeverKeyword', loc)
-    }
-}
-
-class TSVoidKeyword extends ASTNode {
-    constructor(loc = null) {
-        super('TSVoidKeyword', loc)
-    }
-}
-
-class TSUndefinedKeyword extends ASTNode {
-    constructor(loc = null) {
-        super('TSUndefinedKeyword', loc)
-    }
-}
-
-class TSNullKeyword extends ASTNode {
-    constructor(loc = null) {
-        super('TSNullKeyword', loc)
-    }
-}
-
-class TSThisType extends ASTNode {
-    constructor(loc = null) {
-        super('TSThisType', loc)
-    }
-}
-
-class TSArrayType extends ASTNode {
-    constructor(elementType, loc = null) {
-        super('TSArrayType', loc)
-        this.elementType = elementType
-    }
-}
-
-class TSTupleType extends ASTNode {
-    constructor(elementTypes = [], loc = null) {
-        super('TSTupleType', loc)
-        this.elementTypes = elementTypes
-    }
-}
-
-class TSNamedTupleMember extends ASTNode {
-    constructor(label, elementType, optional = false, loc = null) {
-        super('TSNamedTupleMember', loc)
-        this.label = label
-        this.elementType = elementType
-        this.optional = optional
-    }
-}
-
-class TSOptionalType extends ASTNode {
-    constructor(typeAnnotation, loc = null) {
-        super('TSOptionalType', loc)
-        this.typeAnnotation = typeAnnotation
-    }
-}
-
-class TSRestType extends ASTNode {
-    constructor(typeAnnotation, loc = null) {
-        super('TSRestType', loc)
-        this.typeAnnotation = typeAnnotation
-    }
-}
-
-class TSUnionType extends ASTNode {
-    constructor(types = [], loc = null) {
-        super('TSUnionType', loc)
-        this.types = types
-    }
-}
-
-class TSIntersectionType extends ASTNode {
-    constructor(types = [], loc = null) {
-        super('TSIntersectionType', loc)
-        this.types = types
-    }
-}
-
-class TSParenthesizedType extends ASTNode {
-    constructor(typeAnnotation, loc = null) {
-        super('TSParenthesizedType', loc)
-        this.typeAnnotation = typeAnnotation
-    }
-}
-
-class TSTypeLiteral extends ASTNode {
-    constructor(members = [], loc = null) {
-        super('TSTypeLiteral', loc)
-        this.members = members
-    }
-}
-
-class TSPropertySignature extends ASTNode {
-    constructor(key, typeAnnotation = null, computed = false, optional = false, readonly = false, loc = null) {
-        super('TSPropertySignature', loc)
-        this.key = key
-        this.typeAnnotation = typeAnnotation
-        this.computed = computed
-        this.optional = optional
-        this.readonly = readonly
-    }
-}
-
-class TSMethodSignature extends ASTNode {
-    constructor(key, params = [], returnType = null, computed = false, optional = false, typeParameters = null, loc = null) {
-        super('TSMethodSignature', loc)
-        this.key = key
-        this.params = params
-        this.returnType = returnType
-        this.computed = computed
-        this.optional = optional
-        this.typeParameters = typeParameters
-    }
-}
-
-class TSIndexSignature extends ASTNode {
-    constructor(parameters = [], typeAnnotation = null, readonly = false, isStatic = false, loc = null) {
-        super('TSIndexSignature', loc)
-        this.parameters = parameters
-        this.typeAnnotation = typeAnnotation
-        this.readonly = readonly
-        this.static = isStatic
-    }
-}
-
-class TSCallSignatureDeclaration extends ASTNode {
-    constructor(params = [], returnType = null, typeParameters = null, loc = null) {
-        super('TSCallSignatureDeclaration', loc)
-        this.params = params
-        this.returnType = returnType
-        this.typeParameters = typeParameters
-    }
-}
-
-class TSConstructSignatureDeclaration extends ASTNode {
-    constructor(params = [], returnType = null, typeParameters = null, loc = null) {
-        super('TSConstructSignatureDeclaration', loc)
-        this.params = params
-        this.returnType = returnType
-        this.typeParameters = typeParameters
-    }
-}
-
-class TSFunctionType extends ASTNode {
-    constructor(params = [], returnType = null, typeParameters = null, loc = null) {
-        super('TSFunctionType', loc)
-        this.params = params
-        this.returnType = returnType
-        this.typeParameters = typeParameters
-    }
-}
-
-class TSConstructorType extends ASTNode {
-    constructor(params = [], returnType = null, typeParameters = null, abstract = false, loc = null) {
-        super('TSConstructorType', loc)
-        this.params = params
-        this.returnType = returnType
-        this.typeParameters = typeParameters
-        this.abstract = abstract
-    }
-}
-
-class TSConditionalType extends ASTNode {
-    constructor(checkType, extendsType, trueType, falseType, loc = null) {
-        super('TSConditionalType', loc)
-        this.checkType = checkType
-        this.extendsType = extendsType
-        this.trueType = trueType
-        this.falseType = falseType
-    }
-}
-
-class TSInferType extends ASTNode {
-    constructor(typeParameter, loc = null) {
-        super('TSInferType', loc)
-        this.typeParameter = typeParameter
-    }
-}
-
-class TSMappedType extends ASTNode {
-    constructor(typeParameter, typeAnnotation = null, nameType = null, optional = null, readonly = null, loc = null) {
-        super('TSMappedType', loc)
-        this.typeParameter = typeParameter
-        this.typeAnnotation = typeAnnotation
-        this.nameType = nameType
-        this.optional = optional
-        this.readonly = readonly
-    }
-}
-
-class TSIndexedAccessType extends ASTNode {
-    constructor(objectType, indexType, loc = null) {
-        super('TSIndexedAccessType', loc)
-        this.objectType = objectType
-        this.indexType = indexType
-    }
-}
-
-class TSTypeOperator extends ASTNode {
-    constructor(operator, typeAnnotation, loc = null) {
-        super('TSTypeOperator', loc)
-        this.operator = operator
-        this.typeAnnotation = typeAnnotation
-    }
-}
-
-class TSTypePredicate extends ASTNode {
-    constructor(parameterName, typeAnnotation = null, asserts = false, loc = null) {
-        super('TSTypePredicate', loc)
-        this.parameterName = parameterName
-        this.typeAnnotation = typeAnnotation
-        this.asserts = asserts
-    }
-}
-
-class TSTypeQuery extends ASTNode {
-    constructor(exprName, typeParameters = null, loc = null) {
-        super('TSTypeQuery', loc)
-        this.exprName = exprName
-        this.typeParameters = typeParameters
-    }
-}
-
-class TSLiteralType extends ASTNode {
-    constructor(literal, loc = null) {
-        super('TSLiteralType', loc)
-        this.literal = literal
-    }
-}
-
-class TSTemplateLiteralType extends ASTNode {
-    constructor(quasis = [], types = [], loc = null) {
-        super('TSTemplateLiteralType', loc)
-        this.quasis = quasis
-        this.types = types
-    }
-}
-
-class TSInterfaceDeclaration extends ASTNode {
-    constructor(id, body, extends_ = [], typeParameters = null, declare = false, loc = null) {
-        super('TSInterfaceDeclaration', loc)
-        this.id = id
-        this.body = body
-        this.extends = extends_
-        this.typeParameters = typeParameters
-        this.declare = declare
-    }
-}
-
-class TSInterfaceBody extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('TSInterfaceBody', loc)
-        this.body = body
-    }
-}
-
-class TSInterfaceHeritage extends ASTNode {
-    constructor(expression, typeParameters = null, loc = null) {
-        super('TSInterfaceHeritage', loc)
-        this.expression = expression
-        this.typeParameters = typeParameters
-    }
-}
-
-class TSTypeAliasDeclaration extends ASTNode {
-    constructor(id, typeAnnotation, typeParameters = null, declare = false, loc = null) {
-        super('TSTypeAliasDeclaration', loc)
-        this.id = id
-        this.typeAnnotation = typeAnnotation
-        this.typeParameters = typeParameters
-        this.declare = declare
-    }
-}
-
-class TSEnumDeclaration extends ASTNode {
-    constructor(id, members = [], const_ = false, declare = false, loc = null) {
-        super('TSEnumDeclaration', loc)
-        this.id = id
-        this.members = members
-        this.const = const_
-        this.declare = declare
-    }
-}
-
-class TSEnumMember extends ASTNode {
-    constructor(id, initializer = null, loc = null) {
-        super('TSEnumMember', loc)
-        this.id = id
-        this.initializer = initializer
-    }
-}
-
-class TSModuleDeclaration extends ASTNode {
-    constructor(id, body = null, declare = false, global = false, loc = null) {
-        super('TSModuleDeclaration', loc)
-        this.id = id
-        this.body = body
-        this.declare = declare
-        this.global = global
-    }
-}
-
-class TSModuleBlock extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('TSModuleBlock', loc)
-        this.body = body
-    }
-}
-
-class TSDeclareFunction extends ASTNode {
-    constructor(id, params = [], returnType = null, typeParameters = null, async = false, generator = false, loc = null) {
-        super('TSDeclareFunction', loc)
-        this.id = id
-        this.params = params
-        this.returnType = returnType
-        this.typeParameters = typeParameters
-        this.async = async
-        this.generator = generator
-    }
-}
-
-class TSDeclareMethod extends ASTNode {
-    constructor(key, params = [], returnType = null, typeParameters = null, accessibility = null, isStatic = false, abstract = false, loc = null) {
-        super('TSDeclareMethod', loc)
-        this.key = key
-        this.params = params
-        this.returnType = returnType
-        this.typeParameters = typeParameters
-        this.accessibility = accessibility
-        this.static = isStatic
-        this.abstract = abstract
-    }
-}
-
-class TSAsExpression extends ASTNode {
-    constructor(expression, typeAnnotation, loc = null) {
-        super('TSAsExpression', loc)
-        this.expression = expression
-        this.typeAnnotation = typeAnnotation
-    }
-}
-
-class TSSatisfiesExpression extends ASTNode {
-    constructor(expression, typeAnnotation, loc = null) {
-        super('TSSatisfiesExpression', loc)
-        this.expression = expression
-        this.typeAnnotation = typeAnnotation
-    }
-}
-
-class TSTypeAssertion extends ASTNode {
-    constructor(typeAnnotation, expression, loc = null) {
-        super('TSTypeAssertion', loc)
-        this.typeAnnotation = typeAnnotation
-        this.expression = expression
-    }
-}
-
-class TSNonNullExpression extends ASTNode {
-    constructor(expression, loc = null) {
-        super('TSNonNullExpression', loc)
-        this.expression = expression
-    }
-}
-
-class TSInstantiationExpression extends ASTNode {
-    constructor(expression, typeParameters, loc = null) {
-        super('TSInstantiationExpression', loc)
-        this.expression = expression
-        this.typeParameters = typeParameters
-    }
-}
-
-class TSImportType extends ASTNode {
-    constructor(argument, qualifier = null, typeParameters = null, loc = null) {
-        super('TSImportType', loc)
-        this.argument = argument
-        this.qualifier = qualifier
-        this.typeParameters = typeParameters
-    }
-}
-
-class TSImportEqualsDeclaration extends ASTNode {
-    constructor(id, moduleReference, isExport = false, loc = null) {
-        super('TSImportEqualsDeclaration', loc)
-        this.id = id
-        this.moduleReference = moduleReference
-        this.isExport = isExport
-    }
-}
-
-class TSExternalModuleReference extends ASTNode {
-    constructor(expression, loc = null) {
-        super('TSExternalModuleReference', loc)
-        this.expression = expression
-    }
-}
-
-class TSExportAssignment extends ASTNode {
-    constructor(expression, loc = null) {
-        super('TSExportAssignment', loc)
-        this.expression = expression
-    }
-}
-
-class TSNamespaceExportDeclaration extends ASTNode {
-    constructor(id, loc = null) {
-        super('TSNamespaceExportDeclaration', loc)
-        this.id = id
-    }
-}
-
-class Decorator extends ASTNode {
-    constructor(expression, loc = null) {
-        super('Decorator', loc)
-        this.expression = expression
-    }
-}
-
-class TSParameterProperty extends ASTNode {
-    constructor(parameter, accessibility = null, readonly = false, override = false, loc = null) {
-        super('TSParameterProperty', loc)
-        this.parameter = parameter
-        this.accessibility = accessibility
-        this.readonly = readonly
-        this.override = override
-    }
-}
-
-class EtherTypeAlias extends ASTNode {
-    constructor(name, typeAnnotation, typeParameters = null, loc = null) {
-        super('EtherTypeAlias', loc)
-        this.name = name
-        this.typeAnnotation = typeAnnotation
-        this.typeParameters = typeParameters
-    }
-}
-
-class EtherGenericType extends ASTNode {
-    constructor(baseName, typeArguments = [], loc = null) {
-        super('EtherGenericType', loc)
-        this.baseName = baseName
-        this.typeArguments = typeArguments
-    }
-}
-
-module.exports = {
-    ASTNode,
-    Program,
-    Identifier,
-    StringLiteral,
-    NumericLiteral,
-    BooleanLiteral,
-    NullLiteral,
-    UndefinedLiteral,
-    BigIntLiteral,
-    TemplateLiteral,
-    TemplateElement,
-    RegExpLiteral,
-    ArrayExpression,
-    ObjectExpression,
-    Property,
-    SpreadElement,
-    BinaryExpression,
-    UnaryExpression,
-    UpdateExpression,
-    AssignmentExpression,
-    LogicalExpression,
-    ConditionalExpression,
-    CallExpression,
-    NewExpression,
-    MemberExpression,
-    SequenceExpression,
-    ArrowFunctionExpression,
-    FunctionExpression,
-    FunctionDeclaration,
-    VariableDeclaration,
-    VariableDeclarator,
-    ClassDeclaration,
-    ClassExpression,
-    ClassBody,
-    MethodDefinition,
-    PropertyDefinition,
-    StaticBlock,
-    PrivateIdentifier,
-    BlockStatement,
-    ExpressionStatement,
-    EmptyStatement,
-    IfStatement,
-    SwitchStatement,
-    SwitchCase,
-    ForStatement,
-    ForInStatement,
-    ForOfStatement,
-    WhileStatement,
-    DoWhileStatement,
-    BreakStatement,
-    ContinueStatement,
-    ReturnStatement,
-    ThrowStatement,
-    TryStatement,
-    CatchClause,
-    LabeledStatement,
-    WithStatement,
-    DebuggerStatement,
-    ImportDeclaration,
-    ImportSpecifier,
-    ImportDefaultSpecifier,
-    ImportNamespaceSpecifier,
-    ExportNamedDeclaration,
-    ExportDefaultDeclaration,
-    ExportAllDeclaration,
-    ExportSpecifier,
-    AwaitExpression,
-    YieldExpression,
-    ThisExpression,
-    Super,
-    MetaProperty,
-    TaggedTemplateExpression,
-    ChainExpression,
-    ImportExpression,
-    AssignmentPattern,
-    ArrayPattern,
-    ObjectPattern,
-    RestElement,
-    TSTypeAnnotation,
-    TSTypeParameterDeclaration,
-    TSTypeParameter,
-    TSTypeParameterInstantiation,
-    TSTypeReference,
-    TSQualifiedName,
-    TSStringKeyword,
-    TSNumberKeyword,
-    TSBooleanKeyword,
-    TSBigIntKeyword,
-    TSSymbolKeyword,
-    TSObjectKeyword,
-    TSAnyKeyword,
-    TSUnknownKeyword,
-    TSNeverKeyword,
-    TSVoidKeyword,
-    TSUndefinedKeyword,
-    TSNullKeyword,
-    TSThisType,
-    TSArrayType,
-    TSTupleType,
-    TSNamedTupleMember,
-    TSOptionalType,
-    TSRestType,
-    TSUnionType,
-    TSIntersectionType,
-    TSParenthesizedType,
-    TSTypeLiteral,
-    TSPropertySignature,
-    TSMethodSignature,
-    TSIndexSignature,
-    TSCallSignatureDeclaration,
-    TSConstructSignatureDeclaration,
-    TSFunctionType,
-    TSConstructorType,
-    TSConditionalType,
-    TSInferType,
-    TSMappedType,
-    TSIndexedAccessType,
-    TSTypeOperator,
-    TSTypePredicate,
-    TSTypeQuery,
-    TSLiteralType,
-    TSTemplateLiteralType,
-    TSInterfaceDeclaration,
-    TSInterfaceBody,
-    TSInterfaceHeritage,
-    TSTypeAliasDeclaration,
-    TSEnumDeclaration,
-    TSEnumMember,
-    TSModuleDeclaration,
-    TSModuleBlock,
-    TSDeclareFunction,
-    TSDeclareMethod,
-    TSAsExpression,
-    TSSatisfiesExpression,
-    TSTypeAssertion,
-    TSNonNullExpression,
-    TSInstantiationExpression,
-    TSImportType,
-    TSImportEqualsDeclaration,
-    TSExternalModuleReference,
-    TSExportAssignment,
-    TSNamespaceExportDeclaration,
-    Decorator,
-    TSParameterProperty,
-    EtherTypeAlias,
-    EtherGenericType
-}