diff --git a/acorn/acorn-tests.ts b/acorn/acorn-tests.ts new file mode 100644 index 000000000..1c5cf27ba --- /dev/null +++ b/acorn/acorn-tests.ts @@ -0,0 +1,30 @@ +/// +/// + +import acorn = require('acorn'); + +var token: acorn.Token; +var tokens: acorn.Token[]; +var comment: acorn.Comment; +var comments: acorn.Comment[]; +var program: ESTree.Program; +var any: any; +var string: string; + +// acorn +string = acorn.version; +program = acorn.parse('code'); +program = acorn.parse('code', {range: true, onToken: tokens, onComment: comments}); +program = acorn.parse('code', { + ranges: true, + onToken: (token) => tokens.push(token), + onComment: (isBlock, text, start, end) => { } +}); + +// Token +token = tokens[0]; +string = token.type.label; +any = token.value; + +// Comment +string = comment.value; diff --git a/acorn/acorn.d.ts b/acorn/acorn.d.ts new file mode 100644 index 000000000..eaba47e3b --- /dev/null +++ b/acorn/acorn.d.ts @@ -0,0 +1,67 @@ +// Type definitions for Acorn v1.0.1 +// Project: https://github.com/marijnh/acorn +// Definitions by: RReverser +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +/// + +declare module acorn { + var version: string; + function parse(input: string, options?: Options): ESTree.Program; + function parseExpressionAt(input: string, pos: number, options?: Options): ESTree.Expression; + var defaultOptions: Options; + + interface TokenType { + label: string; + keyword: string; + beforeExpr: boolean; + startsExpr: boolean; + isLoop: boolean; + isAssign: boolean; + prefix: boolean; + postfix: boolean; + binop: number; + updateContext: (prevType: TokenType) => any; + } + + interface AbstractToken { + start: number; + end: number; + loc: ESTree.SourceLocation; + range: [number, number]; + } + + interface Token extends AbstractToken { + type: TokenType; + value: any; + } + + interface Comment extends AbstractToken { + type: string; + value: string; + } + + interface Options { + ecmaVersion?: number; + sourceType?: string; + onInsertedSemicolon?: (lastTokEnd: number, lastTokEndLoc?: ESTree.Position) => any; + onTrailingComma?: (lastTokEnd: number, lastTokEndLoc?: ESTree.Position) => any; + allowReserved?: boolean; + allowReturnOutsideFunction?: boolean; + allowImportExportEverywhere?: boolean; + allowHashBang?: boolean; + locations?: boolean; + onToken?: ((token: Token) => any) | Token[]; + onComment?: ((isBlock: boolean, text: string, start: number, end: number, startLoc?: ESTree.Position, endLoc?: ESTree.Position) => any) | Comment[]; + ranges?: boolean; + program?: ESTree.Program; + sourceFile?: string; + directSourceFile?: string; + preserveParens?: boolean; + plugins?: { [name: string]: Function; }; + } +} + +declare module "acorn" { + export = acorn +} diff --git a/esprima/esprima-tests.ts b/esprima/esprima-tests.ts index d2635a404..f1a0f7ad9 100644 --- a/esprima/esprima-tests.ts +++ b/esprima/esprima-tests.ts @@ -1,27 +1,12 @@ +/// /// import esprima = require('esprima'); -import Syntax = esprima.Syntax; var token: esprima.Token; -var options: esprima.Options; -var comment: Syntax.Comment; -var program: Syntax.Program; -var statement: Syntax.Statement; -var expression: Syntax.Expression; -var property: Syntax.Property; -var identifier: Syntax.Identifier; -var literal: Syntax.Literal; -var switchCase: Syntax.SwitchCase; -var catchClause: Syntax.CatchClause; -var variableDeclaratorOrExpression: Syntax.VariableDeclaratorOrExpression; -var literalOrIdentifier: Syntax.LiteralOrIdentifier; -var blockStatementOrExpression: Syntax.BlockStatementOrExpression; -var identifierOrExpression: Syntax.IdentifierOrExpression; -var any: any; +var comment: esprima.Comment; +var program: ESTree.Program; var string: string; -var boolean: boolean; -var number: number; // esprima string = esprima.version; @@ -34,171 +19,5 @@ token = esprima.tokenize('code', {range: true})[0]; string = token.type; string = token.value; -// Program -string = program.type; -statement = program.body[0]; -comment = program.comments[0] - -// Location -number = program.loc.start.line; -number = program.loc.start.column; -number = program.loc.end.line; -number = program.loc.end.column; -number = program.range[0]; - // Comment string = comment.value; - -// Statement -// BlockStatement -var blockStatement: Syntax.BlockStatement; -string = blockStatement.type; -statement = blockStatement.body[0]; -comment = blockStatement.leadingComments[0]; -comment = blockStatement.trailingComments[0]; - -// ExpressionStatement -var expressionStatement: Syntax.ExpressionStatement; -expression = expressionStatement.expression; - -// IfStatement -var ifStatement: Syntax.IfStatement; -expression = ifStatement.test; -statement = ifStatement.consequent; -statement = ifStatement.alternate; - -// LabeledStatement -var labeledStatement: Syntax.LabeledStatement; -identifier = labeledStatement.label; -statement = labeledStatement.body; - -// WithStatement -var withStatement: Syntax.WithStatement; -expression = withStatement.object; - -// SwitchStatement -var switchStatement: Syntax.SwitchStatement; -expression = switchStatement.discriminant; -switchCase = switchStatement.cases[0]; -boolean = switchStatement.lexical; - -// ReturnStatement -var returnStatement: Syntax.ReturnStatement; -expression = returnStatement.argument; - -// TryStatement -var tryStatement: Syntax.TryStatement; -blockStatement = tryStatement.block; -catchClause = tryStatement.handler; -catchClause = tryStatement.guardedHandlers[0]; -blockStatement = tryStatement.finalizer; - -// ForStatement -var forStatement: Syntax.ForStatement; -variableDeclaratorOrExpression = forStatement.init; -expression = forStatement.update; - -// ForInStatement -var forInStatement: Syntax.ForInStatement; -variableDeclaratorOrExpression = forInStatement.left; -expression = forInStatement.right; -boolean = forInStatement.each; - -// Expression -// ArrayExpression -var arrayExpression: Syntax.ArrayExpression; -string = arrayExpression.type; -expression = arrayExpression.elements[0]; - -// ObjectExpression -var objectExpression: Syntax.ObjectExpression; -property = objectExpression.properties[0]; -string = property.type; -literalOrIdentifier = property.key; -expression = property.value; -string = property.kind; - -// FunctionExpression -var functionExpression: Syntax.FunctionExpression; -identifier = functionExpression.id; -identifier = functionExpression.params[0]; -expression = functionExpression.defaults[0]; -identifier = functionExpression.rest; -blockStatementOrExpression = functionExpression.body; -boolean = functionExpression.generator; -boolean = functionExpression.expression; - -// SequenceExpression -var sequenceExpression: Syntax.SequenceExpression; -expression = sequenceExpression.expressions[0] - -// UnaryExpression -var unaryExpression: Syntax.UnaryExpression; -string = unaryExpression.operator; -boolean = unaryExpression.prefix; - -// BinaryExpression -var binaryExpression: Syntax.BinaryExpression; -expression = binaryExpression.left; -expression = binaryExpression.right; - -// ConditionalExpression -var conditionalExpression: Syntax.ConditionalExpression; -expression = conditionalExpression.test; -expression = conditionalExpression.alternate; -expression = conditionalExpression.consequent; - -// NewExpression -var newExpression: Syntax.NewExpression; -expression = newExpression.callee; -expression = newExpression.arguments[0]; - -// CallExpression -var callExpression: Syntax.CallExpression; -expression = callExpression.callee; -expression = callExpression.arguments[0]; - -// MemberExpression -var memberExpression: Syntax.MemberExpression; -expression = memberExpression.object; -identifierOrExpression = memberExpression.property; -boolean = memberExpression.computed; - -// Declarations -var functionDeclaration: Syntax.FunctionDeclaration; -identifier = functionDeclaration.id; -var params:Syntax.Identifier[] = functionDeclaration.params; -var defaults:Syntax.Expression[] = functionDeclaration.defaults; -identifier = functionDeclaration.rest; -var body:Syntax.BlockStatementOrExpression = functionDeclaration.body; -boolean = functionDeclaration.generator; -boolean = functionDeclaration.expression; - -var variableDeclaration: Syntax.VariableDeclaration; -var declarations:Syntax.VariableDeclarator[] = variableDeclaration.declarations; -string = variableDeclaration.kind; // "var" | "let" | "const" - -var variableDeclarator: Syntax.VariableDeclarator; -identifier = variableDeclarator.id; // Pattern -expression = variableDeclarator.init; - -// Clauses -// SwitchCase -string = switchCase.type; -expression = switchCase.test; -statement = switchCase.consequent[0]; - -// CatchClause -string = catchClause.type; -identifier = catchClause.param; -expression = catchClause.guard; -blockStatement = catchClause.body; - -// Misc -// Identifier -string = identifier.type; -string = identifier.name; - -// Literal -string = literal.type; -any = literal.value; diff --git a/esprima/esprima.d.ts b/esprima/esprima.d.ts index d62bb09bb..10e37a530 100644 --- a/esprima/esprima.d.ts +++ b/esprima/esprima.d.ts @@ -1,18 +1,24 @@ -// Type definitions for Esprima v1.2.0 +// Type definitions for Esprima v2.1.0 // Project: http://esprima.org -// Definitions by: teppeis +// Definitions by: teppeis , RReverser // Definitions: https://github.com/borisyankov/DefinitelyTyped +/// + declare module esprima { - var version: string; - function parse(code: string, options?: Options): Syntax.Program; - function tokenize(code: string, options?: Options): Array; + var version: string + function parse(code: string, options?: Options): ESTree.Program + function tokenize(code: string, options?: Options): Array interface Token { type: string value: string } + interface Comment extends ESTree.Node { + value: string + } + interface Options { loc?: boolean range?: boolean @@ -23,244 +29,6 @@ declare module esprima { tolerant?: boolean source?: boolean } - - module Syntax { - // Node - interface Node { - type: string - loc?: LineLocation - range?: number[] - leadingComments?: Comment[] - trailingComments?: Comment[] - } - interface LineLocation { - start: Position - end: Position - } - interface Position { - line: number - column: number - } - - // Comment - interface Comment extends Node { - value: string - } - - // Program - interface Program extends Node { - body: Statement[] - comments?: Comment[] - } - - // Function - interface Function extends Node { - id: Identifier // | null - params: Identifier[] - defaults: Expression[] - rest: Identifier // | null - body: BlockStatementOrExpression - generator: boolean - expression: boolean - } - interface BlockStatementOrExpression extends BlockStatement, Expression { - } - - // Statement - interface Statement extends Node { - } - interface EmptyStatement extends Statement { - } - interface BlockStatement extends Statement { - body: Statement[] - } - interface ExpressionStatement extends Statement { - expression: Expression - } - interface IfStatement extends Statement { - test: Expression - consequent: Statement - alternate: Statement - } - interface LabeledStatement extends Statement { - label: Identifier - body: Statement - } - interface BreakStatement extends Statement { - label: Identifier // | null - } - interface ContinueStatement extends Statement { - label: Identifier // | null - } - interface WithStatement extends Statement { - object: Expression - body: Statement - } - interface SwitchStatement extends Statement { - discriminant: Expression - cases: SwitchCase[] - lexical: boolean - } - interface ReturnStatement extends Statement { - argument: Expression // | null - } - interface ThrowStatement extends Statement { - argument: Expression - } - interface TryStatement extends Statement { - block: BlockStatement - handler: CatchClause // | null - guardedHandlers: CatchClause[] - finalizer: BlockStatement // | null - } - interface WhileStatement extends Statement { - test: Expression - body: Statement - } - interface DoWhileStatement extends Statement { - body: Statement - test: Expression - } - interface ForStatement extends Statement { - init: VariableDeclaratorOrExpression // | null - test: Expression // | null - update: Expression // | null - body: Statement - } - interface ForInStatement extends Statement { - left: VariableDeclaratorOrExpression - right: Expression - body: Statement - each: boolean - } - interface VariableDeclaratorOrExpression extends VariableDeclarator, Expression { - } - interface DebuggerStatement extends Statement { - } - interface StatementOrList extends Array, Statement { - } - - // Declaration - interface Declaration extends Statement { - } - interface FunctionDeclaration extends Declaration { - id: Identifier - params: Identifier[] // Pattern - defaults: Expression[] - rest: Identifier - body: BlockStatementOrExpression - generator: boolean - expression: boolean - } - interface VariableDeclaration extends Declaration { - declarations: VariableDeclarator[] - kind: string // "var" | "let" | "const" - } - interface VariableDeclarator extends Node { - id: Identifier // Pattern - init: Expression - } - - // Expression - interface Expression extends Node { // | Pattern - } - //interface Expression extends - // ThisExpression, ArrayExpression, ObjectExpression, FunctionExpression, - // ArrowFunctionExpression, SequenceExpression, UnaryExpression, BinaryExpression, - // AssignmentExpression, UpdateExpression, LogicalExpression, ConditionalExpression, - // NewExpression, CallExpression, MemberExpression { - //} - interface ThisExpression extends Expression { - } - interface ArrayExpression extends Expression { - elements: Expression[] // [ Expression | null ] - } - interface ObjectExpression extends Expression { - properties: Property[] - } - interface Property extends Node { - key: LiteralOrIdentifier // Literal | Identifier - value: Expression - kind: string // "init" | "get" | "set" - } - interface LiteralOrIdentifier extends Literal, Identifier { - } - interface FunctionExpression extends Function, Expression { - } - interface ArrowFunctionExpression extends Function, Expression { - } - interface SequenceExpression extends Expression { - expressions: Expression[] - } - interface UnaryExpression extends Expression { - operator: string // UnaryOperator - prefix: boolean - argument: Expression - } - interface BinaryExpression extends Expression { - operator: string // BinaryOperator - left: Expression - right: Expression - } - interface AssignmentExpression extends Expression { - operator: string // AssignmentOperator - left: Expression - right: Expression - } - interface UpdateExpression extends Expression { - operator: string // UpdateOperator - argument: Expression - prefix: boolean - } - interface LogicalExpression extends Expression { - operator: string // LogicalOperator - left: Expression - right: Expression - } - interface ConditionalExpression extends Expression { - test: Expression - alternate: Expression - consequent: Expression - } - interface NewExpression extends Expression { - callee: Expression - arguments: Expression[] - } - interface CallExpression extends Expression { - callee: Expression - arguments: Expression[] - } - interface MemberExpression extends Expression { - object: Expression - property: IdentifierOrExpression // Identifier | Expression - computed: boolean - } - interface IdentifierOrExpression extends Identifier, Expression { - } - - // Pattern - // interface Pattern extends Node { - // } - - // Clauses - interface SwitchCase extends Node { - test: Expression - consequent: Statement[] - } - interface CatchClause extends Node { - param: Identifier // Pattern - guard: Expression - body: BlockStatement - } - - // Misc - interface Identifier extends Node, Expression { // | Pattern - name: string - } - interface Literal extends Node, Expression { - value: any // string | boolean | null | number | RegExp - } - } } declare module "esprima" { diff --git a/estree/estree-tests.ts b/estree/estree-tests.ts new file mode 100644 index 000000000..bbf16586d --- /dev/null +++ b/estree/estree-tests.ts @@ -0,0 +1,177 @@ +/// + +var program: ESTree.Program; +var statement: ESTree.Statement; +var expression: ESTree.Expression; +var property: ESTree.Property; +var identifier: ESTree.Identifier; +var literal: ESTree.Literal; +var switchCase: ESTree.SwitchCase; +var catchClause: ESTree.CatchClause; +var pattern: ESTree.Pattern; +var assignmentPattern: ESTree.AssignmentPattern; +var variableDeclaratorOrExpression: ESTree.VariableDeclaration | ESTree.Expression; +var literalOrIdentifier: ESTree.Literal | ESTree.Identifier; +var blockStatementOrExpression: ESTree.BlockStatement | ESTree.Expression; +var identifierOrExpression: ESTree.Expression; +var any: any; +var string: string; +var boolean: boolean; +var number: number; + +// Program +string = program.type; +statement = program.body[0]; + +// Location +number = program.loc.start.line; +number = program.loc.start.column; +number = program.loc.end.line; +number = program.loc.end.column; +number = program.range[0]; + +// Statement +// BlockStatement +var blockStatement: ESTree.BlockStatement; +string = blockStatement.type; +statement = blockStatement.body[0]; + +// ExpressionStatement +var expressionStatement: ESTree.ExpressionStatement; +expression = expressionStatement.expression; + +// IfStatement +var ifStatement: ESTree.IfStatement; +expression = ifStatement.test; +statement = ifStatement.consequent; +statement = ifStatement.alternate; + +// LabeledStatement +var labeledStatement: ESTree.LabeledStatement; +identifier = labeledStatement.label; +statement = labeledStatement.body; + +// WithStatement +var withStatement: ESTree.WithStatement; +expression = withStatement.object; + +// SwitchStatement +var switchStatement: ESTree.SwitchStatement; +expression = switchStatement.discriminant; +switchCase = switchStatement.cases[0]; +boolean = switchStatement.lexical; + +// ReturnStatement +var returnStatement: ESTree.ReturnStatement; +expression = returnStatement.argument; + +// TryStatement +var tryStatement: ESTree.TryStatement; +blockStatement = tryStatement.block; +catchClause = tryStatement.handler; +blockStatement = tryStatement.finalizer; + +// ForStatement +var forStatement: ESTree.ForStatement; +variableDeclaratorOrExpression = forStatement.init; +expression = forStatement.update; + +// ForInStatement +var forInStatement: ESTree.ForInStatement; +variableDeclaratorOrExpression = forInStatement.left; +expression = forInStatement.right; + +// Expression +// ArrayExpression +var arrayExpression: ESTree.ArrayExpression; +string = arrayExpression.type; +expression = arrayExpression.elements[0]; + +// ObjectExpression +var objectExpression: ESTree.ObjectExpression; +property = objectExpression.properties[0]; +string = property.type; +expression = property.key; +expression = property.value; +string = property.kind; + +// FunctionExpression +var functionExpression: ESTree.FunctionExpression; +identifier = functionExpression.id; +assignmentPattern = functionExpression.params[0]; +pattern = assignmentPattern.left; +expression = assignmentPattern.right; +blockStatementOrExpression = functionExpression.body; +boolean = functionExpression.generator; + +// SequenceExpression +var sequenceExpression: ESTree.SequenceExpression; +expression = sequenceExpression.expressions[0] + +// UnaryExpression +var unaryExpression: ESTree.UnaryExpression; +string = unaryExpression.operator; +boolean = unaryExpression.prefix; + +// BinaryExpression +var binaryExpression: ESTree.BinaryExpression; +expression = binaryExpression.left; +expression = binaryExpression.right; + +// ConditionalExpression +var conditionalExpression: ESTree.ConditionalExpression; +expression = conditionalExpression.test; +expression = conditionalExpression.alternate; +expression = conditionalExpression.consequent; + +// NewExpression +var newExpression: ESTree.NewExpression; +expression = newExpression.callee; +expression = newExpression.arguments[0]; + +// CallExpression +var callExpression: ESTree.CallExpression; +expression = callExpression.callee; +expression = callExpression.arguments[0]; + +// MemberExpression +var memberExpression: ESTree.MemberExpression; +expression = memberExpression.object; +identifierOrExpression = memberExpression.property; +boolean = memberExpression.computed; + +// Declarations +var functionDeclaration: ESTree.FunctionDeclaration; +identifier = functionDeclaration.id; +var params:ESTree.Pattern[] = functionDeclaration.params; +var body:ESTree.BlockStatement | ESTree.Expression = functionDeclaration.body; +boolean = functionDeclaration.generator; + +var variableDeclaration: ESTree.VariableDeclaration; +var declarations:ESTree.VariableDeclarator[] = variableDeclaration.declarations; +string = variableDeclaration.kind; // "var" | "let" | "const" + +var variableDeclarator: ESTree.VariableDeclarator; +pattern = variableDeclarator.id; // Pattern +expression = variableDeclarator.init; + +// Clauses +// SwitchCase +string = switchCase.type; +expression = switchCase.test; +statement = switchCase.consequent[0]; + +// CatchClause +string = catchClause.type; +pattern = catchClause.param; +expression = catchClause.guard; +blockStatement = catchClause.body; + +// Misc +// Identifier +string = identifier.type; +string = identifier.name; + +// Literal +string = literal.type; +any = literal.value; diff --git a/estree/estree.d.ts b/estree/estree.d.ts new file mode 100644 index 000000000..8d7e04bfd --- /dev/null +++ b/estree/estree.d.ts @@ -0,0 +1,369 @@ +// Type definitions for ESTree AST specification +// Project: https://github.com/estree/estree +// Definitions by: RReverser +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module ESTree { + interface Node { + type: string; + loc?: SourceLocation; + range?: [number, number]; + } + + interface SourceLocation { + source?: string; + start: Position; + end: Position; + } + + interface Position { + line: number; + column: number; + } + + interface Program extends Node { + body: Array; + sourceType: string; + } + + interface Function extends Node { + id?: Identifier; + params: Array; + body: BlockStatement | Expression; + generator: boolean; + } + + interface Statement extends Node {} + + interface EmptyStatement extends Statement {} + + interface BlockStatement extends Statement { + body: Array; + } + + interface ExpressionStatement extends Statement { + expression: Expression; + } + + interface IfStatement extends Statement { + test: Expression; + consequent: Statement; + alternate?: Statement; + } + + interface LabeledStatement extends Statement { + label: Identifier; + body: Statement; + } + + interface BreakStatement extends Statement { + label?: Identifier; + } + + interface ContinueStatement extends Statement { + label?: Identifier; + } + + interface WithStatement extends Statement { + object: Expression; + body: Statement; + } + + interface SwitchStatement extends Statement { + discriminant: Expression; + cases: Array; + lexical: boolean; + } + + interface ReturnStatement extends Statement { + argument?: Expression; + } + + interface ThrowStatement extends Statement { + argument: Expression; + } + + interface TryStatement extends Statement { + block: BlockStatement; + handler?: CatchClause; + finalizer?: BlockStatement; + } + + interface WhileStatement extends Statement { + test: Expression; + body: Statement; + } + + interface DoWhileStatement extends Statement { + body: Statement; + test: Expression; + } + + interface ForStatement extends Statement { + init?: VariableDeclaration | Expression; + test?: Expression; + update?: Expression; + body: Statement; + } + + interface ForInStatement extends Statement { + left: VariableDeclaration | Expression; + right: Expression; + body: Statement; + } + + interface DebuggerStatement extends Statement {} + + interface Declaration extends Statement {} + + interface FunctionDeclaration extends Function, Declaration { + id: Identifier; + } + + interface VariableDeclaration extends Declaration { + declarations: Array; + kind: string; + } + + interface VariableDeclarator extends Node { + id: Pattern; + init?: Expression; + } + + interface Expression extends Node {} + + interface ThisExpression extends Expression {} + + interface ArrayExpression extends Expression { + elements: Array; + } + + interface ObjectExpression extends Expression { + properties: Array; + } + + interface Property extends Node { + key: Expression; + value: Expression; + kind: string; + method: boolean; + shorthand: boolean; + computed: boolean; + } + + interface FunctionExpression extends Function, Expression {} + + interface SequenceExpression extends Expression { + expressions: Array; + } + + interface UnaryExpression extends Expression { + operator: UnaryOperator; + prefix: boolean; + argument: Expression; + } + + interface BinaryExpression extends Expression { + operator: BinaryOperator; + left: Expression; + right: Expression; + } + + interface AssignmentExpression extends Expression { + operator: AssignmentOperator; + left: Pattern | MemberExpression; + right: Expression; + } + + interface UpdateExpression extends Expression { + operator: UpdateOperator; + argument: Expression; + prefix: boolean; + } + + interface LogicalExpression extends Expression { + operator: LogicalOperator; + left: Expression; + right: Expression; + } + + interface ConditionalExpression extends Expression { + test: Expression; + alternate: Expression; + consequent: Expression; + } + + interface CallExpression extends Expression { + callee: Expression; + arguments: Array; + } + + interface NewExpression extends CallExpression {} + + interface MemberExpression extends Expression, Pattern { + object: Expression | Super; + property: Expression; + computed: boolean; + } + + interface Pattern extends Node {} + + interface SwitchCase extends Node { + test?: Expression; + consequent: Array; + } + + interface CatchClause extends Node { + param: Pattern; + guard: any; + body: BlockStatement; + } + + interface Identifier extends Node, Expression, Pattern { + name: string; + } + + interface Literal extends Node, Expression { + value?: string | boolean | number | RegExp; + } + + interface RegexLiteral extends Literal { + regex: { + pattern: string; + flags: string; + }; + } + + type UnaryOperator = string; + + type BinaryOperator = string; + + type LogicalOperator = string; + + type AssignmentOperator = string; + + type UpdateOperator = string; + + interface ForOfStatement extends ForInStatement {} + + interface Super extends Node {} + + interface SpreadElement extends Node { + argument: Expression; + } + + interface ArrowFunctionExpression extends Function, Expression { + expression: boolean; + } + + interface YieldExpression extends Expression { + argument?: Expression; + } + + interface TemplateLiteral extends Expression { + quasis: Array; + expressions: Array; + } + + interface TaggedTemplateExpression extends Expression { + tag: Expression; + quasi: TemplateLiteral; + } + + interface TemplateElement extends Node { + tail: boolean; + value: { + cooked: string; + value: string; + }; + } + + interface AssignmentProperty extends Property { + value: Pattern; + kind: string; + method: boolean; + } + + interface ObjectPattern extends Pattern { + properties: Array; + } + + interface ArrayPattern extends Pattern { + elements: Array; + } + + interface RestElement extends Pattern { + argument: Pattern; + } + + interface AssignmentPattern extends Pattern { + left: Pattern; + right: Expression; + } + + interface Class extends Node { + id?: Identifier; + superClass: Expression; + body: ClassBody; + } + + interface ClassBody extends Node { + body: Array; + } + + interface MethodDefinition extends Node { + key: Identifier; + value: FunctionExpression; + kind: string; + computed: boolean; + static: boolean; + } + + interface ClassDeclaration extends Class, Declaration { + id: Identifier; + } + + interface ClassExpression extends Class, Expression {} + + interface MetaProperty extends Expression { + meta: Identifier; + property: Identifier; + } + + interface ImportDeclaration extends Node { + specifiers: Array; + source: Literal; + } + + interface ImportSpecifier { + imported: Identifier; + local: Identifier; + } + + interface ImportDefaultSpecifier { + local: Identifier; + } + + interface ImportNamespaceSpecifier { + local: Identifier; + } + + interface ExportNamedDeclaration extends Node { + declaration?: Declaration; + specifiers: Array; + source?: Literal; + } + + interface ExportSpecifier { + exported: Identifier; + local: Identifier; + } + + interface ExportDefaultDeclaration extends Node { + declaration: Declaration | Expression; + } + + interface ExportAllDeclaration extends Node { + source: Literal; + } +} \ No newline at end of file