ether-code 0.1.6 → 0.1.8

package/parsers/ast-js.js

@@ -1,750 +0,0 @@
-class ASTNode {
-    constructor(type, loc = null) {
-        this.type = type
-        this.loc = loc
-    }
-}
-
-class Program extends ASTNode {
-    constructor(body = [], sourceType = 'script', loc = null) {
-        super('Program', loc)
-        this.body = body
-        this.sourceType = sourceType
-    }
-}
-
-class Identifier extends ASTNode {
-    constructor(name, loc = null) {
-        super('Identifier', loc)
-        this.name = name
-    }
-}
-
-class Literal extends ASTNode {
-    constructor(value, raw = null, loc = null) {
-        super('Literal', loc)
-        this.value = value
-        this.raw = raw || String(value)
-    }
-}
-
-class StringLiteral extends ASTNode {
-    constructor(value, raw = null, loc = null) {
-        super('StringLiteral', loc)
-        this.value = value
-        this.raw = raw
-    }
-}
-
-class NumericLiteral extends ASTNode {
-    constructor(value, raw = null, loc = null) {
-        super('NumericLiteral', loc)
-        this.value = value
-        this.raw = raw
-    }
-}
-
-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 BigIntLiteral extends ASTNode {
-    constructor(value, raw = null, loc = null) {
-        super('BigIntLiteral', loc)
-        this.value = value
-        this.raw = raw
-    }
-}
-
-class RegExpLiteral extends ASTNode {
-    constructor(pattern, flags = '', loc = null) {
-        super('RegExpLiteral', loc)
-        this.pattern = pattern
-        this.flags = flags
-    }
-}
-
-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 TaggedTemplateExpression extends ASTNode {
-    constructor(tag, quasi, loc = null) {
-        super('TaggedTemplateExpression', loc)
-        this.tag = tag
-        this.quasi = quasi
-    }
-}
-
-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 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, isStatic = false, loc = null) {
-        super('MethodDefinition', loc)
-        this.key = key
-        this.value = value
-        this.kind = kind
-        this.computed = computed
-        this.static = isStatic
-    }
-}
-
-class PropertyDefinition extends ASTNode {
-    constructor(key, value = null, computed = false, isStatic = false, loc = null) {
-        super('PropertyDefinition', loc)
-        this.key = key
-        this.value = value
-        this.computed = computed
-        this.static = isStatic
-    }
-}
-
-class PrivateIdentifier extends ASTNode {
-    constructor(name, loc = null) {
-        super('PrivateIdentifier', loc)
-        this.name = name
-    }
-}
-
-class StaticBlock extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('StaticBlock', loc)
-        this.body = body
-    }
-}
-
-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 ReturnStatement extends ASTNode {
-    constructor(argument = null, loc = null) {
-        super('ReturnStatement', loc)
-        this.argument = argument
-    }
-}
-
-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 LabeledStatement extends ASTNode {
-    constructor(label, body, loc = null) {
-        super('LabeledStatement', loc)
-        this.label = label
-        this.body = body
-    }
-}
-
-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 = null, consequent = [], loc = null) {
-        super('SwitchCase', loc)
-        this.test = test
-        this.consequent = consequent
-    }
-}
-
-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 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 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 = null, 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 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 BinaryExpression extends ASTNode {
-    constructor(operator, left, right, loc = null) {
-        super('BinaryExpression', 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 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 AssignmentExpression extends ASTNode {
-    constructor(operator, left, right, loc = null) {
-        super('AssignmentExpression', 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 ChainExpression extends ASTNode {
-    constructor(expression, loc = null) {
-        super('ChainExpression', loc)
-        this.expression = expression
-    }
-}
-
-class SequenceExpression extends ASTNode {
-    constructor(expressions = [], loc = null) {
-        super('SequenceExpression', loc)
-        this.expressions = expressions
-    }
-}
-
-class ThisExpression extends ASTNode {
-    constructor(loc = null) {
-        super('ThisExpression', loc)
-    }
-}
-
-class Super extends ASTNode {
-    constructor(loc = null) {
-        super('Super', loc)
-    }
-}
-
-class SpreadElement extends ASTNode {
-    constructor(argument, loc = null) {
-        super('SpreadElement', loc)
-        this.argument = argument
-    }
-}
-
-class RestElement extends ASTNode {
-    constructor(argument, loc = null) {
-        super('RestElement', 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 AwaitExpression extends ASTNode {
-    constructor(argument, loc = null) {
-        super('AwaitExpression', loc)
-        this.argument = argument
-    }
-}
-
-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', method = false, shorthand = false, computed = false, loc = null) {
-        super('Property', loc)
-        this.key = key
-        this.value = value
-        this.kind = kind
-        this.method = method
-        this.shorthand = shorthand
-        this.computed = computed
-    }
-}
-
-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 AssignmentPattern extends ASTNode {
-    constructor(left, right, loc = null) {
-        super('AssignmentPattern', loc)
-        this.left = left
-        this.right = right
-    }
-}
-
-class ImportDeclaration extends ASTNode {
-    constructor(specifiers = [], source, loc = null) {
-        super('ImportDeclaration', loc)
-        this.specifiers = specifiers
-        this.source = source
-    }
-}
-
-class ImportSpecifier extends ASTNode {
-    constructor(imported, local, loc = null) {
-        super('ImportSpecifier', loc)
-        this.imported = imported
-        this.local = local
-    }
-}
-
-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 = 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 ExportAllDeclaration extends ASTNode {
-    constructor(source, exported = null, loc = null) {
-        super('ExportAllDeclaration', loc)
-        this.source = source
-        this.exported = exported
-    }
-}
-
-class ExportSpecifier extends ASTNode {
-    constructor(local, exported, loc = null) {
-        super('ExportSpecifier', loc)
-        this.local = local
-        this.exported = exported
-    }
-}
-
-class ImportExpression extends ASTNode {
-    constructor(source, loc = null) {
-        super('ImportExpression', loc)
-        this.source = source
-    }
-}
-
-class MetaProperty extends ASTNode {
-    constructor(meta, property, loc = null) {
-        super('MetaProperty', loc)
-        this.meta = meta
-        this.property = property
-    }
-}
-
-class Comment extends ASTNode {
-    constructor(value, isBlock = false, loc = null) {
-        super('Comment', loc)
-        this.value = value
-        this.isBlock = isBlock
-    }
-}
-
-class Decorator extends ASTNode {
-    constructor(expression, loc = null) {
-        super('Decorator', loc)
-        this.expression = expression
-    }
-}
-
-class UsingDeclaration extends ASTNode {
-    constructor(declarations = [], await_ = false, loc = null) {
-        super('UsingDeclaration', loc)
-        this.declarations = declarations
-        this.await = await_
-    }
-}
-
-class EtherNaturalExpression extends ASTNode {
-    constructor(naturalText, jsEquivalent, loc = null) {
-        super('EtherNaturalExpression', loc)
-        this.naturalText = naturalText
-        this.jsEquivalent = jsEquivalent
-    }
-}
-
-class EtherPipeExpression extends ASTNode {
-    constructor(value, functions = [], loc = null) {
-        super('EtherPipeExpression', loc)
-        this.value = value
-        this.functions = functions
-    }
-}
-
-module.exports = {
-    ASTNode,
-    Program,
-    Identifier,
-    Literal,
-    StringLiteral,
-    NumericLiteral,
-    BooleanLiteral,
-    NullLiteral,
-    BigIntLiteral,
-    RegExpLiteral,
-    TemplateLiteral,
-    TemplateElement,
-    TaggedTemplateExpression,
-    VariableDeclaration,
-    VariableDeclarator,
-    FunctionDeclaration,
-    FunctionExpression,
-    ArrowFunctionExpression,
-    ClassDeclaration,
-    ClassExpression,
-    ClassBody,
-    MethodDefinition,
-    PropertyDefinition,
-    PrivateIdentifier,
-    StaticBlock,
-    BlockStatement,
-    ExpressionStatement,
-    EmptyStatement,
-    ReturnStatement,
-    BreakStatement,
-    ContinueStatement,
-    LabeledStatement,
-    IfStatement,
-    SwitchStatement,
-    SwitchCase,
-    WhileStatement,
-    DoWhileStatement,
-    ForStatement,
-    ForInStatement,
-    ForOfStatement,
-    TryStatement,
-    CatchClause,
-    ThrowStatement,
-    WithStatement,
-    DebuggerStatement,
-    BinaryExpression,
-    LogicalExpression,
-    UnaryExpression,
-    UpdateExpression,
-    AssignmentExpression,
-    ConditionalExpression,
-    CallExpression,
-    NewExpression,
-    MemberExpression,
-    ChainExpression,
-    SequenceExpression,
-    ThisExpression,
-    Super,
-    SpreadElement,
-    RestElement,
-    YieldExpression,
-    AwaitExpression,
-    ArrayExpression,
-    ObjectExpression,
-    Property,
-    ArrayPattern,
-    ObjectPattern,
-    AssignmentPattern,
-    ImportDeclaration,
-    ImportSpecifier,
-    ImportDefaultSpecifier,
-    ImportNamespaceSpecifier,
-    ExportNamedDeclaration,
-    ExportDefaultDeclaration,
-    ExportAllDeclaration,
-    ExportSpecifier,
-    ImportExpression,
-    MetaProperty,
-    Comment,
-    Decorator,
-    UsingDeclaration,
-    EtherNaturalExpression,
-    EtherPipeExpression
-}