@ibyar/expressions 0.8.3 → 0.8.5

package/v8/node.d.ts

@@ -0,0 +1,141 @@
+import { AccessorProperty, ClassBody, ClassDeclaration, ClassExpression, MetaProperty, MethodDefinition, MethodDefinitionKind, PrivateIdentifier, PropertyDefinition, StaticBlock, Super } from '../api/class/class.js';
+import { Decorator } from '../api/class/decorator.js';
+import { CallExpression } from '../api/computing/call.js';
+import { DebuggerStatement } from '../api/computing/debugger.js';
+import { NewExpression } from '../api/computing/new.js';
+import { RestElement } from '../api/computing/rest.js';
+import { ReturnStatement } from '../api/computing/return.js';
+import { SpreadElement } from '../api/computing/spread.js';
+import { CatchClauseNode, ThrowStatement, TryCatchNode } from '../api/computing/throw.js';
+import { YieldExpression } from '../api/computing/yield.js';
+import { ArrayExpression, ArrayPattern } from '../api/definition/array.js';
+import { BindExpression } from '../api/definition/bind.js';
+import { ArrowFunctionExpression, AssignmentPattern, FunctionDeclaration, FunctionExpression } from '../api/definition/function.js';
+import { MemberExpression } from '../api/definition/member.js';
+import { ObjectExpression, ObjectPattern, Property } from '../api/definition/object.js';
+import { Identifier, Literal, TaggedTemplateExpression, TemplateLiteral, ThisExpression } from '../api/definition/values.js';
+import type { ExpressionNode, SourceLocation } from '../api/expression.js';
+import { DeclarationExpression } from '../api/expression.js';
+import { ImportAttribute } from '../api/module/common.js';
+import { ExportAllDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, ExportSpecifier } from '../api/module/export.js';
+import { ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportSpecifier } from '../api/module/import.js';
+import { AssignmentExpression, AssignmentOperator } from '../api/operators/assignment.js';
+import { AwaitExpression } from '../api/operators/await.js';
+import { BinaryExpression, BinaryOperator } from '../api/operators/binary.js';
+import { ChainExpression } from '../api/operators/chaining.js';
+import { SequenceExpression } from '../api/operators/comma.js';
+import { GroupingExpression } from '../api/operators/grouping.js';
+import { LogicalExpression, LogicalOperator } from '../api/operators/logical.js';
+import { PipelineExpression } from '../api/operators/pipeline.js';
+import { ConditionalExpression } from '../api/operators/ternary.js';
+import { UnaryExpression, UnaryOperator } from '../api/operators/unary.js';
+import { UpdateExpression, UpdateOperator } from '../api/operators/update.js';
+import { Program, ProgramSourceType } from '../api/program.js';
+import { BlockStatement } from '../api/statement/control/block.js';
+import { EmptyStatement } from '../api/statement/control/empty.js';
+import { IfStatement } from '../api/statement/control/if.js';
+import { DefaultExpression, SwitchCase, SwitchStatement } from '../api/statement/control/switch.js';
+import { BreakStatement, ContinueStatement, LabeledStatement } from '../api/statement/control/terminate.js';
+import { WithStatement } from '../api/statement/control/with.js';
+import { VariableDeclarationNode, VariableDeclarator } from '../api/statement/declarations/declares.js';
+import { ForAwaitOfNode, ForDeclaration, ForInNode, ForNode, ForOfNode } from '../api/statement/iterations/for.js';
+import { DoWhileNode, WhileNode } from '../api/statement/iterations/while.js';
+export interface SourcePositionFactory {
+    createSourcePosition(range?: [number, number]): SourceLocation | undefined;
+}
+export interface NodeFactory {
+    createDebuggerStatement(range?: [number, number]): DebuggerStatement;
+    createSuper(range?: [number, number]): Super;
+    createThis(range?: [number, number]): ThisExpression;
+    createNull(range?: [number, number]): Literal<null>;
+    createTrue(range?: [number, number]): Literal<true>;
+    createFalse(range?: [number, number]): Literal<false>;
+    createVoidZero(argument: ExpressionNode, range?: [number, number]): UnaryExpression;
+    createEmptyStatement(range?: [number, number]): EmptyStatement;
+    createExpressionStatement(list: ExpressionNode[], range?: [number, number]): ExpressionNode;
+    createCatchClause(block: BlockStatement, identifier?: ExpressionNode, range?: [number, number]): CatchClauseNode;
+    createTryStatement(tryBlock: BlockStatement, catchBlock?: ExpressionNode, finallyBlock?: ExpressionNode, range?: [number, number]): TryCatchNode;
+    createThrowStatement(exception: ExpressionNode, range?: [number, number]): ThrowStatement;
+    createBlock(statements: ExpressionNode[], range?: [number, number]): BlockStatement;
+    createIfStatement(condition: ExpressionNode, thenStatement: ExpressionNode, elseStatement?: ExpressionNode, range?: [number, number]): IfStatement;
+    createDoStatement(condition: ExpressionNode, body: ExpressionNode, range?: [number, number]): DoWhileNode;
+    createClassDeclaration(body: ClassBody, decorators: Decorator[], id: Identifier, superClass?: ExpressionNode, range?: [number, number]): ClassDeclaration;
+    createFunctionDeclaration(formals: DeclarationExpression[], bodyBlock: BlockStatement, isAsync: boolean, isGenerator: boolean, name: Identifier, range?: [number, number]): FunctionDeclaration;
+    createFunctionExpression(formals: DeclarationExpression[], bodyBlock: BlockStatement, isAsync: boolean, isGenerator: boolean, range?: [number, number]): FunctionExpression;
+    createWhileStatement(condition: ExpressionNode, body: ExpressionNode, range?: [number, number]): WhileNode;
+    createSwitchStatement(tag: ExpressionNode, cases: SwitchCase[], range?: [number, number]): SwitchStatement;
+    createCaseBlock(test: ExpressionNode, block: BlockStatement, range?: [number, number]): SwitchCase;
+    createDefaultClause(block: BlockStatement, range?: [number, number]): DefaultExpression;
+    createWithStatement(object: ExpressionNode, body: ExpressionNode, range?: [number, number]): WithStatement;
+    createForStatement(body: ExpressionNode, initializer: ExpressionNode, cond: ExpressionNode, next: ExpressionNode, range?: [number, number]): ForNode;
+    createForOfStatement(initializer: ForDeclaration, enumerable: ExpressionNode, body: ExpressionNode, range?: [number, number]): ForOfNode;
+    createForAwaitOfStatement(left: ForDeclaration, right: ExpressionNode, body: ExpressionNode, range?: [number, number]): ForAwaitOfNode;
+    createForInStatement(initializer: ForDeclaration, enumerable: ExpressionNode, body: ExpressionNode, range?: [number, number]): ForInNode;
+    createVariableDeclaration(id: DeclarationExpression, init?: ExpressionNode, range?: [number, number]): VariableDeclarator;
+    createVariableStatement(variables: VariableDeclarator[], kind: 'let' | 'var' | 'const', range?: [number, number]): VariableDeclarationNode;
+    createContinueStatement(label?: Identifier, range?: [number, number]): ContinueStatement;
+    createBreakStatement(label?: Identifier, range?: [number, number]): BreakStatement;
+    createReturnStatement(argument?: ExpressionNode, range?: [number, number]): ReturnStatement;
+    createLabeledStatement(expression: Identifier, result: ExpressionNode, range?: [number, number]): LabeledStatement;
+    createAssignmentPattern(left: DeclarationExpression, right: ExpressionNode, range?: [number, number]): AssignmentPattern;
+    createSpreadElement(argument: ExpressionNode, range?: [number, number]): SpreadElement;
+    createCommaListExpression(expressions: ExpressionNode[], range?: [number, number]): SequenceExpression;
+    createTemplateExpression(quasis: string[], expressions: ExpressionNode[], range?: [number, number]): TemplateLiteral;
+    createTaggedTemplateExpression(tag: ExpressionNode, quasis: string[], expressions: ExpressionNode[], range?: [number, number]): TaggedTemplateExpression;
+    createNewExpression(className: ExpressionNode, parameters?: ExpressionNode[], range?: [number, number]): NewExpression;
+    createObjectBindingPattern(properties: (Property | RestElement)[], range?: [number, number]): ObjectPattern;
+    createObjectLiteralExpression(properties: Property[], range?: [number, number]): ObjectExpression;
+    createArrayBindingPattern(elements: (DeclarationExpression | null)[], range?: [number, number]): ArrayPattern;
+    createArrayLiteralExpression(elements: (ExpressionNode | SpreadElement | null)[], range?: [number, number]): ArrayExpression;
+    createAssignment(operator: AssignmentOperator, left: ExpressionNode, right: ExpressionNode, range?: [number, number]): AssignmentExpression;
+    createRestElement(argument: DeclarationExpression, range?: [number, number]): RestElement;
+    createArrowFunction(params: DeclarationExpression[], body: ExpressionNode | ExpressionNode[], expression: boolean, async: boolean, range?: [number, number]): ArrowFunctionExpression;
+    createPropertyDeclaration(key: ExpressionNode, value: DeclarationExpression | ExpressionNode, kind: 'init' | 'get' | 'set', method: boolean, shorthand: boolean, computed: boolean, range?: [number, number]): Property;
+    createIdentifier(name: string, range?: [number, number]): Identifier;
+    createPropertyAssignment(object: ExpressionNode, property: ExpressionNode, computed: boolean, optional?: boolean, range?: [number, number]): MemberExpression;
+    createPipelineExpression(left: ExpressionNode, right: ExpressionNode, params?: (ExpressionNode | '?' | '...?')[], range?: [number, number]): PipelineExpression;
+    createCallExpression(callee: ExpressionNode, params: ExpressionNode[], optional?: boolean, range?: [number, number]): CallExpression;
+    createBindExpression(object: ExpressionNode, property: ExpressionNode, computed: boolean, optional?: boolean, range?: [number, number]): BindExpression;
+    createChainExpression(expression: ExpressionNode, range?: [number, number]): ChainExpression;
+    createLogicalExpression(operator: LogicalOperator, left: ExpressionNode, right: ExpressionNode, range?: [number, number]): LogicalExpression;
+    createConditionalExpression(test: ExpressionNode, alternate: ExpressionNode, consequent: ExpressionNode, range?: [number, number]): ConditionalExpression;
+    createYieldExpression(delegate: boolean, argument?: ExpressionNode, range?: [number, number]): YieldExpression;
+    createMetaProperty(meta: Identifier, property: Identifier, range?: [number, number]): MetaProperty;
+    createProgram(sourceType: ProgramSourceType, body: ExpressionNode[], range?: [number, number]): Program;
+    createClassExpression(body: ClassBody, decorators: Decorator[], id?: Identifier, superClass?: ExpressionNode, range?: [number, number]): ClassExpression;
+    createClassStaticBlockDeclaration(body: ExpressionNode[], range?: [number, number]): StaticBlock;
+    createMethodSignature(kind: MethodDefinitionKind, key: ExpressionNode | PrivateIdentifier, value: FunctionExpression, decorators: Decorator[], computed: boolean, isStatic: boolean, range?: [number, number]): MethodDefinition;
+    createPropertySignature(key: ExpressionNode | PrivateIdentifier, decorators: Decorator[], computed: boolean, isStatic: boolean, value?: ExpressionNode, range?: [number, number]): PropertyDefinition;
+    createClassBody(body: (MethodDefinition | PropertyDefinition | AccessorProperty | StaticBlock)[], range?: [number, number]): ClassBody;
+    createNamespaceExportDeclaration(specifiers: ExportSpecifier[], declaration?: DeclarationExpression, source?: Literal<string>, assertions?: ImportAttribute[], range?: [number, number]): ExportNamedDeclaration;
+    createExportSpecifier(local: Identifier, exported: Identifier, range?: [number, number]): ExportSpecifier;
+    createImportSpecifier(local: Identifier, imported: Identifier, range?: [number, number]): ImportSpecifier;
+    createImportDeclaration(source: Literal<string>, specifiers?: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[], assertions?: ImportAttribute[], range?: [number, number]): ImportDeclaration;
+    createImportNamespaceSpecifier(local: Identifier, range?: [number, number]): ImportNamespaceSpecifier;
+    createImportDefaultSpecifier(local: Identifier, range?: [number, number]): ImportDefaultSpecifier;
+    createImportExpression(source: Literal<string>, attributes?: ExpressionNode, range?: [number, number]): ImportExpression;
+    createAssertEntry(key: Identifier | Literal<string>, value: Literal<string>, range?: [number, number]): ImportAttribute;
+    createExportDefault(declaration: FunctionDeclaration | ClassDeclaration | ExpressionNode, range?: [number, number]): ExportDefaultDeclaration;
+    createExportAllDeclaration(source: Literal<string>, exported?: Identifier, assertions?: ImportAttribute[], range?: [number, number]): ExportAllDeclaration;
+    createInfixExpression(operator: AssignmentOperator | LogicalOperator | BinaryOperator, left: ExpressionNode, right: ExpressionNode, range?: [number, number]): AssignmentExpression | LogicalExpression | BinaryExpression;
+    createUnaryExpression(operator: UpdateOperator | UnaryOperator | 'await', expression: ExpressionNode, range?: [number, number]): UpdateExpression | UnaryExpression | AwaitExpression;
+    createUpdateExpression(operator: UpdateOperator, argument: ExpressionNode, prefix: boolean, range?: [number, number]): UpdateExpression;
+    createAwaitExpression(argument: ExpressionNode, range?: [number, number]): AwaitExpression;
+    isIdentifier(node?: ExpressionNode): node is Identifier;
+    isObjectExpression(node?: ExpressionNode): node is ObjectExpression;
+    isArrayExpression(node?: ExpressionNode): node is ArrayExpression;
+    isObjectPattern(node?: ExpressionNode): node is ObjectPattern;
+    isArrayPattern(node?: ExpressionNode): node is ArrayPattern;
+    isAssignmentPattern(node?: ExpressionNode): node is AssignmentPattern;
+    isPattern(node?: ExpressionNode): boolean;
+    canBePattern(node?: ExpressionNode): node is (ObjectExpression | ArrayExpression);
+    isProperty(node?: ExpressionNode): node is Property;
+    isMemberExpression(node?: ExpressionNode): node is MemberExpression;
+    isPropertyOrMemberExpression(node?: ExpressionNode): node is (Property | MemberExpression);
+    isEmptyStatement(expression: ExpressionNode): expression is EmptyStatement;
+    isSequenceExpression(node: ExpressionNode): node is SequenceExpression;
+    isSuper(node: ExpressionNode): node is Super;
+    isAssignmentExpression(node: ExpressionNode): node is AssignmentExpression;
+    isGroupingExpression(node: ExpressionNode): node is GroupingExpression;
+    isSpreadElement(node: ExpressionNode): node is SpreadElement;
+}

package/v8/node.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=node.js.map

package/v8/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../src/expressions/v8/node.ts"],"names":[],"mappings":"","sourcesContent":["import {\n\tAccessorProperty, ClassBody, ClassDeclaration, ClassExpression,\n\tMetaProperty, MethodDefinition, MethodDefinitionKind, PrivateIdentifier,\n\tPropertyDefinition, StaticBlock, Super\n} from '../api/class/class.js';\nimport { Decorator } from '../api/class/decorator.js';\nimport { CallExpression } from '../api/computing/call.js';\nimport { DebuggerStatement } from '../api/computing/debugger.js';\nimport { NewExpression } from '../api/computing/new.js';\nimport { RestElement } from '../api/computing/rest.js';\nimport { ReturnStatement } from '../api/computing/return.js';\nimport { SpreadElement } from '../api/computing/spread.js';\nimport {\n\tCatchClauseNode, ThrowStatement, TryCatchNode\n} from '../api/computing/throw.js';\nimport { YieldExpression } from '../api/computing/yield.js';\nimport { ArrayExpression, ArrayPattern } from '../api/definition/array.js';\nimport { BindExpression } from '../api/definition/bind.js';\nimport {\n\tArrowFunctionExpression, AssignmentPattern, FunctionDeclaration, FunctionExpression\n} from '../api/definition/function.js';\nimport { MemberExpression } from '../api/definition/member.js';\nimport {\n\tObjectExpression, ObjectPattern, Property\n} from '../api/definition/object.js';\nimport {\n\tIdentifier, Literal, TaggedTemplateExpression, TemplateLiteral, ThisExpression\n} from '../api/definition/values.js';\nimport type { ExpressionNode, SourceLocation } from '../api/expression.js';\nimport { DeclarationExpression } from '../api/expression.js';\nimport { ImportAttribute } from '../api/module/common.js';\nimport {\n\tExportAllDeclaration, ExportDefaultDeclaration,\n\tExportNamedDeclaration, ExportSpecifier\n} from '../api/module/export.js';\nimport {\n\tImportDeclaration, ImportDefaultSpecifier, ImportExpression,\n\tImportNamespaceSpecifier, ImportSpecifier\n} from '../api/module/import.js';\nimport {\n\tAssignmentExpression, AssignmentOperator\n} from '../api/operators/assignment.js';\nimport { AwaitExpression } from '../api/operators/await.js';\nimport { BinaryExpression, BinaryOperator } from '../api/operators/binary.js';\nimport { ChainExpression } from '../api/operators/chaining.js';\nimport { SequenceExpression } from '../api/operators/comma.js';\nimport { GroupingExpression } from '../api/operators/grouping.js';\nimport { LogicalExpression, LogicalOperator } from '../api/operators/logical.js';\nimport { PipelineExpression } from '../api/operators/pipeline.js';\nimport { ConditionalExpression } from '../api/operators/ternary.js';\nimport { UnaryExpression, UnaryOperator } from '../api/operators/unary.js';\nimport { UpdateExpression, UpdateOperator } from '../api/operators/update.js';\nimport { Program, ProgramSourceType } from '../api/program.js';\nimport { BlockStatement } from '../api/statement/control/block.js';\nimport { EmptyStatement } from '../api/statement/control/empty.js';\nimport { IfStatement } from '../api/statement/control/if.js';\nimport {\n\tDefaultExpression, SwitchCase, SwitchStatement\n} from '../api/statement/control/switch.js';\nimport {\n\tBreakStatement, ContinueStatement, LabeledStatement\n} from '../api/statement/control/terminate.js';\nimport { WithStatement } from '../api/statement/control/with.js';\nimport {\n\tVariableDeclarationNode, VariableDeclarator\n} from '../api/statement/declarations/declares.js';\nimport {\n\tForAwaitOfNode, ForDeclaration, ForInNode, ForNode, ForOfNode\n} from '../api/statement/iterations/for.js';\nimport { DoWhileNode, WhileNode } from '../api/statement/iterations/while.js';\n\n\nexport interface SourcePositionFactory {\n\tcreateSourcePosition(range?: [number, number]): SourceLocation | undefined;\n}\n\nexport interface NodeFactory {\n\tcreateDebuggerStatement(range?: [number, number]): DebuggerStatement;\n\tcreateSuper(range?: [number, number]): Super;\n\tcreateThis(range?: [number, number]): ThisExpression;\n\tcreateNull(range?: [number, number]): Literal<null>;\n\tcreateTrue(range?: [number, number]): Literal<true>;\n\tcreateFalse(range?: [number, number]): Literal<false>;\n\tcreateVoidZero(argument: ExpressionNode, range?: [number, number]): UnaryExpression;\n\tcreateEmptyStatement(range?: [number, number]): EmptyStatement;\n\tcreateExpressionStatement(list: ExpressionNode[], range?: [number, number]): ExpressionNode;\n\tcreateCatchClause(block: BlockStatement, identifier?: ExpressionNode, range?: [number, number]): CatchClauseNode;\n\tcreateTryStatement(tryBlock: BlockStatement, catchBlock?: ExpressionNode, finallyBlock?: ExpressionNode, range?: [number, number]): TryCatchNode;\n\tcreateThrowStatement(exception: ExpressionNode, range?: [number, number]): ThrowStatement;\n\tcreateBlock(statements: ExpressionNode[], range?: [number, number]): BlockStatement;\n\tcreateIfStatement(condition: ExpressionNode, thenStatement: ExpressionNode, elseStatement?: ExpressionNode, range?: [number, number]): IfStatement;\n\tcreateDoStatement(condition: ExpressionNode, body: ExpressionNode, range?: [number, number]): DoWhileNode;\n\tcreateClassDeclaration(body: ClassBody, decorators: Decorator[], id: Identifier, superClass?: ExpressionNode, range?: [number, number]): ClassDeclaration;\n\tcreateFunctionDeclaration(formals: DeclarationExpression[], bodyBlock: BlockStatement, isAsync: boolean, isGenerator: boolean, name: Identifier, range?: [number, number]): FunctionDeclaration;\n\tcreateFunctionExpression(formals: DeclarationExpression[], bodyBlock: BlockStatement, isAsync: boolean, isGenerator: boolean, range?: [number, number]): FunctionExpression;\n\tcreateWhileStatement(condition: ExpressionNode, body: ExpressionNode, range?: [number, number]): WhileNode;\n\tcreateSwitchStatement(tag: ExpressionNode, cases: SwitchCase[], range?: [number, number]): SwitchStatement;\n\tcreateCaseBlock(test: ExpressionNode, block: BlockStatement, range?: [number, number]): SwitchCase;\n\tcreateDefaultClause(block: BlockStatement, range?: [number, number]): DefaultExpression;\n\tcreateWithStatement(object: ExpressionNode, body: ExpressionNode, range?: [number, number]): WithStatement;\n\tcreateForStatement(body: ExpressionNode, initializer: ExpressionNode, cond: ExpressionNode, next: ExpressionNode, range?: [number, number]): ForNode;\n\tcreateForOfStatement(initializer: ForDeclaration, enumerable: ExpressionNode, body: ExpressionNode, range?: [number, number]): ForOfNode;\n\tcreateForAwaitOfStatement(left: ForDeclaration, right: ExpressionNode, body: ExpressionNode, range?: [number, number]): ForAwaitOfNode;\n\tcreateForInStatement(initializer: ForDeclaration, enumerable: ExpressionNode, body: ExpressionNode, range?: [number, number]): ForInNode;\n\tcreateVariableDeclaration(id: DeclarationExpression, init?: ExpressionNode, range?: [number, number]): VariableDeclarator;\n\tcreateVariableStatement(variables: VariableDeclarator[], kind: 'let' | 'var' | 'const', range?: [number, number]): VariableDeclarationNode;\n\tcreateContinueStatement(label?: Identifier, range?: [number, number]): ContinueStatement;\n\tcreateBreakStatement(label?: Identifier, range?: [number, number]): BreakStatement;\n\tcreateReturnStatement(argument?: ExpressionNode, range?: [number, number]): ReturnStatement;\n\tcreateLabeledStatement(expression: Identifier, result: ExpressionNode, range?: [number, number]): LabeledStatement;\n\tcreateAssignmentPattern(left: DeclarationExpression, right: ExpressionNode, range?: [number, number]): AssignmentPattern;\n\tcreateSpreadElement(argument: ExpressionNode, range?: [number, number]): SpreadElement;\n\tcreateCommaListExpression(expressions: ExpressionNode[], range?: [number, number]): SequenceExpression;\n\tcreateTemplateExpression(quasis: string[], expressions: ExpressionNode[], range?: [number, number]): TemplateLiteral;\n\tcreateTaggedTemplateExpression(tag: ExpressionNode, quasis: string[], expressions: ExpressionNode[], range?: [number, number]): TaggedTemplateExpression;\n\tcreateNewExpression(className: ExpressionNode, parameters?: ExpressionNode[], range?: [number, number]): NewExpression;\n\tcreateObjectBindingPattern(properties: (Property | RestElement)[], range?: [number, number]): ObjectPattern;\n\tcreateObjectLiteralExpression(properties: Property[], range?: [number, number]): ObjectExpression;\n\tcreateArrayBindingPattern(elements: (DeclarationExpression | null)[], range?: [number, number]): ArrayPattern;\n\tcreateArrayLiteralExpression(elements: (ExpressionNode | SpreadElement | null)[], range?: [number, number]): ArrayExpression;\n\tcreateAssignment(operator: AssignmentOperator, left: ExpressionNode, right: ExpressionNode, range?: [number, number]): AssignmentExpression;\n\tcreateRestElement(argument: DeclarationExpression, range?: [number, number]): RestElement;\n\tcreateArrowFunction(params: DeclarationExpression[], body: ExpressionNode | ExpressionNode[], expression: boolean, async: boolean, range?: [number, number]): ArrowFunctionExpression;\n\tcreatePropertyDeclaration(key: ExpressionNode, value: DeclarationExpression | ExpressionNode, kind: 'init' | 'get' | 'set', method: boolean, shorthand: boolean, computed: boolean, range?: [number, number]): Property;\n\tcreateIdentifier(name: string, range?: [number, number]): Identifier;\n\tcreatePropertyAssignment(object: ExpressionNode, property: ExpressionNode, computed: boolean, optional?: boolean, range?: [number, number]): MemberExpression;\n\tcreatePipelineExpression(left: ExpressionNode, right: ExpressionNode, params?: (ExpressionNode | '?' | '...?')[], range?: [number, number]): PipelineExpression;\n\tcreateCallExpression(callee: ExpressionNode, params: ExpressionNode[], optional?: boolean, range?: [number, number]): CallExpression;\n\tcreateBindExpression(object: ExpressionNode, property: ExpressionNode, computed: boolean, optional?: boolean, range?: [number, number]): BindExpression;\n\tcreateChainExpression(expression: ExpressionNode, range?: [number, number]): ChainExpression;\n\tcreateLogicalExpression(operator: LogicalOperator, left: ExpressionNode, right: ExpressionNode, range?: [number, number],): LogicalExpression;\n\tcreateConditionalExpression(test: ExpressionNode, alternate: ExpressionNode, consequent: ExpressionNode, range?: [number, number]): ConditionalExpression;\n\tcreateYieldExpression(delegate: boolean, argument?: ExpressionNode, range?: [number, number]): YieldExpression;\n\tcreateMetaProperty(meta: Identifier, property: Identifier, range?: [number, number]): MetaProperty;\n\tcreateProgram(sourceType: ProgramSourceType, body: ExpressionNode[], range?: [number, number]): Program;\n\tcreateClassExpression(body: ClassBody, decorators: Decorator[], id?: Identifier, superClass?: ExpressionNode, range?: [number, number]): ClassExpression;\n\tcreateClassStaticBlockDeclaration(body: ExpressionNode[], range?: [number, number]): StaticBlock;\n\tcreateMethodSignature(kind: MethodDefinitionKind, key: ExpressionNode | PrivateIdentifier, value: FunctionExpression, decorators: Decorator[], computed: boolean, isStatic: boolean, range?: [number, number]): MethodDefinition;\n\tcreatePropertySignature(key: ExpressionNode | PrivateIdentifier, decorators: Decorator[], computed: boolean, isStatic: boolean, value?: ExpressionNode, range?: [number, number]): PropertyDefinition;\n\tcreateClassBody(body: (MethodDefinition | PropertyDefinition | AccessorProperty | StaticBlock)[], range?: [number, number]): ClassBody;\n\tcreateNamespaceExportDeclaration(specifiers: ExportSpecifier[], declaration?: DeclarationExpression, source?: Literal<string>, assertions?: ImportAttribute[], range?: [number, number]): ExportNamedDeclaration;\n\tcreateExportSpecifier(local: Identifier, exported: Identifier, range?: [number, number]): ExportSpecifier;\n\tcreateImportSpecifier(local: Identifier, imported: Identifier, range?: [number, number]): ImportSpecifier;\n\tcreateImportDeclaration(source: Literal<string>, specifiers?: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[], assertions?: ImportAttribute[], range?: [number, number]): ImportDeclaration;\n\tcreateImportNamespaceSpecifier(local: Identifier, range?: [number, number]): ImportNamespaceSpecifier;\n\tcreateImportDefaultSpecifier(local: Identifier, range?: [number, number]): ImportDefaultSpecifier;\n\tcreateImportExpression(source: Literal<string>, attributes?: ExpressionNode, range?: [number, number]): ImportExpression;\n\tcreateAssertEntry(key: Identifier | Literal<string>, value: Literal<string>, range?: [number, number]): ImportAttribute;\n\tcreateExportDefault(declaration: FunctionDeclaration | ClassDeclaration | ExpressionNode, range?: [number, number],): ExportDefaultDeclaration;\n\tcreateExportAllDeclaration(source: Literal<string>, exported?: Identifier, assertions?: ImportAttribute[], range?: [number, number]): ExportAllDeclaration;\n\tcreateInfixExpression(operator: AssignmentOperator | LogicalOperator | BinaryOperator, left: ExpressionNode, right: ExpressionNode, range?: [number, number]): AssignmentExpression | LogicalExpression | BinaryExpression;\n\tcreateUnaryExpression(operator: UpdateOperator | UnaryOperator | 'await', expression: ExpressionNode, range?: [number, number]): UpdateExpression | UnaryExpression | AwaitExpression;\n\tcreateUpdateExpression(operator: UpdateOperator, argument: ExpressionNode, prefix: boolean, range?: [number, number]): UpdateExpression;\n\tcreateAwaitExpression(argument: ExpressionNode, range?: [number, number]): AwaitExpression;\n\tisIdentifier(node?: ExpressionNode): node is Identifier;\n\tisObjectExpression(node?: ExpressionNode): node is ObjectExpression;\n\tisArrayExpression(node?: ExpressionNode): node is ArrayExpression;\n\tisObjectPattern(node?: ExpressionNode): node is ObjectPattern;\n\tisArrayPattern(node?: ExpressionNode): node is ArrayPattern;\n\tisAssignmentPattern(node?: ExpressionNode): node is AssignmentPattern;\n\tisPattern(node?: ExpressionNode): boolean;\n\tcanBePattern(node?: ExpressionNode): node is (ObjectExpression | ArrayExpression);\n\tisProperty(node?: ExpressionNode): node is Property;\n\tisMemberExpression(node?: ExpressionNode): node is MemberExpression;\n\tisPropertyOrMemberExpression(node?: ExpressionNode): node is (Property | MemberExpression);\n\tisEmptyStatement(expression: ExpressionNode): expression is EmptyStatement;\n\tisSequenceExpression(node: ExpressionNode): node is SequenceExpression;\n\tisSuper(node: ExpressionNode): node is Super;\n\tisAssignmentExpression(node: ExpressionNode): node is AssignmentExpression;\n\tisGroupingExpression(node: ExpressionNode): node is GroupingExpression;\n\tisSpreadElement(node: ExpressionNode): node is SpreadElement;\n}\n"]}

package/v8/nodes.d.ts

@@ -1,14 +0,0 @@
-import type { ExpressionNode } from '../api/expression.js';
-import { Token, TokenExpression } from './token.js';
-import { UnaryExpression } from '../api/operators/unary.js';
-import { Literal } from '../api/definition/values.js';
-import { AwaitExpression } from '../api/operators/await.js';
-import { UpdateExpression } from '../api/operators/update.js';
-export declare function creteInfixExpression(op: string, left: ExpressionNode, right: ExpressionNode): ExpressionNode;
-export declare function createTernaryExpression(op: string, logical: ExpressionNode, ifTrue: ExpressionNode, ifFalse: ExpressionNode): ExpressionNode;
-export declare function creteCommaExpression(nodes: ExpressionNode[]): ExpressionNode;
-export declare function shortcutNumericLiteralBinaryExpression(x: ExpressionNode, y: ExpressionNode, op: Token): ExpressionNode;
-export declare function coverValue(value: any): false | Literal<boolean> | Literal<null> | Literal<undefined> | Literal<string | number | bigint>;
-export declare function buildUnaryExpression(expression: ExpressionNode, op: Token): UnaryExpression | AwaitExpression | UpdateExpression;
-export declare function buildPostfixExpression(expression: ExpressionNode, op: Token): UpdateExpression;
-export declare function expressionFromLiteral(te: TokenExpression): ExpressionNode | Literal<boolean> | Literal<null> | Literal<undefined>;

package/v8/nodes.js

@@ -1,153 +1,2 @@
-import { Token } from './token.js';
-import { AssignmentExpression } from '../api/operators/assignment.js';
-import { LogicalExpression } from '../api/operators/logical.js';
-import { UnaryExpression } from '../api/operators/unary.js';
-import { ConditionalExpression } from '../api/operators/ternary.js';
-import { SequenceExpression } from '../api/operators/comma.js';
-import { Literal, TrueNode, FalseNode, NullNode, UndefinedNode } from '../api/definition/values.js';
-import { AwaitExpression } from '../api/operators/await.js';
-import { UpdateExpression } from '../api/operators/update.js';
-import { BinaryExpression } from '../api/operators/binary.js';
-export function creteInfixExpression(op, left, right) {
-    switch (op) {
-        case '=':
-        case '+=':
-        case '-=':
-        case '**=':
-        case '/=':
-        case '%=':
-        case '<<=':
-        case '>>=':
-        case '>>>=':
-        case '&=':
-        case '^=':
-        case '|=':
-        case '&&=':
-        case '||=':
-        case '??=':
-            return new AssignmentExpression(op, left, right);
-        case '&&':
-        case '||':
-        case '??':
-            return new LogicalExpression(op, left, right);
-        case '**':
-        case '*':
-        case '/':
-        case '%':
-        case '+':
-        case '-':
-        case '<':
-        case '<=':
-        case '>':
-        case '>=':
-        case 'in':
-        case 'instanceof':
-        case '==':
-        case '!=':
-        case '===':
-        case '!==':
-        case '<<':
-        case '>>':
-        case '>>>':
-        case '&':
-        case '^':
-        case '|':
-        case '>?':
-        case '<?':
-        case '<=>':
-            return new BinaryExpression(op, left, right);
-        default:
-            throw new Error(`Not Supported Operator: ${op}`);
-    }
-}
-export function createTernaryExpression(op, logical, ifTrue, ifFalse) {
-    switch (op) {
-        case '?':
-            return new ConditionalExpression(logical, ifTrue, ifFalse);
-        default:
-            throw new Error(`${op} is not ternary operator`);
-    }
-}
-export function creteCommaExpression(nodes) {
-    return new SequenceExpression(nodes);
-}
-const USELESS_STACK = null; //Object.create(null);
-const ALLOWED_TYPES = ['string', 'number', 'bigint', 'boolean'];
-export function shortcutNumericLiteralBinaryExpression(x, y, op) {
-    const expression = creteInfixExpression(op.getName(), x, y);
-    if (x instanceof Literal && y instanceof Literal) {
-        const typeX = typeof x.getValue();
-        const typeY = typeof y.getValue();
-        if (x === y && ALLOWED_TYPES.indexOf(typeX) > -1) {
-            const result = expression.get(USELESS_STACK);
-            const rawString = `${x.toString()} ${op.getName()} ${x.toString()}`;
-            return new Literal(result, rawString);
-        }
-    }
-    return expression;
-}
-export function coverValue(value) {
-    switch (typeof value) {
-        case 'undefined': return UndefinedNode;
-        case 'boolean': return value ? TrueNode : FalseNode;
-        case 'number':
-        case 'bigint':
-        case 'string':
-            return new Literal(value);
-        case 'object':
-            if (value === null) {
-                return NullNode;
-            }
-        // never reach
-        case 'function':
-        case 'symbol':
-        default:
-            return false;
-    }
-}
-export function buildUnaryExpression(expression, op) {
-    const name = op.getName();
-    switch (name) {
-        case '++':
-        case '--':
-            return new UpdateExpression(name, expression, true);
-        case '+':
-        case '-':
-        case '!':
-        case '~':
-        case 'typeof':
-        case 'void':
-        case 'delete':
-            return new UnaryExpression(name, expression);
-        case 'await':
-            return new AwaitExpression(expression);
-        default:
-            throw new Error(`${op} is not prefix operator`);
-    }
-}
-export function buildPostfixExpression(expression, op) {
-    const name = op.getName();
-    switch (name) {
-        case '++':
-        case '--':
-            return new UpdateExpression(name, expression, false);
-        default:
-            throw new Error(`${op} is not postfix operator`);
-    }
-}
-export function expressionFromLiteral(te) {
-    switch (te.token) {
-        case Token.NUMBER:
-        case Token.BIGINT:
-        case Token.STRING:
-        case Token.REGEXP_LITERAL:
-        case Token.IDENTIFIER:
-            return te.getValue();
-        case Token.NULL_LITERAL: return NullNode;
-        case Token.TRUE_LITERAL: return TrueNode;
-        case Token.FALSE_LITERAL: return FalseNode;
-        default:
-        case Token.UNDEFINED_LITERAL: return UndefinedNode;
-    }
-}
+"use strict";
 //# sourceMappingURL=nodes.js.map

package/v8/nodes.js.map

@@ -1 +1 @@
-{"version":3,"file":"nodes.js","sourceRoot":"","sources":["../../../src/expressions/v8/nodes.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ExpressionNode } from '../api/expression.js';\nimport type { Stack } from '../scope/stack.js';\nimport { Token, TokenExpression } from './token.js';\nimport { AssignmentExpression } from '../api/operators/assignment.js';\nimport { LogicalExpression } from '../api/operators/logical.js';\nimport { UnaryExpression } from '../api/operators/unary.js';\nimport { ConditionalExpression } from '../api/operators/ternary.js';\nimport { SequenceExpression } from '../api/operators/comma.js';\nimport { Literal, TrueNode, FalseNode, NullNode, UndefinedNode } from '../api/definition/values.js';\nimport { AwaitExpression } from '../api/operators/await.js';\nimport { UpdateExpression } from '../api/operators/update.js';\nimport { BinaryExpression } from '../api/operators/binary.js';\n\nexport function creteInfixExpression(op: string, left: ExpressionNode, right: ExpressionNode): ExpressionNode {\n\tswitch (op) {\n\t\tcase '=':\n\t\tcase '+=':\n\t\tcase '-=':\n\t\tcase '**=':\n\t\tcase '/=':\n\t\tcase '%=':\n\t\tcase '<<=':\n\t\tcase '>>=':\n\t\tcase '>>>=':\n\t\tcase '&=':\n\t\tcase '^=':\n\t\tcase '|=':\n\t\tcase '&&=':\n\t\tcase '||=':\n\t\tcase '??=':\n\t\t\treturn new AssignmentExpression(op, left, right);\n\t\tcase '&&':\n\t\tcase '||':\n\t\tcase '??':\n\t\t\treturn new LogicalExpression(op, left, right);\n\t\tcase '**':\n\t\tcase '*':\n\t\tcase '/':\n\t\tcase '%':\n\t\tcase '+':\n\t\tcase '-':\n\t\tcase '<':\n\t\tcase '<=':\n\t\tcase '>':\n\t\tcase '>=':\n\t\tcase 'in':\n\t\tcase 'instanceof':\n\t\tcase '==':\n\t\tcase '!=':\n\t\tcase '===':\n\t\tcase '!==':\n\t\tcase '<<':\n\t\tcase '>>':\n\t\tcase '>>>':\n\t\tcase '&':\n\t\tcase '^':\n\t\tcase '|':\n\t\tcase '>?':\n\t\tcase '<?':\n\t\tcase '<=>':\n\t\t\treturn new BinaryExpression(op, left, right);\n\t\tdefault:\n\t\t\tthrow new Error(`Not Supported Operator: ${op}`);\n\t}\n}\n\nexport function createTernaryExpression(op: string, logical: ExpressionNode, ifTrue: ExpressionNode, ifFalse: ExpressionNode): ExpressionNode {\n\tswitch (op) {\n\t\tcase '?':\n\t\t\treturn new ConditionalExpression(logical, ifTrue, ifFalse);\n\t\tdefault:\n\t\t\tthrow new Error(`${op} is not ternary operator`);\n\n\t}\n}\n\nexport function creteCommaExpression(nodes: ExpressionNode[]): ExpressionNode {\n\treturn new SequenceExpression(nodes);\n}\n\nconst USELESS_STACK: Stack = null as unknown as Stack;//Object.create(null);\nconst ALLOWED_TYPES = ['string', 'number', 'bigint', 'boolean'];\n\nexport function shortcutNumericLiteralBinaryExpression(x: ExpressionNode, y: ExpressionNode, op: Token): ExpressionNode {\n\tconst expression = creteInfixExpression(op.getName(), x, y);\n\n\tif (x instanceof Literal && y instanceof Literal) {\n\t\tconst typeX = typeof x.getValue();\n\t\tconst typeY = typeof y.getValue();\n\t\tif (x === y && ALLOWED_TYPES.indexOf(typeX) > -1) {\n\t\t\tconst result = expression.get(USELESS_STACK);\n\t\t\tconst rawString = `${x.toString()} ${op.getName()} ${x.toString()}`;\n\t\t\treturn new Literal<any>(result, rawString);\n\t\t}\n\t}\n\treturn expression!;\n}\nexport function coverValue(value: any) {\n\tswitch (typeof value) {\n\t\tcase 'undefined': return UndefinedNode;\n\t\tcase 'boolean': return value ? TrueNode : FalseNode;\n\t\tcase 'number':\n\t\tcase 'bigint':\n\t\tcase 'string':\n\t\t\treturn new Literal<number | string | bigint>(value);\n\t\tcase 'object':\n\t\t\tif (value === null) {\n\t\t\t\treturn NullNode;\n\t\t\t}\n\t\t// never reach\n\t\tcase 'function':\n\t\tcase 'symbol':\n\t\tdefault:\n\t\t\treturn false;\n\t}\n}\n\nexport function buildUnaryExpression(expression: ExpressionNode, op: Token) {\n\tconst name = op.getName();\n\tswitch (name) {\n\t\tcase '++':\n\t\tcase '--':\n\t\t\treturn new UpdateExpression(name, expression, true);\n\t\tcase '+':\n\t\tcase '-':\n\t\tcase '!':\n\t\tcase '~':\n\t\tcase 'typeof':\n\t\tcase 'void':\n\t\tcase 'delete':\n\t\t\treturn new UnaryExpression(name, expression);\n\t\tcase 'await':\n\t\t\treturn new AwaitExpression(expression);\n\t\tdefault:\n\t\t\tthrow new Error(`${op} is not prefix operator`);\n\t}\n}\n\nexport function buildPostfixExpression(expression: ExpressionNode, op: Token) {\n\tconst name = op.getName();\n\tswitch (name) {\n\t\tcase '++':\n\t\tcase '--':\n\t\t\treturn new UpdateExpression(name, expression, false);\n\t\tdefault:\n\t\t\tthrow new Error(`${op} is not postfix operator`);\n\t}\n}\n\nexport function expressionFromLiteral(te: TokenExpression) {\n\tswitch (te.token) {\n\t\tcase Token.NUMBER:\n\t\tcase Token.BIGINT:\n\t\tcase Token.STRING:\n\t\tcase Token.REGEXP_LITERAL:\n\t\tcase Token.IDENTIFIER:\n\t\t\treturn te.getValue();\n\n\t\tcase Token.NULL_LITERAL: return NullNode;\n\t\tcase Token.TRUE_LITERAL: return TrueNode;\n\t\tcase Token.FALSE_LITERAL: return FalseNode;\n\t\tdefault:\n\t\tcase Token.UNDEFINED_LITERAL: return UndefinedNode;\n\t}\n}\n"]}
+{"version":3,"file":"nodes.js","sourceRoot":"","sources":["../../../src/expressions/v8/nodes.ts"],"names":[],"mappings":"","sourcesContent":["\n"]}

package/v8/parser.d.ts

@@ -1,17 +1,21 @@
 import type { ExpressionNode } from '../api/expression.js';
-import { InlineParserOptions, JavaScriptInlineParser } from './inline.js';
-import { TokenExpression } from './token.js';
+import type { NodeFactory } from './node.js';
 import { Class, ClassBody, ClassDeclaration, ClassExpression, MethodDefinition, PropertyDefinition, StaticBlock } from '../api/class/class.js';
 import { Identifier, Literal } from '../api/definition/values.js';
-import { VariableDeclarationNode } from '../api/statement/declarations/declares.js';
-import { TokenStream } from './stream.js';
+import { ImportAttribute } from '../api/module/common.js';
 import { ExportDefaultDeclaration, ExportSpecifier } from '../api/module/export.js';
 import { ImportSpecifier } from '../api/module/import.js';
-import { ImportAttribute } from '../api/module/common.js';
+import { Program } from '../api/program.js';
 import { ClassInfo, ClassLiteralPropertyKind, PropertyKindInfo, VariableDeclarationContext } from './enums.js';
+import { InlineParserOptions, JavaScriptInlineParser, PositionMark } from './inline.js';
+import { TokenStream } from './stream.js';
+import { TokenExpression } from './token.js';
+import { WithStatement } from '../api/statement/control/with.js';
 import { LanguageMode } from './language.js';
-export declare type ParserOptions = {
+export type ParserOptions = {
     mode?: LanguageMode;
+    factory?: NodeFactory;
+    addLocation?: boolean;
 };
 export declare class JavaScriptParser extends JavaScriptInlineParser {
     /**
@@ -19,15 +23,15 @@ export declare class JavaScriptParser extends JavaScriptInlineParser {
      * @param source
      * @returns
      */
-    static parse(source: string | TokenExpression[] | TokenStream, { mode }?: ParserOptions): ExpressionNode;
+    static parse(source: string | TokenExpression[] | TokenStream, { mode, factory, addLocation }?: ParserOptions): Program;
     /**
      * parse inline code like that used in html 2 or 1 way binding
      */
-    static parseScript(source: string | TokenExpression[] | TokenStream, options?: InlineParserOptions): ExpressionNode;
-    scan(): ExpressionNode;
-    protected parseNewTargetExpression(): ExpressionNode;
+    static parseScript<T extends ExpressionNode>(source: string | TokenExpression[] | TokenStream, options?: InlineParserOptions): T;
+    scan(): Program;
+    protected parseNewTargetExpression(start?: PositionMark): ExpressionNode;
     protected parseClassExpression(): ClassExpression;
-    protected parseClassDeclaration(names: string[] | undefined, defaultExport: boolean): ClassDeclaration;
+    protected parseClassDeclaration(names: string[] | undefined, defaultExport: boolean, start: PositionMark): ClassDeclaration;
     protected parseClassLiteral(name: ExpressionNode | undefined, nameIsStrictReserved: boolean): Class;
     protected declarePublicClassMethod(name: ExpressionNode | undefined, property: MethodDefinition, isConstructor: boolean, classInfo: ClassInfo): void;
     protected declarePublicClassField(property: PropertyDefinition, isStatic: boolean, isComputedName: boolean, classInfo: ClassInfo): void;
@@ -35,24 +39,23 @@ export declare class JavaScriptParser extends JavaScriptInlineParser {
     protected parseClassPropertyDefinition(classInfo: ClassInfo, propInfo: PropertyKindInfo, hasExtends: boolean): ExpressionNode | Literal<null> | MethodDefinition | PropertyDefinition;
     protected checkClassMethodName(propInfo: PropertyKindInfo, classInfo: ClassInfo): void;
     protected parseClassStaticBlock(classInfo: ClassInfo): StaticBlock;
-    protected declareClass(variableName: string, value: ExpressionNode, names: string[] | undefined): ExpressionNode;
-    protected declareVariable(name: string, mode: 'let' | 'const' | 'var'): VariableDeclarationNode;
-    protected newClassLiteralProperty(nameExpression: ExpressionNode, initializer: ExpressionNode | undefined, kind: ClassLiteralPropertyKind, isStatic: boolean, isComputedName: boolean, isPrivate: boolean): MethodDefinition | PropertyDefinition;
+    protected newClassLiteralProperty(nameExpression: ExpressionNode, initializer: ExpressionNode | undefined, kind: ClassLiteralPropertyKind, isStatic: boolean, isComputedName: boolean, isPrivate: boolean, start: PositionMark): MethodDefinition | PropertyDefinition;
     protected parseMemberInitializer(classInfo: ClassInfo, isStatic: boolean): ExpressionNode | undefined;
     protected setFunctionNameFromPropertyName(property: ExpressionNode, name: string, prefix?: string): void;
     protected parseSuperExpression(): ExpressionNode;
-    protected rewriteClassLiteral(classInfo: ClassInfo, name?: ExpressionNode): ClassBody;
+    protected rewriteClassLiteral(classInfo: ClassInfo, name?: ExpressionNode, range?: [number, number]): ClassBody;
     protected parseModuleItemList(): ExpressionNode[];
     protected parseModuleItem(): ExpressionNode | undefined;
     protected parseExportDeclaration(): ExpressionNode | undefined;
     protected parseImportDeclaration(): ExpressionNode | undefined;
     protected parseImportExpressions(): ExpressionNode;
-    protected parseVariableStatement(varContext: VariableDeclarationContext, names: string[]): VariableDeclarationNode;
+    protected parseVariableStatement(varContext: VariableDeclarationContext, names: string[]): import("../index.js").VariableDeclarationNode;
     protected parseImportAssertClause(): ImportAttribute[] | undefined;
     protected parseModuleSpecifier(): Literal<string>;
     protected parseExportClause(): ExportSpecifier[];
     protected parseExportSpecifierName(): Identifier | Literal<string>;
     protected parseNamedImports(): ImportSpecifier[];
-    protected parseExportDefault(): ExportDefaultDeclaration;
-    protected parseExportStar(): ExpressionNode | undefined;
+    protected parseExportDefault(start: PositionMark): ExportDefaultDeclaration;
+    protected parseExportStar(start: PositionMark): ExpressionNode | undefined;
+    protected parseWithStatement(): WithStatement;
 }