Source code
Revision control
Copy as Markdown
Other Tools
# -*- coding: utf-8 -*-
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
from __future__ import absolute_import, unicode_literals
from .objects import Object
from .syntax import Syntax
from .scanner import RegExp
class Node(Object):
def __dir__(self):
return list(self.__dict__.keys())
def __iter__(self):
return self.__iter__
def keys(self):
return self.__dict__.keys()
def items(self):
return self.__dict__.items()
class ArrayExpression(Node):
def __init__(self, elements):
self.type = Syntax.ArrayExpression
self.elements = elements
class ArrayPattern(Node):
def __init__(self, elements):
self.type = Syntax.ArrayPattern
self.elements = elements
class ArrowFunctionExpression(Node):
def __init__(self, params, body, expression):
self.type = Syntax.ArrowFunctionExpression
self.generator = False
self.isAsync = False
self.params = params
self.body = body
self.expression = expression
class AssignmentExpression(Node):
def __init__(self, operator, left, right):
self.type = Syntax.AssignmentExpression
self.operator = operator
self.left = left
self.right = right
class AssignmentPattern(Node):
def __init__(self, left, right):
self.type = Syntax.AssignmentPattern
self.left = left
self.right = right
class AsyncArrowFunctionExpression(Node):
def __init__(self, params, body, expression):
self.type = Syntax.ArrowFunctionExpression
self.generator = False
self.isAsync = True
self.params = params
self.body = body
self.expression = expression
class AsyncFunctionDeclaration(Node):
def __init__(self, id, params, body):
self.type = Syntax.FunctionDeclaration
self.generator = False
self.expression = False
self.isAsync = True
self.id = id
self.params = params
self.body = body
class AsyncFunctionExpression(Node):
def __init__(self, id, params, body):
self.type = Syntax.FunctionExpression
self.generator = False
self.expression = False
self.isAsync = True
self.id = id
self.params = params
self.body = body
class AwaitExpression(Node):
def __init__(self, argument):
self.type = Syntax.AwaitExpression
self.argument = argument
class BinaryExpression(Node):
def __init__(self, operator, left, right):
self.type = Syntax.LogicalExpression if operator in ('||', '&&') else Syntax.BinaryExpression
self.operator = operator
self.left = left
self.right = right
class BlockStatement(Node):
def __init__(self, body):
self.type = Syntax.BlockStatement
self.body = body
class BreakStatement(Node):
def __init__(self, label):
self.type = Syntax.BreakStatement
self.label = label
class CallExpression(Node):
def __init__(self, callee, args):
self.type = Syntax.CallExpression
self.callee = callee
self.arguments = args
class CatchClause(Node):
def __init__(self, param, body):
self.type = Syntax.CatchClause
self.param = param
self.body = body
class ClassBody(Node):
def __init__(self, body):
self.type = Syntax.ClassBody
self.body = body
class ClassDeclaration(Node):
def __init__(self, id, superClass, body):
self.type = Syntax.ClassDeclaration
self.id = id
self.superClass = superClass
self.body = body
class ClassExpression(Node):
def __init__(self, id, superClass, body):
self.type = Syntax.ClassExpression
self.id = id
self.superClass = superClass
self.body = body
class ComputedMemberExpression(Node):
def __init__(self, object, property):
self.type = Syntax.MemberExpression
self.computed = True
self.object = object
self.property = property
class ConditionalExpression(Node):
def __init__(self, test, consequent, alternate):
self.type = Syntax.ConditionalExpression
self.test = test
self.consequent = consequent
self.alternate = alternate
class ContinueStatement(Node):
def __init__(self, label):
self.type = Syntax.ContinueStatement
self.label = label
class DebuggerStatement(Node):
def __init__(self):
self.type = Syntax.DebuggerStatement
class Directive(Node):
def __init__(self, expression, directive):
self.type = Syntax.ExpressionStatement
self.expression = expression
self.directive = directive
class DoWhileStatement(Node):
def __init__(self, body, test):
self.type = Syntax.DoWhileStatement
self.body = body
self.test = test
class EmptyStatement(Node):
def __init__(self):
self.type = Syntax.EmptyStatement
class ExportAllDeclaration(Node):
def __init__(self, source):
self.type = Syntax.ExportAllDeclaration
self.source = source
class ExportDefaultDeclaration(Node):
def __init__(self, declaration):
self.type = Syntax.ExportDefaultDeclaration
self.declaration = declaration
class ExportNamedDeclaration(Node):
def __init__(self, declaration, specifiers, source):
self.type = Syntax.ExportNamedDeclaration
self.declaration = declaration
self.specifiers = specifiers
self.source = source
class ExportSpecifier(Node):
def __init__(self, local, exported):
self.type = Syntax.ExportSpecifier
self.exported = exported
self.local = local
class ExportDefaultSpecifier(Node):
def __init__(self, local):
self.type = Syntax.ExportDefaultSpecifier
self.local = local
class ExpressionStatement(Node):
def __init__(self, expression):
self.type = Syntax.ExpressionStatement
self.expression = expression
class ForInStatement(Node):
def __init__(self, left, right, body):
self.type = Syntax.ForInStatement
self.each = False
self.left = left
self.right = right
self.body = body
class ForOfStatement(Node):
def __init__(self, left, right, body):
self.type = Syntax.ForOfStatement
self.left = left
self.right = right
self.body = body
class ForStatement(Node):
def __init__(self, init, test, update, body):
self.type = Syntax.ForStatement
self.init = init
self.test = test
self.update = update
self.body = body
class FunctionDeclaration(Node):
def __init__(self, id, params, body, generator):
self.type = Syntax.FunctionDeclaration
self.expression = False
self.isAsync = False
self.id = id
self.params = params
self.body = body
self.generator = generator
class FunctionExpression(Node):
def __init__(self, id, params, body, generator):
self.type = Syntax.FunctionExpression
self.expression = False
self.isAsync = False
self.id = id
self.params = params
self.body = body
self.generator = generator
class Identifier(Node):
def __init__(self, name):
self.type = Syntax.Identifier
self.name = name
class IfStatement(Node):
def __init__(self, test, consequent, alternate):
self.type = Syntax.IfStatement
self.test = test
self.consequent = consequent
self.alternate = alternate
class Import(Node):
def __init__(self):
self.type = Syntax.Import
class ImportDeclaration(Node):
def __init__(self, specifiers, source):
self.type = Syntax.ImportDeclaration
self.specifiers = specifiers
self.source = source
class ImportDefaultSpecifier(Node):
def __init__(self, local):
self.type = Syntax.ImportDefaultSpecifier
self.local = local
class ImportNamespaceSpecifier(Node):
def __init__(self, local):
self.type = Syntax.ImportNamespaceSpecifier
self.local = local
class ImportSpecifier(Node):
def __init__(self, local, imported):
self.type = Syntax.ImportSpecifier
self.local = local
self.imported = imported
class LabeledStatement(Node):
def __init__(self, label, body):
self.type = Syntax.LabeledStatement
self.label = label
self.body = body
class Literal(Node):
def __init__(self, value, raw):
self.type = Syntax.Literal
self.value = value
self.raw = raw
class MetaProperty(Node):
def __init__(self, meta, property):
self.type = Syntax.MetaProperty
self.meta = meta
self.property = property
class MethodDefinition(Node):
def __init__(self, key, computed, value, kind, isStatic):
self.type = Syntax.MethodDefinition
self.key = key
self.computed = computed
self.value = value
self.kind = kind
self.static = isStatic
class FieldDefinition(Node):
def __init__(self, key, computed, value, kind, isStatic):
self.type = Syntax.FieldDefinition
self.key = key
self.computed = computed
self.value = value
self.kind = kind
self.static = isStatic
class Module(Node):
def __init__(self, body):
self.type = Syntax.Program
self.sourceType = 'module'
self.body = body
class NewExpression(Node):
def __init__(self, callee, args):
self.type = Syntax.NewExpression
self.callee = callee
self.arguments = args
class ObjectExpression(Node):
def __init__(self, properties):
self.type = Syntax.ObjectExpression
self.properties = properties
class ObjectPattern(Node):
def __init__(self, properties):
self.type = Syntax.ObjectPattern
self.properties = properties
class Property(Node):
def __init__(self, kind, key, computed, value, method, shorthand):
self.type = Syntax.Property
self.key = key
self.computed = computed
self.value = value
self.kind = kind
self.method = method
self.shorthand = shorthand
class RegexLiteral(Node):
def __init__(self, value, raw, pattern, flags):
self.type = Syntax.Literal
self.value = value
self.raw = raw
self.regex = RegExp(
pattern=pattern,
flags=flags,
)
class RestElement(Node):
def __init__(self, argument):
self.type = Syntax.RestElement
self.argument = argument
class ReturnStatement(Node):
def __init__(self, argument):
self.type = Syntax.ReturnStatement
self.argument = argument
class Script(Node):
def __init__(self, body):
self.type = Syntax.Program
self.sourceType = 'script'
self.body = body
class SequenceExpression(Node):
def __init__(self, expressions):
self.type = Syntax.SequenceExpression
self.expressions = expressions
class SpreadElement(Node):
def __init__(self, argument):
self.type = Syntax.SpreadElement
self.argument = argument
class StaticMemberExpression(Node):
def __init__(self, object, property):
self.type = Syntax.MemberExpression
self.computed = False
self.object = object
self.property = property
class Super(Node):
def __init__(self):
self.type = Syntax.Super
class SwitchCase(Node):
def __init__(self, test, consequent):
self.type = Syntax.SwitchCase
self.test = test
self.consequent = consequent
class SwitchStatement(Node):
def __init__(self, discriminant, cases):
self.type = Syntax.SwitchStatement
self.discriminant = discriminant
self.cases = cases
class TaggedTemplateExpression(Node):
def __init__(self, tag, quasi):
self.type = Syntax.TaggedTemplateExpression
self.tag = tag
self.quasi = quasi
class TemplateElement(Node):
class Value(Object):
def __init__(self, raw, cooked):
self.raw = raw
self.cooked = cooked
def __init__(self, raw, cooked, tail):
self.type = Syntax.TemplateElement
self.value = TemplateElement.Value(raw, cooked)
self.tail = tail
class TemplateLiteral(Node):
def __init__(self, quasis, expressions):
self.type = Syntax.TemplateLiteral
self.quasis = quasis
self.expressions = expressions
class ThisExpression(Node):
def __init__(self):
self.type = Syntax.ThisExpression
class ThrowStatement(Node):
def __init__(self, argument):
self.type = Syntax.ThrowStatement
self.argument = argument
class TryStatement(Node):
def __init__(self, block, handler, finalizer):
self.type = Syntax.TryStatement
self.block = block
self.handler = handler
self.finalizer = finalizer
class UnaryExpression(Node):
def __init__(self, operator, argument):
self.type = Syntax.UnaryExpression
self.prefix = True
self.operator = operator
self.argument = argument
class UpdateExpression(Node):
def __init__(self, operator, argument, prefix):
self.type = Syntax.UpdateExpression
self.operator = operator
self.argument = argument
self.prefix = prefix
class VariableDeclaration(Node):
def __init__(self, declarations, kind):
self.type = Syntax.VariableDeclaration
self.declarations = declarations
self.kind = kind
class VariableDeclarator(Node):
def __init__(self, id, init):
self.type = Syntax.VariableDeclarator
self.id = id
self.init = init
class WhileStatement(Node):
def __init__(self, test, body):
self.type = Syntax.WhileStatement
self.test = test
self.body = body
class WithStatement(Node):
def __init__(self, object, body):
self.type = Syntax.WithStatement
self.object = object
self.body = body
class YieldExpression(Node):
def __init__(self, argument, delegate):
self.type = Syntax.YieldExpression
self.argument = argument
self.delegate = delegate
class ArrowParameterPlaceHolder(Node):
def __init__(self, params):
self.type = Syntax.ArrowParameterPlaceHolder
self.params = params
self.isAsync = False
class AsyncArrowParameterPlaceHolder(Node):
def __init__(self, params):
self.type = Syntax.ArrowParameterPlaceHolder
self.params = params
self.isAsync = True
class BlockComment(Node):
def __init__(self, value):
self.type = Syntax.BlockComment
self.value = value
class LineComment(Node):
def __init__(self, value):
self.type = Syntax.LineComment
self.value = value