Module refinery.lib.scripts.js.model

Expand source code Browse git 
from __future__ import annotations

from dataclasses import dataclass, field
from typing import Generator

from refinery.lib.scripts import Expression, Node, Statement


@dataclass(repr=False)
class JsErrorNode(Node):
    text: str = ''
    message: str = ''

    def children(self) -> Generator[Node, None, None]:
        yield from ()


@dataclass(repr=False)
class JsIdentifier(Expression):
    name: str = ''

    def children(self) -> Generator[Node, None, None]:
        yield from ()


@dataclass(repr=False)
class JsNumericLiteral(Expression):
    value: int | float = 0
    raw: str = '0'

    def children(self) -> Generator[Node, None, None]:
        yield from ()


@dataclass(repr=False)
class JsBigIntLiteral(Expression):
    value: int = 0
    raw: str = '0n'

    def children(self) -> Generator[Node, None, None]:
        yield from ()


@dataclass(repr=False)
class JsStringLiteral(Expression):
    value: str = ''
    raw: str = "''"

    def children(self) -> Generator[Node, None, None]:
        yield from ()


@dataclass(repr=False)
class JsRegExpLiteral(Expression):
    pattern: str = ''
    flags: str = ''
    raw: str = '//'

    def children(self) -> Generator[Node, None, None]:
        yield from ()


@dataclass(repr=False)
class JsTemplateLiteral(Expression):
    quasis: list[JsTemplateElement] = field(default_factory=list)
    expressions: list[Expression] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*self.quasis, *self.expressions)

    def children(self) -> Generator[Node, None, None]:
        qi = iter(self.quasis)
        ei = iter(self.expressions)
        for q in qi:
            yield q
            e = next(ei, None)
            if e is not None:
                yield e


@dataclass(repr=False)
class JsTemplateElement(Node):
    value: str = ''
    raw: str = ''
    tail: bool = False

    def children(self) -> Generator[Node, None, None]:
        yield from ()


@dataclass(repr=False)
class JsBooleanLiteral(Expression):
    value: bool = False

    def children(self) -> Generator[Node, None, None]:
        yield from ()


@dataclass(repr=False)
class JsNullLiteral(Expression):
    def children(self) -> Generator[Node, None, None]:
        yield from ()


@dataclass(repr=False)
class JsThisExpression(Expression):
    def children(self) -> Generator[Node, None, None]:
        yield from ()


@dataclass(repr=False)
class JsArrayExpression(Expression):
    elements: list[Expression | None] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*[e for e in self.elements if e is not None])

    def children(self) -> Generator[Node, None, None]:
        for e in self.elements:
            if e is not None:
                yield e


@dataclass(repr=False)
class JsObjectExpression(Expression):
    properties: list[JsProperty | JsSpreadElement] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*self.properties)

    def children(self) -> Generator[Node, None, None]:
        yield from self.properties


@dataclass(repr=False)
class JsProperty(Node):
    key: Expression | None = None
    value: Expression | None = None
    computed: bool = False
    shorthand: bool = False
    method: bool = False
    kind: str = 'init'

    def __post_init__(self):
        self._adopt(self.key, self.value)

    def children(self) -> Generator[Node, None, None]:
        if self.key is not None:
            yield self.key
        if self.value is not None:
            yield self.value


@dataclass(repr=False)
class JsSpreadElement(Expression):
    argument: Expression | None = None

    def __post_init__(self):
        self._adopt(self.argument)

    def children(self) -> Generator[Node, None, None]:
        if self.argument is not None:
            yield self.argument


@dataclass(repr=False)
class JsFunctionExpression(Expression):
    id: JsIdentifier | None = None
    params: list[Expression] = field(default_factory=list)
    body: JsBlockStatement | None = None
    generator: bool = False
    is_async: bool = False

    def __post_init__(self):
        self._adopt(self.id, *self.params, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.id is not None:
            yield self.id
        yield from self.params
        if self.body is not None:
            yield self.body


@dataclass(repr=False)
class JsArrowFunctionExpression(Expression):
    params: list[Expression] = field(default_factory=list)
    body: Expression | JsBlockStatement | None = None
    is_async: bool = False

    def __post_init__(self):
        self._adopt(*self.params, self.body)

    def children(self) -> Generator[Node, None, None]:
        yield from self.params
        if self.body is not None:
            yield self.body


@dataclass(repr=False)
class JsClassExpression(Expression):
    id: JsIdentifier | None = None
    super_class: Expression | None = None
    body: JsClassBody | None = None

    def __post_init__(self):
        self._adopt(self.id, self.super_class, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.id is not None:
            yield self.id
        if self.super_class is not None:
            yield self.super_class
        if self.body is not None:
            yield self.body


@dataclass(repr=False)
class JsUnaryExpression(Expression):
    operator: str = ''
    operand: Expression | None = None
    prefix: bool = True

    def __post_init__(self):
        self._adopt(self.operand)

    def children(self) -> Generator[Node, None, None]:
        if self.operand is not None:
            yield self.operand


@dataclass(repr=False)
class JsUpdateExpression(Expression):
    operator: str = ''
    argument: Expression | None = None
    prefix: bool = True

    def __post_init__(self):
        self._adopt(self.argument)

    def children(self) -> Generator[Node, None, None]:
        if self.argument is not None:
            yield self.argument


@dataclass(repr=False)
class JsBinaryExpression(Expression):
    left: Expression | None = None
    operator: str = ''
    right: Expression | None = None

    def __post_init__(self):
        self._adopt(self.left, self.right)

    def children(self) -> Generator[Node, None, None]:
        if self.left is not None:
            yield self.left
        if self.right is not None:
            yield self.right


@dataclass(repr=False)
class JsLogicalExpression(Expression):
    left: Expression | None = None
    operator: str = ''
    right: Expression | None = None

    def __post_init__(self):
        self._adopt(self.left, self.right)

    def children(self) -> Generator[Node, None, None]:
        if self.left is not None:
            yield self.left
        if self.right is not None:
            yield self.right


@dataclass(repr=False)
class JsAssignmentExpression(Expression):
    left: Expression | None = None
    operator: str = '='
    right: Expression | None = None

    def __post_init__(self):
        self._adopt(self.left, self.right)

    def children(self) -> Generator[Node, None, None]:
        if self.left is not None:
            yield self.left
        if self.right is not None:
            yield self.right


@dataclass(repr=False)
class JsConditionalExpression(Expression):
    test: Expression | None = None
    consequent: Expression | None = None
    alternate: Expression | None = None

    def __post_init__(self):
        self._adopt(self.test, self.consequent, self.alternate)

    def children(self) -> Generator[Node, None, None]:
        if self.test is not None:
            yield self.test
        if self.consequent is not None:
            yield self.consequent
        if self.alternate is not None:
            yield self.alternate


@dataclass(repr=False)
class JsMemberExpression(Expression):
    object: Expression | None = None
    property: Expression | None = None
    computed: bool = False
    optional: bool = False

    def __post_init__(self):
        self._adopt(self.object, self.property)

    def children(self) -> Generator[Node, None, None]:
        if self.object is not None:
            yield self.object
        if self.property is not None:
            yield self.property


@dataclass(repr=False)
class JsCallExpression(Expression):
    callee: Expression | None = None
    arguments: list[Expression] = field(default_factory=list)
    optional: bool = False

    def __post_init__(self):
        self._adopt(self.callee, *self.arguments)

    def children(self) -> Generator[Node, None, None]:
        if self.callee is not None:
            yield self.callee
        yield from self.arguments


@dataclass(repr=False)
class JsNewExpression(Expression):
    callee: Expression | None = None
    arguments: list[Expression] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(self.callee, *self.arguments)

    def children(self) -> Generator[Node, None, None]:
        if self.callee is not None:
            yield self.callee
        yield from self.arguments


@dataclass(repr=False)
class JsSequenceExpression(Expression):
    expressions: list[Expression] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*self.expressions)

    def children(self) -> Generator[Node, None, None]:
        yield from self.expressions


@dataclass(repr=False)
class JsYieldExpression(Expression):
    argument: Expression | None = None
    delegate: bool = False

    def __post_init__(self):
        self._adopt(self.argument)

    def children(self) -> Generator[Node, None, None]:
        if self.argument is not None:
            yield self.argument


@dataclass(repr=False)
class JsAwaitExpression(Expression):
    argument: Expression | None = None

    def __post_init__(self):
        self._adopt(self.argument)

    def children(self) -> Generator[Node, None, None]:
        if self.argument is not None:
            yield self.argument


@dataclass(repr=False)
class JsTaggedTemplateExpression(Expression):
    tag: Expression | None = None
    quasi: JsTemplateLiteral | None = None

    def __post_init__(self):
        self._adopt(self.tag, self.quasi)

    def children(self) -> Generator[Node, None, None]:
        if self.tag is not None:
            yield self.tag
        if self.quasi is not None:
            yield self.quasi


@dataclass(repr=False)
class JsParenthesizedExpression(Expression):
    expression: Expression | None = None

    def __post_init__(self):
        self._adopt(self.expression)

    def children(self) -> Generator[Node, None, None]:
        if self.expression is not None:
            yield self.expression


@dataclass(repr=False)
class JsArrayPattern(Expression):
    elements: list[Expression | None] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*[e for e in self.elements if e is not None])

    def children(self) -> Generator[Node, None, None]:
        for e in self.elements:
            if e is not None:
                yield e


@dataclass(repr=False)
class JsObjectPattern(Expression):
    properties: list[JsProperty | JsRestElement] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*self.properties)

    def children(self) -> Generator[Node, None, None]:
        yield from self.properties


@dataclass(repr=False)
class JsAssignmentPattern(Expression):
    left: Expression | None = None
    right: Expression | None = None

    def __post_init__(self):
        self._adopt(self.left, self.right)

    def children(self) -> Generator[Node, None, None]:
        if self.left is not None:
            yield self.left
        if self.right is not None:
            yield self.right


@dataclass(repr=False)
class JsRestElement(Expression):
    argument: Expression | None = None

    def __post_init__(self):
        self._adopt(self.argument)

    def children(self) -> Generator[Node, None, None]:
        if self.argument is not None:
            yield self.argument


@dataclass(repr=False)
class JsClassBody(Node):
    body: list[JsMethodDefinition | JsPropertyDefinition] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*self.body)

    def children(self) -> Generator[Node, None, None]:
        yield from self.body


@dataclass(repr=False)
class JsMethodDefinition(Node):
    key: Expression | None = None
    value: JsFunctionExpression | None = None
    kind: str = 'method'
    computed: bool = False
    is_static: bool = False

    def __post_init__(self):
        self._adopt(self.key, self.value)

    def children(self) -> Generator[Node, None, None]:
        if self.key is not None:
            yield self.key
        if self.value is not None:
            yield self.value


@dataclass(repr=False)
class JsPropertyDefinition(Node):
    key: Expression | None = None
    value: Expression | None = None
    computed: bool = False
    is_static: bool = False

    def __post_init__(self):
        self._adopt(self.key, self.value)

    def children(self) -> Generator[Node, None, None]:
        if self.key is not None:
            yield self.key
        if self.value is not None:
            yield self.value


@dataclass(repr=False)
class JsExpressionStatement(Statement):
    expression: Expression | None = None

    def __post_init__(self):
        self._adopt(self.expression)

    def children(self) -> Generator[Node, None, None]:
        if self.expression is not None:
            yield self.expression


@dataclass(repr=False)
class JsBlockStatement(Statement):
    body: list[Statement] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*self.body)

    def children(self) -> Generator[Node, None, None]:
        yield from self.body


@dataclass(repr=False)
class JsEmptyStatement(Statement):
    def children(self) -> Generator[Node, None, None]:
        yield from ()


@dataclass(repr=False)
class JsVariableDeclaration(Statement):
    declarations: list[JsVariableDeclarator] = field(default_factory=list)
    kind: str = 'var'

    def __post_init__(self):
        self._adopt(*self.declarations)

    def children(self) -> Generator[Node, None, None]:
        yield from self.declarations


@dataclass(repr=False)
class JsVariableDeclarator(Node):
    id: Expression | None = None
    init: Expression | None = None

    def __post_init__(self):
        self._adopt(self.id, self.init)

    def children(self) -> Generator[Node, None, None]:
        if self.id is not None:
            yield self.id
        if self.init is not None:
            yield self.init


@dataclass(repr=False)
class JsIfStatement(Statement):
    test: Expression | None = None
    consequent: Statement | None = None
    alternate: Statement | None = None

    def __post_init__(self):
        self._adopt(self.test, self.consequent, self.alternate)

    def children(self) -> Generator[Node, None, None]:
        if self.test is not None:
            yield self.test
        if self.consequent is not None:
            yield self.consequent
        if self.alternate is not None:
            yield self.alternate


@dataclass(repr=False)
class JsWhileStatement(Statement):
    test: Expression | None = None
    body: Statement | None = None

    def __post_init__(self):
        self._adopt(self.test, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.test is not None:
            yield self.test
        if self.body is not None:
            yield self.body


@dataclass(repr=False)
class JsDoWhileStatement(Statement):
    test: Expression | None = None
    body: Statement | None = None

    def __post_init__(self):
        self._adopt(self.test, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.body is not None:
            yield self.body
        if self.test is not None:
            yield self.test


@dataclass(repr=False)
class JsForStatement(Statement):
    init: Expression | Statement | None = None
    test: Expression | None = None
    update: Expression | None = None
    body: Statement | None = None

    def __post_init__(self):
        self._adopt(self.init, self.test, self.update, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.init is not None:
            yield self.init
        if self.test is not None:
            yield self.test
        if self.update is not None:
            yield self.update
        if self.body is not None:
            yield self.body


@dataclass(repr=False)
class JsForInStatement(Statement):
    left: Expression | Statement | None = None
    right: Expression | None = None
    body: Statement | None = None

    def __post_init__(self):
        self._adopt(self.left, self.right, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.left is not None:
            yield self.left
        if self.right is not None:
            yield self.right
        if self.body is not None:
            yield self.body


@dataclass(repr=False)
class JsForOfStatement(Statement):
    left: Expression | Statement | None = None
    right: Expression | None = None
    body: Statement | None = None
    is_await: bool = False

    def __post_init__(self):
        self._adopt(self.left, self.right, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.left is not None:
            yield self.left
        if self.right is not None:
            yield self.right
        if self.body is not None:
            yield self.body


@dataclass(repr=False)
class JsSwitchStatement(Statement):
    discriminant: Expression | None = None
    cases: list[JsSwitchCase] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(self.discriminant, *self.cases)

    def children(self) -> Generator[Node, None, None]:
        if self.discriminant is not None:
            yield self.discriminant
        yield from self.cases


@dataclass(repr=False)
class JsSwitchCase(Node):
    test: Expression | None = None
    consequent: list[Statement] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(self.test, *self.consequent)

    def children(self) -> Generator[Node, None, None]:
        if self.test is not None:
            yield self.test
        yield from self.consequent


@dataclass(repr=False)
class JsTryStatement(Statement):
    block: JsBlockStatement | None = None
    handler: JsCatchClause | None = None
    finalizer: JsBlockStatement | None = None

    def __post_init__(self):
        self._adopt(self.block, self.handler, self.finalizer)

    def children(self) -> Generator[Node, None, None]:
        if self.block is not None:
            yield self.block
        if self.handler is not None:
            yield self.handler
        if self.finalizer is not None:
            yield self.finalizer


@dataclass(repr=False)
class JsCatchClause(Node):
    param: Expression | None = None
    body: JsBlockStatement | None = None

    def __post_init__(self):
        self._adopt(self.param, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.param is not None:
            yield self.param
        if self.body is not None:
            yield self.body


@dataclass(repr=False)
class JsThrowStatement(Statement):
    argument: Expression | None = None

    def __post_init__(self):
        self._adopt(self.argument)

    def children(self) -> Generator[Node, None, None]:
        if self.argument is not None:
            yield self.argument


@dataclass(repr=False)
class JsReturnStatement(Statement):
    argument: Expression | None = None

    def __post_init__(self):
        self._adopt(self.argument)

    def children(self) -> Generator[Node, None, None]:
        if self.argument is not None:
            yield self.argument


@dataclass(repr=False)
class JsBreakStatement(Statement):
    label: JsIdentifier | None = None

    def __post_init__(self):
        self._adopt(self.label)

    def children(self) -> Generator[Node, None, None]:
        if self.label is not None:
            yield self.label


@dataclass(repr=False)
class JsContinueStatement(Statement):
    label: JsIdentifier | None = None

    def __post_init__(self):
        self._adopt(self.label)

    def children(self) -> Generator[Node, None, None]:
        if self.label is not None:
            yield self.label


@dataclass(repr=False)
class JsLabeledStatement(Statement):
    label: JsIdentifier | None = None
    body: Statement | None = None

    def __post_init__(self):
        self._adopt(self.label, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.label is not None:
            yield self.label
        if self.body is not None:
            yield self.body


@dataclass(repr=False)
class JsWithStatement(Statement):
    object: Expression | None = None
    body: Statement | None = None

    def __post_init__(self):
        self._adopt(self.object, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.object is not None:
            yield self.object
        if self.body is not None:
            yield self.body


@dataclass(repr=False)
class JsDebuggerStatement(Statement):
    def children(self) -> Generator[Node, None, None]:
        yield from ()


@dataclass(repr=False)
class JsFunctionDeclaration(Statement):
    id: JsIdentifier | None = None
    params: list[Expression] = field(default_factory=list)
    body: JsBlockStatement | None = None
    generator: bool = False
    is_async: bool = False

    def __post_init__(self):
        self._adopt(self.id, *self.params, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.id is not None:
            yield self.id
        yield from self.params
        if self.body is not None:
            yield self.body


@dataclass(repr=False)
class JsClassDeclaration(Statement):
    id: JsIdentifier | None = None
    super_class: Expression | None = None
    body: JsClassBody | None = None

    def __post_init__(self):
        self._adopt(self.id, self.super_class, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.id is not None:
            yield self.id
        if self.super_class is not None:
            yield self.super_class
        if self.body is not None:
            yield self.body


@dataclass(repr=False)
class JsImportSpecifier(Node):
    imported: JsIdentifier | None = None
    local: JsIdentifier | None = None

    def __post_init__(self):
        self._adopt(self.imported, self.local)

    def children(self) -> Generator[Node, None, None]:
        if self.imported is not None:
            yield self.imported
        if self.local is not None:
            yield self.local


@dataclass(repr=False)
class JsImportDefaultSpecifier(Node):
    local: JsIdentifier | None = None

    def __post_init__(self):
        self._adopt(self.local)

    def children(self) -> Generator[Node, None, None]:
        if self.local is not None:
            yield self.local


@dataclass(repr=False)
class JsImportNamespaceSpecifier(Node):
    local: JsIdentifier | None = None

    def __post_init__(self):
        self._adopt(self.local)

    def children(self) -> Generator[Node, None, None]:
        if self.local is not None:
            yield self.local


@dataclass(repr=False)
class JsImportDeclaration(Statement):
    specifiers: list[
        JsImportSpecifier | JsImportDefaultSpecifier | JsImportNamespaceSpecifier
    ] = field(default_factory=list)
    source: JsStringLiteral | None = None

    def __post_init__(self):
        self._adopt(*self.specifiers, self.source)

    def children(self) -> Generator[Node, None, None]:
        yield from self.specifiers
        if self.source is not None:
            yield self.source


@dataclass(repr=False)
class JsExportSpecifier(Node):
    local: JsIdentifier | None = None
    exported: JsIdentifier | None = None

    def __post_init__(self):
        self._adopt(self.local, self.exported)

    def children(self) -> Generator[Node, None, None]:
        if self.local is not None:
            yield self.local
        if self.exported is not None:
            yield self.exported


@dataclass(repr=False)
class JsExportNamedDeclaration(Statement):
    declaration: Statement | None = None
    specifiers: list[JsExportSpecifier] = field(default_factory=list)
    source: JsStringLiteral | None = None

    def __post_init__(self):
        self._adopt(self.declaration, *self.specifiers, self.source)

    def children(self) -> Generator[Node, None, None]:
        if self.declaration is not None:
            yield self.declaration
        yield from self.specifiers
        if self.source is not None:
            yield self.source


@dataclass(repr=False)
class JsExportDefaultDeclaration(Statement):
    declaration: Expression | Statement | None = None

    def __post_init__(self):
        self._adopt(self.declaration)

    def children(self) -> Generator[Node, None, None]:
        if self.declaration is not None:
            yield self.declaration


@dataclass(repr=False)
class JsExportAllDeclaration(Statement):
    source: JsStringLiteral | None = None
    exported: JsIdentifier | None = None

    def __post_init__(self):
        self._adopt(self.source, self.exported)

    def children(self) -> Generator[Node, None, None]:
        if self.source is not None:
            yield self.source
        if self.exported is not None:
            yield self.exported


@dataclass(repr=False)
class JsScript(Statement):
    body: list[Statement] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*self.body)

    def children(self) -> Generator[Node, None, None]:
        yield from self.body

Classes

class JsErrorNode (offset=-1, parent=None, leading_comments=<factory>, text='', message='')

JsErrorNode(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , text: 'str' = '', message: 'str' = '')

Expand source code Browse git 
@dataclass(repr=False)
class JsErrorNode(Node):
    text: str = ''
    message: str = ''

    def children(self) -> Generator[Node, None, None]:
        yield from ()

Ancestors

Instance variables

var text

The type of the None singleton.

var message

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from ()

Inherited members

class JsIdentifier (offset=-1, parent=None, leading_comments=<factory>, name='')

JsIdentifier(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , name: 'str' = '')

Expand source code Browse git 
@dataclass(repr=False)
class JsIdentifier(Expression):
    name: str = ''

    def children(self) -> Generator[Node, None, None]:
        yield from ()

Ancestors

Instance variables

var name

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from ()

Inherited members

class JsNumericLiteral (offset=-1, parent=None, leading_comments=<factory>, value=0, raw='0')

JsNumericLiteral(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , value: 'int | float' = 0, raw: 'str' = '0')

Expand source code Browse git 
@dataclass(repr=False)
class JsNumericLiteral(Expression):
    value: int | float = 0
    raw: str = '0'

    def children(self) -> Generator[Node, None, None]:
        yield from ()

Ancestors

Instance variables

var value

The type of the None singleton.

var raw

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from ()

Inherited members

class JsBigIntLiteral (offset=-1, parent=None, leading_comments=<factory>, value=0, raw='0n')

JsBigIntLiteral(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , value: 'int' = 0, raw: 'str' = '0n')

Expand source code Browse git 
@dataclass(repr=False)
class JsBigIntLiteral(Expression):
    value: int = 0
    raw: str = '0n'

    def children(self) -> Generator[Node, None, None]:
        yield from ()

Ancestors

Instance variables

var value

The type of the None singleton.

var raw

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from ()

Inherited members

class JsStringLiteral (offset=-1, parent=None, leading_comments=<factory>, value='', raw="''")

JsStringLiteral(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , value: 'str' = '', raw: 'str' = "''")

Expand source code Browse git 
@dataclass(repr=False)
class JsStringLiteral(Expression):
    value: str = ''
    raw: str = "''"

    def children(self) -> Generator[Node, None, None]:
        yield from ()

Ancestors

Instance variables

var value

The type of the None singleton.

var raw

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from ()

Inherited members

class JsRegExpLiteral (offset=-1, parent=None, leading_comments=<factory>, pattern='', flags='', raw='//')

JsRegExpLiteral(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , pattern: 'str' = '', flags: 'str' = '', raw: 'str' = '//')

Expand source code Browse git 
@dataclass(repr=False)
class JsRegExpLiteral(Expression):
    pattern: str = ''
    flags: str = ''
    raw: str = '//'

    def children(self) -> Generator[Node, None, None]:
        yield from ()

Ancestors

Instance variables

var pattern

The type of the None singleton.

var flags

The type of the None singleton.

var raw

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from ()

Inherited members

class JsTemplateLiteral (offset=-1, parent=None, leading_comments=<factory>, quasis=<factory>, expressions=<factory>)

JsTemplateLiteral(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , quasis: 'list[JsTemplateElement]' = , expressions: 'list[Expression]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsTemplateLiteral(Expression):
    quasis: list[JsTemplateElement] = field(default_factory=list)
    expressions: list[Expression] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*self.quasis, *self.expressions)

    def children(self) -> Generator[Node, None, None]:
        qi = iter(self.quasis)
        ei = iter(self.expressions)
        for q in qi:
            yield q
            e = next(ei, None)
            if e is not None:
                yield e

Ancestors

Instance variables

var quasis

The type of the None singleton.

var expressions

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    qi = iter(self.quasis)
    ei = iter(self.expressions)
    for q in qi:
        yield q
        e = next(ei, None)
        if e is not None:
            yield e

Inherited members

class JsTemplateElement (offset=-1, parent=None, leading_comments=<factory>, value='', raw='', tail=False)

JsTemplateElement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , value: 'str' = '', raw: 'str' = '', tail: 'bool' = False)

Expand source code Browse git 
@dataclass(repr=False)
class JsTemplateElement(Node):
    value: str = ''
    raw: str = ''
    tail: bool = False

    def children(self) -> Generator[Node, None, None]:
        yield from ()

Ancestors

Instance variables

var value

The type of the None singleton.

var raw

The type of the None singleton.

var tail

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from ()

Inherited members

class JsBooleanLiteral (offset=-1, parent=None, leading_comments=<factory>, value=False)

JsBooleanLiteral(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , value: 'bool' = False)

Expand source code Browse git 
@dataclass(repr=False)
class JsBooleanLiteral(Expression):
    value: bool = False

    def children(self) -> Generator[Node, None, None]:
        yield from ()

Ancestors

Instance variables

var value

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from ()

Inherited members

class JsNullLiteral (offset=-1, parent=None, leading_comments=<factory>)

JsNullLiteral(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsNullLiteral(Expression):
    def children(self) -> Generator[Node, None, None]:
        yield from ()

Ancestors

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from ()

Inherited members

class JsThisExpression (offset=-1, parent=None, leading_comments=<factory>)

JsThisExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsThisExpression(Expression):
    def children(self) -> Generator[Node, None, None]:
        yield from ()

Ancestors

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from ()

Inherited members

class JsArrayExpression (offset=-1, parent=None, leading_comments=<factory>, elements=<factory>)

JsArrayExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , elements: 'list[Expression | None]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsArrayExpression(Expression):
    elements: list[Expression | None] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*[e for e in self.elements if e is not None])

    def children(self) -> Generator[Node, None, None]:
        for e in self.elements:
            if e is not None:
                yield e

Ancestors

Instance variables

var elements

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    for e in self.elements:
        if e is not None:
            yield e

Inherited members

class JsObjectExpression (offset=-1, parent=None, leading_comments=<factory>, properties=<factory>)

JsObjectExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , properties: 'list[JsProperty | JsSpreadElement]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsObjectExpression(Expression):
    properties: list[JsProperty | JsSpreadElement] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*self.properties)

    def children(self) -> Generator[Node, None, None]:
        yield from self.properties

Ancestors

Instance variables

var properties

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from self.properties

Inherited members

class JsProperty (offset=-1, parent=None, leading_comments=<factory>, key=None, value=None, computed=False, shorthand=False, method=False, kind='init')

JsProperty(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , key: 'Expression | None' = None, value: 'Expression | None' = None, computed: 'bool' = False, shorthand: 'bool' = False, method: 'bool' = False, kind: 'str' = 'init')

Expand source code Browse git 
@dataclass(repr=False)
class JsProperty(Node):
    key: Expression | None = None
    value: Expression | None = None
    computed: bool = False
    shorthand: bool = False
    method: bool = False
    kind: str = 'init'

    def __post_init__(self):
        self._adopt(self.key, self.value)

    def children(self) -> Generator[Node, None, None]:
        if self.key is not None:
            yield self.key
        if self.value is not None:
            yield self.value

Ancestors

Instance variables

var key

The type of the None singleton.

var value

The type of the None singleton.

var computed

The type of the None singleton.

var shorthand

The type of the None singleton.

var method

The type of the None singleton.

var kind

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.key is not None:
        yield self.key
    if self.value is not None:
        yield self.value

Inherited members

class JsSpreadElement (offset=-1, parent=None, leading_comments=<factory>, argument=None)

JsSpreadElement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , argument: 'Expression | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsSpreadElement(Expression):
    argument: Expression | None = None

    def __post_init__(self):
        self._adopt(self.argument)

    def children(self) -> Generator[Node, None, None]:
        if self.argument is not None:
            yield self.argument

Ancestors

Instance variables

var argument

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.argument is not None:
        yield self.argument

Inherited members

class JsFunctionExpression (offset=-1, parent=None, leading_comments=<factory>, id=None, params=<factory>, body=None, generator=False, is_async=False)

JsFunctionExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , id: 'JsIdentifier | None' = None, params: 'list[Expression]' = , body: 'JsBlockStatement | None' = None, generator: 'bool' = False, is_async: 'bool' = False)

Expand source code Browse git 
@dataclass(repr=False)
class JsFunctionExpression(Expression):
    id: JsIdentifier | None = None
    params: list[Expression] = field(default_factory=list)
    body: JsBlockStatement | None = None
    generator: bool = False
    is_async: bool = False

    def __post_init__(self):
        self._adopt(self.id, *self.params, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.id is not None:
            yield self.id
        yield from self.params
        if self.body is not None:
            yield self.body

Ancestors

Instance variables

var params

The type of the None singleton.

var id

The type of the None singleton.

var body

The type of the None singleton.

var generator

The type of the None singleton.

var is_async

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.id is not None:
        yield self.id
    yield from self.params
    if self.body is not None:
        yield self.body

Inherited members

class JsArrowFunctionExpression (offset=-1, parent=None, leading_comments=<factory>, params=<factory>, body=None, is_async=False)

JsArrowFunctionExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , params: 'list[Expression]' = , body: 'Expression | JsBlockStatement | None' = None, is_async: 'bool' = False)

Expand source code Browse git 
@dataclass(repr=False)
class JsArrowFunctionExpression(Expression):
    params: list[Expression] = field(default_factory=list)
    body: Expression | JsBlockStatement | None = None
    is_async: bool = False

    def __post_init__(self):
        self._adopt(*self.params, self.body)

    def children(self) -> Generator[Node, None, None]:
        yield from self.params
        if self.body is not None:
            yield self.body

Ancestors

Instance variables

var params

The type of the None singleton.

var body

The type of the None singleton.

var is_async

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from self.params
    if self.body is not None:
        yield self.body

Inherited members

class JsClassExpression (offset=-1, parent=None, leading_comments=<factory>, id=None, super_class=None, body=None)

JsClassExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , id: 'JsIdentifier | None' = None, super_class: 'Expression | None' = None, body: 'JsClassBody | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsClassExpression(Expression):
    id: JsIdentifier | None = None
    super_class: Expression | None = None
    body: JsClassBody | None = None

    def __post_init__(self):
        self._adopt(self.id, self.super_class, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.id is not None:
            yield self.id
        if self.super_class is not None:
            yield self.super_class
        if self.body is not None:
            yield self.body

Ancestors

Instance variables

var id

The type of the None singleton.

var super_class

The type of the None singleton.

var body

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.id is not None:
        yield self.id
    if self.super_class is not None:
        yield self.super_class
    if self.body is not None:
        yield self.body

Inherited members

class JsUnaryExpression (offset=-1, parent=None, leading_comments=<factory>, operator='', operand=None, prefix=True)

JsUnaryExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , operator: 'str' = '', operand: 'Expression | None' = None, prefix: 'bool' = True)

Expand source code Browse git 
@dataclass(repr=False)
class JsUnaryExpression(Expression):
    operator: str = ''
    operand: Expression | None = None
    prefix: bool = True

    def __post_init__(self):
        self._adopt(self.operand)

    def children(self) -> Generator[Node, None, None]:
        if self.operand is not None:
            yield self.operand

Ancestors

Instance variables

var operator

The type of the None singleton.

var operand

The type of the None singleton.

var prefix

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.operand is not None:
        yield self.operand

Inherited members

class JsUpdateExpression (offset=-1, parent=None, leading_comments=<factory>, operator='', argument=None, prefix=True)

JsUpdateExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , operator: 'str' = '', argument: 'Expression | None' = None, prefix: 'bool' = True)

Expand source code Browse git 
@dataclass(repr=False)
class JsUpdateExpression(Expression):
    operator: str = ''
    argument: Expression | None = None
    prefix: bool = True

    def __post_init__(self):
        self._adopt(self.argument)

    def children(self) -> Generator[Node, None, None]:
        if self.argument is not None:
            yield self.argument

Ancestors

Instance variables

var operator

The type of the None singleton.

var argument

The type of the None singleton.

var prefix

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.argument is not None:
        yield self.argument

Inherited members

class JsBinaryExpression (offset=-1, parent=None, leading_comments=<factory>, left=None, operator='', right=None)

JsBinaryExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , left: 'Expression | None' = None, operator: 'str' = '', right: 'Expression | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsBinaryExpression(Expression):
    left: Expression | None = None
    operator: str = ''
    right: Expression | None = None

    def __post_init__(self):
        self._adopt(self.left, self.right)

    def children(self) -> Generator[Node, None, None]:
        if self.left is not None:
            yield self.left
        if self.right is not None:
            yield self.right

Ancestors

Instance variables

var left

The type of the None singleton.

var operator

The type of the None singleton.

var right

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.left is not None:
        yield self.left
    if self.right is not None:
        yield self.right

Inherited members

class JsLogicalExpression (offset=-1, parent=None, leading_comments=<factory>, left=None, operator='', right=None)

JsLogicalExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , left: 'Expression | None' = None, operator: 'str' = '', right: 'Expression | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsLogicalExpression(Expression):
    left: Expression | None = None
    operator: str = ''
    right: Expression | None = None

    def __post_init__(self):
        self._adopt(self.left, self.right)

    def children(self) -> Generator[Node, None, None]:
        if self.left is not None:
            yield self.left
        if self.right is not None:
            yield self.right

Ancestors

Instance variables

var left

The type of the None singleton.

var operator

The type of the None singleton.

var right

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.left is not None:
        yield self.left
    if self.right is not None:
        yield self.right

Inherited members

class JsAssignmentExpression (offset=-1, parent=None, leading_comments=<factory>, left=None, operator='=', right=None)

JsAssignmentExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , left: 'Expression | None' = None, operator: 'str' = '=', right: 'Expression | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsAssignmentExpression(Expression):
    left: Expression | None = None
    operator: str = '='
    right: Expression | None = None

    def __post_init__(self):
        self._adopt(self.left, self.right)

    def children(self) -> Generator[Node, None, None]:
        if self.left is not None:
            yield self.left
        if self.right is not None:
            yield self.right

Ancestors

Instance variables

var left

The type of the None singleton.

var operator

The type of the None singleton.

var right

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.left is not None:
        yield self.left
    if self.right is not None:
        yield self.right

Inherited members

class JsConditionalExpression (offset=-1, parent=None, leading_comments=<factory>, test=None, consequent=None, alternate=None)

JsConditionalExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , test: 'Expression | None' = None, consequent: 'Expression | None' = None, alternate: 'Expression | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsConditionalExpression(Expression):
    test: Expression | None = None
    consequent: Expression | None = None
    alternate: Expression | None = None

    def __post_init__(self):
        self._adopt(self.test, self.consequent, self.alternate)

    def children(self) -> Generator[Node, None, None]:
        if self.test is not None:
            yield self.test
        if self.consequent is not None:
            yield self.consequent
        if self.alternate is not None:
            yield self.alternate

Ancestors

Instance variables

var test

The type of the None singleton.

var consequent

The type of the None singleton.

var alternate

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.test is not None:
        yield self.test
    if self.consequent is not None:
        yield self.consequent
    if self.alternate is not None:
        yield self.alternate

Inherited members

class JsMemberExpression (offset=-1, parent=None, leading_comments=<factory>, object=None, property=None, computed=False, optional=False)

JsMemberExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , object: 'Expression | None' = None, property: 'Expression | None' = None, computed: 'bool' = False, optional: 'bool' = False)

Expand source code Browse git 
@dataclass(repr=False)
class JsMemberExpression(Expression):
    object: Expression | None = None
    property: Expression | None = None
    computed: bool = False
    optional: bool = False

    def __post_init__(self):
        self._adopt(self.object, self.property)

    def children(self) -> Generator[Node, None, None]:
        if self.object is not None:
            yield self.object
        if self.property is not None:
            yield self.property

Ancestors

Instance variables

var object

The type of the None singleton.

var property

The type of the None singleton.

var computed

The type of the None singleton.

var optional

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.object is not None:
        yield self.object
    if self.property is not None:
        yield self.property

Inherited members

class JsCallExpression (offset=-1, parent=None, leading_comments=<factory>, callee=None, arguments=<factory>, optional=False)

JsCallExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , callee: 'Expression | None' = None, arguments: 'list[Expression]' = , optional: 'bool' = False)

Expand source code Browse git 
@dataclass(repr=False)
class JsCallExpression(Expression):
    callee: Expression | None = None
    arguments: list[Expression] = field(default_factory=list)
    optional: bool = False

    def __post_init__(self):
        self._adopt(self.callee, *self.arguments)

    def children(self) -> Generator[Node, None, None]:
        if self.callee is not None:
            yield self.callee
        yield from self.arguments

Ancestors

Instance variables

var arguments

The type of the None singleton.

var callee

The type of the None singleton.

var optional

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.callee is not None:
        yield self.callee
    yield from self.arguments

Inherited members

class JsNewExpression (offset=-1, parent=None, leading_comments=<factory>, callee=None, arguments=<factory>)

JsNewExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , callee: 'Expression | None' = None, arguments: 'list[Expression]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsNewExpression(Expression):
    callee: Expression | None = None
    arguments: list[Expression] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(self.callee, *self.arguments)

    def children(self) -> Generator[Node, None, None]:
        if self.callee is not None:
            yield self.callee
        yield from self.arguments

Ancestors

Instance variables

var arguments

The type of the None singleton.

var callee

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.callee is not None:
        yield self.callee
    yield from self.arguments

Inherited members

class JsSequenceExpression (offset=-1, parent=None, leading_comments=<factory>, expressions=<factory>)

JsSequenceExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , expressions: 'list[Expression]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsSequenceExpression(Expression):
    expressions: list[Expression] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*self.expressions)

    def children(self) -> Generator[Node, None, None]:
        yield from self.expressions

Ancestors

Instance variables

var expressions

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from self.expressions

Inherited members

class JsYieldExpression (offset=-1, parent=None, leading_comments=<factory>, argument=None, delegate=False)

JsYieldExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , argument: 'Expression | None' = None, delegate: 'bool' = False)

Expand source code Browse git 
@dataclass(repr=False)
class JsYieldExpression(Expression):
    argument: Expression | None = None
    delegate: bool = False

    def __post_init__(self):
        self._adopt(self.argument)

    def children(self) -> Generator[Node, None, None]:
        if self.argument is not None:
            yield self.argument

Ancestors

Instance variables

var argument

The type of the None singleton.

var delegate

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.argument is not None:
        yield self.argument

Inherited members

class JsAwaitExpression (offset=-1, parent=None, leading_comments=<factory>, argument=None)

JsAwaitExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , argument: 'Expression | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsAwaitExpression(Expression):
    argument: Expression | None = None

    def __post_init__(self):
        self._adopt(self.argument)

    def children(self) -> Generator[Node, None, None]:
        if self.argument is not None:
            yield self.argument

Ancestors

Instance variables

var argument

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.argument is not None:
        yield self.argument

Inherited members

class JsTaggedTemplateExpression (offset=-1, parent=None, leading_comments=<factory>, tag=None, quasi=None)

JsTaggedTemplateExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , tag: 'Expression | None' = None, quasi: 'JsTemplateLiteral | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsTaggedTemplateExpression(Expression):
    tag: Expression | None = None
    quasi: JsTemplateLiteral | None = None

    def __post_init__(self):
        self._adopt(self.tag, self.quasi)

    def children(self) -> Generator[Node, None, None]:
        if self.tag is not None:
            yield self.tag
        if self.quasi is not None:
            yield self.quasi

Ancestors

Instance variables

var tag

The type of the None singleton.

var quasi

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.tag is not None:
        yield self.tag
    if self.quasi is not None:
        yield self.quasi

Inherited members

class JsParenthesizedExpression (offset=-1, parent=None, leading_comments=<factory>, expression=None)

JsParenthesizedExpression(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , expression: 'Expression | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsParenthesizedExpression(Expression):
    expression: Expression | None = None

    def __post_init__(self):
        self._adopt(self.expression)

    def children(self) -> Generator[Node, None, None]:
        if self.expression is not None:
            yield self.expression

Ancestors

Instance variables

var expression

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.expression is not None:
        yield self.expression

Inherited members

class JsArrayPattern (offset=-1, parent=None, leading_comments=<factory>, elements=<factory>)

JsArrayPattern(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , elements: 'list[Expression | None]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsArrayPattern(Expression):
    elements: list[Expression | None] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*[e for e in self.elements if e is not None])

    def children(self) -> Generator[Node, None, None]:
        for e in self.elements:
            if e is not None:
                yield e

Ancestors

Instance variables

var elements

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    for e in self.elements:
        if e is not None:
            yield e

Inherited members

class JsObjectPattern (offset=-1, parent=None, leading_comments=<factory>, properties=<factory>)

JsObjectPattern(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , properties: 'list[JsProperty | JsRestElement]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsObjectPattern(Expression):
    properties: list[JsProperty | JsRestElement] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*self.properties)

    def children(self) -> Generator[Node, None, None]:
        yield from self.properties

Ancestors

Instance variables

var properties

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from self.properties

Inherited members

class JsAssignmentPattern (offset=-1, parent=None, leading_comments=<factory>, left=None, right=None)

JsAssignmentPattern(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , left: 'Expression | None' = None, right: 'Expression | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsAssignmentPattern(Expression):
    left: Expression | None = None
    right: Expression | None = None

    def __post_init__(self):
        self._adopt(self.left, self.right)

    def children(self) -> Generator[Node, None, None]:
        if self.left is not None:
            yield self.left
        if self.right is not None:
            yield self.right

Ancestors

Instance variables

var left

The type of the None singleton.

var right

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.left is not None:
        yield self.left
    if self.right is not None:
        yield self.right

Inherited members

class JsRestElement (offset=-1, parent=None, leading_comments=<factory>, argument=None)

JsRestElement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , argument: 'Expression | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsRestElement(Expression):
    argument: Expression | None = None

    def __post_init__(self):
        self._adopt(self.argument)

    def children(self) -> Generator[Node, None, None]:
        if self.argument is not None:
            yield self.argument

Ancestors

Instance variables

var argument

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.argument is not None:
        yield self.argument

Inherited members

class JsClassBody (offset=-1, parent=None, leading_comments=<factory>, body=<factory>)

JsClassBody(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , body: 'list[JsMethodDefinition | JsPropertyDefinition]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsClassBody(Node):
    body: list[JsMethodDefinition | JsPropertyDefinition] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*self.body)

    def children(self) -> Generator[Node, None, None]:
        yield from self.body

Ancestors

Instance variables

var body

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from self.body

Inherited members

class JsMethodDefinition (offset=-1, parent=None, leading_comments=<factory>, key=None, value=None, kind='method', computed=False, is_static=False)

JsMethodDefinition(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , key: 'Expression | None' = None, value: 'JsFunctionExpression | None' = None, kind: 'str' = 'method', computed: 'bool' = False, is_static: 'bool' = False)

Expand source code Browse git 
@dataclass(repr=False)
class JsMethodDefinition(Node):
    key: Expression | None = None
    value: JsFunctionExpression | None = None
    kind: str = 'method'
    computed: bool = False
    is_static: bool = False

    def __post_init__(self):
        self._adopt(self.key, self.value)

    def children(self) -> Generator[Node, None, None]:
        if self.key is not None:
            yield self.key
        if self.value is not None:
            yield self.value

Ancestors

Instance variables

var key

The type of the None singleton.

var value

The type of the None singleton.

var kind

The type of the None singleton.

var computed

The type of the None singleton.

var is_static

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.key is not None:
        yield self.key
    if self.value is not None:
        yield self.value

Inherited members

class JsPropertyDefinition (offset=-1, parent=None, leading_comments=<factory>, key=None, value=None, computed=False, is_static=False)

JsPropertyDefinition(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , key: 'Expression | None' = None, value: 'Expression | None' = None, computed: 'bool' = False, is_static: 'bool' = False)

Expand source code Browse git 
@dataclass(repr=False)
class JsPropertyDefinition(Node):
    key: Expression | None = None
    value: Expression | None = None
    computed: bool = False
    is_static: bool = False

    def __post_init__(self):
        self._adopt(self.key, self.value)

    def children(self) -> Generator[Node, None, None]:
        if self.key is not None:
            yield self.key
        if self.value is not None:
            yield self.value

Ancestors

Instance variables

var key

The type of the None singleton.

var value

The type of the None singleton.

var computed

The type of the None singleton.

var is_static

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.key is not None:
        yield self.key
    if self.value is not None:
        yield self.value

Inherited members

class JsExpressionStatement (offset=-1, parent=None, leading_comments=<factory>, expression=None)

JsExpressionStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , expression: 'Expression | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsExpressionStatement(Statement):
    expression: Expression | None = None

    def __post_init__(self):
        self._adopt(self.expression)

    def children(self) -> Generator[Node, None, None]:
        if self.expression is not None:
            yield self.expression

Ancestors

Instance variables

var expression

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.expression is not None:
        yield self.expression

Inherited members

class JsBlockStatement (offset=-1, parent=None, leading_comments=<factory>, body=<factory>)

JsBlockStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , body: 'list[Statement]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsBlockStatement(Statement):
    body: list[Statement] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*self.body)

    def children(self) -> Generator[Node, None, None]:
        yield from self.body

Ancestors

Instance variables

var body

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from self.body

Inherited members

class JsEmptyStatement (offset=-1, parent=None, leading_comments=<factory>)

JsEmptyStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsEmptyStatement(Statement):
    def children(self) -> Generator[Node, None, None]:
        yield from ()

Ancestors

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from ()

Inherited members

class JsVariableDeclaration (offset=-1, parent=None, leading_comments=<factory>, declarations=<factory>, kind='var')

JsVariableDeclaration(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , declarations: 'list[JsVariableDeclarator]' = , kind: 'str' = 'var')

Expand source code Browse git 
@dataclass(repr=False)
class JsVariableDeclaration(Statement):
    declarations: list[JsVariableDeclarator] = field(default_factory=list)
    kind: str = 'var'

    def __post_init__(self):
        self._adopt(*self.declarations)

    def children(self) -> Generator[Node, None, None]:
        yield from self.declarations

Ancestors

Instance variables

var declarations

The type of the None singleton.

var kind

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from self.declarations

Inherited members

class JsVariableDeclarator (offset=-1, parent=None, leading_comments=<factory>, id=None, init=None)

JsVariableDeclarator(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , id: 'Expression | None' = None, init: 'Expression | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsVariableDeclarator(Node):
    id: Expression | None = None
    init: Expression | None = None

    def __post_init__(self):
        self._adopt(self.id, self.init)

    def children(self) -> Generator[Node, None, None]:
        if self.id is not None:
            yield self.id
        if self.init is not None:
            yield self.init

Ancestors

Instance variables

var id

The type of the None singleton.

var init

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.id is not None:
        yield self.id
    if self.init is not None:
        yield self.init

Inherited members

class JsIfStatement (offset=-1, parent=None, leading_comments=<factory>, test=None, consequent=None, alternate=None)

JsIfStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , test: 'Expression | None' = None, consequent: 'Statement | None' = None, alternate: 'Statement | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsIfStatement(Statement):
    test: Expression | None = None
    consequent: Statement | None = None
    alternate: Statement | None = None

    def __post_init__(self):
        self._adopt(self.test, self.consequent, self.alternate)

    def children(self) -> Generator[Node, None, None]:
        if self.test is not None:
            yield self.test
        if self.consequent is not None:
            yield self.consequent
        if self.alternate is not None:
            yield self.alternate

Ancestors

Instance variables

var test

The type of the None singleton.

var consequent

The type of the None singleton.

var alternate

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.test is not None:
        yield self.test
    if self.consequent is not None:
        yield self.consequent
    if self.alternate is not None:
        yield self.alternate

Inherited members

class JsWhileStatement (offset=-1, parent=None, leading_comments=<factory>, test=None, body=None)

JsWhileStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , test: 'Expression | None' = None, body: 'Statement | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsWhileStatement(Statement):
    test: Expression | None = None
    body: Statement | None = None

    def __post_init__(self):
        self._adopt(self.test, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.test is not None:
            yield self.test
        if self.body is not None:
            yield self.body

Ancestors

Instance variables

var test

The type of the None singleton.

var body

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.test is not None:
        yield self.test
    if self.body is not None:
        yield self.body

Inherited members

class JsDoWhileStatement (offset=-1, parent=None, leading_comments=<factory>, test=None, body=None)

JsDoWhileStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , test: 'Expression | None' = None, body: 'Statement | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsDoWhileStatement(Statement):
    test: Expression | None = None
    body: Statement | None = None

    def __post_init__(self):
        self._adopt(self.test, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.body is not None:
            yield self.body
        if self.test is not None:
            yield self.test

Ancestors

Instance variables

var test

The type of the None singleton.

var body

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.body is not None:
        yield self.body
    if self.test is not None:
        yield self.test

Inherited members

class JsForStatement (offset=-1, parent=None, leading_comments=<factory>, init=None, test=None, update=None, body=None)

JsForStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , init: 'Expression | Statement | None' = None, test: 'Expression | None' = None, update: 'Expression | None' = None, body: 'Statement | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsForStatement(Statement):
    init: Expression | Statement | None = None
    test: Expression | None = None
    update: Expression | None = None
    body: Statement | None = None

    def __post_init__(self):
        self._adopt(self.init, self.test, self.update, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.init is not None:
            yield self.init
        if self.test is not None:
            yield self.test
        if self.update is not None:
            yield self.update
        if self.body is not None:
            yield self.body

Ancestors

Instance variables

var init

The type of the None singleton.

var test

The type of the None singleton.

var update

The type of the None singleton.

var body

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.init is not None:
        yield self.init
    if self.test is not None:
        yield self.test
    if self.update is not None:
        yield self.update
    if self.body is not None:
        yield self.body

Inherited members

class JsForInStatement (offset=-1, parent=None, leading_comments=<factory>, left=None, right=None, body=None)

JsForInStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , left: 'Expression | Statement | None' = None, right: 'Expression | None' = None, body: 'Statement | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsForInStatement(Statement):
    left: Expression | Statement | None = None
    right: Expression | None = None
    body: Statement | None = None

    def __post_init__(self):
        self._adopt(self.left, self.right, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.left is not None:
            yield self.left
        if self.right is not None:
            yield self.right
        if self.body is not None:
            yield self.body

Ancestors

Instance variables

var left

The type of the None singleton.

var right

The type of the None singleton.

var body

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.left is not None:
        yield self.left
    if self.right is not None:
        yield self.right
    if self.body is not None:
        yield self.body

Inherited members

class JsForOfStatement (offset=-1, parent=None, leading_comments=<factory>, left=None, right=None, body=None, is_await=False)

JsForOfStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , left: 'Expression | Statement | None' = None, right: 'Expression | None' = None, body: 'Statement | None' = None, is_await: 'bool' = False)

Expand source code Browse git 
@dataclass(repr=False)
class JsForOfStatement(Statement):
    left: Expression | Statement | None = None
    right: Expression | None = None
    body: Statement | None = None
    is_await: bool = False

    def __post_init__(self):
        self._adopt(self.left, self.right, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.left is not None:
            yield self.left
        if self.right is not None:
            yield self.right
        if self.body is not None:
            yield self.body

Ancestors

Instance variables

var left

The type of the None singleton.

var right

The type of the None singleton.

var body

The type of the None singleton.

var is_await

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.left is not None:
        yield self.left
    if self.right is not None:
        yield self.right
    if self.body is not None:
        yield self.body

Inherited members

class JsSwitchStatement (offset=-1, parent=None, leading_comments=<factory>, discriminant=None, cases=<factory>)

JsSwitchStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , discriminant: 'Expression | None' = None, cases: 'list[JsSwitchCase]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsSwitchStatement(Statement):
    discriminant: Expression | None = None
    cases: list[JsSwitchCase] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(self.discriminant, *self.cases)

    def children(self) -> Generator[Node, None, None]:
        if self.discriminant is not None:
            yield self.discriminant
        yield from self.cases

Ancestors

Instance variables

var cases

The type of the None singleton.

var discriminant

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.discriminant is not None:
        yield self.discriminant
    yield from self.cases

Inherited members

class JsSwitchCase (offset=-1, parent=None, leading_comments=<factory>, test=None, consequent=<factory>)

JsSwitchCase(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , test: 'Expression | None' = None, consequent: 'list[Statement]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsSwitchCase(Node):
    test: Expression | None = None
    consequent: list[Statement] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(self.test, *self.consequent)

    def children(self) -> Generator[Node, None, None]:
        if self.test is not None:
            yield self.test
        yield from self.consequent

Ancestors

Instance variables

var consequent

The type of the None singleton.

var test

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.test is not None:
        yield self.test
    yield from self.consequent

Inherited members

class JsTryStatement (offset=-1, parent=None, leading_comments=<factory>, block=None, handler=None, finalizer=None)

JsTryStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , block: 'JsBlockStatement | None' = None, handler: 'JsCatchClause | None' = None, finalizer: 'JsBlockStatement | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsTryStatement(Statement):
    block: JsBlockStatement | None = None
    handler: JsCatchClause | None = None
    finalizer: JsBlockStatement | None = None

    def __post_init__(self):
        self._adopt(self.block, self.handler, self.finalizer)

    def children(self) -> Generator[Node, None, None]:
        if self.block is not None:
            yield self.block
        if self.handler is not None:
            yield self.handler
        if self.finalizer is not None:
            yield self.finalizer

Ancestors

Instance variables

var block

The type of the None singleton.

var handler

The type of the None singleton.

var finalizer

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.block is not None:
        yield self.block
    if self.handler is not None:
        yield self.handler
    if self.finalizer is not None:
        yield self.finalizer

Inherited members

class JsCatchClause (offset=-1, parent=None, leading_comments=<factory>, param=None, body=None)

JsCatchClause(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , param: 'Expression | None' = None, body: 'JsBlockStatement | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsCatchClause(Node):
    param: Expression | None = None
    body: JsBlockStatement | None = None

    def __post_init__(self):
        self._adopt(self.param, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.param is not None:
            yield self.param
        if self.body is not None:
            yield self.body

Ancestors

Instance variables

var param

The type of the None singleton.

var body

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.param is not None:
        yield self.param
    if self.body is not None:
        yield self.body

Inherited members

class JsThrowStatement (offset=-1, parent=None, leading_comments=<factory>, argument=None)

JsThrowStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , argument: 'Expression | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsThrowStatement(Statement):
    argument: Expression | None = None

    def __post_init__(self):
        self._adopt(self.argument)

    def children(self) -> Generator[Node, None, None]:
        if self.argument is not None:
            yield self.argument

Ancestors

Instance variables

var argument

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.argument is not None:
        yield self.argument

Inherited members

class JsReturnStatement (offset=-1, parent=None, leading_comments=<factory>, argument=None)

JsReturnStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , argument: 'Expression | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsReturnStatement(Statement):
    argument: Expression | None = None

    def __post_init__(self):
        self._adopt(self.argument)

    def children(self) -> Generator[Node, None, None]:
        if self.argument is not None:
            yield self.argument

Ancestors

Instance variables

var argument

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.argument is not None:
        yield self.argument

Inherited members

class JsBreakStatement (offset=-1, parent=None, leading_comments=<factory>, label=None)

JsBreakStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , label: 'JsIdentifier | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsBreakStatement(Statement):
    label: JsIdentifier | None = None

    def __post_init__(self):
        self._adopt(self.label)

    def children(self) -> Generator[Node, None, None]:
        if self.label is not None:
            yield self.label

Ancestors

Instance variables

var label

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.label is not None:
        yield self.label

Inherited members

class JsContinueStatement (offset=-1, parent=None, leading_comments=<factory>, label=None)

JsContinueStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , label: 'JsIdentifier | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsContinueStatement(Statement):
    label: JsIdentifier | None = None

    def __post_init__(self):
        self._adopt(self.label)

    def children(self) -> Generator[Node, None, None]:
        if self.label is not None:
            yield self.label

Ancestors

Instance variables

var label

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.label is not None:
        yield self.label

Inherited members

class JsLabeledStatement (offset=-1, parent=None, leading_comments=<factory>, label=None, body=None)

JsLabeledStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , label: 'JsIdentifier | None' = None, body: 'Statement | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsLabeledStatement(Statement):
    label: JsIdentifier | None = None
    body: Statement | None = None

    def __post_init__(self):
        self._adopt(self.label, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.label is not None:
            yield self.label
        if self.body is not None:
            yield self.body

Ancestors

Instance variables

var label

The type of the None singleton.

var body

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.label is not None:
        yield self.label
    if self.body is not None:
        yield self.body

Inherited members

class JsWithStatement (offset=-1, parent=None, leading_comments=<factory>, object=None, body=None)

JsWithStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , object: 'Expression | None' = None, body: 'Statement | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsWithStatement(Statement):
    object: Expression | None = None
    body: Statement | None = None

    def __post_init__(self):
        self._adopt(self.object, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.object is not None:
            yield self.object
        if self.body is not None:
            yield self.body

Ancestors

Instance variables

var object

The type of the None singleton.

var body

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.object is not None:
        yield self.object
    if self.body is not None:
        yield self.body

Inherited members

class JsDebuggerStatement (offset=-1, parent=None, leading_comments=<factory>)

JsDebuggerStatement(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsDebuggerStatement(Statement):
    def children(self) -> Generator[Node, None, None]:
        yield from ()

Ancestors

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from ()

Inherited members

class JsFunctionDeclaration (offset=-1, parent=None, leading_comments=<factory>, id=None, params=<factory>, body=None, generator=False, is_async=False)

JsFunctionDeclaration(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , id: 'JsIdentifier | None' = None, params: 'list[Expression]' = , body: 'JsBlockStatement | None' = None, generator: 'bool' = False, is_async: 'bool' = False)

Expand source code Browse git 
@dataclass(repr=False)
class JsFunctionDeclaration(Statement):
    id: JsIdentifier | None = None
    params: list[Expression] = field(default_factory=list)
    body: JsBlockStatement | None = None
    generator: bool = False
    is_async: bool = False

    def __post_init__(self):
        self._adopt(self.id, *self.params, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.id is not None:
            yield self.id
        yield from self.params
        if self.body is not None:
            yield self.body

Ancestors

Instance variables

var params

The type of the None singleton.

var id

The type of the None singleton.

var body

The type of the None singleton.

var generator

The type of the None singleton.

var is_async

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.id is not None:
        yield self.id
    yield from self.params
    if self.body is not None:
        yield self.body

Inherited members

class JsClassDeclaration (offset=-1, parent=None, leading_comments=<factory>, id=None, super_class=None, body=None)

JsClassDeclaration(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , id: 'JsIdentifier | None' = None, super_class: 'Expression | None' = None, body: 'JsClassBody | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsClassDeclaration(Statement):
    id: JsIdentifier | None = None
    super_class: Expression | None = None
    body: JsClassBody | None = None

    def __post_init__(self):
        self._adopt(self.id, self.super_class, self.body)

    def children(self) -> Generator[Node, None, None]:
        if self.id is not None:
            yield self.id
        if self.super_class is not None:
            yield self.super_class
        if self.body is not None:
            yield self.body

Ancestors

Instance variables

var id

The type of the None singleton.

var super_class

The type of the None singleton.

var body

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.id is not None:
        yield self.id
    if self.super_class is not None:
        yield self.super_class
    if self.body is not None:
        yield self.body

Inherited members

class JsImportSpecifier (offset=-1, parent=None, leading_comments=<factory>, imported=None, local=None)

JsImportSpecifier(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , imported: 'JsIdentifier | None' = None, local: 'JsIdentifier | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsImportSpecifier(Node):
    imported: JsIdentifier | None = None
    local: JsIdentifier | None = None

    def __post_init__(self):
        self._adopt(self.imported, self.local)

    def children(self) -> Generator[Node, None, None]:
        if self.imported is not None:
            yield self.imported
        if self.local is not None:
            yield self.local

Ancestors

Instance variables

var imported

The type of the None singleton.

var local

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.imported is not None:
        yield self.imported
    if self.local is not None:
        yield self.local

Inherited members

class JsImportDefaultSpecifier (offset=-1, parent=None, leading_comments=<factory>, local=None)

JsImportDefaultSpecifier(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , local: 'JsIdentifier | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsImportDefaultSpecifier(Node):
    local: JsIdentifier | None = None

    def __post_init__(self):
        self._adopt(self.local)

    def children(self) -> Generator[Node, None, None]:
        if self.local is not None:
            yield self.local

Ancestors

Instance variables

var local

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.local is not None:
        yield self.local

Inherited members

class JsImportNamespaceSpecifier (offset=-1, parent=None, leading_comments=<factory>, local=None)

JsImportNamespaceSpecifier(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , local: 'JsIdentifier | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsImportNamespaceSpecifier(Node):
    local: JsIdentifier | None = None

    def __post_init__(self):
        self._adopt(self.local)

    def children(self) -> Generator[Node, None, None]:
        if self.local is not None:
            yield self.local

Ancestors

Instance variables

var local

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.local is not None:
        yield self.local

Inherited members

class JsImportDeclaration (offset=-1, parent=None, leading_comments=<factory>, specifiers=<factory>, source=None)

JsImportDeclaration(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , specifiers: 'list[JsImportSpecifier | JsImportDefaultSpecifier | JsImportNamespaceSpecifier]' = , source: 'JsStringLiteral | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsImportDeclaration(Statement):
    specifiers: list[
        JsImportSpecifier | JsImportDefaultSpecifier | JsImportNamespaceSpecifier
    ] = field(default_factory=list)
    source: JsStringLiteral | None = None

    def __post_init__(self):
        self._adopt(*self.specifiers, self.source)

    def children(self) -> Generator[Node, None, None]:
        yield from self.specifiers
        if self.source is not None:
            yield self.source

Ancestors

Instance variables

var specifiers

The type of the None singleton.

var source

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from self.specifiers
    if self.source is not None:
        yield self.source

Inherited members

class JsExportSpecifier (offset=-1, parent=None, leading_comments=<factory>, local=None, exported=None)

JsExportSpecifier(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , local: 'JsIdentifier | None' = None, exported: 'JsIdentifier | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsExportSpecifier(Node):
    local: JsIdentifier | None = None
    exported: JsIdentifier | None = None

    def __post_init__(self):
        self._adopt(self.local, self.exported)

    def children(self) -> Generator[Node, None, None]:
        if self.local is not None:
            yield self.local
        if self.exported is not None:
            yield self.exported

Ancestors

Instance variables

var local

The type of the None singleton.

var exported

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.local is not None:
        yield self.local
    if self.exported is not None:
        yield self.exported

Inherited members

class JsExportNamedDeclaration (offset=-1, parent=None, leading_comments=<factory>, declaration=None, specifiers=<factory>, source=None)

JsExportNamedDeclaration(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , declaration: 'Statement | None' = None, specifiers: 'list[JsExportSpecifier]' = , source: 'JsStringLiteral | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsExportNamedDeclaration(Statement):
    declaration: Statement | None = None
    specifiers: list[JsExportSpecifier] = field(default_factory=list)
    source: JsStringLiteral | None = None

    def __post_init__(self):
        self._adopt(self.declaration, *self.specifiers, self.source)

    def children(self) -> Generator[Node, None, None]:
        if self.declaration is not None:
            yield self.declaration
        yield from self.specifiers
        if self.source is not None:
            yield self.source

Ancestors

Instance variables

var specifiers

The type of the None singleton.

var declaration

The type of the None singleton.

var source

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.declaration is not None:
        yield self.declaration
    yield from self.specifiers
    if self.source is not None:
        yield self.source

Inherited members

class JsExportDefaultDeclaration (offset=-1, parent=None, leading_comments=<factory>, declaration=None)

JsExportDefaultDeclaration(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , declaration: 'Expression | Statement | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsExportDefaultDeclaration(Statement):
    declaration: Expression | Statement | None = None

    def __post_init__(self):
        self._adopt(self.declaration)

    def children(self) -> Generator[Node, None, None]:
        if self.declaration is not None:
            yield self.declaration

Ancestors

Instance variables

var declaration

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.declaration is not None:
        yield self.declaration

Inherited members

class JsExportAllDeclaration (offset=-1, parent=None, leading_comments=<factory>, source=None, exported=None)

JsExportAllDeclaration(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , source: 'JsStringLiteral | None' = None, exported: 'JsIdentifier | None' = None)

Expand source code Browse git 
@dataclass(repr=False)
class JsExportAllDeclaration(Statement):
    source: JsStringLiteral | None = None
    exported: JsIdentifier | None = None

    def __post_init__(self):
        self._adopt(self.source, self.exported)

    def children(self) -> Generator[Node, None, None]:
        if self.source is not None:
            yield self.source
        if self.exported is not None:
            yield self.exported

Ancestors

Instance variables

var source

The type of the None singleton.

var exported

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    if self.source is not None:
        yield self.source
    if self.exported is not None:
        yield self.exported

Inherited members

class JsScript (offset=-1, parent=None, leading_comments=<factory>, body=<factory>)

JsScript(offset: 'int' = -1, parent: 'Node | None' = None, leading_comments: 'list[str]' = , body: 'list[Statement]' = )

Expand source code Browse git 
@dataclass(repr=False)
class JsScript(Statement):
    body: list[Statement] = field(default_factory=list)

    def __post_init__(self):
        self._adopt(*self.body)

    def children(self) -> Generator[Node, None, None]:
        yield from self.body

Ancestors

Instance variables

var body

The type of the None singleton.

Methods

def children(self)
Expand source code Browse git 
def children(self) -> Generator[Node, None, None]:
    yield from self.body

Inherited members