ether-code 0.1.5 → 0.1.7

package/parsers/ast-node.js

@@ -1,2440 +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 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, shorthand = false, computed = false, loc = null) {
-        super('Property', loc)
-        this.key = key
-        this.value = value
-        this.shorthand = shorthand
-        this.computed = computed
-    }
-}
-
-class SpreadElement extends ASTNode {
-    constructor(argument, loc = null) {
-        super('SpreadElement', loc)
-        this.argument = argument
-    }
-}
-
-class RequireStatement extends ASTNode {
-    constructor(module, variable = null, loc = null) {
-        super('RequireStatement', loc)
-        this.module = module
-        this.variable = variable
-    }
-}
-
-class RequireDestructuring extends ASTNode {
-    constructor(module, properties = [], loc = null) {
-        super('RequireDestructuring', loc)
-        this.module = module
-        this.properties = properties
-    }
-}
-
-class ImportDeclaration extends ASTNode {
-    constructor(specifiers = [], source, loc = null) {
-        super('ImportDeclaration', loc)
-        this.specifiers = specifiers
-        this.source = source
-    }
-}
-
-class ImportDefaultSpecifier extends ASTNode {
-    constructor(local, loc = null) {
-        super('ImportDefaultSpecifier', loc)
-        this.local = local
-    }
-}
-
-class ImportSpecifier extends ASTNode {
-    constructor(imported, local, loc = null) {
-        super('ImportSpecifier', loc)
-        this.imported = imported
-        this.local = local
-    }
-}
-
-class ImportNamespaceSpecifier extends ASTNode {
-    constructor(local, loc = null) {
-        super('ImportNamespaceSpecifier', loc)
-        this.local = local
-    }
-}
-
-class DynamicImport extends ASTNode {
-    constructor(source, loc = null) {
-        super('DynamicImport', loc)
-        this.source = source
-    }
-}
-
-class ExportNamedDeclaration extends ASTNode {
-    constructor(declaration = null, specifiers = [], source = null, loc = null) {
-        super('ExportNamedDeclaration', loc)
-        this.declaration = declaration
-        this.specifiers = specifiers
-        this.source = source
-    }
-}
-
-class ExportDefaultDeclaration extends ASTNode {
-    constructor(declaration, loc = null) {
-        super('ExportDefaultDeclaration', loc)
-        this.declaration = declaration
-    }
-}
-
-class ExportSpecifier extends ASTNode {
-    constructor(local, exported, loc = null) {
-        super('ExportSpecifier', loc)
-        this.local = local
-        this.exported = exported
-    }
-}
-
-class ModuleExports extends ASTNode {
-    constructor(value, loc = null) {
-        super('ModuleExports', loc)
-        this.value = value
-    }
-}
-
-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 FunctionDeclaration extends ASTNode {
-    constructor(id, params = [], body, async = false, generator = false, loc = null) {
-        super('FunctionDeclaration', loc)
-        this.id = id
-        this.params = params
-        this.body = body
-        this.async = async
-        this.generator = generator
-    }
-}
-
-class FunctionExpression extends ASTNode {
-    constructor(id = null, params = [], body, async = false, generator = false, loc = null) {
-        super('FunctionExpression', loc)
-        this.id = id
-        this.params = params
-        this.body = body
-        this.async = async
-        this.generator = generator
-    }
-}
-
-class ArrowFunctionExpression extends ASTNode {
-    constructor(params = [], body, async = false, expression = false, loc = null) {
-        super('ArrowFunctionExpression', loc)
-        this.params = params
-        this.body = body
-        this.async = async
-        this.expression = expression
-    }
-}
-
-class BlockStatement extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('BlockStatement', loc)
-        this.body = body
-    }
-}
-
-class ReturnStatement extends ASTNode {
-    constructor(argument = null, loc = null) {
-        super('ReturnStatement', loc)
-        this.argument = argument
-    }
-}
-
-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 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 ThrowStatement extends ASTNode {
-    constructor(argument, loc = null) {
-        super('ThrowStatement', loc)
-        this.argument = argument
-    }
-}
-
-class ClassDeclaration extends ASTNode {
-    constructor(id, superClass = null, body, loc = null) {
-        super('ClassDeclaration', loc)
-        this.id = id
-        this.superClass = superClass
-        this.body = body
-    }
-}
-
-class ClassExpression extends ASTNode {
-    constructor(id = null, superClass = null, body, loc = null) {
-        super('ClassExpression', loc)
-        this.id = id
-        this.superClass = superClass
-        this.body = body
-    }
-}
-
-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, static_ = false, loc = null) {
-        super('MethodDefinition', loc)
-        this.key = key
-        this.value = value
-        this.kind = kind
-        this.computed = computed
-        this.static = static_
-    }
-}
-
-class PropertyDefinition extends ASTNode {
-    constructor(key, value = null, computed = false, static_ = false, loc = null) {
-        super('PropertyDefinition', loc)
-        this.key = key
-        this.value = value
-        this.computed = computed
-        this.static = static_
-    }
-}
-
-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 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 = false, loc = null) {
-        super('UpdateExpression', loc)
-        this.operator = operator
-        this.argument = argument
-        this.prefix = prefix
-    }
-}
-
-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 AssignmentExpression extends ASTNode {
-    constructor(operator, left, right, loc = null) {
-        super('AssignmentExpression', loc)
-        this.operator = operator
-        this.left = left
-        this.right = right
-    }
-}
-
-class SequenceExpression extends ASTNode {
-    constructor(expressions = [], loc = null) {
-        super('SequenceExpression', loc)
-        this.expressions = expressions
-    }
-}
-
-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 RestElement extends ASTNode {
-    constructor(argument, loc = null) {
-        super('RestElement', loc)
-        this.argument = argument
-    }
-}
-
-class AssignmentPattern extends ASTNode {
-    constructor(left, right, loc = null) {
-        super('AssignmentPattern', loc)
-        this.left = left
-        this.right = right
-    }
-}
-
-class ArrayPattern extends ASTNode {
-    constructor(elements = [], loc = null) {
-        super('ArrayPattern', loc)
-        this.elements = elements
-    }
-}
-
-class ObjectPattern extends ASTNode {
-    constructor(properties = [], loc = null) {
-        super('ObjectPattern', loc)
-        this.properties = properties
-    }
-}
-
-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 DebuggerStatement extends ASTNode {
-    constructor(loc = null) {
-        super('DebuggerStatement', loc)
-    }
-}
-
-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 FSReadFile extends ASTNode {
-    constructor(path, options = null, callback = null, loc = null) {
-        super('FSReadFile', loc)
-        this.path = path
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class FSReadFileSync extends ASTNode {
-    constructor(path, options = null, loc = null) {
-        super('FSReadFileSync', loc)
-        this.path = path
-        this.options = options
-    }
-}
-
-class FSWriteFile extends ASTNode {
-    constructor(path, data, options = null, callback = null, loc = null) {
-        super('FSWriteFile', loc)
-        this.path = path
-        this.data = data
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class FSWriteFileSync extends ASTNode {
-    constructor(path, data, options = null, loc = null) {
-        super('FSWriteFileSync', loc)
-        this.path = path
-        this.data = data
-        this.options = options
-    }
-}
-
-class FSReadDir extends ASTNode {
-    constructor(path, options = null, callback = null, loc = null) {
-        super('FSReadDir', loc)
-        this.path = path
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class FSMkdir extends ASTNode {
-    constructor(path, options = null, callback = null, loc = null) {
-        super('FSMkdir', loc)
-        this.path = path
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class FSUnlink extends ASTNode {
-    constructor(path, callback = null, loc = null) {
-        super('FSUnlink', loc)
-        this.path = path
-        this.callback = callback
-    }
-}
-
-class FSRmdir extends ASTNode {
-    constructor(path, options = null, callback = null, loc = null) {
-        super('FSRmdir', loc)
-        this.path = path
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class FSRm extends ASTNode {
-    constructor(path, options = null, callback = null, loc = null) {
-        super('FSRm', loc)
-        this.path = path
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class FSRename extends ASTNode {
-    constructor(oldPath, newPath, callback = null, loc = null) {
-        super('FSRename', loc)
-        this.oldPath = oldPath
-        this.newPath = newPath
-        this.callback = callback
-    }
-}
-
-class FSCopyFile extends ASTNode {
-    constructor(src, dest, flags = null, callback = null, loc = null) {
-        super('FSCopyFile', loc)
-        this.src = src
-        this.dest = dest
-        this.flags = flags
-        this.callback = callback
-    }
-}
-
-class FSStat extends ASTNode {
-    constructor(path, options = null, callback = null, loc = null) {
-        super('FSStat', loc)
-        this.path = path
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class FSExists extends ASTNode {
-    constructor(path, loc = null) {
-        super('FSExists', loc)
-        this.path = path
-    }
-}
-
-class FSAccess extends ASTNode {
-    constructor(path, mode = null, callback = null, loc = null) {
-        super('FSAccess', loc)
-        this.path = path
-        this.mode = mode
-        this.callback = callback
-    }
-}
-
-class FSAppendFile extends ASTNode {
-    constructor(path, data, options = null, callback = null, loc = null) {
-        super('FSAppendFile', loc)
-        this.path = path
-        this.data = data
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class FSCreateReadStream extends ASTNode {
-    constructor(path, options = null, loc = null) {
-        super('FSCreateReadStream', loc)
-        this.path = path
-        this.options = options
-    }
-}
-
-class FSCreateWriteStream extends ASTNode {
-    constructor(path, options = null, loc = null) {
-        super('FSCreateWriteStream', loc)
-        this.path = path
-        this.options = options
-    }
-}
-
-class FSWatch extends ASTNode {
-    constructor(path, options = null, listener = null, loc = null) {
-        super('FSWatch', loc)
-        this.path = path
-        this.options = options
-        this.listener = listener
-    }
-}
-
-class FSWatchFile extends ASTNode {
-    constructor(path, options = null, listener = null, loc = null) {
-        super('FSWatchFile', loc)
-        this.path = path
-        this.options = options
-        this.listener = listener
-    }
-}
-
-class PathJoin extends ASTNode {
-    constructor(paths = [], loc = null) {
-        super('PathJoin', loc)
-        this.paths = paths
-    }
-}
-
-class PathResolve extends ASTNode {
-    constructor(paths = [], loc = null) {
-        super('PathResolve', loc)
-        this.paths = paths
-    }
-}
-
-class PathNormalize extends ASTNode {
-    constructor(path, loc = null) {
-        super('PathNormalize', loc)
-        this.path = path
-    }
-}
-
-class PathDirname extends ASTNode {
-    constructor(path, loc = null) {
-        super('PathDirname', loc)
-        this.path = path
-    }
-}
-
-class PathBasename extends ASTNode {
-    constructor(path, ext = null, loc = null) {
-        super('PathBasename', loc)
-        this.path = path
-        this.ext = ext
-    }
-}
-
-class PathExtname extends ASTNode {
-    constructor(path, loc = null) {
-        super('PathExtname', loc)
-        this.path = path
-    }
-}
-
-class PathParse extends ASTNode {
-    constructor(path, loc = null) {
-        super('PathParse', loc)
-        this.path = path
-    }
-}
-
-class PathFormat extends ASTNode {
-    constructor(pathObject, loc = null) {
-        super('PathFormat', loc)
-        this.pathObject = pathObject
-    }
-}
-
-class PathIsAbsolute extends ASTNode {
-    constructor(path, loc = null) {
-        super('PathIsAbsolute', loc)
-        this.path = path
-    }
-}
-
-class PathRelative extends ASTNode {
-    constructor(from, to, loc = null) {
-        super('PathRelative', loc)
-        this.from = from
-        this.to = to
-    }
-}
-
-class HttpCreateServer extends ASTNode {
-    constructor(requestListener = null, loc = null) {
-        super('HttpCreateServer', loc)
-        this.requestListener = requestListener
-    }
-}
-
-class HttpsCreateServer extends ASTNode {
-    constructor(options = null, requestListener = null, loc = null) {
-        super('HttpsCreateServer', loc)
-        this.options = options
-        this.requestListener = requestListener
-    }
-}
-
-class ServerListen extends ASTNode {
-    constructor(port, hostname = null, backlog = null, callback = null, loc = null) {
-        super('ServerListen', loc)
-        this.port = port
-        this.hostname = hostname
-        this.backlog = backlog
-        this.callback = callback
-    }
-}
-
-class ServerClose extends ASTNode {
-    constructor(callback = null, loc = null) {
-        super('ServerClose', loc)
-        this.callback = callback
-    }
-}
-
-class HttpRequest extends ASTNode {
-    constructor(options, callback = null, loc = null) {
-        super('HttpRequest', loc)
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class HttpGet extends ASTNode {
-    constructor(url, options = null, callback = null, loc = null) {
-        super('HttpGet', loc)
-        this.url = url
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class ResponseSetHeader extends ASTNode {
-    constructor(name, value, loc = null) {
-        super('ResponseSetHeader', loc)
-        this.name = name
-        this.value = value
-    }
-}
-
-class ResponseGetHeader extends ASTNode {
-    constructor(name, loc = null) {
-        super('ResponseGetHeader', loc)
-        this.name = name
-    }
-}
-
-class ResponseRemoveHeader extends ASTNode {
-    constructor(name, loc = null) {
-        super('ResponseRemoveHeader', loc)
-        this.name = name
-    }
-}
-
-class ResponseWriteHead extends ASTNode {
-    constructor(statusCode, statusMessage = null, headers = null, loc = null) {
-        super('ResponseWriteHead', loc)
-        this.statusCode = statusCode
-        this.statusMessage = statusMessage
-        this.headers = headers
-    }
-}
-
-class ResponseWrite extends ASTNode {
-    constructor(chunk, encoding = null, callback = null, loc = null) {
-        super('ResponseWrite', loc)
-        this.chunk = chunk
-        this.encoding = encoding
-        this.callback = callback
-    }
-}
-
-class ResponseEnd extends ASTNode {
-    constructor(data = null, encoding = null, callback = null, loc = null) {
-        super('ResponseEnd', loc)
-        this.data = data
-        this.encoding = encoding
-        this.callback = callback
-    }
-}
-
-class ProcessEnv extends ASTNode {
-    constructor(variable = null, loc = null) {
-        super('ProcessEnv', loc)
-        this.variable = variable
-    }
-}
-
-class ProcessArgv extends ASTNode {
-    constructor(loc = null) {
-        super('ProcessArgv', loc)
-    }
-}
-
-class ProcessCwd extends ASTNode {
-    constructor(loc = null) {
-        super('ProcessCwd', loc)
-    }
-}
-
-class ProcessChdir extends ASTNode {
-    constructor(directory, loc = null) {
-        super('ProcessChdir', loc)
-        this.directory = directory
-    }
-}
-
-class ProcessExit extends ASTNode {
-    constructor(code = null, loc = null) {
-        super('ProcessExit', loc)
-        this.code = code
-    }
-}
-
-class ProcessKill extends ASTNode {
-    constructor(pid, signal = null, loc = null) {
-        super('ProcessKill', loc)
-        this.pid = pid
-        this.signal = signal
-    }
-}
-
-class ProcessNextTick extends ASTNode {
-    constructor(callback, args = [], loc = null) {
-        super('ProcessNextTick', loc)
-        this.callback = callback
-        this.args = args
-    }
-}
-
-class ProcessMemoryUsage extends ASTNode {
-    constructor(loc = null) {
-        super('ProcessMemoryUsage', loc)
-    }
-}
-
-class ProcessCpuUsage extends ASTNode {
-    constructor(previousValue = null, loc = null) {
-        super('ProcessCpuUsage', loc)
-        this.previousValue = previousValue
-    }
-}
-
-class ProcessUptime extends ASTNode {
-    constructor(loc = null) {
-        super('ProcessUptime', loc)
-    }
-}
-
-class ProcessHrtime extends ASTNode {
-    constructor(time = null, loc = null) {
-        super('ProcessHrtime', loc)
-        this.time = time
-    }
-}
-
-class ProcessOn extends ASTNode {
-    constructor(event, listener, loc = null) {
-        super('ProcessOn', loc)
-        this.event = event
-        this.listener = listener
-    }
-}
-
-class EventEmitterClass extends ASTNode {
-    constructor(loc = null) {
-        super('EventEmitterClass', loc)
-    }
-}
-
-class EventEmit extends ASTNode {
-    constructor(emitter, eventName, args = [], loc = null) {
-        super('EventEmit', loc)
-        this.emitter = emitter
-        this.eventName = eventName
-        this.args = args
-    }
-}
-
-class EventOn extends ASTNode {
-    constructor(emitter, eventName, listener, loc = null) {
-        super('EventOn', loc)
-        this.emitter = emitter
-        this.eventName = eventName
-        this.listener = listener
-    }
-}
-
-class EventOnce extends ASTNode {
-    constructor(emitter, eventName, listener, loc = null) {
-        super('EventOnce', loc)
-        this.emitter = emitter
-        this.eventName = eventName
-        this.listener = listener
-    }
-}
-
-class EventRemoveListener extends ASTNode {
-    constructor(emitter, eventName, listener, loc = null) {
-        super('EventRemoveListener', loc)
-        this.emitter = emitter
-        this.eventName = eventName
-        this.listener = listener
-    }
-}
-
-class EventRemoveAllListeners extends ASTNode {
-    constructor(emitter, eventName = null, loc = null) {
-        super('EventRemoveAllListeners', loc)
-        this.emitter = emitter
-        this.eventName = eventName
-    }
-}
-
-class EventListeners extends ASTNode {
-    constructor(emitter, eventName, loc = null) {
-        super('EventListeners', loc)
-        this.emitter = emitter
-        this.eventName = eventName
-    }
-}
-
-class EventListenerCount extends ASTNode {
-    constructor(emitter, eventName, loc = null) {
-        super('EventListenerCount', loc)
-        this.emitter = emitter
-        this.eventName = eventName
-    }
-}
-
-class EventSetMaxListeners extends ASTNode {
-    constructor(emitter, n, loc = null) {
-        super('EventSetMaxListeners', loc)
-        this.emitter = emitter
-        this.n = n
-    }
-}
-
-class StreamReadable extends ASTNode {
-    constructor(options = null, loc = null) {
-        super('StreamReadable', loc)
-        this.options = options
-    }
-}
-
-class StreamWritable extends ASTNode {
-    constructor(options = null, loc = null) {
-        super('StreamWritable', loc)
-        this.options = options
-    }
-}
-
-class StreamDuplex extends ASTNode {
-    constructor(options = null, loc = null) {
-        super('StreamDuplex', loc)
-        this.options = options
-    }
-}
-
-class StreamTransform extends ASTNode {
-    constructor(options = null, loc = null) {
-        super('StreamTransform', loc)
-        this.options = options
-    }
-}
-
-class StreamPassThrough extends ASTNode {
-    constructor(options = null, loc = null) {
-        super('StreamPassThrough', loc)
-        this.options = options
-    }
-}
-
-class StreamPipe extends ASTNode {
-    constructor(source, destination, options = null, loc = null) {
-        super('StreamPipe', loc)
-        this.source = source
-        this.destination = destination
-        this.options = options
-    }
-}
-
-class StreamUnpipe extends ASTNode {
-    constructor(source, destination = null, loc = null) {
-        super('StreamUnpipe', loc)
-        this.source = source
-        this.destination = destination
-    }
-}
-
-class StreamRead extends ASTNode {
-    constructor(stream, size = null, loc = null) {
-        super('StreamRead', loc)
-        this.stream = stream
-        this.size = size
-    }
-}
-
-class StreamWrite extends ASTNode {
-    constructor(stream, chunk, encoding = null, callback = null, loc = null) {
-        super('StreamWrite', loc)
-        this.stream = stream
-        this.chunk = chunk
-        this.encoding = encoding
-        this.callback = callback
-    }
-}
-
-class StreamEnd extends ASTNode {
-    constructor(stream, chunk = null, encoding = null, callback = null, loc = null) {
-        super('StreamEnd', loc)
-        this.stream = stream
-        this.chunk = chunk
-        this.encoding = encoding
-        this.callback = callback
-    }
-}
-
-class StreamDestroy extends ASTNode {
-    constructor(stream, error = null, loc = null) {
-        super('StreamDestroy', loc)
-        this.stream = stream
-        this.error = error
-    }
-}
-
-class StreamPause extends ASTNode {
-    constructor(stream, loc = null) {
-        super('StreamPause', loc)
-        this.stream = stream
-    }
-}
-
-class StreamResume extends ASTNode {
-    constructor(stream, loc = null) {
-        super('StreamResume', loc)
-        this.stream = stream
-    }
-}
-
-class StreamSetEncoding extends ASTNode {
-    constructor(stream, encoding, loc = null) {
-        super('StreamSetEncoding', loc)
-        this.stream = stream
-        this.encoding = encoding
-    }
-}
-
-class BufferAlloc extends ASTNode {
-    constructor(size, fill = null, encoding = null, loc = null) {
-        super('BufferAlloc', loc)
-        this.size = size
-        this.fill = fill
-        this.encoding = encoding
-    }
-}
-
-class BufferAllocUnsafe extends ASTNode {
-    constructor(size, loc = null) {
-        super('BufferAllocUnsafe', loc)
-        this.size = size
-    }
-}
-
-class BufferFrom extends ASTNode {
-    constructor(data, encodingOrOffset = null, length = null, loc = null) {
-        super('BufferFrom', loc)
-        this.data = data
-        this.encodingOrOffset = encodingOrOffset
-        this.length = length
-    }
-}
-
-class BufferConcat extends ASTNode {
-    constructor(list, totalLength = null, loc = null) {
-        super('BufferConcat', loc)
-        this.list = list
-        this.totalLength = totalLength
-    }
-}
-
-class BufferCompare extends ASTNode {
-    constructor(buf1, buf2, loc = null) {
-        super('BufferCompare', loc)
-        this.buf1 = buf1
-        this.buf2 = buf2
-    }
-}
-
-class BufferIsBuffer extends ASTNode {
-    constructor(obj, loc = null) {
-        super('BufferIsBuffer', loc)
-        this.obj = obj
-    }
-}
-
-class BufferByteLength extends ASTNode {
-    constructor(string, encoding = null, loc = null) {
-        super('BufferByteLength', loc)
-        this.string = string
-        this.encoding = encoding
-    }
-}
-
-class BufferToString extends ASTNode {
-    constructor(buffer, encoding = null, start = null, end = null, loc = null) {
-        super('BufferToString', loc)
-        this.buffer = buffer
-        this.encoding = encoding
-        this.start = start
-        this.end = end
-    }
-}
-
-class BufferToJSON extends ASTNode {
-    constructor(buffer, loc = null) {
-        super('BufferToJSON', loc)
-        this.buffer = buffer
-    }
-}
-
-class BufferCopy extends ASTNode {
-    constructor(source, target, targetStart = null, sourceStart = null, sourceEnd = null, loc = null) {
-        super('BufferCopy', loc)
-        this.source = source
-        this.target = target
-        this.targetStart = targetStart
-        this.sourceStart = sourceStart
-        this.sourceEnd = sourceEnd
-    }
-}
-
-class BufferSlice extends ASTNode {
-    constructor(buffer, start = null, end = null, loc = null) {
-        super('BufferSlice', loc)
-        this.buffer = buffer
-        this.start = start
-        this.end = end
-    }
-}
-
-class BufferFill extends ASTNode {
-    constructor(buffer, value, offset = null, end = null, encoding = null, loc = null) {
-        super('BufferFill', loc)
-        this.buffer = buffer
-        this.value = value
-        this.offset = offset
-        this.end = end
-        this.encoding = encoding
-    }
-}
-
-class BufferIncludes extends ASTNode {
-    constructor(buffer, value, byteOffset = null, encoding = null, loc = null) {
-        super('BufferIncludes', loc)
-        this.buffer = buffer
-        this.value = value
-        this.byteOffset = byteOffset
-        this.encoding = encoding
-    }
-}
-
-class BufferIndexOf extends ASTNode {
-    constructor(buffer, value, byteOffset = null, encoding = null, loc = null) {
-        super('BufferIndexOf', loc)
-        this.buffer = buffer
-        this.value = value
-        this.byteOffset = byteOffset
-        this.encoding = encoding
-    }
-}
-
-class OsType extends ASTNode {
-    constructor(loc = null) {
-        super('OsType', loc)
-    }
-}
-
-class OsPlatform extends ASTNode {
-    constructor(loc = null) {
-        super('OsPlatform', loc)
-    }
-}
-
-class OsArch extends ASTNode {
-    constructor(loc = null) {
-        super('OsArch', loc)
-    }
-}
-
-class OsVersion extends ASTNode {
-    constructor(loc = null) {
-        super('OsVersion', loc)
-    }
-}
-
-class OsRelease extends ASTNode {
-    constructor(loc = null) {
-        super('OsRelease', loc)
-    }
-}
-
-class OsHostname extends ASTNode {
-    constructor(loc = null) {
-        super('OsHostname', loc)
-    }
-}
-
-class OsTotalmem extends ASTNode {
-    constructor(loc = null) {
-        super('OsTotalmem', loc)
-    }
-}
-
-class OsFreemem extends ASTNode {
-    constructor(loc = null) {
-        super('OsFreemem', loc)
-    }
-}
-
-class OsCpus extends ASTNode {
-    constructor(loc = null) {
-        super('OsCpus', loc)
-    }
-}
-
-class OsLoadavg extends ASTNode {
-    constructor(loc = null) {
-        super('OsLoadavg', loc)
-    }
-}
-
-class OsUserInfo extends ASTNode {
-    constructor(options = null, loc = null) {
-        super('OsUserInfo', loc)
-        this.options = options
-    }
-}
-
-class OsHomedir extends ASTNode {
-    constructor(loc = null) {
-        super('OsHomedir', loc)
-    }
-}
-
-class OsTmpdir extends ASTNode {
-    constructor(loc = null) {
-        super('OsTmpdir', loc)
-    }
-}
-
-class OsNetworkInterfaces extends ASTNode {
-    constructor(loc = null) {
-        super('OsNetworkInterfaces', loc)
-    }
-}
-
-class OsUptime extends ASTNode {
-    constructor(loc = null) {
-        super('OsUptime', loc)
-    }
-}
-
-class CryptoCreateHash extends ASTNode {
-    constructor(algorithm, options = null, loc = null) {
-        super('CryptoCreateHash', loc)
-        this.algorithm = algorithm
-        this.options = options
-    }
-}
-
-class CryptoCreateHmac extends ASTNode {
-    constructor(algorithm, key, options = null, loc = null) {
-        super('CryptoCreateHmac', loc)
-        this.algorithm = algorithm
-        this.key = key
-        this.options = options
-    }
-}
-
-class HashUpdate extends ASTNode {
-    constructor(hash, data, inputEncoding = null, loc = null) {
-        super('HashUpdate', loc)
-        this.hash = hash
-        this.data = data
-        this.inputEncoding = inputEncoding
-    }
-}
-
-class HashDigest extends ASTNode {
-    constructor(hash, encoding = null, loc = null) {
-        super('HashDigest', loc)
-        this.hash = hash
-        this.encoding = encoding
-    }
-}
-
-class CryptoCreateCipheriv extends ASTNode {
-    constructor(algorithm, key, iv, options = null, loc = null) {
-        super('CryptoCreateCipheriv', loc)
-        this.algorithm = algorithm
-        this.key = key
-        this.iv = iv
-        this.options = options
-    }
-}
-
-class CryptoCreateDecipheriv extends ASTNode {
-    constructor(algorithm, key, iv, options = null, loc = null) {
-        super('CryptoCreateDecipheriv', loc)
-        this.algorithm = algorithm
-        this.key = key
-        this.iv = iv
-        this.options = options
-    }
-}
-
-class CryptoRandomBytes extends ASTNode {
-    constructor(size, callback = null, loc = null) {
-        super('CryptoRandomBytes', loc)
-        this.size = size
-        this.callback = callback
-    }
-}
-
-class CryptoRandomFill extends ASTNode {
-    constructor(buffer, offset = null, size = null, callback = null, loc = null) {
-        super('CryptoRandomFill', loc)
-        this.buffer = buffer
-        this.offset = offset
-        this.size = size
-        this.callback = callback
-    }
-}
-
-class CryptoRandomUUID extends ASTNode {
-    constructor(options = null, loc = null) {
-        super('CryptoRandomUUID', loc)
-        this.options = options
-    }
-}
-
-class CryptoRandomInt extends ASTNode {
-    constructor(min, max = null, callback = null, loc = null) {
-        super('CryptoRandomInt', loc)
-        this.min = min
-        this.max = max
-        this.callback = callback
-    }
-}
-
-class CryptoPbkdf2 extends ASTNode {
-    constructor(password, salt, iterations, keylen, digest, callback = null, loc = null) {
-        super('CryptoPbkdf2', loc)
-        this.password = password
-        this.salt = salt
-        this.iterations = iterations
-        this.keylen = keylen
-        this.digest = digest
-        this.callback = callback
-    }
-}
-
-class CryptoPbkdf2Sync extends ASTNode {
-    constructor(password, salt, iterations, keylen, digest, loc = null) {
-        super('CryptoPbkdf2Sync', loc)
-        this.password = password
-        this.salt = salt
-        this.iterations = iterations
-        this.keylen = keylen
-        this.digest = digest
-    }
-}
-
-class CryptoScrypt extends ASTNode {
-    constructor(password, salt, keylen, options = null, callback = null, loc = null) {
-        super('CryptoScrypt', loc)
-        this.password = password
-        this.salt = salt
-        this.keylen = keylen
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class CryptoScryptSync extends ASTNode {
-    constructor(password, salt, keylen, options = null, loc = null) {
-        super('CryptoScryptSync', loc)
-        this.password = password
-        this.salt = salt
-        this.keylen = keylen
-        this.options = options
-    }
-}
-
-class CryptoCreateSign extends ASTNode {
-    constructor(algorithm, options = null, loc = null) {
-        super('CryptoCreateSign', loc)
-        this.algorithm = algorithm
-        this.options = options
-    }
-}
-
-class CryptoCreateVerify extends ASTNode {
-    constructor(algorithm, options = null, loc = null) {
-        super('CryptoCreateVerify', loc)
-        this.algorithm = algorithm
-        this.options = options
-    }
-}
-
-class CryptoSign extends ASTNode {
-    constructor(sign, privateKey, outputEncoding = null, loc = null) {
-        super('CryptoSign', loc)
-        this.sign = sign
-        this.privateKey = privateKey
-        this.outputEncoding = outputEncoding
-    }
-}
-
-class CryptoVerify extends ASTNode {
-    constructor(verify, publicKey, signature, signatureEncoding = null, loc = null) {
-        super('CryptoVerify', loc)
-        this.verify = verify
-        this.publicKey = publicKey
-        this.signature = signature
-        this.signatureEncoding = signatureEncoding
-    }
-}
-
-class CryptoGetHashes extends ASTNode {
-    constructor(loc = null) {
-        super('CryptoGetHashes', loc)
-    }
-}
-
-class CryptoGetCiphers extends ASTNode {
-    constructor(loc = null) {
-        super('CryptoGetCiphers', loc)
-    }
-}
-
-class CryptoGetCurves extends ASTNode {
-    constructor(loc = null) {
-        super('CryptoGetCurves', loc)
-    }
-}
-
-class URLClass extends ASTNode {
-    constructor(input, base = null, loc = null) {
-        super('URLClass', loc)
-        this.input = input
-        this.base = base
-    }
-}
-
-class URLParse extends ASTNode {
-    constructor(urlString, parseQueryString = null, slashesDenoteHost = null, loc = null) {
-        super('URLParse', loc)
-        this.urlString = urlString
-        this.parseQueryString = parseQueryString
-        this.slashesDenoteHost = slashesDenoteHost
-    }
-}
-
-class URLFormat extends ASTNode {
-    constructor(urlObject, options = null, loc = null) {
-        super('URLFormat', loc)
-        this.urlObject = urlObject
-        this.options = options
-    }
-}
-
-class URLResolve extends ASTNode {
-    constructor(from, to, loc = null) {
-        super('URLResolve', loc)
-        this.from = from
-        this.to = to
-    }
-}
-
-class URLSearchParamsClass extends ASTNode {
-    constructor(init = null, loc = null) {
-        super('URLSearchParamsClass', loc)
-        this.init = init
-    }
-}
-
-class URLSearchParamsGet extends ASTNode {
-    constructor(params, name, loc = null) {
-        super('URLSearchParamsGet', loc)
-        this.params = params
-        this.name = name
-    }
-}
-
-class URLSearchParamsGetAll extends ASTNode {
-    constructor(params, name, loc = null) {
-        super('URLSearchParamsGetAll', loc)
-        this.params = params
-        this.name = name
-    }
-}
-
-class URLSearchParamsAppend extends ASTNode {
-    constructor(params, name, value, loc = null) {
-        super('URLSearchParamsAppend', loc)
-        this.params = params
-        this.name = name
-        this.value = value
-    }
-}
-
-class URLSearchParamsSet extends ASTNode {
-    constructor(params, name, value, loc = null) {
-        super('URLSearchParamsSet', loc)
-        this.params = params
-        this.name = name
-        this.value = value
-    }
-}
-
-class URLSearchParamsDelete extends ASTNode {
-    constructor(params, name, loc = null) {
-        super('URLSearchParamsDelete', loc)
-        this.params = params
-        this.name = name
-    }
-}
-
-class URLSearchParamsHas extends ASTNode {
-    constructor(params, name, loc = null) {
-        super('URLSearchParamsHas', loc)
-        this.params = params
-        this.name = name
-    }
-}
-
-class URLSearchParamsSort extends ASTNode {
-    constructor(params, loc = null) {
-        super('URLSearchParamsSort', loc)
-        this.params = params
-    }
-}
-
-class ChildProcessSpawn extends ASTNode {
-    constructor(command, args = [], options = null, loc = null) {
-        super('ChildProcessSpawn', loc)
-        this.command = command
-        this.args = args
-        this.options = options
-    }
-}
-
-class ChildProcessExec extends ASTNode {
-    constructor(command, options = null, callback = null, loc = null) {
-        super('ChildProcessExec', loc)
-        this.command = command
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class ChildProcessExecFile extends ASTNode {
-    constructor(file, args = [], options = null, callback = null, loc = null) {
-        super('ChildProcessExecFile', loc)
-        this.file = file
-        this.args = args
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class ChildProcessFork extends ASTNode {
-    constructor(modulePath, args = [], options = null, loc = null) {
-        super('ChildProcessFork', loc)
-        this.modulePath = modulePath
-        this.args = args
-        this.options = options
-    }
-}
-
-class ChildProcessSpawnSync extends ASTNode {
-    constructor(command, args = [], options = null, loc = null) {
-        super('ChildProcessSpawnSync', loc)
-        this.command = command
-        this.args = args
-        this.options = options
-    }
-}
-
-class ChildProcessExecSync extends ASTNode {
-    constructor(command, options = null, loc = null) {
-        super('ChildProcessExecSync', loc)
-        this.command = command
-        this.options = options
-    }
-}
-
-class ChildProcessExecFileSync extends ASTNode {
-    constructor(file, args = [], options = null, loc = null) {
-        super('ChildProcessExecFileSync', loc)
-        this.file = file
-        this.args = args
-        this.options = options
-    }
-}
-
-class ChildKill extends ASTNode {
-    constructor(child, signal = null, loc = null) {
-        super('ChildKill', loc)
-        this.child = child
-        this.signal = signal
-    }
-}
-
-class ChildSend extends ASTNode {
-    constructor(child, message, sendHandle = null, options = null, callback = null, loc = null) {
-        super('ChildSend', loc)
-        this.child = child
-        this.message = message
-        this.sendHandle = sendHandle
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class ChildDisconnect extends ASTNode {
-    constructor(child, loc = null) {
-        super('ChildDisconnect', loc)
-        this.child = child
-    }
-}
-
-class UtilPromisify extends ASTNode {
-    constructor(original, loc = null) {
-        super('UtilPromisify', loc)
-        this.original = original
-    }
-}
-
-class UtilCallbackify extends ASTNode {
-    constructor(original, loc = null) {
-        super('UtilCallbackify', loc)
-        this.original = original
-    }
-}
-
-class UtilFormat extends ASTNode {
-    constructor(format, args = [], loc = null) {
-        super('UtilFormat', loc)
-        this.format = format
-        this.args = args
-    }
-}
-
-class UtilInspect extends ASTNode {
-    constructor(object, options = null, loc = null) {
-        super('UtilInspect', loc)
-        this.object = object
-        this.options = options
-    }
-}
-
-class UtilDeprecate extends ASTNode {
-    constructor(fn, msg, code = null, loc = null) {
-        super('UtilDeprecate', loc)
-        this.fn = fn
-        this.msg = msg
-        this.code = code
-    }
-}
-
-class DnsLookup extends ASTNode {
-    constructor(hostname, options = null, callback = null, loc = null) {
-        super('DnsLookup', loc)
-        this.hostname = hostname
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class DnsResolve extends ASTNode {
-    constructor(hostname, rrtype = null, callback = null, loc = null) {
-        super('DnsResolve', loc)
-        this.hostname = hostname
-        this.rrtype = rrtype
-        this.callback = callback
-    }
-}
-
-class DnsResolve4 extends ASTNode {
-    constructor(hostname, options = null, callback = null, loc = null) {
-        super('DnsResolve4', loc)
-        this.hostname = hostname
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class DnsResolve6 extends ASTNode {
-    constructor(hostname, options = null, callback = null, loc = null) {
-        super('DnsResolve6', loc)
-        this.hostname = hostname
-        this.options = options
-        this.callback = callback
-    }
-}
-
-class DnsResolveMx extends ASTNode {
-    constructor(hostname, callback = null, loc = null) {
-        super('DnsResolveMx', loc)
-        this.hostname = hostname
-        this.callback = callback
-    }
-}
-
-class DnsResolveTxt extends ASTNode {
-    constructor(hostname, callback = null, loc = null) {
-        super('DnsResolveTxt', loc)
-        this.hostname = hostname
-        this.callback = callback
-    }
-}
-
-class DnsResolveNs extends ASTNode {
-    constructor(hostname, callback = null, loc = null) {
-        super('DnsResolveNs', loc)
-        this.hostname = hostname
-        this.callback = callback
-    }
-}
-
-class DnsResolveCname extends ASTNode {
-    constructor(hostname, callback = null, loc = null) {
-        super('DnsResolveCname', loc)
-        this.hostname = hostname
-        this.callback = callback
-    }
-}
-
-class DnsReverse extends ASTNode {
-    constructor(ip, callback = null, loc = null) {
-        super('DnsReverse', loc)
-        this.ip = ip
-        this.callback = callback
-    }
-}
-
-class SetTimeout extends ASTNode {
-    constructor(callback, delay, args = [], loc = null) {
-        super('SetTimeout', loc)
-        this.callback = callback
-        this.delay = delay
-        this.args = args
-    }
-}
-
-class ClearTimeout extends ASTNode {
-    constructor(timeoutId, loc = null) {
-        super('ClearTimeout', loc)
-        this.timeoutId = timeoutId
-    }
-}
-
-class SetInterval extends ASTNode {
-    constructor(callback, delay, args = [], loc = null) {
-        super('SetInterval', loc)
-        this.callback = callback
-        this.delay = delay
-        this.args = args
-    }
-}
-
-class ClearInterval extends ASTNode {
-    constructor(intervalId, loc = null) {
-        super('ClearInterval', loc)
-        this.intervalId = intervalId
-    }
-}
-
-class SetImmediate extends ASTNode {
-    constructor(callback, args = [], loc = null) {
-        super('SetImmediate', loc)
-        this.callback = callback
-        this.args = args
-    }
-}
-
-class ClearImmediate extends ASTNode {
-    constructor(immediateId, loc = null) {
-        super('ClearImmediate', loc)
-        this.immediateId = immediateId
-    }
-}
-
-class ConsoleLog extends ASTNode {
-    constructor(args = [], loc = null) {
-        super('ConsoleLog', loc)
-        this.args = args
-    }
-}
-
-class ConsoleError extends ASTNode {
-    constructor(args = [], loc = null) {
-        super('ConsoleError', loc)
-        this.args = args
-    }
-}
-
-class ConsoleWarn extends ASTNode {
-    constructor(args = [], loc = null) {
-        super('ConsoleWarn', loc)
-        this.args = args
-    }
-}
-
-class ConsoleInfo extends ASTNode {
-    constructor(args = [], loc = null) {
-        super('ConsoleInfo', loc)
-        this.args = args
-    }
-}
-
-class ConsoleDebug extends ASTNode {
-    constructor(args = [], loc = null) {
-        super('ConsoleDebug', loc)
-        this.args = args
-    }
-}
-
-class ConsoleTable extends ASTNode {
-    constructor(tabularData, properties = null, loc = null) {
-        super('ConsoleTable', loc)
-        this.tabularData = tabularData
-        this.properties = properties
-    }
-}
-
-class ConsoleTime extends ASTNode {
-    constructor(label = null, loc = null) {
-        super('ConsoleTime', loc)
-        this.label = label
-    }
-}
-
-class ConsoleTimeEnd extends ASTNode {
-    constructor(label = null, loc = null) {
-        super('ConsoleTimeEnd', loc)
-        this.label = label
-    }
-}
-
-class ConsoleTimeLog extends ASTNode {
-    constructor(label = null, args = [], loc = null) {
-        super('ConsoleTimeLog', loc)
-        this.label = label
-        this.args = args
-    }
-}
-
-class ConsoleTrace extends ASTNode {
-    constructor(args = [], loc = null) {
-        super('ConsoleTrace', loc)
-        this.args = args
-    }
-}
-
-class ConsoleClear extends ASTNode {
-    constructor(loc = null) {
-        super('ConsoleClear', loc)
-    }
-}
-
-class ConsoleCount extends ASTNode {
-    constructor(label = null, loc = null) {
-        super('ConsoleCount', loc)
-        this.label = label
-    }
-}
-
-class ConsoleCountReset extends ASTNode {
-    constructor(label = null, loc = null) {
-        super('ConsoleCountReset', loc)
-        this.label = label
-    }
-}
-
-class ConsoleGroup extends ASTNode {
-    constructor(args = [], loc = null) {
-        super('ConsoleGroup', loc)
-        this.args = args
-    }
-}
-
-class ConsoleGroupEnd extends ASTNode {
-    constructor(loc = null) {
-        super('ConsoleGroupEnd', loc)
-    }
-}
-
-class ConsoleGroupCollapsed extends ASTNode {
-    constructor(args = [], loc = null) {
-        super('ConsoleGroupCollapsed', loc)
-        this.args = args
-    }
-}
-
-class ConsoleAssert extends ASTNode {
-    constructor(assertion, args = [], loc = null) {
-        super('ConsoleAssert', loc)
-        this.assertion = assertion
-        this.args = args
-    }
-}
-
-class ConsoleDir extends ASTNode {
-    constructor(obj, options = null, loc = null) {
-        super('ConsoleDir', loc)
-        this.obj = obj
-        this.options = options
-    }
-}
-
-class GlobalVariable extends ASTNode {
-    constructor(name, loc = null) {
-        super('GlobalVariable', loc)
-        this.name = name
-    }
-}
-
-class Dirname extends ASTNode {
-    constructor(loc = null) {
-        super('Dirname', loc)
-    }
-}
-
-class Filename extends ASTNode {
-    constructor(loc = null) {
-        super('Filename', loc)
-    }
-}
-
-class PromiseExpression extends ASTNode {
-    constructor(executor, loc = null) {
-        super('PromiseExpression', loc)
-        this.executor = executor
-    }
-}
-
-class PromiseResolve extends ASTNode {
-    constructor(value = null, loc = null) {
-        super('PromiseResolve', loc)
-        this.value = value
-    }
-}
-
-class PromiseReject extends ASTNode {
-    constructor(reason = null, loc = null) {
-        super('PromiseReject', loc)
-        this.reason = reason
-    }
-}
-
-class PromiseAll extends ASTNode {
-    constructor(iterable, loc = null) {
-        super('PromiseAll', loc)
-        this.iterable = iterable
-    }
-}
-
-class PromiseAllSettled extends ASTNode {
-    constructor(iterable, loc = null) {
-        super('PromiseAllSettled', loc)
-        this.iterable = iterable
-    }
-}
-
-class PromiseRace extends ASTNode {
-    constructor(iterable, loc = null) {
-        super('PromiseRace', loc)
-        this.iterable = iterable
-    }
-}
-
-class PromiseAny extends ASTNode {
-    constructor(iterable, loc = null) {
-        super('PromiseAny', loc)
-        this.iterable = iterable
-    }
-}
-
-class PromiseThen extends ASTNode {
-    constructor(promise, onFulfilled = null, onRejected = null, loc = null) {
-        super('PromiseThen', loc)
-        this.promise = promise
-        this.onFulfilled = onFulfilled
-        this.onRejected = onRejected
-    }
-}
-
-class PromiseCatch extends ASTNode {
-    constructor(promise, onRejected, loc = null) {
-        super('PromiseCatch', loc)
-        this.promise = promise
-        this.onRejected = onRejected
-    }
-}
-
-class PromiseFinally extends ASTNode {
-    constructor(promise, onFinally, loc = null) {
-        super('PromiseFinally', loc)
-        this.promise = promise
-        this.onFinally = onFinally
-    }
-}
-
-module.exports = {
-    ASTNode,
-    Program,
-    Identifier,
-    StringLiteral,
-    NumericLiteral,
-    BooleanLiteral,
-    NullLiteral,
-    UndefinedLiteral,
-    TemplateLiteral,
-    TemplateElement,
-    RegExpLiteral,
-    ArrayExpression,
-    ObjectExpression,
-    Property,
-    SpreadElement,
-    RequireStatement,
-    RequireDestructuring,
-    ImportDeclaration,
-    ImportDefaultSpecifier,
-    ImportSpecifier,
-    ImportNamespaceSpecifier,
-    DynamicImport,
-    ExportNamedDeclaration,
-    ExportDefaultDeclaration,
-    ExportSpecifier,
-    ModuleExports,
-    VariableDeclaration,
-    VariableDeclarator,
-    FunctionDeclaration,
-    FunctionExpression,
-    ArrowFunctionExpression,
-    BlockStatement,
-    ReturnStatement,
-    IfStatement,
-    SwitchStatement,
-    SwitchCase,
-    ForStatement,
-    ForInStatement,
-    ForOfStatement,
-    WhileStatement,
-    DoWhileStatement,
-    BreakStatement,
-    ContinueStatement,
-    TryStatement,
-    CatchClause,
-    ThrowStatement,
-    ClassDeclaration,
-    ClassExpression,
-    ClassBody,
-    MethodDefinition,
-    PropertyDefinition,
-    CallExpression,
-    NewExpression,
-    MemberExpression,
-    BinaryExpression,
-    UnaryExpression,
-    UpdateExpression,
-    LogicalExpression,
-    ConditionalExpression,
-    AssignmentExpression,
-    SequenceExpression,
-    AwaitExpression,
-    YieldExpression,
-    ThisExpression,
-    Super,
-    RestElement,
-    AssignmentPattern,
-    ArrayPattern,
-    ObjectPattern,
-    ExpressionStatement,
-    EmptyStatement,
-    DebuggerStatement,
-    LabeledStatement,
-    WithStatement,
-    FSReadFile,
-    FSReadFileSync,
-    FSWriteFile,
-    FSWriteFileSync,
-    FSReadDir,
-    FSMkdir,
-    FSUnlink,
-    FSRmdir,
-    FSRm,
-    FSRename,
-    FSCopyFile,
-    FSStat,
-    FSExists,
-    FSAccess,
-    FSAppendFile,
-    FSCreateReadStream,
-    FSCreateWriteStream,
-    FSWatch,
-    FSWatchFile,
-    PathJoin,
-    PathResolve,
-    PathNormalize,
-    PathDirname,
-    PathBasename,
-    PathExtname,
-    PathParse,
-    PathFormat,
-    PathIsAbsolute,
-    PathRelative,
-    HttpCreateServer,
-    HttpsCreateServer,
-    ServerListen,
-    ServerClose,
-    HttpRequest,
-    HttpGet,
-    ResponseSetHeader,
-    ResponseGetHeader,
-    ResponseRemoveHeader,
-    ResponseWriteHead,
-    ResponseWrite,
-    ResponseEnd,
-    ProcessEnv,
-    ProcessArgv,
-    ProcessCwd,
-    ProcessChdir,
-    ProcessExit,
-    ProcessKill,
-    ProcessNextTick,
-    ProcessMemoryUsage,
-    ProcessCpuUsage,
-    ProcessUptime,
-    ProcessHrtime,
-    ProcessOn,
-    EventEmitterClass,
-    EventEmit,
-    EventOn,
-    EventOnce,
-    EventRemoveListener,
-    EventRemoveAllListeners,
-    EventListeners,
-    EventListenerCount,
-    EventSetMaxListeners,
-    StreamReadable,
-    StreamWritable,
-    StreamDuplex,
-    StreamTransform,
-    StreamPassThrough,
-    StreamPipe,
-    StreamUnpipe,
-    StreamRead,
-    StreamWrite,
-    StreamEnd,
-    StreamDestroy,
-    StreamPause,
-    StreamResume,
-    StreamSetEncoding,
-    BufferAlloc,
-    BufferAllocUnsafe,
-    BufferFrom,
-    BufferConcat,
-    BufferCompare,
-    BufferIsBuffer,
-    BufferByteLength,
-    BufferToString,
-    BufferToJSON,
-    BufferCopy,
-    BufferSlice,
-    BufferFill,
-    BufferIncludes,
-    BufferIndexOf,
-    OsType,
-    OsPlatform,
-    OsArch,
-    OsVersion,
-    OsRelease,
-    OsHostname,
-    OsTotalmem,
-    OsFreemem,
-    OsCpus,
-    OsLoadavg,
-    OsUserInfo,
-    OsHomedir,
-    OsTmpdir,
-    OsNetworkInterfaces,
-    OsUptime,
-    CryptoCreateHash,
-    CryptoCreateHmac,
-    HashUpdate,
-    HashDigest,
-    CryptoCreateCipheriv,
-    CryptoCreateDecipheriv,
-    CryptoRandomBytes,
-    CryptoRandomFill,
-    CryptoRandomUUID,
-    CryptoRandomInt,
-    CryptoPbkdf2,
-    CryptoPbkdf2Sync,
-    CryptoScrypt,
-    CryptoScryptSync,
-    CryptoCreateSign,
-    CryptoCreateVerify,
-    CryptoSign,
-    CryptoVerify,
-    CryptoGetHashes,
-    CryptoGetCiphers,
-    CryptoGetCurves,
-    URLClass,
-    URLParse,
-    URLFormat,
-    URLResolve,
-    URLSearchParamsClass,
-    URLSearchParamsGet,
-    URLSearchParamsGetAll,
-    URLSearchParamsAppend,
-    URLSearchParamsSet,
-    URLSearchParamsDelete,
-    URLSearchParamsHas,
-    URLSearchParamsSort,
-    ChildProcessSpawn,
-    ChildProcessExec,
-    ChildProcessExecFile,
-    ChildProcessFork,
-    ChildProcessSpawnSync,
-    ChildProcessExecSync,
-    ChildProcessExecFileSync,
-    ChildKill,
-    ChildSend,
-    ChildDisconnect,
-    UtilPromisify,
-    UtilCallbackify,
-    UtilFormat,
-    UtilInspect,
-    UtilDeprecate,
-    DnsLookup,
-    DnsResolve,
-    DnsResolve4,
-    DnsResolve6,
-    DnsResolveMx,
-    DnsResolveTxt,
-    DnsResolveNs,
-    DnsResolveCname,
-    DnsReverse,
-    SetTimeout,
-    ClearTimeout,
-    SetInterval,
-    ClearInterval,
-    SetImmediate,
-    ClearImmediate,
-    ConsoleLog,
-    ConsoleError,
-    ConsoleWarn,
-    ConsoleInfo,
-    ConsoleDebug,
-    ConsoleTable,
-    ConsoleTime,
-    ConsoleTimeEnd,
-    ConsoleTimeLog,
-    ConsoleTrace,
-    ConsoleClear,
-    ConsoleCount,
-    ConsoleCountReset,
-    ConsoleGroup,
-    ConsoleGroupEnd,
-    ConsoleGroupCollapsed,
-    ConsoleAssert,
-    ConsoleDir,
-    GlobalVariable,
-    Dirname,
-    Filename,
-    PromiseExpression,
-    PromiseResolve,
-    PromiseReject,
-    PromiseAll,
-    PromiseAllSettled,
-    PromiseRace,
-    PromiseAny,
-    PromiseThen,
-    PromiseCatch,
-    PromiseFinally
-}