js

type AST ¶

type AST struct {
	Comments  [][]byte // first comments in file
	BlockStmt          // module
}

AST is the full ECMAScript abstract syntax tree.

func Parse(r *parse.Input) (*AST, error)

func (ast *AST) String() string

type Alias ¶

type Alias struct {
	Name    []byte // can be nil
	Binding []byte // can be nil
}

Alias is a name space import or import/export specifier for import/export statements.

func (alias Alias) String() string

type Arg ¶

type Arg struct {
	Value IExpr
	Rest  bool
}

type Args ¶

type Args struct {
	List []Arg
}

Args is a list of arguments as used by new and call expressions.

func (n Args) String() string

type ArrayExpr ¶

type ArrayExpr struct {
	List []Element
}

ArrayExpr is an array literal.

func (n ArrayExpr) String() string

type ArrowFunc ¶

type ArrowFunc struct {
	Async  bool
	Params Params
	Body   BlockStmt
}

ArrowFunc is an (async) arrow function.

func (n ArrowFunc) String() string

type BinaryExpr ¶

type BinaryExpr struct {
	Op   TokenType
	X, Y IExpr
}

BinaryExpr is a binary expression.

func (n BinaryExpr) String() string

type BindingArray ¶

type BindingArray struct {
	List []BindingElement
	Rest IBinding // can be nil
}

BindingArray is an array binding pattern.

func (n BindingArray) String() string

type BindingElement ¶

type BindingElement struct {
	Binding IBinding // can be nil (in case of ellision)
	Default IExpr    // can be nil
}

BindingElement is a binding element.

func (n BindingElement) String() string

type BindingObject ¶

type BindingObject struct {
	List []BindingObjectItem
	Rest *Var // can be nil
}

BindingObject is an object binding pattern.

func (n BindingObject) String() string

type BindingObjectItem ¶

type BindingObjectItem struct {
	Key   *PropertyName // can be nil
	Value BindingElement
}

BindingObjectItem is a binding property.

type BlockStmt ¶

type BlockStmt struct {
	List []IStmt
	Scope
}

BlockStmt is a block statement.

func (n BlockStmt) String() string

type BranchStmt ¶

type BranchStmt struct {
	Type  TokenType
	Label []byte // can be nil
}

BranchStmt is a continue or break statement.

func (n BranchStmt) String() string

type CallExpr ¶

type CallExpr struct {
	X    IExpr
	Args Args
}

CallExpr is a call expression.

func (n CallExpr) String() string

type CaseClause ¶

type CaseClause struct {
	TokenType
	Cond IExpr // can be nil
	List []IStmt
}

CaseClause is a case clause or default clause for a switch statement.

type ClassDecl ¶

type ClassDecl struct {
	Name        *Var  // can be nil
	Extends     IExpr // can be nil
	Definitions []FieldDefinition
	Methods     []*MethodDecl
}

ClassDecl is a class declaration.

func (n ClassDecl) String() string

type CondExpr ¶

type CondExpr struct {
	Cond, X, Y IExpr
}

CondExpr is a conditional expression.

func (n CondExpr) String() string

type DebuggerStmt ¶

type DebuggerStmt struct {
}

DebuggerStmt is a debugger statement.

func (n DebuggerStmt) String() string

type DeclType ¶

type DeclType uint16

DeclType specifies the kind of declaration.

const (
	NoDecl       DeclType = iota // undeclared variables
	VariableDecl                 // var
	FunctionDecl                 // function
	ArgumentDecl                 // function and method arguments
	LexicalDecl                  // let, const, class
	CatchDecl                    // catch statement argument
	ExprDecl                     // function expression name or class expression name
)

func (decl DeclType) String() string

type DirectivePrologueStmt ¶

type DirectivePrologueStmt struct {
	Value []byte
}

DirectivePrologueStmt is a string literal at the beginning of a function or module (usually "use strict").

func (n DirectivePrologueStmt) String() string

type DoWhileStmt ¶

type DoWhileStmt struct {
	Cond IExpr
	Body IStmt
}

DoWhileStmt is a do-while iteration statement.

func (n DoWhileStmt) String() string

type DotExpr ¶

type DotExpr struct {
	X    IExpr
	Y    LiteralExpr
	Prec OpPrec
}

DotExpr is a member/call expression, super property, or optional chain with a dot expression.

func (n DotExpr) String() string

type Element ¶

type Element struct {
	Value  IExpr // can be nil
	Spread bool
}

Element is an array literal element.

type EmptyStmt ¶

type EmptyStmt struct {
}

EmptyStmt is an empty statement.

func (n EmptyStmt) String() string

type ExportStmt ¶

type ExportStmt struct {
	List    []Alias
	Module  []byte // can be nil
	Default bool
	Decl    IExpr
}

ExportStmt is an export statement.

func (n ExportStmt) String() string

type ExprStmt ¶

type ExprStmt struct {
	Value IExpr
}

ExprStmt is an expression statement.

func (n ExprStmt) String() string

type FieldDefinition ¶

type FieldDefinition struct {
	Name PropertyName
	Init IExpr
}

FieldDefinition is a field definition in a class declaration.

func (n FieldDefinition) String() string

type ForInStmt ¶

type ForInStmt struct {
	Init  IExpr
	Value IExpr
	Body  *BlockStmt
}

ForInStmt is a for-in iteration statement.

func (n ForInStmt) String() string

type ForOfStmt ¶

type ForOfStmt struct {
	Await bool
	Init  IExpr
	Value IExpr
	Body  *BlockStmt
}

ForOfStmt is a for-of iteration statement.

func (n ForOfStmt) String() string

type ForStmt ¶

type ForStmt struct {
	Init IExpr // can be nil
	Cond IExpr // can be nil
	Post IExpr // can be nil
	Body *BlockStmt
}

ForStmt is a regular for iteration statement.

func (n ForStmt) String() string

type FuncDecl ¶

type FuncDecl struct {
	Async     bool
	Generator bool
	Name      *Var // can be nil
	Params    Params
	Body      BlockStmt
}

FuncDecl is an (async) (generator) function declaration or expression.

func (n FuncDecl) String() string

type GroupExpr ¶

type GroupExpr struct {
	X IExpr
}

GroupExpr is a parenthesized expression.

func (n GroupExpr) String() string

type IBinding ¶

type IBinding interface {
	String() string
	// contains filtered or unexported methods
}

IBinding is a dummy interface for bindings.

type IExpr ¶

type IExpr interface {
	String() string
	// contains filtered or unexported methods
}

IExpr is a dummy interface for expressions.

type IStmt ¶

type IStmt interface {
	String() string
	// contains filtered or unexported methods
}

IStmt is a dummy interface for statements.

type IfStmt ¶

type IfStmt struct {
	Cond IExpr
	Body IStmt
	Else IStmt // can be nil
}

IfStmt is an if statement.

func (n IfStmt) String() string

type ImportMetaExpr ¶

type ImportMetaExpr struct {
}

ImportMetaExpr is a import meta meta property.

func (n ImportMetaExpr) String() string

type ImportStmt ¶

type ImportStmt struct {
	List    []Alias
	Default []byte // can be nil
	Module  []byte
}

ImportStmt is an import statement.

func (n ImportStmt) String() string

type IndexExpr ¶

type IndexExpr struct {
	X    IExpr
	Y    IExpr
	Prec OpPrec
}

IndexExpr is a member/call expression, super property, or optional chain with an index expression.

func (n IndexExpr) String() string

type LabelledStmt ¶

type LabelledStmt struct {
	Label []byte
	Value IStmt
}

LabelledStmt is a labelled statement.

func (n LabelledStmt) String() string

type Lexer ¶

type Lexer struct {
	// contains filtered or unexported fields
}

Lexer is the state for the lexer.

func NewLexer(r *parse.Input) *Lexer

l := NewLexer(parse.NewInputString("var x = 'lorem ipsum';"))
out := ""
for {
	tt, data := l.Next()
	if tt == ErrorToken {
		break
	}
	out += string(data)
}
fmt.Println(out)

Output:

var x = 'lorem ipsum';

func (l *Lexer) Err() error

func (l *Lexer) Next() (TokenType, []byte)

func (l *Lexer) RegExp() (TokenType, []byte)

type LiteralExpr ¶

type LiteralExpr struct {
	TokenType
	Data []byte
}

LiteralExpr can be this, null, boolean, numeric, string, or regular expression literals.

func (n LiteralExpr) String() string

type MethodDecl ¶

type MethodDecl struct {
	Static    bool
	Async     bool
	Generator bool
	Get       bool
	Set       bool
	Name      PropertyName
	Params    Params
	Body      BlockStmt
}

MethodDecl is a method definition in a class declaration.

func (n MethodDecl) String() string

type NewExpr ¶

type NewExpr struct {
	X    IExpr
	Args *Args // can be nil
}

NewExpr is a new expression or new member expression.

func (n NewExpr) String() string

type NewTargetExpr ¶

type NewTargetExpr struct {
}

NewTargetExpr is a new target meta property.

func (n NewTargetExpr) String() string

type ObjectExpr ¶

type ObjectExpr struct {
	List []Property
}

ObjectExpr is an object literal.

func (n ObjectExpr) String() string

type OpPrec ¶

type OpPrec int

OpPrec is the operator precedence

const (
	OpExpr     OpPrec = iota // a,b
	OpAssign                 // a?b:c, yield x, ()=>x, async ()=>x, a=b, a+=b, ...
	OpCoalesce               // a??b
	OpOr                     // a||b
	OpAnd                    // a&&b
	OpBitOr                  // a|b
	OpBitXor                 // a^b
	OpBitAnd                 // a&b
	OpEquals                 // a==b, a!=b, a===b, a!==b
	OpCompare                // a<b, a>b, a<=b, a>=b, a instanceof b, a in b
	OpShift                  // a<<b, a>>b, a>>>b
	OpAdd                    // a+b, a-b
	OpMul                    // a*b, a/b, a%b
	OpExp                    // a**b
	OpUnary                  // ++x, --x, delete x, void x, typeof x, +x, -x, ~x, !x, await x
	OpUpdate                 // x++, x--
	OpLHS                    // CallExpr/OptChainExpr or NewExpr
	OpCall                   // a?.b, a(b), super(a), import(a)
	OpNew                    // new a
	OpMember                 // a[b], a.b, a`b`, super[x], super.x, new.target, import.meta, new a(b)
	OpPrimary                // literal, function, class, parenthesized
)

func (prec OpPrec) String() string

type OptChainExpr ¶

type OptChainExpr struct {
	X IExpr
	Y IExpr // can be CallExpr, IndexExpr, LiteralExpr, or TemplateExpr
}

OptChainExpr is an optional chain.

func (n OptChainExpr) String() string

type Params ¶

type Params struct {
	List []BindingElement
	Rest IBinding // can be nil
}

Params is a list of parameters for functions, methods, and arrow function.

func (n Params) String() string

type Parser ¶

type Parser struct {
	// contains filtered or unexported fields
}

Parser is the state for the parser.

type Property ¶

type Property struct {
	// either Name or Spread are set. When Spread is set then Value is AssignmentExpression
	// if Init is set then Value is IdentifierReference, otherwise it can also be MethodDefinition
	Name   *PropertyName // can be nil
	Spread bool
	Value  IExpr
	Init   IExpr // can be nil
}

Property is a property definition in an object literal.

func (n Property) String() string

type PropertyName ¶

type PropertyName struct {
	Literal  LiteralExpr
	Computed IExpr // can be nil
}

PropertyName is a property name for binding properties, method names, and in object literals.

func (n PropertyName) IsComputed() bool

func (n PropertyName) IsIdent(data []byte) bool

func (n PropertyName) IsSet() bool

func (n PropertyName) String() string

type ReturnStmt ¶

type ReturnStmt struct {
	Value IExpr // can be nil
}

ReturnStmt is a return statement.

func (n ReturnStmt) String() string

type Scope ¶

type Scope struct {
	Parent, Func   *Scope   // Parent is nil for global scope, Parent equals Func for function scope
	Declared       VarArray // Link in Var are always nil
	Undeclared     VarArray
	NumVarDecls    uint16 // number of variable declaration statements in a function scope
	NumForInit     uint16 // offset into Declared to mark variables used in for initializer
	NumArguments   uint16 // offset into Undeclared to mark variables used in arguments
	IsGlobalOrFunc bool
	HasWith        bool
}

Scope is a function or block scope with a list of variables declared and used.

func (s *Scope) Declare(decl DeclType, name []byte) (*Var, bool)

func (s *Scope) HoistUndeclared()

func (s *Scope) MarkArguments()

func (s *Scope) MarkForInit()

func (s Scope) String() string

func (s *Scope) UndeclareScope()

func (s *Scope) Unscope()

func (s *Scope) Use(name []byte) *Var

type SwitchStmt ¶

type SwitchStmt struct {
	Init IExpr
	List []CaseClause
	Scope
}

SwitchStmt is a switch statement.

func (n SwitchStmt) String() string

type TemplateExpr ¶

type TemplateExpr struct {
	Tag  IExpr // can be nil
	List []TemplatePart
	Tail []byte
	Prec OpPrec
}

TemplateExpr is a template literal or member/call expression, super property, or optional chain with template literal.

func (n TemplateExpr) String() string

type TemplatePart ¶

type TemplatePart struct {
	Value []byte
	Expr  IExpr
}

TemplatePart is a template head or middle.

type ThrowStmt ¶

type ThrowStmt struct {
	Value IExpr
}

ThrowStmt is a throw statement.

func (n ThrowStmt) String() string

type TokenType ¶

type TokenType uint16 // from LSB to MSB: 8 bits for tokens per category, 1 bit for numeric, 1 bit for punctuator, 1 bit for operator, 1 bit for identifier, 4 bits unused

TokenType determines the type of token, eg. a number or a semicolon.

const (
	ErrorToken TokenType = iota // extra token when errors occur
	WhitespaceToken
	LineTerminatorToken // \r \n \r\n
	CommentToken
	CommentLineTerminatorToken
	StringToken
	TemplateToken
	TemplateStartToken
	TemplateMiddleToken
	TemplateEndToken
	RegExpToken
	PrivateIdentifierToken
)

const (
	NumericToken TokenType = 0x0100 + iota
	DecimalToken
	BinaryToken
	OctalToken
	HexadecimalToken
	BigIntToken
)

const (
	PunctuatorToken   TokenType = 0x0200 + iota
	OpenBraceToken              // {
	CloseBraceToken             // }
	OpenParenToken              // (
	CloseParenToken             // )
	OpenBracketToken            // [
	CloseBracketToken           // ]
	DotToken                    // .
	SemicolonToken              // ;
	CommaToken                  // ,
	QuestionToken               // ?
	ColonToken                  // :
	ArrowToken                  // =>
	EllipsisToken               // ...
)

const (
	OperatorToken  TokenType = 0x0600 + iota
	EqToken                  // =
	EqEqToken                // ==
	EqEqEqToken              // ===
	NotToken                 // !
	NotEqToken               // !=
	NotEqEqToken             // !==
	LtToken                  // <
	LtEqToken                // <=
	LtLtToken                // <<
	LtLtEqToken              // <<=
	GtToken                  // >
	GtEqToken                // >=
	GtGtToken                // >>
	GtGtEqToken              // >>=
	GtGtGtToken              // >>>
	GtGtGtEqToken            // >>>=
	AddToken                 // +
	AddEqToken               // +=
	IncrToken                // ++
	SubToken                 // -
	SubEqToken               // -=
	DecrToken                // --
	MulToken                 // *
	MulEqToken               // *=
	ExpToken                 // **
	ExpEqToken               // **=
	DivToken                 // /
	DivEqToken               // /=
	ModToken                 // %
	ModEqToken               // %=
	BitAndToken              // &
	BitOrToken               // |
	BitXorToken              // ^
	BitNotToken              // ~
	BitAndEqToken            // &=
	BitOrEqToken             // |=
	BitXorEqToken            // ^=
	AndToken                 // &&
	OrToken                  // ||
	NullishToken             // ??
	AndEqToken               // &&=
	OrEqToken                // ||=
	NullishEqToken           // ??=
	OptChainToken            // ?.

	// unused in lexer
	PosToken      // +a
	NegToken      // -a
	PreIncrToken  // ++a
	PreDecrToken  // --a
	PostIncrToken // a++
	PostDecrToken // a--
)

const (
	ReservedToken TokenType = 0x0800 + iota
	AwaitToken
	BreakToken
	CaseToken
	CatchToken
	ClassToken
	ConstToken
	ContinueToken
	DebuggerToken
	DefaultToken
	DeleteToken
	DoToken
	ElseToken
	EnumToken
	ExportToken
	ExtendsToken
	FalseToken
	FinallyToken
	ForToken
	FunctionToken
	IfToken
	ImportToken
	InToken
	InstanceofToken
	NewToken
	NullToken
	ReturnToken
	SuperToken
	SwitchToken
	ThisToken
	ThrowToken
	TrueToken
	TryToken
	TypeofToken
	YieldToken
	VarToken
	VoidToken
	WhileToken
	WithToken
)

const (
	IdentifierToken TokenType = 0x1000 + iota
	AsToken
	AsyncToken
	FromToken
	GetToken
	ImplementsToken
	InterfaceToken
	LetToken
	MetaToken
	OfToken
	PackageToken
	PrivateToken
	ProtectedToken
	PublicToken
	SetToken
	StaticToken
	TargetToken
)

func (tt TokenType) Bytes() []byte

func (tt TokenType) String() string

type TryStmt ¶

type TryStmt struct {
	Body    *BlockStmt
	Binding IBinding   // can be nil
	Catch   *BlockStmt // can be nil
	Finally *BlockStmt // can be nil
}

TryStmt is a try statement.

func (n TryStmt) String() string

type UnaryExpr ¶

type UnaryExpr struct {
	Op TokenType
	X  IExpr
}

UnaryExpr is an update or unary expression.

func (n UnaryExpr) String() string

type Var ¶

type Var struct {
	Data []byte
	Link *Var // is set when merging variable uses, as in:  {a} {var a}  where the first links to the second, only used for undeclared variables
	Uses uint16
	Decl DeclType
}

Var is a variable, where Decl is the type of declaration and can be var|function for function scoped variables, let|const|class for block scoped variables.

func (v *Var) Name() []byte

func (v *Var) String() string

type VarArray ¶

type VarArray []*Var

VarArray is a set of variables in scopes.

func (vs VarArray) String() string

type VarDecl ¶

type VarDecl struct {
	TokenType
	List []BindingElement
}

VarDecl is a variable statement or lexical declaration.

func (n VarDecl) String() string

type VarsByUses ¶

type VarsByUses VarArray

VarsByUses is sortable by uses in descending order.

func (vs VarsByUses) Len() int

func (vs VarsByUses) Less(i, j int) bool

func (vs VarsByUses) Swap(i, j int)

type WhileStmt ¶

type WhileStmt struct {
	Cond IExpr
	Body IStmt
}

WhileStmt is a while iteration statement.

func (n WhileStmt) String() string

type WithStmt ¶

type WithStmt struct {
	Cond IExpr
	Body IStmt
}

WithStmt is a with statement.

func (n WithStmt) String() string

type YieldExpr ¶

type YieldExpr struct {
	Generator bool
	X         IExpr // can be nil
}

YieldExpr is a yield expression.

func (n YieldExpr) String() string