<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[211554] trunk</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/211554">211554</a></dd>
<dt>Author</dt> <dd>utatane.tea@gmail.com</dd>
<dt>Date</dt> <dd>2017-02-02 02:31:18 -0800 (Thu, 02 Feb 2017)</dd>
</dl>
<h3>Log Message</h3>
<pre>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.
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:</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkLayoutTestsChangeLog">trunk/LayoutTests/ChangeLog</a></li>
<li><a href="#trunkLayoutTestsinspectorformattingformattingjavascriptexpectedtxt">trunk/LayoutTests/inspector/formatting/formatting-javascript-expected.txt</a></li>
<li><a href="#trunkLayoutTestsinspectorformattingformattingjavascripthtml">trunk/LayoutTests/inspector/formatting/formatting-javascript.html</a></li>
<li><a href="#trunkLayoutTestsinspectorformattingresourcesjavascripttestsobjectarrayliteralexpectedjs">trunk/LayoutTests/inspector/formatting/resources/javascript-tests/object-array-literal-expected.js</a></li>
<li><a href="#trunkLayoutTestsinspectorformattingresourcesjavascripttestsobjectarrayliteraljs">trunk/LayoutTests/inspector/formatting/resources/javascript-tests/object-array-literal.js</a></li>
<li><a href="#trunkLayoutTestsinspectorformattingresourcesjavascripttestsvariabledeclarationexpectedjs">trunk/LayoutTests/inspector/formatting/resources/javascript-tests/variable-declaration-expected.js</a></li>
<li><a href="#trunkLayoutTestsinspectorformattingresourcesjavascripttestsvariabledeclarationjs">trunk/LayoutTests/inspector/formatting/resources/javascript-tests/variable-declaration.js</a></li>
<li><a href="#trunkLayoutTestsinspectorformattingresourcesutilitiesjs">trunk/LayoutTests/inspector/formatting/resources/utilities.js</a></li>
<li><a href="#trunkLayoutTestsinspectormodelparsescriptsyntaxtreeexpectedtxt">trunk/LayoutTests/inspector/model/parse-script-syntax-tree-expected.txt</a></li>
<li><a href="#trunkLayoutTestsinspectormodelparsescriptsyntaxtreehtml">trunk/LayoutTests/inspector/model/parse-script-syntax-tree.html</a></li>
<li><a href="#trunkSourceWebInspectorUIChangeLog">trunk/Source/WebInspectorUI/ChangeLog</a></li>
<li><a href="#trunkSourceWebInspectorUIToolsFormattingindexhtml">trunk/Source/WebInspectorUI/Tools/Formatting/index.html</a></li>
<li><a href="#trunkSourceWebInspectorUIUserInterfaceExternalEsprimaesprimajs">trunk/Source/WebInspectorUI/UserInterface/External/Esprima/esprima.js</a></li>
<li><a href="#trunkSourceWebInspectorUIUserInterfaceModelsScriptSyntaxTreejs">trunk/Source/WebInspectorUI/UserInterface/Models/ScriptSyntaxTree.js</a></li>
<li><a href="#trunkSourceWebInspectorUIUserInterfaceWorkersFormatterESTreeWalkerjs">trunk/Source/WebInspectorUI/UserInterface/Workers/Formatter/ESTreeWalker.js</a></li>
<li><a href="#trunkSourceWebInspectorUIUserInterfaceWorkersFormatterEsprimaFormatterjs">trunk/Source/WebInspectorUI/UserInterface/Workers/Formatter/EsprimaFormatter.js</a></li>
</ul>
<h3>Added Paths</h3>
<ul>
<li><a href="#trunkLayoutTestsinspectorformattingresourcesjavascripttestsimportexpectedjs">trunk/LayoutTests/inspector/formatting/resources/javascript-tests/import-expected.js</a></li>
<li><a href="#trunkLayoutTestsinspectorformattingresourcesjavascripttestsimportjs">trunk/LayoutTests/inspector/formatting/resources/javascript-tests/import.js</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkLayoutTestsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/ChangeLog (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/ChangeLog 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/LayoutTests/ChangeLog 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -1,3 +1,28 @@
</span><ins>+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:
+
</ins><span class="cx"> 2017-02-01 Zan Dobersek <zdobersek@igalia.com>
</span><span class="cx">
</span><span class="cx"> [EME] Implement MediaKeySession::update()
</span></span></pre></div>
<a id="trunkLayoutTestsinspectorformattingformattingjavascriptexpectedtxt"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/inspector/formatting/formatting-javascript-expected.txt (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/inspector/formatting/formatting-javascript-expected.txt 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/LayoutTests/inspector/formatting/formatting-javascript-expected.txt 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -29,6 +29,9 @@
</span><span class="cx"> -- Running test case: EsprimaFormatter.JavaScript.if-statement.js
</span><span class="cx"> PASS
</span><span class="cx">
</span><ins>+-- Running test case: EsprimaFormatter.JavaScript.import.js
+PASS
+
</ins><span class="cx"> -- Running test case: EsprimaFormatter.JavaScript.label-break-continue-block.js
</span><span class="cx"> PASS
</span><span class="cx">
</span></span></pre></div>
<a id="trunkLayoutTestsinspectorformattingformattingjavascripthtml"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/inspector/formatting/formatting-javascript.html (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/inspector/formatting/formatting-javascript.html 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/LayoutTests/inspector/formatting/formatting-javascript.html 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -18,6 +18,7 @@
</span><span class="cx"> "resources/javascript-tests/functions.js",
</span><span class="cx"> "resources/javascript-tests/generators.js",
</span><span class="cx"> "resources/javascript-tests/if-statement.js",
</span><ins>+ "resources/javascript-tests/import.js",
</ins><span class="cx"> "resources/javascript-tests/label-break-continue-block.js",
</span><span class="cx"> "resources/javascript-tests/logic-expressions.js",
</span><span class="cx"> "resources/javascript-tests/new-expression.js",
</span></span></pre></div>
<a id="trunkLayoutTestsinspectorformattingresourcesjavascripttestsimportexpectedjs"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/inspector/formatting/resources/javascript-tests/import-expected.js (0 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/inspector/formatting/resources/javascript-tests/import-expected.js (rev 0)
+++ trunk/LayoutTests/inspector/formatting/resources/javascript-tests/import-expected.js 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -0,0 +1,6 @@
</span><ins>+import("./Cocoa.js");
+import(host + "/Cocoa.js");
+
+async function load() {
+ return await import("./Cappuccino.js");
+}
</ins></span></pre></div>
<a id="trunkLayoutTestsinspectorformattingresourcesjavascripttestsimportjs"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/inspector/formatting/resources/javascript-tests/import.js (0 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/inspector/formatting/resources/javascript-tests/import.js (rev 0)
+++ trunk/LayoutTests/inspector/formatting/resources/javascript-tests/import.js 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -0,0 +1,4 @@
</span><ins>+import("./Cocoa.js");
+import(host + "/Cocoa.js");
+
+async function load() { return await import("./Cappuccino.js"); }
</ins></span></pre></div>
<a id="trunkLayoutTestsinspectorformattingresourcesjavascripttestsobjectarrayliteralexpectedjs"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/inspector/formatting/resources/javascript-tests/object-array-literal-expected.js (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/inspector/formatting/resources/javascript-tests/object-array-literal-expected.js 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/LayoutTests/inspector/formatting/resources/javascript-tests/object-array-literal-expected.js 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -29,6 +29,16 @@
</span><span class="cx"> c: 3,
</span><span class="cx"> d: 4
</span><span class="cx"> }
</span><ins>+o = {
+ a: 1,
+ b: 2,
+ c: 3,
+ d: 4,
+ ...e
+}
+o = {
+ ...a
+}
</ins><span class="cx">
</span><span class="cx"> ;
</span><span class="cx"> [];
</span></span></pre></div>
<a id="trunkLayoutTestsinspectorformattingresourcesjavascripttestsobjectarrayliteraljs"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/inspector/formatting/resources/javascript-tests/object-array-literal.js (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/inspector/formatting/resources/javascript-tests/object-array-literal.js 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/LayoutTests/inspector/formatting/resources/javascript-tests/object-array-literal.js 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -8,6 +8,8 @@
</span><span class="cx"> o={a:1,b:2}
</span><span class="cx"> o={a:1,b:2,c:3}
</span><span class="cx"> o={a:1,b:2,c:3,d:4}
</span><ins>+o={a:1,b:2,c:3,d:4,...e}
+o={...a}
</ins><span class="cx">
</span><span class="cx"> ;
</span><span class="cx"> [];
</span></span></pre></div>
<a id="trunkLayoutTestsinspectorformattingresourcesjavascripttestsvariabledeclarationexpectedjs"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/inspector/formatting/resources/javascript-tests/variable-declaration-expected.js (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/inspector/formatting/resources/javascript-tests/variable-declaration-expected.js 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/LayoutTests/inspector/formatting/resources/javascript-tests/variable-declaration-expected.js 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -52,3 +52,14 @@
</span><span class="cx"> },
</span><span class="cx"> club: [4, 5]
</span><span class="cx"> };
</span><ins>+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];
</ins></span></pre></div>
<a id="trunkLayoutTestsinspectorformattingresourcesjavascripttestsvariabledeclarationjs"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/inspector/formatting/resources/javascript-tests/variable-declaration.js (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/inspector/formatting/resources/javascript-tests/variable-declaration.js 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/LayoutTests/inspector/formatting/resources/javascript-tests/variable-declaration.js 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -23,3 +23,8 @@
</span><span class="cx">
</span><span class="cx"> var {alpha:a,beta:{b,gamma:c},club:[d,e]} = o;
</span><span class="cx"> var {alpha:a,beta:{b,gamma:c},club:[d,e]} = {alpha:1,beta:{b:2,gamma:3},club:[4,5]};
</span><ins>+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];
</ins></span></pre></div>
<a id="trunkLayoutTestsinspectorformattingresourcesutilitiesjs"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/inspector/formatting/resources/utilities.js (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/inspector/formatting/resources/utilities.js 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/LayoutTests/inspector/formatting/resources/utilities.js 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -25,9 +25,9 @@
</span><span class="cx"> InspectorTest.log("-----------");
</span><span class="cx"> InspectorTest.log(testText);
</span><span class="cx"> InspectorTest.log("-----------");
</span><del>- InspectorTest.log("Formatted Output: " + builder.formattedContent.length);
</del><ins>+ InspectorTest.log("Formatted Output: " + formattedText.length);
</ins><span class="cx"> InspectorTest.log("-----------");
</span><del>- InspectorTest.log(builder.formattedContent);
</del><ins>+ InspectorTest.log(formattedText);
</ins><span class="cx"> InspectorTest.log("-----------");
</span><span class="cx"> InspectorTest.log("Expected Output: " + expectedText.length);
</span><span class="cx"> InspectorTest.log("-----------");
</span></span></pre></div>
<a id="trunkLayoutTestsinspectormodelparsescriptsyntaxtreeexpectedtxt"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/inspector/model/parse-script-syntax-tree-expected.txt (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/inspector/model/parse-script-syntax-tree-expected.txt 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/LayoutTests/inspector/model/parse-script-syntax-tree-expected.txt 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -41,6 +41,9 @@
</span><span class="cx"> passed WithStatement
</span><span class="cx"> passed YieldExpression
</span><span class="cx"> passed ClassStatement, Super, MetaProperty
</span><ins>+passed Import
+passed RestProperty
+passed SpreadProperty
</ins><span class="cx"> passed AssignmentPattern
</span><span class="cx"> passed ArrowFunctionExpression
</span><span class="cx"> passed Async Functions
</span></span></pre></div>
<a id="trunkLayoutTestsinspectormodelparsescriptsyntaxtreehtml"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/inspector/model/parse-script-syntax-tree.html (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/inspector/model/parse-script-syntax-tree.html 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/LayoutTests/inspector/model/parse-script-syntax-tree.html 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -495,6 +495,38 @@
</span><span class="cx"> InspectorTest.assert(node.body.body[0].value.body.body[1].expression.property.name === "target");
</span><span class="cx"> InspectorTest.log("passed ClassStatement, Super, MetaProperty");
</span><span class="cx">
</span><ins>+ 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");
+
</ins><span class="cx"> node = makeNode("let [x=20] = [];", false);
</span><span class="cx"> InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.VariableDeclaration);
</span><span class="cx"> InspectorTest.assert(node.kind === "let");
</span></span></pre></div>
<a id="trunkSourceWebInspectorUIChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebInspectorUI/ChangeLog (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebInspectorUI/ChangeLog 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/Source/WebInspectorUI/ChangeLog 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -1,3 +1,31 @@
</span><ins>+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):
+
</ins><span class="cx"> 2017-02-01 Joseph Pecoraro <pecoraro@apple.com>
</span><span class="cx">
</span><span class="cx"> Web Inspector: Remove keyboard shortcut to close tab - does not match expectations
</span></span></pre></div>
<a id="trunkSourceWebInspectorUIToolsFormattingindexhtml"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebInspectorUI/Tools/Formatting/index.html (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebInspectorUI/Tools/Formatting/index.html 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/Source/WebInspectorUI/Tools/Formatting/index.html 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -44,6 +44,7 @@
</span><span class="cx">
</span><span class="cx"> let tests = [
</span><span class="cx"> "if-statement.js",
</span><ins>+ "import.js",
</ins><span class="cx"> "for-statements.js",
</span><span class="cx"> "while-statement.js",
</span><span class="cx"> "do-while-statement.js",
</span></span></pre></div>
<a id="trunkSourceWebInspectorUIUserInterfaceExternalEsprimaesprimajs"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebInspectorUI/UserInterface/External/Esprima/esprima.js (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebInspectorUI/UserInterface/External/Esprima/esprima.js 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/Source/WebInspectorUI/UserInterface/External/Esprima/esprima.js 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -82,8 +82,8 @@
</span><span class="cx"> */
</span><span class="cx"> "use strict";
</span><span class="cx"> var comment_handler_1 = __webpack_require__(1);
</span><del>- var parser_1 = __webpack_require__(3);
- var jsx_parser_1 = __webpack_require__(11);
</del><ins>+ var jsx_parser_1 = __webpack_require__(3);
+ var parser_1 = __webpack_require__(8);
</ins><span class="cx"> var tokenizer_1 = __webpack_require__(15);
</span><span class="cx"> function parse(code, options, delegate) {
</span><span class="cx"> var commentHandler = null;
</span><span class="lines">@@ -119,7 +119,7 @@
</span><span class="cx"> parser = new parser_1.Parser(code, options, parserDelegate);
</span><span class="cx"> }
</span><span class="cx"> var program = isModule ? parser.parseModule() : parser.parseScript();
</span><del>- var ast = (program);
</del><ins>+ var ast = program;
</ins><span class="cx"> if (collectComment && commentHandler) {
</span><span class="cx"> ast.comments = commentHandler.comments;
</span><span class="cx"> }
</span><span class="lines">@@ -366,6 +366,7 @@
</span><span class="cx"> FunctionExpression: 'FunctionExpression',
</span><span class="cx"> Identifier: 'Identifier',
</span><span class="cx"> IfStatement: 'IfStatement',
</span><ins>+ Import: 'Import',
</ins><span class="cx"> ImportDeclaration: 'ImportDeclaration',
</span><span class="cx"> ImportDefaultSpecifier: 'ImportDefaultSpecifier',
</span><span class="cx"> ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
</span><span class="lines">@@ -382,9 +383,11 @@
</span><span class="cx"> Program: 'Program',
</span><span class="cx"> Property: 'Property',
</span><span class="cx"> RestElement: 'RestElement',
</span><ins>+ RestProperty: 'RestProperty',
</ins><span class="cx"> ReturnStatement: 'ReturnStatement',
</span><span class="cx"> SequenceExpression: 'SequenceExpression',
</span><span class="cx"> SpreadElement: 'SpreadElement',
</span><ins>+ SpreadProperty: 'SpreadProperty',
</ins><span class="cx"> Super: 'Super',
</span><span class="cx"> SwitchCase: 'SwitchCase',
</span><span class="cx"> SwitchStatement: 'SwitchStatement',
</span><span class="lines">@@ -409,13 +412,1433 @@
</span><span class="cx"> /***/ function(module, exports, __webpack_require__) {
</span><span class="cx">
</span><span class="cx"> "use strict";
</span><del>- 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);
</del><ins>+/* 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;
+ }
+ 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);
+ };
+ 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;
+ };
+ 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();
+ }
+ };
+ JSXParser.prototype.createJSXNode = function () {
+ this.collectComments();
+ return {
+ index: this.scanner.index,
+ line: this.scanner.lineNumber,
+ column: this.scanner.index - this.scanner.lineStart
+ };
+ };
+ JSXParser.prototype.createJSXChildNode = function () {
+ return {
+ index: this.scanner.index,
+ line: this.scanner.lineNumber,
+ column: this.scanner.index - this.scanner.lineStart
+ };
+ };
+ 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;
+ }
+ 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;
+ };
+ // 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 (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
+ };
+ }
+ // ... 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
+ };
+ }
+ // `
+ 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
+ };
+ }
+ // 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 this.scanner.throwUnexpectedToken();
+ };
+ JSXParser.prototype.nextJSXToken = function () {
+ this.collectComments();
+ 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) {
+ this.tokens.push(this.convertToken(token));
+ }
+ return token;
+ };
+ 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;
+ }
+ this.scanner.lineStart = this.scanner.index;
+ }
+ }
+ 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 token;
+ };
+ 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.
+ JSXParser.prototype.expectJSX = function (value) {
+ var token = this.nextJSXToken();
+ if (token.type !== 7 /* Punctuator */ || token.value !== value) {
+ this.throwUnexpectedToken(token);
+ }
+ };
+ // 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;
+ };
+ 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));
+ };
+ 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));
+ }
+ 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));
+ }
+ }
+ return elementName;
+ };
+ 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 {
+ attributeName = identifier;
+ }
+ return attributeName;
+ };
+ JSXParser.prototype.parseJSXStringLiteralAttribute = function () {
+ var node = this.createJSXNode();
+ var token = this.nextJSXToken();
+ if (token.type !== 8 /* StringLiteral */) {
+ this.throwUnexpectedToken(token);
+ }
+ var raw = this.getTokenRaw(token);
+ return this.finalize(node, new Node.Literal(token.value, raw));
+ };
+ 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');
+ }
+ var expression = this.parseAssignmentExpression();
+ this.reenterJSX();
+ return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));
+ };
+ 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();
+ }
+ return this.finalize(node, new JSXNode.JSXAttribute(name, value));
+ };
+ 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));
+ };
+ JSXParser.prototype.parseJSXAttributes = function () {
+ var attributes = [];
+ while (!this.matchJSX('/') && !this.matchJSX('>')) {
+ var attribute = this.matchJSX('{') ? this.parseJSXSpreadAttribute() :
+ this.parseJSXNameValueAttribute();
+ attributes.push(attribute);
+ }
+ return attributes;
+ };
+ 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('/');
+ }
+ 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));
+ }
+ var name = this.parseJSXElementName();
+ var attributes = this.parseJSXAttributes();
+ var selfClosing = this.matchJSX('/');
+ if (selfClosing) {
+ this.expectJSX('/');
+ }
+ 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 {
+ 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);
+ }
+ if (this.scanner.source[this.scanner.index] === '{') {
+ var container = this.parseJSXExpressionContainer();
+ children.push(container);
+ }
+ else {
+ break;
+ }
+ }
+ 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 {
+ stack.push(el);
+ el = { node: node, opening: opening, closing: null, children: [] };
+ }
+ }
+ 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 el;
+ };
+ 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;
+ }
+ return this.finalize(node, new JSXNode.JSXElement(opening, children, closing));
+ };
+ JSXParser.prototype.parseJSXRoot = function () {
+ // Pop the opening '<' added from the lookahead.
+ if (this.config.tokens) {
+ this.tokens.pop();
+ }
+ this.startJSX();
+ var element = this.parseJSXElement();
+ this.finishJSX();
+ return element;
+ };
+ return JSXParser;
+ }(parser_1.Parser));
+ exports.JSXParser = JSXParser;
+
+
+/***/ },
+/* 4 */
+/***/ function(module, exports) {
+
+ "use strict";
+ // See also tools/generate-unicode-regex.js.
+ var Regex = {
+ // Unicode v8.0.0 NonAsciiIdentifierStart:
+ NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5
C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\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-\u12C
5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\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\u2071\u207F\u2090-\u209C\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-\u2CEE\u2CF2\u2CF3\u2D0
0-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB
\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\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\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\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\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0
-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\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\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD
07-\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]|\uD83A[\uDC00-\uDCC4]|\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]/,
+ // Unicode v8.0.0 NonAsciiIdentifierPart:
+ 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-\u0DD
4\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-\u
191E\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\u3
021-\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\uF
E76-\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\uDC9
D\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]|\uD
86E[\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));
+ },
+ // 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);
+ },
+ // https://tc39.github.io/ecma262/#sec-line-terminators
+ isLineTerminator: function (cp) {
+ return (cp === 0x0A) || (cp === 0x0D) || (cp === 0x2028) || (cp === 0x2029);
+ },
+ // https://tc39.github.io/ecma262/#sec-names-and-keywords
+ isIdentifierStart: function (cp) {
+ return (cp === 0x24) || (cp === 0x5F) ||
+ (cp >= 0x41 && cp <= 0x5A) ||
+ (cp >= 0x61 && cp <= 0x7A) ||
+ (cp === 0x5C) ||
+ ((cp >= 0x80) && Regex.NonAsciiIdentifierStart.test(exports.Character.fromCodePoint(cp)));
+ },
+ isIdentifierPart: function (cp) {
+ return (cp === 0x24) || (cp === 0x5F) ||
+ (cp >= 0x41 && cp <= 0x5A) ||
+ (cp >= 0x61 && cp <= 0x7A) ||
+ (cp >= 0x30 && cp <= 0x39) ||
+ (cp === 0x5C) ||
+ ((cp >= 0x80) && Regex.NonAsciiIdentifierPart.test(exports.Character.fromCodePoint(cp)));
+ },
+ // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
+ isDecimalDigit: function (cp) {
+ return (cp >= 0x30 && cp <= 0x39); // 0..9
+ },
+ isHexDigit: function (cp) {
+ return (cp >= 0x30 && cp <= 0x39) ||
+ (cp >= 0x41 && cp <= 0x46) ||
+ (cp >= 0x61 && cp <= 0x66); // a..f
+ },
+ isOctalDigit: function (cp) {
+ return (cp >= 0x30 && cp <= 0x37); // 0..7
+ }
+ };
+
+
+/***/ },
+/* 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";
</ins><span class="cx"> var syntax_1 = __webpack_require__(2);
</span><del>- var Node = __webpack_require__(10);
</del><ins>+ /* tslint:disable:max-classes-per-file */
+ var ArrayExpression = (function () {
+ function ArrayExpression(elements) {
+ this.type = syntax_1.Syntax.ArrayExpression;
+ this.elements = elements;
+ }
+ return ArrayExpression;
+ }());
+ exports.ArrayExpression = ArrayExpression;
+ var ArrayPattern = (function () {
+ function ArrayPattern(elements) {
+ this.type = syntax_1.Syntax.ArrayPattern;
+ this.elements = elements;
+ }
+ return ArrayPattern;
+ }());
+ exports.ArrayPattern = ArrayPattern;
+ var ArrowFunctionExpression = (function () {
+ function ArrowFunctionExpression(params, body, expression) {
+ this.type = syntax_1.Syntax.ArrowFunctionExpression;
+ this.id = null;
+ this.params = params;
+ this.body = body;
+ this.generator = false;
+ this.expression = expression;
+ this.async = false;
+ }
+ return ArrowFunctionExpression;
+ }());
+ exports.ArrowFunctionExpression = ArrowFunctionExpression;
+ var AssignmentExpression = (function () {
+ function AssignmentExpression(operator, left, right) {
+ this.type = syntax_1.Syntax.AssignmentExpression;
+ this.operator = operator;
+ this.left = left;
+ this.right = right;
+ }
+ return AssignmentExpression;
+ }());
+ exports.AssignmentExpression = AssignmentExpression;
+ var AssignmentPattern = (function () {
+ function AssignmentPattern(left, right) {
+ this.type = syntax_1.Syntax.AssignmentPattern;
+ this.left = left;
+ this.right = right;
+ }
+ return AssignmentPattern;
+ }());
+ exports.AssignmentPattern = AssignmentPattern;
+ var AsyncArrowFunctionExpression = (function () {
+ function AsyncArrowFunctionExpression(params, body, expression) {
+ this.type = syntax_1.Syntax.ArrowFunctionExpression;
+ this.id = null;
+ this.params = params;
+ this.body = body;
+ this.generator = false;
+ this.expression = expression;
+ this.async = true;
+ }
+ return AsyncArrowFunctionExpression;
+ }());
+ exports.AsyncArrowFunctionExpression = AsyncArrowFunctionExpression;
+ var AsyncFunctionDeclaration = (function () {
+ function AsyncFunctionDeclaration(id, params, body) {
+ this.type = syntax_1.Syntax.FunctionDeclaration;
+ this.id = id;
+ this.params = params;
+ this.body = body;
+ this.generator = false;
+ this.expression = false;
+ this.async = true;
+ }
+ return AsyncFunctionDeclaration;
+ }());
+ exports.AsyncFunctionDeclaration = AsyncFunctionDeclaration;
+ var AsyncFunctionExpression = (function () {
+ function AsyncFunctionExpression(id, params, body) {
+ this.type = syntax_1.Syntax.FunctionExpression;
+ this.id = id;
+ this.params = params;
+ this.body = body;
+ this.generator = false;
+ this.expression = false;
+ this.async = true;
+ }
+ return AsyncFunctionExpression;
+ }());
+ exports.AsyncFunctionExpression = AsyncFunctionExpression;
+ var AwaitExpression = (function () {
+ function AwaitExpression(argument) {
+ this.type = syntax_1.Syntax.AwaitExpression;
+ this.argument = argument;
+ }
+ return AwaitExpression;
+ }());
+ exports.AwaitExpression = AwaitExpression;
+ var BinaryExpression = (function () {
+ function BinaryExpression(operator, left, right) {
+ var logical = (operator === '||' || operator === '&&');
+ this.type = logical ? syntax_1.Syntax.LogicalExpression : syntax_1.Syntax.BinaryExpression;
+ this.operator = operator;
+ this.left = left;
+ this.right = right;
+ }
+ return BinaryExpression;
+ }());
+ exports.BinaryExpression = BinaryExpression;
+ var BlockStatement = (function () {
+ function BlockStatement(body) {
+ this.type = syntax_1.Syntax.BlockStatement;
+ this.body = body;
+ }
+ return BlockStatement;
+ }());
+ exports.BlockStatement = BlockStatement;
+ var BreakStatement = (function () {
+ function BreakStatement(label) {
+ this.type = syntax_1.Syntax.BreakStatement;
+ this.label = label;
+ }
+ return BreakStatement;
+ }());
+ exports.BreakStatement = BreakStatement;
+ var CallExpression = (function () {
+ function CallExpression(callee, args) {
+ this.type = syntax_1.Syntax.CallExpression;
+ this.callee = callee;
+ this.arguments = args;
+ }
+ return CallExpression;
+ }());
+ exports.CallExpression = CallExpression;
+ var CatchClause = (function () {
+ function CatchClause(param, body) {
+ this.type = syntax_1.Syntax.CatchClause;
+ this.param = param;
+ this.body = body;
+ }
+ return CatchClause;
+ }());
+ exports.CatchClause = CatchClause;
+ var ClassBody = (function () {
+ function ClassBody(body) {
+ this.type = syntax_1.Syntax.ClassBody;
+ this.body = body;
+ }
+ return ClassBody;
+ }());
+ exports.ClassBody = ClassBody;
+ var ClassDeclaration = (function () {
+ function ClassDeclaration(id, superClass, body) {
+ this.type = syntax_1.Syntax.ClassDeclaration;
+ this.id = id;
+ this.superClass = superClass;
+ this.body = body;
+ }
+ return ClassDeclaration;
+ }());
+ exports.ClassDeclaration = ClassDeclaration;
+ var ClassExpression = (function () {
+ function ClassExpression(id, superClass, body) {
+ this.type = syntax_1.Syntax.ClassExpression;
+ this.id = id;
+ this.superClass = superClass;
+ this.body = body;
+ }
+ return ClassExpression;
+ }());
+ exports.ClassExpression = ClassExpression;
+ var ComputedMemberExpression = (function () {
+ function ComputedMemberExpression(object, property) {
+ this.type = syntax_1.Syntax.MemberExpression;
+ this.computed = true;
+ this.object = object;
+ this.property = property;
+ }
+ return ComputedMemberExpression;
+ }());
+ exports.ComputedMemberExpression = ComputedMemberExpression;
+ var ConditionalExpression = (function () {
+ function ConditionalExpression(test, consequent, alternate) {
+ this.type = syntax_1.Syntax.ConditionalExpression;
+ this.test = test;
+ this.consequent = consequent;
+ this.alternate = alternate;
+ }
+ return ConditionalExpression;
+ }());
+ exports.ConditionalExpression = ConditionalExpression;
+ var ContinueStatement = (function () {
+ function ContinueStatement(label) {
+ this.type = syntax_1.Syntax.ContinueStatement;
+ this.label = label;
+ }
+ return ContinueStatement;
+ }());
+ exports.ContinueStatement = ContinueStatement;
+ var DebuggerStatement = (function () {
+ function DebuggerStatement() {
+ this.type = syntax_1.Syntax.DebuggerStatement;
+ }
+ return DebuggerStatement;
+ }());
+ exports.DebuggerStatement = DebuggerStatement;
+ var Directive = (function () {
+ function Directive(expression, directive) {
+ this.type = syntax_1.Syntax.ExpressionStatement;
+ this.expression = expression;
+ this.directive = directive;
+ }
+ return Directive;
+ }());
+ exports.Directive = Directive;
+ var DoWhileStatement = (function () {
+ function DoWhileStatement(body, test) {
+ this.type = syntax_1.Syntax.DoWhileStatement;
+ this.body = body;
+ this.test = test;
+ }
+ return DoWhileStatement;
+ }());
+ exports.DoWhileStatement = DoWhileStatement;
+ var EmptyStatement = (function () {
+ function EmptyStatement() {
+ this.type = syntax_1.Syntax.EmptyStatement;
+ }
+ return EmptyStatement;
+ }());
+ exports.EmptyStatement = EmptyStatement;
+ var ExportAllDeclaration = (function () {
+ function ExportAllDeclaration(source) {
+ this.type = syntax_1.Syntax.ExportAllDeclaration;
+ this.source = source;
+ }
+ return ExportAllDeclaration;
+ }());
+ exports.ExportAllDeclaration = ExportAllDeclaration;
+ var ExportDefaultDeclaration = (function () {
+ function ExportDefaultDeclaration(declaration) {
+ this.type = syntax_1.Syntax.ExportDefaultDeclaration;
+ this.declaration = declaration;
+ }
+ return ExportDefaultDeclaration;
+ }());
+ exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
+ var ExportNamedDeclaration = (function () {
+ function ExportNamedDeclaration(declaration, specifiers, source) {
+ this.type = syntax_1.Syntax.ExportNamedDeclaration;
+ this.declaration = declaration;
+ this.specifiers = specifiers;
+ this.source = source;
+ }
+ return ExportNamedDeclaration;
+ }());
+ exports.ExportNamedDeclaration = ExportNamedDeclaration;
+ var ExportSpecifier = (function () {
+ function ExportSpecifier(local, exported) {
+ this.type = syntax_1.Syntax.ExportSpecifier;
+ this.exported = exported;
+ this.local = local;
+ }
+ return ExportSpecifier;
+ }());
+ exports.ExportSpecifier = ExportSpecifier;
+ var ExpressionStatement = (function () {
+ function ExpressionStatement(expression) {
+ this.type = syntax_1.Syntax.ExpressionStatement;
+ this.expression = expression;
+ }
+ return ExpressionStatement;
+ }());
+ exports.ExpressionStatement = ExpressionStatement;
+ var ForInStatement = (function () {
+ function ForInStatement(left, right, body) {
+ this.type = syntax_1.Syntax.ForInStatement;
+ this.left = left;
+ this.right = right;
+ this.body = body;
+ this.each = false;
+ }
+ return ForInStatement;
+ }());
+ exports.ForInStatement = ForInStatement;
+ var ForOfStatement = (function () {
+ function ForOfStatement(left, right, body) {
+ this.type = syntax_1.Syntax.ForOfStatement;
+ this.left = left;
+ this.right = right;
+ this.body = body;
+ }
+ return ForOfStatement;
+ }());
+ exports.ForOfStatement = ForOfStatement;
+ var ForStatement = (function () {
+ function ForStatement(init, test, update, body) {
+ this.type = syntax_1.Syntax.ForStatement;
+ this.init = init;
+ this.test = test;
+ this.update = update;
+ this.body = body;
+ }
+ return ForStatement;
+ }());
+ exports.ForStatement = ForStatement;
+ var FunctionDeclaration = (function () {
+ function FunctionDeclaration(id, params, body, generator) {
+ this.type = syntax_1.Syntax.FunctionDeclaration;
+ this.id = id;
+ this.params = params;
+ this.body = body;
+ this.generator = generator;
+ this.expression = false;
+ this.async = false;
+ }
+ return FunctionDeclaration;
+ }());
+ exports.FunctionDeclaration = FunctionDeclaration;
+ var FunctionExpression = (function () {
+ function FunctionExpression(id, params, body, generator) {
+ this.type = syntax_1.Syntax.FunctionExpression;
+ this.id = id;
+ this.params = params;
+ this.body = body;
+ this.generator = generator;
+ this.expression = false;
+ this.async = false;
+ }
+ return FunctionExpression;
+ }());
+ exports.FunctionExpression = FunctionExpression;
+ var Identifier = (function () {
+ function Identifier(name) {
+ this.type = syntax_1.Syntax.Identifier;
+ this.name = name;
+ }
+ return Identifier;
+ }());
+ exports.Identifier = Identifier;
+ var IfStatement = (function () {
+ function IfStatement(test, consequent, alternate) {
+ this.type = syntax_1.Syntax.IfStatement;
+ this.test = test;
+ this.consequent = consequent;
+ this.alternate = alternate;
+ }
+ 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;
+ this.specifiers = specifiers;
+ this.source = source;
+ }
+ return ImportDeclaration;
+ }());
+ exports.ImportDeclaration = ImportDeclaration;
+ var ImportDefaultSpecifier = (function () {
+ function ImportDefaultSpecifier(local) {
+ this.type = syntax_1.Syntax.ImportDefaultSpecifier;
+ this.local = local;
+ }
+ return ImportDefaultSpecifier;
+ }());
+ exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
+ var ImportNamespaceSpecifier = (function () {
+ function ImportNamespaceSpecifier(local) {
+ this.type = syntax_1.Syntax.ImportNamespaceSpecifier;
+ this.local = local;
+ }
+ return ImportNamespaceSpecifier;
+ }());
+ exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
+ var ImportSpecifier = (function () {
+ function ImportSpecifier(local, imported) {
+ this.type = syntax_1.Syntax.ImportSpecifier;
+ this.local = local;
+ this.imported = imported;
+ }
+ return ImportSpecifier;
+ }());
+ exports.ImportSpecifier = ImportSpecifier;
+ var LabeledStatement = (function () {
+ function LabeledStatement(label, body) {
+ this.type = syntax_1.Syntax.LabeledStatement;
+ this.label = label;
+ this.body = body;
+ }
+ return LabeledStatement;
+ }());
+ exports.LabeledStatement = LabeledStatement;
+ var Literal = (function () {
+ function Literal(value, raw) {
+ this.type = syntax_1.Syntax.Literal;
+ this.value = value;
+ this.raw = raw;
+ }
+ return Literal;
+ }());
+ exports.Literal = Literal;
+ var MetaProperty = (function () {
+ function MetaProperty(meta, property) {
+ this.type = syntax_1.Syntax.MetaProperty;
+ this.meta = meta;
+ this.property = property;
+ }
+ return MetaProperty;
+ }());
+ exports.MetaProperty = MetaProperty;
+ var MethodDefinition = (function () {
+ function MethodDefinition(key, computed, value, kind, isStatic) {
+ this.type = syntax_1.Syntax.MethodDefinition;
+ this.key = key;
+ this.computed = computed;
+ this.value = value;
+ this.kind = kind;
+ this.static = isStatic;
+ }
+ return MethodDefinition;
+ }());
+ exports.MethodDefinition = MethodDefinition;
+ var Module = (function () {
+ function Module(body) {
+ this.type = syntax_1.Syntax.Program;
+ this.body = body;
+ this.sourceType = 'module';
+ }
+ return Module;
+ }());
+ exports.Module = Module;
+ var NewExpression = (function () {
+ function NewExpression(callee, args) {
+ this.type = syntax_1.Syntax.NewExpression;
+ this.callee = callee;
+ this.arguments = args;
+ }
+ return NewExpression;
+ }());
+ exports.NewExpression = NewExpression;
+ var ObjectExpression = (function () {
+ function ObjectExpression(properties) {
+ this.type = syntax_1.Syntax.ObjectExpression;
+ this.properties = properties;
+ }
+ return ObjectExpression;
+ }());
+ exports.ObjectExpression = ObjectExpression;
+ var ObjectPattern = (function () {
+ function ObjectPattern(properties) {
+ this.type = syntax_1.Syntax.ObjectPattern;
+ this.properties = properties;
+ }
+ return ObjectPattern;
+ }());
+ exports.ObjectPattern = ObjectPattern;
+ var Property = (function () {
+ function Property(kind, key, computed, value, method, shorthand) {
+ this.type = syntax_1.Syntax.Property;
+ this.key = key;
+ this.computed = computed;
+ this.value = value;
+ this.kind = kind;
+ this.method = method;
+ this.shorthand = shorthand;
+ }
+ return Property;
+ }());
+ exports.Property = Property;
+ var RegexLiteral = (function () {
+ function RegexLiteral(value, raw, pattern, flags) {
+ this.type = syntax_1.Syntax.Literal;
+ this.value = value;
+ this.raw = raw;
+ this.regex = { pattern: pattern, flags: flags };
+ }
+ return RegexLiteral;
+ }());
+ exports.RegexLiteral = RegexLiteral;
+ var RestElement = (function () {
+ function RestElement(argument) {
+ this.type = syntax_1.Syntax.RestElement;
+ this.argument = argument;
+ }
+ 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;
+ this.argument = argument;
+ }
+ return ReturnStatement;
+ }());
+ exports.ReturnStatement = ReturnStatement;
+ var Script = (function () {
+ function Script(body) {
+ this.type = syntax_1.Syntax.Program;
+ this.body = body;
+ this.sourceType = 'script';
+ }
+ return Script;
+ }());
+ exports.Script = Script;
+ var SequenceExpression = (function () {
+ function SequenceExpression(expressions) {
+ this.type = syntax_1.Syntax.SequenceExpression;
+ this.expressions = expressions;
+ }
+ return SequenceExpression;
+ }());
+ exports.SequenceExpression = SequenceExpression;
+ var SpreadElement = (function () {
+ function SpreadElement(argument) {
+ this.type = syntax_1.Syntax.SpreadElement;
+ this.argument = argument;
+ }
+ 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;
+ this.computed = false;
+ this.object = object;
+ this.property = property;
+ }
+ return StaticMemberExpression;
+ }());
+ exports.StaticMemberExpression = StaticMemberExpression;
+ var Super = (function () {
+ function Super() {
+ this.type = syntax_1.Syntax.Super;
+ }
+ return Super;
+ }());
+ exports.Super = Super;
+ var SwitchCase = (function () {
+ function SwitchCase(test, consequent) {
+ this.type = syntax_1.Syntax.SwitchCase;
+ this.test = test;
+ this.consequent = consequent;
+ }
+ return SwitchCase;
+ }());
+ exports.SwitchCase = SwitchCase;
+ var SwitchStatement = (function () {
+ function SwitchStatement(discriminant, cases) {
+ this.type = syntax_1.Syntax.SwitchStatement;
+ this.discriminant = discriminant;
+ this.cases = cases;
+ }
+ return SwitchStatement;
+ }());
+ exports.SwitchStatement = SwitchStatement;
+ var TaggedTemplateExpression = (function () {
+ function TaggedTemplateExpression(tag, quasi) {
+ this.type = syntax_1.Syntax.TaggedTemplateExpression;
+ this.tag = tag;
+ this.quasi = quasi;
+ }
+ return TaggedTemplateExpression;
+ }());
+ exports.TaggedTemplateExpression = TaggedTemplateExpression;
+ var TemplateElement = (function () {
+ function TemplateElement(value, tail) {
+ this.type = syntax_1.Syntax.TemplateElement;
+ this.value = value;
+ this.tail = tail;
+ }
+ return TemplateElement;
+ }());
+ exports.TemplateElement = TemplateElement;
+ var TemplateLiteral = (function () {
+ function TemplateLiteral(quasis, expressions) {
+ this.type = syntax_1.Syntax.TemplateLiteral;
+ this.quasis = quasis;
+ this.expressions = expressions;
+ }
+ return TemplateLiteral;
+ }());
+ exports.TemplateLiteral = TemplateLiteral;
+ var ThisExpression = (function () {
+ function ThisExpression() {
+ this.type = syntax_1.Syntax.ThisExpression;
+ }
+ return ThisExpression;
+ }());
+ exports.ThisExpression = ThisExpression;
+ var ThrowStatement = (function () {
+ function ThrowStatement(argument) {
+ this.type = syntax_1.Syntax.ThrowStatement;
+ this.argument = argument;
+ }
+ return ThrowStatement;
+ }());
+ exports.ThrowStatement = ThrowStatement;
+ var TryStatement = (function () {
+ function TryStatement(block, handler, finalizer) {
+ this.type = syntax_1.Syntax.TryStatement;
+ this.block = block;
+ this.handler = handler;
+ this.finalizer = finalizer;
+ }
+ return TryStatement;
+ }());
+ exports.TryStatement = TryStatement;
+ var UnaryExpression = (function () {
+ function UnaryExpression(operator, argument) {
+ this.type = syntax_1.Syntax.UnaryExpression;
+ this.operator = operator;
+ this.argument = argument;
+ this.prefix = true;
+ }
+ return UnaryExpression;
+ }());
+ exports.UnaryExpression = UnaryExpression;
+ var UpdateExpression = (function () {
+ function UpdateExpression(operator, argument, prefix) {
+ this.type = syntax_1.Syntax.UpdateExpression;
+ this.operator = operator;
+ this.argument = argument;
+ this.prefix = prefix;
+ }
+ return UpdateExpression;
+ }());
+ exports.UpdateExpression = UpdateExpression;
+ var VariableDeclaration = (function () {
+ function VariableDeclaration(declarations, kind) {
+ this.type = syntax_1.Syntax.VariableDeclaration;
+ this.declarations = declarations;
+ this.kind = kind;
+ }
+ return VariableDeclaration;
+ }());
+ exports.VariableDeclaration = VariableDeclaration;
+ var VariableDeclarator = (function () {
+ function VariableDeclarator(id, init) {
+ this.type = syntax_1.Syntax.VariableDeclarator;
+ this.id = id;
+ this.init = init;
+ }
+ return VariableDeclarator;
+ }());
+ exports.VariableDeclarator = VariableDeclarator;
+ var WhileStatement = (function () {
+ function WhileStatement(test, body) {
+ this.type = syntax_1.Syntax.WhileStatement;
+ this.test = test;
+ this.body = body;
+ }
+ return WhileStatement;
+ }());
+ 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);
</ins><span class="cx"> var ArrowParameterPlaceHolder = 'ArrowParameterPlaceHolder';
</span><span class="cx"> var Parser = (function () {
</span><span class="cx"> function Parser(code, options, delegate) {
</span><span class="lines">@@ -464,12 +1887,20 @@
</span><span class="cx"> '/': 11,
</span><span class="cx"> '%': 11
</span><span class="cx"> };
</span><del>- this.lookahead = null;
</del><ins>+ this.lookahead = {
+ type: 2 /* EOF */,
+ value: '',
+ lineNumber: this.scanner.lineNumber,
+ lineStart: 0,
+ start: 0,
+ end: 0
+ };
</ins><span class="cx"> this.hasLineTerminator = false;
</span><span class="cx"> this.context = {
</span><span class="cx"> isModule: false,
</span><span class="cx"> await: false,
</span><span class="cx"> allowIn: true,
</span><ins>+ allowStrictDirective: true,
</ins><span class="cx"> allowYield: true,
</span><span class="cx"> firstCoverInitializedNameError: null,
</span><span class="cx"> isAssignmentTarget: false,
</span><span class="lines">@@ -483,19 +1914,19 @@
</span><span class="cx"> this.tokens = [];
</span><span class="cx"> this.startMarker = {
</span><span class="cx"> index: 0,
</span><del>- lineNumber: this.scanner.lineNumber,
- lineStart: 0
</del><ins>+ line: this.scanner.lineNumber,
+ column: 0
</ins><span class="cx"> };
</span><span class="cx"> this.lastMarker = {
</span><span class="cx"> index: 0,
</span><del>- lineNumber: this.scanner.lineNumber,
- lineStart: 0
</del><ins>+ line: this.scanner.lineNumber,
+ column: 0
</ins><span class="cx"> };
</span><span class="cx"> this.nextToken();
</span><span class="cx"> this.lastMarker = {
</span><span class="cx"> index: this.scanner.index,
</span><del>- lineNumber: this.scanner.lineNumber,
- lineStart: this.scanner.lineStart
</del><ins>+ line: this.scanner.lineNumber,
+ column: this.scanner.index - this.scanner.lineStart
</ins><span class="cx"> };
</span><span class="cx"> }
</span><span class="cx"> Parser.prototype.throwError = function (messageFormat) {
</span><span class="lines">@@ -509,8 +1940,8 @@
</span><span class="cx"> return args[idx];
</span><span class="cx"> });
</span><span class="cx"> var index = this.lastMarker.index;
</span><del>- var line = this.lastMarker.lineNumber;
- var column = this.lastMarker.index - this.lastMarker.lineStart + 1;
</del><ins>+ var line = this.lastMarker.line;
+ var column = this.lastMarker.column + 1;
</ins><span class="cx"> throw this.errorHandler.createError(index, line, column, msg);
</span><span class="cx"> };
</span><span class="cx"> Parser.prototype.tolerateError = function (messageFormat) {
</span><span class="lines">@@ -525,7 +1956,7 @@
</span><span class="cx"> });
</span><span class="cx"> var index = this.lastMarker.index;
</span><span class="cx"> var line = this.scanner.lineNumber;
</span><del>- var column = this.lastMarker.index - this.lastMarker.lineStart + 1;
</del><ins>+ var column = this.lastMarker.column + 1;
</ins><span class="cx"> this.errorHandler.tolerateError(index, line, column, msg);
</span><span class="cx"> };
</span><span class="cx"> // Throw an exception because of the token.
</span><span class="lines">@@ -534,13 +1965,13 @@
</span><span class="cx"> var value;
</span><span class="cx"> if (token) {
</span><span class="cx"> if (!message) {
</span><del>- 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 :
</del><ins>+ 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 :
</ins><span class="cx"> messages_1.Messages.UnexpectedToken;
</span><del>- if (token.type === token_1.Token.Keyword) {
</del><ins>+ if (token.type === 4 /* Keyword */) {
</ins><span class="cx"> if (this.scanner.isFutureReservedWord(token.value)) {
</span><span class="cx"> msg = messages_1.Messages.UnexpectedReserved;
</span><span class="cx"> }
</span><span class="lines">@@ -549,7 +1980,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- value = (token.type === token_1.Token.Template) ? token.value.raw : token.value;
</del><ins>+ value = token.value;
</ins><span class="cx"> }
</span><span class="cx"> else {
</span><span class="cx"> value = 'ILLEGAL';
</span><span class="lines">@@ -558,13 +1989,14 @@
</span><span class="cx"> if (token && typeof token.lineNumber === 'number') {
</span><span class="cx"> var index = token.start;
</span><span class="cx"> var line = token.lineNumber;
</span><del>- var column = token.start - this.lastMarker.lineStart + 1;
</del><ins>+ var lastMarkerLineStart = this.lastMarker.index - this.lastMarker.column;
+ var column = token.start - lastMarkerLineStart + 1;
</ins><span class="cx"> return this.errorHandler.createError(index, line, column, msg);
</span><span class="cx"> }
</span><span class="cx"> else {
</span><span class="cx"> var index = this.lastMarker.index;
</span><del>- var line = this.lastMarker.lineNumber;
- var column = index - this.lastMarker.lineStart + 1;
</del><ins>+ var line = this.lastMarker.line;
+ var column = this.lastMarker.column + 1;
</ins><span class="cx"> return this.errorHandler.createError(index, line, column, msg);
</span><span class="cx"> }
</span><span class="cx"> };
</span><span class="lines">@@ -616,8 +2048,7 @@
</span><span class="cx"> return this.scanner.source.slice(token.start, token.end);
</span><span class="cx"> };
</span><span class="cx"> Parser.prototype.convertToken = function (token) {
</span><del>- var t;
- t = {
</del><ins>+ var t = {
</ins><span class="cx"> type: token_1.TokenName[token.type],
</span><span class="cx"> value: this.getTokenRaw(token)
</span><span class="cx"> };
</span><span class="lines">@@ -627,8 +2058,8 @@
</span><span class="cx"> if (this.config.loc) {
</span><span class="cx"> t.loc = {
</span><span class="cx"> start: {
</span><del>- line: this.startMarker.lineNumber,
- column: this.startMarker.index - this.startMarker.lineStart
</del><ins>+ line: this.startMarker.line,
+ column: this.startMarker.column
</ins><span class="cx"> },
</span><span class="cx"> end: {
</span><span class="cx"> line: this.scanner.lineNumber,
</span><span class="lines">@@ -636,8 +2067,10 @@
</span><span class="cx"> }
</span><span class="cx"> };
</span><span class="cx"> }
</span><del>- if (token.regex) {
- t.regex = token.regex;
</del><ins>+ if (token.type === 9 /* RegularExpression */) {
+ var pattern = token.pattern;
+ var flags = token.flags;
+ t.regex = { pattern: pattern, flags: flags };
</ins><span class="cx"> }
</span><span class="cx"> return t;
</span><span class="cx"> };
</span><span class="lines">@@ -644,22 +2077,23 @@
</span><span class="cx"> Parser.prototype.nextToken = function () {
</span><span class="cx"> var token = this.lookahead;
</span><span class="cx"> this.lastMarker.index = this.scanner.index;
</span><del>- this.lastMarker.lineNumber = this.scanner.lineNumber;
- this.lastMarker.lineStart = this.scanner.lineStart;
</del><ins>+ this.lastMarker.line = this.scanner.lineNumber;
+ this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
</ins><span class="cx"> this.collectComments();
</span><del>- 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) {
</del><ins>+ 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 */) {
</ins><span class="cx"> if (this.scanner.isStrictModeReservedWord(next.value)) {
</span><del>- next.type = token_1.Token.Keyword;
</del><ins>+ next.type = 4 /* Keyword */;
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> this.lookahead = next;
</span><del>- if (this.config.tokens && next.type !== token_1.Token.EOF) {
</del><ins>+ if (this.config.tokens && next.type !== 2 /* EOF */) {
</ins><span class="cx"> this.tokens.push(this.convertToken(next));
</span><span class="cx"> }
</span><span class="cx"> return token;
</span><span class="lines">@@ -681,8 +2115,8 @@
</span><span class="cx"> Parser.prototype.createNode = function () {
</span><span class="cx"> return {
</span><span class="cx"> index: this.startMarker.index,
</span><del>- line: this.startMarker.lineNumber,
- column: this.startMarker.index - this.startMarker.lineStart
</del><ins>+ line: this.startMarker.line,
+ column: this.startMarker.column
</ins><span class="cx"> };
</span><span class="cx"> };
</span><span class="cx"> Parser.prototype.startNode = function (token) {
</span><span class="lines">@@ -692,19 +2126,19 @@
</span><span class="cx"> column: token.start - token.lineStart
</span><span class="cx"> };
</span><span class="cx"> };
</span><del>- Parser.prototype.finalize = function (meta, node) {
</del><ins>+ Parser.prototype.finalize = function (marker, node) {
</ins><span class="cx"> if (this.config.range) {
</span><del>- node.range = [meta.index, this.lastMarker.index];
</del><ins>+ node.range = [marker.index, this.lastMarker.index];
</ins><span class="cx"> }
</span><span class="cx"> if (this.config.loc) {
</span><span class="cx"> node.loc = {
</span><span class="cx"> start: {
</span><del>- line: meta.line,
- column: meta.column
</del><ins>+ line: marker.line,
+ column: marker.column,
</ins><span class="cx"> },
</span><span class="cx"> end: {
</span><del>- line: this.lastMarker.lineNumber,
- column: this.lastMarker.index - this.lastMarker.lineStart
</del><ins>+ line: this.lastMarker.line,
+ column: this.lastMarker.column
</ins><span class="cx"> }
</span><span class="cx"> };
</span><span class="cx"> if (this.config.source) {
</span><span class="lines">@@ -714,13 +2148,13 @@
</span><span class="cx"> if (this.delegate) {
</span><span class="cx"> var metadata = {
</span><span class="cx"> start: {
</span><del>- line: meta.line,
- column: meta.column,
- offset: meta.index
</del><ins>+ line: marker.line,
+ column: marker.column,
+ offset: marker.index
</ins><span class="cx"> },
</span><span class="cx"> end: {
</span><del>- line: this.lastMarker.lineNumber,
- column: this.lastMarker.index - this.lastMarker.lineStart,
</del><ins>+ line: this.lastMarker.line,
+ column: this.lastMarker.column,
</ins><span class="cx"> offset: this.lastMarker.index
</span><span class="cx"> }
</span><span class="cx"> };
</span><span class="lines">@@ -732,7 +2166,7 @@
</span><span class="cx"> // If not, an exception will be thrown.
</span><span class="cx"> Parser.prototype.expect = function (value) {
</span><span class="cx"> var token = this.nextToken();
</span><del>- if (token.type !== token_1.Token.Punctuator || token.value !== value) {
</del><ins>+ if (token.type !== 7 /* Punctuator */ || token.value !== value) {
</ins><span class="cx"> this.throwUnexpectedToken(token);
</span><span class="cx"> }
</span><span class="cx"> };
</span><span class="lines">@@ -740,10 +2174,10 @@
</span><span class="cx"> Parser.prototype.expectCommaSeparator = function () {
</span><span class="cx"> if (this.config.tolerant) {
</span><span class="cx"> var token = this.lookahead;
</span><del>- if (token.type === token_1.Token.Punctuator && token.value === ',') {
</del><ins>+ if (token.type === 7 /* Punctuator */ && token.value === ',') {
</ins><span class="cx"> this.nextToken();
</span><span class="cx"> }
</span><del>- else if (token.type === token_1.Token.Punctuator && token.value === ';') {
</del><ins>+ else if (token.type === 7 /* Punctuator */ && token.value === ';') {
</ins><span class="cx"> this.nextToken();
</span><span class="cx"> this.tolerateUnexpectedToken(token);
</span><span class="cx"> }
</span><span class="lines">@@ -759,26 +2193,26 @@
</span><span class="cx"> // If not, an exception will be thrown.
</span><span class="cx"> Parser.prototype.expectKeyword = function (keyword) {
</span><span class="cx"> var token = this.nextToken();
</span><del>- if (token.type !== token_1.Token.Keyword || token.value !== keyword) {
</del><ins>+ if (token.type !== 4 /* Keyword */ || token.value !== keyword) {
</ins><span class="cx"> this.throwUnexpectedToken(token);
</span><span class="cx"> }
</span><span class="cx"> };
</span><span class="cx"> // Return true if the next token matches the specified punctuator.
</span><span class="cx"> Parser.prototype.match = function (value) {
</span><del>- return this.lookahead.type === token_1.Token.Punctuator && this.lookahead.value === value;
</del><ins>+ return this.lookahead.type === 7 /* Punctuator */ && this.lookahead.value === value;
</ins><span class="cx"> };
</span><span class="cx"> // Return true if the next token matches the specified keyword
</span><span class="cx"> Parser.prototype.matchKeyword = function (keyword) {
</span><del>- return this.lookahead.type === token_1.Token.Keyword && this.lookahead.value === keyword;
</del><ins>+ return this.lookahead.type === 4 /* Keyword */ && this.lookahead.value === keyword;
</ins><span class="cx"> };
</span><span class="cx"> // Return true if the next token matches the specified contextual keyword
</span><span class="cx"> // (where an identifier is sometimes a keyword depending on the context)
</span><span class="cx"> Parser.prototype.matchContextualKeyword = function (keyword) {
</span><del>- return this.lookahead.type === token_1.Token.Identifier && this.lookahead.value === keyword;
</del><ins>+ return this.lookahead.type === 3 /* Identifier */ && this.lookahead.value === keyword;
</ins><span class="cx"> };
</span><span class="cx"> // Return true if the next token is an assignment operator
</span><span class="cx"> Parser.prototype.matchAssign = function () {
</span><del>- if (this.lookahead.type !== token_1.Token.Punctuator) {
</del><ins>+ if (this.lookahead.type !== 7 /* Punctuator */) {
</ins><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx"> var op = this.lookahead.value;
</span><span class="lines">@@ -861,28 +2295,28 @@
</span><span class="cx"> this.nextToken();
</span><span class="cx"> }
</span><span class="cx"> else if (!this.hasLineTerminator) {
</span><del>- if (this.lookahead.type !== token_1.Token.EOF && !this.match('}')) {
</del><ins>+ if (this.lookahead.type !== 2 /* EOF */ && !this.match('}')) {
</ins><span class="cx"> this.throwUnexpectedToken(this.lookahead);
</span><span class="cx"> }
</span><span class="cx"> this.lastMarker.index = this.startMarker.index;
</span><del>- this.lastMarker.lineNumber = this.startMarker.lineNumber;
- this.lastMarker.lineStart = this.startMarker.lineStart;
</del><ins>+ this.lastMarker.line = this.startMarker.line;
+ this.lastMarker.column = this.startMarker.column;
</ins><span class="cx"> }
</span><span class="cx"> };
</span><del>- // ECMA-262 12.2 Primary Expressions
</del><ins>+ // https://tc39.github.io/ecma262/#sec-primary-expression
</ins><span class="cx"> Parser.prototype.parsePrimaryExpression = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var expr;
</span><del>- var value, token, raw;
</del><ins>+ var token, raw;
</ins><span class="cx"> switch (this.lookahead.type) {
</span><del>- case token_1.Token.Identifier:
</del><ins>+ case 3 /* Identifier */:
</ins><span class="cx"> if ((this.context.isModule || this.context.await) && this.lookahead.value === 'await') {
</span><span class="cx"> this.tolerateUnexpectedToken(this.lookahead);
</span><span class="cx"> }
</span><span class="cx"> expr = this.matchAsyncFunction() ? this.parseFunctionExpression() : this.finalize(node, new Node.Identifier(this.nextToken().value));
</span><span class="cx"> break;
</span><del>- case token_1.Token.NumericLiteral:
- case token_1.Token.StringLiteral:
</del><ins>+ case 6 /* NumericLiteral */:
+ case 8 /* StringLiteral */:
</ins><span class="cx"> if (this.context.strict && this.lookahead.octal) {
</span><span class="cx"> this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.StrictOctalLiteral);
</span><span class="cx"> }
</span><span class="lines">@@ -892,28 +2326,25 @@
</span><span class="cx"> raw = this.getTokenRaw(token);
</span><span class="cx"> expr = this.finalize(node, new Node.Literal(token.value, raw));
</span><span class="cx"> break;
</span><del>- case token_1.Token.BooleanLiteral:
</del><ins>+ case 1 /* BooleanLiteral */:
</ins><span class="cx"> this.context.isAssignmentTarget = false;
</span><span class="cx"> this.context.isBindingElement = false;
</span><span class="cx"> token = this.nextToken();
</span><del>- token.value = (token.value === 'true');
</del><span class="cx"> raw = this.getTokenRaw(token);
</span><del>- expr = this.finalize(node, new Node.Literal(token.value, raw));
</del><ins>+ expr = this.finalize(node, new Node.Literal(token.value === 'true', raw));
</ins><span class="cx"> break;
</span><del>- case token_1.Token.NullLiteral:
</del><ins>+ case 5 /* NullLiteral */:
</ins><span class="cx"> this.context.isAssignmentTarget = false;
</span><span class="cx"> this.context.isBindingElement = false;
</span><span class="cx"> token = this.nextToken();
</span><del>- token.value = null;
</del><span class="cx"> raw = this.getTokenRaw(token);
</span><del>- expr = this.finalize(node, new Node.Literal(token.value, raw));
</del><ins>+ expr = this.finalize(node, new Node.Literal(null, raw));
</ins><span class="cx"> break;
</span><del>- case token_1.Token.Template:
</del><ins>+ case 10 /* Template */:
</ins><span class="cx"> expr = this.parseTemplateLiteral();
</span><span class="cx"> break;
</span><del>- case token_1.Token.Punctuator:
- value = this.lookahead.value;
- switch (value) {
</del><ins>+ case 7 /* Punctuator */:
+ switch (this.lookahead.value) {
</ins><span class="cx"> case '(':
</span><span class="cx"> this.context.isBindingElement = false;
</span><span class="cx"> expr = this.inheritCoverGrammar(this.parseGroupExpression);
</span><span class="lines">@@ -931,13 +2362,13 @@
</span><span class="cx"> this.scanner.index = this.startMarker.index;
</span><span class="cx"> token = this.nextRegexToken();
</span><span class="cx"> raw = this.getTokenRaw(token);
</span><del>- expr = this.finalize(node, new Node.RegexLiteral(token.value, raw, token.regex));
</del><ins>+ expr = this.finalize(node, new Node.RegexLiteral(token.regex, raw, token.pattern, token.flags));
</ins><span class="cx"> break;
</span><span class="cx"> default:
</span><span class="cx"> expr = this.throwUnexpectedToken(this.nextToken());
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case token_1.Token.Keyword:
</del><ins>+ case 4 /* Keyword */:
</ins><span class="cx"> if (!this.context.strict && this.context.allowYield && this.matchKeyword('yield')) {
</span><span class="cx"> expr = this.parseIdentifierName();
</span><span class="cx"> }
</span><span class="lines">@@ -957,6 +2388,9 @@
</span><span class="cx"> else if (this.matchKeyword('class')) {
</span><span class="cx"> expr = this.parseClassExpression();
</span><span class="cx"> }
</span><ins>+ else if (this.matchImportCall()) {
+ expr = this.parseImportCall();
+ }
</ins><span class="cx"> else {
</span><span class="cx"> expr = this.throwUnexpectedToken(this.nextToken());
</span><span class="cx"> }
</span><span class="lines">@@ -967,7 +2401,7 @@
</span><span class="cx"> }
</span><span class="cx"> return expr;
</span><span class="cx"> };
</span><del>- // ECMA-262 12.2.5 Array Initializer
</del><ins>+ // https://tc39.github.io/ecma262/#sec-array-initializer
</ins><span class="cx"> Parser.prototype.parseSpreadElement = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> this.expect('...');
</span><span class="lines">@@ -1002,11 +2436,13 @@
</span><span class="cx"> this.expect(']');
</span><span class="cx"> return this.finalize(node, new Node.ArrayExpression(elements));
</span><span class="cx"> };
</span><del>- // ECMA-262 12.2.6 Object Initializer
</del><ins>+ // https://tc39.github.io/ecma262/#sec-object-initializer
</ins><span class="cx"> Parser.prototype.parsePropertyMethod = function (params) {
</span><span class="cx"> this.context.isAssignmentTarget = false;
</span><span class="cx"> this.context.isBindingElement = false;
</span><span class="cx"> var previousStrict = this.context.strict;
</span><ins>+ var previousAllowStrictDirective = this.context.allowStrictDirective;
+ this.context.allowStrictDirective = params.simple;
</ins><span class="cx"> var body = this.isolateCoverGrammar(this.parseFunctionSourceElements);
</span><span class="cx"> if (this.context.strict && params.firstRestricted) {
</span><span class="cx"> this.tolerateUnexpectedToken(params.firstRestricted, params.message);
</span><span class="lines">@@ -1015,6 +2451,7 @@
</span><span class="cx"> this.tolerateUnexpectedToken(params.stricted, params.message);
</span><span class="cx"> }
</span><span class="cx"> this.context.strict = previousStrict;
</span><ins>+ this.context.allowStrictDirective = previousAllowStrictDirective;
</ins><span class="cx"> return body;
</span><span class="cx"> };
</span><span class="cx"> Parser.prototype.parsePropertyMethodFunction = function () {
</span><span class="lines">@@ -1044,8 +2481,8 @@
</span><span class="cx"> var token = this.nextToken();
</span><span class="cx"> var key;
</span><span class="cx"> switch (token.type) {
</span><del>- case token_1.Token.StringLiteral:
- case token_1.Token.NumericLiteral:
</del><ins>+ case 8 /* StringLiteral */:
+ case 6 /* NumericLiteral */:
</ins><span class="cx"> if (this.context.strict && token.octal) {
</span><span class="cx"> this.tolerateUnexpectedToken(token, messages_1.Messages.StrictOctalLiteral);
</span><span class="cx"> }
</span><span class="lines">@@ -1052,13 +2489,13 @@
</span><span class="cx"> var raw = this.getTokenRaw(token);
</span><span class="cx"> key = this.finalize(node, new Node.Literal(token.value, raw));
</span><span class="cx"> break;
</span><del>- case token_1.Token.Identifier:
- case token_1.Token.BooleanLiteral:
- case token_1.Token.NullLiteral:
- case token_1.Token.Keyword:
</del><ins>+ case 3 /* Identifier */:
+ case 1 /* BooleanLiteral */:
+ case 5 /* NullLiteral */:
+ case 4 /* Keyword */:
</ins><span class="cx"> key = this.finalize(node, new Node.Identifier(token.value));
</span><span class="cx"> break;
</span><del>- case token_1.Token.Punctuator:
</del><ins>+ case 7 /* Punctuator */:
</ins><span class="cx"> if (token.value === '[') {
</span><span class="cx"> key = this.isolateCoverGrammar(this.parseAssignmentExpression);
</span><span class="cx"> this.expect(']');
</span><span class="lines">@@ -1086,7 +2523,7 @@
</span><span class="cx"> var method = false;
</span><span class="cx"> var shorthand = false;
</span><span class="cx"> var isAsync = false;
</span><del>- if (token.type === token_1.Token.Identifier) {
</del><ins>+ if (token.type === 3 /* Identifier */) {
</ins><span class="cx"> var id = token.value;
</span><span class="cx"> this.nextToken();
</span><span class="cx"> if (id === 'async' && !this.hasLineTerminator) {
</span><span class="lines">@@ -1118,7 +2555,7 @@
</span><span class="cx"> key = this.parseObjectPropertyKey();
</span><span class="cx"> }
</span><span class="cx"> var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);
</span><del>- if (token.type === token_1.Token.Identifier && !isAsync && token.value === 'get' && lookaheadPropertyKey) {
</del><ins>+ if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'get' && lookaheadPropertyKey) {
</ins><span class="cx"> kind = 'get';
</span><span class="cx"> computed = this.match('[');
</span><span class="cx"> key = this.parseObjectPropertyKey();
</span><span class="lines">@@ -1125,13 +2562,13 @@
</span><span class="cx"> this.context.allowYield = false;
</span><span class="cx"> value = this.parseGetterMethod();
</span><span class="cx"> }
</span><del>- else if (token.type === token_1.Token.Identifier && !isAsync && token.value === 'set' && lookaheadPropertyKey) {
</del><ins>+ else if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'set' && lookaheadPropertyKey) {
</ins><span class="cx"> kind = 'set';
</span><span class="cx"> computed = this.match('[');
</span><span class="cx"> key = this.parseObjectPropertyKey();
</span><span class="cx"> value = this.parseSetterMethod();
</span><span class="cx"> }
</span><del>- else if (token.type === token_1.Token.Punctuator && token.value === '*' && lookaheadPropertyKey) {
</del><ins>+ else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) {
</ins><span class="cx"> kind = 'init';
</span><span class="cx"> computed = this.match('[');
</span><span class="cx"> key = this.parseObjectPropertyKey();
</span><span class="lines">@@ -1157,7 +2594,7 @@
</span><span class="cx"> value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();
</span><span class="cx"> method = true;
</span><span class="cx"> }
</span><del>- else if (token.type === token_1.Token.Identifier) {
</del><ins>+ else if (token.type === 3 /* Identifier */) {
</ins><span class="cx"> var id = this.finalize(node, new Node.Identifier(token.value));
</span><span class="cx"> if (this.match('=')) {
</span><span class="cx"> this.context.firstCoverInitializedNameError = this.lookahead;
</span><span class="lines">@@ -1175,8 +2612,14 @@
</span><span class="cx"> this.throwUnexpectedToken(this.nextToken());
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- return this.finalize(node, new Node.Property(kind, (key), computed, value, method, shorthand));
</del><ins>+ return this.finalize(node, new Node.Property(kind, key, computed, value, method, shorthand));
</ins><span class="cx"> };
</span><ins>+ Parser.prototype.parseSpreadProperty = function () {
+ var node = this.createNode();
+ this.expect('...');
+ var arg = this.inheritCoverGrammar(this.parseAssignmentExpression);
+ return this.finalize(node, new Node.SpreadProperty(arg));
+ };
</ins><span class="cx"> Parser.prototype.parseObjectInitializer = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> this.expect('{');
</span><span class="lines">@@ -1183,7 +2626,7 @@
</span><span class="cx"> var properties = [];
</span><span class="cx"> var hasProto = { value: false };
</span><span class="cx"> while (!this.match('}')) {
</span><del>- properties.push(this.parseObjectProperty(hasProto));
</del><ins>+ properties.push(this.match('...') ? this.parseSpreadProperty() : this.parseObjectProperty(hasProto));
</ins><span class="cx"> if (!this.match('}')) {
</span><span class="cx"> this.expectCommaSeparator();
</span><span class="cx"> }
</span><span class="lines">@@ -1191,28 +2634,24 @@
</span><span class="cx"> this.expect('}');
</span><span class="cx"> return this.finalize(node, new Node.ObjectExpression(properties));
</span><span class="cx"> };
</span><del>- // ECMA-262 12.2.9 Template Literals
</del><ins>+ // https://tc39.github.io/ecma262/#sec-template-literals
</ins><span class="cx"> Parser.prototype.parseTemplateHead = function () {
</span><span class="cx"> assert_1.assert(this.lookahead.head, 'Template literal must start with a template head');
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var token = this.nextToken();
</span><del>- var value = {
- raw: token.value.raw,
- cooked: token.value.cooked
- };
- return this.finalize(node, new Node.TemplateElement(value, token.tail));
</del><ins>+ var raw = token.value;
+ var cooked = token.cooked;
+ return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail));
</ins><span class="cx"> };
</span><span class="cx"> Parser.prototype.parseTemplateElement = function () {
</span><del>- if (this.lookahead.type !== token_1.Token.Template) {
</del><ins>+ if (this.lookahead.type !== 10 /* Template */) {
</ins><span class="cx"> this.throwUnexpectedToken();
</span><span class="cx"> }
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var token = this.nextToken();
</span><del>- var value = {
- raw: token.value.raw,
- cooked: token.value.cooked
- };
- return this.finalize(node, new Node.TemplateElement(value, token.tail));
</del><ins>+ var raw = token.value;
+ var cooked = token.cooked;
+ return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail));
</ins><span class="cx"> };
</span><span class="cx"> Parser.prototype.parseTemplateLiteral = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="lines">@@ -1227,7 +2666,7 @@
</span><span class="cx"> }
</span><span class="cx"> return this.finalize(node, new Node.TemplateLiteral(quasis, expressions));
</span><span class="cx"> };
</span><del>- // ECMA-262 12.2.10 The Grouping Operator
</del><ins>+ // https://tc39.github.io/ecma262/#sec-grouping-operator
</ins><span class="cx"> Parser.prototype.reinterpretExpressionAsPattern = function (expr) {
</span><span class="cx"> switch (expr.type) {
</span><span class="cx"> case syntax_1.Syntax.Identifier:
</span><span class="lines">@@ -1239,6 +2678,10 @@
</span><span class="cx"> expr.type = syntax_1.Syntax.RestElement;
</span><span class="cx"> this.reinterpretExpressionAsPattern(expr.argument);
</span><span class="cx"> break;
</span><ins>+ case syntax_1.Syntax.SpreadProperty:
+ expr.type = syntax_1.Syntax.RestProperty;
+ this.reinterpretExpressionAsPattern(expr.argument);
+ break;
</ins><span class="cx"> case syntax_1.Syntax.ArrayExpression:
</span><span class="cx"> expr.type = syntax_1.Syntax.ArrayPattern;
</span><span class="cx"> for (var i = 0; i < expr.elements.length; i++) {
</span><span class="lines">@@ -1250,7 +2693,8 @@
</span><span class="cx"> case syntax_1.Syntax.ObjectExpression:
</span><span class="cx"> expr.type = syntax_1.Syntax.ObjectPattern;
</span><span class="cx"> for (var i = 0; i < expr.properties.length; i++) {
</span><del>- this.reinterpretExpressionAsPattern(expr.properties[i].value);
</del><ins>+ var property = expr.properties[i];
+ this.reinterpretExpressionAsPattern(property.type === syntax_1.Syntax.SpreadProperty ? property : property.value);
</ins><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> case syntax_1.Syntax.AssignmentExpression:
</span><span class="lines">@@ -1300,7 +2744,7 @@
</span><span class="cx"> var expressions = [];
</span><span class="cx"> this.context.isAssignmentTarget = false;
</span><span class="cx"> expressions.push(expr);
</span><del>- while (this.startMarker.index < this.scanner.length) {
</del><ins>+ while (this.lookahead.type !== 2 /* EOF */) {
</ins><span class="cx"> if (!this.match(',')) {
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="lines">@@ -1385,7 +2829,7 @@
</span><span class="cx"> }
</span><span class="cx"> return expr;
</span><span class="cx"> };
</span><del>- // ECMA-262 12.3 Left-Hand-Side Expressions
</del><ins>+ // https://tc39.github.io/ecma262/#sec-left-hand-side-expressions
</ins><span class="cx"> Parser.prototype.parseArguments = function () {
</span><span class="cx"> this.expect('(');
</span><span class="cx"> var args = [];
</span><span class="lines">@@ -1407,10 +2851,10 @@
</span><span class="cx"> return args;
</span><span class="cx"> };
</span><span class="cx"> Parser.prototype.isIdentifierName = function (token) {
</span><del>- 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;
</del><ins>+ return token.type === 3 /* Identifier */ ||
+ token.type === 4 /* Keyword */ ||
+ token.type === 1 /* BooleanLiteral */ ||
+ token.type === 5 /* NullLiteral */;
</ins><span class="cx"> };
</span><span class="cx"> Parser.prototype.parseIdentifierName = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="lines">@@ -1427,7 +2871,7 @@
</span><span class="cx"> var expr;
</span><span class="cx"> if (this.match('.')) {
</span><span class="cx"> this.nextToken();
</span><del>- if (this.lookahead.type === token_1.Token.Identifier && this.context.inFunctionBody && this.lookahead.value === 'target') {
</del><ins>+ if (this.lookahead.type === 3 /* Identifier */ && this.context.inFunctionBody && this.lookahead.value === 'target') {
</ins><span class="cx"> var property = this.parseIdentifierName();
</span><span class="cx"> expr = new Node.MetaProperty(id, property);
</span><span class="cx"> }
</span><span class="lines">@@ -1435,6 +2879,9 @@
</span><span class="cx"> this.throwUnexpectedToken(this.lookahead);
</span><span class="cx"> }
</span><span class="cx"> }
</span><ins>+ else if (this.matchKeyword('import')) {
+ this.throwUnexpectedToken(this.lookahead);
+ }
</ins><span class="cx"> else {
</span><span class="cx"> var callee = this.isolateCoverGrammar(this.parseLeftHandSideExpression);
</span><span class="cx"> var args = this.match('(') ? this.parseArguments() : [];
</span><span class="lines">@@ -1469,6 +2916,22 @@
</span><span class="cx"> this.expect(')');
</span><span class="cx"> return args;
</span><span class="cx"> };
</span><ins>+ Parser.prototype.matchImportCall = function () {
+ var match = this.matchKeyword('import');
+ if (match) {
+ var state = this.scanner.saveState();
+ this.scanner.scanComments();
+ var next = this.scanner.lex();
+ this.scanner.restoreState(state);
+ match = (next.type === 7 /* Punctuator */) && (next.value === '(');
+ }
+ return match;
+ };
+ Parser.prototype.parseImportCall = function () {
+ var node = this.createNode();
+ this.expectKeyword('import');
+ return this.finalize(node, new Node.Import());
+ };
</ins><span class="cx"> Parser.prototype.parseLeftHandSideExpressionAllowCall = function () {
</span><span class="cx"> var startToken = this.lookahead;
</span><span class="cx"> var maybeAsync = this.matchContextualKeyword('async');
</span><span class="lines">@@ -1499,6 +2962,9 @@
</span><span class="cx"> this.context.isBindingElement = false;
</span><span class="cx"> this.context.isAssignmentTarget = false;
</span><span class="cx"> var args = asyncArrow ? this.parseAsyncArguments() : this.parseArguments();
</span><ins>+ if (expr.type === syntax_1.Syntax.Import && args.length !== 1) {
+ this.tolerateError(messages_1.Messages.BadImportCallArity);
+ }
</ins><span class="cx"> expr = this.finalize(this.startNode(startToken), new Node.CallExpression(expr, args));
</span><span class="cx"> if (asyncArrow && this.match('=>')) {
</span><span class="cx"> expr = {
</span><span class="lines">@@ -1516,7 +2982,7 @@
</span><span class="cx"> this.expect(']');
</span><span class="cx"> expr = this.finalize(this.startNode(startToken), new Node.ComputedMemberExpression(expr, property));
</span><span class="cx"> }
</span><del>- else if (this.lookahead.type === token_1.Token.Template && this.lookahead.head) {
</del><ins>+ else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) {
</ins><span class="cx"> var quasi = this.parseTemplateLiteral();
</span><span class="cx"> expr = this.finalize(this.startNode(startToken), new Node.TaggedTemplateExpression(expr, quasi));
</span><span class="cx"> }
</span><span class="lines">@@ -1556,7 +3022,7 @@
</span><span class="cx"> var property = this.parseIdentifierName();
</span><span class="cx"> expr = this.finalize(node, new Node.StaticMemberExpression(expr, property));
</span><span class="cx"> }
</span><del>- else if (this.lookahead.type === token_1.Token.Template && this.lookahead.head) {
</del><ins>+ else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) {
</ins><span class="cx"> var quasi = this.parseTemplateLiteral();
</span><span class="cx"> expr = this.finalize(node, new Node.TaggedTemplateExpression(expr, quasi));
</span><span class="cx"> }
</span><span class="lines">@@ -1566,7 +3032,7 @@
</span><span class="cx"> }
</span><span class="cx"> return expr;
</span><span class="cx"> };
</span><del>- // ECMA-262 12.4 Update Expressions
</del><ins>+ // https://tc39.github.io/ecma262/#sec-update-expressions
</ins><span class="cx"> Parser.prototype.parseUpdateExpression = function () {
</span><span class="cx"> var expr;
</span><span class="cx"> var startToken = this.lookahead;
</span><span class="lines">@@ -1587,7 +3053,7 @@
</span><span class="cx"> }
</span><span class="cx"> else {
</span><span class="cx"> expr = this.inheritCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
</span><del>- if (!this.hasLineTerminator && this.lookahead.type === token_1.Token.Punctuator) {
</del><ins>+ if (!this.hasLineTerminator && this.lookahead.type === 7 /* Punctuator */) {
</ins><span class="cx"> if (this.match('++') || this.match('--')) {
</span><span class="cx"> if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
</span><span class="cx"> this.tolerateError(messages_1.Messages.StrictLHSPostfix);
</span><span class="lines">@@ -1605,7 +3071,7 @@
</span><span class="cx"> }
</span><span class="cx"> return expr;
</span><span class="cx"> };
</span><del>- // ECMA-262 12.5 Unary Operators
</del><ins>+ // https://tc39.github.io/ecma262/#sec-unary-operators
</ins><span class="cx"> Parser.prototype.parseAwaitExpression = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> this.nextToken();
</span><span class="lines">@@ -1647,21 +3113,21 @@
</span><span class="cx"> }
</span><span class="cx"> return expr;
</span><span class="cx"> };
</span><del>- // 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
</del><ins>+ // https://tc39.github.io/ecma262/#sec-exp-operator
+ // https://tc39.github.io/ecma262/#sec-multiplicative-operators
+ // https://tc39.github.io/ecma262/#sec-additive-operators
+ // https://tc39.github.io/ecma262/#sec-bitwise-shift-operators
+ // https://tc39.github.io/ecma262/#sec-relational-operators
+ // https://tc39.github.io/ecma262/#sec-equality-operators
+ // https://tc39.github.io/ecma262/#sec-binary-bitwise-operators
+ // https://tc39.github.io/ecma262/#sec-binary-logical-operators
</ins><span class="cx"> Parser.prototype.binaryPrecedence = function (token) {
</span><span class="cx"> var op = token.value;
</span><span class="cx"> var precedence;
</span><del>- if (token.type === token_1.Token.Punctuator) {
</del><ins>+ if (token.type === 7 /* Punctuator */) {
</ins><span class="cx"> precedence = this.operatorPrecedence[op] || 0;
</span><span class="cx"> }
</span><del>- else if (token.type === token_1.Token.Keyword) {
</del><ins>+ else if (token.type === 4 /* Keyword */) {
</ins><span class="cx"> precedence = (op === 'instanceof' || (this.context.allowIn && op === 'in')) ? 7 : 0;
</span><span class="cx"> }
</span><span class="cx"> else {
</span><span class="lines">@@ -1676,13 +3142,13 @@
</span><span class="cx"> var prec = this.binaryPrecedence(token);
</span><span class="cx"> if (prec > 0) {
</span><span class="cx"> this.nextToken();
</span><del>- token.prec = prec;
</del><span class="cx"> this.context.isAssignmentTarget = false;
</span><span class="cx"> this.context.isBindingElement = false;
</span><span class="cx"> var markers = [startToken, this.lookahead];
</span><span class="cx"> var left = expr;
</span><span class="cx"> var right = this.isolateCoverGrammar(this.parseExponentiationExpression);
</span><del>- var stack = [left, token, right];
</del><ins>+ var stack = [left, token.value, right];
+ var precedences = [prec];
</ins><span class="cx"> while (true) {
</span><span class="cx"> prec = this.binaryPrecedence(this.lookahead);
</span><span class="cx"> if (prec <= 0) {
</span><span class="lines">@@ -1689,9 +3155,10 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> // Reduce: make a binary expression from the three topmost entries.
</span><del>- while ((stack.length > 2) && (prec <= stack[stack.length - 2].prec)) {
</del><ins>+ while ((stack.length > 2) && (prec <= precedences[precedences.length - 1])) {
</ins><span class="cx"> right = stack.pop();
</span><del>- var operator = stack.pop().value;
</del><ins>+ var operator = stack.pop();
+ precedences.pop();
</ins><span class="cx"> left = stack.pop();
</span><span class="cx"> markers.pop();
</span><span class="cx"> var node = this.startNode(markers[markers.length - 1]);
</span><span class="lines">@@ -1698,9 +3165,8 @@
</span><span class="cx"> stack.push(this.finalize(node, new Node.BinaryExpression(operator, left, right)));
</span><span class="cx"> }
</span><span class="cx"> // Shift.
</span><del>- token = this.nextToken();
- token.prec = prec;
- stack.push(token);
</del><ins>+ stack.push(this.nextToken().value);
+ precedences.push(prec);
</ins><span class="cx"> markers.push(this.lookahead);
</span><span class="cx"> stack.push(this.isolateCoverGrammar(this.parseExponentiationExpression));
</span><span class="cx"> }
</span><span class="lines">@@ -1710,13 +3176,14 @@
</span><span class="cx"> markers.pop();
</span><span class="cx"> while (i > 1) {
</span><span class="cx"> var node = this.startNode(markers.pop());
</span><del>- expr = this.finalize(node, new Node.BinaryExpression(stack[i - 1].value, stack[i - 2], expr));
</del><ins>+ var operator = stack[i - 1];
+ expr = this.finalize(node, new Node.BinaryExpression(operator, stack[i - 2], expr));
</ins><span class="cx"> i -= 2;
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> return expr;
</span><span class="cx"> };
</span><del>- // ECMA-262 12.14 Conditional Operator
</del><ins>+ // https://tc39.github.io/ecma262/#sec-conditional-operator
</ins><span class="cx"> Parser.prototype.parseConditionalExpression = function () {
</span><span class="cx"> var startToken = this.lookahead;
</span><span class="cx"> var expr = this.inheritCoverGrammar(this.parseBinaryExpression);
</span><span class="lines">@@ -1734,7 +3201,7 @@
</span><span class="cx"> }
</span><span class="cx"> return expr;
</span><span class="cx"> };
</span><del>- // ECMA-262 12.15 Assignment Operators
</del><ins>+ // https://tc39.github.io/ecma262/#sec-assignment-operators
</ins><span class="cx"> Parser.prototype.checkPatternParam = function (options, param) {
</span><span class="cx"> switch (param.type) {
</span><span class="cx"> case syntax_1.Syntax.Identifier:
</span><span class="lines">@@ -1741,6 +3208,7 @@
</span><span class="cx"> this.validateParam(options, param, param.name);
</span><span class="cx"> break;
</span><span class="cx"> case syntax_1.Syntax.RestElement:
</span><ins>+ case syntax_1.Syntax.RestProperty:
</ins><span class="cx"> this.checkPatternParam(options, param.argument);
</span><span class="cx"> break;
</span><span class="cx"> case syntax_1.Syntax.AssignmentPattern:
</span><span class="lines">@@ -1755,12 +3223,14 @@
</span><span class="cx"> break;
</span><span class="cx"> case syntax_1.Syntax.ObjectPattern:
</span><span class="cx"> for (var i = 0; i < param.properties.length; i++) {
</span><del>- this.checkPatternParam(options, param.properties[i].value);
</del><ins>+ var property = param.properties[i];
+ this.checkPatternParam(options, (property.type === syntax_1.Syntax.RestProperty) ? property : property.value);
</ins><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> default:
</span><span class="cx"> break;
</span><span class="cx"> }
</span><ins>+ options.simple = options.simple && (param instanceof Node.Identifier);
</ins><span class="cx"> };
</span><span class="cx"> Parser.prototype.reinterpretAsCoverFormalsList = function (expr) {
</span><span class="cx"> var params = [expr];
</span><span class="lines">@@ -1777,6 +3247,7 @@
</span><span class="cx"> return null;
</span><span class="cx"> }
</span><span class="cx"> options = {
</span><ins>+ simple: true,
</ins><span class="cx"> paramSet: {}
</span><span class="cx"> };
</span><span class="cx"> for (var i = 0; i < params.length; ++i) {
</span><span class="lines">@@ -1811,6 +3282,7 @@
</span><span class="cx"> this.throwUnexpectedToken(token, options.message);
</span><span class="cx"> }
</span><span class="cx"> return {
</span><ins>+ simple: options.simple,
</ins><span class="cx"> params: params,
</span><span class="cx"> stricted: options.stricted,
</span><span class="cx"> firstRestricted: options.firstRestricted,
</span><span class="lines">@@ -1826,7 +3298,7 @@
</span><span class="cx"> var startToken = this.lookahead;
</span><span class="cx"> var token = startToken;
</span><span class="cx"> expr = this.parseConditionalExpression();
</span><del>- if (token.type === token_1.Token.Identifier && (token.lineNumber === this.lookahead.lineNumber) && token.value === 'async' && (this.lookahead.type === token_1.Token.Identifier)) {
</del><ins>+ if (token.type === 3 /* Identifier */ && (token.lineNumber === this.lookahead.lineNumber) && token.value === 'async' && (this.lookahead.type === 3 /* Identifier */)) {
</ins><span class="cx"> var arg = this.parsePrimaryExpression();
</span><span class="cx"> expr = {
</span><span class="cx"> type: ArrowParameterPlaceHolder,
</span><span class="lines">@@ -1835,7 +3307,7 @@
</span><span class="cx"> };
</span><span class="cx"> }
</span><span class="cx"> if (expr.type === ArrowParameterPlaceHolder || this.match('=>')) {
</span><del>- // ECMA-262 14.2 Arrow Function Definitions
</del><ins>+ // https://tc39.github.io/ecma262/#sec-arrow-function-definitions
</ins><span class="cx"> this.context.isAssignmentTarget = false;
</span><span class="cx"> this.context.isBindingElement = false;
</span><span class="cx"> var isAsync = expr.async;
</span><span class="lines">@@ -1846,6 +3318,8 @@
</span><span class="cx"> }
</span><span class="cx"> this.context.firstCoverInitializedNameError = null;
</span><span class="cx"> var previousStrict = this.context.strict;
</span><ins>+ var previousAllowStrictDirective = this.context.allowStrictDirective;
+ this.context.allowStrictDirective = list.simple;
</ins><span class="cx"> var previousAllowYield = this.context.allowYield;
</span><span class="cx"> var previousAwait = this.context.await;
</span><span class="cx"> this.context.allowYield = true;
</span><span class="lines">@@ -1864,6 +3338,7 @@
</span><span class="cx"> expr = isAsync ? this.finalize(node, new Node.AsyncArrowFunctionExpression(list.params, body, expression)) :
</span><span class="cx"> this.finalize(node, new Node.ArrowFunctionExpression(list.params, body, expression));
</span><span class="cx"> this.context.strict = previousStrict;
</span><ins>+ this.context.allowStrictDirective = previousAllowStrictDirective;
</ins><span class="cx"> this.context.allowYield = previousAllowYield;
</span><span class="cx"> this.context.await = previousAwait;
</span><span class="cx"> }
</span><span class="lines">@@ -1874,7 +3349,7 @@
</span><span class="cx"> this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
</span><span class="cx"> }
</span><span class="cx"> if (this.context.strict && expr.type === syntax_1.Syntax.Identifier) {
</span><del>- var id = (expr);
</del><ins>+ var id = expr;
</ins><span class="cx"> if (this.scanner.isRestrictedWord(id.name)) {
</span><span class="cx"> this.tolerateUnexpectedToken(token, messages_1.Messages.StrictLHSAssignment);
</span><span class="cx"> }
</span><span class="lines">@@ -1890,8 +3365,9 @@
</span><span class="cx"> this.reinterpretExpressionAsPattern(expr);
</span><span class="cx"> }
</span><span class="cx"> token = this.nextToken();
</span><ins>+ var operator = token.value;
</ins><span class="cx"> var right = this.isolateCoverGrammar(this.parseAssignmentExpression);
</span><del>- expr = this.finalize(this.startNode(startToken), new Node.AssignmentExpression(token.value, expr, right));
</del><ins>+ expr = this.finalize(this.startNode(startToken), new Node.AssignmentExpression(operator, expr, right));
</ins><span class="cx"> this.context.firstCoverInitializedNameError = null;
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -1898,7 +3374,7 @@
</span><span class="cx"> }
</span><span class="cx"> return expr;
</span><span class="cx"> };
</span><del>- // ECMA-262 12.16 Comma Operator
</del><ins>+ // https://tc39.github.io/ecma262/#sec-comma-operator
</ins><span class="cx"> Parser.prototype.parseExpression = function () {
</span><span class="cx"> var startToken = this.lookahead;
</span><span class="cx"> var expr = this.isolateCoverGrammar(this.parseAssignmentExpression);
</span><span class="lines">@@ -1905,7 +3381,7 @@
</span><span class="cx"> if (this.match(',')) {
</span><span class="cx"> var expressions = [];
</span><span class="cx"> expressions.push(expr);
</span><del>- while (this.startMarker.index < this.scanner.length) {
</del><ins>+ while (this.lookahead.type !== 2 /* EOF */) {
</ins><span class="cx"> if (!this.match(',')) {
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="lines">@@ -1916,12 +3392,12 @@
</span><span class="cx"> }
</span><span class="cx"> return expr;
</span><span class="cx"> };
</span><del>- // ECMA-262 13.2 Block
</del><ins>+ // https://tc39.github.io/ecma262/#sec-block
</ins><span class="cx"> Parser.prototype.parseStatementListItem = function () {
</span><span class="cx"> var statement;
</span><span class="cx"> this.context.isAssignmentTarget = true;
</span><span class="cx"> this.context.isBindingElement = true;
</span><del>- if (this.lookahead.type === token_1.Token.Keyword) {
</del><ins>+ if (this.lookahead.type === 4 /* Keyword */) {
</ins><span class="cx"> switch (this.lookahead.value) {
</span><span class="cx"> case 'export':
</span><span class="cx"> if (!this.context.isModule) {
</span><span class="lines">@@ -1930,10 +3406,15 @@
</span><span class="cx"> statement = this.parseExportDeclaration();
</span><span class="cx"> break;
</span><span class="cx"> case 'import':
</span><del>- if (!this.context.isModule) {
- this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalImportDeclaration);
</del><ins>+ if (this.matchImportCall()) {
+ statement = this.parseExpressionStatement();
</ins><span class="cx"> }
</span><del>- statement = this.parseImportDeclaration();
</del><ins>+ else {
+ if (!this.context.isModule) {
+ this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalImportDeclaration);
+ }
+ statement = this.parseImportDeclaration();
+ }
</ins><span class="cx"> break;
</span><span class="cx"> case 'const':
</span><span class="cx"> statement = this.parseLexicalDeclaration({ inFor: false });
</span><span class="lines">@@ -1970,14 +3451,13 @@
</span><span class="cx"> this.expect('}');
</span><span class="cx"> return this.finalize(node, new Node.BlockStatement(block));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.3.1 Let and Const Declarations
</del><ins>+ // https://tc39.github.io/ecma262/#sec-let-and-const-declarations
</ins><span class="cx"> Parser.prototype.parseLexicalBinding = function (kind, options) {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var params = [];
</span><span class="cx"> var id = this.parsePattern(params, kind);
</span><del>- // ECMA-262 12.2.1
</del><span class="cx"> if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
</span><del>- if (this.scanner.isRestrictedWord((id).name)) {
</del><ins>+ if (this.scanner.isRestrictedWord(id.name)) {
</ins><span class="cx"> this.tolerateError(messages_1.Messages.StrictVarName);
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -2008,19 +3488,15 @@
</span><span class="cx"> return list;
</span><span class="cx"> };
</span><span class="cx"> Parser.prototype.isLexicalDeclaration = function () {
</span><del>- var previousIndex = this.scanner.index;
- var previousLineNumber = this.scanner.lineNumber;
- var previousLineStart = this.scanner.lineStart;
- this.collectComments();
</del><ins>+ var state = this.scanner.saveState();
+ this.scanner.scanComments();
</ins><span class="cx"> var next = this.scanner.lex();
</span><del>- 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');
</del><ins>+ this.scanner.restoreState(state);
+ return (next.type === 3 /* Identifier */) ||
+ (next.type === 7 /* Punctuator */ && next.value === '[') ||
+ (next.type === 7 /* Punctuator */ && next.value === '{') ||
+ (next.type === 4 /* Keyword */ && next.value === 'let') ||
+ (next.type === 4 /* Keyword */ && next.value === 'yield');
</ins><span class="cx"> };
</span><span class="cx"> Parser.prototype.parseLexicalDeclaration = function (options) {
</span><span class="cx"> var node = this.createNode();
</span><span class="lines">@@ -2030,12 +3506,11 @@
</span><span class="cx"> this.consumeSemicolon();
</span><span class="cx"> return this.finalize(node, new Node.VariableDeclaration(declarations, kind));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.3.3 Destructuring Binding Patterns
</del><ins>+ // https://tc39.github.io/ecma262/#sec-destructuring-binding-patterns
</ins><span class="cx"> Parser.prototype.parseBindingRestElement = function (params, kind) {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> this.expect('...');
</span><del>- params.push(this.lookahead);
- var arg = this.parseVariableIdentifier(kind);
</del><ins>+ var arg = this.parsePattern(params, kind);
</ins><span class="cx"> return this.finalize(node, new Node.RestElement(arg));
</span><span class="cx"> };
</span><span class="cx"> Parser.prototype.parseArrayPattern = function (params, kind) {
</span><span class="lines">@@ -2070,7 +3545,7 @@
</span><span class="cx"> var method = false;
</span><span class="cx"> var key;
</span><span class="cx"> var value;
</span><del>- if (this.lookahead.type === token_1.Token.Identifier) {
</del><ins>+ if (this.lookahead.type === 3 /* Identifier */) {
</ins><span class="cx"> var keyToken = this.lookahead;
</span><span class="cx"> key = this.parseVariableIdentifier();
</span><span class="cx"> var init = this.finalize(node, new Node.Identifier(keyToken.value));
</span><span class="lines">@@ -2099,12 +3574,24 @@
</span><span class="cx"> }
</span><span class="cx"> return this.finalize(node, new Node.Property('init', key, computed, value, method, shorthand));
</span><span class="cx"> };
</span><ins>+ Parser.prototype.parseRestProperty = function (params, kind) {
+ var node = this.createNode();
+ this.expect('...');
+ var arg = this.parsePattern(params);
+ if (this.match('=')) {
+ this.throwError(messages_1.Messages.DefaultRestProperty);
+ }
+ if (!this.match('}')) {
+ this.throwError(messages_1.Messages.PropertyAfterRestProperty);
+ }
+ return this.finalize(node, new Node.RestProperty(arg));
+ };
</ins><span class="cx"> Parser.prototype.parseObjectPattern = function (params, kind) {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var properties = [];
</span><span class="cx"> this.expect('{');
</span><span class="cx"> while (!this.match('}')) {
</span><del>- properties.push(this.parsePropertyPattern(params, kind));
</del><ins>+ properties.push(this.match('...') ? this.parseRestProperty(params, kind) : this.parsePropertyPattern(params, kind));
</ins><span class="cx"> if (!this.match('}')) {
</span><span class="cx"> this.expect(',');
</span><span class="cx"> }
</span><span class="lines">@@ -2142,20 +3629,20 @@
</span><span class="cx"> }
</span><span class="cx"> return pattern;
</span><span class="cx"> };
</span><del>- // ECMA-262 13.3.2 Variable Statement
</del><ins>+ // https://tc39.github.io/ecma262/#sec-variable-statement
</ins><span class="cx"> Parser.prototype.parseVariableIdentifier = function (kind) {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var token = this.nextToken();
</span><del>- if (token.type === token_1.Token.Keyword && token.value === 'yield') {
</del><ins>+ if (token.type === 4 /* Keyword */ && token.value === 'yield') {
</ins><span class="cx"> if (this.context.strict) {
</span><span class="cx"> this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
</span><span class="cx"> }
</span><del>- if (!this.context.allowYield) {
</del><ins>+ else if (!this.context.allowYield) {
</ins><span class="cx"> this.throwUnexpectedToken(token);
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- else if (token.type !== token_1.Token.Identifier) {
- if (this.context.strict && token.type === token_1.Token.Keyword && this.scanner.isStrictModeReservedWord(token.value)) {
</del><ins>+ else if (token.type !== 3 /* Identifier */) {
+ if (this.context.strict && token.type === 4 /* Keyword */ && this.scanner.isStrictModeReservedWord(token.value)) {
</ins><span class="cx"> this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
</span><span class="cx"> }
</span><span class="cx"> else {
</span><span class="lines">@@ -2164,7 +3651,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- else if ((this.context.isModule || this.context.await) && token.type === token_1.Token.Identifier && token.value === 'await') {
</del><ins>+ else if ((this.context.isModule || this.context.await) && token.type === 3 /* Identifier */ && token.value === 'await') {
</ins><span class="cx"> this.tolerateUnexpectedToken(token);
</span><span class="cx"> }
</span><span class="cx"> return this.finalize(node, new Node.Identifier(token.value));
</span><span class="lines">@@ -2173,9 +3660,8 @@
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var params = [];
</span><span class="cx"> var id = this.parsePattern(params, 'var');
</span><del>- // ECMA-262 12.2.1
</del><span class="cx"> if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
</span><del>- if (this.scanner.isRestrictedWord((id).name)) {
</del><ins>+ if (this.scanner.isRestrictedWord(id.name)) {
</ins><span class="cx"> this.tolerateError(messages_1.Messages.StrictVarName);
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -2206,13 +3692,13 @@
</span><span class="cx"> this.consumeSemicolon();
</span><span class="cx"> return this.finalize(node, new Node.VariableDeclaration(declarations, 'var'));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.4 Empty Statement
</del><ins>+ // https://tc39.github.io/ecma262/#sec-empty-statement
</ins><span class="cx"> Parser.prototype.parseEmptyStatement = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> this.expect(';');
</span><span class="cx"> return this.finalize(node, new Node.EmptyStatement());
</span><span class="cx"> };
</span><del>- // ECMA-262 13.5 Expression Statement
</del><ins>+ // https://tc39.github.io/ecma262/#sec-expression-statement
</ins><span class="cx"> Parser.prototype.parseExpressionStatement = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var expr = this.parseExpression();
</span><span class="lines">@@ -2219,7 +3705,13 @@
</span><span class="cx"> this.consumeSemicolon();
</span><span class="cx"> return this.finalize(node, new Node.ExpressionStatement(expr));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.6 If statement
</del><ins>+ // https://tc39.github.io/ecma262/#sec-if-statement
+ Parser.prototype.parseIfClause = function () {
+ if (this.context.strict && this.matchKeyword('function')) {
+ this.tolerateError(messages_1.Messages.StrictFunction);
+ }
+ return this.parseStatement();
+ };
</ins><span class="cx"> Parser.prototype.parseIfStatement = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var consequent;
</span><span class="lines">@@ -2233,15 +3725,15 @@
</span><span class="cx"> }
</span><span class="cx"> else {
</span><span class="cx"> this.expect(')');
</span><del>- consequent = this.parseStatement();
</del><ins>+ consequent = this.parseIfClause();
</ins><span class="cx"> if (this.matchKeyword('else')) {
</span><span class="cx"> this.nextToken();
</span><del>- alternate = this.parseStatement();
</del><ins>+ alternate = this.parseIfClause();
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> return this.finalize(node, new Node.IfStatement(test, consequent, alternate));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.7.2 The do-while Statement
</del><ins>+ // https://tc39.github.io/ecma262/#sec-do-while-statement
</ins><span class="cx"> Parser.prototype.parseDoWhileStatement = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> this.expectKeyword('do');
</span><span class="lines">@@ -2252,13 +3744,18 @@
</span><span class="cx"> this.expectKeyword('while');
</span><span class="cx"> this.expect('(');
</span><span class="cx"> var test = this.parseExpression();
</span><del>- this.expect(')');
- if (this.match(';')) {
- this.nextToken();
</del><ins>+ if (!this.match(')') && this.config.tolerant) {
+ this.tolerateUnexpectedToken(this.nextToken());
</ins><span class="cx"> }
</span><ins>+ else {
+ this.expect(')');
+ if (this.match(';')) {
+ this.nextToken();
+ }
+ }
</ins><span class="cx"> return this.finalize(node, new Node.DoWhileStatement(body, test));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.7.3 The while Statement
</del><ins>+ // https://tc39.github.io/ecma262/#sec-while-statement
</ins><span class="cx"> Parser.prototype.parseWhileStatement = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var body;
</span><span class="lines">@@ -2278,8 +3775,8 @@
</span><span class="cx"> }
</span><span class="cx"> return this.finalize(node, new Node.WhileStatement(test, body));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.7.4 The for Statement
- // ECMA-262 13.7.5 The for-in and for-of Statements
</del><ins>+ // https://tc39.github.io/ecma262/#sec-for-statement
+ // https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements
</ins><span class="cx"> Parser.prototype.parseForStatement = function () {
</span><span class="cx"> var init = null;
</span><span class="cx"> var test = null;
</span><span class="lines">@@ -2426,12 +3923,12 @@
</span><span class="cx"> forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) :
</span><span class="cx"> this.finalize(node, new Node.ForOfStatement(left, right, body));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.8 The continue statement
</del><ins>+ // https://tc39.github.io/ecma262/#sec-continue-statement
</ins><span class="cx"> Parser.prototype.parseContinueStatement = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> this.expectKeyword('continue');
</span><span class="cx"> var label = null;
</span><del>- if (this.lookahead.type === token_1.Token.Identifier && !this.hasLineTerminator) {
</del><ins>+ if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) {
</ins><span class="cx"> var id = this.parseVariableIdentifier();
</span><span class="cx"> label = id;
</span><span class="cx"> var key = '$' + id.name;
</span><span class="lines">@@ -2445,12 +3942,12 @@
</span><span class="cx"> }
</span><span class="cx"> return this.finalize(node, new Node.ContinueStatement(label));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.9 The break statement
</del><ins>+ // https://tc39.github.io/ecma262/#sec-break-statement
</ins><span class="cx"> Parser.prototype.parseBreakStatement = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> this.expectKeyword('break');
</span><span class="cx"> var label = null;
</span><del>- if (this.lookahead.type === token_1.Token.Identifier && !this.hasLineTerminator) {
</del><ins>+ if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) {
</ins><span class="cx"> var id = this.parseVariableIdentifier();
</span><span class="cx"> var key = '$' + id.name;
</span><span class="cx"> if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
</span><span class="lines">@@ -2464,7 +3961,7 @@
</span><span class="cx"> }
</span><span class="cx"> return this.finalize(node, new Node.BreakStatement(label));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.10 The return statement
</del><ins>+ // https://tc39.github.io/ecma262/#sec-return-statement
</ins><span class="cx"> Parser.prototype.parseReturnStatement = function () {
</span><span class="cx"> if (!this.context.inFunctionBody) {
</span><span class="cx"> this.tolerateError(messages_1.Messages.IllegalReturn);
</span><span class="lines">@@ -2472,25 +3969,32 @@
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> this.expectKeyword('return');
</span><span class="cx"> var hasArgument = !this.match(';') && !this.match('}') &&
</span><del>- !this.hasLineTerminator && this.lookahead.type !== token_1.Token.EOF;
</del><ins>+ !this.hasLineTerminator && this.lookahead.type !== 2 /* EOF */;
</ins><span class="cx"> var argument = hasArgument ? this.parseExpression() : null;
</span><span class="cx"> this.consumeSemicolon();
</span><span class="cx"> return this.finalize(node, new Node.ReturnStatement(argument));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.11 The with statement
</del><ins>+ // https://tc39.github.io/ecma262/#sec-with-statement
</ins><span class="cx"> Parser.prototype.parseWithStatement = function () {
</span><span class="cx"> if (this.context.strict) {
</span><span class="cx"> this.tolerateError(messages_1.Messages.StrictModeWith);
</span><span class="cx"> }
</span><span class="cx"> var node = this.createNode();
</span><ins>+ var body;
</ins><span class="cx"> this.expectKeyword('with');
</span><span class="cx"> this.expect('(');
</span><span class="cx"> var object = this.parseExpression();
</span><del>- this.expect(')');
- var body = this.parseStatement();
</del><ins>+ if (!this.match(')') && this.config.tolerant) {
+ this.tolerateUnexpectedToken(this.nextToken());
+ body = this.finalize(this.createNode(), new Node.EmptyStatement());
+ }
+ else {
+ this.expect(')');
+ body = this.parseStatement();
+ }
</ins><span class="cx"> return this.finalize(node, new Node.WithStatement(object, body));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.12 The switch statement
</del><ins>+ // https://tc39.github.io/ecma262/#sec-switch-statement
</ins><span class="cx"> Parser.prototype.parseSwitchCase = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var test;
</span><span class="lines">@@ -2540,7 +4044,7 @@
</span><span class="cx"> this.context.inSwitch = previousInSwitch;
</span><span class="cx"> return this.finalize(node, new Node.SwitchStatement(discriminant, cases));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.13 Labelled Statements
</del><ins>+ // https://tc39.github.io/ecma262/#sec-labelled-statements
</ins><span class="cx"> Parser.prototype.parseLabelledStatement = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var expr = this.parseExpression();
</span><span class="lines">@@ -2547,15 +4051,33 @@
</span><span class="cx"> var statement;
</span><span class="cx"> if ((expr.type === syntax_1.Syntax.Identifier) && this.match(':')) {
</span><span class="cx"> this.nextToken();
</span><del>- var id = (expr);
</del><ins>+ var id = expr;
</ins><span class="cx"> var key = '$' + id.name;
</span><span class="cx"> if (Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
</span><span class="cx"> this.throwError(messages_1.Messages.Redeclaration, 'Label', id.name);
</span><span class="cx"> }
</span><span class="cx"> this.context.labelSet[key] = true;
</span><del>- var labeledBody = this.parseStatement();
</del><ins>+ var body = void 0;
+ if (this.matchKeyword('class')) {
+ this.tolerateUnexpectedToken(this.lookahead);
+ body = this.parseClassDeclaration();
+ }
+ else if (this.matchKeyword('function')) {
+ var token = this.lookahead;
+ var declaration = this.parseFunctionDeclaration();
+ if (this.context.strict) {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunction);
+ }
+ else if (declaration.generator) {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.GeneratorInLegacyContext);
+ }
+ body = declaration;
+ }
+ else {
+ body = this.parseStatement();
+ }
</ins><span class="cx"> delete this.context.labelSet[key];
</span><del>- statement = new Node.LabeledStatement(id, labeledBody);
</del><ins>+ statement = new Node.LabeledStatement(id, body);
</ins><span class="cx"> }
</span><span class="cx"> else {
</span><span class="cx"> this.consumeSemicolon();
</span><span class="lines">@@ -2563,7 +4085,7 @@
</span><span class="cx"> }
</span><span class="cx"> return this.finalize(node, statement);
</span><span class="cx"> };
</span><del>- // ECMA-262 13.14 The throw statement
</del><ins>+ // https://tc39.github.io/ecma262/#sec-throw-statement
</ins><span class="cx"> Parser.prototype.parseThrowStatement = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> this.expectKeyword('throw');
</span><span class="lines">@@ -2574,7 +4096,7 @@
</span><span class="cx"> this.consumeSemicolon();
</span><span class="cx"> return this.finalize(node, new Node.ThrowStatement(argument));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.15 The try statement
</del><ins>+ // https://tc39.github.io/ecma262/#sec-try-statement
</ins><span class="cx"> Parser.prototype.parseCatchClause = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> this.expectKeyword('catch');
</span><span class="lines">@@ -2593,7 +4115,7 @@
</span><span class="cx"> paramMap[key] = true;
</span><span class="cx"> }
</span><span class="cx"> if (this.context.strict && param.type === syntax_1.Syntax.Identifier) {
</span><del>- if (this.scanner.isRestrictedWord((param).name)) {
</del><ins>+ if (this.scanner.isRestrictedWord(param.name)) {
</ins><span class="cx"> this.tolerateError(messages_1.Messages.StrictCatchVariable);
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -2616,7 +4138,7 @@
</span><span class="cx"> }
</span><span class="cx"> return this.finalize(node, new Node.TryStatement(block, handler, finalizer));
</span><span class="cx"> };
</span><del>- // ECMA-262 13.16 The debugger statement
</del><ins>+ // https://tc39.github.io/ecma262/#sec-debugger-statement
</ins><span class="cx"> Parser.prototype.parseDebuggerStatement = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> this.expectKeyword('debugger');
</span><span class="lines">@@ -2623,19 +4145,19 @@
</span><span class="cx"> this.consumeSemicolon();
</span><span class="cx"> return this.finalize(node, new Node.DebuggerStatement());
</span><span class="cx"> };
</span><del>- // ECMA-262 13 Statements
</del><ins>+ // https://tc39.github.io/ecma262/#sec-ecmascript-language-statements-and-declarations
</ins><span class="cx"> Parser.prototype.parseStatement = function () {
</span><span class="cx"> var statement;
</span><span class="cx"> switch (this.lookahead.type) {
</span><del>- 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:
</del><ins>+ case 1 /* BooleanLiteral */:
+ case 5 /* NullLiteral */:
+ case 6 /* NumericLiteral */:
+ case 8 /* StringLiteral */:
+ case 10 /* Template */:
+ case 9 /* RegularExpression */:
</ins><span class="cx"> statement = this.parseExpressionStatement();
</span><span class="cx"> break;
</span><del>- case token_1.Token.Punctuator:
</del><ins>+ case 7 /* Punctuator */:
</ins><span class="cx"> var value = this.lookahead.value;
</span><span class="cx"> if (value === '{') {
</span><span class="cx"> statement = this.parseBlock();
</span><span class="lines">@@ -2650,10 +4172,10 @@
</span><span class="cx"> statement = this.parseExpressionStatement();
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case token_1.Token.Identifier:
</del><ins>+ case 3 /* Identifier */:
</ins><span class="cx"> statement = this.matchAsyncFunction() ? this.parseFunctionDeclaration() : this.parseLabelledStatement();
</span><span class="cx"> break;
</span><del>- case token_1.Token.Keyword:
</del><ins>+ case 4 /* Keyword */:
</ins><span class="cx"> switch (this.lookahead.value) {
</span><span class="cx"> case 'break':
</span><span class="cx"> statement = this.parseBreakStatement();
</span><span class="lines">@@ -2707,7 +4229,7 @@
</span><span class="cx"> }
</span><span class="cx"> return statement;
</span><span class="cx"> };
</span><del>- // ECMA-262 14.1 Function Definition
</del><ins>+ // https://tc39.github.io/ecma262/#sec-function-definitions
</ins><span class="cx"> Parser.prototype.parseFunctionSourceElements = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> this.expect('{');
</span><span class="lines">@@ -2720,7 +4242,7 @@
</span><span class="cx"> this.context.inIteration = false;
</span><span class="cx"> this.context.inSwitch = false;
</span><span class="cx"> this.context.inFunctionBody = true;
</span><del>- while (this.startMarker.index < this.scanner.length) {
</del><ins>+ while (this.lookahead.type !== 2 /* EOF */) {
</ins><span class="cx"> if (this.match('}')) {
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="lines">@@ -2769,12 +4291,8 @@
</span><span class="cx"> };
</span><span class="cx"> Parser.prototype.parseRestElement = function (params) {
</span><span class="cx"> var node = this.createNode();
</span><del>- this.nextToken();
- if (this.match('{')) {
- this.throwError(messages_1.Messages.ObjectPatternAsRestParameter);
- }
- params.push(this.lookahead);
- var param = this.parseVariableIdentifier();
</del><ins>+ this.expect('...');
+ var arg = this.parsePattern(params);
</ins><span class="cx"> if (this.match('=')) {
</span><span class="cx"> this.throwError(messages_1.Messages.DefaultRestParameter);
</span><span class="cx"> }
</span><span class="lines">@@ -2781,27 +4299,21 @@
</span><span class="cx"> if (!this.match(')')) {
</span><span class="cx"> this.throwError(messages_1.Messages.ParameterAfterRestParameter);
</span><span class="cx"> }
</span><del>- return this.finalize(node, new Node.RestElement(param));
</del><ins>+ return this.finalize(node, new Node.RestElement(arg));
</ins><span class="cx"> };
</span><span class="cx"> Parser.prototype.parseFormalParameter = function (options) {
</span><del>- var param;
</del><span class="cx"> var params = [];
</span><del>- 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);
</del><ins>+ var param = this.match('...') ? this.parseRestElement(params) : this.parsePatternWithDefault(params);
</ins><span class="cx"> for (var i = 0; i < params.length; i++) {
</span><span class="cx"> this.validateParam(options, params[i], params[i].value);
</span><span class="cx"> }
</span><ins>+ options.simple = options.simple && (param instanceof Node.Identifier);
</ins><span class="cx"> options.params.push(param);
</span><span class="cx"> };
</span><span class="cx"> Parser.prototype.parseFormalParameters = function (firstRestricted) {
</span><span class="cx"> var options;
</span><span class="cx"> options = {
</span><ins>+ simple: true,
</ins><span class="cx"> params: [],
</span><span class="cx"> firstRestricted: firstRestricted
</span><span class="cx"> };
</span><span class="lines">@@ -2808,7 +4320,7 @@
</span><span class="cx"> this.expect('(');
</span><span class="cx"> if (!this.match(')')) {
</span><span class="cx"> options.paramSet = {};
</span><del>- while (this.startMarker.index < this.scanner.length) {
</del><ins>+ while (this.lookahead.type !== 2 /* EOF */) {
</ins><span class="cx"> this.parseFormalParameter(options);
</span><span class="cx"> if (this.match(')')) {
</span><span class="cx"> break;
</span><span class="lines">@@ -2821,6 +4333,7 @@
</span><span class="cx"> }
</span><span class="cx"> this.expect(')');
</span><span class="cx"> return {
</span><ins>+ simple: options.simple,
</ins><span class="cx"> params: options.params,
</span><span class="cx"> stricted: options.stricted,
</span><span class="cx"> firstRestricted: options.firstRestricted,
</span><span class="lines">@@ -2830,15 +4343,11 @@
</span><span class="cx"> Parser.prototype.matchAsyncFunction = function () {
</span><span class="cx"> var match = this.matchContextualKeyword('async');
</span><span class="cx"> if (match) {
</span><del>- var previousIndex = this.scanner.index;
- var previousLineNumber = this.scanner.lineNumber;
- var previousLineStart = this.scanner.lineStart;
- this.collectComments();
</del><ins>+ var state = this.scanner.saveState();
+ this.scanner.scanComments();
</ins><span class="cx"> var next = this.scanner.lex();
</span><del>- 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'));
</del><ins>+ this.scanner.restoreState(state);
+ match = (state.lineNumber === next.lineNumber) && (next.type === 4 /* Keyword */) && (next.value === 'function');
</ins><span class="cx"> }
</span><span class="cx"> return match;
</span><span class="cx"> };
</span><span class="lines">@@ -2887,6 +4396,8 @@
</span><span class="cx"> message = formalParameters.message;
</span><span class="cx"> }
</span><span class="cx"> var previousStrict = this.context.strict;
</span><ins>+ var previousAllowStrictDirective = this.context.allowStrictDirective;
+ this.context.allowStrictDirective = formalParameters.simple;
</ins><span class="cx"> var body = this.parseFunctionSourceElements();
</span><span class="cx"> if (this.context.strict && firstRestricted) {
</span><span class="cx"> this.throwUnexpectedToken(firstRestricted, message);
</span><span class="lines">@@ -2895,6 +4406,7 @@
</span><span class="cx"> this.tolerateUnexpectedToken(stricted, message);
</span><span class="cx"> }
</span><span class="cx"> this.context.strict = previousStrict;
</span><ins>+ this.context.allowStrictDirective = previousAllowStrictDirective;
</ins><span class="cx"> this.context.await = previousAllowAwait;
</span><span class="cx"> this.context.allowYield = previousAllowYield;
</span><span class="cx"> return isAsync ? this.finalize(node, new Node.AsyncFunctionDeclaration(id, params, body)) :
</span><span class="lines">@@ -2945,6 +4457,8 @@
</span><span class="cx"> message = formalParameters.message;
</span><span class="cx"> }
</span><span class="cx"> var previousStrict = this.context.strict;
</span><ins>+ var previousAllowStrictDirective = this.context.allowStrictDirective;
+ this.context.allowStrictDirective = formalParameters.simple;
</ins><span class="cx"> var body = this.parseFunctionSourceElements();
</span><span class="cx"> if (this.context.strict && firstRestricted) {
</span><span class="cx"> this.throwUnexpectedToken(firstRestricted, message);
</span><span class="lines">@@ -2953,12 +4467,13 @@
</span><span class="cx"> this.tolerateUnexpectedToken(stricted, message);
</span><span class="cx"> }
</span><span class="cx"> this.context.strict = previousStrict;
</span><ins>+ this.context.allowStrictDirective = previousAllowStrictDirective;
</ins><span class="cx"> this.context.await = previousAllowAwait;
</span><span class="cx"> this.context.allowYield = previousAllowYield;
</span><span class="cx"> return isAsync ? this.finalize(node, new Node.AsyncFunctionExpression(id, params, body)) :
</span><span class="cx"> this.finalize(node, new Node.FunctionExpression(id, params, body, isGenerator));
</span><span class="cx"> };
</span><del>- // ECMA-262 14.1.1 Directive Prologues
</del><ins>+ // https://tc39.github.io/ecma262/#sec-directive-prologues-and-the-use-strict-directive
</ins><span class="cx"> Parser.prototype.parseDirective = function () {
</span><span class="cx"> var token = this.lookahead;
</span><span class="cx"> var node = this.createNode();
</span><span class="lines">@@ -2972,7 +4487,7 @@
</span><span class="cx"> var body = [];
</span><span class="cx"> while (true) {
</span><span class="cx"> var token = this.lookahead;
</span><del>- if (token.type !== token_1.Token.StringLiteral) {
</del><ins>+ if (token.type !== 8 /* StringLiteral */) {
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> var statement = this.parseDirective();
</span><span class="lines">@@ -2986,6 +4501,9 @@
</span><span class="cx"> if (firstRestricted) {
</span><span class="cx"> this.tolerateUnexpectedToken(firstRestricted, messages_1.Messages.StrictOctalLiteral);
</span><span class="cx"> }
</span><ins>+ if (!this.context.allowStrictDirective) {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.IllegalLanguageModeDirective);
+ }
</ins><span class="cx"> }
</span><span class="cx"> else {
</span><span class="cx"> if (!firstRestricted && token.octal) {
</span><span class="lines">@@ -2995,59 +4513,51 @@
</span><span class="cx"> }
</span><span class="cx"> return body;
</span><span class="cx"> };
</span><del>- // ECMA-262 14.3 Method Definitions
</del><ins>+ // https://tc39.github.io/ecma262/#sec-method-definitions
</ins><span class="cx"> Parser.prototype.qualifiedPropertyName = function (token) {
</span><span class="cx"> switch (token.type) {
</span><del>- 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:
</del><ins>+ case 3 /* Identifier */:
+ case 8 /* StringLiteral */:
+ case 1 /* BooleanLiteral */:
+ case 5 /* NullLiteral */:
+ case 6 /* NumericLiteral */:
+ case 4 /* Keyword */:
</ins><span class="cx"> return true;
</span><del>- case token_1.Token.Punctuator:
</del><ins>+ case 7 /* Punctuator */:
</ins><span class="cx"> return token.value === '[';
</span><ins>+ default:
+ break;
</ins><span class="cx"> }
</span><span class="cx"> return false;
</span><span class="cx"> };
</span><span class="cx"> Parser.prototype.parseGetterMethod = function () {
</span><span class="cx"> var node = this.createNode();
</span><del>- this.expect('(');
- this.expect(')');
</del><span class="cx"> var isGenerator = false;
</span><del>- var params = {
- params: [],
- stricted: null,
- firstRestricted: null,
- message: null
- };
</del><span class="cx"> var previousAllowYield = this.context.allowYield;
</span><span class="cx"> this.context.allowYield = false;
</span><del>- var method = this.parsePropertyMethod(params);
</del><ins>+ var formalParameters = this.parseFormalParameters();
+ if (formalParameters.params.length > 0) {
+ this.tolerateError(messages_1.Messages.BadGetterArity);
+ }
+ var method = this.parsePropertyMethod(formalParameters);
</ins><span class="cx"> this.context.allowYield = previousAllowYield;
</span><del>- return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
</del><ins>+ return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));
</ins><span class="cx"> };
</span><span class="cx"> Parser.prototype.parseSetterMethod = function () {
</span><span class="cx"> var node = this.createNode();
</span><del>- var options = {
- params: [],
- firstRestricted: null,
- paramSet: {}
- };
</del><span class="cx"> var isGenerator = false;
</span><span class="cx"> var previousAllowYield = this.context.allowYield;
</span><span class="cx"> this.context.allowYield = false;
</span><del>- this.expect('(');
- if (this.match(')')) {
- this.tolerateUnexpectedToken(this.lookahead);
</del><ins>+ var formalParameters = this.parseFormalParameters();
+ if (formalParameters.params.length !== 1) {
+ this.tolerateError(messages_1.Messages.BadSetterArity);
</ins><span class="cx"> }
</span><del>- else {
- this.parseFormalParameter(options);
</del><ins>+ else if (formalParameters.params[0] instanceof Node.RestElement) {
+ this.tolerateError(messages_1.Messages.BadSetterRestParameter);
</ins><span class="cx"> }
</span><del>- this.expect(')');
- var method = this.parsePropertyMethod(options);
</del><ins>+ var method = this.parsePropertyMethod(formalParameters);
</ins><span class="cx"> this.context.allowYield = previousAllowYield;
</span><del>- return this.finalize(node, new Node.FunctionExpression(null, options.params, method, isGenerator));
</del><ins>+ return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));
</ins><span class="cx"> };
</span><span class="cx"> Parser.prototype.parseGeneratorMethod = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="lines">@@ -3060,7 +4570,29 @@
</span><span class="cx"> this.context.allowYield = previousAllowYield;
</span><span class="cx"> return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
</span><span class="cx"> };
</span><del>- // ECMA-262 14.4 Generator Function Definitions
</del><ins>+ // https://tc39.github.io/ecma262/#sec-generator-function-definitions
+ Parser.prototype.isStartOfExpression = function () {
+ var start = true;
+ var value = this.lookahead.value;
+ switch (this.lookahead.type) {
+ case 7 /* Punctuator */:
+ start = (value === '[') || (value === '(') || (value === '{') ||
+ (value === '+') || (value === '-') ||
+ (value === '!') || (value === '~') ||
+ (value === '++') || (value === '--') ||
+ (value === '/') || (value === '/='); // regular expression literal
+ break;
+ case 4 /* Keyword */:
+ start = (value === 'class') || (value === 'delete') ||
+ (value === 'function') || (value === 'let') || (value === 'new') ||
+ (value === 'super') || (value === 'this') || (value === 'typeof') ||
+ (value === 'void') || (value === 'yield');
+ break;
+ default:
+ break;
+ }
+ return start;
+ };
</ins><span class="cx"> Parser.prototype.parseYieldExpression = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> this.expectKeyword('yield');
</span><span class="lines">@@ -3074,16 +4606,14 @@
</span><span class="cx"> this.nextToken();
</span><span class="cx"> argument = this.parseAssignmentExpression();
</span><span class="cx"> }
</span><del>- else {
- if (!this.match(';') && !this.match('}') && !this.match(')') && this.lookahead.type !== token_1.Token.EOF) {
- argument = this.parseAssignmentExpression();
- }
</del><ins>+ else if (this.isStartOfExpression()) {
+ argument = this.parseAssignmentExpression();
</ins><span class="cx"> }
</span><span class="cx"> this.context.allowYield = previousAllowYield;
</span><span class="cx"> }
</span><span class="cx"> return this.finalize(node, new Node.YieldExpression(argument, delegate));
</span><span class="cx"> };
</span><del>- // ECMA-262 14.5 Class Definitions
</del><ins>+ // https://tc39.github.io/ecma262/#sec-class-definitions
</ins><span class="cx"> Parser.prototype.parseClassElement = function (hasConstructor) {
</span><span class="cx"> var token = this.lookahead;
</span><span class="cx"> var node = this.createNode();
</span><span class="lines">@@ -3112,13 +4642,13 @@
</span><span class="cx"> key = this.parseObjectPropertyKey();
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- if ((token.type === token_1.Token.Identifier) && !this.hasLineTerminator && (token.value === 'async')) {
</del><ins>+ if ((token.type === 3 /* Identifier */) && !this.hasLineTerminator && (token.value === 'async')) {
</ins><span class="cx"> var punctuator = this.lookahead.value;
</span><span class="cx"> if (punctuator !== ':' && punctuator !== '(' && punctuator !== '*') {
</span><span class="cx"> isAsync = true;
</span><span class="cx"> token = this.lookahead;
</span><span class="cx"> key = this.parseObjectPropertyKey();
</span><del>- if (token.type === token_1.Token.Identifier) {
</del><ins>+ if (token.type === 3 /* Identifier */) {
</ins><span class="cx"> if (token.value === 'get' || token.value === 'set') {
</span><span class="cx"> this.tolerateUnexpectedToken(token);
</span><span class="cx"> }
</span><span class="lines">@@ -3130,7 +4660,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);
</span><del>- if (token.type === token_1.Token.Identifier) {
</del><ins>+ if (token.type === 3 /* Identifier */) {
</ins><span class="cx"> if (token.value === 'get' && lookaheadPropertyKey) {
</span><span class="cx"> kind = 'get';
</span><span class="cx"> computed = this.match('[');
</span><span class="lines">@@ -3145,7 +4675,7 @@
</span><span class="cx"> value = this.parseSetterMethod();
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- else if (token.type === token_1.Token.Punctuator && token.value === '*' && lookaheadPropertyKey) {
</del><ins>+ else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) {
</ins><span class="cx"> kind = 'init';
</span><span class="cx"> computed = this.match('[');
</span><span class="cx"> key = this.parseObjectPropertyKey();
</span><span class="lines">@@ -3207,7 +4737,7 @@
</span><span class="cx"> var previousStrict = this.context.strict;
</span><span class="cx"> this.context.strict = true;
</span><span class="cx"> this.expectKeyword('class');
</span><del>- var id = (identifierIsOptional && (this.lookahead.type !== token_1.Token.Identifier)) ? null : this.parseVariableIdentifier();
</del><ins>+ var id = (identifierIsOptional && (this.lookahead.type !== 3 /* Identifier */)) ? null : this.parseVariableIdentifier();
</ins><span class="cx"> var superClass = null;
</span><span class="cx"> if (this.matchKeyword('extends')) {
</span><span class="cx"> this.nextToken();
</span><span class="lines">@@ -3222,7 +4752,7 @@
</span><span class="cx"> var previousStrict = this.context.strict;
</span><span class="cx"> this.context.strict = true;
</span><span class="cx"> this.expectKeyword('class');
</span><del>- var id = (this.lookahead.type === token_1.Token.Identifier) ? this.parseVariableIdentifier() : null;
</del><ins>+ var id = (this.lookahead.type === 3 /* Identifier */) ? this.parseVariableIdentifier() : null;
</ins><span class="cx"> var superClass = null;
</span><span class="cx"> if (this.matchKeyword('extends')) {
</span><span class="cx"> this.nextToken();
</span><span class="lines">@@ -3232,14 +4762,14 @@
</span><span class="cx"> this.context.strict = previousStrict;
</span><span class="cx"> return this.finalize(node, new Node.ClassExpression(id, superClass, classBody));
</span><span class="cx"> };
</span><del>- // ECMA-262 15.1 Scripts
- // ECMA-262 15.2 Modules
</del><ins>+ // https://tc39.github.io/ecma262/#sec-scripts
+ // https://tc39.github.io/ecma262/#sec-modules
</ins><span class="cx"> Parser.prototype.parseModule = function () {
</span><span class="cx"> this.context.strict = true;
</span><span class="cx"> this.context.isModule = true;
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var body = this.parseDirectivePrologues();
</span><del>- while (this.startMarker.index < this.scanner.length) {
</del><ins>+ while (this.lookahead.type !== 2 /* EOF */) {
</ins><span class="cx"> body.push(this.parseStatementListItem());
</span><span class="cx"> }
</span><span class="cx"> return this.finalize(node, new Node.Module(body));
</span><span class="lines">@@ -3247,15 +4777,15 @@
</span><span class="cx"> Parser.prototype.parseScript = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var body = this.parseDirectivePrologues();
</span><del>- while (this.startMarker.index < this.scanner.length) {
</del><ins>+ while (this.lookahead.type !== 2 /* EOF */) {
</ins><span class="cx"> body.push(this.parseStatementListItem());
</span><span class="cx"> }
</span><span class="cx"> return this.finalize(node, new Node.Script(body));
</span><span class="cx"> };
</span><del>- // ECMA-262 15.2.2 Imports
</del><ins>+ // https://tc39.github.io/ecma262/#sec-imports
</ins><span class="cx"> Parser.prototype.parseModuleSpecifier = function () {
</span><span class="cx"> var node = this.createNode();
</span><del>- if (this.lookahead.type !== token_1.Token.StringLiteral) {
</del><ins>+ if (this.lookahead.type !== 8 /* StringLiteral */) {
</ins><span class="cx"> this.throwError(messages_1.Messages.InvalidModuleSpecifier);
</span><span class="cx"> }
</span><span class="cx"> var token = this.nextToken();
</span><span class="lines">@@ -3267,7 +4797,7 @@
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var imported;
</span><span class="cx"> var local;
</span><del>- if (this.lookahead.type === token_1.Token.Identifier) {
</del><ins>+ if (this.lookahead.type === 3 /* Identifier */) {
</ins><span class="cx"> imported = this.parseVariableIdentifier();
</span><span class="cx"> local = imported;
</span><span class="cx"> if (this.matchContextualKeyword('as')) {
</span><span class="lines">@@ -3326,7 +4856,7 @@
</span><span class="cx"> this.expectKeyword('import');
</span><span class="cx"> var src;
</span><span class="cx"> var specifiers = [];
</span><del>- if (this.lookahead.type === token_1.Token.StringLiteral) {
</del><ins>+ if (this.lookahead.type === 8 /* StringLiteral */) {
</ins><span class="cx"> // import 'foo';
</span><span class="cx"> src = this.parseModuleSpecifier();
</span><span class="cx"> }
</span><span class="lines">@@ -3370,7 +4900,7 @@
</span><span class="cx"> this.consumeSemicolon();
</span><span class="cx"> return this.finalize(node, new Node.ImportDeclaration(specifiers, src));
</span><span class="cx"> };
</span><del>- // ECMA-262 15.2.3 Exports
</del><ins>+ // https://tc39.github.io/ecma262/#sec-exports
</ins><span class="cx"> Parser.prototype.parseExportSpecifier = function () {
</span><span class="cx"> var node = this.createNode();
</span><span class="cx"> var local = this.parseIdentifierName();
</span><span class="lines">@@ -3402,6 +4932,13 @@
</span><span class="cx"> var declaration = this.parseClassDeclaration(true);
</span><span class="cx"> exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
</span><span class="cx"> }
</span><ins>+ else if (this.matchContextualKeyword('async')) {
+ // export default async function f () {}
+ // export default async function () {}
+ // export default async x => x
+ var declaration = this.matchAsyncFunction() ? this.parseFunctionDeclaration(true) : this.parseAssignmentExpression();
+ exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
+ }
</ins><span class="cx"> else {
</span><span class="cx"> if (this.matchContextualKeyword('from')) {
</span><span class="cx"> this.throwError(messages_1.Messages.UnexpectedToken, this.lookahead.value);
</span><span class="lines">@@ -3427,7 +4964,7 @@
</span><span class="cx"> this.consumeSemicolon();
</span><span class="cx"> exportDeclaration = this.finalize(node, new Node.ExportAllDeclaration(src));
</span><span class="cx"> }
</span><del>- else if (this.lookahead.type === token_1.Token.Keyword) {
</del><ins>+ else if (this.lookahead.type === 4 /* Keyword */) {
</ins><span class="cx"> // export var f = 1;
</span><span class="cx"> var declaration = void 0;
</span><span class="cx"> switch (this.lookahead.value) {
</span><span class="lines">@@ -3488,7 +5025,7 @@
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> /***/ },
</span><del>-/* 4 */
</del><ins>+/* 9 */
</ins><span class="cx"> /***/ function(module, exports) {
</span><span class="cx">
</span><span class="cx"> // Ensure the condition is true, otherwise throw an error.
</span><span class="lines">@@ -3506,81 +5043,19 @@
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> /***/ },
</span><del>-/* 5 */
</del><ins>+/* 10 */
</ins><span class="cx"> /***/ function(module, exports) {
</span><span class="cx">
</span><ins>+ /* tslint:disable:max-classes-per-file */
</ins><span class="cx"> "use strict";
</span><del>- // 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";
</del><span class="cx"> var ErrorHandler = (function () {
</span><span class="cx"> function ErrorHandler() {
</span><span class="cx"> this.errors = [];
</span><span class="cx"> this.tolerant = false;
</span><span class="cx"> }
</span><del>- ;
</del><span class="cx"> ErrorHandler.prototype.recordError = function (error) {
</span><span class="cx"> this.errors.push(error);
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> ErrorHandler.prototype.tolerate = function (error) {
</span><span class="cx"> if (this.tolerant) {
</span><span class="cx"> this.recordError(error);
</span><span class="lines">@@ -3589,7 +5064,6 @@
</span><span class="cx"> throw error;
</span><span class="cx"> }
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> ErrorHandler.prototype.constructError = function (msg, column) {
</span><span class="cx"> var error = new Error(msg);
</span><span class="cx"> try {
</span><span class="lines">@@ -3602,13 +5076,9 @@
</span><span class="cx"> Object.defineProperty(error, 'column', { value: column });
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- finally {
- return error;
- }
</del><span class="cx"> /* istanbul ignore next */
</span><span class="cx"> return error;
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> ErrorHandler.prototype.createError = function (index, line, col, description) {
</span><span class="cx"> var msg = 'Line ' + line + ': ' + description;
</span><span class="cx"> var error = this.constructError(msg, col);
</span><span class="lines">@@ -3617,11 +5087,9 @@
</span><span class="cx"> error.description = description;
</span><span class="cx"> return error;
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> ErrorHandler.prototype.throwError = function (index, line, col, description) {
</span><span class="cx"> throw this.createError(index, line, col, description);
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> ErrorHandler.prototype.tolerateError = function (index, line, col, description) {
</span><span class="cx"> var error = this.createError(index, line, col, description);
</span><span class="cx"> if (this.tolerant) {
</span><span class="lines">@@ -3631,7 +5099,6 @@
</span><span class="cx"> throw error;
</span><span class="cx"> }
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> return ErrorHandler;
</span><span class="cx"> }());
</span><span class="cx"> exports.ErrorHandler = ErrorHandler;
</span><span class="lines">@@ -3638,46 +5105,84 @@
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> /***/ },
</span><del>-/* 7 */
</del><ins>+/* 11 */
</ins><span class="cx"> /***/ function(module, exports) {
</span><span class="cx">
</span><span class="cx"> "use strict";
</span><del>- (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';
</del><ins>+ // Error messages should be identical to V8.
+ exports.Messages = {
+ BadImportCallArity: 'Unexpected token',
+ BadGetterArity: 'Getter must not have any formal parameters',
+ BadSetterArity: 'Setter must have exactly one formal parameter',
+ BadSetterRestParameter: 'Setter function argument must not be a rest parameter',
+ ConstructorIsAsync: 'Class constructor may not be an async method',
+ ConstructorSpecialMethod: 'Class constructor may not be an accessor',
+ DeclarationMissingInitializer: 'Missing initializer in %0 declaration',
+ DefaultRestParameter: 'Unexpected token =',
+ DefaultRestProperty: 'Unexpected token =',
+ DuplicateBinding: 'Duplicate binding %0',
+ DuplicateConstructor: 'A class may only have one constructor',
+ DuplicateProtoProperty: 'Duplicate __proto__ fields are not allowed in object literals',
+ ForInOfLoopInitializer: '%0 loop variable declaration may not have an initializer',
+ GeneratorInLegacyContext: 'Generator declarations are not allowed in legacy contexts',
+ IllegalBreak: 'Illegal break statement',
+ IllegalContinue: 'Illegal continue statement',
+ IllegalExportDeclaration: 'Unexpected token',
+ IllegalImportDeclaration: 'Unexpected token',
+ IllegalLanguageModeDirective: 'Illegal \'use strict\' directive in function with non-simple parameter list',
+ IllegalReturn: 'Illegal return statement',
+ InvalidEscapedReservedWord: 'Keyword must not contain escaped characters',
+ InvalidHexEscapeSequence: 'Invalid hexadecimal escape sequence',
+ InvalidLHSInAssignment: 'Invalid left-hand side in assignment',
+ InvalidLHSInForIn: 'Invalid left-hand side in for-in',
+ InvalidLHSInForLoop: 'Invalid left-hand side in for-loop',
+ InvalidModuleSpecifier: 'Unexpected token',
+ InvalidRegExp: 'Invalid regular expression',
+ LetInLexicalBinding: 'let is disallowed as a lexically bound name',
+ MissingFromClause: 'Unexpected token',
+ MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
+ NewlineAfterThrow: 'Illegal newline after throw',
+ NoAsAfterImportNamespace: 'Unexpected token',
+ NoCatchOrFinally: 'Missing catch or finally after try',
+ ParameterAfterRestParameter: 'Rest parameter must be last formal parameter',
+ PropertyAfterRestProperty: 'Unexpected token',
+ Redeclaration: '%0 \'%1\' has already been declared',
+ StaticPrototype: 'Classes may not have static property named prototype',
+ StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode',
+ StrictDelete: 'Delete of an unqualified identifier in strict mode.',
+ StrictFunction: 'In strict mode code, functions can only be declared at top level or inside a block',
+ StrictFunctionName: 'Function name may not be eval or arguments 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',
+ StrictModeWith: 'Strict mode code may not include a with statement',
+ StrictOctalLiteral: 'Octal literals are not allowed in strict mode.',
+ StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
+ StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode',
+ StrictReservedWord: 'Use of future reserved word in strict mode',
+ StrictVarName: 'Variable name may not be eval or arguments in strict mode',
+ TemplateOctalLiteral: 'Octal literals are not allowed in template strings.',
+ UnexpectedEOS: 'Unexpected end of input',
+ UnexpectedIdentifier: 'Unexpected identifier',
+ UnexpectedNumber: 'Unexpected number',
+ UnexpectedReserved: 'Unexpected reserved word',
+ UnexpectedString: 'Unexpected string',
+ UnexpectedTemplate: 'Unexpected quasi %0',
+ UnexpectedToken: 'Unexpected token %0',
+ UnexpectedTokenIllegal: 'Unexpected token ILLEGAL',
+ UnknownLabel: 'Undefined label \'%0\'',
+ UnterminatedRegExp: 'Invalid regular expression: missing /'
+ };
</ins><span class="cx">
</span><span class="cx">
</span><span class="cx"> /***/ },
</span><del>-/* 8 */
</del><ins>+/* 12 */
</ins><span class="cx"> /***/ function(module, exports, __webpack_require__) {
</span><span class="cx">
</span><span class="cx"> "use strict";
</span><del>- var assert_1 = __webpack_require__(4);
- var messages_1 = __webpack_require__(5);
- var character_1 = __webpack_require__(9);
- var token_1 = __webpack_require__(7);
</del><ins>+ var assert_1 = __webpack_require__(9);
+ var character_1 = __webpack_require__(4);
+ var messages_1 = __webpack_require__(11);
</ins><span class="cx"> function hexValue(ch) {
</span><span class="cx"> return '0123456789abcdef'.indexOf(ch.toLowerCase());
</span><span class="cx"> }
</span><span class="lines">@@ -3695,21 +5200,30 @@
</span><span class="cx"> this.lineStart = 0;
</span><span class="cx"> this.curlyStack = [];
</span><span class="cx"> }
</span><del>- ;
</del><ins>+ Scanner.prototype.saveState = function () {
+ return {
+ index: this.index,
+ lineNumber: this.lineNumber,
+ lineStart: this.lineStart
+ };
+ };
+ Scanner.prototype.restoreState = function (state) {
+ this.index = state.index;
+ this.lineNumber = state.lineNumber;
+ this.lineStart = state.lineStart;
+ };
</ins><span class="cx"> Scanner.prototype.eof = function () {
</span><span class="cx"> return this.index >= this.length;
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.throwUnexpectedToken = function (message) {
</span><span class="cx"> if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }
</span><del>- this.errorHandler.throwError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
</del><ins>+ return this.errorHandler.throwError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
</ins><span class="cx"> };
</span><del>- ;
- Scanner.prototype.tolerateUnexpectedToken = function () {
- this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, messages_1.Messages.UnexpectedTokenIllegal);
</del><ins>+ Scanner.prototype.tolerateUnexpectedToken = function (message) {
+ if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }
+ this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
</ins><span class="cx"> };
</span><del>- ;
- // ECMA-262 11.4 Comments
</del><ins>+ // https://tc39.github.io/ecma262/#sec-comments
</ins><span class="cx"> Scanner.prototype.skipSingleLineComment = function (offset) {
</span><span class="cx"> var comments = [];
</span><span class="cx"> var start, loc;
</span><span class="lines">@@ -3764,7 +5278,6 @@
</span><span class="cx"> }
</span><span class="cx"> return comments;
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.skipMultiLineComment = function () {
</span><span class="cx"> var comments = [];
</span><span class="cx"> var start, loc;
</span><span class="lines">@@ -3831,7 +5344,6 @@
</span><span class="cx"> this.tolerateUnexpectedToken();
</span><span class="cx"> return comments;
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.scanComments = function () {
</span><span class="cx"> var comments;
</span><span class="cx"> if (this.trackComment) {
</span><span class="lines">@@ -3905,8 +5417,7 @@
</span><span class="cx"> }
</span><span class="cx"> return comments;
</span><span class="cx"> };
</span><del>- ;
- // ECMA-262 11.6.2.2 Future Reserved Words
</del><ins>+ // https://tc39.github.io/ecma262/#sec-future-reserved-words
</ins><span class="cx"> Scanner.prototype.isFutureReservedWord = function (id) {
</span><span class="cx"> switch (id) {
</span><span class="cx"> case 'enum':
</span><span class="lines">@@ -3918,7 +5429,6 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.isStrictModeReservedWord = function (id) {
</span><span class="cx"> switch (id) {
</span><span class="cx"> case 'implements':
</span><span class="lines">@@ -3935,12 +5445,10 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.isRestrictedWord = function (id) {
</span><span class="cx"> return id === 'eval' || id === 'arguments';
</span><span class="cx"> };
</span><del>- ;
- // ECMA-262 11.6.2.1 Keywords
</del><ins>+ // https://tc39.github.io/ecma262/#sec-keywords
</ins><span class="cx"> Scanner.prototype.isKeyword = function (id) {
</span><span class="cx"> switch (id.length) {
</span><span class="cx"> case 2:
</span><span class="lines">@@ -3968,7 +5476,6 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.codePointAt = function (i) {
</span><span class="cx"> var cp = this.source.charCodeAt(i);
</span><span class="cx"> if (cp >= 0xD800 && cp <= 0xDBFF) {
</span><span class="lines">@@ -3980,7 +5487,6 @@
</span><span class="cx"> }
</span><span class="cx"> return cp;
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.scanHexEscape = function (prefix) {
</span><span class="cx"> var len = (prefix === 'u') ? 4 : 2;
</span><span class="cx"> var code = 0;
</span><span class="lines">@@ -3989,12 +5495,11 @@
</span><span class="cx"> code = code * 16 + hexValue(this.source[this.index++]);
</span><span class="cx"> }
</span><span class="cx"> else {
</span><del>- return '';
</del><ins>+ return null;
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> return String.fromCharCode(code);
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.scanUnicodeCodePointEscape = function () {
</span><span class="cx"> var ch = this.source[this.index];
</span><span class="cx"> var code = 0;
</span><span class="lines">@@ -4014,7 +5519,6 @@
</span><span class="cx"> }
</span><span class="cx"> return character_1.Character.fromCodePoint(code);
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.getIdentifier = function () {
</span><span class="cx"> var start = this.index++;
</span><span class="cx"> while (!this.eof()) {
</span><span class="lines">@@ -4038,7 +5542,6 @@
</span><span class="cx"> }
</span><span class="cx"> return this.source.slice(start, this.index);
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.getComplexIdentifier = function () {
</span><span class="cx"> var cp = this.codePointAt(this.index);
</span><span class="cx"> var id = character_1.Character.fromCodePoint(cp);
</span><span class="lines">@@ -4056,8 +5559,7 @@
</span><span class="cx"> }
</span><span class="cx"> else {
</span><span class="cx"> ch = this.scanHexEscape('u');
</span><del>- cp = ch.charCodeAt(0);
- if (!ch || ch === '\\' || !character_1.Character.isIdentifierStart(cp)) {
</del><ins>+ if (ch === null || ch === '\\' || !character_1.Character.isIdentifierStart(ch.charCodeAt(0))) {
</ins><span class="cx"> this.throwUnexpectedToken();
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -4084,8 +5586,7 @@
</span><span class="cx"> }
</span><span class="cx"> else {
</span><span class="cx"> ch = this.scanHexEscape('u');
</span><del>- cp = ch.charCodeAt(0);
- if (!ch || ch === '\\' || !character_1.Character.isIdentifierPart(cp)) {
</del><ins>+ if (ch === null || ch === '\\' || !character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {
</ins><span class="cx"> this.throwUnexpectedToken();
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -4094,7 +5595,6 @@
</span><span class="cx"> }
</span><span class="cx"> return id;
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.octalToDecimal = function (ch) {
</span><span class="cx"> // \0 is not octal escape sequence
</span><span class="cx"> var octal = (ch !== '0');
</span><span class="lines">@@ -4113,8 +5613,7 @@
</span><span class="cx"> octal: octal
</span><span class="cx"> };
</span><span class="cx"> };
</span><del>- ;
- // ECMA-262 11.6 Names and Keywords
</del><ins>+ // https://tc39.github.io/ecma262/#sec-names-and-keywords
</ins><span class="cx"> Scanner.prototype.scanIdentifier = function () {
</span><span class="cx"> var type;
</span><span class="cx"> var start = this.index;
</span><span class="lines">@@ -4123,20 +5622,26 @@
</span><span class="cx"> // There is no keyword or literal with only one character.
</span><span class="cx"> // Thus, it must be an identifier.
</span><span class="cx"> if (id.length === 1) {
</span><del>- type = token_1.Token.Identifier;
</del><ins>+ type = 3 /* Identifier */;
</ins><span class="cx"> }
</span><span class="cx"> else if (this.isKeyword(id)) {
</span><del>- type = token_1.Token.Keyword;
</del><ins>+ type = 4 /* Keyword */;
</ins><span class="cx"> }
</span><span class="cx"> else if (id === 'null') {
</span><del>- type = token_1.Token.NullLiteral;
</del><ins>+ type = 5 /* NullLiteral */;
</ins><span class="cx"> }
</span><span class="cx"> else if (id === 'true' || id === 'false') {
</span><del>- type = token_1.Token.BooleanLiteral;
</del><ins>+ type = 1 /* BooleanLiteral */;
</ins><span class="cx"> }
</span><span class="cx"> else {
</span><del>- type = token_1.Token.Identifier;
</del><ins>+ type = 3 /* Identifier */;
</ins><span class="cx"> }
</span><ins>+ if (type !== 3 /* Identifier */ && (start + id.length !== this.index)) {
+ var restore = this.index;
+ this.index = start;
+ this.tolerateUnexpectedToken(messages_1.Messages.InvalidEscapedReservedWord);
+ this.index = restore;
+ }
</ins><span class="cx"> return {
</span><span class="cx"> type: type,
</span><span class="cx"> value: id,
</span><span class="lines">@@ -4146,17 +5651,9 @@
</span><span class="cx"> end: this.index
</span><span class="cx"> };
</span><span class="cx"> };
</span><del>- ;
- // ECMA-262 11.7 Punctuators
</del><ins>+ // https://tc39.github.io/ecma262/#sec-punctuators
</ins><span class="cx"> Scanner.prototype.scanPunctuator = function () {
</span><del>- var token = {
- type: token_1.Token.Punctuator,
- value: '',
- lineNumber: this.lineNumber,
- lineStart: this.lineStart,
- start: this.index,
- end: this.index
- };
</del><ins>+ var start = this.index;
</ins><span class="cx"> // Check for most common single-character punctuators.
</span><span class="cx"> var str = this.source[this.index];
</span><span class="cx"> switch (str) {
</span><span class="lines">@@ -4222,24 +5719,28 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- if (this.index === token.start) {
</del><ins>+ if (this.index === start) {
</ins><span class="cx"> this.throwUnexpectedToken();
</span><span class="cx"> }
</span><del>- token.end = this.index;
- token.value = str;
- return token;
</del><ins>+ return {
+ type: 7 /* Punctuator */,
+ value: str,
+ lineNumber: this.lineNumber,
+ lineStart: this.lineStart,
+ start: start,
+ end: this.index
+ };
</ins><span class="cx"> };
</span><del>- ;
- // ECMA-262 11.8.3 Numeric Literals
</del><ins>+ // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
</ins><span class="cx"> Scanner.prototype.scanHexLiteral = function (start) {
</span><del>- var number = '';
</del><ins>+ var num = '';
</ins><span class="cx"> while (!this.eof()) {
</span><span class="cx"> if (!character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- number += this.source[this.index++];
</del><ins>+ num += this.source[this.index++];
</ins><span class="cx"> }
</span><del>- if (number.length === 0) {
</del><ins>+ if (num.length === 0) {
</ins><span class="cx"> this.throwUnexpectedToken();
</span><span class="cx"> }
</span><span class="cx"> if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {
</span><span class="lines">@@ -4246,8 +5747,8 @@
</span><span class="cx"> this.throwUnexpectedToken();
</span><span class="cx"> }
</span><span class="cx"> return {
</span><del>- type: token_1.Token.NumericLiteral,
- value: parseInt('0x' + number, 16),
</del><ins>+ type: 6 /* NumericLiteral */,
+ value: parseInt('0x' + num, 16),
</ins><span class="cx"> lineNumber: this.lineNumber,
</span><span class="cx"> lineStart: this.lineStart,
</span><span class="cx"> start: start,
</span><span class="lines">@@ -4254,9 +5755,8 @@
</span><span class="cx"> end: this.index
</span><span class="cx"> };
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.scanBinaryLiteral = function (start) {
</span><del>- var number = '';
</del><ins>+ var num = '';
</ins><span class="cx"> var ch;
</span><span class="cx"> while (!this.eof()) {
</span><span class="cx"> ch = this.source[this.index];
</span><span class="lines">@@ -4263,9 +5763,9 @@
</span><span class="cx"> if (ch !== '0' && ch !== '1') {
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- number += this.source[this.index++];
</del><ins>+ num += this.source[this.index++];
</ins><span class="cx"> }
</span><del>- if (number.length === 0) {
</del><ins>+ if (num.length === 0) {
</ins><span class="cx"> // only 0b or 0B
</span><span class="cx"> this.throwUnexpectedToken();
</span><span class="cx"> }
</span><span class="lines">@@ -4277,8 +5777,8 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> return {
</span><del>- type: token_1.Token.NumericLiteral,
- value: parseInt(number, 2),
</del><ins>+ type: 6 /* NumericLiteral */,
+ value: parseInt(num, 2),
</ins><span class="cx"> lineNumber: this.lineNumber,
</span><span class="cx"> lineStart: this.lineStart,
</span><span class="cx"> start: start,
</span><span class="lines">@@ -4285,13 +5785,12 @@
</span><span class="cx"> end: this.index
</span><span class="cx"> };
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.scanOctalLiteral = function (prefix, start) {
</span><del>- var number = '';
</del><ins>+ var num = '';
</ins><span class="cx"> var octal = false;
</span><span class="cx"> if (character_1.Character.isOctalDigit(prefix.charCodeAt(0))) {
</span><span class="cx"> octal = true;
</span><del>- number = '0' + this.source[this.index++];
</del><ins>+ num = '0' + this.source[this.index++];
</ins><span class="cx"> }
</span><span class="cx"> else {
</span><span class="cx"> ++this.index;
</span><span class="lines">@@ -4300,9 +5799,9 @@
</span><span class="cx"> if (!character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- number += this.source[this.index++];
</del><ins>+ num += this.source[this.index++];
</ins><span class="cx"> }
</span><del>- if (!octal && number.length === 0) {
</del><ins>+ if (!octal && num.length === 0) {
</ins><span class="cx"> // only 0o or 0O
</span><span class="cx"> this.throwUnexpectedToken();
</span><span class="cx"> }
</span><span class="lines">@@ -4310,8 +5809,8 @@
</span><span class="cx"> this.throwUnexpectedToken();
</span><span class="cx"> }
</span><span class="cx"> return {
</span><del>- type: token_1.Token.NumericLiteral,
- value: parseInt(number, 8),
</del><ins>+ type: 6 /* NumericLiteral */,
+ value: parseInt(num, 8),
</ins><span class="cx"> octal: octal,
</span><span class="cx"> lineNumber: this.lineNumber,
</span><span class="cx"> lineStart: this.lineStart,
</span><span class="lines">@@ -4319,7 +5818,6 @@
</span><span class="cx"> end: this.index
</span><span class="cx"> };
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.isImplicitOctalLiteral = function () {
</span><span class="cx"> // Implicit octal, unless there is a non-octal digit.
</span><span class="cx"> // (Annex B.1.1 on Numeric Literals)
</span><span class="lines">@@ -4334,20 +5832,19 @@
</span><span class="cx"> }
</span><span class="cx"> return true;
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.scanNumericLiteral = function () {
</span><span class="cx"> var start = this.index;
</span><span class="cx"> var ch = this.source[start];
</span><span class="cx"> assert_1.assert(character_1.Character.isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'), 'Numeric literal must start with a decimal digit or a decimal point');
</span><del>- var number = '';
</del><ins>+ var num = '';
</ins><span class="cx"> if (ch !== '.') {
</span><del>- number = this.source[this.index++];
</del><ins>+ num = this.source[this.index++];
</ins><span class="cx"> ch = this.source[this.index];
</span><span class="cx"> // Hex number starts with '0x'.
</span><span class="cx"> // Octal number starts with '0'.
</span><span class="cx"> // Octal number in ES6 starts with '0o'.
</span><span class="cx"> // Binary number in ES6 starts with '0b'.
</span><del>- if (number === '0') {
</del><ins>+ if (num === '0') {
</ins><span class="cx"> if (ch === 'x' || ch === 'X') {
</span><span class="cx"> ++this.index;
</span><span class="cx"> return this.scanHexLiteral(start);
</span><span class="lines">@@ -4366,26 +5863,26 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
</span><del>- number += this.source[this.index++];
</del><ins>+ num += this.source[this.index++];
</ins><span class="cx"> }
</span><span class="cx"> ch = this.source[this.index];
</span><span class="cx"> }
</span><span class="cx"> if (ch === '.') {
</span><del>- number += this.source[this.index++];
</del><ins>+ num += this.source[this.index++];
</ins><span class="cx"> while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
</span><del>- number += this.source[this.index++];
</del><ins>+ num += this.source[this.index++];
</ins><span class="cx"> }
</span><span class="cx"> ch = this.source[this.index];
</span><span class="cx"> }
</span><span class="cx"> if (ch === 'e' || ch === 'E') {
</span><del>- number += this.source[this.index++];
</del><ins>+ num += this.source[this.index++];
</ins><span class="cx"> ch = this.source[this.index];
</span><span class="cx"> if (ch === '+' || ch === '-') {
</span><del>- number += this.source[this.index++];
</del><ins>+ num += this.source[this.index++];
</ins><span class="cx"> }
</span><span class="cx"> if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
</span><span class="cx"> while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
</span><del>- number += this.source[this.index++];
</del><ins>+ num += this.source[this.index++];
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> else {
</span><span class="lines">@@ -4396,8 +5893,8 @@
</span><span class="cx"> this.throwUnexpectedToken();
</span><span class="cx"> }
</span><span class="cx"> return {
</span><del>- type: token_1.Token.NumericLiteral,
- value: parseFloat(number),
</del><ins>+ type: 6 /* NumericLiteral */,
+ value: parseFloat(num),
</ins><span class="cx"> lineNumber: this.lineNumber,
</span><span class="cx"> lineStart: this.lineStart,
</span><span class="cx"> start: start,
</span><span class="lines">@@ -4404,8 +5901,7 @@
</span><span class="cx"> end: this.index
</span><span class="cx"> };
</span><span class="cx"> };
</span><del>- ;
- // ECMA-262 11.8.4 String Literals
</del><ins>+ // https://tc39.github.io/ecma262/#sec-literals-string-literals
</ins><span class="cx"> Scanner.prototype.scanStringLiteral = function () {
</span><span class="cx"> var start = this.index;
</span><span class="cx"> var quote = this.source[start];
</span><span class="lines">@@ -4424,19 +5920,25 @@
</span><span class="cx"> if (!ch || !character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
</span><span class="cx"> switch (ch) {
</span><span class="cx"> case 'u':
</span><del>- case 'x':
</del><span class="cx"> if (this.source[this.index] === '{') {
</span><span class="cx"> ++this.index;
</span><span class="cx"> str += this.scanUnicodeCodePointEscape();
</span><span class="cx"> }
</span><span class="cx"> else {
</span><del>- var unescaped = this.scanHexEscape(ch);
- if (!unescaped) {
</del><ins>+ var unescaped_1 = this.scanHexEscape(ch);
+ if (unescaped_1 === null) {
</ins><span class="cx"> this.throwUnexpectedToken();
</span><span class="cx"> }
</span><del>- str += unescaped;
</del><ins>+ str += unescaped_1;
</ins><span class="cx"> }
</span><span class="cx"> break;
</span><ins>+ case 'x':
+ var unescaped = this.scanHexEscape(ch);
+ if (unescaped === null) {
+ this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);
+ }
+ str += unescaped;
+ break;
</ins><span class="cx"> case 'n':
</span><span class="cx"> str += '\n';
</span><span class="cx"> break;
</span><span class="lines">@@ -4492,7 +5994,7 @@
</span><span class="cx"> this.throwUnexpectedToken();
</span><span class="cx"> }
</span><span class="cx"> return {
</span><del>- type: token_1.Token.StringLiteral,
</del><ins>+ type: 8 /* StringLiteral */,
</ins><span class="cx"> value: str,
</span><span class="cx"> octal: octal,
</span><span class="cx"> lineNumber: this.lineNumber,
</span><span class="lines">@@ -4501,8 +6003,7 @@
</span><span class="cx"> end: this.index
</span><span class="cx"> };
</span><span class="cx"> };
</span><del>- ;
- // ECMA-262 11.8.6 Template Literal Lexical Components
</del><ins>+ // https://tc39.github.io/ecma262/#sec-template-literal-lexical-components
</ins><span class="cx"> Scanner.prototype.scanTemplate = function () {
</span><span class="cx"> var cooked = '';
</span><span class="cx"> var terminated = false;
</span><span class="lines">@@ -4542,7 +6043,6 @@
</span><span class="cx"> cooked += '\t';
</span><span class="cx"> break;
</span><span class="cx"> case 'u':
</span><del>- case 'x':
</del><span class="cx"> if (this.source[this.index] === '{') {
</span><span class="cx"> ++this.index;
</span><span class="cx"> cooked += this.scanUnicodeCodePointEscape();
</span><span class="lines">@@ -4549,9 +6049,9 @@
</span><span class="cx"> }
</span><span class="cx"> else {
</span><span class="cx"> var restore = this.index;
</span><del>- var unescaped = this.scanHexEscape(ch);
- if (unescaped) {
- cooked += unescaped;
</del><ins>+ var unescaped_2 = this.scanHexEscape(ch);
+ if (unescaped_2 !== null) {
+ cooked += unescaped_2;
</ins><span class="cx"> }
</span><span class="cx"> else {
</span><span class="cx"> this.index = restore;
</span><span class="lines">@@ -4559,6 +6059,13 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> break;
</span><ins>+ case 'x':
+ var unescaped = this.scanHexEscape(ch);
+ if (unescaped === null) {
+ this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);
+ }
+ cooked += unescaped;
+ break;
</ins><span class="cx"> case 'b':
</span><span class="cx"> cooked += '\b';
</span><span class="cx"> break;
</span><span class="lines">@@ -4613,11 +6120,9 @@
</span><span class="cx"> this.curlyStack.pop();
</span><span class="cx"> }
</span><span class="cx"> return {
</span><del>- type: token_1.Token.Template,
- value: {
- cooked: cooked,
- raw: this.source.slice(start + 1, this.index - rawOffset)
- },
</del><ins>+ type: 10 /* Template */,
+ value: this.source.slice(start + 1, this.index - rawOffset),
+ cooked: cooked,
</ins><span class="cx"> head: head,
</span><span class="cx"> tail: tail,
</span><span class="cx"> lineNumber: this.lineNumber,
</span><span class="lines">@@ -4626,8 +6131,7 @@
</span><span class="cx"> end: this.index
</span><span class="cx"> };
</span><span class="cx"> };
</span><del>- ;
- // ECMA-262 11.8.5 Regular Expression Literals
</del><ins>+ // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals
</ins><span class="cx"> Scanner.prototype.testRegExp = function (pattern, flags) {
</span><span class="cx"> // The BMP character to use as a replacement for astral symbols when
</span><span class="cx"> // translating an ES6 "u"-flagged pattern to an ES5-compatible
</span><span class="lines">@@ -4670,7 +6174,6 @@
</span><span class="cx"> return null;
</span><span class="cx"> }
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.scanRegExpBody = function () {
</span><span class="cx"> var ch = this.source[this.index];
</span><span class="cx"> assert_1.assert(ch === '/', 'Regular expression literal must start with a slash');
</span><span class="lines">@@ -4682,7 +6185,7 @@
</span><span class="cx"> str += ch;
</span><span class="cx"> if (ch === '\\') {
</span><span class="cx"> ch = this.source[this.index++];
</span><del>- // ECMA-262 7.8.5
</del><ins>+ // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals
</ins><span class="cx"> if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
</span><span class="cx"> this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
</span><span class="cx"> }
</span><span class="lines">@@ -4710,13 +6213,8 @@
</span><span class="cx"> this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
</span><span class="cx"> }
</span><span class="cx"> // Exclude leading and trailing slash.
</span><del>- var body = str.substr(1, str.length - 2);
- return {
- value: body,
- literal: str
- };
</del><ins>+ return str.substr(1, str.length - 2);
</ins><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.scanRegExpFlags = function () {
</span><span class="cx"> var str = '';
</span><span class="cx"> var flags = '';
</span><span class="lines">@@ -4731,9 +6229,9 @@
</span><span class="cx"> if (ch === 'u') {
</span><span class="cx"> ++this.index;
</span><span class="cx"> var restore = this.index;
</span><del>- ch = this.scanHexEscape('u');
- if (ch) {
- flags += ch;
</del><ins>+ var char = this.scanHexEscape('u');
+ if (char !== null) {
+ flags += char;
</ins><span class="cx"> for (str += '\\u'; restore < this.index; ++restore) {
</span><span class="cx"> str += this.source[restore];
</span><span class="cx"> }
</span><span class="lines">@@ -4755,25 +6253,19 @@
</span><span class="cx"> str += ch;
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- return {
- value: flags,
- literal: str
- };
</del><ins>+ return flags;
</ins><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.scanRegExp = function () {
</span><span class="cx"> var start = this.index;
</span><del>- var body = this.scanRegExpBody();
</del><ins>+ var pattern = this.scanRegExpBody();
</ins><span class="cx"> var flags = this.scanRegExpFlags();
</span><del>- var value = this.testRegExp(body.value, flags.value);
</del><ins>+ var value = this.testRegExp(pattern, flags);
</ins><span class="cx"> return {
</span><del>- type: token_1.Token.RegularExpression,
- value: value,
- literal: body.literal + flags.literal,
- regex: {
- pattern: body.value,
- flags: flags.value
- },
</del><ins>+ type: 9 /* RegularExpression */,
+ value: '',
+ pattern: pattern,
+ flags: flags,
+ regex: value,
</ins><span class="cx"> lineNumber: this.lineNumber,
</span><span class="cx"> lineStart: this.lineStart,
</span><span class="cx"> start: start,
</span><span class="lines">@@ -4780,11 +6272,11 @@
</span><span class="cx"> end: this.index
</span><span class="cx"> };
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Scanner.prototype.lex = function () {
</span><span class="cx"> if (this.eof()) {
</span><span class="cx"> return {
</span><del>- type: token_1.Token.EOF,
</del><ins>+ type: 2 /* EOF */,
+ value: '',
</ins><span class="cx"> lineNumber: this.lineNumber,
</span><span class="cx"> lineStart: this.lineStart,
</span><span class="cx"> start: this.index,
</span><span class="lines">@@ -4827,7 +6319,6 @@
</span><span class="cx"> }
</span><span class="cx"> return this.scanPunctuator();
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> return Scanner;
</span><span class="cx"> }());
</span><span class="cx"> exports.Scanner = Scanner;
</span><span class="lines">@@ -4834,1283 +6325,26 @@
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> /***/ },
</span><del>-/* 9 */
</del><ins>+/* 13 */
</ins><span class="cx"> /***/ function(module, exports) {
</span><span class="cx">
</span><span class="cx"> "use strict";
</span><del>- // See also tools/generate-unicode-regex.js.
- var Regex = {
- // Unicode v8.0.0 NonAsciiIdentifierStart:
- NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5
C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\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-\u12C
5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\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\u2071\u207F\u2090-\u209C\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-\u2CEE\u2CF2\u2CF3\u2D0
0-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB
\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\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\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\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\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0
-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\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\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD
07-\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]|\uD83A[\uDC00-\uDCC4]|\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]/,
- // Unicode v8.0.0 NonAsciiIdentifierPart:
- 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-\u0DD
4\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-\u
191E\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\u3
021-\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\uF
E76-\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\uDC9
D\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]|\uD
86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/
- };
- exports.Character = {
- 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
- 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
- isLineTerminator: function (cp) {
- return (cp === 0x0A) || (cp === 0x0D) || (cp === 0x2028) || (cp === 0x2029);
- },
- // ECMA-262 11.6 Identifier Names and Identifiers
- isIdentifierStart: function (cp) {
- return (cp === 0x24) || (cp === 0x5F) ||
- (cp >= 0x41 && cp <= 0x5A) ||
- (cp >= 0x61 && cp <= 0x7A) ||
- (cp === 0x5C) ||
- ((cp >= 0x80) && Regex.NonAsciiIdentifierStart.test(exports.Character.fromCodePoint(cp)));
- },
- isIdentifierPart: function (cp) {
- return (cp === 0x24) || (cp === 0x5F) ||
- (cp >= 0x41 && cp <= 0x5A) ||
- (cp >= 0x61 && cp <= 0x7A) ||
- (cp >= 0x30 && cp <= 0x39) ||
- (cp === 0x5C) ||
- ((cp >= 0x80) && Regex.NonAsciiIdentifierPart.test(exports.Character.fromCodePoint(cp)));
- },
- // ECMA-262 11.8.3 Numeric Literals
- isDecimalDigit: function (cp) {
- return (cp >= 0x30 && cp <= 0x39); // 0..9
- },
- isHexDigit: function (cp) {
- return (cp >= 0x30 && cp <= 0x39) ||
- (cp >= 0x41 && cp <= 0x46) ||
- (cp >= 0x61 && cp <= 0x66); // a..f
- },
- isOctalDigit: function (cp) {
- return (cp >= 0x30 && cp <= 0x37); // 0..7
- }
- };
</del><ins>+ ;
+ exports.TokenName = {};
+ exports.TokenName[1 /* BooleanLiteral */] = 'Boolean';
+ exports.TokenName[2 /* EOF */] = '<end>';
+ exports.TokenName[3 /* Identifier */] = 'Identifier';
+ exports.TokenName[4 /* Keyword */] = 'Keyword';
+ exports.TokenName[5 /* NullLiteral */] = 'Null';
+ exports.TokenName[6 /* NumericLiteral */] = 'Numeric';
+ exports.TokenName[7 /* Punctuator */] = 'Punctuator';
+ exports.TokenName[8 /* StringLiteral */] = 'String';
+ exports.TokenName[9 /* RegularExpression */] = 'RegularExpression';
+ exports.TokenName[10 /* Template */] = 'Template';
</ins><span class="cx">
</span><span class="cx">
</span><span class="cx"> /***/ },
</span><del>-/* 10 */
-/***/ function(module, exports, __webpack_require__) {
-
- "use strict";
- var syntax_1 = __webpack_require__(2);
- var ArrayExpression = (function () {
- function ArrayExpression(elements) {
- this.type = syntax_1.Syntax.ArrayExpression;
- this.elements = elements;
- }
- return ArrayExpression;
- }());
- exports.ArrayExpression = ArrayExpression;
- var ArrayPattern = (function () {
- function ArrayPattern(elements) {
- this.type = syntax_1.Syntax.ArrayPattern;
- this.elements = elements;
- }
- return ArrayPattern;
- }());
- exports.ArrayPattern = ArrayPattern;
- var ArrowFunctionExpression = (function () {
- function ArrowFunctionExpression(params, body, expression) {
- this.type = syntax_1.Syntax.ArrowFunctionExpression;
- this.id = null;
- this.params = params;
- this.body = body;
- this.generator = false;
- this.expression = expression;
- this.async = false;
- }
- return ArrowFunctionExpression;
- }());
- exports.ArrowFunctionExpression = ArrowFunctionExpression;
- var AssignmentExpression = (function () {
- function AssignmentExpression(operator, left, right) {
- this.type = syntax_1.Syntax.AssignmentExpression;
- this.operator = operator;
- this.left = left;
- this.right = right;
- }
- return AssignmentExpression;
- }());
- exports.AssignmentExpression = AssignmentExpression;
- var AssignmentPattern = (function () {
- function AssignmentPattern(left, right) {
- this.type = syntax_1.Syntax.AssignmentPattern;
- this.left = left;
- this.right = right;
- }
- return AssignmentPattern;
- }());
- exports.AssignmentPattern = AssignmentPattern;
- var AsyncArrowFunctionExpression = (function () {
- function AsyncArrowFunctionExpression(params, body, expression) {
- this.type = syntax_1.Syntax.ArrowFunctionExpression;
- this.id = null;
- this.params = params;
- this.body = body;
- this.generator = false;
- this.expression = expression;
- this.async = true;
- }
- return AsyncArrowFunctionExpression;
- }());
- exports.AsyncArrowFunctionExpression = AsyncArrowFunctionExpression;
- var AsyncFunctionDeclaration = (function () {
- function AsyncFunctionDeclaration(id, params, body) {
- this.type = syntax_1.Syntax.FunctionDeclaration;
- this.id = id;
- this.params = params;
- this.body = body;
- this.generator = false;
- this.expression = false;
- this.async = true;
- }
- return AsyncFunctionDeclaration;
- }());
- exports.AsyncFunctionDeclaration = AsyncFunctionDeclaration;
- var AsyncFunctionExpression = (function () {
- function AsyncFunctionExpression(id, params, body) {
- this.type = syntax_1.Syntax.FunctionExpression;
- this.id = id;
- this.params = params;
- this.body = body;
- this.generator = false;
- this.expression = false;
- this.async = true;
- }
- return AsyncFunctionExpression;
- }());
- exports.AsyncFunctionExpression = AsyncFunctionExpression;
- var AwaitExpression = (function () {
- function AwaitExpression(argument) {
- this.type = syntax_1.Syntax.AwaitExpression;
- this.argument = argument;
- }
- return AwaitExpression;
- }());
- exports.AwaitExpression = AwaitExpression;
- var BinaryExpression = (function () {
- function BinaryExpression(operator, left, right) {
- var logical = (operator === '||' || operator === '&&');
- this.type = logical ? syntax_1.Syntax.LogicalExpression : syntax_1.Syntax.BinaryExpression;
- this.operator = operator;
- this.left = left;
- this.right = right;
- }
- return BinaryExpression;
- }());
- exports.BinaryExpression = BinaryExpression;
- var BlockStatement = (function () {
- function BlockStatement(body) {
- this.type = syntax_1.Syntax.BlockStatement;
- this.body = body;
- }
- return BlockStatement;
- }());
- exports.BlockStatement = BlockStatement;
- var BreakStatement = (function () {
- function BreakStatement(label) {
- this.type = syntax_1.Syntax.BreakStatement;
- this.label = label;
- }
- return BreakStatement;
- }());
- exports.BreakStatement = BreakStatement;
- var CallExpression = (function () {
- function CallExpression(callee, args) {
- this.type = syntax_1.Syntax.CallExpression;
- this.callee = callee;
- this.arguments = args;
- }
- return CallExpression;
- }());
- exports.CallExpression = CallExpression;
- var CatchClause = (function () {
- function CatchClause(param, body) {
- this.type = syntax_1.Syntax.CatchClause;
- this.param = param;
- this.body = body;
- }
- return CatchClause;
- }());
- exports.CatchClause = CatchClause;
- var ClassBody = (function () {
- function ClassBody(body) {
- this.type = syntax_1.Syntax.ClassBody;
- this.body = body;
- }
- return ClassBody;
- }());
- exports.ClassBody = ClassBody;
- var ClassDeclaration = (function () {
- function ClassDeclaration(id, superClass, body) {
- this.type = syntax_1.Syntax.ClassDeclaration;
- this.id = id;
- this.superClass = superClass;
- this.body = body;
- }
- return ClassDeclaration;
- }());
- exports.ClassDeclaration = ClassDeclaration;
- var ClassExpression = (function () {
- function ClassExpression(id, superClass, body) {
- this.type = syntax_1.Syntax.ClassExpression;
- this.id = id;
- this.superClass = superClass;
- this.body = body;
- }
- return ClassExpression;
- }());
- exports.ClassExpression = ClassExpression;
- var ComputedMemberExpression = (function () {
- function ComputedMemberExpression(object, property) {
- this.type = syntax_1.Syntax.MemberExpression;
- this.computed = true;
- this.object = object;
- this.property = property;
- }
- return ComputedMemberExpression;
- }());
- exports.ComputedMemberExpression = ComputedMemberExpression;
- var ConditionalExpression = (function () {
- function ConditionalExpression(test, consequent, alternate) {
- this.type = syntax_1.Syntax.ConditionalExpression;
- this.test = test;
- this.consequent = consequent;
- this.alternate = alternate;
- }
- return ConditionalExpression;
- }());
- exports.ConditionalExpression = ConditionalExpression;
- var ContinueStatement = (function () {
- function ContinueStatement(label) {
- this.type = syntax_1.Syntax.ContinueStatement;
- this.label = label;
- }
- return ContinueStatement;
- }());
- exports.ContinueStatement = ContinueStatement;
- var DebuggerStatement = (function () {
- function DebuggerStatement() {
- this.type = syntax_1.Syntax.DebuggerStatement;
- }
- return DebuggerStatement;
- }());
- exports.DebuggerStatement = DebuggerStatement;
- var Directive = (function () {
- function Directive(expression, directive) {
- this.type = syntax_1.Syntax.ExpressionStatement;
- this.expression = expression;
- this.directive = directive;
- }
- return Directive;
- }());
- exports.Directive = Directive;
- var DoWhileStatement = (function () {
- function DoWhileStatement(body, test) {
- this.type = syntax_1.Syntax.DoWhileStatement;
- this.body = body;
- this.test = test;
- }
- return DoWhileStatement;
- }());
- exports.DoWhileStatement = DoWhileStatement;
- var EmptyStatement = (function () {
- function EmptyStatement() {
- this.type = syntax_1.Syntax.EmptyStatement;
- }
- return EmptyStatement;
- }());
- exports.EmptyStatement = EmptyStatement;
- var ExportAllDeclaration = (function () {
- function ExportAllDeclaration(source) {
- this.type = syntax_1.Syntax.ExportAllDeclaration;
- this.source = source;
- }
- return ExportAllDeclaration;
- }());
- exports.ExportAllDeclaration = ExportAllDeclaration;
- var ExportDefaultDeclaration = (function () {
- function ExportDefaultDeclaration(declaration) {
- this.type = syntax_1.Syntax.ExportDefaultDeclaration;
- this.declaration = declaration;
- }
- return ExportDefaultDeclaration;
- }());
- exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
- var ExportNamedDeclaration = (function () {
- function ExportNamedDeclaration(declaration, specifiers, source) {
- this.type = syntax_1.Syntax.ExportNamedDeclaration;
- this.declaration = declaration;
- this.specifiers = specifiers;
- this.source = source;
- }
- return ExportNamedDeclaration;
- }());
- exports.ExportNamedDeclaration = ExportNamedDeclaration;
- var ExportSpecifier = (function () {
- function ExportSpecifier(local, exported) {
- this.type = syntax_1.Syntax.ExportSpecifier;
- this.exported = exported;
- this.local = local;
- }
- return ExportSpecifier;
- }());
- exports.ExportSpecifier = ExportSpecifier;
- var ExpressionStatement = (function () {
- function ExpressionStatement(expression) {
- this.type = syntax_1.Syntax.ExpressionStatement;
- this.expression = expression;
- }
- return ExpressionStatement;
- }());
- exports.ExpressionStatement = ExpressionStatement;
- var ForInStatement = (function () {
- function ForInStatement(left, right, body) {
- this.type = syntax_1.Syntax.ForInStatement;
- this.left = left;
- this.right = right;
- this.body = body;
- this.each = false;
- }
- return ForInStatement;
- }());
- exports.ForInStatement = ForInStatement;
- var ForOfStatement = (function () {
- function ForOfStatement(left, right, body) {
- this.type = syntax_1.Syntax.ForOfStatement;
- this.left = left;
- this.right = right;
- this.body = body;
- }
- return ForOfStatement;
- }());
- exports.ForOfStatement = ForOfStatement;
- var ForStatement = (function () {
- function ForStatement(init, test, update, body) {
- this.type = syntax_1.Syntax.ForStatement;
- this.init = init;
- this.test = test;
- this.update = update;
- this.body = body;
- }
- return ForStatement;
- }());
- exports.ForStatement = ForStatement;
- var FunctionDeclaration = (function () {
- function FunctionDeclaration(id, params, body, generator) {
- this.type = syntax_1.Syntax.FunctionDeclaration;
- this.id = id;
- this.params = params;
- this.body = body;
- this.generator = generator;
- this.expression = false;
- this.async = false;
- }
- return FunctionDeclaration;
- }());
- exports.FunctionDeclaration = FunctionDeclaration;
- var FunctionExpression = (function () {
- function FunctionExpression(id, params, body, generator) {
- this.type = syntax_1.Syntax.FunctionExpression;
- this.id = id;
- this.params = params;
- this.body = body;
- this.generator = generator;
- this.expression = false;
- this.async = false;
- }
- return FunctionExpression;
- }());
- exports.FunctionExpression = FunctionExpression;
- var Identifier = (function () {
- function Identifier(name) {
- this.type = syntax_1.Syntax.Identifier;
- this.name = name;
- }
- return Identifier;
- }());
- exports.Identifier = Identifier;
- var IfStatement = (function () {
- function IfStatement(test, consequent, alternate) {
- this.type = syntax_1.Syntax.IfStatement;
- this.test = test;
- this.consequent = consequent;
- this.alternate = alternate;
- }
- return IfStatement;
- }());
- exports.IfStatement = IfStatement;
- var ImportDeclaration = (function () {
- function ImportDeclaration(specifiers, source) {
- this.type = syntax_1.Syntax.ImportDeclaration;
- this.specifiers = specifiers;
- this.source = source;
- }
- return ImportDeclaration;
- }());
- exports.ImportDeclaration = ImportDeclaration;
- var ImportDefaultSpecifier = (function () {
- function ImportDefaultSpecifier(local) {
- this.type = syntax_1.Syntax.ImportDefaultSpecifier;
- this.local = local;
- }
- return ImportDefaultSpecifier;
- }());
- exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
- var ImportNamespaceSpecifier = (function () {
- function ImportNamespaceSpecifier(local) {
- this.type = syntax_1.Syntax.ImportNamespaceSpecifier;
- this.local = local;
- }
- return ImportNamespaceSpecifier;
- }());
- exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
- var ImportSpecifier = (function () {
- function ImportSpecifier(local, imported) {
- this.type = syntax_1.Syntax.ImportSpecifier;
- this.local = local;
- this.imported = imported;
- }
- return ImportSpecifier;
- }());
- exports.ImportSpecifier = ImportSpecifier;
- var LabeledStatement = (function () {
- function LabeledStatement(label, body) {
- this.type = syntax_1.Syntax.LabeledStatement;
- this.label = label;
- this.body = body;
- }
- return LabeledStatement;
- }());
- exports.LabeledStatement = LabeledStatement;
- var Literal = (function () {
- function Literal(value, raw) {
- this.type = syntax_1.Syntax.Literal;
- this.value = value;
- this.raw = raw;
- }
- return Literal;
- }());
- exports.Literal = Literal;
- var MetaProperty = (function () {
- function MetaProperty(meta, property) {
- this.type = syntax_1.Syntax.MetaProperty;
- this.meta = meta;
- this.property = property;
- }
- return MetaProperty;
- }());
- exports.MetaProperty = MetaProperty;
- var MethodDefinition = (function () {
- function MethodDefinition(key, computed, value, kind, isStatic) {
- this.type = syntax_1.Syntax.MethodDefinition;
- this.key = key;
- this.computed = computed;
- this.value = value;
- this.kind = kind;
- this.static = isStatic;
- }
- return MethodDefinition;
- }());
- exports.MethodDefinition = MethodDefinition;
- var Module = (function () {
- function Module(body) {
- this.type = syntax_1.Syntax.Program;
- this.body = body;
- this.sourceType = 'module';
- }
- return Module;
- }());
- exports.Module = Module;
- var NewExpression = (function () {
- function NewExpression(callee, args) {
- this.type = syntax_1.Syntax.NewExpression;
- this.callee = callee;
- this.arguments = args;
- }
- return NewExpression;
- }());
- exports.NewExpression = NewExpression;
- var ObjectExpression = (function () {
- function ObjectExpression(properties) {
- this.type = syntax_1.Syntax.ObjectExpression;
- this.properties = properties;
- }
- return ObjectExpression;
- }());
- exports.ObjectExpression = ObjectExpression;
- var ObjectPattern = (function () {
- function ObjectPattern(properties) {
- this.type = syntax_1.Syntax.ObjectPattern;
- this.properties = properties;
- }
- return ObjectPattern;
- }());
- exports.ObjectPattern = ObjectPattern;
- var Property = (function () {
- function Property(kind, key, computed, value, method, shorthand) {
- this.type = syntax_1.Syntax.Property;
- this.key = key;
- this.computed = computed;
- this.value = value;
- this.kind = kind;
- this.method = method;
- this.shorthand = shorthand;
- }
- return Property;
- }());
- exports.Property = Property;
- var RegexLiteral = (function () {
- function RegexLiteral(value, raw, regex) {
- this.type = syntax_1.Syntax.Literal;
- this.value = value;
- this.raw = raw;
- this.regex = regex;
- }
- return RegexLiteral;
- }());
- exports.RegexLiteral = RegexLiteral;
- var RestElement = (function () {
- function RestElement(argument) {
- this.type = syntax_1.Syntax.RestElement;
- this.argument = argument;
- }
- return RestElement;
- }());
- exports.RestElement = RestElement;
- var ReturnStatement = (function () {
- function ReturnStatement(argument) {
- this.type = syntax_1.Syntax.ReturnStatement;
- this.argument = argument;
- }
- return ReturnStatement;
- }());
- exports.ReturnStatement = ReturnStatement;
- var Script = (function () {
- function Script(body) {
- this.type = syntax_1.Syntax.Program;
- this.body = body;
- this.sourceType = 'script';
- }
- return Script;
- }());
- exports.Script = Script;
- var SequenceExpression = (function () {
- function SequenceExpression(expressions) {
- this.type = syntax_1.Syntax.SequenceExpression;
- this.expressions = expressions;
- }
- return SequenceExpression;
- }());
- exports.SequenceExpression = SequenceExpression;
- var SpreadElement = (function () {
- function SpreadElement(argument) {
- this.type = syntax_1.Syntax.SpreadElement;
- this.argument = argument;
- }
- return SpreadElement;
- }());
- exports.SpreadElement = SpreadElement;
- var StaticMemberExpression = (function () {
- function StaticMemberExpression(object, property) {
- this.type = syntax_1.Syntax.MemberExpression;
- this.computed = false;
- this.object = object;
- this.property = property;
- }
- return StaticMemberExpression;
- }());
- exports.StaticMemberExpression = StaticMemberExpression;
- var Super = (function () {
- function Super() {
- this.type = syntax_1.Syntax.Super;
- }
- return Super;
- }());
- exports.Super = Super;
- var SwitchCase = (function () {
- function SwitchCase(test, consequent) {
- this.type = syntax_1.Syntax.SwitchCase;
- this.test = test;
- this.consequent = consequent;
- }
- return SwitchCase;
- }());
- exports.SwitchCase = SwitchCase;
- var SwitchStatement = (function () {
- function SwitchStatement(discriminant, cases) {
- this.type = syntax_1.Syntax.SwitchStatement;
- this.discriminant = discriminant;
- this.cases = cases;
- }
- return SwitchStatement;
- }());
- exports.SwitchStatement = SwitchStatement;
- var TaggedTemplateExpression = (function () {
- function TaggedTemplateExpression(tag, quasi) {
- this.type = syntax_1.Syntax.TaggedTemplateExpression;
- this.tag = tag;
- this.quasi = quasi;
- }
- return TaggedTemplateExpression;
- }());
- exports.TaggedTemplateExpression = TaggedTemplateExpression;
- var TemplateElement = (function () {
- function TemplateElement(value, tail) {
- this.type = syntax_1.Syntax.TemplateElement;
- this.value = value;
- this.tail = tail;
- }
- return TemplateElement;
- }());
- exports.TemplateElement = TemplateElement;
- var TemplateLiteral = (function () {
- function TemplateLiteral(quasis, expressions) {
- this.type = syntax_1.Syntax.TemplateLiteral;
- this.quasis = quasis;
- this.expressions = expressions;
- }
- return TemplateLiteral;
- }());
- exports.TemplateLiteral = TemplateLiteral;
- var ThisExpression = (function () {
- function ThisExpression() {
- this.type = syntax_1.Syntax.ThisExpression;
- }
- return ThisExpression;
- }());
- exports.ThisExpression = ThisExpression;
- var ThrowStatement = (function () {
- function ThrowStatement(argument) {
- this.type = syntax_1.Syntax.ThrowStatement;
- this.argument = argument;
- }
- return ThrowStatement;
- }());
- exports.ThrowStatement = ThrowStatement;
- var TryStatement = (function () {
- function TryStatement(block, handler, finalizer) {
- this.type = syntax_1.Syntax.TryStatement;
- this.block = block;
- this.handler = handler;
- this.finalizer = finalizer;
- }
- return TryStatement;
- }());
- exports.TryStatement = TryStatement;
- var UnaryExpression = (function () {
- function UnaryExpression(operator, argument) {
- this.type = syntax_1.Syntax.UnaryExpression;
- this.operator = operator;
- this.argument = argument;
- this.prefix = true;
- }
- return UnaryExpression;
- }());
- exports.UnaryExpression = UnaryExpression;
- var UpdateExpression = (function () {
- function UpdateExpression(operator, argument, prefix) {
- this.type = syntax_1.Syntax.UpdateExpression;
- this.operator = operator;
- this.argument = argument;
- this.prefix = prefix;
- }
- return UpdateExpression;
- }());
- exports.UpdateExpression = UpdateExpression;
- var VariableDeclaration = (function () {
- function VariableDeclaration(declarations, kind) {
- this.type = syntax_1.Syntax.VariableDeclaration;
- this.declarations = declarations;
- this.kind = kind;
- }
- return VariableDeclaration;
- }());
- exports.VariableDeclaration = VariableDeclaration;
- var VariableDeclarator = (function () {
- function VariableDeclarator(id, init) {
- this.type = syntax_1.Syntax.VariableDeclarator;
- this.id = id;
- this.init = init;
- }
- return VariableDeclarator;
- }());
- exports.VariableDeclarator = VariableDeclarator;
- var WhileStatement = (function () {
- function WhileStatement(test, body) {
- this.type = syntax_1.Syntax.WhileStatement;
- this.test = test;
- this.body = body;
- }
- return WhileStatement;
- }());
- 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;
-
-
-/***/ },
-/* 11 */
-/***/ function(module, exports, __webpack_require__) {
-
- "use strict";
-/* 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__(9);
- var token_1 = __webpack_require__(7);
- var parser_1 = __webpack_require__(3);
- var xhtml_entities_1 = __webpack_require__(12);
- var jsx_syntax_1 = __webpack_require__(13);
- var Node = __webpack_require__(10);
- var JSXNode = __webpack_require__(14);
- var JSXToken;
- (function (JSXToken) {
- JSXToken[JSXToken["Identifier"] = 100] = "Identifier";
- JSXToken[JSXToken["Text"] = 101] = "Text";
- })(JSXToken || (JSXToken = {}));
- token_1.TokenName[JSXToken.Identifier] = 'JSXIdentifier';
- token_1.TokenName[JSXToken.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;
- }
- return qualifiedName;
- }
- var JSXParser = (function (_super) {
- __extends(JSXParser, _super);
- function JSXParser(code, options, delegate) {
- _super.call(this, code, options, delegate);
- }
- JSXParser.prototype.parsePrimaryExpression = function () {
- return this.match('<') ? this.parseJSXRoot() : _super.prototype.parsePrimaryExpression.call(this);
- };
- JSXParser.prototype.startJSX = function () {
- // Unwind the scanner before the lookahead token.
- this.scanner.index = this.startMarker.index;
- this.scanner.lineNumber = this.startMarker.lineNumber;
- this.scanner.lineStart = this.startMarker.lineStart;
- };
- 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();
- }
- };
- JSXParser.prototype.createJSXNode = function () {
- this.collectComments();
- return {
- index: this.scanner.index,
- line: this.scanner.lineNumber,
- column: this.scanner.index - this.scanner.lineStart
- };
- };
- JSXParser.prototype.createJSXChildNode = function () {
- return {
- index: this.scanner.index,
- line: this.scanner.lineNumber,
- column: this.scanner.index - this.scanner.lineStart
- };
- };
- 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;
- }
- 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;
- };
- // 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: token_1.Token.Punctuator,
- value: value,
- lineNumber: this.scanner.lineNumber,
- lineStart: this.scanner.lineStart,
- start: this.scanner.index - 1,
- end: this.scanner.index
- };
- }
- // " '
- 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: token_1.Token.StringLiteral,
- value: str,
- lineNumber: this.scanner.lineNumber,
- lineStart: this.scanner.lineStart,
- start: start,
- end: this.scanner.index
- };
- }
- // ... 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: token_1.Token.Punctuator,
- value: value,
- lineNumber: this.scanner.lineNumber,
- lineStart: this.scanner.lineStart,
- start: start,
- end: this.scanner.index
- };
- }
- // `
- if (cp === 96) {
- // Only placeholder, since it will be rescanned as a real assignment expression.
- return {
- type: token_1.Token.Template,
- lineNumber: this.scanner.lineNumber,
- lineStart: this.scanner.lineStart,
- start: this.scanner.index,
- end: this.scanner.index
- };
- }
- // 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: JSXToken.Identifier,
- value: id,
- lineNumber: this.scanner.lineNumber,
- lineStart: this.scanner.lineStart,
- start: start,
- end: this.scanner.index
- };
- }
- this.scanner.throwUnexpectedToken();
- };
- JSXParser.prototype.nextJSXToken = function () {
- this.collectComments();
- this.startMarker.index = this.scanner.index;
- this.startMarker.lineNumber = this.scanner.lineNumber;
- this.startMarker.lineStart = this.scanner.lineStart;
- var token = this.lexJSX();
- this.lastMarker.index = this.scanner.index;
- this.lastMarker.lineNumber = this.scanner.lineNumber;
- this.lastMarker.lineStart = this.scanner.lineStart;
- if (this.config.tokens) {
- this.tokens.push(this.convertToken(token));
- }
- return token;
- };
- JSXParser.prototype.nextJSXText = function () {
- this.startMarker.index = this.scanner.index;
- this.startMarker.lineNumber = this.scanner.lineNumber;
- this.startMarker.lineStart = 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;
- }
- this.scanner.lineStart = this.scanner.index;
- }
- }
- this.lastMarker.index = this.scanner.index;
- this.lastMarker.lineNumber = this.scanner.lineNumber;
- this.lastMarker.lineStart = this.scanner.lineStart;
- var token = {
- type: JSXToken.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 token;
- };
- JSXParser.prototype.peekJSXToken = function () {
- var previousIndex = this.scanner.index;
- var previousLineNumber = this.scanner.lineNumber;
- var previousLineStart = this.scanner.lineStart;
- this.scanner.scanComments();
- var next = this.lexJSX();
- this.scanner.index = previousIndex;
- this.scanner.lineNumber = previousLineNumber;
- this.scanner.lineStart = previousLineStart;
- return next;
- };
- // Expect the next JSX token to match the specified punctuator.
- // If not, an exception will be thrown.
- JSXParser.prototype.expectJSX = function (value) {
- var token = this.nextJSXToken();
- if (token.type !== token_1.Token.Punctuator || token.value !== value) {
- this.throwUnexpectedToken(token);
- }
- };
- // Return true if the next JSX token matches the specified punctuator.
- JSXParser.prototype.matchJSX = function (value) {
- var next = this.peekJSXToken();
- return next.type === token_1.Token.Punctuator && next.value === value;
- };
- JSXParser.prototype.parseJSXIdentifier = function () {
- var node = this.createJSXNode();
- var token = this.nextJSXToken();
- if (token.type !== JSXToken.Identifier) {
- this.throwUnexpectedToken(token);
- }
- return this.finalize(node, new JSXNode.JSXIdentifier(token.value));
- };
- 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));
- }
- 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));
- }
- }
- return elementName;
- };
- 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 {
- attributeName = identifier;
- }
- return attributeName;
- };
- JSXParser.prototype.parseJSXStringLiteralAttribute = function () {
- var node = this.createJSXNode();
- var token = this.nextJSXToken();
- if (token.type !== token_1.Token.StringLiteral) {
- this.throwUnexpectedToken(token);
- }
- var raw = this.getTokenRaw(token);
- return this.finalize(node, new Node.Literal(token.value, raw));
- };
- 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');
- }
- var expression = this.parseAssignmentExpression();
- this.reenterJSX();
- return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));
- };
- 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();
- }
- return this.finalize(node, new JSXNode.JSXAttribute(name, value));
- };
- 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));
- };
- JSXParser.prototype.parseJSXAttributes = function () {
- var attributes = [];
- while (!this.matchJSX('/') && !this.matchJSX('>')) {
- var attribute = this.matchJSX('{') ? this.parseJSXSpreadAttribute() :
- this.parseJSXNameValueAttribute();
- attributes.push(attribute);
- }
- return attributes;
- };
- 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('/');
- }
- 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));
- }
- var name = this.parseJSXElementName();
- var attributes = this.parseJSXAttributes();
- var selfClosing = this.matchJSX('/');
- if (selfClosing) {
- this.expectJSX('/');
- }
- 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.lineNumber = this.scanner.lineNumber;
- this.lastMarker.lineStart = 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 {
- 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);
- }
- if (this.scanner.source[this.scanner.index] === '{') {
- var container = this.parseJSXExpressionContainer();
- children.push(container);
- }
- else {
- break;
- }
- }
- 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 {
- stack.push(el);
- el = { node: node, opening: opening, closing: null, children: [] };
- }
- }
- 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 el;
- };
- 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;
- }
- return this.finalize(node, new JSXNode.JSXElement(opening, children, closing));
- };
- JSXParser.prototype.parseJSXRoot = function () {
- // Pop the opening '<' added from the lookahead.
- if (this.config.tokens) {
- this.tokens.pop();
- }
- this.startJSX();
- var element = this.parseJSXElement();
- this.finishJSX();
- return element;
- };
- return JSXParser;
- }(parser_1.Parser));
- exports.JSXParser = JSXParser;
-
-
-/***/ },
-/* 12 */
</del><ins>+/* 14 */
</ins><span class="cx"> /***/ function(module, exports) {
</span><span class="cx">
</span><span class="cx"> // Generated by generate-xhtml-entities.js. DO NOT MODIFY!
</span><span class="lines">@@ -6372,142 +6606,18 @@
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> /***/ },
</span><del>-/* 13 */
-/***/ 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'
- };
-
-
-/***/ },
-/* 14 */
-/***/ function(module, exports, __webpack_require__) {
-
- "use strict";
- var jsx_syntax_1 = __webpack_require__(13);
- 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;
-
-
-/***/ },
</del><span class="cx"> /* 15 */
</span><span class="cx"> /***/ function(module, exports, __webpack_require__) {
</span><span class="cx">
</span><span class="cx"> "use strict";
</span><del>- var scanner_1 = __webpack_require__(8);
- var error_handler_1 = __webpack_require__(6);
- var token_1 = __webpack_require__(7);
</del><ins>+ var error_handler_1 = __webpack_require__(10);
+ var scanner_1 = __webpack_require__(12);
+ var token_1 = __webpack_require__(13);
</ins><span class="cx"> var Reader = (function () {
</span><span class="cx"> function Reader() {
</span><span class="cx"> this.values = [];
</span><span class="cx"> this.curly = this.paren = -1;
</span><span class="cx"> }
</span><del>- ;
</del><span class="cx"> // A function following one of those tokens is an expression.
</span><span class="cx"> Reader.prototype.beforeFunctionExpression = function (t) {
</span><span class="cx"> return ['(', '{', '[', 'in', 'typeof', 'instanceof', 'new',
</span><span class="lines">@@ -6520,7 +6630,6 @@
</span><span class="cx"> '|', '^', '!', '~', '&&', '||', '?', ':', '===', '==', '>=',
</span><span class="cx"> '<=', '<', '>', '!=', '!=='].indexOf(t) >= 0;
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> // Determine if forward slash (/) is an operator or part of a regular expression
</span><span class="cx"> // https://github.com/mozilla/sweet.js/wiki/design
</span><span class="cx"> Reader.prototype.isRegexStart = function () {
</span><span class="lines">@@ -6549,12 +6658,14 @@
</span><span class="cx"> var check_2 = this.values[this.curly - 5];
</span><span class="cx"> regex = check_2 ? !this.beforeFunctionExpression(check_2) : true;
</span><span class="cx"> }
</span><ins>+ break;
+ default:
+ break;
</ins><span class="cx"> }
</span><span class="cx"> return regex;
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Reader.prototype.push = function (token) {
</span><del>- if (token.type === token_1.Token.Punctuator || token.type === token_1.Token.Keyword) {
</del><ins>+ if (token.type === 7 /* Punctuator */ || token.type === 4 /* Keyword */) {
</ins><span class="cx"> if (token.value === '{') {
</span><span class="cx"> this.curly = this.values.length;
</span><span class="cx"> }
</span><span class="lines">@@ -6567,7 +6678,6 @@
</span><span class="cx"> this.values.push(null);
</span><span class="cx"> }
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> return Reader;
</span><span class="cx"> }());
</span><span class="cx"> var Tokenizer = (function () {
</span><span class="lines">@@ -6581,11 +6691,9 @@
</span><span class="cx"> this.buffer = [];
</span><span class="cx"> this.reader = new Reader();
</span><span class="cx"> }
</span><del>- ;
</del><span class="cx"> Tokenizer.prototype.errors = function () {
</span><span class="cx"> return this.errorHandler.errors;
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> Tokenizer.prototype.getNextToken = function () {
</span><span class="cx"> if (this.buffer.length === 0) {
</span><span class="cx"> var comments = this.scanner.scanComments();
</span><span class="lines">@@ -6592,9 +6700,8 @@
</span><span class="cx"> if (this.scanner.trackComment) {
</span><span class="cx"> for (var i = 0; i < comments.length; ++i) {
</span><span class="cx"> var e = comments[i];
</span><del>- var comment = void 0;
</del><span class="cx"> var value = this.scanner.source.slice(e.slice[0], e.slice[1]);
</span><del>- comment = {
</del><ins>+ var comment = {
</ins><span class="cx"> type: e.multiLine ? 'BlockComment' : 'LineComment',
</span><span class="cx"> value: value
</span><span class="cx"> };
</span><span class="lines">@@ -6626,8 +6733,7 @@
</span><span class="cx"> token = this.scanner.lex();
</span><span class="cx"> }
</span><span class="cx"> this.reader.push(token);
</span><del>- var entry = void 0;
- entry = {
</del><ins>+ var entry = {
</ins><span class="cx"> type: token_1.TokenName[token.type],
</span><span class="cx"> value: this.scanner.source.slice(token.start, token.end)
</span><span class="cx"> };
</span><span class="lines">@@ -6641,8 +6747,10 @@
</span><span class="cx"> };
</span><span class="cx"> entry.loc = loc;
</span><span class="cx"> }
</span><del>- if (token.regex) {
- entry.regex = token.regex;
</del><ins>+ if (token.type === 9 /* RegularExpression */) {
+ var pattern = token.pattern;
+ var flags = token.flags;
+ entry.regex = { pattern: pattern, flags: flags };
</ins><span class="cx"> }
</span><span class="cx"> this.buffer.push(entry);
</span><span class="cx"> }
</span><span class="lines">@@ -6649,7 +6757,6 @@
</span><span class="cx"> }
</span><span class="cx"> return this.buffer.shift();
</span><span class="cx"> };
</span><del>- ;
</del><span class="cx"> return Tokenizer;
</span><span class="cx"> }());
</span><span class="cx"> exports.Tokenizer = Tokenizer;
</span><span class="lines">@@ -6658,4 +6765,4 @@
</span><span class="cx"> /***/ }
</span><span class="cx"> /******/ ])
</span><span class="cx"> });
</span><del>-;
</del><span class="cx">\ No newline at end of file
</span><ins>+;
</ins></span></pre></div>
<a id="trunkSourceWebInspectorUIUserInterfaceModelsScriptSyntaxTreejs"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebInspectorUI/UserInterface/Models/ScriptSyntaxTree.js (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebInspectorUI/UserInterface/Models/ScriptSyntaxTree.js 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/Source/WebInspectorUI/UserInterface/Models/ScriptSyntaxTree.js 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -285,6 +285,7 @@
</span><span class="cx"> case WebInspector.ScriptSyntaxTree.NodeType.AssignmentPattern:
</span><span class="cx"> return gatherIdentifiers(node.left);
</span><span class="cx"> case WebInspector.ScriptSyntaxTree.NodeType.RestElement:
</span><ins>+ case WebInspector.ScriptSyntaxTree.NodeType.RestProperty:
</ins><span class="cx"> return gatherIdentifiers(node.argument);
</span><span class="cx"> default:
</span><span class="cx"> console.assert(false, "Unexpected node type in variable declarator: " + node.type);
</span><span class="lines">@@ -292,7 +293,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- console.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier || node.type === WebInspector.ScriptSyntaxTree.NodeType.ObjectPattern || node.type === WebInspector.ScriptSyntaxTree.NodeType.ArrayPattern || node.type === WebInspector.ScriptSyntaxTree.NodeType.RestElement);
</del><ins>+ console.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier || node.type === WebInspector.ScriptSyntaxTree.NodeType.ObjectPattern || node.type === WebInspector.ScriptSyntaxTree.NodeType.ArrayPattern || node.type === WebInspector.ScriptSyntaxTree.NodeType.RestElement || node.type === WebInspector.ScriptSyntaxTree.NodeType.RestProperty);
</ins><span class="cx">
</span><span class="cx"> return gatherIdentifiers(node);
</span><span class="cx"> }
</span><span class="lines">@@ -426,6 +427,9 @@
</span><span class="cx"> case WebInspector.ScriptSyntaxTree.NodeType.RestElement:
</span><span class="cx"> this._recurse(node.argument, callback, state);
</span><span class="cx"> break;
</span><ins>+ case WebInspector.ScriptSyntaxTree.NodeType.RestProperty:
+ this._recurse(node.argument, callback, state);
+ break;
</ins><span class="cx"> case WebInspector.ScriptSyntaxTree.NodeType.ReturnStatement:
</span><span class="cx"> this._recurse(node.argument, callback, state);
</span><span class="cx"> break;
</span><span class="lines">@@ -435,6 +439,9 @@
</span><span class="cx"> case WebInspector.ScriptSyntaxTree.NodeType.SpreadElement:
</span><span class="cx"> this._recurse(node.argument, callback, state);
</span><span class="cx"> break;
</span><ins>+ case WebInspector.ScriptSyntaxTree.NodeType.SpreadProperty:
+ this._recurse(node.argument, callback, state);
+ break;
</ins><span class="cx"> case WebInspector.ScriptSyntaxTree.NodeType.SwitchStatement:
</span><span class="cx"> this._recurse(node.discriminant, callback, state);
</span><span class="cx"> this._recurseArray(node.cases, callback, state);
</span><span class="lines">@@ -525,6 +532,7 @@
</span><span class="cx"> case WebInspector.ScriptSyntaxTree.NodeType.DebuggerStatement:
</span><span class="cx"> case WebInspector.ScriptSyntaxTree.NodeType.EmptyStatement:
</span><span class="cx"> case WebInspector.ScriptSyntaxTree.NodeType.Identifier:
</span><ins>+ case WebInspector.ScriptSyntaxTree.NodeType.Import:
</ins><span class="cx"> case WebInspector.ScriptSyntaxTree.NodeType.Literal:
</span><span class="cx"> case WebInspector.ScriptSyntaxTree.NodeType.MetaProperty:
</span><span class="cx"> case WebInspector.ScriptSyntaxTree.NodeType.Super:
</span><span class="lines">@@ -845,6 +853,12 @@
</span><span class="cx"> argument: this._createInternalSyntaxTree(node.argument)
</span><span class="cx"> };
</span><span class="cx"> break;
</span><ins>+ case "RestProperty":
+ result = {
+ type: WebInspector.ScriptSyntaxTree.NodeType.RestProperty,
+ argument: this._createInternalSyntaxTree(node.argument),
+ };
+ break;
</ins><span class="cx"> case "ReturnStatement":
</span><span class="cx"> result = {
</span><span class="cx"> type: WebInspector.ScriptSyntaxTree.NodeType.ReturnStatement,
</span><span class="lines">@@ -863,6 +877,12 @@
</span><span class="cx"> argument: this._createInternalSyntaxTree(node.argument),
</span><span class="cx"> };
</span><span class="cx"> break;
</span><ins>+ case "SpreadProperty":
+ result = {
+ type: WebInspector.ScriptSyntaxTree.NodeType.SpreadProperty,
+ argument: this._createInternalSyntaxTree(node.argument),
+ };
+ break;
</ins><span class="cx"> case "Super":
</span><span class="cx"> result = {
</span><span class="cx"> type: WebInspector.ScriptSyntaxTree.NodeType.Super
</span><span class="lines">@@ -1002,6 +1022,11 @@
</span><span class="cx"> exported: this._createInternalSyntaxTree(node.exported),
</span><span class="cx"> };
</span><span class="cx"> break;
</span><ins>+ case "Import":
+ result = {
+ type: WebInspector.ScriptSyntaxTree.NodeType.Import,
+ };
+ break;
</ins><span class="cx"> case "ImportDeclaration":
</span><span class="cx"> result = {
</span><span class="cx"> type: WebInspector.ScriptSyntaxTree.NodeType.ImportDeclaration,
</span><span class="lines">@@ -1080,6 +1105,7 @@
</span><span class="cx"> FunctionExpression: Symbol("function-expression"),
</span><span class="cx"> Identifier: Symbol("identifier"),
</span><span class="cx"> IfStatement: Symbol("if-statement"),
</span><ins>+ Import: Symbol("import"),
</ins><span class="cx"> ImportDeclaration: Symbol("import-declaration"),
</span><span class="cx"> ImportDefaultSpecifier: Symbol("import-default-specifier"),
</span><span class="cx"> ImportNamespaceSpecifier: Symbol("import-namespace-specifier"),
</span><span class="lines">@@ -1096,9 +1122,11 @@
</span><span class="cx"> Program: Symbol("program"),
</span><span class="cx"> Property: Symbol("property"),
</span><span class="cx"> RestElement: Symbol("rest-element"),
</span><ins>+ RestProperty: Symbol("rest-property"),
</ins><span class="cx"> ReturnStatement: Symbol("return-statement"),
</span><span class="cx"> SequenceExpression: Symbol("sequence-expression"),
</span><span class="cx"> SpreadElement: Symbol("spread-element"),
</span><ins>+ SpreadProperty: Symbol("spread-property"),
</ins><span class="cx"> Super: Symbol("super"),
</span><span class="cx"> SwitchCase: Symbol("switch-case"),
</span><span class="cx"> SwitchStatement: Symbol("switch-statement"),
</span></span></pre></div>
<a id="trunkSourceWebInspectorUIUserInterfaceWorkersFormatterESTreeWalkerjs"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebInspectorUI/UserInterface/Workers/Formatter/ESTreeWalker.js (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebInspectorUI/UserInterface/Workers/Formatter/ESTreeWalker.js 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/Source/WebInspectorUI/UserInterface/Workers/Formatter/ESTreeWalker.js 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -182,6 +182,9 @@
</span><span class="cx"> case "RestElement":
</span><span class="cx"> this._walk(node.argument, node);
</span><span class="cx"> break;
</span><ins>+ case "RestProperty":
+ this._walk(node.argument, node);
+ break;
</ins><span class="cx"> case "ReturnStatement":
</span><span class="cx"> this._walk(node.argument, node);
</span><span class="cx"> break;
</span><span class="lines">@@ -191,6 +194,9 @@
</span><span class="cx"> case "SpreadElement":
</span><span class="cx"> this._walk(node.argument, node);
</span><span class="cx"> break;
</span><ins>+ case "SpreadProperty":
+ this._walk(node.argument, node);
+ break;
</ins><span class="cx"> case "SwitchStatement":
</span><span class="cx"> this._walk(node.discriminant, node);
</span><span class="cx"> this._walkArray(node.cases, node);
</span><span class="lines">@@ -288,6 +294,7 @@
</span><span class="cx"> case "DebuggerStatement":
</span><span class="cx"> case "EmptyStatement":
</span><span class="cx"> case "Identifier":
</span><ins>+ case "Import":
</ins><span class="cx"> case "Literal":
</span><span class="cx"> case "Super":
</span><span class="cx"> case "ThisExpression":
</span></span></pre></div>
<a id="trunkSourceWebInspectorUIUserInterfaceWorkersFormatterEsprimaFormatterjs"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebInspectorUI/UserInterface/Workers/Formatter/EsprimaFormatter.js (211553 => 211554)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebInspectorUI/UserInterface/Workers/Formatter/EsprimaFormatter.js 2017-02-02 10:30:17 UTC (rev 211553)
+++ trunk/Source/WebInspectorUI/UserInterface/Workers/Formatter/EsprimaFormatter.js 2017-02-02 10:31:18 UTC (rev 211554)
</span><span class="lines">@@ -828,9 +828,12 @@
</span><span class="cx"> // Include these here so we get only get warnings about unhandled nodes.
</span><span class="cx"> if (nodeType === "ExpressionStatement"
</span><span class="cx"> || nodeType === "SpreadElement"
</span><ins>+ || nodeType === "SpreadProperty"
</ins><span class="cx"> || nodeType === "Super"
</span><ins>+ || nodeType === "Import"
</ins><span class="cx"> || nodeType === "MetaProperty"
</span><span class="cx"> || nodeType === "RestElement"
</span><ins>+ || nodeType === "RestProperty"
</ins><span class="cx"> || nodeType === "TemplateElement"
</span><span class="cx"> || nodeType === "TemplateLiteral"
</span><span class="cx"> || nodeType === "DebuggerStatement"
</span></span></pre>
</div>
</div>
</body>
</html>