@ibyar/expressions 0.8.3 → 0.8.5

package/v8/parser.js

@@ -1,27 +1,26 @@
+import { Class } from '../api/class/class.js';
+import { Literal } from '../api/definition/values.js';
+import { ClassLiteralProperty, ClassLiteralPropertyKind, classPropertyKindFor, createClassInfo, FunctionKind, FunctionSyntaxKind, isAccessor, ParseFunctionFlag, PropertyKind, PropertyKindInfo, PropertyPosition, VariableDeclarationContext } from './enums.js';
 import { JavaScriptInlineParser } from './inline.js';
-import { Token } from './token.js';
-import { Class, ClassBody, ClassDeclaration, ClassExpression, MetaProperty, MethodDefinition, PropertyDefinition, StaticBlock, Super } from '../api/class/class.js';
-import { Identifier, Literal, NullNode } from '../api/definition/values.js';
-import { AssignmentExpression } from '../api/operators/assignment.js';
-import { VariableDeclarationNode, VariableDeclarator } from '../api/statement/declarations/declares.js';
 import { TokenStream } from './stream.js';
-import { Program } from '../api/program.js';
-import { ExportAllDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, ExportSpecifier } from '../api/module/export.js';
-import { ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportSpecifier } from '../api/module/import.js';
-import { ImportAttribute } from '../api/module/common.js';
-import { ClassLiteralProperty, ClassLiteralPropertyKind, classPropertyKindFor, createClassInfo, FunctionKind, FunctionSyntaxKind, isAccessor, ParseFunctionFlag, PropertyKind, PropertyKindInfo, PropertyPosition, VariableDeclarationContext } from './enums.js';
-import { isStrict, LanguageMode, } from './language.js';
+import { Token } from './token.js';
+import { ExpressionNodeFactory, ExpressionNodeSourcePosition } from './factory.js';
+import { isStrict, LanguageMode } from './language.js';
 export class JavaScriptParser extends JavaScriptInlineParser {
     /**
      * parser js with
      * @param source
      * @returns
      */
-    static parse(source, { mode } = {}) {
+    static parse(source, { mode, factory, addLocation } = {}) {
         mode ?? (mode = LanguageMode.Strict);
         const stream = (typeof source === 'string') || Array.isArray(source)
             ? TokenStream.getTokenStream(source, mode) : source;
-        const parser = new JavaScriptParser(stream);
+        if (factory == undefined) {
+            const sourcePositionFactory = addLocation && typeof source === 'string' ? new ExpressionNodeSourcePosition(source) : undefined;
+            factory = new ExpressionNodeFactory(sourcePositionFactory);
+        }
+        const parser = new JavaScriptParser(stream, factory, false);
         return parser.scan();
     }
     /**
@@ -31,20 +30,22 @@ export class JavaScriptParser extends JavaScriptInlineParser {
         return JavaScriptInlineParser.parse(source, options);
     }
     scan() {
+        const range = this.createStartPosition();
         const isModule = isStrict(this.languageMode);
         if (isModule) {
             this.setFunctionKind(FunctionKind.Module);
         }
         const body = isModule ? this.parseModuleItemList() : this.parseStatementList(Token.EOS);
-        return new Program(isModule ? 'module' : 'script', body);
+        this.updateRangeEnd(range);
+        return this.factory.createProgram(isModule ? 'module' : 'script', body, range);
     }
-    parseNewTargetExpression() {
+    parseNewTargetExpression(start) {
         this.consume(Token.PERIOD);
         const target = this.parsePropertyOrPrivatePropertyName();
         if (target.toString() !== 'target') {
             throw new Error(this.errorMessage(`Expression (new.${target.toString()}) not supported.`));
         }
-        return MetaProperty.NewTarget;
+        return this.factory.createMetaProperty(this.factory.createIdentifier('new', start?.range), this.factory.createIdentifier('target', target.range), this.createRange(start));
     }
     parseClassExpression() {
         this.consume(Token.CLASS);
@@ -55,9 +56,9 @@ export class JavaScriptParser extends JavaScriptInlineParser {
             isStrictReserved = Token.isStrictReservedWord(this.current().token);
         }
         const classLiteral = this.parseClassLiteral(name, isStrictReserved);
-        return new ClassExpression(classLiteral.getBody(), classLiteral.getDecorators(), classLiteral.getId(), classLiteral.getSuperClass());
+        return this.factory.createClassExpression(classLiteral.getBody(), classLiteral.getDecorators(), classLiteral.getId(), classLiteral.getSuperClass());
     }
-    parseClassDeclaration(names, defaultExport) {
+    parseClassDeclaration(names, defaultExport, start) {
         // ClassDeclaration ::
         //   'class' Identifier ('extends' LeftHandExpression)? '{' ClassBody '}'
         //   'class' ('extends' LeftHandExpression)? '{' ClassBody '}'
@@ -89,7 +90,8 @@ export class JavaScriptParser extends JavaScriptInlineParser {
             name = identifier;
         }
         const classLiteral = this.parseClassLiteral(name, isStrictReserved);
-        return new ClassDeclaration(classLiteral.getBody(), classLiteral.getDecorators(), classLiteral.getId(), classLiteral.getSuperClass());
+        const range = this.createRange(start);
+        return this.factory.createClassDeclaration(classLiteral.getBody(), classLiteral.getDecorators(), classLiteral.getId(), classLiteral.getSuperClass(), range);
     }
     parseClassLiteral(name, nameIsStrictReserved) {
         const isAnonymous = !!!name;
@@ -107,7 +109,7 @@ export class JavaScriptParser extends JavaScriptInlineParser {
         if (this.check(Token.EXTENDS)) {
             classInfo.extends = this.parseLeftHandSideExpression();
         }
-        this.expect(Token.LBRACE);
+        const bodyStart = this.expect(Token.LBRACE);
         const hasExtends = !!classInfo.extends;
         while (this.peek().isNotType(Token.RBRACE)) {
             if (this.check(Token.SEMICOLON))
@@ -153,8 +155,8 @@ export class JavaScriptParser extends JavaScriptInlineParser {
             }
             this.declarePublicClassMethod(name, property, isConstructor, classInfo);
         }
-        this.expect(Token.RBRACE);
-        const classBody = this.rewriteClassLiteral(classInfo, name);
+        const bodyEnd = this.expect(Token.RBRACE);
+        const classBody = this.rewriteClassLiteral(classInfo, name, [bodyStart.range[0], bodyEnd.range[1]]);
         return new Class(classBody, [], name, classInfo.extends);
     }
     declarePublicClassMethod(name, property, isConstructor, classInfo) {
@@ -237,7 +239,7 @@ export class JavaScriptParser extends JavaScriptInlineParser {
                 // }
                 const initializer = this.parseMemberInitializer(classInfo, propInfo.isStatic);
                 this.expectSemicolon();
-                const result = this.newClassLiteralProperty(nameExpression, initializer, ClassLiteralPropertyKind.FIELD, propInfo.isStatic, propInfo.isComputedName, propInfo.isPrivate);
+                const result = this.newClassLiteralProperty(nameExpression, initializer, ClassLiteralPropertyKind.FIELD, propInfo.isStatic, propInfo.isComputedName, propInfo.isPrivate, propInfo.rangeStart);
                 this.setFunctionNameFromPropertyName(result, propInfo.name);
                 return result;
             }
@@ -257,8 +259,8 @@ export class JavaScriptParser extends JavaScriptInlineParser {
                     classInfo.hasSeenConstructor = true;
                     kind = hasExtends ? FunctionKind.DerivedConstructor : FunctionKind.BaseConstructor;
                 }
-                const value = this.parseFunctionLiteral(kind, FunctionSyntaxKind.AccessorOrMethod, nameExpression);
-                const result = this.newClassLiteralProperty(nameExpression, value, ClassLiteralProperty.Kind.METHOD, propInfo.isStatic, propInfo.isComputedName, propInfo.isPrivate);
+                const value = this.parseFunctionLiteral(kind, FunctionSyntaxKind.AccessorOrMethod, nameExpression, propInfo.rangeStart);
+                const result = this.newClassLiteralProperty(nameExpression, value, ClassLiteralProperty.Kind.METHOD, propInfo.isStatic, propInfo.isComputedName, propInfo.isPrivate, propInfo.rangeStart);
                 this.setFunctionNameFromPropertyName(result, propInfo.name);
                 return result;
             }
@@ -284,9 +286,9 @@ export class JavaScriptParser extends JavaScriptInlineParser {
                     kind = isGet ? FunctionKind.GetterFunction
                         : FunctionKind.SetterFunction;
                 }
-                const value = this.parseFunctionLiteral(kind, FunctionSyntaxKind.AccessorOrMethod, nameExpression);
+                const value = this.parseFunctionLiteral(kind, FunctionSyntaxKind.AccessorOrMethod, nameExpression, propInfo.rangeStart);
                 const propertyKind = isGet ? ClassLiteralProperty.Kind.GETTER : ClassLiteralProperty.Kind.SETTER;
-                const result = this.newClassLiteralProperty(nameExpression, value, propertyKind, propInfo.isStatic, propInfo.isComputedName, propInfo.isPrivate);
+                const result = this.newClassLiteralProperty(nameExpression, value, propertyKind, propInfo.isStatic, propInfo.isComputedName, propInfo.isPrivate, propInfo.rangeStart);
                 const prefix = isGet ? 'get ' : 'set ';
                 this.setFunctionNameFromPropertyName(result, propInfo.name, prefix);
                 return result;
@@ -295,7 +297,7 @@ export class JavaScriptParser extends JavaScriptInlineParser {
             case PropertyKind.Shorthand:
             case PropertyKind.Spread:
                 // throw new Error(this.errorMessage('Report Unexpected Token'));
-                return NullNode;
+                return this.factory.createNull(propInfo.rangeStart?.range);
         }
         throw new Error(this.errorMessage('UNREACHABLE'));
     }
@@ -333,29 +335,22 @@ export class JavaScriptParser extends JavaScriptInlineParser {
         const block = this.parseBlock();
         this.restoreStatue();
         classInfo.hasStaticElements = true;
-        return new StaticBlock(block.getBody());
-    }
-    declareClass(variableName, value, names) {
-        names?.push(variableName);
-        const proxy = this.declareVariable(variableName, 'let');
-        return new AssignmentExpression('=', proxy, value);
-    }
-    declareVariable(name, mode) {
-        return new VariableDeclarationNode([new VariableDeclarator(new Identifier(name))], mode);
+        return this.factory.createClassStaticBlockDeclaration(block.getBody(), block.range);
     }
-    newClassLiteralProperty(nameExpression, initializer, kind, isStatic, isComputedName, isPrivate) {
+    newClassLiteralProperty(nameExpression, initializer, kind, isStatic, isComputedName, isPrivate, start) {
+        const range = this.createRange(start);
         switch (kind) {
             case ClassLiteralPropertyKind.METHOD:
                 if (nameExpression.toString() === 'constructor') {
-                    return new MethodDefinition('constructor', nameExpression, initializer, [], isComputedName, isStatic);
+                    return this.factory.createMethodSignature('constructor', nameExpression, initializer, [], isComputedName, isStatic, range);
                 }
-                return new MethodDefinition('method', nameExpression, initializer, [], isComputedName, isStatic);
+                return this.factory.createMethodSignature('method', nameExpression, initializer, [], isComputedName, isStatic, range);
             case ClassLiteralPropertyKind.GETTER:
-                return new MethodDefinition('get', nameExpression, initializer, [], isComputedName, isStatic);
+                return this.factory.createMethodSignature('get', nameExpression, initializer, [], isComputedName, isStatic, range);
             case ClassLiteralPropertyKind.SETTER:
-                return new MethodDefinition('set', nameExpression, initializer, [], isComputedName, isStatic);
+                return this.factory.createMethodSignature('set', nameExpression, initializer, [], isComputedName, isStatic, range);
             case ClassLiteralPropertyKind.FIELD:
-                return new PropertyDefinition(nameExpression, [], isComputedName, isStatic, initializer);
+                return this.factory.createPropertySignature(nameExpression, [], isComputedName, isStatic, initializer, range);
             default:
                 break;
         }
@@ -385,7 +380,7 @@ export class JavaScriptParser extends JavaScriptInlineParser {
         // the ClassExpression* handle this
     }
     parseSuperExpression() {
-        this.consume(Token.SUPER);
+        const superToken = this.consume(Token.SUPER);
         if (Token.isProperty(this.peek().token)) {
             if (this.peek().isType(Token.PERIOD) && this.peekAhead().isType(Token.PRIVATE_NAME)) {
                 this.consume(Token.PERIOD);
@@ -396,11 +391,11 @@ export class JavaScriptParser extends JavaScriptInlineParser {
                 this.consume(Token.QUESTION_PERIOD);
                 throw new Error(this.errorMessage('Optional Chaining No Super'));
             }
-            return Super.INSTANCE;
+            return this.factory.createSuper(superToken.range);
         }
         throw new Error(this.errorMessage('Unexpected Super'));
     }
-    rewriteClassLiteral(classInfo, name) {
+    rewriteClassLiteral(classInfo, name, range) {
         const body = [];
         if (classInfo.hasSeenConstructor) {
             body.push(classInfo.constructor);
@@ -409,7 +404,7 @@ export class JavaScriptParser extends JavaScriptInlineParser {
         body.push(...classInfo.instanceFields);
         body.push(...classInfo.publicMembers);
         body.push(...classInfo.privateMembers);
-        return new ClassBody(body);
+        return this.factory.createClassBody(body, range);
     }
     parseModuleItemList() {
         // ecma262/#prod-Module
@@ -425,7 +420,7 @@ export class JavaScriptParser extends JavaScriptInlineParser {
             if (!stat) {
                 break;
             }
-            if (this.isEmptyStatement(stat)) {
+            if (this.factory.isEmptyStatement(stat)) {
                 continue;
             }
             body.push(stat);
@@ -473,7 +468,7 @@ export class JavaScriptParser extends JavaScriptInlineParser {
         //
         // ModuleExportName :
         //   StringLiteral
-        this.expect(Token.EXPORT);
+        const start = this.expect(Token.EXPORT);
         let result;
         const names = [];
         // Statement * result = nullptr;
@@ -481,9 +476,9 @@ export class JavaScriptParser extends JavaScriptInlineParser {
         // Scanner::Location loc = scanner() -> peek_location();
         switch (this.peek().token) {
             case Token.DEFAULT:
-                return this.parseExportDefault();
+                return this.parseExportDefault(start);
             case Token.MUL:
-                return this.parseExportStar();
+                return this.parseExportStar(start);
             case Token.LBRACE: {
                 // There are two cases here:
                 //
@@ -535,20 +530,22 @@ export class JavaScriptParser extends JavaScriptInlineParser {
                     // 		zone());
                     // }
                 }
-                return new ExportNamedDeclaration(exportData, undefined, moduleSpecifier, importAssertions);
+                return this.factory.createNamespaceExportDeclaration(exportData, undefined, moduleSpecifier, importAssertions, this.createRange(start));
                 // return factory() -> EmptyStatement();
             }
             case Token.FUNCTION: {
                 const declaration = this.parseFunctionDeclaration();
                 const identifier = declaration.getId();
-                result = new ExportNamedDeclaration([new ExportSpecifier(identifier, identifier)], declaration);
+                const specifier = this.factory.createExportSpecifier(identifier, identifier, identifier.range);
+                result = this.factory.createNamespaceExportDeclaration([specifier], declaration, undefined, undefined, this.createRange(start));
                 break;
             }
             case Token.CLASS: {
-                this.consume(Token.CLASS);
-                const declaration = this.parseClassDeclaration(names, false);
+                const classToken = this.consume(Token.CLASS);
+                const declaration = this.parseClassDeclaration(names, false, classToken);
                 const identifier = declaration.getId();
-                result = new ExportNamedDeclaration([new ExportSpecifier(identifier, identifier)], declaration);
+                const specifier = this.factory.createExportSpecifier(identifier, identifier, identifier.range);
+                result = this.factory.createNamespaceExportDeclaration([specifier], declaration, undefined, undefined, this.createRange(start));
                 break;
             }
             case Token.VAR:
@@ -556,15 +553,16 @@ export class JavaScriptParser extends JavaScriptInlineParser {
             case Token.CONST:
                 const declaration = this.parseVariableStatement(VariableDeclarationContext.StatementListItem, names);
                 const specifiers = declaration.getDeclarations()
-                    .map(node => new ExportSpecifier(node.getId(), node.getId()));
-                result = new ExportNamedDeclaration(specifiers, declaration);
+                    .map(node => this.factory.createExportSpecifier(node.getId(), node.getId(), node.getId().range));
+                result = this.factory.createNamespaceExportDeclaration(specifiers, declaration, undefined, undefined, this.createRange(start));
                 break;
             case Token.ASYNC:
-                this.consume(Token.ASYNC);
+                const asyncToken = this.consume(Token.ASYNC);
                 if (this.peek().isType(Token.FUNCTION) && !this.scanner.hasLineTerminatorBeforeNext()) {
-                    const declaration = this.parseAsyncFunctionDeclaration(names, false);
+                    const declaration = this.parseAsyncFunctionDeclaration(names, false, asyncToken);
                     const identifier = declaration.getId();
-                    result = new ExportNamedDeclaration([new ExportSpecifier(identifier, identifier)], declaration);
+                    const specifier = this.factory.createExportSpecifier(identifier, identifier, identifier.range);
+                    result = this.factory.createNamespaceExportDeclaration([specifier], declaration, undefined, undefined, this.createRange(start));
                     break;
                 }
             default:
@@ -594,7 +592,7 @@ export class JavaScriptParser extends JavaScriptInlineParser {
         //
         // NameSpaceImport :
         //   '*' 'as' ImportedBinding
-        this.expect(Token.IMPORT);
+        const start = this.expect(Token.IMPORT);
         const tok = this.peek();
         // 'import' ModuleSpecifier ';'
         if (tok.isType(Token.STRING)) {
@@ -603,7 +601,7 @@ export class JavaScriptParser extends JavaScriptInlineParser {
             const importAssertions = this.parseImportAssertClause();
             this.expectSemicolon();
             // module() -> AddEmptyImport(module_specifier, import_assertions, specifier_loc,zone());
-            return new ImportDeclaration(moduleSpecifier, undefined, importAssertions);
+            return this.factory.createImportDeclaration(moduleSpecifier, undefined, importAssertions, this.createRange(start));
         }
         // Parse ImportedDefaultBinding if present.
         let importDefaultBinding;
@@ -650,21 +648,22 @@ export class JavaScriptParser extends JavaScriptInlineParser {
         // Declare that takes a location?
         const specifiers = [];
         if (moduleNamespaceBinding) {
-            specifiers.push(new ImportNamespaceSpecifier(moduleNamespaceBinding));
+            specifiers.push(this.factory.createImportNamespaceSpecifier(moduleNamespaceBinding, moduleNamespaceBinding.range));
         }
         if (importDefaultBinding) {
-            specifiers.push(new ImportDefaultSpecifier(importDefaultBinding));
+            specifiers.push(this.factory.createImportDefaultSpecifier(importDefaultBinding, importDefaultBinding.range));
         }
         if (namedImports?.length) {
             specifiers.push(...namedImports);
         }
-        return new ImportDeclaration(moduleSpecifier, specifiers.length ? specifiers : undefined, importAssertions);
+        return this.factory.createImportDeclaration(moduleSpecifier, specifiers.length ? specifiers : undefined, importAssertions, this.createRange(start));
     }
     parseImportExpressions() {
-        this.consume(Token.IMPORT);
+        const start = this.consume(Token.IMPORT);
         if (this.check(Token.PERIOD)) {
+            const peek = this.peek();
             this.expectContextualKeyword('meta');
-            return MetaProperty.ImportMeta;
+            return this.factory.createMetaProperty(this.factory.createIdentifier('import', start.range), this.factory.createIdentifier('meta', peek.range), this.createRange(start));
         }
         if (this.peek().isNotType(Token.LPAREN)) {
             throw new SyntaxError(this.errorMessage('Unexpected Token'));
@@ -678,19 +677,19 @@ export class JavaScriptParser extends JavaScriptInlineParser {
         if (this.check(Token.COMMA)) {
             if (this.check(Token.RPAREN)) {
                 // A trailing comma allowed after the specifier.
-                return new ImportExpression(specifier);
+                return this.factory.createImportExpression(specifier, undefined, this.createRange(start));
             }
             else {
                 const importAssertions = this.parseAssignmentExpressionCoverGrammar();
                 this.check(Token.COMMA); // A trailing comma is allowed after the import
                 // assertions.
                 this.expect(Token.RPAREN);
-                return new ImportExpression(specifier, importAssertions);
+                return this.factory.createImportExpression(specifier, importAssertions, this.createRange(start));
             }
         }
         this.expect(Token.RPAREN);
         this.restoreAcceptIN();
-        return new ImportExpression(specifier);
+        return this.factory.createImportExpression(specifier, undefined, this.createRange(start));
     }
     parseVariableStatement(varContext, names) {
         // VariableStatement ::
@@ -739,7 +738,7 @@ export class JavaScriptParser extends JavaScriptInlineParser {
             }
             this.expect(Token.COLON);
             const attributeValue = this.expectAndGetValue(Token.STRING);
-            importAssertions.push(new ImportAttribute(attributeKey, attributeValue));
+            importAssertions.push(this.factory.createAssertEntry(attributeKey, attributeValue, this.createRange(attributeKey)));
             counts[attributeKey.toString()] = (counts[attributeKey.toString()] ?? 0) + 1;
             if (counts[attributeKey.toString()] > 1) {
                 // 	// It is a syntax error if two AssertEntries have the same key.
@@ -791,7 +790,7 @@ export class JavaScriptParser extends JavaScriptInlineParser {
             else {
                 exportName = localName;
             }
-            exportData.push(new ExportSpecifier(exportName, localName));
+            exportData.push(this.factory.createExportSpecifier(exportName, localName));
             if (this.peek().isType(Token.RBRACE))
                 break;
             if (!this.check(Token.COMMA)) {
@@ -846,7 +845,7 @@ export class JavaScriptParser extends JavaScriptInlineParser {
             else if (this.isEvalOrArguments(localName)) {
                 throw new SyntaxError(this.errorMessage('Strict Eval Arguments'));
             }
-            result.push(new ImportSpecifier(localName, importName));
+            result.push(this.factory.createImportSpecifier(localName, importName, this.createRange(importName)));
             // DeclareUnboundVariable(localName, VariableMode:: kConst, kNeedsInitialization, position());
             // NamedImport * import = zone() -> New<NamedImport>(import_name, local_name, location);
             // result-> Add(import, zone());
@@ -857,7 +856,7 @@ export class JavaScriptParser extends JavaScriptInlineParser {
         this.expect(Token.RBRACE);
         return result;
     }
-    parseExportDefault() {
+    parseExportDefault(start) {
         //  Supports the following productions, starting after the 'default' token:
         //    'export' 'default' HoistableDeclaration
         //    'export' 'default' ClassDeclaration
@@ -869,16 +868,16 @@ export class JavaScriptParser extends JavaScriptInlineParser {
         let result;
         switch (this.peek().token) {
             case Token.FUNCTION:
-                result = this.parseHoistableDeclaration(localNames, true);
+                result = this.parseHoistableDeclaration(localNames, true, this.peek());
                 break;
             case Token.CLASS:
-                this.consume(Token.CLASS);
-                result = this.parseClassDeclaration(localNames, true);
+                const classToken = this.consume(Token.CLASS);
+                result = this.parseClassDeclaration(localNames, true, classToken);
                 break;
             case Token.ASYNC:
                 if (this.peekAhead().isType(Token.FUNCTION) && !this.scanner.hasLineTerminatorBeforeNext()) {
-                    this.consume(Token.ASYNC);
-                    result = this.parseHoistableDeclaration(localNames, true);
+                    const asyncStart = this.consume(Token.ASYNC);
+                    result = this.parseHoistableDeclaration(localNames, true, asyncStart);
                     break;
                 }
             default: {
@@ -904,9 +903,9 @@ export class JavaScriptParser extends JavaScriptInlineParser {
         // 	DCHECK_EQ(localNames.length(), 1);
         // 	module() -> AddExport(localNames.first(), ast_value_factory() -> default_string(), default_loc, zone());
         // }
-        return new ExportDefaultDeclaration(result);
+        return this.factory.createExportDefault(result, this.createRange(start));
     }
-    parseExportStar() {
+    parseExportStar(start) {
         this.consume(Token.MUL);
         if (!this.peekContextualKeyword('as')) {
             // 'export' '*' 'from' ModuleSpecifier ';'
@@ -917,7 +916,7 @@ export class JavaScriptParser extends JavaScriptInlineParser {
             const importAssertions = this.parseImportAssertClause();
             this.expectSemicolon();
             // module() -> AddStarExport(module_specifier, import_assertions, loc,specifier_loc, zone());
-            return new ExportAllDeclaration(moduleSpecifier, undefined, importAssertions);
+            return this.factory.createExportAllDeclaration(moduleSpecifier, undefined, importAssertions, this.createRange(start));
         }
         // 'export' '*' 'as' IdentifierName 'from' ModuleSpecifier ';'
         //
@@ -943,7 +942,21 @@ export class JavaScriptParser extends JavaScriptInlineParser {
         // const specifiers = [new ExportSpecifier(exportName as Identifier, exportName as Identifier)];
         // module() -> AddStarImport(local_name, module_specifier, import_assertions,local_name_loc, specifier_loc, zone());
         // module() -> AddExport(local_name, export_name, export_name_loc, zone());
-        return new ExportAllDeclaration(moduleSpecifier, exportName, importAssertions);
+        return this.factory.createExportAllDeclaration(moduleSpecifier, exportName, importAssertions, this.createRange(start));
+    }
+    parseWithStatement() {
+        // WithStatement ::
+        //   'with' '(' Expression ')' Statement
+        const start = this.consume(Token.WITH);
+        if (isStrict(this.languageMode)) {
+            throw new SyntaxError(this.errorMessage('With is not allowed in Strict mode.'));
+        }
+        this.expect(Token.LPAREN);
+        const object = this.parseExpression();
+        this.expect(Token.RPAREN);
+        const body = this.parseStatement();
+        const range = this.createRange(start);
+        return this.factory.createWithStatement(object, body, range);
     }
 }
 //# sourceMappingURL=parser.js.map