Web Inspector: Upgrade Esprima to the latest one to support dynamic import
authorutatane.tea@gmail.com <utatane.tea@gmail.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 2 Feb 2017 10:31:18 +0000 (10:31 +0000)
committerutatane.tea@gmail.com <utatane.tea@gmail.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 2 Feb 2017 10:31:18 +0000 (10:31 +0000)
https://bugs.webkit.org/show_bug.cgi?id=167698

Reviewed by Joseph Pecoraro.

Source/WebInspectorUI:

* UserInterface/External/Esprima/esprima.js:
Update to Esprima@5307e30 (4.0.0-dev).

* UserInterface/Models/ScriptSyntaxTree.js:
(WebInspector.ScriptSyntaxTree.prototype._gatherIdentifiersInDeclaration.gatherIdentifiers):
(WebInspector.ScriptSyntaxTree.prototype._gatherIdentifiersInDeclaration):
(WebInspector.ScriptSyntaxTree.prototype._recurse):
(WebInspector.ScriptSyntaxTree.prototype._createInternalSyntaxTree):
(WebInspector.ScriptSyntaxTree):
* UserInterface/Workers/Formatter/ESTreeWalker.js:
(ESTreeWalker.prototype._walkChildren):
(ESTreeWalker):
Add new nodes, SpreadProperty, RestProperty, and Import.
SpreadProperty and RestProperty are the part of ES2018 rest and spread properties.
https://github.com/sebmarkbage/ecmascript-rest-spread
Import is dynamic import node. The syntax is similar to Super.
https://github.com/tc39/proposal-dynamic-import

* UserInterface/Workers/Formatter/EsprimaFormatter.js:
(EsprimaFormatter.prototype._handleTokenAtNode):

LayoutTests:

* inspector/formatting/formatting-javascript-expected.txt:
* inspector/formatting/formatting-javascript.html:
* inspector/formatting/resources/javascript-tests/import-expected.js: Added.
(async.load):
* inspector/formatting/resources/javascript-tests/import.js: Added.
(async.load):
* inspector/formatting/resources/javascript-tests/object-array-literal-expected.js:
* inspector/formatting/resources/javascript-tests/object-array-literal.js:
* inspector/formatting/resources/javascript-tests/variable-declaration-expected.js:
* inspector/formatting/resources/javascript-tests/variable-declaration.js:
* inspector/formatting/resources/utilities.js:
(TestPage.registerInitializer.):
(TestPage.registerInitializer):
Fix a bug which occurs when output is not expected one.

* inspector/model/parse-script-syntax-tree-expected.txt:
* inspector/model/parse-script-syntax-tree.html:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@211554 268f45cc-cd09-0410-ab3c-d52691b4dbfc

18 files changed:
LayoutTests/ChangeLog
LayoutTests/inspector/formatting/formatting-javascript-expected.txt
LayoutTests/inspector/formatting/formatting-javascript.html
LayoutTests/inspector/formatting/resources/javascript-tests/import-expected.js [new file with mode: 0644]
LayoutTests/inspector/formatting/resources/javascript-tests/import.js [new file with mode: 0644]
LayoutTests/inspector/formatting/resources/javascript-tests/object-array-literal-expected.js
LayoutTests/inspector/formatting/resources/javascript-tests/object-array-literal.js
LayoutTests/inspector/formatting/resources/javascript-tests/variable-declaration-expected.js
LayoutTests/inspector/formatting/resources/javascript-tests/variable-declaration.js
LayoutTests/inspector/formatting/resources/utilities.js
LayoutTests/inspector/model/parse-script-syntax-tree-expected.txt
LayoutTests/inspector/model/parse-script-syntax-tree.html
Source/WebInspectorUI/ChangeLog
Source/WebInspectorUI/Tools/Formatting/index.html
Source/WebInspectorUI/UserInterface/External/Esprima/esprima.js
Source/WebInspectorUI/UserInterface/Models/ScriptSyntaxTree.js
Source/WebInspectorUI/UserInterface/Workers/Formatter/ESTreeWalker.js
Source/WebInspectorUI/UserInterface/Workers/Formatter/EsprimaFormatter.js

index 376fe2c..6a91bb5 100644 (file)
@@ -1,3 +1,28 @@
+2017-02-01  Yusuke Suzuki  <utatane.tea@gmail.com>
+
+        Web Inspector: Upgrade Esprima to the latest one to support dynamic import
+        https://bugs.webkit.org/show_bug.cgi?id=167698
+
+        Reviewed by Joseph Pecoraro.
+
+        * inspector/formatting/formatting-javascript-expected.txt:
+        * inspector/formatting/formatting-javascript.html:
+        * inspector/formatting/resources/javascript-tests/import-expected.js: Added.
+        (async.load):
+        * inspector/formatting/resources/javascript-tests/import.js: Added.
+        (async.load):
+        * inspector/formatting/resources/javascript-tests/object-array-literal-expected.js:
+        * inspector/formatting/resources/javascript-tests/object-array-literal.js:
+        * inspector/formatting/resources/javascript-tests/variable-declaration-expected.js:
+        * inspector/formatting/resources/javascript-tests/variable-declaration.js:
+        * inspector/formatting/resources/utilities.js:
+        (TestPage.registerInitializer.):
+        (TestPage.registerInitializer):
+        Fix a bug which occurs when output is not expected one.
+
+        * inspector/model/parse-script-syntax-tree-expected.txt:
+        * inspector/model/parse-script-syntax-tree.html:
+
 2017-02-01  Zan Dobersek  <zdobersek@igalia.com>
 
         [EME] Implement MediaKeySession::update()
index 017cc56..2ba5d73 100644 (file)
@@ -29,6 +29,9 @@ PASS
 -- Running test case: EsprimaFormatter.JavaScript.if-statement.js
 PASS
 
+-- Running test case: EsprimaFormatter.JavaScript.import.js
+PASS
+
 -- Running test case: EsprimaFormatter.JavaScript.label-break-continue-block.js
 PASS
 
index 33e12bb..9db6617 100644 (file)
@@ -18,6 +18,7 @@ function test()
         "resources/javascript-tests/functions.js",
         "resources/javascript-tests/generators.js",
         "resources/javascript-tests/if-statement.js",
+        "resources/javascript-tests/import.js",
         "resources/javascript-tests/label-break-continue-block.js",
         "resources/javascript-tests/logic-expressions.js",
         "resources/javascript-tests/new-expression.js",
diff --git a/LayoutTests/inspector/formatting/resources/javascript-tests/import-expected.js b/LayoutTests/inspector/formatting/resources/javascript-tests/import-expected.js
new file mode 100644 (file)
index 0000000..90c4803
--- /dev/null
@@ -0,0 +1,6 @@
+import("./Cocoa.js");
+import(host + "/Cocoa.js");
+
+async function load() {
+    return await import("./Cappuccino.js");
+}
diff --git a/LayoutTests/inspector/formatting/resources/javascript-tests/import.js b/LayoutTests/inspector/formatting/resources/javascript-tests/import.js
new file mode 100644 (file)
index 0000000..78c8699
--- /dev/null
@@ -0,0 +1,4 @@
+import("./Cocoa.js");
+import(host + "/Cocoa.js");
+
+async function load() { return await import("./Cappuccino.js"); }
index 355d3eb..ee5bc56 100644 (file)
@@ -52,3 +52,14 @@ var {alpha: a, beta: {b, gamma: c}, club: [d, e]} = {
     },
     club: [4, 5]
 };
+var {type, ...rest} = {
+    type: "Cocoa",
+    taste: "Sweet"
+};
+var {...rest} = {
+    a: 1,
+    b: 2
+};
+
+var [a, b] = [0, 1];
+var [a, b, ...rest] = [0, 1, 2];
index 47fd038..f4a222b 100644 (file)
@@ -23,3 +23,8 @@ var a={a:1,b:2},b={x:1,y:2},c=[1,2,3],d=/regex/,e=true;
 
 var {alpha:a,beta:{b,gamma:c},club:[d,e]} = o;
 var {alpha:a,beta:{b,gamma:c},club:[d,e]} = {alpha:1,beta:{b:2,gamma:3},club:[4,5]};
+var {type,...rest} = { type: "Cocoa", taste: "Sweet" };
+var {...rest} = {a:1,b:2};
+
+var [a,b]=[0,1];
+var [a,b,...rest]=[0,1,2];
index 9871d40..9e03666 100644 (file)
@@ -25,9 +25,9 @@ TestPage.registerInitializer(function() {
                         InspectorTest.log("-----------");
                         InspectorTest.log(testText);
                         InspectorTest.log("-----------");
-                        InspectorTest.log("Formatted Output: " + builder.formattedContent.length);
+                        InspectorTest.log("Formatted Output: " + formattedText.length);
                         InspectorTest.log("-----------");
-                        InspectorTest.log(builder.formattedContent);
+                        InspectorTest.log(formattedText);
                         InspectorTest.log("-----------");
                         InspectorTest.log("Expected Output: " + expectedText.length);
                         InspectorTest.log("-----------");
index e2e4425..4188fda 100644 (file)
@@ -41,6 +41,9 @@ passed WhileStatement
 passed WithStatement
 passed YieldExpression
 passed ClassStatement, Super, MetaProperty
+passed Import
+passed RestProperty
+passed SpreadProperty
 passed AssignmentPattern
 passed ArrowFunctionExpression
 passed Async Functions
index ca1144d..2ddebc6 100644 (file)
@@ -495,6 +495,38 @@ function test()
     InspectorTest.assert(node.body.body[0].value.body.body[1].expression.property.name === "target");
     InspectorTest.log("passed ClassStatement, Super, MetaProperty");
 
+    node = makeNode("import('./Cocoa.js')", true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.CallExpression);
+    InspectorTest.assert(node.callee.type === WebInspector.ScriptSyntaxTree.NodeType.Import);
+    InspectorTest.assert(node.arguments);
+    InspectorTest.assert(node.arguments.length === 1);
+    InspectorTest.assert(node.arguments[0].type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    InspectorTest.log("passed Import");
+
+    node = makeNode("let { ...rest } = { x: 1, y: 0 }", false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.VariableDeclaration);
+    InspectorTest.assert(node.kind === "let");
+    InspectorTest.assert(node.declarations.length === 1);
+    InspectorTest.assert(node.declarations[0].type === WebInspector.ScriptSyntaxTree.NodeType.VariableDeclarator);
+    InspectorTest.assert(node.declarations[0].id.type === WebInspector.ScriptSyntaxTree.NodeType.ObjectPattern);
+    InspectorTest.assert(node.declarations[0].id.properties.length === 1);
+    InspectorTest.assert(node.declarations[0].id.properties[0].type === WebInspector.ScriptSyntaxTree.NodeType.RestProperty);
+    InspectorTest.assert(node.declarations[0].id.properties[0].argument.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.declarations[0].id.properties[0].argument.name === "rest");
+    InspectorTest.log("passed RestProperty");
+
+    node = makeNode("let n = { ...spread }", false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.VariableDeclaration);
+    InspectorTest.assert(node.kind === "let");
+    InspectorTest.assert(node.declarations.length === 1);
+    InspectorTest.assert(node.declarations[0].type === WebInspector.ScriptSyntaxTree.NodeType.VariableDeclarator);
+    InspectorTest.assert(node.declarations[0].init.type === WebInspector.ScriptSyntaxTree.NodeType.ObjectExpression);
+    InspectorTest.assert(node.declarations[0].init.properties.length === 1);
+    InspectorTest.assert(node.declarations[0].init.properties[0].type === WebInspector.ScriptSyntaxTree.NodeType.SpreadProperty);
+    InspectorTest.assert(node.declarations[0].init.properties[0].argument.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.declarations[0].init.properties[0].argument.name === "spread");
+    InspectorTest.log("passed SpreadProperty");
+
     node = makeNode("let [x=20] = [];", false);
     InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.VariableDeclaration);
     InspectorTest.assert(node.kind === "let");
index 9bc3c73..b97989a 100644 (file)
@@ -1,3 +1,31 @@
+2017-02-01  Yusuke Suzuki  <utatane.tea@gmail.com>
+
+        Web Inspector: Upgrade Esprima to the latest one to support dynamic import
+        https://bugs.webkit.org/show_bug.cgi?id=167698
+
+        Reviewed by Joseph Pecoraro.
+
+        * UserInterface/External/Esprima/esprima.js:
+        Update to Esprima@5307e30 (4.0.0-dev).
+
+        * UserInterface/Models/ScriptSyntaxTree.js:
+        (WebInspector.ScriptSyntaxTree.prototype._gatherIdentifiersInDeclaration.gatherIdentifiers):
+        (WebInspector.ScriptSyntaxTree.prototype._gatherIdentifiersInDeclaration):
+        (WebInspector.ScriptSyntaxTree.prototype._recurse):
+        (WebInspector.ScriptSyntaxTree.prototype._createInternalSyntaxTree):
+        (WebInspector.ScriptSyntaxTree):
+        * UserInterface/Workers/Formatter/ESTreeWalker.js:
+        (ESTreeWalker.prototype._walkChildren):
+        (ESTreeWalker):
+        Add new nodes, SpreadProperty, RestProperty, and Import.
+        SpreadProperty and RestProperty are the part of ES2018 rest and spread properties.
+        https://github.com/sebmarkbage/ecmascript-rest-spread
+        Import is dynamic import node. The syntax is similar to Super.
+        https://github.com/tc39/proposal-dynamic-import
+
+        * UserInterface/Workers/Formatter/EsprimaFormatter.js:
+        (EsprimaFormatter.prototype._handleTokenAtNode):
+
 2017-02-01  Joseph Pecoraro  <pecoraro@apple.com>
 
         Web Inspector: Remove keyboard shortcut to close tab - does not match expectations
index f93462e..c024603 100644 (file)
@@ -44,6 +44,7 @@
 
     let tests = [
         "if-statement.js",
+        "import.js",
         "for-statements.js",
         "while-statement.js",
         "do-while-statement.js",
index 2de215b..67e3926 100644 (file)
@@ -82,8 +82,8 @@ return /******/ (function(modules) { // webpackBootstrap
     */
     "use strict";
     var comment_handler_1 = __webpack_require__(1);
-    var parser_1 = __webpack_require__(3);
-    var jsx_parser_1 = __webpack_require__(11);
+    var jsx_parser_1 = __webpack_require__(3);
+    var parser_1 = __webpack_require__(8);
     var tokenizer_1 = __webpack_require__(15);
     function parse(code, options, delegate) {
         var commentHandler = null;
@@ -119,7 +119,7 @@ return /******/ (function(modules) { // webpackBootstrap
             parser = new parser_1.Parser(code, options, parserDelegate);
         }
         var program = isModule ? parser.parseModule() : parser.parseScript();
-        var ast = (program);
+        var ast = program;
         if (collectComment && commentHandler) {
             ast.comments = commentHandler.comments;
         }
@@ -366,6 +366,7 @@ return /******/ (function(modules) { // webpackBootstrap
         FunctionExpression: 'FunctionExpression',
         Identifier: 'Identifier',
         IfStatement: 'IfStatement',
+        Import: 'Import',
         ImportDeclaration: 'ImportDeclaration',
         ImportDefaultSpecifier: 'ImportDefaultSpecifier',
         ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
@@ -382,9 +383,11 @@ return /******/ (function(modules) { // webpackBootstrap
         Program: 'Program',
         Property: 'Property',
         RestElement: 'RestElement',
+        RestProperty: 'RestProperty',
         ReturnStatement: 'ReturnStatement',
         SequenceExpression: 'SequenceExpression',
         SpreadElement: 'SpreadElement',
+        SpreadProperty: 'SpreadProperty',
         Super: 'Super',
         SwitchCase: 'SwitchCase',
         SwitchStatement: 'SwitchStatement',
@@ -409,4432 +412,538 @@ return /******/ (function(modules) { // webpackBootstrap
 /***/ function(module, exports, __webpack_require__) {
 
     "use strict";
-    var assert_1 = __webpack_require__(4);
-    var messages_1 = __webpack_require__(5);
-    var error_handler_1 = __webpack_require__(6);
-    var token_1 = __webpack_require__(7);
-    var scanner_1 = __webpack_require__(8);
-    var syntax_1 = __webpack_require__(2);
-    var Node = __webpack_require__(10);
-    var ArrowParameterPlaceHolder = 'ArrowParameterPlaceHolder';
-    var Parser = (function () {
-        function Parser(code, options, delegate) {
-            if (options === void 0) { options = {}; }
-            this.config = {
-                range: (typeof options.range === 'boolean') && options.range,
-                loc: (typeof options.loc === 'boolean') && options.loc,
-                source: null,
-                tokens: (typeof options.tokens === 'boolean') && options.tokens,
-                comment: (typeof options.comment === 'boolean') && options.comment,
-                tolerant: (typeof options.tolerant === 'boolean') && options.tolerant
-            };
-            if (this.config.loc && options.source && options.source !== null) {
-                this.config.source = String(options.source);
-            }
-            this.delegate = delegate;
-            this.errorHandler = new error_handler_1.ErrorHandler();
-            this.errorHandler.tolerant = this.config.tolerant;
-            this.scanner = new scanner_1.Scanner(code, this.errorHandler);
-            this.scanner.trackComment = this.config.comment;
-            this.operatorPrecedence = {
-                ')': 0,
-                ';': 0,
-                ',': 0,
-                '=': 0,
-                ']': 0,
-                '||': 1,
-                '&&': 2,
-                '|': 3,
-                '^': 4,
-                '&': 5,
-                '==': 6,
-                '!=': 6,
-                '===': 6,
-                '!==': 6,
-                '<': 7,
-                '>': 7,
-                '<=': 7,
-                '>=': 7,
-                '<<': 8,
-                '>>': 8,
-                '>>>': 8,
-                '+': 9,
-                '-': 9,
-                '*': 11,
-                '/': 11,
-                '%': 11
-            };
-            this.lookahead = null;
-            this.hasLineTerminator = false;
-            this.context = {
-                isModule: false,
-                await: false,
-                allowIn: true,
-                allowYield: true,
-                firstCoverInitializedNameError: null,
-                isAssignmentTarget: false,
-                isBindingElement: false,
-                inFunctionBody: false,
-                inIteration: false,
-                inSwitch: false,
-                labelSet: {},
-                strict: false
-            };
-            this.tokens = [];
-            this.startMarker = {
-                index: 0,
-                lineNumber: this.scanner.lineNumber,
-                lineStart: 0
-            };
-            this.lastMarker = {
-                index: 0,
-                lineNumber: this.scanner.lineNumber,
-                lineStart: 0
-            };
-            this.nextToken();
-            this.lastMarker = {
-                index: this.scanner.index,
-                lineNumber: this.scanner.lineNumber,
-                lineStart: this.scanner.lineStart
-            };
+/* istanbul ignore next */
+    var __extends = (this && this.__extends) || function (d, b) {
+        for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+    var character_1 = __webpack_require__(4);
+    var JSXNode = __webpack_require__(5);
+    var jsx_syntax_1 = __webpack_require__(6);
+    var Node = __webpack_require__(7);
+    var parser_1 = __webpack_require__(8);
+    var token_1 = __webpack_require__(13);
+    var xhtml_entities_1 = __webpack_require__(14);
+    token_1.TokenName[100 /* Identifier */] = 'JSXIdentifier';
+    token_1.TokenName[101 /* Text */] = 'JSXText';
+    // Fully qualified element name, e.g. <svg:path> returns "svg:path"
+    function getQualifiedElementName(elementName) {
+        var qualifiedName;
+        switch (elementName.type) {
+            case jsx_syntax_1.JSXSyntax.JSXIdentifier:
+                var id = elementName;
+                qualifiedName = id.name;
+                break;
+            case jsx_syntax_1.JSXSyntax.JSXNamespacedName:
+                var ns = elementName;
+                qualifiedName = getQualifiedElementName(ns.namespace) + ':' +
+                    getQualifiedElementName(ns.name);
+                break;
+            case jsx_syntax_1.JSXSyntax.JSXMemberExpression:
+                var expr = elementName;
+                qualifiedName = getQualifiedElementName(expr.object) + '.' +
+                    getQualifiedElementName(expr.property);
+                break;
+            /* istanbul ignore next */
+            default:
+                break;
         }
-        Parser.prototype.throwError = function (messageFormat) {
-            var values = [];
-            for (var _i = 1; _i < arguments.length; _i++) {
-                values[_i - 1] = arguments[_i];
-            }
-            var args = Array.prototype.slice.call(arguments, 1);
-            var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) {
-                assert_1.assert(idx < args.length, 'Message reference must be in range');
-                return args[idx];
-            });
-            var index = this.lastMarker.index;
-            var line = this.lastMarker.lineNumber;
-            var column = this.lastMarker.index - this.lastMarker.lineStart + 1;
-            throw this.errorHandler.createError(index, line, column, msg);
+        return qualifiedName;
+    }
+    var JSXParser = (function (_super) {
+        __extends(JSXParser, _super);
+        function JSXParser(code, options, delegate) {
+            return _super.call(this, code, options, delegate) || this;
+        }
+        JSXParser.prototype.parsePrimaryExpression = function () {
+            return this.match('<') ? this.parseJSXRoot() : _super.prototype.parsePrimaryExpression.call(this);
         };
-        Parser.prototype.tolerateError = function (messageFormat) {
-            var values = [];
-            for (var _i = 1; _i < arguments.length; _i++) {
-                values[_i - 1] = arguments[_i];
-            }
-            var args = Array.prototype.slice.call(arguments, 1);
-            var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) {
-                assert_1.assert(idx < args.length, 'Message reference must be in range');
-                return args[idx];
-            });
-            var index = this.lastMarker.index;
-            var line = this.scanner.lineNumber;
-            var column = this.lastMarker.index - this.lastMarker.lineStart + 1;
-            this.errorHandler.tolerateError(index, line, column, msg);
+        JSXParser.prototype.startJSX = function () {
+            // Unwind the scanner before the lookahead token.
+            this.scanner.index = this.startMarker.index;
+            this.scanner.lineNumber = this.startMarker.line;
+            this.scanner.lineStart = this.startMarker.index - this.startMarker.column;
         };
-        // Throw an exception because of the token.
-        Parser.prototype.unexpectedTokenError = function (token, message) {
-            var msg = message || messages_1.Messages.UnexpectedToken;
-            var value;
-            if (token) {
-                if (!message) {
-                    msg = (token.type === token_1.Token.EOF) ? messages_1.Messages.UnexpectedEOS :
-                        (token.type === token_1.Token.Identifier) ? messages_1.Messages.UnexpectedIdentifier :
-                            (token.type === token_1.Token.NumericLiteral) ? messages_1.Messages.UnexpectedNumber :
-                                (token.type === token_1.Token.StringLiteral) ? messages_1.Messages.UnexpectedString :
-                                    (token.type === token_1.Token.Template) ? messages_1.Messages.UnexpectedTemplate :
-                                        messages_1.Messages.UnexpectedToken;
-                    if (token.type === token_1.Token.Keyword) {
-                        if (this.scanner.isFutureReservedWord(token.value)) {
-                            msg = messages_1.Messages.UnexpectedReserved;
-                        }
-                        else if (this.context.strict && this.scanner.isStrictModeReservedWord(token.value)) {
-                            msg = messages_1.Messages.StrictReservedWord;
-                        }
-                    }
-                }
-                value = (token.type === token_1.Token.Template) ? token.value.raw : token.value;
-            }
-            else {
-                value = 'ILLEGAL';
-            }
-            msg = msg.replace('%0', value);
-            if (token && typeof token.lineNumber === 'number') {
-                var index = token.start;
-                var line = token.lineNumber;
-                var column = token.start - this.lastMarker.lineStart + 1;
-                return this.errorHandler.createError(index, line, column, msg);
-            }
-            else {
-                var index = this.lastMarker.index;
-                var line = this.lastMarker.lineNumber;
-                var column = index - this.lastMarker.lineStart + 1;
-                return this.errorHandler.createError(index, line, column, msg);
+        JSXParser.prototype.finishJSX = function () {
+            // Prime the next lookahead.
+            this.nextToken();
+        };
+        JSXParser.prototype.reenterJSX = function () {
+            this.startJSX();
+            this.expectJSX('}');
+            // Pop the closing '}' added from the lookahead.
+            if (this.config.tokens) {
+                this.tokens.pop();
             }
         };
-        Parser.prototype.throwUnexpectedToken = function (token, message) {
-            throw this.unexpectedTokenError(token, message);
+        JSXParser.prototype.createJSXNode = function () {
+            this.collectComments();
+            return {
+                index: this.scanner.index,
+                line: this.scanner.lineNumber,
+                column: this.scanner.index - this.scanner.lineStart
+            };
         };
-        Parser.prototype.tolerateUnexpectedToken = function (token, message) {
-            this.errorHandler.tolerate(this.unexpectedTokenError(token, message));
+        JSXParser.prototype.createJSXChildNode = function () {
+            return {
+                index: this.scanner.index,
+                line: this.scanner.lineNumber,
+                column: this.scanner.index - this.scanner.lineStart
+            };
         };
-        Parser.prototype.collectComments = function () {
-            if (!this.config.comment) {
-                this.scanner.scanComments();
-            }
-            else {
-                var comments = this.scanner.scanComments();
-                if (comments.length > 0 && this.delegate) {
-                    for (var i = 0; i < comments.length; ++i) {
-                        var e = comments[i];
-                        var node = void 0;
-                        node = {
-                            type: e.multiLine ? 'BlockComment' : 'LineComment',
-                            value: this.scanner.source.slice(e.slice[0], e.slice[1])
-                        };
-                        if (this.config.range) {
-                            node.range = e.range;
-                        }
-                        if (this.config.loc) {
-                            node.loc = e.loc;
-                        }
-                        var metadata = {
-                            start: {
-                                line: e.loc.start.line,
-                                column: e.loc.start.column,
-                                offset: e.range[0]
-                            },
-                            end: {
-                                line: e.loc.end.line,
-                                column: e.loc.end.column,
-                                offset: e.range[1]
+        JSXParser.prototype.scanXHTMLEntity = function (quote) {
+            var result = '&';
+            var valid = true;
+            var terminated = false;
+            var numeric = false;
+            var hex = false;
+            while (!this.scanner.eof() && valid && !terminated) {
+                var ch = this.scanner.source[this.scanner.index];
+                if (ch === quote) {
+                    break;
+                }
+                terminated = (ch === ';');
+                result += ch;
+                ++this.scanner.index;
+                if (!terminated) {
+                    switch (result.length) {
+                        case 2:
+                            // e.g. '&#123;'
+                            numeric = (ch === '#');
+                            break;
+                        case 3:
+                            if (numeric) {
+                                // e.g. '&#x41;'
+                                hex = (ch === 'x');
+                                valid = hex || character_1.Character.isDecimalDigit(ch.charCodeAt(0));
+                                numeric = numeric && !hex;
                             }
-                        };
-                        this.delegate(node, metadata);
+                            break;
+                        default:
+                            valid = valid && !(numeric && !character_1.Character.isDecimalDigit(ch.charCodeAt(0)));
+                            valid = valid && !(hex && !character_1.Character.isHexDigit(ch.charCodeAt(0)));
+                            break;
                     }
                 }
             }
+            if (valid && terminated && result.length > 2) {
+                // e.g. '&#x41;' becomes just '#x41'
+                var str = result.substr(1, result.length - 2);
+                if (numeric && str.length > 1) {
+                    result = String.fromCharCode(parseInt(str.substr(1), 10));
+                }
+                else if (hex && str.length > 2) {
+                    result = String.fromCharCode(parseInt('0' + str.substr(1), 16));
+                }
+                else if (!numeric && !hex && xhtml_entities_1.XHTMLEntities[str]) {
+                    result = xhtml_entities_1.XHTMLEntities[str];
+                }
+            }
+            return result;
         };
-        // From internal representation to an external structure
-        Parser.prototype.getTokenRaw = function (token) {
-            return this.scanner.source.slice(token.start, token.end);
-        };
-        Parser.prototype.convertToken = function (token) {
-            var t;
-            t = {
-                type: token_1.TokenName[token.type],
-                value: this.getTokenRaw(token)
-            };
-            if (this.config.range) {
-                t.range = [token.start, token.end];
+        // Scan the next JSX token. This replaces Scanner#lex when in JSX mode.
+        JSXParser.prototype.lexJSX = function () {
+            var cp = this.scanner.source.charCodeAt(this.scanner.index);
+            // < > / : = { }
+            if (cp === 60 || cp === 62 || cp === 47 || cp === 58 || cp === 61 || cp === 123 || cp === 125) {
+                var value = this.scanner.source[this.scanner.index++];
+                return {
+                    type: 7 /* Punctuator */,
+                    value: value,
+                    lineNumber: this.scanner.lineNumber,
+                    lineStart: this.scanner.lineStart,
+                    start: this.scanner.index - 1,
+                    end: this.scanner.index
+                };
             }
-            if (this.config.loc) {
-                t.loc = {
-                    start: {
-                        line: this.startMarker.lineNumber,
-                        column: this.startMarker.index - this.startMarker.lineStart
-                    },
-                    end: {
-                        line: this.scanner.lineNumber,
-                        column: this.scanner.index - this.scanner.lineStart
+            // " '
+            if (cp === 34 || cp === 39) {
+                var start = this.scanner.index;
+                var quote = this.scanner.source[this.scanner.index++];
+                var str = '';
+                while (!this.scanner.eof()) {
+                    var ch = this.scanner.source[this.scanner.index++];
+                    if (ch === quote) {
+                        break;
+                    }
+                    else if (ch === '&') {
+                        str += this.scanXHTMLEntity(quote);
+                    }
+                    else {
+                        str += ch;
                     }
+                }
+                return {
+                    type: 8 /* StringLiteral */,
+                    value: str,
+                    lineNumber: this.scanner.lineNumber,
+                    lineStart: this.scanner.lineStart,
+                    start: start,
+                    end: this.scanner.index
                 };
             }
-            if (token.regex) {
-                t.regex = token.regex;
+            // ... or .
+            if (cp === 46) {
+                var n1 = this.scanner.source.charCodeAt(this.scanner.index + 1);
+                var n2 = this.scanner.source.charCodeAt(this.scanner.index + 2);
+                var value = (n1 === 46 && n2 === 46) ? '...' : '.';
+                var start = this.scanner.index;
+                this.scanner.index += value.length;
+                return {
+                    type: 7 /* Punctuator */,
+                    value: value,
+                    lineNumber: this.scanner.lineNumber,
+                    lineStart: this.scanner.lineStart,
+                    start: start,
+                    end: this.scanner.index
+                };
             }
-            return t;
-        };
-        Parser.prototype.nextToken = function () {
-            var token = this.lookahead;
-            this.lastMarker.index = this.scanner.index;
-            this.lastMarker.lineNumber = this.scanner.lineNumber;
-            this.lastMarker.lineStart = this.scanner.lineStart;
-            this.collectComments();
-            this.startMarker.index = this.scanner.index;
-            this.startMarker.lineNumber = this.scanner.lineNumber;
-            this.startMarker.lineStart = this.scanner.lineStart;
-            var next;
-            next = this.scanner.lex();
-            this.hasLineTerminator = (token && next) ? (token.lineNumber !== next.lineNumber) : false;
-            if (next && this.context.strict && next.type === token_1.Token.Identifier) {
-                if (this.scanner.isStrictModeReservedWord(next.value)) {
-                    next.type = token_1.Token.Keyword;
-                }
+            // `
+            if (cp === 96) {
+                // Only placeholder, since it will be rescanned as a real assignment expression.
+                return {
+                    type: 10 /* Template */,
+                    value: '',
+                    lineNumber: this.scanner.lineNumber,
+                    lineStart: this.scanner.lineStart,
+                    start: this.scanner.index,
+                    end: this.scanner.index
+                };
             }
-            this.lookahead = next;
-            if (this.config.tokens && next.type !== token_1.Token.EOF) {
-                this.tokens.push(this.convertToken(next));
+            // Identifer can not contain backslash (char code 92).
+            if (character_1.Character.isIdentifierStart(cp) && (cp !== 92)) {
+                var start = this.scanner.index;
+                ++this.scanner.index;
+                while (!this.scanner.eof()) {
+                    var ch = this.scanner.source.charCodeAt(this.scanner.index);
+                    if (character_1.Character.isIdentifierPart(ch) && (ch !== 92)) {
+                        ++this.scanner.index;
+                    }
+                    else if (ch === 45) {
+                        // Hyphen (char code 45) can be part of an identifier.
+                        ++this.scanner.index;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                var id = this.scanner.source.slice(start, this.scanner.index);
+                return {
+                    type: 100 /* Identifier */,
+                    value: id,
+                    lineNumber: this.scanner.lineNumber,
+                    lineStart: this.scanner.lineStart,
+                    start: start,
+                    end: this.scanner.index
+                };
             }
-            return token;
+            return this.scanner.throwUnexpectedToken();
         };
-        Parser.prototype.nextRegexToken = function () {
+        JSXParser.prototype.nextJSXToken = function () {
             this.collectComments();
-            var token = this.scanner.scanRegExp();
+            this.startMarker.index = this.scanner.index;
+            this.startMarker.line = this.scanner.lineNumber;
+            this.startMarker.column = this.scanner.index - this.scanner.lineStart;
+            var token = this.lexJSX();
+            this.lastMarker.index = this.scanner.index;
+            this.lastMarker.line = this.scanner.lineNumber;
+            this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
             if (this.config.tokens) {
-                // Pop the previous token, '/' or '/='
-                // This is added from the lookahead token.
-                this.tokens.pop();
                 this.tokens.push(this.convertToken(token));
             }
-            // Prime the next lookahead.
-            this.lookahead = token;
-            this.nextToken();
             return token;
         };
-        Parser.prototype.createNode = function () {
-            return {
-                index: this.startMarker.index,
-                line: this.startMarker.lineNumber,
-                column: this.startMarker.index - this.startMarker.lineStart
-            };
-        };
-        Parser.prototype.startNode = function (token) {
-            return {
-                index: token.start,
-                line: token.lineNumber,
-                column: token.start - token.lineStart
-            };
-        };
-        Parser.prototype.finalize = function (meta, node) {
-            if (this.config.range) {
-                node.range = [meta.index, this.lastMarker.index];
-            }
-            if (this.config.loc) {
-                node.loc = {
-                    start: {
-                        line: meta.line,
-                        column: meta.column
-                    },
-                    end: {
-                        line: this.lastMarker.lineNumber,
-                        column: this.lastMarker.index - this.lastMarker.lineStart
+        JSXParser.prototype.nextJSXText = function () {
+            this.startMarker.index = this.scanner.index;
+            this.startMarker.line = this.scanner.lineNumber;
+            this.startMarker.column = this.scanner.index - this.scanner.lineStart;
+            var start = this.scanner.index;
+            var text = '';
+            while (!this.scanner.eof()) {
+                var ch = this.scanner.source[this.scanner.index];
+                if (ch === '{' || ch === '<') {
+                    break;
+                }
+                ++this.scanner.index;
+                text += ch;
+                if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
+                    ++this.scanner.lineNumber;
+                    if (ch === '\r' && this.scanner.source[this.scanner.index] === '\n') {
+                        ++this.scanner.index;
                     }
-                };
-                if (this.config.source) {
-                    node.loc.source = this.config.source;
+                    this.scanner.lineStart = this.scanner.index;
                 }
             }
-            if (this.delegate) {
-                var metadata = {
-                    start: {
-                        line: meta.line,
-                        column: meta.column,
-                        offset: meta.index
-                    },
-                    end: {
-                        line: this.lastMarker.lineNumber,
-                        column: this.lastMarker.index - this.lastMarker.lineStart,
-                        offset: this.lastMarker.index
-                    }
-                };
-                this.delegate(node, metadata);
+            this.lastMarker.index = this.scanner.index;
+            this.lastMarker.line = this.scanner.lineNumber;
+            this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
+            var token = {
+                type: 101 /* Text */,
+                value: text,
+                lineNumber: this.scanner.lineNumber,
+                lineStart: this.scanner.lineStart,
+                start: start,
+                end: this.scanner.index
+            };
+            if ((text.length > 0) && this.config.tokens) {
+                this.tokens.push(this.convertToken(token));
             }
-            return node;
+            return token;
         };
-        // Expect the next token to match the specified punctuator.
+        JSXParser.prototype.peekJSXToken = function () {
+            var state = this.scanner.saveState();
+            this.scanner.scanComments();
+            var next = this.lexJSX();
+            this.scanner.restoreState(state);
+            return next;
+        };
+        // Expect the next JSX token to match the specified punctuator.
         // If not, an exception will be thrown.
-        Parser.prototype.expect = function (value) {
-            var token = this.nextToken();
-            if (token.type !== token_1.Token.Punctuator || token.value !== value) {
+        JSXParser.prototype.expectJSX = function (value) {
+            var token = this.nextJSXToken();
+            if (token.type !== 7 /* Punctuator */ || token.value !== value) {
                 this.throwUnexpectedToken(token);
             }
         };
-        // Quietly expect a comma when in tolerant mode, otherwise delegates to expect().
-        Parser.prototype.expectCommaSeparator = function () {
-            if (this.config.tolerant) {
-                var token = this.lookahead;
-                if (token.type === token_1.Token.Punctuator && token.value === ',') {
-                    this.nextToken();
-                }
-                else if (token.type === token_1.Token.Punctuator && token.value === ';') {
-                    this.nextToken();
-                    this.tolerateUnexpectedToken(token);
-                }
-                else {
-                    this.tolerateUnexpectedToken(token, messages_1.Messages.UnexpectedToken);
-                }
-            }
-            else {
-                this.expect(',');
-            }
+        // Return true if the next JSX token matches the specified punctuator.
+        JSXParser.prototype.matchJSX = function (value) {
+            var next = this.peekJSXToken();
+            return next.type === 7 /* Punctuator */ && next.value === value;
         };
-        // Expect the next token to match the specified keyword.
-        // If not, an exception will be thrown.
-        Parser.prototype.expectKeyword = function (keyword) {
-            var token = this.nextToken();
-            if (token.type !== token_1.Token.Keyword || token.value !== keyword) {
+        JSXParser.prototype.parseJSXIdentifier = function () {
+            var node = this.createJSXNode();
+            var token = this.nextJSXToken();
+            if (token.type !== 100 /* Identifier */) {
                 this.throwUnexpectedToken(token);
             }
+            return this.finalize(node, new JSXNode.JSXIdentifier(token.value));
         };
-        // Return true if the next token matches the specified punctuator.
-        Parser.prototype.match = function (value) {
-            return this.lookahead.type === token_1.Token.Punctuator && this.lookahead.value === value;
-        };
-        // Return true if the next token matches the specified keyword
-        Parser.prototype.matchKeyword = function (keyword) {
-            return this.lookahead.type === token_1.Token.Keyword && this.lookahead.value === keyword;
-        };
-        // Return true if the next token matches the specified contextual keyword
-        // (where an identifier is sometimes a keyword depending on the context)
-        Parser.prototype.matchContextualKeyword = function (keyword) {
-            return this.lookahead.type === token_1.Token.Identifier && this.lookahead.value === keyword;
-        };
-        // Return true if the next token is an assignment operator
-        Parser.prototype.matchAssign = function () {
-            if (this.lookahead.type !== token_1.Token.Punctuator) {
-                return false;
+        JSXParser.prototype.parseJSXElementName = function () {
+            var node = this.createJSXNode();
+            var elementName = this.parseJSXIdentifier();
+            if (this.matchJSX(':')) {
+                var namespace = elementName;
+                this.expectJSX(':');
+                var name_1 = this.parseJSXIdentifier();
+                elementName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_1));
             }
-            var op = this.lookahead.value;
-            return op === '=' ||
-                op === '*=' ||
-                op === '**=' ||
-                op === '/=' ||
-                op === '%=' ||
-                op === '+=' ||
-                op === '-=' ||
-                op === '<<=' ||
-                op === '>>=' ||
-                op === '>>>=' ||
-                op === '&=' ||
-                op === '^=' ||
-                op === '|=';
-        };
-        // Cover grammar support.
-        //
-        // When an assignment expression position starts with an left parenthesis, the determination of the type
-        // of the syntax is to be deferred arbitrarily long until the end of the parentheses pair (plus a lookahead)
-        // or the first comma. This situation also defers the determination of all the expressions nested in the pair.
-        //
-        // There are three productions that can be parsed in a parentheses pair that needs to be determined
-        // after the outermost pair is closed. They are:
-        //
-        //   1. AssignmentExpression
-        //   2. BindingElements
-        //   3. AssignmentTargets
-        //
-        // In order to avoid exponential backtracking, we use two flags to denote if the production can be
-        // binding element or assignment target.
-        //
-        // The three productions have the relationship:
-        //
-        //   BindingElements ⊆ AssignmentTargets ⊆ AssignmentExpression
-        //
-        // with a single exception that CoverInitializedName when used directly in an Expression, generates
-        // an early error. Therefore, we need the third state, firstCoverInitializedNameError, to track the
-        // first usage of CoverInitializedName and report it when we reached the end of the parentheses pair.
-        //
-        // isolateCoverGrammar function runs the given parser function with a new cover grammar context, and it does not
-        // effect the current flags. This means the production the parser parses is only used as an expression. Therefore
-        // the CoverInitializedName check is conducted.
-        //
-        // inheritCoverGrammar function runs the given parse function with a new cover grammar context, and it propagates
-        // the flags outside of the parser. This means the production the parser parses is used as a part of a potential
-        // pattern. The CoverInitializedName check is deferred.
-        Parser.prototype.isolateCoverGrammar = function (parseFunction) {
-            var previousIsBindingElement = this.context.isBindingElement;
-            var previousIsAssignmentTarget = this.context.isAssignmentTarget;
-            var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;
-            this.context.isBindingElement = true;
-            this.context.isAssignmentTarget = true;
-            this.context.firstCoverInitializedNameError = null;
-            var result = parseFunction.call(this);
-            if (this.context.firstCoverInitializedNameError !== null) {
-                this.throwUnexpectedToken(this.context.firstCoverInitializedNameError);
+            else if (this.matchJSX('.')) {
+                while (this.matchJSX('.')) {
+                    var object = elementName;
+                    this.expectJSX('.');
+                    var property = this.parseJSXIdentifier();
+                    elementName = this.finalize(node, new JSXNode.JSXMemberExpression(object, property));
+                }
             }
-            this.context.isBindingElement = previousIsBindingElement;
-            this.context.isAssignmentTarget = previousIsAssignmentTarget;
-            this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError;
-            return result;
-        };
-        Parser.prototype.inheritCoverGrammar = function (parseFunction) {
-            var previousIsBindingElement = this.context.isBindingElement;
-            var previousIsAssignmentTarget = this.context.isAssignmentTarget;
-            var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;
-            this.context.isBindingElement = true;
-            this.context.isAssignmentTarget = true;
-            this.context.firstCoverInitializedNameError = null;
-            var result = parseFunction.call(this);
-            this.context.isBindingElement = this.context.isBindingElement && previousIsBindingElement;
-            this.context.isAssignmentTarget = this.context.isAssignmentTarget && previousIsAssignmentTarget;
-            this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError || this.context.firstCoverInitializedNameError;
-            return result;
+            return elementName;
         };
-        Parser.prototype.consumeSemicolon = function () {
-            if (this.match(';')) {
-                this.nextToken();
+        JSXParser.prototype.parseJSXAttributeName = function () {
+            var node = this.createJSXNode();
+            var attributeName;
+            var identifier = this.parseJSXIdentifier();
+            if (this.matchJSX(':')) {
+                var namespace = identifier;
+                this.expectJSX(':');
+                var name_2 = this.parseJSXIdentifier();
+                attributeName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_2));
             }
-            else if (!this.hasLineTerminator) {
-                if (this.lookahead.type !== token_1.Token.EOF && !this.match('}')) {
-                    this.throwUnexpectedToken(this.lookahead);
-                }
-                this.lastMarker.index = this.startMarker.index;
-                this.lastMarker.lineNumber = this.startMarker.lineNumber;
-                this.lastMarker.lineStart = this.startMarker.lineStart;
+            else {
+                attributeName = identifier;
             }
+            return attributeName;
         };
-        // ECMA-262 12.2 Primary Expressions
-        Parser.prototype.parsePrimaryExpression = function () {
-            var node = this.createNode();
-            var expr;
-            var value, token, raw;
-            switch (this.lookahead.type) {
-                case token_1.Token.Identifier:
-                    if ((this.context.isModule || this.context.await) && this.lookahead.value === 'await') {
-                        this.tolerateUnexpectedToken(this.lookahead);
-                    }
-                    expr = this.matchAsyncFunction() ? this.parseFunctionExpression() : this.finalize(node, new Node.Identifier(this.nextToken().value));
-                    break;
-                case token_1.Token.NumericLiteral:
-                case token_1.Token.StringLiteral:
-                    if (this.context.strict && this.lookahead.octal) {
-                        this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.StrictOctalLiteral);
-                    }
-                    this.context.isAssignmentTarget = false;
-                    this.context.isBindingElement = false;
-                    token = this.nextToken();
-                    raw = this.getTokenRaw(token);
-                    expr = this.finalize(node, new Node.Literal(token.value, raw));
-                    break;
-                case token_1.Token.BooleanLiteral:
-                    this.context.isAssignmentTarget = false;
-                    this.context.isBindingElement = false;
-                    token = this.nextToken();
-                    token.value = (token.value === 'true');
-                    raw = this.getTokenRaw(token);
-                    expr = this.finalize(node, new Node.Literal(token.value, raw));
-                    break;
-                case token_1.Token.NullLiteral:
-                    this.context.isAssignmentTarget = false;
-                    this.context.isBindingElement = false;
-                    token = this.nextToken();
-                    token.value = null;
-                    raw = this.getTokenRaw(token);
-                    expr = this.finalize(node, new Node.Literal(token.value, raw));
-                    break;
-                case token_1.Token.Template:
-                    expr = this.parseTemplateLiteral();
-                    break;
-                case token_1.Token.Punctuator:
-                    value = this.lookahead.value;
-                    switch (value) {
-                        case '(':
-                            this.context.isBindingElement = false;
-                            expr = this.inheritCoverGrammar(this.parseGroupExpression);
-                            break;
-                        case '[':
-                            expr = this.inheritCoverGrammar(this.parseArrayInitializer);
-                            break;
-                        case '{':
-                            expr = this.inheritCoverGrammar(this.parseObjectInitializer);
-                            break;
-                        case '/':
-                        case '/=':
-                            this.context.isAssignmentTarget = false;
-                            this.context.isBindingElement = false;
-                            this.scanner.index = this.startMarker.index;
-                            token = this.nextRegexToken();
-                            raw = this.getTokenRaw(token);
-                            expr = this.finalize(node, new Node.RegexLiteral(token.value, raw, token.regex));
-                            break;
-                        default:
-                            expr = this.throwUnexpectedToken(this.nextToken());
-                    }
-                    break;
-                case token_1.Token.Keyword:
-                    if (!this.context.strict && this.context.allowYield && this.matchKeyword('yield')) {
-                        expr = this.parseIdentifierName();
-                    }
-                    else if (!this.context.strict && this.matchKeyword('let')) {
-                        expr = this.finalize(node, new Node.Identifier(this.nextToken().value));
-                    }
-                    else {
-                        this.context.isAssignmentTarget = false;
-                        this.context.isBindingElement = false;
-                        if (this.matchKeyword('function')) {
-                            expr = this.parseFunctionExpression();
-                        }
-                        else if (this.matchKeyword('this')) {
-                            this.nextToken();
-                            expr = this.finalize(node, new Node.ThisExpression());
-                        }
-                        else if (this.matchKeyword('class')) {
-                            expr = this.parseClassExpression();
-                        }
-                        else {
-                            expr = this.throwUnexpectedToken(this.nextToken());
-                        }
-                    }
-                    break;
-                default:
-                    expr = this.throwUnexpectedToken(this.nextToken());
+        JSXParser.prototype.parseJSXStringLiteralAttribute = function () {
+            var node = this.createJSXNode();
+            var token = this.nextJSXToken();
+            if (token.type !== 8 /* StringLiteral */) {
+                this.throwUnexpectedToken(token);
             }
-            return expr;
-        };
-        // ECMA-262 12.2.5 Array Initializer
-        Parser.prototype.parseSpreadElement = function () {
-            var node = this.createNode();
-            this.expect('...');
-            var arg = this.inheritCoverGrammar(this.parseAssignmentExpression);
-            return this.finalize(node, new Node.SpreadElement(arg));
+            var raw = this.getTokenRaw(token);
+            return this.finalize(node, new Node.Literal(token.value, raw));
         };
-        Parser.prototype.parseArrayInitializer = function () {
-            var node = this.createNode();
-            var elements = [];
-            this.expect('[');
-            while (!this.match(']')) {
-                if (this.match(',')) {
-                    this.nextToken();
-                    elements.push(null);
-                }
-                else if (this.match('...')) {
-                    var element = this.parseSpreadElement();
-                    if (!this.match(']')) {
-                        this.context.isAssignmentTarget = false;
-                        this.context.isBindingElement = false;
-                        this.expect(',');
-                    }
-                    elements.push(element);
-                }
-                else {
-                    elements.push(this.inheritCoverGrammar(this.parseAssignmentExpression));
-                    if (!this.match(']')) {
-                        this.expect(',');
-                    }
-                }
+        JSXParser.prototype.parseJSXExpressionAttribute = function () {
+            var node = this.createJSXNode();
+            this.expectJSX('{');
+            this.finishJSX();
+            if (this.match('}')) {
+                this.tolerateError('JSX attributes must only be assigned a non-empty expression');
             }
-            this.expect(']');
-            return this.finalize(node, new Node.ArrayExpression(elements));
+            var expression = this.parseAssignmentExpression();
+            this.reenterJSX();
+            return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));
         };
-        // ECMA-262 12.2.6 Object Initializer
-        Parser.prototype.parsePropertyMethod = function (params) {
-            this.context.isAssignmentTarget = false;
-            this.context.isBindingElement = false;
-            var previousStrict = this.context.strict;
-            var body = this.isolateCoverGrammar(this.parseFunctionSourceElements);
-            if (this.context.strict && params.firstRestricted) {
-                this.tolerateUnexpectedToken(params.firstRestricted, params.message);
-            }
-            if (this.context.strict && params.stricted) {
-                this.tolerateUnexpectedToken(params.stricted, params.message);
+        JSXParser.prototype.parseJSXAttributeValue = function () {
+            return this.matchJSX('{') ? this.parseJSXExpressionAttribute() :
+                this.matchJSX('<') ? this.parseJSXElement() : this.parseJSXStringLiteralAttribute();
+        };
+        JSXParser.prototype.parseJSXNameValueAttribute = function () {
+            var node = this.createJSXNode();
+            var name = this.parseJSXAttributeName();
+            var value = null;
+            if (this.matchJSX('=')) {
+                this.expectJSX('=');
+                value = this.parseJSXAttributeValue();
             }
-            this.context.strict = previousStrict;
-            return body;
+            return this.finalize(node, new JSXNode.JSXAttribute(name, value));
         };
-        Parser.prototype.parsePropertyMethodFunction = function () {
-            var isGenerator = false;
-            var node = this.createNode();
-            var previousAllowYield = this.context.allowYield;
-            this.context.allowYield = false;
-            var params = this.parseFormalParameters();
-            var method = this.parsePropertyMethod(params);
-            this.context.allowYield = previousAllowYield;
-            return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
-        };
-        Parser.prototype.parsePropertyMethodAsyncFunction = function () {
-            var node = this.createNode();
-            var previousAllowYield = this.context.allowYield;
-            var previousAwait = this.context.await;
-            this.context.allowYield = false;
-            this.context.await = true;
-            var params = this.parseFormalParameters();
-            var method = this.parsePropertyMethod(params);
-            this.context.allowYield = previousAllowYield;
-            this.context.await = previousAwait;
-            return this.finalize(node, new Node.AsyncFunctionExpression(null, params.params, method));
+        JSXParser.prototype.parseJSXSpreadAttribute = function () {
+            var node = this.createJSXNode();
+            this.expectJSX('{');
+            this.expectJSX('...');
+            this.finishJSX();
+            var argument = this.parseAssignmentExpression();
+            this.reenterJSX();
+            return this.finalize(node, new JSXNode.JSXSpreadAttribute(argument));
         };
-        Parser.prototype.parseObjectPropertyKey = function () {
-            var node = this.createNode();
-            var token = this.nextToken();
-            var key;
-            switch (token.type) {
-                case token_1.Token.StringLiteral:
-                case token_1.Token.NumericLiteral:
-                    if (this.context.strict && token.octal) {
-                        this.tolerateUnexpectedToken(token, messages_1.Messages.StrictOctalLiteral);
-                    }
-                    var raw = this.getTokenRaw(token);
-                    key = this.finalize(node, new Node.Literal(token.value, raw));
-                    break;
-                case token_1.Token.Identifier:
-                case token_1.Token.BooleanLiteral:
-                case token_1.Token.NullLiteral:
-                case token_1.Token.Keyword:
-                    key = this.finalize(node, new Node.Identifier(token.value));
-                    break;
-                case token_1.Token.Punctuator:
-                    if (token.value === '[') {
-                        key = this.isolateCoverGrammar(this.parseAssignmentExpression);
-                        this.expect(']');
-                    }
-                    else {
-                        key = this.throwUnexpectedToken(token);
-                    }
-                    break;
-                default:
-                    key = this.throwUnexpectedToken(token);
+        JSXParser.prototype.parseJSXAttributes = function () {
+            var attributes = [];
+            while (!this.matchJSX('/') && !this.matchJSX('>')) {
+                var attribute = this.matchJSX('{') ? this.parseJSXSpreadAttribute() :
+                    this.parseJSXNameValueAttribute();
+                attributes.push(attribute);
             }
-            return key;
-        };
-        Parser.prototype.isPropertyKey = function (key, value) {
-            return (key.type === syntax_1.Syntax.Identifier && key.name === value) ||
-                (key.type === syntax_1.Syntax.Literal && key.value === value);
+            return attributes;
         };
-        Parser.prototype.parseObjectProperty = function (hasProto) {
-            var node = this.createNode();
-            var token = this.lookahead;
-            var kind;
-            var key = null;
-            var value = null;
-            var computed = false;
-            var method = false;
-            var shorthand = false;
-            var isAsync = false;
-            if (token.type === token_1.Token.Identifier) {
-                var id = token.value;
-                this.nextToken();
-                if (id === 'async' && !this.hasLineTerminator) {
-                    computed = this.match('[');
-                    if (computed) {
-                        isAsync = true;
-                        key = this.parseObjectPropertyKey();
-                    }
-                    else {
-                        var punctuator = this.lookahead.value;
-                        if (punctuator !== ':' && punctuator !== '(' && punctuator !== '*') {
-                            isAsync = true;
-                            token = this.lookahead;
-                            id = token.value;
-                            this.nextToken();
-                        }
-                        key = this.finalize(node, new Node.Identifier(id));
-                    }
-                }
-                else {
-                    key = this.finalize(node, new Node.Identifier(id));
-                }
-            }
-            else if (this.match('*')) {
-                this.nextToken();
-            }
-            else {
-                computed = this.match('[');
-                key = this.parseObjectPropertyKey();
+        JSXParser.prototype.parseJSXOpeningElement = function () {
+            var node = this.createJSXNode();
+            this.expectJSX('<');
+            var name = this.parseJSXElementName();
+            var attributes = this.parseJSXAttributes();
+            var selfClosing = this.matchJSX('/');
+            if (selfClosing) {
+                this.expectJSX('/');
             }
-            var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);
-            if (token.type === token_1.Token.Identifier && !isAsync && token.value === 'get' && lookaheadPropertyKey) {
-                kind = 'get';
-                computed = this.match('[');
-                key = this.parseObjectPropertyKey();
-                this.context.allowYield = false;
-                value = this.parseGetterMethod();
+            this.expectJSX('>');
+            return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes));
+        };
+        JSXParser.prototype.parseJSXBoundaryElement = function () {
+            var node = this.createJSXNode();
+            this.expectJSX('<');
+            if (this.matchJSX('/')) {
+                this.expectJSX('/');
+                var name_3 = this.parseJSXElementName();
+                this.expectJSX('>');
+                return this.finalize(node, new JSXNode.JSXClosingElement(name_3));
             }
-            else if (token.type === token_1.Token.Identifier && !isAsync && token.value === 'set' && lookaheadPropertyKey) {
-                kind = 'set';
-                computed = this.match('[');
-                key = this.parseObjectPropertyKey();
-                value = this.parseSetterMethod();
+            var name = this.parseJSXElementName();
+            var attributes = this.parseJSXAttributes();
+            var selfClosing = this.matchJSX('/');
+            if (selfClosing) {
+                this.expectJSX('/');
             }
-            else if (token.type === token_1.Token.Punctuator && token.value === '*' && lookaheadPropertyKey) {
-                kind = 'init';
-                computed = this.match('[');
-                key = this.parseObjectPropertyKey();
-                value = this.parseGeneratorMethod();
-                method = true;
+            this.expectJSX('>');
+            return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes));
+        };
+        JSXParser.prototype.parseJSXEmptyExpression = function () {
+            var node = this.createJSXChildNode();
+            this.collectComments();
+            this.lastMarker.index = this.scanner.index;
+            this.lastMarker.line = this.scanner.lineNumber;
+            this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
+            return this.finalize(node, new JSXNode.JSXEmptyExpression());
+        };
+        JSXParser.prototype.parseJSXExpressionContainer = function () {
+            var node = this.createJSXNode();
+            this.expectJSX('{');
+            var expression;
+            if (this.matchJSX('}')) {
+                expression = this.parseJSXEmptyExpression();
+                this.expectJSX('}');
             }
             else {
-                if (!key) {
-                    this.throwUnexpectedToken(this.lookahead);
+                this.finishJSX();
+                expression = this.parseAssignmentExpression();
+                this.reenterJSX();
+            }
+            return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));
+        };
+        JSXParser.prototype.parseJSXChildren = function () {
+            var children = [];
+            while (!this.scanner.eof()) {
+                var node = this.createJSXChildNode();
+                var token = this.nextJSXText();
+                if (token.start < token.end) {
+                    var raw = this.getTokenRaw(token);
+                    var child = this.finalize(node, new JSXNode.JSXText(token.value, raw));
+                    children.push(child);
                 }
-                kind = 'init';
-                if (this.match(':') && !isAsync) {
-                    if (!computed && this.isPropertyKey(key, '__proto__')) {
-                        if (hasProto.value) {
-                            this.tolerateError(messages_1.Messages.DuplicateProtoProperty);
-                        }
-                        hasProto.value = true;
-                    }
-                    this.nextToken();
-                    value = this.inheritCoverGrammar(this.parseAssignmentExpression);
+                if (this.scanner.source[this.scanner.index] === '{') {
+                    var container = this.parseJSXExpressionContainer();
+                    children.push(container);
                 }
-                else if (this.match('(')) {
-                    value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();
-                    method = true;
+                else {
+                    break;
                 }
-                else if (token.type === token_1.Token.Identifier) {
-                    var id = this.finalize(node, new Node.Identifier(token.value));
-                    if (this.match('=')) {
-                        this.context.firstCoverInitializedNameError = this.lookahead;
-                        this.nextToken();
-                        shorthand = true;
-                        var init = this.isolateCoverGrammar(this.parseAssignmentExpression);
-                        value = this.finalize(node, new Node.AssignmentPattern(id, init));
+            }
+            return children;
+        };
+        JSXParser.prototype.parseComplexJSXElement = function (el) {
+            var stack = [];
+            while (!this.scanner.eof()) {
+                el.children = el.children.concat(this.parseJSXChildren());
+                var node = this.createJSXChildNode();
+                var element = this.parseJSXBoundaryElement();
+                if (element.type === jsx_syntax_1.JSXSyntax.JSXOpeningElement) {
+                    var opening = element;
+                    if (opening.selfClosing) {
+                        var child = this.finalize(node, new JSXNode.JSXElement(opening, [], null));
+                        el.children.push(child);
                     }
                     else {
-                        shorthand = true;
-                        value = id;
+                        stack.push(el);
+                        el = { node: node, opening: opening, closing: null, children: [] };
                     }
                 }
-                else {
-                    this.throwUnexpectedToken(this.nextToken());
+                if (element.type === jsx_syntax_1.JSXSyntax.JSXClosingElement) {
+                    el.closing = element;
+                    var open_1 = getQualifiedElementName(el.opening.name);
+                    var close_1 = getQualifiedElementName(el.closing.name);
+                    if (open_1 !== close_1) {
+                        this.tolerateError('Expected corresponding JSX closing tag for %0', open_1);
+                    }
+                    if (stack.length > 0) {
+                        var child = this.finalize(el.node, new JSXNode.JSXElement(el.opening, el.children, el.closing));
+                        el = stack[stack.length - 1];
+                        el.children.push(child);
+                        stack.pop();
+                    }
+                    else {
+                        break;
+                    }
                 }
             }
-            return this.finalize(node, new Node.Property(kind, (key), computed, value, method, shorthand));
+            return el;
         };
-        Parser.prototype.parseObjectInitializer = function () {
-            var node = this.createNode();
-            this.expect('{');
-            var properties = [];
-            var hasProto = { value: false };
-            while (!this.match('}')) {
-                properties.push(this.parseObjectProperty(hasProto));
-                if (!this.match('}')) {
-                    this.expectCommaSeparator();
-                }
+        JSXParser.prototype.parseJSXElement = function () {
+            var node = this.createJSXNode();
+            var opening = this.parseJSXOpeningElement();
+            var children = [];
+            var closing = null;
+            if (!opening.selfClosing) {
+                var el = this.parseComplexJSXElement({ node: node, opening: opening, closing: closing, children: children });
+                children = el.children;
+                closing = el.closing;
             }
-            this.expect('}');
-            return this.finalize(node, new Node.ObjectExpression(properties));
+            return this.finalize(node, new JSXNode.JSXElement(opening, children, closing));
         };
-        // ECMA-262 12.2.9 Template Literals
-        Parser.prototype.parseTemplateHead = function () {
-            assert_1.assert(this.lookahead.head, 'Template literal must start with a template head');
-            var node = this.createNode();
-            var token = this.nextToken();
-            var value = {
-                raw: token.value.raw,
-                cooked: token.value.cooked
-            };
-            return this.finalize(node, new Node.TemplateElement(value, token.tail));
-        };
-        Parser.prototype.parseTemplateElement = function () {
-            if (this.lookahead.type !== token_1.Token.Template) {
-                this.throwUnexpectedToken();
-            }
-            var node = this.createNode();
-            var token = this.nextToken();
-            var value = {
-                raw: token.value.raw,
-                cooked: token.value.cooked
-            };
-            return this.finalize(node, new Node.TemplateElement(value, token.tail));
-        };
-        Parser.prototype.parseTemplateLiteral = function () {
-            var node = this.createNode();
-            var expressions = [];
-            var quasis = [];
-            var quasi = this.parseTemplateHead();
-            quasis.push(quasi);
-            while (!quasi.tail) {
-                expressions.push(this.parseExpression());
-                quasi = this.parseTemplateElement();
-                quasis.push(quasi);
-            }
-            return this.finalize(node, new Node.TemplateLiteral(quasis, expressions));
-        };
-        // ECMA-262 12.2.10 The Grouping Operator
-        Parser.prototype.reinterpretExpressionAsPattern = function (expr) {
-            switch (expr.type) {
-                case syntax_1.Syntax.Identifier:
-                case syntax_1.Syntax.MemberExpression:
-                case syntax_1.Syntax.RestElement:
-                case syntax_1.Syntax.AssignmentPattern:
-                    break;
-                case syntax_1.Syntax.SpreadElement:
-                    expr.type = syntax_1.Syntax.RestElement;
-                    this.reinterpretExpressionAsPattern(expr.argument);
-                    break;
-                case syntax_1.Syntax.ArrayExpression:
-                    expr.type = syntax_1.Syntax.ArrayPattern;
-                    for (var i = 0; i < expr.elements.length; i++) {
-                        if (expr.elements[i] !== null) {
-                            this.reinterpretExpressionAsPattern(expr.elements[i]);
-                        }
-                    }
-                    break;
-                case syntax_1.Syntax.ObjectExpression:
-                    expr.type = syntax_1.Syntax.ObjectPattern;
-                    for (var i = 0; i < expr.properties.length; i++) {
-                        this.reinterpretExpressionAsPattern(expr.properties[i].value);
-                    }
-                    break;
-                case syntax_1.Syntax.AssignmentExpression:
-                    expr.type = syntax_1.Syntax.AssignmentPattern;
-                    delete expr.operator;
-                    this.reinterpretExpressionAsPattern(expr.left);
-                    break;
-                default:
-                    // Allow other node type for tolerant parsing.
-                    break;
-            }
-        };
-        Parser.prototype.parseGroupExpression = function () {
-            var expr;
-            this.expect('(');
-            if (this.match(')')) {
-                this.nextToken();
-                if (!this.match('=>')) {
-                    this.expect('=>');
-                }
-                expr = {
-                    type: ArrowParameterPlaceHolder,
-                    params: [],
-                    async: false
-                };
-            }
-            else {
-                var startToken = this.lookahead;
-                var params = [];
-                if (this.match('...')) {
-                    expr = this.parseRestElement(params);
-                    this.expect(')');
-                    if (!this.match('=>')) {
-                        this.expect('=>');
-                    }
-                    expr = {
-                        type: ArrowParameterPlaceHolder,
-                        params: [expr],
-                        async: false
-                    };
-                }
-                else {
-                    var arrow = false;
-                    this.context.isBindingElement = true;
-                    expr = this.inheritCoverGrammar(this.parseAssignmentExpression);
-                    if (this.match(',')) {
-                        var expressions = [];
-                        this.context.isAssignmentTarget = false;
-                        expressions.push(expr);
-                        while (this.startMarker.index < this.scanner.length) {
-                            if (!this.match(',')) {
-                                break;
-                            }
-                            this.nextToken();
-                            if (this.match(')')) {
-                                this.nextToken();
-                                for (var i = 0; i < expressions.length; i++) {
-                                    this.reinterpretExpressionAsPattern(expressions[i]);
-                                }
-                                arrow = true;
-                                expr = {
-                                    type: ArrowParameterPlaceHolder,
-                                    params: expressions,
-                                    async: false
-                                };
-                            }
-                            else if (this.match('...')) {
-                                if (!this.context.isBindingElement) {
-                                    this.throwUnexpectedToken(this.lookahead);
-                                }
-                                expressions.push(this.parseRestElement(params));
-                                this.expect(')');
-                                if (!this.match('=>')) {
-                                    this.expect('=>');
-                                }
-                                this.context.isBindingElement = false;
-                                for (var i = 0; i < expressions.length; i++) {
-                                    this.reinterpretExpressionAsPattern(expressions[i]);
-                                }
-                                arrow = true;
-                                expr = {
-                                    type: ArrowParameterPlaceHolder,
-                                    params: expressions,
-                                    async: false
-                                };
-                            }
-                            else {
-                                expressions.push(this.inheritCoverGrammar(this.parseAssignmentExpression));
-                            }
-                            if (arrow) {
-                                break;
-                            }
-                        }
-                        if (!arrow) {
-                            expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));
-                        }
-                    }
-                    if (!arrow) {
-                        this.expect(')');
-                        if (this.match('=>')) {
-                            if (expr.type === syntax_1.Syntax.Identifier && expr.name === 'yield') {
-                                arrow = true;
-                                expr = {
-                                    type: ArrowParameterPlaceHolder,
-                                    params: [expr],
-                                    async: false
-                                };
-                            }
-                            if (!arrow) {
-                                if (!this.context.isBindingElement) {
-                                    this.throwUnexpectedToken(this.lookahead);
-                                }
-                                if (expr.type === syntax_1.Syntax.SequenceExpression) {
-                                    for (var i = 0; i < expr.expressions.length; i++) {
-                                        this.reinterpretExpressionAsPattern(expr.expressions[i]);
-                                    }
-                                }
-                                else {
-                                    this.reinterpretExpressionAsPattern(expr);
-                                }
-                                var params_1 = (expr.type === syntax_1.Syntax.SequenceExpression ? expr.expressions : [expr]);
-                                expr = {
-                                    type: ArrowParameterPlaceHolder,
-                                    params: params_1,
-                                    async: false
-                                };
-                            }
-                        }
-                        this.context.isBindingElement = false;
-                    }
-                }
-            }
-            return expr;
-        };
-        // ECMA-262 12.3 Left-Hand-Side Expressions
-        Parser.prototype.parseArguments = function () {
-            this.expect('(');
-            var args = [];
-            if (!this.match(')')) {
-                while (true) {
-                    var expr = this.match('...') ? this.parseSpreadElement() :
-                        this.isolateCoverGrammar(this.parseAssignmentExpression);
-                    args.push(expr);
-                    if (this.match(')')) {
-                        break;
-                    }
-                    this.expectCommaSeparator();
-                    if (this.match(')')) {
-                        break;
-                    }
-                }
-            }
-            this.expect(')');
-            return args;
-        };
-        Parser.prototype.isIdentifierName = function (token) {
-            return token.type === token_1.Token.Identifier ||
-                token.type === token_1.Token.Keyword ||
-                token.type === token_1.Token.BooleanLiteral ||
-                token.type === token_1.Token.NullLiteral;
-        };
-        Parser.prototype.parseIdentifierName = function () {
-            var node = this.createNode();
-            var token = this.nextToken();
-            if (!this.isIdentifierName(token)) {
-                this.throwUnexpectedToken(token);
-            }
-            return this.finalize(node, new Node.Identifier(token.value));
-        };
-        Parser.prototype.parseNewExpression = function () {
-            var node = this.createNode();
-            var id = this.parseIdentifierName();
-            assert_1.assert(id.name === 'new', 'New expression must start with `new`');
-            var expr;
-            if (this.match('.')) {
-                this.nextToken();
-                if (this.lookahead.type === token_1.Token.Identifier && this.context.inFunctionBody && this.lookahead.value === 'target') {
-                    var property = this.parseIdentifierName();
-                    expr = new Node.MetaProperty(id, property);
-                }
-                else {
-                    this.throwUnexpectedToken(this.lookahead);
-                }
-            }
-            else {
-                var callee = this.isolateCoverGrammar(this.parseLeftHandSideExpression);
-                var args = this.match('(') ? this.parseArguments() : [];
-                expr = new Node.NewExpression(callee, args);
-                this.context.isAssignmentTarget = false;
-                this.context.isBindingElement = false;
+        JSXParser.prototype.parseJSXRoot = function () {
+            // Pop the opening '<' added from the lookahead.
+            if (this.config.tokens) {
+                this.tokens.pop();
             }
-            return this.finalize(node, expr);
-        };
-        Parser.prototype.parseAsyncArgument = function () {
-            var arg = this.parseAssignmentExpression();
-            this.context.firstCoverInitializedNameError = null;
-            return arg;
+            this.startJSX();
+            var element = this.parseJSXElement();
+            this.finishJSX();
+            return element;
         };
-        Parser.prototype.parseAsyncArguments = function () {
-            this.expect('(');
-            var args = [];
-            if (!this.match(')')) {
-                while (true) {
-                    var expr = this.match('...') ? this.parseSpreadElement() :
-                        this.isolateCoverGrammar(this.parseAsyncArgument);
-                    args.push(expr);
-                    if (this.match(')')) {
-                        break;
-                    }
-                    this.expectCommaSeparator();
-                    if (this.match(')')) {
-                        break;
-                    }
-                }
-            }
-            this.expect(')');
-            return args;
-        };
-        Parser.prototype.parseLeftHandSideExpressionAllowCall = function () {
-            var startToken = this.lookahead;
-            var maybeAsync = this.matchContextualKeyword('async');
-            var previousAllowIn = this.context.allowIn;
-            this.context.allowIn = true;
-            var expr;
-            if (this.matchKeyword('super') && this.context.inFunctionBody) {
-                expr = this.createNode();
-                this.nextToken();
-                expr = this.finalize(expr, new Node.Super());
-                if (!this.match('(') && !this.match('.') && !this.match('[')) {
-                    this.throwUnexpectedToken(this.lookahead);
-                }
-            }
-            else {
-                expr = this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);
-            }
-            while (true) {
-                if (this.match('.')) {
-                    this.context.isBindingElement = false;
-                    this.context.isAssignmentTarget = true;
-                    this.expect('.');
-                    var property = this.parseIdentifierName();
-                    expr = this.finalize(this.startNode(startToken), new Node.StaticMemberExpression(expr, property));
-                }
-                else if (this.match('(')) {
-                    var asyncArrow = maybeAsync && (startToken.lineNumber === this.lookahead.lineNumber);
-                    this.context.isBindingElement = false;
-                    this.context.isAssignmentTarget = false;
-                    var args = asyncArrow ? this.parseAsyncArguments() : this.parseArguments();
-                    expr = this.finalize(this.startNode(startToken), new Node.CallExpression(expr, args));
-                    if (asyncArrow && this.match('=>')) {
-                        expr = {
-                            type: ArrowParameterPlaceHolder,
-                            params: args,
-                            async: true
-                        };
-                    }
-                }
-                else if (this.match('[')) {
-                    this.context.isBindingElement = false;
-                    this.context.isAssignmentTarget = true;
-                    this.expect('[');
-                    var property = this.isolateCoverGrammar(this.parseExpression);
-                    this.expect(']');
-                    expr = this.finalize(this.startNode(startToken), new Node.ComputedMemberExpression(expr, property));
-                }
-                else if (this.lookahead.type === token_1.Token.Template && this.lookahead.head) {
-                    var quasi = this.parseTemplateLiteral();
-                    expr = this.finalize(this.startNode(startToken), new Node.TaggedTemplateExpression(expr, quasi));
-                }
-                else {
-                    break;
-                }
-            }
-            this.context.allowIn = previousAllowIn;
-            return expr;
-        };
-        Parser.prototype.parseSuper = function () {
-            var node = this.createNode();
-            this.expectKeyword('super');
-            if (!this.match('[') && !this.match('.')) {
-                this.throwUnexpectedToken(this.lookahead);
-            }
-            return this.finalize(node, new Node.Super());
-        };
-        Parser.prototype.parseLeftHandSideExpression = function () {
-            assert_1.assert(this.context.allowIn, 'callee of new expression always allow in keyword.');
-            var node = this.startNode(this.lookahead);
-            var expr = (this.matchKeyword('super') && this.context.inFunctionBody) ? this.parseSuper() :
-                this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);
-            while (true) {
-                if (this.match('[')) {
-                    this.context.isBindingElement = false;
-                    this.context.isAssignmentTarget = true;
-                    this.expect('[');
-                    var property = this.isolateCoverGrammar(this.parseExpression);
-                    this.expect(']');
-                    expr = this.finalize(node, new Node.ComputedMemberExpression(expr, property));
-                }
-                else if (this.match('.')) {
-                    this.context.isBindingElement = false;
-                    this.context.isAssignmentTarget = true;
-                    this.expect('.');
-                    var property = this.parseIdentifierName();
-                    expr = this.finalize(node, new Node.StaticMemberExpression(expr, property));
-                }
-                else if (this.lookahead.type === token_1.Token.Template && this.lookahead.head) {
-                    var quasi = this.parseTemplateLiteral();
-                    expr = this.finalize(node, new Node.TaggedTemplateExpression(expr, quasi));
-                }
-                else {
-                    break;
-                }
-            }
-            return expr;
-        };
-        // ECMA-262 12.4 Update Expressions
-        Parser.prototype.parseUpdateExpression = function () {
-            var expr;
-            var startToken = this.lookahead;
-            if (this.match('++') || this.match('--')) {
-                var node = this.startNode(startToken);
-                var token = this.nextToken();
-                expr = this.inheritCoverGrammar(this.parseUnaryExpression);
-                if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
-                    this.tolerateError(messages_1.Messages.StrictLHSPrefix);
-                }
-                if (!this.context.isAssignmentTarget) {
-                    this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
-                }
-                var prefix = true;
-                expr = this.finalize(node, new Node.UpdateExpression(token.value, expr, prefix));
-                this.context.isAssignmentTarget = false;
-                this.context.isBindingElement = false;
-            }
-            else {
-                expr = this.inheritCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
-                if (!this.hasLineTerminator && this.lookahead.type === token_1.Token.Punctuator) {
-                    if (this.match('++') || this.match('--')) {
-                        if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
-                            this.tolerateError(messages_1.Messages.StrictLHSPostfix);
-                        }
-                        if (!this.context.isAssignmentTarget) {
-                            this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
-                        }
-                        this.context.isAssignmentTarget = false;
-                        this.context.isBindingElement = false;
-                        var operator = this.nextToken().value;
-                        var prefix = false;
-                        expr = this.finalize(this.startNode(startToken), new Node.UpdateExpression(operator, expr, prefix));
-                    }
-                }
-            }
-            return expr;
-        };
-        // ECMA-262 12.5 Unary Operators
-        Parser.prototype.parseAwaitExpression = function () {
-            var node = this.createNode();
-            this.nextToken();
-            var argument = this.parseUnaryExpression();
-            return this.finalize(node, new Node.AwaitExpression(argument));
-        };
-        Parser.prototype.parseUnaryExpression = function () {
-            var expr;
-            if (this.match('+') || this.match('-') || this.match('~') || this.match('!') ||
-                this.matchKeyword('delete') || this.matchKeyword('void') || this.matchKeyword('typeof')) {
-                var node = this.startNode(this.lookahead);
-                var token = this.nextToken();
-                expr = this.inheritCoverGrammar(this.parseUnaryExpression);
-                expr = this.finalize(node, new Node.UnaryExpression(token.value, expr));
-                if (this.context.strict && expr.operator === 'delete' && expr.argument.type === syntax_1.Syntax.Identifier) {
-                    this.tolerateError(messages_1.Messages.StrictDelete);
-                }
-                this.context.isAssignmentTarget = false;
-                this.context.isBindingElement = false;
-            }
-            else if (this.context.await && this.matchContextualKeyword('await')) {
-                expr = this.parseAwaitExpression();
-            }
-            else {
-                expr = this.parseUpdateExpression();
-            }
-            return expr;
-        };
-        Parser.prototype.parseExponentiationExpression = function () {
-            var startToken = this.lookahead;
-            var expr = this.inheritCoverGrammar(this.parseUnaryExpression);
-            if (expr.type !== syntax_1.Syntax.UnaryExpression && this.match('**')) {
-                this.nextToken();
-                this.context.isAssignmentTarget = false;
-                this.context.isBindingElement = false;
-                var left = expr;
-                var right = this.isolateCoverGrammar(this.parseExponentiationExpression);
-                expr = this.finalize(this.startNode(startToken), new Node.BinaryExpression('**', left, right));
-            }
-            return expr;
-        };
-        // ECMA-262 12.6 Exponentiation Operators
-        // ECMA-262 12.7 Multiplicative Operators
-        // ECMA-262 12.8 Additive Operators
-        // ECMA-262 12.9 Bitwise Shift Operators
-        // ECMA-262 12.10 Relational Operators
-        // ECMA-262 12.11 Equality Operators
-        // ECMA-262 12.12 Binary Bitwise Operators
-        // ECMA-262 12.13 Binary Logical Operators
-        Parser.prototype.binaryPrecedence = function (token) {
-            var op = token.value;
-            var precedence;
-            if (token.type === token_1.Token.Punctuator) {
-                precedence = this.operatorPrecedence[op] || 0;
-            }
-            else if (token.type === token_1.Token.Keyword) {
-                precedence = (op === 'instanceof' || (this.context.allowIn && op === 'in')) ? 7 : 0;
-            }
-            else {
-                precedence = 0;
-            }
-            return precedence;
-        };
-        Parser.prototype.parseBinaryExpression = function () {
-            var startToken = this.lookahead;
-            var expr = this.inheritCoverGrammar(this.parseExponentiationExpression);
-            var token = this.lookahead;
-            var prec = this.binaryPrecedence(token);
-            if (prec > 0) {
-                this.nextToken();
-                token.prec = prec;
-                this.context.isAssignmentTarget = false;
-                this.context.isBindingElement = false;
-                var markers = [startToken, this.lookahead];
-                var left = expr;
-                var right = this.isolateCoverGrammar(this.parseExponentiationExpression);
-                var stack = [left, token, right];
-                while (true) {
-                    prec = this.binaryPrecedence(this.lookahead);
-                    if (prec <= 0) {
-                        break;
-                    }
-                    // Reduce: make a binary expression from the three topmost entries.
-                    while ((stack.length > 2) && (prec <= stack[stack.length - 2].prec)) {
-                        right = stack.pop();
-                        var operator = stack.pop().value;
-                        left = stack.pop();
-                        markers.pop();
-                        var node = this.startNode(markers[markers.length - 1]);
-                        stack.push(this.finalize(node, new Node.BinaryExpression(operator, left, right)));
-                    }
-                    // Shift.
-                    token = this.nextToken();
-                    token.prec = prec;
-                    stack.push(token);
-                    markers.push(this.lookahead);
-                    stack.push(this.isolateCoverGrammar(this.parseExponentiationExpression));
-                }
-                // Final reduce to clean-up the stack.
-                var i = stack.length - 1;
-                expr = stack[i];
-                markers.pop();
-                while (i > 1) {
-                    var node = this.startNode(markers.pop());
-                    expr = this.finalize(node, new Node.BinaryExpression(stack[i - 1].value, stack[i - 2], expr));
-                    i -= 2;
-                }
-            }
-            return expr;
-        };
-        // ECMA-262 12.14 Conditional Operator
-        Parser.prototype.parseConditionalExpression = function () {
-            var startToken = this.lookahead;
-            var expr = this.inheritCoverGrammar(this.parseBinaryExpression);
-            if (this.match('?')) {
-                this.nextToken();
-                var previousAllowIn = this.context.allowIn;
-                this.context.allowIn = true;
-                var consequent = this.isolateCoverGrammar(this.parseAssignmentExpression);
-                this.context.allowIn = previousAllowIn;
-                this.expect(':');
-                var alternate = this.isolateCoverGrammar(this.parseAssignmentExpression);
-                expr = this.finalize(this.startNode(startToken), new Node.ConditionalExpression(expr, consequent, alternate));
-                this.context.isAssignmentTarget = false;
-                this.context.isBindingElement = false;
-            }
-            return expr;
-        };
-        // ECMA-262 12.15 Assignment Operators
-        Parser.prototype.checkPatternParam = function (options, param) {
-            switch (param.type) {
-                case syntax_1.Syntax.Identifier:
-                    this.validateParam(options, param, param.name);
-                    break;
-                case syntax_1.Syntax.RestElement:
-                    this.checkPatternParam(options, param.argument);
-                    break;
-                case syntax_1.Syntax.AssignmentPattern:
-                    this.checkPatternParam(options, param.left);
-                    break;
-                case syntax_1.Syntax.ArrayPattern:
-                    for (var i = 0; i < param.elements.length; i++) {
-                        if (param.elements[i] !== null) {
-                            this.checkPatternParam(options, param.elements[i]);
-                        }
-                    }
-                    break;
-                case syntax_1.Syntax.ObjectPattern:
-                    for (var i = 0; i < param.properties.length; i++) {
-                        this.checkPatternParam(options, param.properties[i].value);
-                    }
-                    break;
-                default:
-                    break;
-            }
-        };
-        Parser.prototype.reinterpretAsCoverFormalsList = function (expr) {
-            var params = [expr];
-            var options;
-            var asyncArrow = false;
-            switch (expr.type) {
-                case syntax_1.Syntax.Identifier:
-                    break;
-                case ArrowParameterPlaceHolder:
-                    params = expr.params;
-                    asyncArrow = expr.async;
-                    break;
-                default:
-                    return null;
-            }
-            options = {
-                paramSet: {}
-            };
-            for (var i = 0; i < params.length; ++i) {
-                var param = params[i];
-                if (param.type === syntax_1.Syntax.AssignmentPattern) {
-                    if (param.right.type === syntax_1.Syntax.YieldExpression) {
-                        if (param.right.argument) {
-                            this.throwUnexpectedToken(this.lookahead);
-                        }
-                        param.right.type = syntax_1.Syntax.Identifier;
-                        param.right.name = 'yield';
-                        delete param.right.argument;
-                        delete param.right.delegate;
-                    }
-                }
-                else if (asyncArrow && param.type === syntax_1.Syntax.Identifier && param.name === 'await') {
-                    this.throwUnexpectedToken(this.lookahead);
-                }
-                this.checkPatternParam(options, param);
-                params[i] = param;
-            }
-            if (this.context.strict || !this.context.allowYield) {
-                for (var i = 0; i < params.length; ++i) {
-                    var param = params[i];
-                    if (param.type === syntax_1.Syntax.YieldExpression) {
-                        this.throwUnexpectedToken(this.lookahead);
-                    }
-                }
-            }
-            if (options.message === messages_1.Messages.StrictParamDupe) {
-                var token = this.context.strict ? options.stricted : options.firstRestricted;
-                this.throwUnexpectedToken(token, options.message);
-            }
-            return {
-                params: params,
-                stricted: options.stricted,
-                firstRestricted: options.firstRestricted,
-                message: options.message
-            };
-        };
-        Parser.prototype.parseAssignmentExpression = function () {
-            var expr;
-            if (!this.context.allowYield && this.matchKeyword('yield')) {
-                expr = this.parseYieldExpression();
-            }
-            else {
-                var startToken = this.lookahead;
-                var token = startToken;
-                expr = this.parseConditionalExpression();
-                if (token.type === token_1.Token.Identifier && (token.lineNumber === this.lookahead.lineNumber) && token.value === 'async' && (this.lookahead.type === token_1.Token.Identifier)) {
-                    var arg = this.parsePrimaryExpression();
-                    expr = {
-                        type: ArrowParameterPlaceHolder,
-                        params: [arg],
-                        async: true
-                    };
-                }
-                if (expr.type === ArrowParameterPlaceHolder || this.match('=>')) {
-                    // ECMA-262 14.2 Arrow Function Definitions
-                    this.context.isAssignmentTarget = false;
-                    this.context.isBindingElement = false;
-                    var isAsync = expr.async;
-                    var list = this.reinterpretAsCoverFormalsList(expr);
-                    if (list) {
-                        if (this.hasLineTerminator) {
-                            this.tolerateUnexpectedToken(this.lookahead);
-                        }
-                        this.context.firstCoverInitializedNameError = null;
-                        var previousStrict = this.context.strict;
-                        var previousAllowYield = this.context.allowYield;
-                        var previousAwait = this.context.await;
-                        this.context.allowYield = true;
-                        this.context.await = isAsync;
-                        var node = this.startNode(startToken);
-                        this.expect('=>');
-                        var body = this.match('{') ? this.parseFunctionSourceElements() :
-                            this.isolateCoverGrammar(this.parseAssignmentExpression);
-                        var expression = body.type !== syntax_1.Syntax.BlockStatement;
-                        if (this.context.strict && list.firstRestricted) {
-                            this.throwUnexpectedToken(list.firstRestricted, list.message);
-                        }
-                        if (this.context.strict && list.stricted) {
-                            this.tolerateUnexpectedToken(list.stricted, list.message);
-                        }
-                        expr = isAsync ? this.finalize(node, new Node.AsyncArrowFunctionExpression(list.params, body, expression)) :
-                            this.finalize(node, new Node.ArrowFunctionExpression(list.params, body, expression));
-                        this.context.strict = previousStrict;
-                        this.context.allowYield = previousAllowYield;
-                        this.context.await = previousAwait;
-                    }
-                }
-                else {
-                    if (this.matchAssign()) {
-                        if (!this.context.isAssignmentTarget) {
-                            this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
-                        }
-                        if (this.context.strict && expr.type === syntax_1.Syntax.Identifier) {
-                            var id = (expr);
-                            if (this.scanner.isRestrictedWord(id.name)) {
-                                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictLHSAssignment);
-                            }
-                            if (this.scanner.isStrictModeReservedWord(id.name)) {
-                                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
-                            }
-                        }
-                        if (!this.match('=')) {
-                            this.context.isAssignmentTarget = false;
-                            this.context.isBindingElement = false;
-                        }
-                        else {
-                            this.reinterpretExpressionAsPattern(expr);
-                        }
-                        token = this.nextToken();
-                        var right = this.isolateCoverGrammar(this.parseAssignmentExpression);
-                        expr = this.finalize(this.startNode(startToken), new Node.AssignmentExpression(token.value, expr, right));
-                        this.context.firstCoverInitializedNameError = null;
-                    }
-                }
-            }
-            return expr;
-        };
-        // ECMA-262 12.16 Comma Operator
-        Parser.prototype.parseExpression = function () {
-            var startToken = this.lookahead;
-            var expr = this.isolateCoverGrammar(this.parseAssignmentExpression);
-            if (this.match(',')) {
-                var expressions = [];
-                expressions.push(expr);
-                while (this.startMarker.index < this.scanner.length) {
-                    if (!this.match(',')) {
-                        break;
-                    }
-                    this.nextToken();
-                    expressions.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
-                }
-                expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));
-            }
-            return expr;
-        };
-        // ECMA-262 13.2 Block
-        Parser.prototype.parseStatementListItem = function () {
-            var statement;
-            this.context.isAssignmentTarget = true;
-            this.context.isBindingElement = true;
-            if (this.lookahead.type === token_1.Token.Keyword) {
-                switch (this.lookahead.value) {
-                    case 'export':
-                        if (!this.context.isModule) {
-                            this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalExportDeclaration);
-                        }
-                        statement = this.parseExportDeclaration();
-                        break;
-                    case 'import':
-                        if (!this.context.isModule) {
-                            this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalImportDeclaration);
-                        }
-                        statement = this.parseImportDeclaration();
-                        break;
-                    case 'const':
-                        statement = this.parseLexicalDeclaration({ inFor: false });
-                        break;
-                    case 'function':
-                        statement = this.parseFunctionDeclaration();
-                        break;
-                    case 'class':
-                        statement = this.parseClassDeclaration();
-                        break;
-                    case 'let':
-                        statement = this.isLexicalDeclaration() ? this.parseLexicalDeclaration({ inFor: false }) : this.parseStatement();
-                        break;
-                    default:
-                        statement = this.parseStatement();
-                        break;
-                }
-            }
-            else {
-                statement = this.parseStatement();
-            }
-            return statement;
-        };
-        Parser.prototype.parseBlock = function () {
-            var node = this.createNode();
-            this.expect('{');
-            var block = [];
-            while (true) {
-                if (this.match('}')) {
-                    break;
-                }
-                block.push(this.parseStatementListItem());
-            }
-            this.expect('}');
-            return this.finalize(node, new Node.BlockStatement(block));
-        };
-        // ECMA-262 13.3.1 Let and Const Declarations
-        Parser.prototype.parseLexicalBinding = function (kind, options) {
-            var node = this.createNode();
-            var params = [];
-            var id = this.parsePattern(params, kind);
-            // ECMA-262 12.2.1
-            if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
-                if (this.scanner.isRestrictedWord((id).name)) {
-                    this.tolerateError(messages_1.Messages.StrictVarName);
-                }
-            }
-            var init = null;
-            if (kind === 'const') {
-                if (!this.matchKeyword('in') && !this.matchContextualKeyword('of')) {
-                    if (this.match('=')) {
-                        this.nextToken();
-                        init = this.isolateCoverGrammar(this.parseAssignmentExpression);
-                    }
-                    else {
-                        this.throwError(messages_1.Messages.DeclarationMissingInitializer, 'const');
-                    }
-                }
-            }
-            else if ((!options.inFor && id.type !== syntax_1.Syntax.Identifier) || this.match('=')) {
-                this.expect('=');
-                init = this.isolateCoverGrammar(this.parseAssignmentExpression);
-            }
-            return this.finalize(node, new Node.VariableDeclarator(id, init));
-        };
-        Parser.prototype.parseBindingList = function (kind, options) {
-            var list = [this.parseLexicalBinding(kind, options)];
-            while (this.match(',')) {
-                this.nextToken();
-                list.push(this.parseLexicalBinding(kind, options));
-            }
-            return list;
-        };
-        Parser.prototype.isLexicalDeclaration = function () {
-            var previousIndex = this.scanner.index;
-            var previousLineNumber = this.scanner.lineNumber;
-            var previousLineStart = this.scanner.lineStart;
-            this.collectComments();
-            var next = this.scanner.lex();
-            this.scanner.index = previousIndex;
-            this.scanner.lineNumber = previousLineNumber;
-            this.scanner.lineStart = previousLineStart;
-            return (next.type === token_1.Token.Identifier) ||
-                (next.type === token_1.Token.Punctuator && next.value === '[') ||
-                (next.type === token_1.Token.Punctuator && next.value === '{') ||
-                (next.type === token_1.Token.Keyword && next.value === 'let') ||
-                (next.type === token_1.Token.Keyword && next.value === 'yield');
-        };
-        Parser.prototype.parseLexicalDeclaration = function (options) {
-            var node = this.createNode();
-            var kind = this.nextToken().value;
-            assert_1.assert(kind === 'let' || kind === 'const', 'Lexical declaration must be either let or const');
-            var declarations = this.parseBindingList(kind, options);
-            this.consumeSemicolon();
-            return this.finalize(node, new Node.VariableDeclaration(declarations, kind));
-        };
-        // ECMA-262 13.3.3 Destructuring Binding Patterns
-        Parser.prototype.parseBindingRestElement = function (params, kind) {
-            var node = this.createNode();
-            this.expect('...');
-            params.push(this.lookahead);
-            var arg = this.parseVariableIdentifier(kind);
-            return this.finalize(node, new Node.RestElement(arg));
-        };
-        Parser.prototype.parseArrayPattern = function (params, kind) {
-            var node = this.createNode();
-            this.expect('[');
-            var elements = [];
-            while (!this.match(']')) {
-                if (this.match(',')) {
-                    this.nextToken();
-                    elements.push(null);
-                }
-                else {
-                    if (this.match('...')) {
-                        elements.push(this.parseBindingRestElement(params, kind));
-                        break;
-                    }
-                    else {
-                        elements.push(this.parsePatternWithDefault(params, kind));
-                    }
-                    if (!this.match(']')) {
-                        this.expect(',');
-                    }
-                }
-            }
-            this.expect(']');
-            return this.finalize(node, new Node.ArrayPattern(elements));
-        };
-        Parser.prototype.parsePropertyPattern = function (params, kind) {
-            var node = this.createNode();
-            var computed = false;
-            var shorthand = false;
-            var method = false;
-            var key;
-            var value;
-            if (this.lookahead.type === token_1.Token.Identifier) {
-                var keyToken = this.lookahead;
-                key = this.parseVariableIdentifier();
-                var init = this.finalize(node, new Node.Identifier(keyToken.value));
-                if (this.match('=')) {
-                    params.push(keyToken);
-                    shorthand = true;
-                    this.nextToken();
-                    var expr = this.parseAssignmentExpression();
-                    value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr));
-                }
-                else if (!this.match(':')) {
-                    params.push(keyToken);
-                    shorthand = true;
-                    value = init;
-                }
-                else {
-                    this.expect(':');
-                    value = this.parsePatternWithDefault(params, kind);
-                }
-            }
-            else {
-                computed = this.match('[');
-                key = this.parseObjectPropertyKey();
-                this.expect(':');
-                value = this.parsePatternWithDefault(params, kind);
-            }
-            return this.finalize(node, new Node.Property('init', key, computed, value, method, shorthand));
-        };
-        Parser.prototype.parseObjectPattern = function (params, kind) {
-            var node = this.createNode();
-            var properties = [];
-            this.expect('{');
-            while (!this.match('}')) {
-                properties.push(this.parsePropertyPattern(params, kind));
-                if (!this.match('}')) {
-                    this.expect(',');
-                }
-            }
-            this.expect('}');
-            return this.finalize(node, new Node.ObjectPattern(properties));
-        };
-        Parser.prototype.parsePattern = function (params, kind) {
-            var pattern;
-            if (this.match('[')) {
-                pattern = this.parseArrayPattern(params, kind);
-            }
-            else if (this.match('{')) {
-                pattern = this.parseObjectPattern(params, kind);
-            }
-            else {
-                if (this.matchKeyword('let') && (kind === 'const' || kind === 'let')) {
-                    this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.LetInLexicalBinding);
-                }
-                params.push(this.lookahead);
-                pattern = this.parseVariableIdentifier(kind);
-            }
-            return pattern;
-        };
-        Parser.prototype.parsePatternWithDefault = function (params, kind) {
-            var startToken = this.lookahead;
-            var pattern = this.parsePattern(params, kind);
-            if (this.match('=')) {
-                this.nextToken();
-                var previousAllowYield = this.context.allowYield;
-                this.context.allowYield = true;
-                var right = this.isolateCoverGrammar(this.parseAssignmentExpression);
-                this.context.allowYield = previousAllowYield;
-                pattern = this.finalize(this.startNode(startToken), new Node.AssignmentPattern(pattern, right));
-            }
-            return pattern;
-        };
-        // ECMA-262 13.3.2 Variable Statement
-        Parser.prototype.parseVariableIdentifier = function (kind) {
-            var node = this.createNode();
-            var token = this.nextToken();
-            if (token.type === token_1.Token.Keyword && token.value === 'yield') {
-                if (this.context.strict) {
-                    this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
-                }
-                if (!this.context.allowYield) {
-                    this.throwUnexpectedToken(token);
-                }
-            }
-            else if (token.type !== token_1.Token.Identifier) {
-                if (this.context.strict && token.type === token_1.Token.Keyword && this.scanner.isStrictModeReservedWord(token.value)) {
-                    this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
-                }
-                else {
-                    if (this.context.strict || token.value !== 'let' || kind !== 'var') {
-                        this.throwUnexpectedToken(token);
-                    }
-                }
-            }
-            else if ((this.context.isModule || this.context.await) && token.type === token_1.Token.Identifier && token.value === 'await') {
-                this.tolerateUnexpectedToken(token);
-            }
-            return this.finalize(node, new Node.Identifier(token.value));
-        };
-        Parser.prototype.parseVariableDeclaration = function (options) {
-            var node = this.createNode();
-            var params = [];
-            var id = this.parsePattern(params, 'var');
-            // ECMA-262 12.2.1
-            if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
-                if (this.scanner.isRestrictedWord((id).name)) {
-                    this.tolerateError(messages_1.Messages.StrictVarName);
-                }
-            }
-            var init = null;
-            if (this.match('=')) {
-                this.nextToken();
-                init = this.isolateCoverGrammar(this.parseAssignmentExpression);
-            }
-            else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) {
-                this.expect('=');
-            }
-            return this.finalize(node, new Node.VariableDeclarator(id, init));
-        };
-        Parser.prototype.parseVariableDeclarationList = function (options) {
-            var opt = { inFor: options.inFor };
-            var list = [];
-            list.push(this.parseVariableDeclaration(opt));
-            while (this.match(',')) {
-                this.nextToken();
-                list.push(this.parseVariableDeclaration(opt));
-            }
-            return list;
-        };
-        Parser.prototype.parseVariableStatement = function () {
-            var node = this.createNode();
-            this.expectKeyword('var');
-            var declarations = this.parseVariableDeclarationList({ inFor: false });
-            this.consumeSemicolon();
-            return this.finalize(node, new Node.VariableDeclaration(declarations, 'var'));
-        };
-        // ECMA-262 13.4 Empty Statement
-        Parser.prototype.parseEmptyStatement = function () {
-            var node = this.createNode();
-            this.expect(';');
-            return this.finalize(node, new Node.EmptyStatement());
-        };
-        // ECMA-262 13.5 Expression Statement
-        Parser.prototype.parseExpressionStatement = function () {
-            var node = this.createNode();
-            var expr = this.parseExpression();
-            this.consumeSemicolon();
-            return this.finalize(node, new Node.ExpressionStatement(expr));
-        };
-        // ECMA-262 13.6 If statement
-        Parser.prototype.parseIfStatement = function () {
-            var node = this.createNode();
-            var consequent;
-            var alternate = null;
-            this.expectKeyword('if');
-            this.expect('(');
-            var test = this.parseExpression();
-            if (!this.match(')') && this.config.tolerant) {
-                this.tolerateUnexpectedToken(this.nextToken());
-                consequent = this.finalize(this.createNode(), new Node.EmptyStatement());
-            }
-            else {
-                this.expect(')');
-                consequent = this.parseStatement();
-                if (this.matchKeyword('else')) {
-                    this.nextToken();
-                    alternate = this.parseStatement();
-                }
-            }
-            return this.finalize(node, new Node.IfStatement(test, consequent, alternate));
-        };
-        // ECMA-262 13.7.2 The do-while Statement
-        Parser.prototype.parseDoWhileStatement = function () {
-            var node = this.createNode();
-            this.expectKeyword('do');
-            var previousInIteration = this.context.inIteration;
-            this.context.inIteration = true;
-            var body = this.parseStatement();
-            this.context.inIteration = previousInIteration;
-            this.expectKeyword('while');
-            this.expect('(');
-            var test = this.parseExpression();
-            this.expect(')');
-            if (this.match(';')) {
-                this.nextToken();
-            }
-            return this.finalize(node, new Node.DoWhileStatement(body, test));
-        };
-        // ECMA-262 13.7.3 The while Statement
-        Parser.prototype.parseWhileStatement = function () {
-            var node = this.createNode();
-            var body;
-            this.expectKeyword('while');
-            this.expect('(');
-            var test = this.parseExpression();
-            if (!this.match(')') && this.config.tolerant) {
-                this.tolerateUnexpectedToken(this.nextToken());
-                body = this.finalize(this.createNode(), new Node.EmptyStatement());
-            }
-            else {
-                this.expect(')');
-                var previousInIteration = this.context.inIteration;
-                this.context.inIteration = true;
-                body = this.parseStatement();
-                this.context.inIteration = previousInIteration;
-            }
-            return this.finalize(node, new Node.WhileStatement(test, body));
-        };
-        // ECMA-262 13.7.4 The for Statement
-        // ECMA-262 13.7.5 The for-in and for-of Statements
-        Parser.prototype.parseForStatement = function () {
-            var init = null;
-            var test = null;
-            var update = null;
-            var forIn = true;
-            var left, right;
-            var node = this.createNode();
-            this.expectKeyword('for');
-            this.expect('(');
-            if (this.match(';')) {
-                this.nextToken();
-            }
-            else {
-                if (this.matchKeyword('var')) {
-                    init = this.createNode();
-                    this.nextToken();
-                    var previousAllowIn = this.context.allowIn;
-                    this.context.allowIn = false;
-                    var declarations = this.parseVariableDeclarationList({ inFor: true });
-                    this.context.allowIn = previousAllowIn;
-                    if (declarations.length === 1 && this.matchKeyword('in')) {
-                        var decl = declarations[0];
-                        if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) {
-                            this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, 'for-in');
-                        }
-                        init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
-                        this.nextToken();
-                        left = init;
-                        right = this.parseExpression();
-                        init = null;
-                    }
-                    else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {
-                        init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
-                        this.nextToken();
-                        left = init;
-                        right = this.parseAssignmentExpression();
-                        init = null;
-                        forIn = false;
-                    }
-                    else {
-                        init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
-                        this.expect(';');
-                    }
-                }
-                else if (this.matchKeyword('const') || this.matchKeyword('let')) {
-                    init = this.createNode();
-                    var kind = this.nextToken().value;
-                    if (!this.context.strict && this.lookahead.value === 'in') {
-                        init = this.finalize(init, new Node.Identifier(kind));
-                        this.nextToken();
-                        left = init;
-                        right = this.parseExpression();
-                        init = null;
-                    }
-                    else {
-                        var previousAllowIn = this.context.allowIn;
-                        this.context.allowIn = false;
-                        var declarations = this.parseBindingList(kind, { inFor: true });
-                        this.context.allowIn = previousAllowIn;
-                        if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword('in')) {
-                            init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
-                            this.nextToken();
-                            left = init;
-                            right = this.parseExpression();
-                            init = null;
-                        }
-                        else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {
-                            init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
-                            this.nextToken();
-                            left = init;
-                            right = this.parseAssignmentExpression();
-                            init = null;
-                            forIn = false;
-                        }
-                        else {
-                            this.consumeSemicolon();
-                            init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
-                        }
-                    }
-                }
-                else {
-                    var initStartToken = this.lookahead;
-                    var previousAllowIn = this.context.allowIn;
-                    this.context.allowIn = false;
-                    init = this.inheritCoverGrammar(this.parseAssignmentExpression);
-                    this.context.allowIn = previousAllowIn;
-                    if (this.matchKeyword('in')) {
-                        if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
-                            this.tolerateError(messages_1.Messages.InvalidLHSInForIn);
-                        }
-                        this.nextToken();
-                        this.reinterpretExpressionAsPattern(init);
-                        left = init;
-                        right = this.parseExpression();
-                        init = null;
-                    }
-                    else if (this.matchContextualKeyword('of')) {
-                        if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
-                            this.tolerateError(messages_1.Messages.InvalidLHSInForLoop);
-                        }
-                        this.nextToken();
-                        this.reinterpretExpressionAsPattern(init);
-                        left = init;
-                        right = this.parseAssignmentExpression();
-                        init = null;
-                        forIn = false;
-                    }
-                    else {
-                        if (this.match(',')) {
-                            var initSeq = [init];
-                            while (this.match(',')) {
-                                this.nextToken();
-                                initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
-                            }
-                            init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
-                        }
-                        this.expect(';');
-                    }
-                }
-            }
-            if (typeof left === 'undefined') {
-                if (!this.match(';')) {
-                    test = this.parseExpression();
-                }
-                this.expect(';');
-                if (!this.match(')')) {
-                    update = this.parseExpression();
-                }
-            }
-            var body;
-            if (!this.match(')') && this.config.tolerant) {
-                this.tolerateUnexpectedToken(this.nextToken());
-                body = this.finalize(this.createNode(), new Node.EmptyStatement());
-            }
-            else {
-                this.expect(')');
-                var previousInIteration = this.context.inIteration;
-                this.context.inIteration = true;
-                body = this.isolateCoverGrammar(this.parseStatement);
-                this.context.inIteration = previousInIteration;
-            }
-            return (typeof left === 'undefined') ?
-                this.finalize(node, new Node.ForStatement(init, test, update, body)) :
-                forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) :
-                    this.finalize(node, new Node.ForOfStatement(left, right, body));
-        };
-        // ECMA-262 13.8 The continue statement
-        Parser.prototype.parseContinueStatement = function () {
-            var node = this.createNode();
-            this.expectKeyword('continue');
-            var label = null;
-            if (this.lookahead.type === token_1.Token.Identifier && !this.hasLineTerminator) {
-                var id = this.parseVariableIdentifier();
-                label = id;
-                var key = '$' + id.name;
-                if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
-                    this.throwError(messages_1.Messages.UnknownLabel, id.name);
-                }
-            }
-            this.consumeSemicolon();
-            if (label === null && !this.context.inIteration) {
-                this.throwError(messages_1.Messages.IllegalContinue);
-            }
-            return this.finalize(node, new Node.ContinueStatement(label));
-        };
-        // ECMA-262 13.9 The break statement
-        Parser.prototype.parseBreakStatement = function () {
-            var node = this.createNode();
-            this.expectKeyword('break');
-            var label = null;
-            if (this.lookahead.type === token_1.Token.Identifier && !this.hasLineTerminator) {
-                var id = this.parseVariableIdentifier();
-                var key = '$' + id.name;
-                if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
-                    this.throwError(messages_1.Messages.UnknownLabel, id.name);
-                }
-                label = id;
-            }
-            this.consumeSemicolon();
-            if (label === null && !this.context.inIteration && !this.context.inSwitch) {
-                this.throwError(messages_1.Messages.IllegalBreak);
-            }
-            return this.finalize(node, new Node.BreakStatement(label));
-        };
-        // ECMA-262 13.10 The return statement
-        Parser.prototype.parseReturnStatement = function () {
-            if (!this.context.inFunctionBody) {
-                this.tolerateError(messages_1.Messages.IllegalReturn);
-            }
-            var node = this.createNode();
-            this.expectKeyword('return');
-            var hasArgument = !this.match(';') && !this.match('}') &&
-                !this.hasLineTerminator && this.lookahead.type !== token_1.Token.EOF;
-            var argument = hasArgument ? this.parseExpression() : null;
-            this.consumeSemicolon();
-            return this.finalize(node, new Node.ReturnStatement(argument));
-        };
-        // ECMA-262 13.11 The with statement
-        Parser.prototype.parseWithStatement = function () {
-            if (this.context.strict) {
-                this.tolerateError(messages_1.Messages.StrictModeWith);
-            }
-            var node = this.createNode();
-            this.expectKeyword('with');
-            this.expect('(');
-            var object = this.parseExpression();
-            this.expect(')');
-            var body = this.parseStatement();
-            return this.finalize(node, new Node.WithStatement(object, body));
-        };
-        // ECMA-262 13.12 The switch statement
-        Parser.prototype.parseSwitchCase = function () {
-            var node = this.createNode();
-            var test;
-            if (this.matchKeyword('default')) {
-                this.nextToken();
-                test = null;
-            }
-            else {
-                this.expectKeyword('case');
-                test = this.parseExpression();
-            }
-            this.expect(':');
-            var consequent = [];
-            while (true) {
-                if (this.match('}') || this.matchKeyword('default') || this.matchKeyword('case')) {
-                    break;
-                }
-                consequent.push(this.parseStatementListItem());
-            }
-            return this.finalize(node, new Node.SwitchCase(test, consequent));
-        };
-        Parser.prototype.parseSwitchStatement = function () {
-            var node = this.createNode();
-            this.expectKeyword('switch');
-            this.expect('(');
-            var discriminant = this.parseExpression();
-            this.expect(')');
-            var previousInSwitch = this.context.inSwitch;
-            this.context.inSwitch = true;
-            var cases = [];
-            var defaultFound = false;
-            this.expect('{');
-            while (true) {
-                if (this.match('}')) {
-                    break;
-                }
-                var clause = this.parseSwitchCase();
-                if (clause.test === null) {
-                    if (defaultFound) {
-                        this.throwError(messages_1.Messages.MultipleDefaultsInSwitch);
-                    }
-                    defaultFound = true;
-                }
-                cases.push(clause);
-            }
-            this.expect('}');
-            this.context.inSwitch = previousInSwitch;
-            return this.finalize(node, new Node.SwitchStatement(discriminant, cases));
-        };
-        // ECMA-262 13.13 Labelled Statements
-        Parser.prototype.parseLabelledStatement = function () {
-            var node = this.createNode();
-            var expr = this.parseExpression();
-            var statement;
-            if ((expr.type === syntax_1.Syntax.Identifier) && this.match(':')) {
-                this.nextToken();
-                var id = (expr);
-                var key = '$' + id.name;
-                if (Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
-                    this.throwError(messages_1.Messages.Redeclaration, 'Label', id.name);
-                }
-                this.context.labelSet[key] = true;
-                var labeledBody = this.parseStatement();
-                delete this.context.labelSet[key];
-                statement = new Node.LabeledStatement(id, labeledBody);
-            }
-            else {
-                this.consumeSemicolon();
-                statement = new Node.ExpressionStatement(expr);
-            }
-            return this.finalize(node, statement);
-        };
-        // ECMA-262 13.14 The throw statement
-        Parser.prototype.parseThrowStatement = function () {
-            var node = this.createNode();
-            this.expectKeyword('throw');
-            if (this.hasLineTerminator) {
-                this.throwError(messages_1.Messages.NewlineAfterThrow);
-            }
-            var argument = this.parseExpression();
-            this.consumeSemicolon();
-            return this.finalize(node, new Node.ThrowStatement(argument));
-        };
-        // ECMA-262 13.15 The try statement
-        Parser.prototype.parseCatchClause = function () {
-            var node = this.createNode();
-            this.expectKeyword('catch');
-            this.expect('(');
-            if (this.match(')')) {
-                this.throwUnexpectedToken(this.lookahead);
-            }
-            var params = [];
-            var param = this.parsePattern(params);
-            var paramMap = {};
-            for (var i = 0; i < params.length; i++) {
-                var key = '$' + params[i].value;
-                if (Object.prototype.hasOwnProperty.call(paramMap, key)) {
-                    this.tolerateError(messages_1.Messages.DuplicateBinding, params[i].value);
-                }
-                paramMap[key] = true;
-            }
-            if (this.context.strict && param.type === syntax_1.Syntax.Identifier) {
-                if (this.scanner.isRestrictedWord((param).name)) {
-                    this.tolerateError(messages_1.Messages.StrictCatchVariable);
-                }
-            }
-            this.expect(')');
-            var body = this.parseBlock();
-            return this.finalize(node, new Node.CatchClause(param, body));
-        };
-        Parser.prototype.parseFinallyClause = function () {
-            this.expectKeyword('finally');
-            return this.parseBlock();
-        };
-        Parser.prototype.parseTryStatement = function () {
-            var node = this.createNode();
-            this.expectKeyword('try');
-            var block = this.parseBlock();
-            var handler = this.matchKeyword('catch') ? this.parseCatchClause() : null;
-            var finalizer = this.matchKeyword('finally') ? this.parseFinallyClause() : null;
-            if (!handler && !finalizer) {
-                this.throwError(messages_1.Messages.NoCatchOrFinally);
-            }
-            return this.finalize(node, new Node.TryStatement(block, handler, finalizer));
-        };
-        // ECMA-262 13.16 The debugger statement
-        Parser.prototype.parseDebuggerStatement = function () {
-            var node = this.createNode();
-            this.expectKeyword('debugger');
-            this.consumeSemicolon();
-            return this.finalize(node, new Node.DebuggerStatement());
-        };
-        // ECMA-262 13 Statements
-        Parser.prototype.parseStatement = function () {
-            var statement;
-            switch (this.lookahead.type) {
-                case token_1.Token.BooleanLiteral:
-                case token_1.Token.NullLiteral:
-                case token_1.Token.NumericLiteral:
-                case token_1.Token.StringLiteral:
-                case token_1.Token.Template:
-                case token_1.Token.RegularExpression:
-                    statement = this.parseExpressionStatement();
-                    break;
-                case token_1.Token.Punctuator:
-                    var value = this.lookahead.value;
-                    if (value === '{') {
-                        statement = this.parseBlock();
-                    }
-                    else if (value === '(') {
-                        statement = this.parseExpressionStatement();
-                    }
-                    else if (value === ';') {
-                        statement = this.parseEmptyStatement();
-                    }
-                    else {
-                        statement = this.parseExpressionStatement();
-                    }
-                    break;
-                case token_1.Token.Identifier:
-                    statement = this.matchAsyncFunction() ? this.parseFunctionDeclaration() : this.parseLabelledStatement();
-                    break;
-                case token_1.Token.Keyword:
-                    switch (this.lookahead.value) {
-                        case 'break':
-                            statement = this.parseBreakStatement();
-                            break;
-                        case 'continue':
-                            statement = this.parseContinueStatement();
-                            break;
-                        case 'debugger':
-                            statement = this.parseDebuggerStatement();
-                            break;
-                        case 'do':
-                            statement = this.parseDoWhileStatement();
-                            break;
-                        case 'for':
-                            statement = this.parseForStatement();
-                            break;
-                        case 'function':
-                            statement = this.parseFunctionDeclaration();
-                            break;
-                        case 'if':
-                            statement = this.parseIfStatement();
-                            break;
-                        case 'return':
-                            statement = this.parseReturnStatement();
-                            break;
-                        case 'switch':
-                            statement = this.parseSwitchStatement();
-                            break;
-                        case 'throw':
-                            statement = this.parseThrowStatement();
-                            break;
-                        case 'try':
-                            statement = this.parseTryStatement();
-                            break;
-                        case 'var':
-                            statement = this.parseVariableStatement();
-                            break;
-                        case 'while':
-                            statement = this.parseWhileStatement();
-                            break;
-                        case 'with':
-                            statement = this.parseWithStatement();
-                            break;
-                        default:
-                            statement = this.parseExpressionStatement();
-                            break;
-                    }
-                    break;
-                default:
-                    statement = this.throwUnexpectedToken(this.lookahead);
-            }
-            return statement;
-        };
-        // ECMA-262 14.1 Function Definition
-        Parser.prototype.parseFunctionSourceElements = function () {
-            var node = this.createNode();
-            this.expect('{');
-            var body = this.parseDirectivePrologues();
-            var previousLabelSet = this.context.labelSet;
-            var previousInIteration = this.context.inIteration;
-            var previousInSwitch = this.context.inSwitch;
-            var previousInFunctionBody = this.context.inFunctionBody;
-            this.context.labelSet = {};
-            this.context.inIteration = false;
-            this.context.inSwitch = false;
-            this.context.inFunctionBody = true;
-            while (this.startMarker.index < this.scanner.length) {
-                if (this.match('}')) {
-                    break;
-                }
-                body.push(this.parseStatementListItem());
-            }
-            this.expect('}');
-            this.context.labelSet = previousLabelSet;
-            this.context.inIteration = previousInIteration;
-            this.context.inSwitch = previousInSwitch;
-            this.context.inFunctionBody = previousInFunctionBody;
-            return this.finalize(node, new Node.BlockStatement(body));
-        };
-        Parser.prototype.validateParam = function (options, param, name) {
-            var key = '$' + name;
-            if (this.context.strict) {
-                if (this.scanner.isRestrictedWord(name)) {
-                    options.stricted = param;
-                    options.message = messages_1.Messages.StrictParamName;
-                }
-                if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {
-                    options.stricted = param;
-                    options.message = messages_1.Messages.StrictParamDupe;
-                }
-            }
-            else if (!options.firstRestricted) {
-                if (this.scanner.isRestrictedWord(name)) {
-                    options.firstRestricted = param;
-                    options.message = messages_1.Messages.StrictParamName;
-                }
-                else if (this.scanner.isStrictModeReservedWord(name)) {
-                    options.firstRestricted = param;
-                    options.message = messages_1.Messages.StrictReservedWord;
-                }
-                else if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {
-                    options.stricted = param;
-                    options.message = messages_1.Messages.StrictParamDupe;
-                }
-            }
-            /* istanbul ignore next */
-            if (typeof Object.defineProperty === 'function') {
-                Object.defineProperty(options.paramSet, key, { value: true, enumerable: true, writable: true, configurable: true });
-            }
-            else {
-                options.paramSet[key] = true;
-            }
-        };
-        Parser.prototype.parseRestElement = function (params) {
-            var node = this.createNode();
-            this.nextToken();
-            if (this.match('{')) {
-                this.throwError(messages_1.Messages.ObjectPatternAsRestParameter);
-            }
-            params.push(this.lookahead);
-            var param = this.parseVariableIdentifier();
-            if (this.match('=')) {
-                this.throwError(messages_1.Messages.DefaultRestParameter);
-            }
-            if (!this.match(')')) {
-                this.throwError(messages_1.Messages.ParameterAfterRestParameter);
-            }
-            return this.finalize(node, new Node.RestElement(param));
-        };
-        Parser.prototype.parseFormalParameter = function (options) {
-            var param;
-            var params = [];
-            var token = this.lookahead;
-            if (token.value === '...') {
-                param = this.parseRestElement(params);
-                this.validateParam(options, param.argument, param.argument.name);
-                options.params.push(param);
-                return;
-            }
-            param = this.parsePatternWithDefault(params);
-            for (var i = 0; i < params.length; i++) {
-                this.validateParam(options, params[i], params[i].value);
-            }
-            options.params.push(param);
-        };
-        Parser.prototype.parseFormalParameters = function (firstRestricted) {
-            var options;
-            options = {
-                params: [],
-                firstRestricted: firstRestricted
-            };
-            this.expect('(');
-            if (!this.match(')')) {
-                options.paramSet = {};
-                while (this.startMarker.index < this.scanner.length) {
-                    this.parseFormalParameter(options);
-                    if (this.match(')')) {
-                        break;
-                    }
-                    this.expect(',');
-                    if (this.match(')')) {
-                        break;
-                    }
-                }
-            }
-            this.expect(')');
-            return {
-                params: options.params,
-                stricted: options.stricted,
-                firstRestricted: options.firstRestricted,
-                message: options.message
-            };
-        };
-        Parser.prototype.matchAsyncFunction = function () {
-            var match = this.matchContextualKeyword('async');
-            if (match) {
-                var previousIndex = this.scanner.index;
-                var previousLineNumber = this.scanner.lineNumber;
-                var previousLineStart = this.scanner.lineStart;
-                this.collectComments();
-                var next = this.scanner.lex();
-                this.scanner.index = previousIndex;
-                this.scanner.lineNumber = previousLineNumber;
-                this.scanner.lineStart = previousLineStart;
-                match = (previousLineNumber === next.lineNumber) && ((next.type === token_1.Token.Keyword) || (next.value === 'function'));
-            }
-            return match;
-        };
-        Parser.prototype.parseFunctionDeclaration = function (identifierIsOptional) {
-            var node = this.createNode();
-            var isAsync = this.matchContextualKeyword('async');
-            if (isAsync) {
-                this.nextToken();
-            }
-            this.expectKeyword('function');
-            var isGenerator = isAsync ? false : this.match('*');
-            if (isGenerator) {
-                this.nextToken();
-            }
-            var message;
-            var id = null;
-            var firstRestricted = null;
-            if (!identifierIsOptional || !this.match('(')) {
-                var token = this.lookahead;
-                id = this.parseVariableIdentifier();
-                if (this.context.strict) {
-                    if (this.scanner.isRestrictedWord(token.value)) {
-                        this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);
-                    }
-                }
-                else {
-                    if (this.scanner.isRestrictedWord(token.value)) {
-                        firstRestricted = token;
-                        message = messages_1.Messages.StrictFunctionName;
-                    }
-                    else if (this.scanner.isStrictModeReservedWord(token.value)) {
-                        firstRestricted = token;
-                        message = messages_1.Messages.StrictReservedWord;
-                    }
-                }
-            }
-            var previousAllowAwait = this.context.await;
-            var previousAllowYield = this.context.allowYield;
-            this.context.await = isAsync;
-            this.context.allowYield = !isGenerator;
-            var formalParameters = this.parseFormalParameters(firstRestricted);
-            var params = formalParameters.params;
-            var stricted = formalParameters.stricted;
-            firstRestricted = formalParameters.firstRestricted;
-            if (formalParameters.message) {
-                message = formalParameters.message;
-            }
-            var previousStrict = this.context.strict;
-            var body = this.parseFunctionSourceElements();
-            if (this.context.strict && firstRestricted) {
-                this.throwUnexpectedToken(firstRestricted, message);
-            }
-            if (this.context.strict && stricted) {
-                this.tolerateUnexpectedToken(stricted, message);
-            }
-            this.context.strict = previousStrict;
-            this.context.await = previousAllowAwait;
-            this.context.allowYield = previousAllowYield;
-            return isAsync ? this.finalize(node, new Node.AsyncFunctionDeclaration(id, params, body)) :
-                this.finalize(node, new Node.FunctionDeclaration(id, params, body, isGenerator));
-        };
-        Parser.prototype.parseFunctionExpression = function () {
-            var node = this.createNode();
-            var isAsync = this.matchContextualKeyword('async');
-            if (isAsync) {
-                this.nextToken();
-            }
-            this.expectKeyword('function');
-            var isGenerator = isAsync ? false : this.match('*');
-            if (isGenerator) {
-                this.nextToken();
-            }
-            var message;
-            var id = null;
-            var firstRestricted;
-            var previousAllowAwait = this.context.await;
-            var previousAllowYield = this.context.allowYield;
-            this.context.await = isAsync;
-            this.context.allowYield = !isGenerator;
-            if (!this.match('(')) {
-                var token = this.lookahead;
-                id = (!this.context.strict && !isGenerator && this.matchKeyword('yield')) ? this.parseIdentifierName() : this.parseVariableIdentifier();
-                if (this.context.strict) {
-                    if (this.scanner.isRestrictedWord(token.value)) {
-                        this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);
-                    }
-                }
-                else {
-                    if (this.scanner.isRestrictedWord(token.value)) {
-                        firstRestricted = token;
-                        message = messages_1.Messages.StrictFunctionName;
-                    }
-                    else if (this.scanner.isStrictModeReservedWord(token.value)) {
-                        firstRestricted = token;
-                        message = messages_1.Messages.StrictReservedWord;
-                    }
-                }
-            }
-            var formalParameters = this.parseFormalParameters(firstRestricted);
-            var params = formalParameters.params;
-            var stricted = formalParameters.stricted;
-            firstRestricted = formalParameters.firstRestricted;
-            if (formalParameters.message) {
-                message = formalParameters.message;
-            }
-            var previousStrict = this.context.strict;
-            var body = this.parseFunctionSourceElements();
-            if (this.context.strict && firstRestricted) {
-                this.throwUnexpectedToken(firstRestricted, message);
-            }
-            if (this.context.strict && stricted) {
-                this.tolerateUnexpectedToken(stricted, message);
-            }
-            this.context.strict = previousStrict;
-            this.context.await = previousAllowAwait;
-            this.context.allowYield = previousAllowYield;
-            return isAsync ? this.finalize(node, new Node.AsyncFunctionExpression(id, params, body)) :
-                this.finalize(node, new Node.FunctionExpression(id, params, body, isGenerator));
-        };
-        // ECMA-262 14.1.1 Directive Prologues
-        Parser.prototype.parseDirective = function () {
-            var token = this.lookahead;
-            var node = this.createNode();
-            var expr = this.parseExpression();
-            var directive = (expr.type === syntax_1.Syntax.Literal) ? this.getTokenRaw(token).slice(1, -1) : null;
-            this.consumeSemicolon();
-            return this.finalize(node, directive ? new Node.Directive(expr, directive) : new Node.ExpressionStatement(expr));
-        };
-        Parser.prototype.parseDirectivePrologues = function () {
-            var firstRestricted = null;
-            var body = [];
-            while (true) {
-                var token = this.lookahead;
-                if (token.type !== token_1.Token.StringLiteral) {
-                    break;
-                }
-                var statement = this.parseDirective();
-                body.push(statement);
-                var directive = statement.directive;
-                if (typeof directive !== 'string') {
-                    break;
-                }
-                if (directive === 'use strict') {
-                    this.context.strict = true;
-                    if (firstRestricted) {
-                        this.tolerateUnexpectedToken(firstRestricted, messages_1.Messages.StrictOctalLiteral);
-                    }
-                }
-                else {
-                    if (!firstRestricted && token.octal) {
-                        firstRestricted = token;
-                    }
-                }
-            }
-            return body;
-        };
-        // ECMA-262 14.3 Method Definitions
-        Parser.prototype.qualifiedPropertyName = function (token) {
-            switch (token.type) {
-                case token_1.Token.Identifier:
-                case token_1.Token.StringLiteral:
-                case token_1.Token.BooleanLiteral:
-                case token_1.Token.NullLiteral:
-                case token_1.Token.NumericLiteral:
-                case token_1.Token.Keyword:
-                    return true;
-                case token_1.Token.Punctuator:
-                    return token.value === '[';
-            }
-            return false;
-        };
-        Parser.prototype.parseGetterMethod = function () {
-            var node = this.createNode();
-            this.expect('(');
-            this.expect(')');
-            var isGenerator = false;
-            var params = {
-                params: [],
-                stricted: null,
-                firstRestricted: null,
-                message: null
-            };
-            var previousAllowYield = this.context.allowYield;
-            this.context.allowYield = false;
-            var method = this.parsePropertyMethod(params);
-            this.context.allowYield = previousAllowYield;
-            return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
-        };
-        Parser.prototype.parseSetterMethod = function () {
-            var node = this.createNode();
-            var options = {
-                params: [],
-                firstRestricted: null,
-                paramSet: {}
-            };
-            var isGenerator = false;
-            var previousAllowYield = this.context.allowYield;
-            this.context.allowYield = false;
-            this.expect('(');
-            if (this.match(')')) {
-                this.tolerateUnexpectedToken(this.lookahead);
-            }
-            else {
-                this.parseFormalParameter(options);
-            }
-            this.expect(')');
-            var method = this.parsePropertyMethod(options);
-            this.context.allowYield = previousAllowYield;
-            return this.finalize(node, new Node.FunctionExpression(null, options.params, method, isGenerator));
-        };
-        Parser.prototype.parseGeneratorMethod = function () {
-            var node = this.createNode();
-            var isGenerator = true;
-            var previousAllowYield = this.context.allowYield;
-            this.context.allowYield = true;
-            var params = this.parseFormalParameters();
-            this.context.allowYield = false;
-            var method = this.parsePropertyMethod(params);
-            this.context.allowYield = previousAllowYield;
-            return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
-        };
-        // ECMA-262 14.4 Generator Function Definitions
-        Parser.prototype.parseYieldExpression = function () {
-            var node = this.createNode();
-            this.expectKeyword('yield');
-            var argument = null;
-            var delegate = false;
-            if (!this.hasLineTerminator) {
-                var previousAllowYield = this.context.allowYield;
-                this.context.allowYield = false;
-                delegate = this.match('*');
-                if (delegate) {
-                    this.nextToken();
-                    argument = this.parseAssignmentExpression();
-                }
-                else {
-                    if (!this.match(';') && !this.match('}') && !this.match(')') && this.lookahead.type !== token_1.Token.EOF) {
-                        argument = this.parseAssignmentExpression();
-                    }
-                }
-                this.context.allowYield = previousAllowYield;
-            }
-            return this.finalize(node, new Node.YieldExpression(argument, delegate));
-        };
-        // ECMA-262 14.5 Class Definitions
-        Parser.prototype.parseClassElement = function (hasConstructor) {
-            var token = this.lookahead;
-            var node = this.createNode();
-            var kind = '';
-            var key = null;
-            var value = null;
-            var computed = false;
-            var method = false;
-            var isStatic = false;
-            var isAsync = false;
-            if (this.match('*')) {
-                this.nextToken();
-            }
-            else {
-                computed = this.match('[');
-                key = this.parseObjectPropertyKey();
-                var id = key;
-                if (id.name === 'static' && (this.qualifiedPropertyName(this.lookahead) || this.match('*'))) {
-                    token = this.lookahead;
-                    isStatic = true;
-                    computed = this.match('[');
-                    if (this.match('*')) {
-                        this.nextToken();
-                    }
-                    else {
-                        key = this.parseObjectPropertyKey();
-                    }
-                }
-                if ((token.type === token_1.Token.Identifier) && !this.hasLineTerminator && (token.value === 'async')) {
-                    var punctuator = this.lookahead.value;
-                    if (punctuator !== ':' && punctuator !== '(' && punctuator !== '*') {
-                        isAsync = true;
-                        token = this.lookahead;
-                        key = this.parseObjectPropertyKey();
-                        if (token.type === token_1.Token.Identifier) {
-                            if (token.value === 'get' || token.value === 'set') {
-                                this.tolerateUnexpectedToken(token);
-                            }
-                            else if (token.value === 'constructor') {
-                                this.tolerateUnexpectedToken(token, messages_1.Messages.ConstructorIsAsync);
-                            }
-                        }
-                    }
-                }
-            }
-            var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);
-            if (token.type === token_1.Token.Identifier) {
-                if (token.value === 'get' && lookaheadPropertyKey) {
-                    kind = 'get';
-                    computed = this.match('[');
-                    key = this.parseObjectPropertyKey();
-                    this.context.allowYield = false;
-                    value = this.parseGetterMethod();
-                }
-                else if (token.value === 'set' && lookaheadPropertyKey) {
-                    kind = 'set';
-                    computed = this.match('[');
-                    key = this.parseObjectPropertyKey();
-                    value = this.parseSetterMethod();
-                }
-            }
-            else if (token.type === token_1.Token.Punctuator && token.value === '*' && lookaheadPropertyKey) {
-                kind = 'init';
-                computed = this.match('[');
-                key = this.parseObjectPropertyKey();
-                value = this.parseGeneratorMethod();
-                method = true;
-            }
-            if (!kind && key && this.match('(')) {
-                kind = 'init';
-                value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();
-                method = true;
-            }
-            if (!kind) {
-                this.throwUnexpectedToken(this.lookahead);
-            }
-            if (kind === 'init') {
-                kind = 'method';
-            }
-            if (!computed) {
-                if (isStatic && this.isPropertyKey(key, 'prototype')) {
-                    this.throwUnexpectedToken(token, messages_1.Messages.StaticPrototype);
-                }
-                if (!isStatic && this.isPropertyKey(key, 'constructor')) {
-                    if (kind !== 'method' || !method || (value && value.generator)) {
-                        this.throwUnexpectedToken(token, messages_1.Messages.ConstructorSpecialMethod);
-                    }
-                    if (hasConstructor.value) {
-                        this.throwUnexpectedToken(token, messages_1.Messages.DuplicateConstructor);
-                    }
-                    else {
-                        hasConstructor.value = true;
-                    }
-                    kind = 'constructor';
-                }
-            }
-            return this.finalize(node, new Node.MethodDefinition(key, computed, value, kind, isStatic));
-        };
-        Parser.prototype.parseClassElementList = function () {
-            var body = [];
-            var hasConstructor = { value: false };
-            this.expect('{');
-            while (!this.match('}')) {
-                if (this.match(';')) {
-                    this.nextToken();
-                }
-                else {
-                    body.push(this.parseClassElement(hasConstructor));
-                }
-            }
-            this.expect('}');
-            return body;
-        };
-        Parser.prototype.parseClassBody = function () {
-            var node = this.createNode();
-            var elementList = this.parseClassElementList();
-            return this.finalize(node, new Node.ClassBody(elementList));
-        };
-        Parser.prototype.parseClassDeclaration = function (identifierIsOptional) {
-            var node = this.createNode();
-            var previousStrict = this.context.strict;
-            this.context.strict = true;
-            this.expectKeyword('class');
-            var id = (identifierIsOptional && (this.lookahead.type !== token_1.Token.Identifier)) ? null : this.parseVariableIdentifier();
-            var superClass = null;
-            if (this.matchKeyword('extends')) {
-                this.nextToken();
-                superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
-            }
-            var classBody = this.parseClassBody();
-            this.context.strict = previousStrict;
-            return this.finalize(node, new Node.ClassDeclaration(id, superClass, classBody));
-        };
-        Parser.prototype.parseClassExpression = function () {
-            var node = this.createNode();
-            var previousStrict = this.context.strict;
-            this.context.strict = true;
-            this.expectKeyword('class');
-            var id = (this.lookahead.type === token_1.Token.Identifier) ? this.parseVariableIdentifier() : null;
-            var superClass = null;
-            if (this.matchKeyword('extends')) {
-                this.nextToken();
-                superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
-            }
-            var classBody = this.parseClassBody();
-            this.context.strict = previousStrict;
-            return this.finalize(node, new Node.ClassExpression(id, superClass, classBody));
-        };
-        // ECMA-262 15.1 Scripts
-        // ECMA-262 15.2 Modules
-        Parser.prototype.parseModule = function () {
-            this.context.strict = true;
-            this.context.isModule = true;
-            var node = this.createNode();
-            var body = this.parseDirectivePrologues();
-            while (this.startMarker.index < this.scanner.length) {
-                body.push(this.parseStatementListItem());
-            }
-            return this.finalize(node, new Node.Module(body));
-        };
-        Parser.prototype.parseScript = function () {
-            var node = this.createNode();
-            var body = this.parseDirectivePrologues();
-            while (this.startMarker.index < this.scanner.length) {
-                body.push(this.parseStatementListItem());
-            }
-            return this.finalize(node, new Node.Script(body));
-        };
-        // ECMA-262 15.2.2 Imports
-        Parser.prototype.parseModuleSpecifier = function () {
-            var node = this.createNode();
-            if (this.lookahead.type !== token_1.Token.StringLiteral) {
-                this.throwError(messages_1.Messages.InvalidModuleSpecifier);
-            }
-            var token = this.nextToken();
-            var raw = this.getTokenRaw(token);
-            return this.finalize(node, new Node.Literal(token.value, raw));
-        };
-        // import {<foo as bar>} ...;
-        Parser.prototype.parseImportSpecifier = function () {
-            var node = this.createNode();
-            var imported;
-            var local;
-            if (this.lookahead.type === token_1.Token.Identifier) {
-                imported = this.parseVariableIdentifier();
-                local = imported;
-                if (this.matchContextualKeyword('as')) {
-                    this.nextToken();
-                    local = this.parseVariableIdentifier();
-                }
-            }
-            else {
-                imported = this.parseIdentifierName();
-                local = imported;
-                if (this.matchContextualKeyword('as')) {
-                    this.nextToken();
-                    local = this.parseVariableIdentifier();
-                }
-                else {
-                    this.throwUnexpectedToken(this.nextToken());
-                }
-            }
-            return this.finalize(node, new Node.ImportSpecifier(local, imported));
-        };
-        // {foo, bar as bas}
-        Parser.prototype.parseNamedImports = function () {
-            this.expect('{');
-            var specifiers = [];
-            while (!this.match('}')) {
-                specifiers.push(this.parseImportSpecifier());
-                if (!this.match('}')) {
-                    this.expect(',');
-                }
-            }
-            this.expect('}');
-            return specifiers;
-        };
-        // import <foo> ...;
-        Parser.prototype.parseImportDefaultSpecifier = function () {
-            var node = this.createNode();
-            var local = this.parseIdentifierName();
-            return this.finalize(node, new Node.ImportDefaultSpecifier(local));
-        };
-        // import <* as foo> ...;
-        Parser.prototype.parseImportNamespaceSpecifier = function () {
-            var node = this.createNode();
-            this.expect('*');
-            if (!this.matchContextualKeyword('as')) {
-                this.throwError(messages_1.Messages.NoAsAfterImportNamespace);
-            }
-            this.nextToken();
-            var local = this.parseIdentifierName();
-            return this.finalize(node, new Node.ImportNamespaceSpecifier(local));
-        };
-        Parser.prototype.parseImportDeclaration = function () {
-            if (this.context.inFunctionBody) {
-                this.throwError(messages_1.Messages.IllegalImportDeclaration);
-            }
-            var node = this.createNode();
-            this.expectKeyword('import');
-            var src;
-            var specifiers = [];
-            if (this.lookahead.type === token_1.Token.StringLiteral) {
-                // import 'foo';
-                src = this.parseModuleSpecifier();
-            }
-            else {
-                if (this.match('{')) {
-                    // import {bar}
-                    specifiers = specifiers.concat(this.parseNamedImports());
-                }
-                else if (this.match('*')) {
-                    // import * as foo
-                    specifiers.push(this.parseImportNamespaceSpecifier());
-                }
-                else if (this.isIdentifierName(this.lookahead) && !this.matchKeyword('default')) {
-                    // import foo
-                    specifiers.push(this.parseImportDefaultSpecifier());
-                    if (this.match(',')) {
-                        this.nextToken();
-                        if (this.match('*')) {
-                            // import foo, * as foo
-                            specifiers.push(this.parseImportNamespaceSpecifier());
-                        }
-                        else if (this.match('{')) {
-                            // import foo, {bar}
-                            specifiers = specifiers.concat(this.parseNamedImports());
-                        }
-                        else {
-                            this.throwUnexpectedToken(this.lookahead);
-                        }
-                    }
-                }
-                else {
-                    this.throwUnexpectedToken(this.nextToken());
-                }
-                if (!this.matchContextualKeyword('from')) {
-                    var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
-                    this.throwError(message, this.lookahead.value);
-                }
-                this.nextToken();
-                src = this.parseModuleSpecifier();
-            }
-            this.consumeSemicolon();
-            return this.finalize(node, new Node.ImportDeclaration(specifiers, src));
-        };
-        // ECMA-262 15.2.3 Exports
-        Parser.prototype.parseExportSpecifier = function () {
-            var node = this.createNode();
-            var local = this.parseIdentifierName();
-            var exported = local;
-            if (this.matchContextualKeyword('as')) {
-                this.nextToken();
-                exported = this.parseIdentifierName();
-            }
-            return this.finalize(node, new Node.ExportSpecifier(local, exported));
-        };
-        Parser.prototype.parseExportDeclaration = function () {
-            if (this.context.inFunctionBody) {
-                this.throwError(messages_1.Messages.IllegalExportDeclaration);
-            }
-            var node = this.createNode();
-            this.expectKeyword('export');
-            var exportDeclaration;
-            if (this.matchKeyword('default')) {
-                // export default ...
-                this.nextToken();
-                if (this.matchKeyword('function')) {
-                    // export default function foo () {}
-                    // export default function () {}
-                    var declaration = this.parseFunctionDeclaration(true);
-                    exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
-                }
-                else if (this.matchKeyword('class')) {
-                    // export default class foo {}
-                    var declaration = this.parseClassDeclaration(true);
-                    exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
-                }
-                else {
-                    if (this.matchContextualKeyword('from')) {
-                        this.throwError(messages_1.Messages.UnexpectedToken, this.lookahead.value);
-                    }
-                    // export default {};
-                    // export default [];
-                    // export default (1 + 2);
-                    var declaration = this.match('{') ? this.parseObjectInitializer() :
-                        this.match('[') ? this.parseArrayInitializer() : this.parseAssignmentExpression();
-                    this.consumeSemicolon();
-                    exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
-                }
-            }
-            else if (this.match('*')) {
-                // export * from 'foo';
-                this.nextToken();
-                if (!this.matchContextualKeyword('from')) {
-                    var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
-                    this.throwError(message, this.lookahead.value);
-                }
-                this.nextToken();
-                var src = this.parseModuleSpecifier();
-                this.consumeSemicolon();
-                exportDeclaration = this.finalize(node, new Node.ExportAllDeclaration(src));
-            }
-            else if (this.lookahead.type === token_1.Token.Keyword) {
-                // export var f = 1;
-                var declaration = void 0;
-                switch (this.lookahead.value) {
-                    case 'let':
-                    case 'const':
-                        declaration = this.parseLexicalDeclaration({ inFor: false });
-                        break;
-                    case 'var':
-                    case 'class':
-                    case 'function':
-                        declaration = this.parseStatementListItem();
-                        break;
-                    default:
-                        this.throwUnexpectedToken(this.lookahead);
-                }
-                exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));
-            }
-            else if (this.matchAsyncFunction()) {
-                var declaration = this.parseFunctionDeclaration();
-                exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));
-            }
-            else {
-                var specifiers = [];
-                var source = null;
-                var isExportFromIdentifier = false;
-                this.expect('{');
-                while (!this.match('}')) {
-                    isExportFromIdentifier = isExportFromIdentifier || this.matchKeyword('default');
-                    specifiers.push(this.parseExportSpecifier());
-                    if (!this.match('}')) {
-                        this.expect(',');
-                    }
-                }
-                this.expect('}');
-                if (this.matchContextualKeyword('from')) {
-                    // export {default} from 'foo';
-                    // export {foo} from 'foo';
-                    this.nextToken();
-                    source = this.parseModuleSpecifier();
-                    this.consumeSemicolon();
-                }
-                else if (isExportFromIdentifier) {
-                    // export {default}; // missing fromClause
-                    var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
-                    this.throwError(message, this.lookahead.value);
-                }
-                else {
-                    // export {foo};
-                    this.consumeSemicolon();
-                }
-                exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(null, specifiers, source));
-            }
-            return exportDeclaration;
-        };
-        return Parser;
-    }());
-    exports.Parser = Parser;
-
-
-/***/ },
-/* 4 */
-/***/ function(module, exports) {
-
-    // Ensure the condition is true, otherwise throw an error.
-    // This is only to have a better contract semantic, i.e. another safety net
-    // to catch a logic error. The condition shall be fulfilled in normal case.
-    // Do NOT use this to enforce a certain condition on any user input.
-    "use strict";
-    function assert(condition, message) {
-        /* istanbul ignore if */
-        if (!condition) {
-            throw new Error('ASSERT: ' + message);
-        }
-    }
-    exports.assert = assert;
-
-
-/***/ },
-/* 5 */
-/***/ function(module, exports) {
-
-    "use strict";
-    // Error messages should be identical to V8.
-    exports.Messages = {
-        UnexpectedToken: 'Unexpected token %0',
-        UnexpectedTokenIllegal: 'Unexpected token ILLEGAL',
-        UnexpectedNumber: 'Unexpected number',
-        UnexpectedString: 'Unexpected string',
-        UnexpectedIdentifier: 'Unexpected identifier',
-        UnexpectedReserved: 'Unexpected reserved word',
-        UnexpectedTemplate: 'Unexpected quasi %0',
-        UnexpectedEOS: 'Unexpected end of input',
-        NewlineAfterThrow: 'Illegal newline after throw',
-        InvalidRegExp: 'Invalid regular expression',
-        UnterminatedRegExp: 'Invalid regular expression: missing /',
-        InvalidLHSInAssignment: 'Invalid left-hand side in assignment',
-        InvalidLHSInForIn: 'Invalid left-hand side in for-in',
-        InvalidLHSInForLoop: 'Invalid left-hand side in for-loop',
-        MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
-        NoCatchOrFinally: 'Missing catch or finally after try',
-        UnknownLabel: 'Undefined label \'%0\'',
-        Redeclaration: '%0 \'%1\' has already been declared',
-        IllegalContinue: 'Illegal continue statement',
-        IllegalBreak: 'Illegal break statement',
-        IllegalReturn: 'Illegal return statement',
-        StrictModeWith: 'Strict mode code may not include a with statement',
-        StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode',
-        StrictVarName: 'Variable name may not be eval or arguments in strict mode',
-        StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode',
-        StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
-        StrictFunctionName: 'Function name may not be eval or arguments in strict mode',
-        StrictOctalLiteral: 'Octal literals are not allowed in strict mode.',
-        StrictDelete: 'Delete of an unqualified identifier in strict mode.',
-        StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode',
-        StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode',
-        StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode',
-        StrictReservedWord: 'Use of future reserved word in strict mode',
-        TemplateOctalLiteral: 'Octal literals are not allowed in template strings.',
-        ParameterAfterRestParameter: 'Rest parameter must be last formal parameter',
-        DefaultRestParameter: 'Unexpected token =',
-        ObjectPatternAsRestParameter: 'Unexpected token {',
-        DuplicateProtoProperty: 'Duplicate __proto__ fields are not allowed in object literals',
-        ConstructorSpecialMethod: 'Class constructor may not be an accessor',
-        DuplicateConstructor: 'A class may only have one constructor',
-        StaticPrototype: 'Classes may not have static property named prototype',
-        MissingFromClause: 'Unexpected token',
-        NoAsAfterImportNamespace: 'Unexpected token',
-        InvalidModuleSpecifier: 'Unexpected token',
-        IllegalImportDeclaration: 'Unexpected token',
-        IllegalExportDeclaration: 'Unexpected token',
-        DuplicateBinding: 'Duplicate binding %0',
-        DeclarationMissingInitializer: 'Missing initializer in %0 declaration',
-        LetInLexicalBinding: 'let is disallowed as a lexically bound name',
-        ForInOfLoopInitializer: '%0 loop variable declaration may not have an initializer',
-        ConstructorIsAsync: 'Class constructor may not be an async method'
-    };
-
-
-/***/ },
-/* 6 */
-/***/ function(module, exports) {
-
-    "use strict";
-    var ErrorHandler = (function () {
-        function ErrorHandler() {
-            this.errors = [];
-            this.tolerant = false;
-        }
-        ;
-        ErrorHandler.prototype.recordError = function (error) {
-            this.errors.push(error);
-        };
-        ;
-        ErrorHandler.prototype.tolerate = function (error) {
-            if (this.tolerant) {
-                this.recordError(error);
-            }
-            else {
-                throw error;
-            }
-        };
-        ;
-        ErrorHandler.prototype.constructError = function (msg, column) {
-            var error = new Error(msg);
-            try {
-                throw error;
-            }
-            catch (base) {
-                /* istanbul ignore else */
-                if (Object.create && Object.defineProperty) {
-                    error = Object.create(base);
-                    Object.defineProperty(error, 'column', { value: column });
-                }
-            }
-            finally {
-                return error;
-            }
-            /* istanbul ignore next */
-            return error;
-        };
-        ;
-        ErrorHandler.prototype.createError = function (index, line, col, description) {
-            var msg = 'Line ' + line + ': ' + description;
-            var error = this.constructError(msg, col);
-            error.index = index;
-            error.lineNumber = line;
-            error.description = description;
-            return error;
-        };
-        ;
-        ErrorHandler.prototype.throwError = function (index, line, col, description) {
-            throw this.createError(index, line, col, description);
-        };
-        ;
-        ErrorHandler.prototype.tolerateError = function (index, line, col, description) {
-            var error = this.createError(index, line, col, description);
-            if (this.tolerant) {
-                this.recordError(error);
-            }
-            else {
-                throw error;
-            }
-        };
-        ;
-        return ErrorHandler;
-    }());
-    exports.ErrorHandler = ErrorHandler;
-
-
-/***/ },
-/* 7 */
-/***/ function(module, exports) {
-
-    "use strict";
-    (function (Token) {
-        Token[Token["BooleanLiteral"] = 1] = "BooleanLiteral";
-        Token[Token["EOF"] = 2] = "EOF";
-        Token[Token["Identifier"] = 3] = "Identifier";
-        Token[Token["Keyword"] = 4] = "Keyword";
-        Token[Token["NullLiteral"] = 5] = "NullLiteral";
-        Token[Token["NumericLiteral"] = 6] = "NumericLiteral";
-        Token[Token["Punctuator"] = 7] = "Punctuator";
-        Token[Token["StringLiteral"] = 8] = "StringLiteral";
-        Token[Token["RegularExpression"] = 9] = "RegularExpression";
-        Token[Token["Template"] = 10] = "Template";
-    })(exports.Token || (exports.Token = {}));
-    var Token = exports.Token;
-    ;
-    exports.TokenName = {};
-    exports.TokenName[Token.BooleanLiteral] = 'Boolean';
-    exports.TokenName[Token.EOF] = '<end>';
-    exports.TokenName[Token.Identifier] = 'Identifier';
-    exports.TokenName[Token.Keyword] = 'Keyword';
-    exports.TokenName[Token.NullLiteral] = 'Null';
-    exports.TokenName[Token.NumericLiteral] = 'Numeric';
-    exports.TokenName[Token.Punctuator] = 'Punctuator';
-    exports.TokenName[Token.StringLiteral] = 'String';
-    exports.TokenName[Token.RegularExpression] = 'RegularExpression';
-    exports.TokenName[Token.Template] = 'Template';
-
-
-/***/ },
-/* 8 */
-/***/ function(module, exports, __webpack_require__) {
-
-    "use strict";
-    var assert_1 = __webpack_require__(4);
-    var messages_1 = __webpack_require__(5);
-    var character_1 = __webpack_require__(9);
-    var token_1 = __webpack_require__(7);
-    function hexValue(ch) {
-        return '0123456789abcdef'.indexOf(ch.toLowerCase());
-    }
-    function octalValue(ch) {
-        return '01234567'.indexOf(ch);
-    }
-    var Scanner = (function () {
-        function Scanner(code, handler) {
-            this.source = code;
-            this.errorHandler = handler;
-            this.trackComment = false;
-            this.length = code.length;
-            this.index = 0;
-            this.lineNumber = (code.length > 0) ? 1 : 0;
-            this.lineStart = 0;
-            this.curlyStack = [];
-        }
-        ;
-        Scanner.prototype.eof = function () {
-            return this.index >= this.length;
-        };
-        ;
-        Scanner.prototype.throwUnexpectedToken = function (message) {
-            if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }
-            this.errorHandler.throwError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
-        };
-        ;
-        Scanner.prototype.tolerateUnexpectedToken = function () {
-            this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, messages_1.Messages.UnexpectedTokenIllegal);
-        };
-        ;
-        // ECMA-262 11.4 Comments
-        Scanner.prototype.skipSingleLineComment = function (offset) {
-            var comments = [];
-            var start, loc;
-            if (this.trackComment) {
-                comments = [];
-                start = this.index - offset;
-                loc = {
-                    start: {
-                        line: this.lineNumber,
-                        column: this.index - this.lineStart - offset
-                    },
-                    end: {}
-                };
-            }
-            while (!this.eof()) {
-                var ch = this.source.charCodeAt(this.index);
-                ++this.index;
-                if (character_1.Character.isLineTerminator(ch)) {
-                    if (this.trackComment) {
-                        loc.end = {
-                            line: this.lineNumber,
-                            column: this.index - this.lineStart - 1
-                        };
-                        var entry = {
-                            multiLine: false,
-                            slice: [start + offset, this.index - 1],
-                            range: [start, this.index - 1],
-                            loc: loc
-                        };
-                        comments.push(entry);
-                    }
-                    if (ch === 13 && this.source.charCodeAt(this.index) === 10) {
-                        ++this.index;
-                    }
-                    ++this.lineNumber;
-                    this.lineStart = this.index;
-                    return comments;
-                }
-            }
-            if (this.trackComment) {
-                loc.end = {
-                    line: this.lineNumber,
-                    column: this.index - this.lineStart
-                };
-                var entry = {
-                    multiLine: false,
-                    slice: [start + offset, this.index],
-                    range: [start, this.index],
-                    loc: loc
-                };
-                comments.push(entry);
-            }
-            return comments;
-        };
-        ;
-        Scanner.prototype.skipMultiLineComment = function () {
-            var comments = [];
-            var start, loc;
-            if (this.trackComment) {
-                comments = [];
-                start = this.index - 2;
-                loc = {
-                    start: {
-                        line: this.lineNumber,
-                        column: this.index - this.lineStart - 2
-                    },
-                    end: {}
-                };
-            }
-            while (!this.eof()) {
-                var ch = this.source.charCodeAt(this.index);
-                if (character_1.Character.isLineTerminator(ch)) {
-                    if (ch === 0x0D && this.source.charCodeAt(this.index + 1) === 0x0A) {
-                        ++this.index;
-                    }
-                    ++this.lineNumber;
-                    ++this.index;
-                    this.lineStart = this.index;
-                }
-                else if (ch === 0x2A) {
-                    // Block comment ends with '*/'.
-                    if (this.source.charCodeAt(this.index + 1) === 0x2F) {
-                        this.index += 2;
-                        if (this.trackComment) {
-                            loc.end = {
-                                line: this.lineNumber,
-                                column: this.index - this.lineStart
-                            };
-                            var entry = {
-                                multiLine: true,
-                                slice: [start + 2, this.index - 2],
-                                range: [start, this.index],
-                                loc: loc
-                            };
-                            comments.push(entry);
-                        }
-                        return comments;
-                    }
-                    ++this.index;
-                }
-                else {
-                    ++this.index;
-                }
-            }
-            // Ran off the end of the file - the whole thing is a comment
-            if (this.trackComment) {
-                loc.end = {
-                    line: this.lineNumber,
-                    column: this.index - this.lineStart
-                };
-                var entry = {
-                    multiLine: true,
-                    slice: [start + 2, this.index],
-                    range: [start, this.index],
-                    loc: loc
-                };
-                comments.push(entry);
-            }
-            this.tolerateUnexpectedToken();
-            return comments;
-        };
-        ;
-        Scanner.prototype.scanComments = function () {
-            var comments;
-            if (this.trackComment) {
-                comments = [];
-            }
-            var start = (this.index === 0);
-            while (!this.eof()) {
-                var ch = this.source.charCodeAt(this.index);
-                if (character_1.Character.isWhiteSpace(ch)) {
-                    ++this.index;
-                }
-                else if (character_1.Character.isLineTerminator(ch)) {
-                    ++this.index;
-                    if (ch === 0x0D && this.source.charCodeAt(this.index) === 0x0A) {
-                        ++this.index;
-                    }
-                    ++this.lineNumber;
-                    this.lineStart = this.index;
-                    start = true;
-                }
-                else if (ch === 0x2F) {
-                    ch = this.source.charCodeAt(this.index + 1);
-                    if (ch === 0x2F) {
-                        this.index += 2;
-                        var comment = this.skipSingleLineComment(2);
-                        if (this.trackComment) {
-                            comments = comments.concat(comment);
-                        }
-                        start = true;
-                    }
-                    else if (ch === 0x2A) {
-                        this.index += 2;
-                        var comment = this.skipMultiLineComment();
-                        if (this.trackComment) {
-                            comments = comments.concat(comment);
-                        }
-                    }
-                    else {
-                        break;
-                    }
-                }
-                else if (start && ch === 0x2D) {
-                    // U+003E is '>'
-                    if ((this.source.charCodeAt(this.index + 1) === 0x2D) && (this.source.charCodeAt(this.index + 2) === 0x3E)) {
-                        // '-->' is a single-line comment
-                        this.index += 3;
-                        var comment = this.skipSingleLineComment(3);
-                        if (this.trackComment) {
-                            comments = comments.concat(comment);
-                        }
-                    }
-                    else {
-                        break;
-                    }
-                }
-                else if (ch === 0x3C) {
-                    if (this.source.slice(this.index + 1, this.index + 4) === '!--') {
-                        this.index += 4; // `<!--`
-                        var comment = this.skipSingleLineComment(4);
-                        if (this.trackComment) {
-                            comments = comments.concat(comment);
-                        }
-                    }
-                    else {
-                        break;
-                    }
-                }
-                else {
-                    break;
-                }
-            }
-            return comments;
-        };
-        ;
-        // ECMA-262 11.6.2.2 Future Reserved Words
-        Scanner.prototype.isFutureReservedWord = function (id) {
-            switch (id) {
-                case 'enum':
-                case 'export':
-                case 'import':
-                case 'super':
-                    return true;
-                default:
-                    return false;
-            }
-        };
-        ;
-        Scanner.prototype.isStrictModeReservedWord = function (id) {
-            switch (id) {
-                case 'implements':
-                case 'interface':
-                case 'package':
-                case 'private':
-                case 'protected':
-                case 'public':
-                case 'static':
-                case 'yield':
-                case 'let':
-                    return true;
-                default:
-                    return false;
-            }
-        };
-        ;
-        Scanner.prototype.isRestrictedWord = function (id) {
-            return id === 'eval' || id === 'arguments';
-        };
-        ;
-        // ECMA-262 11.6.2.1 Keywords
-        Scanner.prototype.isKeyword = function (id) {
-            switch (id.length) {
-                case 2:
-                    return (id === 'if') || (id === 'in') || (id === 'do');
-                case 3:
-                    return (id === 'var') || (id === 'for') || (id === 'new') ||
-                        (id === 'try') || (id === 'let');
-                case 4:
-                    return (id === 'this') || (id === 'else') || (id === 'case') ||
-                        (id === 'void') || (id === 'with') || (id === 'enum');
-                case 5:
-                    return (id === 'while') || (id === 'break') || (id === 'catch') ||
-                        (id === 'throw') || (id === 'const') || (id === 'yield') ||
-                        (id === 'class') || (id === 'super');
-                case 6:
-                    return (id === 'return') || (id === 'typeof') || (id === 'delete') ||
-                        (id === 'switch') || (id === 'export') || (id === 'import');
-                case 7:
-                    return (id === 'default') || (id === 'finally') || (id === 'extends');
-                case 8:
-                    return (id === 'function') || (id === 'continue') || (id === 'debugger');
-                case 10:
-                    return (id === 'instanceof');
-                default:
-                    return false;
-            }
-        };
-        ;
-        Scanner.prototype.codePointAt = function (i) {
-            var cp = this.source.charCodeAt(i);
-            if (cp >= 0xD800 && cp <= 0xDBFF) {
-                var second = this.source.charCodeAt(i + 1);
-                if (second >= 0xDC00 && second <= 0xDFFF) {
-                    var first = cp;
-                    cp = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
-                }
-            }
-            return cp;
-        };
-        ;
-        Scanner.prototype.scanHexEscape = function (prefix) {
-            var len = (prefix === 'u') ? 4 : 2;
-            var code = 0;
-            for (var i = 0; i < len; ++i) {
-                if (!this.eof() && character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {
-                    code = code * 16 + hexValue(this.source[this.index++]);
-                }
-                else {
-                    return '';
-                }
-            }
-            return String.fromCharCode(code);
-        };
-        ;
-        Scanner.prototype.scanUnicodeCodePointEscape = function () {
-            var ch = this.source[this.index];
-            var code = 0;
-            // At least, one hex digit is required.
-            if (ch === '}') {
-                this.throwUnexpectedToken();
-            }
-            while (!this.eof()) {
-                ch = this.source[this.index++];
-                if (!character_1.Character.isHexDigit(ch.charCodeAt(0))) {
-                    break;
-                }
-                code = code * 16 + hexValue(ch);
-            }
-            if (code > 0x10FFFF || ch !== '}') {
-                this.throwUnexpectedToken();
-            }
-            return character_1.Character.fromCodePoint(code);
-        };
-        ;
-        Scanner.prototype.getIdentifier = function () {
-            var start = this.index++;
-            while (!this.eof()) {
-                var ch = this.source.charCodeAt(this.index);
-                if (ch === 0x5C) {
-                    // Blackslash (U+005C) marks Unicode escape sequence.
-                    this.index = start;
-                    return this.getComplexIdentifier();
-                }
-                else if (ch >= 0xD800 && ch < 0xDFFF) {
-                    // Need to handle surrogate pairs.
-                    this.index = start;
-                    return this.getComplexIdentifier();
-                }
-                if (character_1.Character.isIdentifierPart(ch)) {
-                    ++this.index;
-                }
-                else {
-                    break;
-                }
-            }
-            return this.source.slice(start, this.index);
-        };
-        ;
-        Scanner.prototype.getComplexIdentifier = function () {
-            var cp = this.codePointAt(this.index);
-            var id = character_1.Character.fromCodePoint(cp);
-            this.index += id.length;
-            // '\u' (U+005C, U+0075) denotes an escaped character.
-            var ch;
-            if (cp === 0x5C) {
-                if (this.source.charCodeAt(this.index) !== 0x75) {
-                    this.throwUnexpectedToken();
-                }
-                ++this.index;
-                if (this.source[this.index] === '{') {
-                    ++this.index;
-                    ch = this.scanUnicodeCodePointEscape();
-                }
-                else {
-                    ch = this.scanHexEscape('u');
-                    cp = ch.charCodeAt(0);
-                    if (!ch || ch === '\\' || !character_1.Character.isIdentifierStart(cp)) {
-                        this.throwUnexpectedToken();
-                    }
-                }
-                id = ch;
-            }
-            while (!this.eof()) {
-                cp = this.codePointAt(this.index);
-                if (!character_1.Character.isIdentifierPart(cp)) {
-                    break;
-                }
-                ch = character_1.Character.fromCodePoint(cp);
-                id += ch;
-                this.index += ch.length;
-                // '\u' (U+005C, U+0075) denotes an escaped character.
-                if (cp === 0x5C) {
-                    id = id.substr(0, id.length - 1);
-                    if (this.source.charCodeAt(this.index) !== 0x75) {
-                        this.throwUnexpectedToken();
-                    }
-                    ++this.index;
-                    if (this.source[this.index] === '{') {
-                        ++this.index;
-                        ch = this.scanUnicodeCodePointEscape();
-                    }
-                    else {
-                        ch = this.scanHexEscape('u');
-                        cp = ch.charCodeAt(0);
-                        if (!ch || ch === '\\' || !character_1.Character.isIdentifierPart(cp)) {
-                            this.throwUnexpectedToken();
-                        }
-                    }
-                    id += ch;
-                }
-            }
-            return id;
-        };
-        ;
-        Scanner.prototype.octalToDecimal = function (ch) {
-            // \0 is not octal escape sequence
-            var octal = (ch !== '0');
-            var code = octalValue(ch);
-            if (!this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
-                octal = true;
-                code = code * 8 + octalValue(this.source[this.index++]);
-                // 3 digits are only allowed when string starts
-                // with 0, 1, 2, 3
-                if ('0123'.indexOf(ch) >= 0 && !this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
-                    code = code * 8 + octalValue(this.source[this.index++]);
-                }
-            }
-            return {
-                code: code,
-                octal: octal
-            };
-        };
-        ;
-        // ECMA-262 11.6 Names and Keywords
-        Scanner.prototype.scanIdentifier = function () {
-            var type;
-            var start = this.index;
-            // Backslash (U+005C) starts an escaped character.
-            var id = (this.source.charCodeAt(start) === 0x5C) ? this.getComplexIdentifier() : this.getIdentifier();
-            // There is no keyword or literal with only one character.
-            // Thus, it must be an identifier.
-            if (id.length === 1) {
-                type = token_1.Token.Identifier;
-            }
-            else if (this.isKeyword(id)) {
-                type = token_1.Token.Keyword;
-            }
-            else if (id === 'null') {
-                type = token_1.Token.NullLiteral;
-            }
-            else if (id === 'true' || id === 'false') {
-                type = token_1.Token.BooleanLiteral;
-            }
-            else {
-                type = token_1.Token.Identifier;
-            }
-            return {
-                type: type,
-                value: id,
-                lineNumber: this.lineNumber,
-                lineStart: this.lineStart,
-                start: start,
-                end: this.index
-            };
-        };
-        ;
-        // ECMA-262 11.7 Punctuators
-        Scanner.prototype.scanPunctuator = function () {
-            var token = {
-                type: token_1.Token.Punctuator,
-                value: '',
-                lineNumber: this.lineNumber,
-                lineStart: this.lineStart,
-                start: this.index,
-                end: this.index
-            };
-            // Check for most common single-character punctuators.
-            var str = this.source[this.index];
-            switch (str) {
-                case '(':
-                case '{':
-                    if (str === '{') {
-                        this.curlyStack.push('{');
-                    }
-                    ++this.index;
-                    break;
-                case '.':
-                    ++this.index;
-                    if (this.source[this.index] === '.' && this.source[this.index + 1] === '.') {
-                        // Spread operator: ...
-                        this.index += 2;
-                        str = '...';
-                    }
-                    break;
-                case '}':
-                    ++this.index;
-                    this.curlyStack.pop();
-                    break;
-                case ')':
-                case ';':
-                case ',':
-                case '[':
-                case ']':
-                case ':':
-                case '?':
-                case '~':
-                    ++this.index;
-                    break;
-                default:
-                    // 4-character punctuator.
-                    str = this.source.substr(this.index, 4);
-                    if (str === '>>>=') {
-                        this.index += 4;
-                    }
-                    else {
-                        // 3-character punctuators.
-                        str = str.substr(0, 3);
-                        if (str === '===' || str === '!==' || str === '>>>' ||
-                            str === '<<=' || str === '>>=' || str === '**=') {
-                            this.index += 3;
-                        }
-                        else {
-                            // 2-character punctuators.
-                            str = str.substr(0, 2);
-                            if (str === '&&' || str === '||' || str === '==' || str === '!=' ||
-                                str === '+=' || str === '-=' || str === '*=' || str === '/=' ||
-                                str === '++' || str === '--' || str === '<<' || str === '>>' ||
-                                str === '&=' || str === '|=' || str === '^=' || str === '%=' ||
-                                str === '<=' || str === '>=' || str === '=>' || str === '**') {
-                                this.index += 2;
-                            }
-                            else {
-                                // 1-character punctuators.
-                                str = this.source[this.index];
-                                if ('<>=!+-*%&|^/'.indexOf(str) >= 0) {
-                                    ++this.index;
-                                }
-                            }
-                        }
-                    }
-            }
-            if (this.index === token.start) {
-                this.throwUnexpectedToken();
-            }
-            token.end = this.index;
-            token.value = str;
-            return token;
-        };
-        ;
-        // ECMA-262 11.8.3 Numeric Literals
-        Scanner.prototype.scanHexLiteral = function (start) {
-            var number = '';
-            while (!this.eof()) {
-                if (!character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {
-                    break;
-                }
-                number += this.source[this.index++];
-            }
-            if (number.length === 0) {
-                this.throwUnexpectedToken();
-            }
-            if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {
-                this.throwUnexpectedToken();
-            }
-            return {
-                type: token_1.Token.NumericLiteral,
-                value: parseInt('0x' + number, 16),
-                lineNumber: this.lineNumber,
-                lineStart: this.lineStart,
-                start: start,
-                end: this.index
-            };
-        };
-        ;
-        Scanner.prototype.scanBinaryLiteral = function (start) {
-            var number = '';
-            var ch;
-            while (!this.eof()) {
-                ch = this.source[this.index];
-                if (ch !== '0' && ch !== '1') {
-                    break;
-                }
-                number += this.source[this.index++];
-            }
-            if (number.length === 0) {
-                // only 0b or 0B
-                this.throwUnexpectedToken();
-            }
-            if (!this.eof()) {
-                ch = this.source.charCodeAt(this.index);
-                /* istanbul ignore else */
-                if (character_1.Character.isIdentifierStart(ch) || character_1.Character.isDecimalDigit(ch)) {
-                    this.throwUnexpectedToken();
-                }
-            }
-            return {
-                type: token_1.Token.NumericLiteral,
-                value: parseInt(number, 2),
-                lineNumber: this.lineNumber,
-                lineStart: this.lineStart,
-                start: start,
-                end: this.index
-            };
-        };
-        ;
-        Scanner.prototype.scanOctalLiteral = function (prefix, start) {
-            var number = '';
-            var octal = false;
-            if (character_1.Character.isOctalDigit(prefix.charCodeAt(0))) {
-                octal = true;
-                number = '0' + this.source[this.index++];
-            }
-            else {
-                ++this.index;
-            }
-            while (!this.eof()) {
-                if (!character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
-                    break;
-                }
-                number += this.source[this.index++];
-            }
-            if (!octal && number.length === 0) {
-                // only 0o or 0O
-                this.throwUnexpectedToken();
-            }
-            if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index)) || character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
-                this.throwUnexpectedToken();
-            }
-            return {
-                type: token_1.Token.NumericLiteral,
-                value: parseInt(number, 8),
-                octal: octal,
-                lineNumber: this.lineNumber,
-                lineStart: this.lineStart,
-                start: start,
-                end: this.index
-            };
-        };
-        ;
-        Scanner.prototype.isImplicitOctalLiteral = function () {
-            // Implicit octal, unless there is a non-octal digit.
-            // (Annex B.1.1 on Numeric Literals)
-            for (var i = this.index + 1; i < this.length; ++i) {
-                var ch = this.source[i];
-                if (ch === '8' || ch === '9') {
-                    return false;
-                }
-                if (!character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
-                    return true;
-                }
-            }
-            return true;
-        };
-        ;
-        Scanner.prototype.scanNumericLiteral = function () {
-            var start = this.index;
-            var ch = this.source[start];
-            assert_1.assert(character_1.Character.isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'), 'Numeric literal must start with a decimal digit or a decimal point');
-            var number = '';
-            if (ch !== '.') {
-                number = this.source[this.index++];
-                ch = this.source[this.index];
-                // Hex number starts with '0x'.
-                // Octal number starts with '0'.
-                // Octal number in ES6 starts with '0o'.
-                // Binary number in ES6 starts with '0b'.
-                if (number === '0') {
-                    if (ch === 'x' || ch === 'X') {
-                        ++this.index;
-                        return this.scanHexLiteral(start);
-                    }
-                    if (ch === 'b' || ch === 'B') {
-                        ++this.index;
-                        return this.scanBinaryLiteral(start);
-                    }
-                    if (ch === 'o' || ch === 'O') {
-                        return this.scanOctalLiteral(ch, start);
-                    }
-                    if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
-                        if (this.isImplicitOctalLiteral()) {
-                            return this.scanOctalLiteral(ch, start);
-                        }
-                    }
-                }
-                while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
-                    number += this.source[this.index++];
-                }
-                ch = this.source[this.index];
-            }
-            if (ch === '.') {
-                number += this.source[this.index++];
-                while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
-                    number += this.source[this.index++];
-                }
-                ch = this.source[this.index];
-            }
-            if (ch === 'e' || ch === 'E') {
-                number += this.source[this.index++];
-                ch = this.source[this.index];
-                if (ch === '+' || ch === '-') {
-                    number += this.source[this.index++];
-                }
-                if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
-                    while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
-                        number += this.source[this.index++];
-                    }
-                }
-                else {
-                    this.throwUnexpectedToken();
-                }
-            }
-            if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {
-                this.throwUnexpectedToken();
-            }
-            return {
-                type: token_1.Token.NumericLiteral,
-                value: parseFloat(number),
-                lineNumber: this.lineNumber,
-                lineStart: this.lineStart,
-                start: start,
-                end: this.index
-            };
-        };
-        ;
-        // ECMA-262 11.8.4 String Literals
-        Scanner.prototype.scanStringLiteral = function () {
-            var start = this.index;
-            var quote = this.source[start];
-            assert_1.assert((quote === '\'' || quote === '"'), 'String literal must starts with a quote');
-            ++this.index;
-            var octal = false;
-            var str = '';
-            while (!this.eof()) {
-                var ch = this.source[this.index++];
-                if (ch === quote) {
-                    quote = '';
-                    break;
-                }
-                else if (ch === '\\') {
-                    ch = this.source[this.index++];
-                    if (!ch || !character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
-                        switch (ch) {
-                            case 'u':
-                            case 'x':
-                                if (this.source[this.index] === '{') {
-                                    ++this.index;
-                                    str += this.scanUnicodeCodePointEscape();
-                                }
-                                else {
-                                    var unescaped = this.scanHexEscape(ch);
-                                    if (!unescaped) {
-                                        this.throwUnexpectedToken();
-                                    }
-                                    str += unescaped;
-                                }
-                                break;
-                            case 'n':
-                                str += '\n';
-                                break;
-                            case 'r':
-                                str += '\r';
-                                break;
-                            case 't':
-                                str += '\t';
-                                break;
-                            case 'b':
-                                str += '\b';
-                                break;
-                            case 'f':
-                                str += '\f';
-                                break;
-                            case 'v':
-                                str += '\x0B';
-                                break;
-                            case '8':
-                            case '9':
-                                str += ch;
-                                this.tolerateUnexpectedToken();
-                                break;
-                            default:
-                                if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
-                                    var octToDec = this.octalToDecimal(ch);
-                                    octal = octToDec.octal || octal;
-                                    str += String.fromCharCode(octToDec.code);
-                                }
-                                else {
-                                    str += ch;
-                                }
-                                break;
-                        }
-                    }
-                    else {
-                        ++this.lineNumber;
-                        if (ch === '\r' && this.source[this.index] === '\n') {
-                            ++this.index;
-                        }
-                        this.lineStart = this.index;
-                    }
-                }
-                else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
-                    break;
-                }
-                else {
-                    str += ch;
-                }
-            }
-            if (quote !== '') {
-                this.index = start;
-                this.throwUnexpectedToken();
-            }
-            return {
-                type: token_1.Token.StringLiteral,
-                value: str,
-                octal: octal,
-                lineNumber: this.lineNumber,
-                lineStart: this.lineStart,
-                start: start,
-                end: this.index
-            };
-        };
-        ;
-        // ECMA-262 11.8.6 Template Literal Lexical Components
-        Scanner.prototype.scanTemplate = function () {
-            var cooked = '';
-            var terminated = false;
-            var start = this.index;
-            var head = (this.source[start] === '`');
-            var tail = false;
-            var rawOffset = 2;
-            ++this.index;
-            while (!this.eof()) {
-                var ch = this.source[this.index++];
-                if (ch === '`') {
-                    rawOffset = 1;
-                    tail = true;
-                    terminated = true;
-                    break;
-                }
-                else if (ch === '$') {
-                    if (this.source[this.index] === '{') {
-                        this.curlyStack.push('${');
-                        ++this.index;
-                        terminated = true;
-                        break;
-                    }
-                    cooked += ch;
-                }
-                else if (ch === '\\') {
-                    ch = this.source[this.index++];
-                    if (!character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
-                        switch (ch) {
-                            case 'n':
-                                cooked += '\n';
-                                break;
-                            case 'r':
-                                cooked += '\r';
-                                break;
-                            case 't':
-                                cooked += '\t';
-                                break;
-                            case 'u':
-                            case 'x':
-                                if (this.source[this.index] === '{') {
-                                    ++this.index;
-                                    cooked += this.scanUnicodeCodePointEscape();
-                                }
-                                else {
-                                    var restore = this.index;
-                                    var unescaped = this.scanHexEscape(ch);
-                                    if (unescaped) {
-                                        cooked += unescaped;
-                                    }
-                                    else {
-                                        this.index = restore;
-                                        cooked += ch;
-                                    }
-                                }
-                                break;
-                            case 'b':
-                                cooked += '\b';
-                                break;
-                            case 'f':
-                                cooked += '\f';
-                                break;
-                            case 'v':
-                                cooked += '\v';
-                                break;
-                            default:
-                                if (ch === '0') {
-                                    if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
-                                        // Illegal: \01 \02 and so on
-                                        this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);
-                                    }
-                                    cooked += '\0';
-                                }
-                                else if (character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
-                                    // Illegal: \1 \2
-                                    this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);
-                                }
-                                else {
-                                    cooked += ch;
-                                }
-                                break;
-                        }
-                    }
-                    else {
-                        ++this.lineNumber;
-                        if (ch === '\r' && this.source[this.index] === '\n') {
-                            ++this.index;
-                        }
-                        this.lineStart = this.index;
-                    }
-                }
-                else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
-                    ++this.lineNumber;
-                    if (ch === '\r' && this.source[this.index] === '\n') {
-                        ++this.index;
-                    }
-                    this.lineStart = this.index;
-                    cooked += '\n';
-                }
-                else {
-                    cooked += ch;
-                }
-            }
-            if (!terminated) {
-                this.throwUnexpectedToken();
-            }
-            if (!head) {
-                this.curlyStack.pop();
-            }
-            return {
-                type: token_1.Token.Template,
-                value: {
-                    cooked: cooked,
-                    raw: this.source.slice(start + 1, this.index - rawOffset)
-                },
-                head: head,
-                tail: tail,
-                lineNumber: this.lineNumber,
-                lineStart: this.lineStart,
-                start: start,
-                end: this.index
-            };
-        };
-        ;
-        // ECMA-262 11.8.5 Regular Expression Literals
-        Scanner.prototype.testRegExp = function (pattern, flags) {
-            // The BMP character to use as a replacement for astral symbols when
-            // translating an ES6 "u"-flagged pattern to an ES5-compatible
-            // approximation.
-            // Note: replacing with '\uFFFF' enables false positives in unlikely
-            // scenarios. For example, `[\u{1044f}-\u{10440}]` is an invalid
-            // pattern that would not be detected by this substitution.
-            var astralSubstitute = '\uFFFF';
-            var tmp = pattern;
-            var self = this;
-            if (flags.indexOf('u') >= 0) {
-                tmp = tmp
-                    .replace(/\\u\{([0-9a-fA-F]+)\}|\\u([a-fA-F0-9]{4})/g, function ($0, $1, $2) {
-                    var codePoint = parseInt($1 || $2, 16);
-                    if (codePoint > 0x10FFFF) {
-                        self.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);
-                    }
-                    if (codePoint <= 0xFFFF) {
-                        return String.fromCharCode(codePoint);
-                    }
-                    return astralSubstitute;
-                })
-                    .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, astralSubstitute);
-            }
-            // First, detect invalid regular expressions.
-            try {
-                RegExp(tmp);
-            }
-            catch (e) {
-                this.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);
-            }
-            // Return a regular expression object for this pattern-flag pair, or
-            // `null` in case the current environment doesn't support the flags it
-            // uses.
-            try {
-                return new RegExp(pattern, flags);
-            }
-            catch (exception) {
-                /* istanbul ignore next */
-                return null;
-            }
-        };
-        ;
-        Scanner.prototype.scanRegExpBody = function () {
-            var ch = this.source[this.index];
-            assert_1.assert(ch === '/', 'Regular expression literal must start with a slash');
-            var str = this.source[this.index++];
-            var classMarker = false;
-            var terminated = false;
-            while (!this.eof()) {
-                ch = this.source[this.index++];
-                str += ch;
-                if (ch === '\\') {
-                    ch = this.source[this.index++];
-                    // ECMA-262 7.8.5
-                    if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
-                        this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
-                    }
-                    str += ch;
-                }
-                else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
-                    this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
-                }
-                else if (classMarker) {
-                    if (ch === ']') {
-                        classMarker = false;
-                    }
-                }
-                else {
-                    if (ch === '/') {
-                        terminated = true;
-                        break;
-                    }
-                    else if (ch === '[') {
-                        classMarker = true;
-                    }
-                }
-            }
-            if (!terminated) {
-                this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
-            }
-            // Exclude leading and trailing slash.
-            var body = str.substr(1, str.length - 2);
-            return {
-                value: body,
-                literal: str
-            };
-        };
-        ;
-        Scanner.prototype.scanRegExpFlags = function () {
-            var str = '';
-            var flags = '';
-            while (!this.eof()) {
-                var ch = this.source[this.index];
-                if (!character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {
-                    break;
-                }
-                ++this.index;
-                if (ch === '\\' && !this.eof()) {
-                    ch = this.source[this.index];
-                    if (ch === 'u') {
-                        ++this.index;
-                        var restore = this.index;
-                        ch = this.scanHexEscape('u');
-                        if (ch) {
-                            flags += ch;
-                            for (str += '\\u'; restore < this.index; ++restore) {
-                                str += this.source[restore];
-                            }
-                        }
-                        else {
-                            this.index = restore;
-                            flags += 'u';
-                            str += '\\u';
-                        }
-                        this.tolerateUnexpectedToken();
-                    }
-                    else {
-                        str += '\\';
-                        this.tolerateUnexpectedToken();
-                    }
-                }
-                else {
-                    flags += ch;
-                    str += ch;
-                }
-            }
-            return {
-                value: flags,
-                literal: str
-            };
-        };
-        ;
-        Scanner.prototype.scanRegExp = function () {
-            var start = this.index;
-            var body = this.scanRegExpBody();
-            var flags = this.scanRegExpFlags();
-            var value = this.testRegExp(body.value, flags.value);
-            return {
-                type: token_1.Token.RegularExpression,
-                value: value,
-                literal: body.literal + flags.literal,
-                regex: {
-                    pattern: body.value,
-                    flags: flags.value
-                },
-                lineNumber: this.lineNumber,
-                lineStart: this.lineStart,
-                start: start,
-                end: this.index
-            };
-        };
-        ;
-        Scanner.prototype.lex = function () {
-            if (this.eof()) {
-                return {
-                    type: token_1.Token.EOF,
-                    lineNumber: this.lineNumber,
-                    lineStart: this.lineStart,
-                    start: this.index,
-                    end: this.index
-                };
-            }
-            var cp = this.source.charCodeAt(this.index);
-            if (character_1.Character.isIdentifierStart(cp)) {
-                return this.scanIdentifier();
-            }
-            // Very common: ( and ) and ;
-            if (cp === 0x28 || cp === 0x29 || cp === 0x3B) {
-                return this.scanPunctuator();
-            }
-            // String literal starts with single quote (U+0027) or double quote (U+0022).
-            if (cp === 0x27 || cp === 0x22) {
-                return this.scanStringLiteral();
-            }
-            // Dot (.) U+002E can also start a floating-point number, hence the need
-            // to check the next character.
-            if (cp === 0x2E) {
-                if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index + 1))) {
-                    return this.scanNumericLiteral();
-                }
-                return this.scanPunctuator();
-            }
-            if (character_1.Character.isDecimalDigit(cp)) {
-                return this.scanNumericLiteral();
-            }
-            // Template literals start with ` (U+0060) for template head
-            // or } (U+007D) for template middle or template tail.
-            if (cp === 0x60 || (cp === 0x7D && this.curlyStack[this.curlyStack.length - 1] === '${')) {
-                return this.scanTemplate();
-            }
-            // Possible identifier start in a surrogate pair.
-            if (cp >= 0xD800 && cp < 0xDFFF) {
-                if (character_1.Character.isIdentifierStart(this.codePointAt(this.index))) {
-                    return this.scanIdentifier();
-                }
-            }
-            return this.scanPunctuator();
-        };
-        ;
-        return Scanner;
-    }());
-    exports.Scanner = Scanner;
+        return JSXParser;
+    }(parser_1.Parser));
+    exports.JSXParser = JSXParser;
 
 
 /***/ },
-/* 9 */
+/* 4 */
 /***/ function(module, exports) {
 
     "use strict";
@@ -4846,21 +955,22 @@ return /******/ (function(modules) { // webpackBootstrap
         NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/
     };
     exports.Character = {
+        /* tslint:disable:no-bitwise */
         fromCodePoint: function (cp) {
             return (cp < 0x10000) ? String.fromCharCode(cp) :
                 String.fromCharCode(0xD800 + ((cp - 0x10000) >> 10)) +
                     String.fromCharCode(0xDC00 + ((cp - 0x10000) & 1023));
         },
-        // ECMA-262 11.2 White Space
+        // https://tc39.github.io/ecma262/#sec-white-space
         isWhiteSpace: function (cp) {
             return (cp === 0x20) || (cp === 0x09) || (cp === 0x0B) || (cp === 0x0C) || (cp === 0xA0) ||
                 (cp >= 0x1680 && [0x1680, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF].indexOf(cp) >= 0);
         },
-        // ECMA-262 11.3 Line Terminators
+        // https://tc39.github.io/ecma262/#sec-line-terminators
         isLineTerminator: function (cp) {
             return (cp === 0x0A) || (cp === 0x0D) || (cp === 0x2028) || (cp === 0x2029);
         },
-        // ECMA-262 11.6 Identifier Names and Identifiers
+        // https://tc39.github.io/ecma262/#sec-names-and-keywords
         isIdentifierStart: function (cp) {
             return (cp === 0x24) || (cp === 0x5F) ||
                 (cp >= 0x41 && cp <= 0x5A) ||
@@ -4876,7 +986,7 @@ return /******/ (function(modules) { // webpackBootstrap
                 (cp === 0x5C) ||
                 ((cp >= 0x80) && Regex.NonAsciiIdentifierPart.test(exports.Character.fromCodePoint(cp)));
         },
-        // ECMA-262 11.8.3 Numeric Literals
+        // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
         isDecimalDigit: function (cp) {
             return (cp >= 0x30 && cp <= 0x39); // 0..9
         },
@@ -4892,11 +1002,136 @@ return /******/ (function(modules) { // webpackBootstrap
 
 
 /***/ },
-/* 10 */
+/* 5 */
+/***/ function(module, exports, __webpack_require__) {
+
+    "use strict";
+    var jsx_syntax_1 = __webpack_require__(6);
+    /* tslint:disable:max-classes-per-file */
+    var JSXClosingElement = (function () {
+        function JSXClosingElement(name) {
+            this.type = jsx_syntax_1.JSXSyntax.JSXClosingElement;
+            this.name = name;
+        }
+        return JSXClosingElement;
+    }());
+    exports.JSXClosingElement = JSXClosingElement;
+    var JSXElement = (function () {
+        function JSXElement(openingElement, children, closingElement) {
+            this.type = jsx_syntax_1.JSXSyntax.JSXElement;
+            this.openingElement = openingElement;
+            this.children = children;
+            this.closingElement = closingElement;
+        }
+        return JSXElement;
+    }());
+    exports.JSXElement = JSXElement;
+    var JSXEmptyExpression = (function () {
+        function JSXEmptyExpression() {
+            this.type = jsx_syntax_1.JSXSyntax.JSXEmptyExpression;
+        }
+        return JSXEmptyExpression;
+    }());
+    exports.JSXEmptyExpression = JSXEmptyExpression;
+    var JSXExpressionContainer = (function () {
+        function JSXExpressionContainer(expression) {
+            this.type = jsx_syntax_1.JSXSyntax.JSXExpressionContainer;
+            this.expression = expression;
+        }
+        return JSXExpressionContainer;
+    }());
+    exports.JSXExpressionContainer = JSXExpressionContainer;
+    var JSXIdentifier = (function () {
+        function JSXIdentifier(name) {
+            this.type = jsx_syntax_1.JSXSyntax.JSXIdentifier;
+            this.name = name;
+        }
+        return JSXIdentifier;
+    }());
+    exports.JSXIdentifier = JSXIdentifier;
+    var JSXMemberExpression = (function () {
+        function JSXMemberExpression(object, property) {
+            this.type = jsx_syntax_1.JSXSyntax.JSXMemberExpression;
+            this.object = object;
+            this.property = property;
+        }
+        return JSXMemberExpression;
+    }());
+    exports.JSXMemberExpression = JSXMemberExpression;
+    var JSXAttribute = (function () {
+        function JSXAttribute(name, value) {
+            this.type = jsx_syntax_1.JSXSyntax.JSXAttribute;
+            this.name = name;
+            this.value = value;
+        }
+        return JSXAttribute;
+    }());
+    exports.JSXAttribute = JSXAttribute;
+    var JSXNamespacedName = (function () {
+        function JSXNamespacedName(namespace, name) {
+            this.type = jsx_syntax_1.JSXSyntax.JSXNamespacedName;
+            this.namespace = namespace;
+            this.name = name;
+        }
+        return JSXNamespacedName;
+    }());
+    exports.JSXNamespacedName = JSXNamespacedName;
+    var JSXOpeningElement = (function () {
+        function JSXOpeningElement(name, selfClosing, attributes) {
+            this.type = jsx_syntax_1.JSXSyntax.JSXOpeningElement;
+            this.name = name;
+            this.selfClosing = selfClosing;
+            this.attributes = attributes;
+        }
+        return JSXOpeningElement;
+    }());
+    exports.JSXOpeningElement = JSXOpeningElement;
+    var JSXSpreadAttribute = (function () {
+        function JSXSpreadAttribute(argument) {
+            this.type = jsx_syntax_1.JSXSyntax.JSXSpreadAttribute;
+            this.argument = argument;
+        }
+        return JSXSpreadAttribute;
+    }());
+    exports.JSXSpreadAttribute = JSXSpreadAttribute;
+    var JSXText = (function () {
+        function JSXText(value, raw) {
+            this.type = jsx_syntax_1.JSXSyntax.JSXText;
+            this.value = value;
+            this.raw = raw;
+        }
+        return JSXText;
+    }());
+    exports.JSXText = JSXText;
+
+
+/***/ },
+/* 6 */
+/***/ function(module, exports) {
+
+    "use strict";
+    exports.JSXSyntax = {
+        JSXAttribute: 'JSXAttribute',
+        JSXClosingElement: 'JSXClosingElement',
+        JSXElement: 'JSXElement',
+        JSXEmptyExpression: 'JSXEmptyExpression',
+        JSXExpressionContainer: 'JSXExpressionContainer',
+        JSXIdentifier: 'JSXIdentifier',
+        JSXMemberExpression: 'JSXMemberExpression',
+        JSXNamespacedName: 'JSXNamespacedName',
+        JSXOpeningElement: 'JSXOpeningElement',
+        JSXSpreadAttribute: 'JSXSpreadAttribute',
+        JSXText: 'JSXText'
+    };
+
+
+/***/ },
+/* 7 */
 /***/ function(module, exports, __webpack_require__) {
 
     "use strict";
     var syntax_1 = __webpack_require__(2);
+    /* tslint:disable:max-classes-per-file */
     var ArrayExpression = (function () {
         function ArrayExpression(elements) {
             this.type = syntax_1.Syntax.ArrayExpression;
@@ -5244,6 +1479,13 @@ return /******/ (function(modules) { // webpackBootstrap
         return IfStatement;
     }());
     exports.IfStatement = IfStatement;
+    var Import = (function () {
+        function Import() {
+            this.type = syntax_1.Syntax.Import;
+        }
+        return Import;
+    }());
+    exports.Import = Import;
     var ImportDeclaration = (function () {
         function ImportDeclaration(specifiers, source) {
             this.type = syntax_1.Syntax.ImportDeclaration;
@@ -5365,11 +1607,11 @@ return /******/ (function(modules) { // webpackBootstrap
     }());
     exports.Property = Property;
     var RegexLiteral = (function () {
-        function RegexLiteral(value, raw, regex) {
+        function RegexLiteral(value, raw, pattern, flags) {
             this.type = syntax_1.Syntax.Literal;
             this.value = value;
             this.raw = raw;
-            this.regex = regex;
+            this.regex = { pattern: pattern, flags: flags };
         }
         return RegexLiteral;
     }());
@@ -5382,6 +1624,14 @@ return /******/ (function(modules) { // webpackBootstrap
         return RestElement;
     }());
     exports.RestElement = RestElement;
+    var RestProperty = (function () {
+        function RestProperty(argument) {
+            this.type = syntax_1.Syntax.RestProperty;
+            this.argument = argument;
+        }
+        return RestProperty;
+    }());
+    exports.RestProperty = RestProperty;
     var ReturnStatement = (function () {
         function ReturnStatement(argument) {
             this.type = syntax_1.Syntax.ReturnStatement;
@@ -5415,6 +1665,14 @@ return /******/ (function(modules) { // webpackBootstrap
         return SpreadElement;
     }());
     exports.SpreadElement = SpreadElement;
+    var SpreadProperty = (function () {
+        function SpreadProperty(argument) {
+            this.type = syntax_1.Syntax.SpreadProperty;
+            this.argument = argument;
+        }
+        return SpreadProperty;
+    }());
+    exports.SpreadProperty = SpreadProperty;
     var StaticMemberExpression = (function () {
         function StaticMemberExpression(object, property) {
             this.type = syntax_1.Syntax.MemberExpression;
@@ -5548,569 +1806,4545 @@ return /******/ (function(modules) { // webpackBootstrap
         }
         return WhileStatement;
     }());
-    exports.WhileStatement = WhileStatement;
-    var WithStatement = (function () {
-        function WithStatement(object, body) {
-            this.type = syntax_1.Syntax.WithStatement;
-            this.object = object;
-            this.body = body;
+    exports.WhileStatement = WhileStatement;
+    var WithStatement = (function () {
+        function WithStatement(object, body) {
+            this.type = syntax_1.Syntax.WithStatement;
+            this.object = object;
+            this.body = body;
+        }
+        return WithStatement;
+    }());
+    exports.WithStatement = WithStatement;
+    var YieldExpression = (function () {
+        function YieldExpression(argument, delegate) {
+            this.type = syntax_1.Syntax.YieldExpression;
+            this.argument = argument;
+            this.delegate = delegate;
+        }
+        return YieldExpression;
+    }());
+    exports.YieldExpression = YieldExpression;
+
+
+/***/ },
+/* 8 */
+/***/ function(module, exports, __webpack_require__) {
+
+    "use strict";
+    var assert_1 = __webpack_require__(9);
+    var error_handler_1 = __webpack_require__(10);
+    var messages_1 = __webpack_require__(11);
+    var Node = __webpack_require__(7);
+    var scanner_1 = __webpack_require__(12);
+    var syntax_1 = __webpack_require__(2);
+    var token_1 = __webpack_require__(13);
+    var ArrowParameterPlaceHolder = 'ArrowParameterPlaceHolder';
+    var Parser = (function () {
+        function Parser(code, options, delegate) {
+            if (options === void 0) { options = {}; }
+            this.config = {
+                range: (typeof options.range === 'boolean') && options.range,
+                loc: (typeof options.loc === 'boolean') && options.loc,
+                source: null,
+                tokens: (typeof options.tokens === 'boolean') && options.tokens,
+                comment: (typeof options.comment === 'boolean') && options.comment,
+                tolerant: (typeof options.tolerant === 'boolean') && options.tolerant
+            };
+            if (this.config.loc && options.source && options.source !== null) {
+                this.config.source = String(options.source);
+            }
+            this.delegate = delegate;
+            this.errorHandler = new error_handler_1.ErrorHandler();
+            this.errorHandler.tolerant = this.config.tolerant;
+            this.scanner = new scanner_1.Scanner(code, this.errorHandler);
+            this.scanner.trackComment = this.config.comment;
+            this.operatorPrecedence = {
+                ')': 0,
+                ';': 0,
+                ',': 0,
+                '=': 0,
+                ']': 0,
+                '||': 1,
+                '&&': 2,
+                '|': 3,
+                '^': 4,
+                '&': 5,
+                '==': 6,
+                '!=': 6,
+                '===': 6,
+                '!==': 6,
+                '<': 7,
+                '>': 7,
+                '<=': 7,
+                '>=': 7,
+                '<<': 8,
+                '>>': 8,
+                '>>>': 8,
+                '+': 9,
+                '-': 9,
+                '*': 11,
+                '/': 11,
+                '%': 11
+            };
+            this.lookahead = {
+                type: 2 /* EOF */,
+                value: '',
+                lineNumber: this.scanner.lineNumber,
+                lineStart: 0,
+                start: 0,
+                end: 0
+            };
+            this.hasLineTerminator = false;
+            this.context = {
+                isModule: false,
+                await: false,
+                allowIn: true,
+                allowStrictDirective: true,
+                allowYield: true,
+                firstCoverInitializedNameError: null,
+                isAssignmentTarget: false,
+                isBindingElement: false,
+                inFunctionBody: false,
+                inIteration: false,
+                inSwitch: false,
+                labelSet: {},
+                strict: false
+            };
+            this.tokens = [];
+            this.startMarker = {
+                index: 0,
+                line: this.scanner.lineNumber,
+                column: 0
+            };
+            this.lastMarker = {
+                index: 0,
+                line: this.scanner.lineNumber,
+                column: 0
+            };
+            this.nextToken();
+            this.lastMarker = {
+                index: this.scanner.index,
+                line: this.scanner.lineNumber,
+                column: this.scanner.index - this.scanner.lineStart
+            };
+        }
+        Parser.prototype.throwError = function (messageFormat) {
+            var values = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                values[_i - 1] = arguments[_i];
+            }
+            var args = Array.prototype.slice.call(arguments, 1);
+            var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) {
+                assert_1.assert(idx < args.length, 'Message reference must be in range');
+                return args[idx];
+            });
+            var index = this.lastMarker.index;
+            var line = this.lastMarker.line;
+            var column = this.lastMarker.column + 1;
+            throw this.errorHandler.createError(index, line, column, msg);
+        };
+        Parser.prototype.tolerateError = function (messageFormat) {
+            var values = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                values[_i - 1] = arguments[_i];
+            }
+            var args = Array.prototype.slice.call(arguments, 1);
+            var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) {
+                assert_1.assert(idx < args.length, 'Message reference must be in range');
+                return args[idx];
+            });
+            var index = this.lastMarker.index;
+            var line = this.scanner.lineNumber;
+            var column = this.lastMarker.column + 1;
+            this.errorHandler.tolerateError(index, line, column, msg);
+        };
+        // Throw an exception because of the token.
+        Parser.prototype.unexpectedTokenError = function (token, message) {
+            var msg = message || messages_1.Messages.UnexpectedToken;
+            var value;
+            if (token) {
+                if (!message) {
+                    msg = (token.type === 2 /* EOF */) ? messages_1.Messages.UnexpectedEOS :
+                        (token.type === 3 /* Identifier */) ? messages_1.Messages.UnexpectedIdentifier :
+                            (token.type === 6 /* NumericLiteral */) ? messages_1.Messages.UnexpectedNumber :
+                                (token.type === 8 /* StringLiteral */) ? messages_1.Messages.UnexpectedString :
+                                    (token.type === 10 /* Template */) ? messages_1.Messages.UnexpectedTemplate :
+                                        messages_1.Messages.UnexpectedToken;
+                    if (token.type === 4 /* Keyword */) {
+                        if (this.scanner.isFutureReservedWord(token.value)) {
+                            msg = messages_1.Messages.UnexpectedReserved;
+                        }
+                        else if (this.context.strict && this.scanner.isStrictModeReservedWord(token.value)) {
+                            msg = messages_1.Messages.StrictReservedWord;
+                        }
+                    }
+                }
+                value = token.value;
+            }
+            else {
+                value = 'ILLEGAL';
+            }
+            msg = msg.replace('%0', value);
+            if (token && typeof token.lineNumber === 'number') {
+                var index = token.start;
+                var line = token.lineNumber;
+                var lastMarkerLineStart = this.lastMarker.index - this.lastMarker.column;
+                var column = token.start - lastMarkerLineStart + 1;
+                return this.errorHandler.createError(index, line, column, msg);
+            }
+            else {
+                var index = this.lastMarker.index;
+                var line = this.lastMarker.line;
+                var column = this.lastMarker.column + 1;
+                return this.errorHandler.createError(index, line, column, msg);
+            }
+        };
+        Parser.prototype.throwUnexpectedToken = function (token, message) {
+            throw this.unexpectedTokenError(token, message);
+        };
+        Parser.prototype.tolerateUnexpectedToken = function (token, message) {
+            this.errorHandler.tolerate(this.unexpectedTokenError(token, message));
+        };
+        Parser.prototype.collectComments = function () {
+            if (!this.config.comment) {
+                this.scanner.scanComments();
+            }
+            else {
+                var comments = this.scanner.scanComments();
+                if (comments.length > 0 && this.delegate) {
+                    for (var i = 0; i < comments.length; ++i) {
+                        var e = comments[i];
+                        var node = void 0;
+                        node = {
+                            type: e.multiLine ? 'BlockComment' : 'LineComment',
+                            value: this.scanner.source.slice(e.slice[0], e.slice[1])
+                        };
+                        if (this.config.range) {
+                            node.range = e.range;
+                        }
+                        if (this.config.loc) {
+                            node.loc = e.loc;
+                        }
+                        var metadata = {
+                            start: {
+                                line: e.loc.start.line,
+                                column: e.loc.start.column,
+                                offset: e.range[0]
+                            },
+                            end: {
+                                line: e.loc.end.line,
+                                column: e.loc.end.column,
+                                offset: e.range[1]
+                            }
+                        };
+                        this.delegate(node, metadata);
+                    }
+                }
+            }
+        };
+        // From internal representation to an external structure
+        Parser.prototype.getTokenRaw = function (token) {
+            return this.scanner.source.slice(token.start, token.end);
+        };
+        Parser.prototype.convertToken = function (token) {
+            var t = {
+                type: token_1.TokenName[token.type],
+                value: this.getTokenRaw(token)
+            };
+            if (this.config.range) {
+                t.range = [token.start, token.end];
+            }
+            if (this.config.loc) {
+                t.loc = {
+                    start: {
+                        line: this.startMarker.line,
+                        column: this.startMarker.column
+                    },
+                    end: {
+                        line: this.scanner.lineNumber,
+                        column: this.scanner.index - this.scanner.lineStart
+                    }
+                };
+            }
+            if (token.type === 9 /* RegularExpression */) {
+                var pattern = token.pattern;
+                var flags = token.flags;
+                t.regex = { pattern: pattern, flags: flags };
+            }
+            return t;
+        };
+        Parser.prototype.nextToken = function () {
+            var token = this.lookahead;
+            this.lastMarker.index = this.scanner.index;
+            this.lastMarker.line = this.scanner.lineNumber;
+            this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
+            this.collectComments();
+            if (this.scanner.index !== this.startMarker.index) {
+                this.startMarker.index = this.scanner.index;
+                this.startMarker.line = this.scanner.lineNumber;
+                this.startMarker.column = this.scanner.index - this.scanner.lineStart;
+            }
+            var next = this.scanner.lex();
+            this.hasLineTerminator = (token.lineNumber !== next.lineNumber);
+            if (next && this.context.strict && next.type === 3 /* Identifier */) {
+                if (this.scanner.isStrictModeReservedWord(next.value)) {
+                    next.type = 4 /* Keyword */;
+                }
+            }
+            this.lookahead = next;
+            if (this.config.tokens && next.type !== 2 /* EOF */) {
+                this.tokens.push(this.convertToken(next));
+            }
+            return token;
+        };
+        Parser.prototype.nextRegexToken = function () {
+            this.collectComments();
+            var token = this.scanner.scanRegExp();
+            if (this.config.tokens) {
+                // Pop the previous token, '/' or '/='
+                // This is added from the lookahead token.
+                this.tokens.pop();
+                this.tokens.push(this.convertToken(token));
+            }
+            // Prime the next lookahead.
+            this.lookahead = token;
+            this.nextToken();
+            return token;
+        };
+        Parser.prototype.createNode = function () {
+            return {
+                index: this.startMarker.index,
+                line: this.startMarker.line,
+                column: this.startMarker.column
+            };
+        };
+        Parser.prototype.startNode = function (token) {
+            return {
+                index: token.start,
+                line: token.lineNumber,
+                column: token.start - token.lineStart
+            };
+        };
+        Parser.prototype.finalize = function (marker, node) {
+            if (this.config.range) {
+                node.range = [marker.index, this.lastMarker.index];
+            }
+            if (this.config.loc) {
+                node.loc = {
+                    start: {
+                        line: marker.line,
+                        column: marker.column,
+                    },
+                    end: {
+                        line: this.lastMarker.line,
+                        column: this.lastMarker.column
+                    }
+                };
+                if (this.config.source) {
+                    node.loc.source = this.config.source;
+                }
+            }
+            if (this.delegate) {
+                var metadata = {
+                    start: {
+                        line: marker.line,
+                        column: marker.column,
+                        offset: marker.index
+                    },
+                    end: {
+                        line: this.lastMarker.line,
+                        column: this.lastMarker.column,
+                        offset: this.lastMarker.index
+                    }
+                };
+                this.delegate(node, metadata);
+            }
+            return node;
+        };
+        // Expect the next token to match the specified punctuator.
+        // If not, an exception will be thrown.
+        Parser.prototype.expect = function (value) {
+            var token = this.nextToken();
+            if (token.type !== 7 /* Punctuator */ || token.value !== value) {
+                this.throwUnexpectedToken(token);
+            }
+        };
+        // Quietly expect a comma when in tolerant mode, otherwise delegates to expect().
+        Parser.prototype.expectCommaSeparator = function () {
+            if (this.config.tolerant) {
+                var token = this.lookahead;
+                if (token.type === 7 /* Punctuator */ && token.value === ',') {
+                    this.nextToken();
+                }
+                else if (token.type === 7 /* Punctuator */ && token.value === ';') {
+                    this.nextToken();
+                    this.tolerateUnexpectedToken(token);
+                }
+                else {
+                    this.tolerateUnexpectedToken(token, messages_1.Messages.UnexpectedToken);
+                }
+            }
+            else {
+                this.expect(',');
+            }
+        };
+        // Expect the next token to match the specified keyword.
+        // If not, an exception will be thrown.
+        Parser.prototype.expectKeyword = function (keyword) {
+            var token = this.nextToken();
+            if (token.type !== 4 /* Keyword */ || token.value !== keyword) {
+                this.throwUnexpectedToken(token);
+            }
+        };
+        // Return true if the next token matches the specified punctuator.
+        Parser.prototype.match = function (value) {
+            return this.lookahead.type === 7 /* Punctuator */ && this.lookahead.value === value;
+        };
+        // Return true if the next token matches the specified keyword
+        Parser.prototype.matchKeyword = function (keyword) {
+            return this.lookahead.type === 4 /* Keyword */ && this.lookahead.value === keyword;
+        };
+        // Return true if the next token matches the specified contextual keyword
+        // (where an identifier is sometimes a keyword depending on the context)
+        Parser.prototype.matchContextualKeyword = function (keyword) {
+            return this.lookahead.type === 3 /* Identifier */ && this.lookahead.value === keyword;
+        };
+        // Return true if the next token is an assignment operator
+        Parser.prototype.matchAssign = function () {
+            if (this.lookahead.type !== 7 /* Punctuator */) {
+                return false;
+            }
+            var op = this.lookahead.value;
+            return op === '=' ||
+                op === '*=' ||
+                op === '**=' ||
+                op === '/=' ||
+                op === '%=' ||
+                op === '+=' ||
+                op === '-=' ||
+                op === '<<=' ||
+                op === '>>=' ||
+                op === '>>>=' ||
+                op === '&=' ||
+                op === '^=' ||
+                op === '|=';
+        };
+        // Cover grammar support.
+        //
+        // When an assignment expression position starts with an left parenthesis, the determination of the type
+        // of the syntax is to be deferred arbitrarily long until the end of the parentheses pair (plus a lookahead)
+        // or the first comma. This situation also defers the determination of all the expressions nested in the pair.
+        //
+        // There are three productions that can be parsed in a parentheses pair that needs to be determined
+        // after the outermost pair is closed. They are:
+        //
+        //   1. AssignmentExpression
+        //   2. BindingElements
+        //   3. AssignmentTargets
+        //
+        // In order to avoid exponential backtracking, we use two flags to denote if the production can be
+        // binding element or assignment target.
+        //
+        // The three productions have the relationship:
+        //
+        //   BindingElements ⊆ AssignmentTargets ⊆ AssignmentExpression
+        //
+        // with a single exception that CoverInitializedName when used directly in an Expression, generates
+        // an early error. Therefore, we need the third state, firstCoverInitializedNameError, to track the
+        // first usage of CoverInitializedName and report it when we reached the end of the parentheses pair.
+        //
+        // isolateCoverGrammar function runs the given parser function with a new cover grammar context, and it does not
+        // effect the current flags. This means the production the parser parses is only used as an expression. Therefore
+        // the CoverInitializedName check is conducted.
+        //
+        // inheritCoverGrammar function runs the given parse function with a new cover grammar context, and it propagates
+        // the flags outside of the parser. This means the production the parser parses is used as a part of a potential
+        // pattern. The CoverInitializedName check is deferred.
+        Parser.prototype.isolateCoverGrammar = function (parseFunction) {
+            var previousIsBindingElement = this.context.isBindingElement;
+            var previousIsAssignmentTarget = this.context.isAssignmentTarget;
+            var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;
+            this.context.isBindingElement = true;
+            this.context.isAssignmentTarget = true;
+            this.context.firstCoverInitializedNameError = null;
+            var result = parseFunction.call(this);
+            if (this.context.firstCoverInitializedNameError !== null) {
+                this.throwUnexpectedToken(this.context.firstCoverInitializedNameError);
+            }
+            this.context.isBindingElement = previousIsBindingElement;
+            this.context.isAssignmentTarget = previousIsAssignmentTarget;
+            this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError;
+            return result;
+        };
+        Parser.prototype.inheritCoverGrammar = function (parseFunction) {
+            var previousIsBindingElement = this.context.isBindingElement;
+            var previousIsAssignmentTarget = this.context.isAssignmentTarget;
+            var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;
+            this.context.isBindingElement = true;
+            this.context.isAssignmentTarget = true;
+            this.context.firstCoverInitializedNameError = null;
+            var result = parseFunction.call(this);
+            this.context.isBindingElement = this.context.isBindingElement && previousIsBindingElement;
+            this.context.isAssignmentTarget = this.context.isAssignmentTarget && previousIsAssignmentTarget;
+            this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError || this.context.firstCoverInitializedNameError;
+            return result;
+        };
+        Parser.prototype.consumeSemicolon = function () {
+            if (this.match(';')) {
+                this.nextToken();
+            }
+            else if (!this.hasLineTerminator) {
+                if (this.lookahead.type !== 2 /* EOF */ && !this.match('}')) {
+                    this.throwUnexpectedToken(this.lookahead);
+                }
+                this.lastMarker.index = this.startMarker.index;
+                this.lastMarker.line = this.startMarker.line;
+                this.lastMarker.column = this.startMarker.column;
+            }
+        };
+        // https://tc39.github.io/ecma262/#sec-primary-expression
+        Parser.prototype.parsePrimaryExpression = function () {
+            var node = this.createNode();
+            var expr;
+            var token, raw;
+            switch (this.lookahead.type) {
+                case 3 /* Identifier */:
+                    if ((this.context.isModule || this.context.await) && this.lookahead.value === 'await') {
+                        this.tolerateUnexpectedToken(this.lookahead);
+                    }
+                    expr = this.matchAsyncFunction() ? this.parseFunctionExpression() : this.finalize(node, new Node.Identifier(this.nextToken().value));
+                    break;
+                case 6 /* NumericLiteral */:
+                case 8 /* StringLiteral */:
+                    if (this.context.strict && this.lookahead.octal) {
+                        this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.StrictOctalLiteral);
+                    }
+                    this.context.isAssignmentTarget = false;
+                    this.context.isBindingElement = false;
+                    token = this.nextToken();
+                    raw = this.getTokenRaw(token);
+                    expr = this.finalize(node, new Node.Literal(token.value, raw));
+                    break;
+                case 1 /* BooleanLiteral */:
+                    this.context.isAssignmentTarget = false;
+                    this.context.isBindingElement = false;
+                    token = this.nextToken();
+                    raw = this.getTokenRaw(token);
+                    expr = this.finalize(node, new Node.Literal(token.value === 'true', raw));
+                    break;
+                case 5 /* NullLiteral */:
+                    this.context.isAssignmentTarget = false;
+                    this.context.isBindingElement = false;
+                    token = this.nextToken();
+                    raw = this.getTokenRaw(token);
+                    expr = this.finalize(node, new Node.Literal(null, raw));
+                    break;
+                case 10 /* Template */:
+                    expr = this.parseTemplateLiteral();
+                    break;
+                case 7 /* Punctuator */:
+                    switch (this.lookahead.value) {
+                        case '(':
+                            this.context.isBindingElement = false;
+                            expr = this.inheritCoverGrammar(this.parseGroupExpression);
+                            break;
+                        case '[':
+                            expr = this.inheritCoverGrammar(this.parseArrayInitializer);
+                            break;
+                        case '{':
+                            expr = this.inheritCoverGrammar(this.parseObjectInitializer);
+                            break;
+                        case '/':
+                        case '/=':
+                            this.context.isAssignmentTarget = false;
+                            this.context.isBindingElement = false;
+                            this.scanner.index = this.startMarker.index;
+                            token = this.nextRegexToken();
+                            raw = this.getTokenRaw(token);
+                            expr = this.finalize(node, new Node.RegexLiteral(token.regex, raw, token.pattern, token.flags));
+                            break;
+                        default:
+                            expr = this.throwUnexpectedToken(this.nextToken());
+                    }
+                    break;
+                case 4 /* Keyword */:
+                    if (!this.context.strict && this.context.allowYield && this.matchKeyword('yield')) {
+                        expr = this.parseIdentifierName();
+                    }
+                    else if (!this.context.strict && this.matchKeyword('let')) {
+                        expr = this.finalize(node, new Node.Identifier(this.nextToken().value));
+                    }
+                    else {
+                        this.context.isAssignmentTarget = false;
+                        this.context.isBindingElement = false;
+                        if (this.matchKeyword('function')) {
+                            expr = this.parseFunctionExpression();
+                        }
+                        else if (this.matchKeyword('this')) {
+                            this.nextToken();
+                            expr = this.finalize(node, new Node.ThisExpression());
+                        }
+                        else if (this.matchKeyword('class')) {
+                            expr = this.parseClassExpression();
+                        }
+                        else if (this.matchImportCall()) {
+                            expr = this.parseImportCall();
+                        }
+                        else {
+                            expr = this.throwUnexpectedToken(this.nextToken());
+                        }
+                    }
+                    break;
+                default:
+                    expr = this.throwUnexpectedToken(this.nextToken());
+            }
+            return expr;
+        };
+        // https://tc39.github.io/ecma262/#sec-array-initializer
+        Parser.prototype.parseSpreadElement = function () {
+            var node = this.createNode();
+            this.expect('...');
+            var arg = this.inheritCoverGrammar(this.parseAssignmentExpression);
+            return this.finalize(node, new Node.SpreadElement(arg));
+        };
+        Parser.prototype.parseArrayInitializer = function () {
+            var node = this.createNode();
+            var elements = [];
+            this.expect('[');
+            while (!this.match(']')) {
+                if (this.match(',')) {
+                    this.nextToken();
+                    elements.push(null);
+                }
+                else if (this.match('...')) {
+                    var element = this.parseSpreadElement();
+                    if (!this.match(']')) {
+                        this.context.isAssignmentTarget = false;
+                        this.context.isBindingElement = false;
+                        this.expect(',');
+                    }
+                    elements.push(element);
+                }
+                else {
+                    elements.push(this.inheritCoverGrammar(this.parseAssignmentExpression));
+                    if (!this.match(']')) {
+                        this.expect(',');
+                    }
+                }
+            }
+            this.expect(']');
+            return this.finalize(node, new Node.ArrayExpression(elements));
+        };
+        // https://tc39.github.io/ecma262/#sec-object-initializer
+        Parser.prototype.parsePropertyMethod = function (params) {
+            this.context.isAssignmentTarget = false;
+            this.context.isBindingElement = false;
+            var previousStrict = this.context.strict;
+            var previousAllowStrictDirective = this.context.allowStrictDirective;
+            this.context.allowStrictDirective = params.simple;
+            var body = this.isolateCoverGrammar(this.parseFunctionSourceElements);
+            if (this.context.strict && params.firstRestricted) {
+                this.tolerateUnexpectedToken(params.firstRestricted, params.message);
+            }
+            if (this.context.strict && params.stricted) {
+                this.tolerateUnexpectedToken(params.stricted, params.message);
+            }
+            this.context.strict = previousStrict;
+            this.context.allowStrictDirective = previousAllowStrictDirective;
+            return body;
+        };
+        Parser.prototype.parsePropertyMethodFunction = function () {
+            var isGenerator = false;
+            var node = this.createNode();
+            var previousAllowYield = this.context.allowYield;
+            this.context.allowYield = false;
+            var params = this.parseFormalParameters();
+            var method = this.parsePropertyMethod(params);
+            this.context.allowYield = previousAllowYield;
+            return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
+        };
+        Parser.prototype.parsePropertyMethodAsyncFunction = function () {
+            var node = this.createNode();
+            var previousAllowYield = this.context.allowYield;
+            var previousAwait = this.context.await;
+            this.context.allowYield = false;
+            this.context.await = true;
+            var params = this.parseFormalParameters();
+            var method = this.parsePropertyMethod(params);
+            this.context.allowYield = previousAllowYield;
+            this.context.await = previousAwait;
+            return this.finalize(node, new Node.AsyncFunctionExpression(null, params.params, method));
+        };
+        Parser.prototype.parseObjectPropertyKey = function () {
+            var node = this.createNode();
+            var token = this.nextToken();
+            var key;
+            switch (token.type) {
+                case 8 /* StringLiteral */:
+                case 6 /* NumericLiteral */:
+                    if (this.context.strict && token.octal) {
+                        this.tolerateUnexpectedToken(token, messages_1.Messages.StrictOctalLiteral);
+                    }
+                    var raw = this.getTokenRaw(token);
+                    key = this.finalize(node, new Node.Literal(token.value, raw));
+                    break;
+                case 3 /* Identifier */:
+                case 1 /* BooleanLiteral */:
+                case 5 /* NullLiteral */:
+                case 4 /* Keyword */:
+                    key = this.finalize(node, new Node.Identifier(token.value));
+                    break;
+                case 7 /* Punctuator */:
+                    if (token.value === '[') {
+                        key = this.isolateCoverGrammar(this.parseAssignmentExpression);
+                        this.expect(']');
+                    }
+                    else {
+                        key = this.throwUnexpectedToken(token);
+                    }
+                    break;
+                default:
+                    key = this.throwUnexpectedToken(token);
+            }
+            return key;
+        };
+        Parser.prototype.isPropertyKey = function (key, value) {
+            return (key.type === syntax_1.Syntax.Identifier && key.name === value) ||
+                (key.type === syntax_1.Syntax.Literal && key.value === value);
+        };
+        Parser.prototype.parseObjectProperty = function (hasProto) {
+            var node = this.createNode();
+            var token = this.lookahead;
+            var kind;
+            var key = null;
+            var value = null;
+            var computed = false;
+            var method = false;
+            var shorthand = false;
+            var isAsync = false;
+            if (token.type === 3 /* Identifier */) {
+                var id = token.value;
+                this.nextToken();
+                if (id === 'async' && !this.hasLineTerminator) {
+                    computed = this.match('[');
+                    if (computed) {
+                        isAsync = true;
+                        key = this.parseObjectPropertyKey();
+                    }
+                    else {
+                        var punctuator = this.lookahead.value;
+                        if (punctuator !== ':' && punctuator !== '(' && punctuator !== '*') {
+                            isAsync = true;
+                            token = this.lookahead;
+                            id = token.value;
+