From 91911bcfcd1b6ab1a64cd7566c428f33b2371f63 Mon Sep 17 00:00:00 2001 From: Marijn Haverbeke Date: Fri, 12 Sep 2014 14:07:22 +0200 Subject: [PATCH 01/25] Add bin/without_eval utility --- README.md | 14 +++ bin/without_eval | 48 +++++++ index.html | 316 ++++++++++++++++++++++++++--------------------- 3 files changed, 235 insertions(+), 143 deletions(-) create mode 100755 bin/without_eval diff --git a/README.md b/README.md index 26d724de52..82ecd6b77c 100644 --- a/README.md +++ b/README.md @@ -176,6 +176,20 @@ console.log(escodegen.generate(ast, {comment: true})); [escodegen]: https://github.com/Constellation/escodegen +#### Using Acorn in an environment with a Content Security Policy + +Some contexts, such as Chrome Web Apps, disallow run-time code evaluation. +Acorn uses `new Function` to generate fast functions that test whether +a word is in a given set, and will trigger a security error when used +in a context with such a +[Content Security Policy](http://www.html5rocks.com/en/tutorials/security/content-security-policy/#eval-too) +(see [#90](https://github.com/marijnh/acorn/issues/90) and +[#123](https://github.com/marijnh/acorn/issues/123)). + +The `bin/without_eval` script can be used to generate a version of +`acorn.js` that has the generated code inlined, and can thus run +without evaluating anything. + ### acorn_loose.js ### This file implements an error-tolerant parser. It exposes a single diff --git a/bin/without_eval b/bin/without_eval new file mode 100755 index 0000000000..fd8befb6b0 --- /dev/null +++ b/bin/without_eval @@ -0,0 +1,48 @@ +#!/usr/bin/env node + +var fs = require("fs"); + +var acornSrc = fs.readFileSync(require.resolve("../acorn"), "utf8"); +var acorn = require("../acorn"), walk = require("../util/walk"); + +var ast = acorn.parse(acornSrc); +var touchups = []; +var uses = [], declaration; + +walk.simple(ast, { + FunctionDeclaration: function(node) { + if (node.id.name == "makePredicate") { + touchups.push({text: "// Removed to create an eval-free library", from: node.start, to: node.end}); + declaration = node; + } + }, + VariableDeclaration: function(node) { + node.declarations.forEach(function(decl) { + if (decl.init && decl.init.type == "CallExpression" && + decl.init.callee.name == "makePredicate") + uses.push(decl); + }); + } +}); + +var results = Object.create(null); +var functions = new Function("predicates", acornSrc.replace( + /\}\);\s*$/, uses.map(function(decl) { + return "predicates[" + JSON.stringify(decl.id.name) + "] = " + decl.id.name + ";"; + }).join("") + "});"))(results); + +uses.forEach(function(decl) { + touchups.push({text: results[decl.id.name].toString(), + from: decl.init.start, to: decl.init.end}); +}); + +var result = "", pos = 0; +touchups.sort(function(a, b) { return a.from - b.from; }); +touchups.forEach(function(touchup) { + result += acornSrc.slice(pos, touchup.from); + result += touchup.text; + pos = touchup.to; +}); +result += acornSrc.slice(pos); + +process.stdout.write(result); diff --git a/index.html b/index.html index d0d5e8de73..855387dbb8 100644 --- a/index.html +++ b/index.html @@ -72,12 +72,40 @@ file in every node's loc object.

locations is on or off.

    directSourceFile: null
   };
 
+  var isArray = function (obj) {
+    return Object.prototype.toString.call(obj) === "[object Array]";
+  };
+
   function setOptions(opts) {
     options = opts || {};
     for (var opt in defaultOptions) if (!has(options, opt))
       options[opt] = defaultOptions[opt];
     sourceFile = options.sourceFile || null;
-
+    if (isArray(options.onToken)) {
+      var tokens = options.onToken;
+      options.onToken = function (token) {
+        tokens.push(token);
+      };
+    }
+    if (isArray(options.onComment)) {
+      var comments = options.onComment;
+      options.onComment = function (block, text, start, end, startLoc, endLoc) {
+        var comment = {
+          type: block ? 'Block' : 'Line',
+          value: text,
+          start: start,
+          end: end
+        };
+        if (options.locations) {
+          comment.loc = new SourceLocation();
+          comment.loc.start = startLoc;
+          comment.loc.end = endLoc;
+        }
+        if (options.ranges)
+          comment.range = [start, end];
+        comments.push(comment);
+      };
+    }
     isKeyword = options.ecmaVersion >= 6 ? isEcma6Keyword : isEcma5AndLessKeyword;
   }

The getLineInfo function is mostly useful when the locations option is off (for performance reasons) and you @@ -95,19 +123,21 @@ into.

return {line: line, column: offset - cur}; }; - var getCurrentToken = function () { - var token = { - type: tokType, - value: tokVal, - start: tokStart, - end: tokEnd - }; + function Token() { + this.type = tokType; + this.value = tokVal; + this.start = tokStart; + this.end = tokEnd; if (options.locations) { - token.startLoc = tokStartLoc; - token.endLoc = tokEndLoc; + this.loc = new SourceLocation(); + this.loc.end = tokEndLoc;

TODO: remove in next major release

      this.startLoc = tokStartLoc;
+      this.endLoc = tokEndLoc;
     }
-    return token;
-  };

Acorn is organized as a tokenizer and a recursive-descent parser. + if (options.ranges) + this.range = [tokStart, tokEnd]; + } + + exports.Token = Token;

Acorn is organized as a tokenizer and a recursive-descent parser. The tokenize export provides an interface to the tokenizer. Because the tokenizer is optimized for being efficiently used by the Acorn parser itself, this interface is somewhat crude and not @@ -120,7 +150,7 @@ reset the internal state, and invalidate existing tokenizers.

function getToken(forceRegexp) { lastEnd = tokEnd; readToken(forceRegexp); - return getCurrentToken(); + return new Token(); } getToken.jumpTo = function(pos, reAllowed) { tokPos = pos; @@ -137,30 +167,30 @@ reset the internal state, and invalidate existing tokenizers.

skipSpace(); }; return getToken; - };

State is kept in (closure-)global variables. We already saw the -options, input, and inputLen variables above.

                                                                                   
                                
               
The current position of the tokenizer in the input.
                                         
  var tokPos;
                                                                                   
                                
               
The start and end offsets of the current token.
                                         
  var tokStart, tokEnd;
                                                                                   
                                
               
When options.locations is true, these hold objects
-containing the tokens start and end line/column pairs.
                                         
  var tokStartLoc, tokEndLoc;
                                                                                   
                                
               
The type and value of the current token. Token types are objects,
+  };                                                                                   
                                
               
State is kept in (closure-)global variables. We already saw the
+options, input, and inputLen variables above.
                                         
                                                                                   
                                
               
The current position of the tokenizer in the input.
                                         
  var tokPos;
                                                                                   
                                
               
The start and end offsets of the current token.
                                         
  var tokStart, tokEnd;
                                                                                   
                                
               
When options.locations is true, these hold objects
+containing the tokens start and end line/column pairs.
                                         
  var tokStartLoc, tokEndLoc;
                                                                                   
                                
               
The type and value of the current token. Token types are objects,
 named by variables against which they can be compared, and
 holding properties that describe them (indicating, for example,
 the precedence of an infix operator, and the original name of a
 keyword token). The kind of value that's held in tokVal depends
 on the type of the token. For literals, it is the literal value,
-for operators, the operator name, and so on.
                                         
  var tokType, tokVal;
                                                                                   
                                
               
Internal state for the tokenizer. To distinguish between division
+for operators, the operator name, and so on.
                                         
  var tokType, tokVal;
                                                                                   
                                
               
Internal state for the tokenizer. To distinguish between division
 operators and regular expressions, it remembers whether the last
 token was one that is allowed to be followed by an expression.
 (If it is, a slash is probably a regexp, if it isn't it's a
 division operator. See the parseStatement function for a
-caveat.)
                                         
  var tokRegexpAllowed;
                                                                                   
                                
               
When options.locations is true, these are used to keep
+caveat.)
                                         
  var tokRegexpAllowed;
                                                                                   
                                
               
When options.locations is true, these are used to keep
 track of the current line, and know when a new line has been
-entered.
                                         
  var tokCurLine, tokLineStart;
                                                                                   
                                
               
These store the position of the previous token, which is useful
-when finishing a node and assigning its end position.
                                         
  var lastStart, lastEnd, lastEndLoc;
                                                                                   
                                
               
This is the parser's state. inFunction is used to reject
+entered.
                                         
  var tokCurLine, tokLineStart;
                                                                                   
                                
               
These store the position of the previous token, which is useful
+when finishing a node and assigning its end position.
                                         
  var lastStart, lastEnd, lastEndLoc;
                                                                                   
                                
               
This is the parser's state. inFunction is used to reject
 return statements outside of functions, inGenerator to
 reject yields outside of generators, labels to verify
 that break and continue have somewhere to jump to, and
-strict indicates whether strict mode is on.
                                         
  var inFunction, inGenerator, labels, strict;
                                                                                   
                                
               
This counter is used for checking that arrow expressions did
-not contain nested parentheses in argument list.
                                         
  var metParenL;
                                                                                   
                                
               
This is used by parser for detecting if it's inside ES6
+strict indicates whether strict mode is on.
                                         
  var inFunction, inGenerator, labels, strict;
                                                                                   
                                
               
This counter is used for checking that arrow expressions did
+not contain nested parentheses in argument list.
                                         
  var metParenL;
                                                                                   
                                
               
This is used by parser for detecting if it's inside ES6
 Template String. If it is, it should treat '$' as prefix before
-'{expression}' and everything else as string literals.
                                         
  var inTemplate;
                                                                                   
                                
               
This function is used to raise exceptions on parse errors. It
+'{expression}' and everything else as string literals.
                                         
  var inTemplate;
                                                                                   
                                
               
This function is used to raise exceptions on parse errors. It
 takes an offset integer (into the current input) to indicate
 the location of the error, attaches the position to the end
 of the error message, and then raises a SyntaxError with that
@@ -170,12 +200,12 @@ message.
                                         
var err = new SyntaxError(message);
     err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
     throw err;
-  }
                                                                                   
                                
               
Reused empty array added for node fields that are always empty.
                                         
  var empty = [];
                                                                                   
                                
               
Token types
                                         
                                                                                   
                                
               
The assignment of fine-grained, information-carrying type objects
+  }                                                                                   
                                
               
Reused empty array added for node fields that are always empty.
                                         
  var empty = [];
                                                                                   
                                
               
Token types
                                         
                                                                                   
                                
               
The assignment of fine-grained, information-carrying type objects
 allows the tokenizer to store the information it has about a
-token in a way that is very cheap for the parser to look up.
                                         
                                                                                   
                                
               
All token type variables start with an underscore, to make them
-easy to recognize.
                                         
                                                                                   
                                
               
These are the general types. The type property is only used to
+token in a way that is very cheap for the parser to look up.
                                         
                                                                                   
                                
               
All token type variables start with an underscore, to make them
+easy to recognize.
                                         
                                                                                   
                                
               
These are the general types. The type property is only used to
 make them recognizeable when debugging.
                                         
  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
-  var _name = {type: "name"}, _eof = {type: "eof"};
                                                                                   
                                
               
Keyword tokens. The keyword property (also used in keyword-like
+  var _name = {type: "name"}, _eof = {type: "eof"};                                                                                   
                                
               
Keyword tokens. The keyword property (also used in keyword-like
 operators) indicates that the token originated from an
 identifier-like word, which is used when parsing property names.

 
@@ -197,10 +227,10 @@ continue jumps to that label.
                          var _this = {keyword: "this"};
   var _class = {keyword: "class"}, _extends = {keyword: "extends", beforeExpr: true};
   var _export = {keyword: "export"}, _import = {keyword: "import"};
-  var _yield = {keyword: "yield", beforeExpr: true};                                                                                   
                                
               
The keywords that denote values.
                                         
  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
-  var _false = {keyword: "false", atomValue: false};
                                                                                   
                                
               
Some keywords are treated as regular operators. in sometimes
+  var _yield = {keyword: "yield", beforeExpr: true};                                                                                   
                                
               
The keywords that denote values.
                                         
  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
+  var _false = {keyword: "false", atomValue: false};
                                                                                   
                                
               
Some keywords are treated as regular operators. in sometimes
 (when parsing for) needs to be tested against specifically, so
-we assign a variable name to it for quick comparing.
                                         
  var _in = {keyword: "in", binop: 7, beforeExpr: true};
                                                                                   
                                
               
Map keyword names to token types.
                                         
  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
+we assign a variable name to it for quick comparing.
                                         
  var _in = {keyword: "in", binop: 7, beforeExpr: true};
                                                                                   
                                
               
Map keyword names to token types.
                                         
  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
                       "continue": _continue, "debugger": _debugger, "default": _default,
                       "do": _do, "else": _else, "finally": _finally, "for": _for,
                       "function": _function, "if": _if, "return": _return, "switch": _switch,
@@ -212,11 +242,11 @@ we assign a variable name to it for quick comparing.
             
                       "void": {keyword: "void", prefix: true, beforeExpr: true},
                       "delete": {keyword: "delete", prefix: true, beforeExpr: true},
                       "class": _class, "extends": _extends,
-                      "export": _export, "import": _import, "yield": _yield};
                                                                                   
                                
               
Punctuation token types. Again, the type property is purely for debugging.
                                         
  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
+                      "export": _export, "import": _import, "yield": _yield};
                                                                                   
                                
               
Punctuation token types. Again, the type property is purely for debugging.
                                         
  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
   var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
   var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
   var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _ellipsis = {type: "..."}, _question = {type: "?", beforeExpr: true};
-  var _arrow = {type: "=>", beforeExpr: true}, _bquote = {type: "`"}, _dollarBraceL = {type: "${", beforeExpr: true};
                                                                                   
                                
               
Operators. These carry several kinds of properties to help the
+  var _arrow = {type: "=>", beforeExpr: true}, _bquote = {type: "`"}, _dollarBraceL = {type: "${", beforeExpr: true};
                                                                                   
                                
               
Operators. These carry several kinds of properties to help the
 parser use them properly (the presence of these properties is
 what categorizes them as operators).

 
@@ -242,13 +272,13 @@ in AssignmentExpression nodes.
                          var _relational = {binop: 7, beforeExpr: true};
   var _bitShift = {binop: 8, beforeExpr: true};
   var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
-  var _modulo = {binop: 10, beforeExpr: true};                                                                                   
                                
               
'*' may be multiply or have special meaning in ES6
                                         
  var _star = {binop: 10, beforeExpr: true};
                                                                                   
                                
               
Provide access to the token types for external users of the
+  var _modulo = {binop: 10, beforeExpr: true};                                                                                   
                                
               
'*' may be multiply or have special meaning in ES6
                                         
  var _star = {binop: 10, beforeExpr: true};
                                                                                   
                                
               
Provide access to the token types for external users of the
 tokenizer.
                                         
  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
                       parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
                       dot: _dot, ellipsis: _ellipsis, question: _question, slash: _slash, eq: _eq,
                       name: _name, eof: _eof, num: _num, regexp: _regexp, string: _string,
                       arrow: _arrow, bquote: _bquote, dollarBraceL: _dollarBraceL};
-  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
                                                                                   
                                
               
This is a trick taken from Esprima. It turns out that, on
+  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];                                                                                   
                                
               
This is a trick taken from Esprima. It turns out that, on
 non-Chrome browsers, to check whether a string is in a set, a
 predicate containing a big ugly switch statement is faster than
 a regular expression, and on Chrome the two are about on par.
@@ -271,7 +301,7 @@ predicate from a space-separated string of words.

       f += "switch(str){";
       for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
       f += "return true}return false;";
-    }                                                                                   
                                
               
When there are more than three length categories, an outer
+    }                                                                                   
                                
               
When there are more than three length categories, an outer
 switch first dispatches on the lengths, to save on comparisons.
                                         
    if (cats.length > 3) {
       cats.sort(function(a, b) {return b.length - a.length;});
       f += "switch(str.length){";
@@ -280,17 +310,17 @@ switch first dispatches on the lengths, to save on comparisons.

         f += "case " + cat[0].length + ":";
         compareTo(cat);
       }
-      f += "}";
                                                                                   
                                
               
Otherwise, simply generate a flat switch statement.
                                         
    } else {
+      f += "}";
                                                                                   
                                
               
Otherwise, simply generate a flat switch statement.
                                         
    } else {
       compareTo(words);
     }
     return new Function("str", f);
-  }
                                                                                   
                                
               
The ECMAScript 3 reserved word list.
                                         
  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
                                                                                   
                                
               
ECMAScript 5 reserved words.
                                         
  var isReservedWord5 = makePredicate("class enum extends super const export import");
                                                                                   
                                
               
The additional reserved words in strict mode.
                                         
  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
                                                                                   
                                
               
The forbidden variable names in strict mode.
                                         
  var isStrictBadIdWord = makePredicate("eval arguments");
                                                                                   
                                
               
And the keywords.
                                         
  var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
+  }
                                                                                   
                                
               
The ECMAScript 3 reserved word list.
                                         
  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
                                                                                   
                                
               
ECMAScript 5 reserved words.
                                         
  var isReservedWord5 = makePredicate("class enum extends super const export import");
                                                                                   
                                
               
The additional reserved words in strict mode.
                                         
  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
                                                                                   
                                
               
The forbidden variable names in strict mode.
                                         
  var isStrictBadIdWord = makePredicate("eval arguments");
                                                                                   
                                
               
And the keywords.
                                         
  var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
 
   var isEcma5AndLessKeyword = makePredicate(ecma5AndLessKeywords);
 
   var isEcma6Keyword = makePredicate(ecma5AndLessKeywords + " let const class extends export import yield");
 
-  var isKeyword = isEcma5AndLessKeyword;
                                                                                   
                                
               
Character categories
                                         
                                                                                   
                                
               
Big ugly regular expressions that match characters in the
+  var isKeyword = isEcma5AndLessKeyword;                                                                                   
                                
               
Character categories
                                         
                                                                                   
                                
               
Big ugly regular expressions that match characters in the
 whitespace, identifier, and identifier-start categories. These
 are only applied when a character is found to actually have a
 code point above 128.
@@ -298,14 +328,14 @@ Generated by tools/generate-identifier-regex.js.
             var nonASCIIidentifierStartChars = "\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-\u08B2\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\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\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\u0C59\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\u0D60\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-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\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\u19C1-\u19C7\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\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\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-\uAB5F\uAB64\uAB65\uABC0-\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";
   var nonASCIIidentifierChars = "\u0300-\u036F\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E4-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0D01-\u0D03\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19B0-\u19C0\u19C8\u19C9\u19D0-\u19D9\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u200C\u200D\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA620-\uA629\uA66F\uA674-\uA67D\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F1\uA900-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F";
   var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");                                                                                   
                                
               
Whether a single character denotes a newline.
                                         
  var newline = /[\n\r\u2028\u2029]/;
                                                                                   
                                
               
Matches a whole line break (where CRLF is considered a single
-line break). Used to count lines.
                                         
  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
                                                                                   
                                
               
Test whether a given character code starts an identifier.
                                         
  var isIdentifierStart = exports.isIdentifierStart = function(code) {
+  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
                                                                                   
                                
               
Whether a single character denotes a newline.
                                         
  var newline = /[\n\r\u2028\u2029]/;
                                                                                   
                                
               
Matches a whole line break (where CRLF is considered a single
+line break). Used to count lines.
                                         
  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
                                                                                   
                                
               
Test whether a given character code starts an identifier.
                                         
  var isIdentifierStart = exports.isIdentifierStart = function(code) {
     if (code < 65) return code === 36;
     if (code < 91) return true;
     if (code < 97) return code === 95;
     if (code < 123)return true;
     return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  };
                                                                                   
                                
               
Test whether a given character is part of an identifier.
                                         
  var isIdentifierChar = exports.isIdentifierChar = function(code) {
+  };
                                                                                   
                                
               
Test whether a given character is part of an identifier.
                                         
  var isIdentifierChar = exports.isIdentifierChar = function(code) {
     if (code < 48) return code === 36;
     if (code < 58) return true;
     if (code < 65) return false;
@@ -313,18 +343,18 @@ line break). Used to count lines.
                          if (code < 97) return code === 95;
     if (code < 123)return true;
     return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  };
                                                                                   
                                
               
Tokenizer
                                         
                                                                                   
                                
               
These are used when options.locations is on, for the
+  };                                                                                   
                                
               
Tokenizer
                                         
                                                                                   
                                
               
These are used when options.locations is on, for the
 tokStartLoc and tokEndLoc properties.
                                         
  function Position() {
     this.line = tokCurLine;
     this.column = tokPos - tokLineStart;
-  }
                                                                                   
                                
               
Reset the token state. Used at the start of a parse.
                                         
  function initTokenState() {
+  }
                                                                                   
                                
               
Reset the token state. Used at the start of a parse.
                                         
  function initTokenState() {
     tokCurLine = 1;
     tokPos = tokLineStart = 0;
     tokRegexpAllowed = true;
     metParenL = 0;
     inTemplate = false;
     skipSpace();
-  }
                                                                                   
                                
               
Called at the end of every token. Sets tokEnd, tokVal, and
+  }                                                                                   
                                
               
Called at the end of every token. Sets tokEnd, tokVal, and
 tokRegexpAllowed, and skips the space after the token, so that
 the next one's tokStart will point at the right position.
                                         
  function finishToken(type, val, shouldSkipSpace) {
     tokEnd = tokPos;
@@ -334,7 +364,7 @@ the next one's tokStart will point at the right position.

     tokVal = val;
     tokRegexpAllowed = type.beforeExpr;
     if (options.onToken) {
-      options.onToken(getCurrentToken());
+      options.onToken(new Token());
     }
   }
 
@@ -367,7 +397,7 @@ the next one's tokStart will point at the right position.

     if (options.onComment)
       options.onComment(false, input.slice(start + startSkip, tokPos), start, tokPos,
                         startLoc, options.locations && new Position);
-  }
                                                                                   
                                
               
Called at the start of the parse and after every token. Skips
+  }                                                                                   
                                
               
Called at the start of the parse and after every token. Skips
 whitespace and comments, and.
                                         
  function skipSpace() {
     while (tokPos < inputLen) {
       var ch = input.charCodeAt(tokPos);
@@ -406,7 +436,7 @@ whitespace and comments, and.
                          break;
       }
     }
-  }
                                                                                   
                                
               
Token reading
                                         
                                                                                   
                                
               
This is the function that is called to fetch the next token. It
+  }                                                                                   
                                
               
Token reading
                                         
                                                                                   
                                
               
This is the function that is called to fetch the next token. It
 is somewhat obscure, because it works in character codes rather
 than characters, and because operator parsing has been inlined
 into it.

@@ -457,7 +487,7 @@ into it.

     var next = input.charCodeAt(tokPos + 1);
     if (next === code) {
       if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
-          newline.test(input.slice(lastEnd, tokPos))) {                                                                                   
                                
               
A --> line comment
                                         
        skipLineComment(3);
+          newline.test(input.slice(lastEnd, tokPos))) {
                                                                                   
                                
               
A --> line comment
                                         
        skipLineComment(3);
         skipSpace();
         return readToken();
       }
@@ -476,7 +506,7 @@ into it.

       return finishOp(_bitShift, size);
     }
     if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
-        input.charCodeAt(tokPos + 3) == 45) {
                                                                                   
                                
               
<!--, an XML-style comment that should be interpreted as a line comment
                                         
      skipLineComment(4);
+        input.charCodeAt(tokPos + 3) == 45) {
                                                                                   
                                
               
<!--, an XML-style comment that should be interpreted as a line comment
                                         
      skipLineComment(4);
       skipSpace();
       return readToken();
     }
@@ -493,7 +523,7 @@ into it.

       return finishToken(_arrow);
     }
     return finishOp(code === 61 ? _eq : _prefix, 1);
-  }
                                                                                   
                                
               
Get token inside ES6 template (special rules work there).
                                         
  function getTemplateToken(code) {
                                                                                   
                                
               
'`' and '${' have special meanings, but they should follow
+  }                                                                                   
                                
               
Get token inside ES6 template (special rules work there).
                                         
  function getTemplateToken(code) {
                                                                                   
                                
               
'`' and '${' have special meanings, but they should follow
 string (can be empty)
                                         
    if (tokType === _string) {
       if (code === 96) { // '`'
         ++tokPos;
@@ -508,13 +538,13 @@ string (can be empty)
                          
     if (code === 125) { // '}'
       ++tokPos;
       return finishToken(_braceR, undefined, false);
-    }
                                                                                   
                                
               
anything else is considered string literal
                                         
    return readTmplString();
+    }
                                                                                   
                                
               
anything else is considered string literal
                                         
    return readTmplString();
   }
 
   function getTokenFromCode(code) {
-    switch (code) {
                                                                                   
                                
               
The interpretation of a dot depends on whether it is followed
+    switch (code) {                                                                                   
                                
               
The interpretation of a dot depends on whether it is followed
 by a digit or another two dots.
                                         
    case 46: // '.'
-      return readToken_dot();
                                                                                   
                                
               
Punctuation tokens.
                                         
    case 40: ++tokPos; return finishToken(_parenL);
+      return readToken_dot();
                                                                                   
                                
               
Punctuation tokens.
                                         
    case 40: ++tokPos; return finishToken(_parenL);
     case 41: ++tokPos; return finishToken(_parenR);
     case 59: ++tokPos; return finishToken(_semi);
     case 44: ++tokPos; return finishToken(_comma);
@@ -537,10 +567,10 @@ by a digit or another two dots.
                          if (options.ecmaVersion >= 6) {
         if (next === 111 || next === 79) return readRadixNumber(8); // '0o', '0O' - octal number
         if (next === 98 || next === 66) return readRadixNumber(2); // '0b', '0B' - binary number
-      }
                                                                                   
                                
               
Anything else beginning with a digit is an integer, octal
+      }                                                                                   
                                
               
Anything else beginning with a digit is an integer, octal
 number, or float.
                                         
    case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9
-      return readNumber(false);
                                                                                   
                                
               
Quotes produce strings.
                                         
    case 34: case 39: // '"', "'"
-      return readString(code);
                                                                                   
                                
               
Operators are parsed inline in tiny state machines. '=' (61) is
+      return readNumber(false);                                                                                   
                                
               
Quotes produce strings.
                                         
    case 34: case 39: // '"', "'"
+      return readString(code);
                                                                                   
                                
               
Operators are parsed inline in tiny state machines. '=' (61) is
 often referred to. finishOp simply skips the amount of
 characters it is given as second argument, and returns a token
 of the type given by its first argument.
                                         
    case 47: // '/'
@@ -580,12 +610,12 @@ of the type given by its first argument.
                          var code = input.charCodeAt(tokPos);
 
-    if (inTemplate) return getTemplateToken(code);
                                                                                   
                                
               
Identifier or keyword. '\uXXXX' sequences are allowed in
+    if (inTemplate) return getTemplateToken(code);                                                                                   
                                
               
Identifier or keyword. '\uXXXX' sequences are allowed in
 identifiers, so '\' also dispatches to that.
                                         
    if (isIdentifierStart(code) || code === 92 /* '\' */) return readWord();
 
     var tok = getTokenFromCode(code);
 
-    if (tok === false) {
                                                                                   
                                
               
If we are here, we either found a non-ASCII identifier
+    if (tok === false) {                                                                                   
                                
               
If we are here, we either found a non-ASCII identifier
 character, or something that's entirely disallowed.
                                         
      var ch = String.fromCharCode(code);
       if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
       raise(tokPos, "Unexpected character '" + ch + "'");
@@ -597,7 +627,7 @@ character, or something that's entirely disallowed.
             
     var str = input.slice(tokPos, tokPos + size);
     tokPos += size;
     finishToken(type, str);
-  }
                                                                                   
                                
               
Parse a regular expression. Some context-awareness is necessary,
+  }                                                                                   
                                
               
Parse a regular expression. Some context-awareness is necessary,
 since a '/' inside a '[]' set does not end the expression.
                                         
  function readRegexp() {
     var content = "", escaped, inClass, start = tokPos;
     for (;;) {
@@ -613,7 +643,7 @@ since a '/' inside a '[]' set does not end the expression.
             
       ++tokPos;
     }
     var content = input.slice(start, tokPos);
-    ++tokPos;
                                                                                   
                                
               
Need to use readWord1 because '\uXXXX' sequences are allowed
+    ++tokPos;                                                                                   
                                
               
Need to use readWord1 because '\uXXXX' sequences are allowed
 here (don't ask).
                                         
    var mods = readWord1();
     if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regular expression flag");
     try {
@@ -623,7 +653,7 @@ here (don't ask).
                          
       raise(e);
     }
     return finishToken(_regexp, value);
-  }
                                                                                   
                                
               
Read an integer in the given radix. Return null if zero digits
+  }                                                                                   
                                
               
Read an integer in the given radix. Return null if zero digits
 were read, the integer value otherwise. When len is given, this
 will return null unless the integer has exactly len digits.
                                         
  function readInt(radix, len) {
     var start = tokPos, total = 0;
@@ -648,7 +678,7 @@ will return null unless the integer has exactly len di
     if (val == null) raise(tokStart + 2, "Expected number in radix " + radix);
     if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
     return finishToken(_num, val);
-  }
                                                                                   
                                
               
Read an integer, octal integer, or floating-point number.
                                         
  function readNumber(startsWithDot) {
+  }
                                                                                   
                                
               
Read an integer, octal integer, or floating-point number.
                                         
  function readNumber(startsWithDot) {
     var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
     if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
     if (input.charCodeAt(tokPos) === 46) {
@@ -671,7 +701,7 @@ will return null unless the integer has exactly len di
     else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
     else val = parseInt(str, 8);
     return finishToken(_num, val);
-  }
                                                                                   
                                
               
Read a string value, interpreting backslash-escapes.
                                         
  function readCodePoint() {
+  }
                                                                                   
                                
               
Read a string value, interpreting backslash-escapes.
                                         
  function readCodePoint() {
     var ch = input.charCodeAt(tokPos), code;
 
     if (ch === 123) {
@@ -682,7 +712,7 @@ will return null unless the integer has exactly len di
       if (code > 0x10FFFF) unexpected();
     } else {
       code = readHexChar(4);
-    }
                                                                                   
                                
               
UTF-16 Encoding
                                         
    if (code <= 0xFFFF) {
+    }
                                                                                   
                                
               
UTF-16 Encoding
                                         
    if (code <= 0xFFFF) {
       return String.fromCharCode(code);
     }
     var cu1 = ((code - 0x10000) >> 10) + 0xD800;
@@ -736,7 +766,7 @@ will return null unless the integer has exactly len di
         out += String.fromCharCode(ch); // '\'
       }
     }
-  }
                                                                                   
                                
               
Used to read escaped characters
                                         
  function readEscapedChar() {
+  }
                                                                                   
                                
               
Used to read escaped characters
                                         
  function readEscapedChar() {
     var ch = input.charCodeAt(++tokPos);
     var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
     if (octal) octal = octal[0];
@@ -766,13 +796,13 @@ will return null unless the integer has exactly len di
         default: return String.fromCharCode(ch);
       }
     }
-  }
                                                                                   
                                
               
Used to read character escape sequences ('\x', '\u', '\U').
                                         
  function readHexChar(len) {
+  }
                                                                                   
                                
               
Used to read character escape sequences ('\x', '\u', '\U').
                                         
  function readHexChar(len) {
     var n = readInt(16, len);
     if (n === null) raise(tokStart, "Bad character escape sequence");
     return n;
-  }
                                                                                   
                                
               
Used to signal to callers of readWord1 whether the word
+  }                                                                                   
                                
               
Used to signal to callers of readWord1 whether the word
 contained any escape sequences. This is needed because words with
-escape sequences must not be interpreted as keywords.
                                         
  var containsEsc;
                                                                                   
                                
               
Read an identifier, and return it as a string. Sets containsEsc
+escape sequences must not be interpreted as keywords.
                                         
  var containsEsc;
                                                                                   
                                
               
Read an identifier, and return it as a string. Sets containsEsc
 to whether the word contained a '\u' escape.

 
 
Only builds up the word character-by-character when it actually
@@ -802,14 +832,14 @@ containeds an escape, as a micro-optimization.
             
       first = false;
     }
     return containsEsc ? word : input.slice(start, tokPos);
-  }                                                                                   
                                
               
Read an identifier or keyword token. Will check for reserved
+  }                                                                                   
                                
               
Read an identifier or keyword token. Will check for reserved
 words when necessary.
                                         
  function readWord() {
     var word = readWord1();
     var type = _name;
     if (!containsEsc && isKeyword(word))
       type = keywordTypes[word];
     return finishToken(type, word);
-  }
                                                                                   
                                
               
Parser
                                         
                                                                                   
                                
               
A recursive descent parser operates by defining functions for all
+  }                                                                                   
                                
               
Parser
                                         
                                                                                   
                                
               
A recursive descent parser operates by defining functions for all
 syntactic elements, and recursively calling those, each function
 advancing the input stream and returning an AST node. Precedence
 of constructs (for example, the fact that !x[1] means !(x[1])
@@ -823,12 +853,12 @@ way, it'll receive the node for x[1] already parsed, and wraps
 operator precedence, because it is much more compact than using
 the technique outlined above, which uses different, nesting
 functions to specify precedence, for all of the ten binary
-precedence levels that JavaScript defines.
                                         
                                                                                   
                                
               
Parser utilities
                                         
                                                                                   
                                
               
Continue to the next token.
                                         
  function next() {
+precedence levels that JavaScript defines.
                                         
                                                                                   
                                
               
Parser utilities
                                         
                                                                                   
                                
               
Continue to the next token.
                                         
  function next() {
     lastStart = tokStart;
     lastEnd = tokEnd;
     lastEndLoc = tokEndLoc;
     readToken();
-  }
                                                                                   
                                
               
Enter strict mode. Re-reads the next token to please pedantic
+  }
                                                                                   
                                
               
Enter strict mode. Re-reads the next token to please pedantic
 tests ("use strict"; 010; -- should fail).
                                         
  function setStrict(strct) {
     strict = strct;
     tokPos = tokStart;
@@ -840,7 +870,7 @@ tests ("use strict"; 010; -- should fail).
                          }
     skipSpace();
     readToken();
-  }
                                                                                   
                                
               
Start an AST node, attaching a start offset.
                                         
  function Node() {
+  }
                                                                                   
                                
               
Start an AST node, attaching a start offset.
                                         
  function Node() {
     this.type = null;
     this.start = tokStart;
     this.end = null;
@@ -863,7 +893,7 @@ tests ("use strict"; 010; -- should fail).
                          if (options.ranges)
       node.range = [tokStart, 0];
     return node;
-  }
                                                                                   
                                
               
Start a node whose start offset information should be based on
+  }                                                                                   
                                
               
Start a node whose start offset information should be based on
 the start of another node. For example, a binary operator node is
 only started after its left-hand side has already been parsed.
                                         
  function startNodeFrom(other) {
     var node = new Node();
@@ -876,7 +906,7 @@ only started after its left-hand side has already been parsed.
             <
       node.range = [other.range[0], 0];
 
     return node;
-  }
                                                                                   
                                
               
Finish an AST node, adding type and end properties.
                                         
  function finishNode(node, type) {
+  }
                                                                                   
                                
               
Finish an AST node, adding type and end properties.
                                         
  function finishNode(node, type) {
     node.type = type;
     node.end = lastEnd;
     if (options.locations)
@@ -884,10 +914,10 @@ only started after its left-hand side has already been parsed.
             <
     if (options.ranges)
       node.range[1] = lastEnd;
     return node;
-  }
                                                                                   
                                
               
Test whether a statement node is the string literal "use strict".
                                         
  function isUseStrict(stmt) {
+  }
                                                                                   
                                
               
Test whether a statement node is the string literal "use strict".
                                         
  function isUseStrict(stmt) {
     return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
       stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
-  }
                                                                                   
                                
               
Predicate that tests whether the next token is of the given
+  }                                                                                   
                                
               
Predicate that tests whether the next token is of the given
 type, and if yes, consumes it as a side effect.
                                         
  function eat(type) {
     if (tokType === type) {
       next();
@@ -895,20 +925,20 @@ type, and if yes, consumes it as a side effect.
             
     } else {
       return false;
     }
-  }
                                                                                   
                                
               
Test whether a semicolon can be inserted at the current position.
                                         
  function canInsertSemicolon() {
+  }
                                                                                   
                                
               
Test whether a semicolon can be inserted at the current position.
                                         
  function canInsertSemicolon() {
     return !options.strictSemicolons &&
       (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
-  }
                                                                                   
                                
               
Consume a semicolon, or, failing that, see if we are allowed to
+  }                                                                                   
                                
               
Consume a semicolon, or, failing that, see if we are allowed to
 pretend that there is a semicolon at this position.
                                         
  function semicolon() {
     if (!eat(_semi) && !canInsertSemicolon()) unexpected();
-  }
                                                                                   
                                
               
Expect a token of a given type. If found, consume it, otherwise,
+  }                                                                                   
                                
               
Expect a token of a given type. If found, consume it, otherwise,
 raise an unexpected token error.
                                         
  function expect(type) {
     eat(type) || unexpected();
-  }
                                                                                   
                                
               
Raise an unexpected token error.
                                         
  function unexpected(pos) {
+  }
                                                                                   
                                
               
Raise an unexpected token error.
                                         
  function unexpected(pos) {
     raise(pos != null ? pos : tokStart, "Unexpected token");
-  }
                                                                                   
                                
               
Checks if hash object has a property.
                                         
  function has(obj, propName) {
+  }
                                                                                   
                                
               
Checks if hash object has a property.
                                         
  function has(obj, propName) {
     return Object.prototype.hasOwnProperty.call(obj, propName);
-  }
                                                                                   
                                
               
Convert existing expression atom to assignable pattern
+  }                                                                                   
                                
               
Convert existing expression atom to assignable pattern
 if possible.
                                         
  function toAssignable(node, allowSpread, checkType) {
     if (options.ecmaVersion >= 6 && node) {
       switch (node.type) {
@@ -946,10 +976,10 @@ if possible.
                                         <
       }
     }
     return node;
-  }
                                                                                   
                                
               
Checks if node can be assignable spread argument.
                                         
  function checkSpreadAssign(node) {
+  }
                                                                                   
                                
               
Checks if node can be assignable spread argument.
                                         
  function checkSpreadAssign(node) {
     if (node.type !== "Identifier" && node.type !== "ArrayPattern")
       unexpected(node.start);
-  }
                                                                                   
                                
               
Verify that argument names are not repeated, and it does not
+  }                                                                                   
                                
               
Verify that argument names are not repeated, and it does not
 try to bind the words eval or arguments.
                                         
  function checkFunctionParam(param, nameHash) {
     switch (param.type) {
       case "Identifier":
@@ -970,7 +1000,7 @@ try to bind the words eval or arguments.

           checkFunctionParam(param.elements[i], nameHash);
         break;
     }
-  }
                                                                                   
                                
               
Check if property name clashes with already added.
+  }                                                                                   
                                
               
Check if property name clashes with already added.
 Object/class getters and setters are not allowed to clash —
 either with each other or with an init property — and in
 strict mode, init properties are also not allowed to be repeated.
                                         
  function checkPropClash(prop, propHash) {
@@ -995,7 +1025,7 @@ strict mode, init properties are also not allowed to be repeated.

       };
     }
     other[kind] = true;
-  }
                                                                                   
                                
               
Verify that a node is an lval — something that can be assigned
+  }                                                                                   
                                
               
Verify that a node is an lval — something that can be assigned
 to.
                                         
  function checkLVal(expr, isBinding) {
     switch (expr.type) {
       case "Identifier":
@@ -1027,7 +1057,7 @@ to.
                                         
default:
         raise(expr.start, "Assigning to rvalue");
     }
-  }
                                                                                   
                                
               
Statement parsing
                                         
                                                                                   
                                
               
Parse a program. Initializes the parser, reads any number of
+  }                                                                                   
                                
               
Statement parsing
                                         
                                                                                   
                                
               
Parse a program. Initializes the parser, reads any number of
 statements, and wraps them in a Program node.  Optionally takes a
 program argument.  If present, the statements will be appended
 to its body instead of creating a new node.
                                         
  function parseTopLevel(program) {
@@ -1048,7 +1078,7 @@ to its body instead of creating a new node.
                          return finishNode(node, "Program");
   }
 
-  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
                                                                                   
                                
               
Parse a single statement.

+  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};                                                                                   
                                
               
Parse a single statement.

 
 
If expecting a statement and finding a slash operator, parse a
 regular expression literal. This is to handle cases like
@@ -1057,7 +1087,7 @@ does not help.
                          
     if (tokType === _slash || tokType === _assign && tokVal == "/=")
       readToken(true);
 
-    var starttype = tokType, node = startNode();                                                                                   
                                
               
Most types of statements are recognized by the keyword they
+    var starttype = tokType, node = startNode();                                                                                   
                                
               
Most types of statements are recognized by the keyword they
 start with. Many are trivial to parse, some require a bit of
 complexity.
                                         
    switch (starttype) {
     case _break: case _continue: return parseBreakContinueStatement(node, starttype.keyword);
@@ -1077,7 +1107,7 @@ complexity.
                                         case _braceL: return parseBlock(); // no point creating a function for this
     case _semi: return parseEmptyStatement(node);
     case _export: return parseExport(node);
-    case _import: return parseImport(node);
                                                                                   
                                
               
If the statement does not start with a statement keyword or a
+    case _import: return parseImport(node);                                                                                   
                                
               
If the statement does not start with a statement keyword or a
 brace, it's an ExpressionStatement or LabeledStatement. We
 simply start parsing an expression, and afterwards, if the
 next token is a colon and the expression was a simple
@@ -1097,7 +1127,7 @@ Identifier node, we switch to interpreting it as a label.
             
     else {
       node.label = parseIdent();
       semicolon();
-    }                                                                                   
                                
               
Verify that there is an actual destination to break or
+    }                                                                                   
                                
               
Verify that there is an actual destination to break or
 continue to.
                                         
    for (var i = 0; i < labels.length; ++i) {
       var lab = labels[i];
       if (node.label == null || lab.name === node.label.name) {
@@ -1124,7 +1154,7 @@ continue to.
                                         <
     node.test = parseParenExpression();
     semicolon();
     return finishNode(node, "DoWhileStatement");
-  }
                                                                                   
                                
               
Disambiguating between a for and a for/in or for/of
+  }                                                                                   
                                
               
Disambiguating between a for and a for/in or for/of
 loop is non-trivial. Basically, we have to parse the init var
 statement or expression, disallowing the in operator (see
 the second parameter to parseExpression), and then check
@@ -1169,7 +1199,7 @@ is a regular for loop.
                          function parseReturnStatement(node) {
     if (!inFunction && !options.allowReturnOutsideFunction)
       raise(tokStart, "'return' outside of function");
-    next();                                                                                   
                                
               
In return (and break/continue), the keywords with
+    next();                                                                                   
                                
               
In return (and break/continue), the keywords with
 optional arguments, we eagerly look for a semicolon or the
 possibility to insert one.
                                         
    if (eat(_semi) || canInsertSemicolon()) node.argument = null;
     else { node.argument = parseExpression(); semicolon(); }
@@ -1181,7 +1211,7 @@ possibility to insert one.
                          
     node.discriminant = parseParenExpression();
     node.cases = [];
     expect(_braceL);
-    labels.push(switchLabel);
                                                                                   
                                
               
Statements under must be grouped (by label) in SwitchCase
+    labels.push(switchLabel);                                                                                   
                                
               
Statements under must be grouped (by label) in SwitchCase
 nodes. cur is used to keep the node that we are currently
 adding statements to.
                                         
    for (var cur, sawDefault; tokType != _braceR;) {
       if (tokType === _case || tokType === _default) {
@@ -1283,13 +1313,13 @@ adding statements to.
                          
     node.expression = expr;
     semicolon();
     return finishNode(node, "ExpressionStatement");
-  }
                                                                                   
                                
               
Used for constructs like switch and if that insist on
+  }                                                                                   
                                
               
Used for constructs like switch and if that insist on
 parentheses around their expression.
                                         
  function parseParenExpression() {
     expect(_parenL);
     var val = parseExpression();
     expect(_parenR);
     return val;
-  }
                                                                                   
                                
               
Parse a semicolon-enclosed block of statements, handling "use
+  }                                                                                   
                                
               
Parse a semicolon-enclosed block of statements, handling "use
 strict" declarations when allowStrict is true (used for
 function bodies).
                                         
  function parseBlock(allowStrict) {
     var node = startNode(), first = true, strict = false, oldStrict;
@@ -1306,7 +1336,7 @@ function bodies).
                          
     }
     if (strict && !oldStrict) setStrict(false);
     return finishNode(node, "BlockStatement");
-  }
                                                                                   
                                
               
Parse a regular for loop. The disambiguation code in
+  }                                                                                   
                                
               
Parse a regular for loop. The disambiguation code in
 parseStatement will already have parsed the init statement or
 expression.
                                         
  function parseFor(node, init) {
     node.init = init;
@@ -1318,7 +1348,7 @@ expression.
                                         node.body = parseStatement();
     labels.pop();
     return finishNode(node, "ForStatement");
-  }
                                                                                   
                                
               
Parse a for/in and for/of loop, which are almost
+  }                                                                                   
                                
               
Parse a for/in and for/of loop, which are almost
 same from parser's perspective.
                                         
  function parseForIn(node, init) {
     var type = tokType === _in ? "ForInStatement" : "ForOfStatement";
     next();
@@ -1328,7 +1358,7 @@ same from parser's perspective.
                          node.body = parseStatement();
     labels.pop();
     return finishNode(node, type);
-  }
                                                                                   
                                
               
Parse a list of variable declarations.
                                         
  function parseVar(node, noIn, kind) {
+  }
                                                                                   
                                
               
Parse a list of variable declarations.
                                         
  function parseVar(node, noIn, kind) {
     node.declarations = [];
     node.kind = kind;
     for (;;) {
@@ -1340,11 +1370,11 @@ same from parser's perspective.
                          if (!eat(_comma)) break;
     }
     return node;
-  }
                                                                                   
                                
               
Expression parsing
                                         
                                                                                   
                                
               
These nest, from the most general expression type at the top to
+  }                                                                                   
                                
               
Expression parsing
                                         
                                                                                   
                                
               
These nest, from the most general expression type at the top to
 'atomic', nondivisible expression types at the bottom. Most of
 the functions will simply let the function(s) below them parse,
 and, if the syntactic construct they handle is present, wrap
-the AST node that the inner parser gave them in another node.
                                         
                                                                                   
                                
               
Parse a full expression. The arguments are used to forbid comma
+the AST node that the inner parser gave them in another node.
                                         
                                                                                   
                                
               
Parse a full expression. The arguments are used to forbid comma
 sequences (in argument lists, array literals, or object literals)
 or the in operator (in for loops initalization expressions).
                                         
  function parseExpression(noComma, noIn) {
     var expr = parseMaybeAssign(noIn);
@@ -1355,7 +1385,7 @@ or the in operator (in for loops initalization expressions).

       return finishNode(node, "SequenceExpression");
     }
     return expr;
-  }
                                                                                   
                                
               
Parse an assignment expression. This includes applications of
+  }                                                                                   
                                
               
Parse an assignment expression. This includes applications of
 operators like +=.
                                         
  function parseMaybeAssign(noIn) {
     var left = parseMaybeConditional(noIn);
     if (tokType.isAssign) {
@@ -1368,7 +1398,7 @@ operators like +=.
                          return finishNode(node, "AssignmentExpression");
     }
     return left;
-  }
                                                                                   
                                
               
Parse a ternary conditional (?:) operator.
                                         
  function parseMaybeConditional(noIn) {
+  }
                                                                                   
                                
               
Parse a ternary conditional (?:) operator.
                                         
  function parseMaybeConditional(noIn) {
     var expr = parseExprOps(noIn);
     if (eat(_question)) {
       var node = startNodeFrom(expr);
@@ -1379,9 +1409,9 @@ operators like +=.
                          return finishNode(node, "ConditionalExpression");
     }
     return expr;
-  }
                                                                                   
                                
               
Start the precedence parser.
                                         
  function parseExprOps(noIn) {
+  }
                                                                                   
                                
               
Start the precedence parser.
                                         
  function parseExprOps(noIn) {
     return parseExprOp(parseMaybeUnary(), -1, noIn);
-  }
                                                                                   
                                
               
Parse binary operators with the operator precedence parsing
+  }                                                                                   
                                
               
Parse binary operators with the operator precedence parsing
 algorithm. left is the left-hand side of the operator.
 minPrec provides context that allows the function to stop and
 defer further parser to one of its callers when it encounters an
@@ -1400,7 +1430,7 @@ operator that has a lower precedence than the set it is parsing.

       }
     }
     return left;
-  }                                                                                   
                                
               
Parse unary operators, both prefix and postfix.
                                         
  function parseMaybeUnary() {
+  }
                                                                                   
                                
               
Parse unary operators, both prefix and postfix.
                                         
  function parseMaybeUnary() {
     if (tokType.prefix) {
       var node = startNode(), update = tokType.isUpdate;
       node.operator = tokVal;
@@ -1425,7 +1455,7 @@ operator that has a lower precedence than the set it is parsing.

       expr = finishNode(node, "UpdateExpression");
     }
     return expr;
-  }
                                                                                   
                                
               
Parse call, dot, and []-subscript expressions.
                                         
  function parseExprSubscripts() {
+  }
                                                                                   
                                
               
Parse call, dot, and []-subscript expressions.
                                         
  function parseExprSubscripts() {
     return parseSubscripts(parseExprAtom());
   }
 
@@ -1454,7 +1484,7 @@ operator that has a lower precedence than the set it is parsing.

       node.quasi = parseTemplate();
       return parseSubscripts(finishNode(node, "TaggedTemplateExpression"), noCalls);
     } return base;
-  }
                                                                                   
                                
               
Parse an atomic expression — either a single token that is an
+  }                                                                                   
                                
               
Parse an atomic expression — either a single token that is an
 expression, an expression started by a keyword like function or
 new, or an expression wrapped in punctuation like (), [],
 or {}.
                                         
  function parseExprAtom() {
@@ -1490,7 +1520,7 @@ or {}.
                          
 
     case _parenL:
       var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart, val, exprList;
-      next();
                                                                                   
                                
               
check whether this is generator comprehension or regular expression
                                         
      if (options.ecmaVersion >= 6 && tokType === _for) {
+      next();
                                                                                   
                                
               
check whether this is generator comprehension or regular expression
                                         
      if (options.ecmaVersion >= 6 && tokType === _for) {
         val = parseComprehension(startNode(), true);
       } else {
         var oldParenL = ++metParenL;
@@ -1500,9 +1530,9 @@ or {}.
                          
         } else {
           exprList = [];
         }
-        expect(_parenR);
                                                                                   
                                
               
if '=>' follows '(...)', convert contents to arguments
                                         
        if (metParenL === oldParenL && eat(_arrow)) {
+        expect(_parenR);
                                                                                   
                                
               
if '=>' follows '(...)', convert contents to arguments
                                         
        if (metParenL === oldParenL && eat(_arrow)) {
           val = parseArrowExpression(startNode(), exprList);
-        } else {
                                                                                   
                                
               
forbid '()' before everything but '=>'
                                         
          if (!val) unexpected(lastStart);
                                                                                   
                                
               
forbid '...' in sequence expressions
                                         
          if (options.ecmaVersion >= 6) {
+        } else {
                                                                                   
                                
               
forbid '()' before everything but '=>'
                                         
          if (!val) unexpected(lastStart);
                                                                                   
                                
               
forbid '...' in sequence expressions
                                         
          if (options.ecmaVersion >= 6) {
             for (var i = 0; i < exprList.length; i++) {
               if (exprList[i].type === "SpreadElement") unexpected();
             }
@@ -1522,7 +1552,7 @@ or {}.
                          
 
     case _bracketL:
       var node = startNode();
-      next();
                                                                                   
                                
               
check whether this is array comprehension or regular array
                                         
      if (options.ecmaVersion >= 6 && tokType === _for) {
+      next();
                                                                                   
                                
               
check whether this is array comprehension or regular array
                                         
      if (options.ecmaVersion >= 6 && tokType === _for) {
         return parseComprehension(node, false);
       }
       node.elements = parseExprList(_bracketR, true, true);
@@ -1551,7 +1581,7 @@ or {}.
                          
     default:
       unexpected();
     }
-  }
                                                                                   
                                
               
New's precedence is slightly tricky. It must allow its argument
+  }                                                                                   
                                
               
New's precedence is slightly tricky. It must allow its argument
 to be a [] or dot subscript expression, but not a call — at
 least, not without wrapping it in parentheses. Thus, it uses the
                                         
  function parseNew() {
     var node = startNode();
@@ -1560,12 +1590,12 @@ least, not without wrapping it in parentheses. Thus, it uses the

     if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
     else node.arguments = empty;
     return finishNode(node, "NewExpression");
-  }
                                                                                   
                                
               
Parse spread element '...expr'
                                         
  function parseSpread() {
+  }
                                                                                   
                                
               
Parse spread element '...expr'
                                         
  function parseSpread() {
     var node = startNode();
     next();
     node.argument = parseExpression(true);
     return finishNode(node, "SpreadElement");
-  }
                                                                                   
                                
               
Parse template expression.
                                         
  function parseTemplate() {
+  }
                                                                                   
                                
               
Parse template expression.
                                         
  function parseTemplate() {
     var node = startNode();
     node.expressions = [];
     node.quasis = [];
@@ -1589,7 +1619,7 @@ least, not without wrapping it in parentheses. Thus, it uses the

     }
     inTemplate = false;
     return finishNode(node, "TemplateLiteral");
-  }
                                                                                   
                                
               
Parse an object literal.
                                         
  function parseObj() {
+  }
                                                                                   
                                
               
Parse an object literal.
                                         
  function parseObj() {
     var node = startNode(), first = true, propHash = {};
     node.properties = [];
     next();
@@ -1643,7 +1673,7 @@ least, not without wrapping it in parentheses. Thus, it uses the

       }
     }
     prop.key = (tokType === _num || tokType === _string) ? parseExprAtom() : parseIdent(true);
-  }
                                                                                   
                                
               
Initialize empty function node.
                                         
  function initFunction(node) {
+  }
                                                                                   
                                
               
Initialize empty function node.
                                         
  function initFunction(node) {
     node.id = null;
     node.params = [];
     if (options.ecmaVersion >= 6) {
@@ -1651,7 +1681,7 @@ least, not without wrapping it in parentheses. Thus, it uses the

       node.rest = null;
       node.generator = false;
     }
-  }
                                                                                   
                                
               
Parse a function declaration or literal (depending on the
+  }                                                                                   
                                
               
Parse a function declaration or literal (depending on the
 isStatement parameter).
                                         
  function parseFunction(node, isStatement, allowExpressionBody) {
     initFunction(node);
     if (options.ecmaVersion >= 6) {
@@ -1663,7 +1693,7 @@ least, not without wrapping it in parentheses. Thus, it uses the

     parseFunctionParams(node);
     parseFunctionBody(node, allowExpressionBody);
     return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  }
                                                                                   
                                
               
Parse object or class method.
                                         
  function parseMethod(isGenerator) {
+  }
                                                                                   
                                
               
Parse object or class method.
                                         
  function parseMethod(isGenerator) {
     var node = startNode();
     initFunction(node);
     parseFunctionParams(node);
@@ -1676,7 +1706,7 @@ least, not without wrapping it in parentheses. Thus, it uses the

     }
     parseFunctionBody(node, allowExpressionBody);
     return finishNode(node, "FunctionExpression");
-  }
                                                                                   
                                
               
Parse arrow function expression with given parameters.
                                         
  function parseArrowExpression(node, params) {
+  }
                                                                                   
                                
               
Parse arrow function expression with given parameters.
                                         
  function parseArrowExpression(node, params) {
     initFunction(node);
 
     var defaults = node.defaults, hasDefaults = false;
@@ -1704,7 +1734,7 @@ least, not without wrapping it in parentheses. Thus, it uses the

 
     parseFunctionBody(node, true);
     return finishNode(node, "ArrowFunctionExpression");
-  }
                                                                                   
                                
               
Parse function parameters.
                                         
  function parseFunctionParams(node) {
+  }
                                                                                   
                                
               
Parse function parameters.
                                         
  function parseFunctionParams(node) {
     var defaults = [], hasDefaults = false;
 
     expect(_parenL);
@@ -1731,19 +1761,19 @@ least, not without wrapping it in parentheses. Thus, it uses the

     }
 
     if (hasDefaults) node.defaults = defaults;
-  }
                                                                                   
                                
               
Parse function body and check parameters.
                                         
  function parseFunctionBody(node, allowExpression) {
+  }
                                                                                   
                                
               
Parse function body and check parameters.
                                         
  function parseFunctionBody(node, allowExpression) {
     var isExpression = allowExpression && tokType !== _braceL;
 
     if (isExpression) {
       node.body = parseExpression(true);
       node.expression = true;
-    } else {
                                                                                   
                                
               
Start a new scope with regard to labels and the inFunction
+    } else {                                                                                   
                                
               
Start a new scope with regard to labels and the inFunction
 flag (restore them to their old value afterwards).
                                         
      var oldInFunc = inFunction, oldInGen = inGenerator, oldLabels = labels;
       inFunction = true; inGenerator = node.generator; labels = [];
       node.body = parseBlock(true);
       node.expression = false;
       inFunction = oldInFunc; inGenerator = oldInGen; labels = oldLabels;
-    }
                                                                                   
                                
               
If this is a strict mode function, verify that argument names
+    }                                                                                   
                                
               
If this is a strict mode function, verify that argument names
 are not repeated, and it does not try to bind the words eval
 or arguments.
                                         
    if (strict || !isExpression && node.body.body.length && isUseStrict(node.body.body[0])) {
       var nameHash = {};
@@ -1754,7 +1784,7 @@ or arguments.
                          
       if (node.rest)
         checkFunctionParam(node.rest, nameHash);
     }
-  }
                                                                                   
                                
               
Parse a class declaration or literal (depending on the
+  }                                                                                   
                                
               
Parse a class declaration or literal (depending on the
 isStatement parameter).
                                         
  function parseClass(node, isStatement) {
     next();
     node.id = tokType === _name ? parseIdent() : isStatement ? unexpected() : null;
@@ -1787,7 +1817,7 @@ or arguments.
                          
     }
     node.body = finishNode(classBody, "ClassBody");
     return finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
-  }
                                                                                   
                                
               
Parses a comma-separated list of expressions, and returns them as
+  }                                                                                   
                                
               
Parses a comma-separated list of expressions, and returns them as
 an array. close is the token type that ends the list, and
 allowEmpty can be turned on to allow subsequent commas with
 nothing in between them to be parsed as null (which is needed
@@ -1803,7 +1833,7 @@ for array literals).
                          
       else elts.push(parseExpression(true));
     }
     return elts;
-  }                                                                                   
                                
               
Parse the next token as an identifier. If liberal is true (used
+  }                                                                                   
                                
               
Parse the next token as an identifier. If liberal is true (used
 when parsing properties), it will also convert keywords into
 identifiers.
                                         
  function parseIdent(liberal) {
     var node = startNode();
@@ -1824,19 +1854,19 @@ identifiers.
                                         <
     tokRegexpAllowed = false;
     next();
     return finishNode(node, "Identifier");
-  }
                                                                                   
                                
               
Parses module export declaration.
                                         
  function parseExport(node) {
-    next();
                                                                                   
                                
               
export var|const|let|function|class ...;
                                         
    if (tokType === _var || tokType === _const || tokType === _let || tokType === _function || tokType === _class) {
+  }
                                                                                   
                                
               
Parses module export declaration.
                                         
  function parseExport(node) {
+    next();
                                                                                   
                                
               
export var|const|let|function|class ...;
                                         
    if (tokType === _var || tokType === _const || tokType === _let || tokType === _function || tokType === _class) {
       node.declaration = parseStatement();
       node['default'] = false;
       node.specifiers = null;
       node.source = null;
-    } else
                                                                                   
                                
               
export default ...;
                                         
    if (eat(_default)) {
+    } else
                                                                                   
                                
               
export default ...;
                                         
    if (eat(_default)) {
       node.declaration = parseExpression(true);
       node['default'] = true;
       node.specifiers = null;
       node.source = null;
       semicolon();
-    } else {
                                                                                   
                                
               
export * from '...'
+    } else {                                                                                   
                                
               
export * from '...'
 export { x, y as z } [from '...']
                                         
      var isBatch = tokType === _star;
       node.declaration = null;
       node['default'] = false;
@@ -1850,12 +1880,12 @@ export { x, y as z } [from '...']
                          }
     }
     return finishNode(node, "ExportDeclaration");
-  }
                                                                                   
                                
               
Parses a comma-separated list of module exports.
                                         
  function parseExportSpecifiers() {
+  }
                                                                                   
                                
               
Parses a comma-separated list of module exports.
                                         
  function parseExportSpecifiers() {
     var nodes = [], first = true;
-    if (tokType === _star) {
                                                                                   
                                
               
export * from '...'
                                         
      var node = startNode();
+    if (tokType === _star) {
                                                                                   
                                
               
export * from '...'
                                         
      var node = startNode();
       next();
       nodes.push(finishNode(node, "ExportBatchSpecifier"));
-    } else {
                                                                                   
                                
               
export { x, y as z } [from '...']
                                         
      expect(_braceL);
+    } else {
                                                                                   
                                
               
export { x, y as z } [from '...']
                                         
      expect(_braceL);
       while (!eat(_braceR)) {
         if (!first) {
           expect(_comma);
@@ -1874,8 +1904,8 @@ export { x, y as z } [from '...']
                          }
     }
     return nodes;
-  }
                                                                                   
                                
               
Parses import declaration.
                                         
  function parseImport(node) {
-    next();
                                                                                   
                                
               
import '...';
                                         
    if (tokType === _string) {
+  }
                                                                                   
                                
               
Parses import declaration.
                                         
  function parseImport(node) {
+    next();
                                                                                   
                                
               
import '...';
                                         
    if (tokType === _string) {
       node.specifiers = [];
       node.source = parseExprAtom();
       node.kind = "";
@@ -1883,11 +1913,11 @@ export { x, y as z } [from '...']
                          node.specifiers = parseImportSpecifiers();
       if (tokType !== _name || tokVal !== "from") unexpected();
       next();
-      node.source = tokType === _string ? parseExprAtom() : unexpected();
                                                                                   
                                
               
only for backward compatibility with Esprima's AST
+      node.source = tokType === _string ? parseExprAtom() : unexpected();                                                                                   
                                
               
only for backward compatibility with Esprima's AST
 (it doesn't support mixed default + named yet)
                                         
      node.kind = node.specifiers[0]['default'] ? "default" : "named";
     }
     return finishNode(node, "ImportDeclaration");
-  }
                                                                                   
                                
               
Parses a comma-separated list of module imports.
                                         
  function parseImportSpecifiers() {
+  }
                                                                                   
                                
               
Parses a comma-separated list of module imports.
                                         
  function parseImportSpecifiers() {
     var nodes = [], first = true;
     if (tokType === _star) {
       var node = startNode();
@@ -1899,7 +1929,7 @@ export { x, y as z } [from '...']
                          nodes.push(finishNode(node, "ImportBatchSpecifier"));
       return nodes;
     }
-    if (tokType === _name) {
                                                                                   
                                
               
import defaultObj, { x, y as z } from '...'
                                         
      var node = startNode();
+    if (tokType === _name) {
                                                                                   
                                
               
import defaultObj, { x, y as z } from '...'
                                         
      var node = startNode();
       node.id = parseIdent();
       checkLVal(node.id, true);
       node.name = null;
@@ -1927,7 +1957,7 @@ export { x, y as z } [from '...']
                          nodes.push(finishNode(node, "ImportSpecifier"));
     }
     return nodes;
-  }
                                                                                   
                                
               
Parses yield expression inside generator.
                                         
  function parseYield() {
+  }
                                                                                   
                                
               
Parses yield expression inside generator.
                                         
  function parseYield() {
     var node = startNode();
     next();
     if (eat(_semi) || canInsertSemicolon()) {
@@ -1938,7 +1968,7 @@ export { x, y as z } [from '...']
                          node.argument = parseExpression(true);
     }
     return finishNode(node, "YieldExpression");
-  }
                                                                                   
                                
               
Parses array and generator comprehensions.
                                         
  function parseComprehension(node, isGenerator) {
+  }
                                                                                   
                                
               
Parses array and generator comprehensions.
                                         
  function parseComprehension(node, isGenerator) {
     node.blocks = [];
     while (tokType === _for) {
       var block = startNode();
@@ -1947,7 +1977,7 @@ export { x, y as z } [from '...']
                          block.left = toAssignable(parseExprAtom());
       checkLVal(block.left, true);
       if (tokType !== _name || tokVal !== "of") unexpected();
-      next();
                                                                                   
                                
               
of property is here for compatibility with Esprima's AST
+      next();                                                                                   
                                
               
of property is here for compatibility with Esprima's AST
 which also supports deprecated [for (... in ...) expr]
                                         
      block.of = true;
       block.right = parseExpression();
       expect(_parenR);

From 4d4daa07e06821527f3a1c39738ccc9e10b3eb4a Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke 
Date: Fri, 12 Sep 2014 15:50:34 +0200
Subject: [PATCH 02/25] Don't keep the docco output in the repository anymore


From 0322beb0aa5d170e427d76f668afaf3088fc5e29 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke 
Date: Fri, 12 Sep 2014 16:54:28 +0200
Subject: [PATCH 03/25] Add a prepublish step to package.json

---
 README.md        | 3 ++-
 bin/without_eval | 7 ++-----
 package.json     | 5 ++++-
 3 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index 82ecd6b77c..531f38063a 100644
--- a/README.md
+++ b/README.md
@@ -188,7 +188,8 @@ in a context with such a
 
 The `bin/without_eval` script can be used to generate a version of
 `acorn.js` that has the generated code inlined, and can thus run
-without evaluating anything.
+without evaluating anything. In versions of this library downloaded
+from NPM, this script will be available as `acorn_csp.js`.
 
 ### acorn_loose.js ###
 
diff --git a/bin/without_eval b/bin/without_eval
index fd8befb6b0..e9ef18f380 100755
--- a/bin/without_eval
+++ b/bin/without_eval
@@ -6,15 +6,12 @@ var acornSrc = fs.readFileSync(require.resolve("../acorn"), "utf8");
 var acorn = require("../acorn"), walk = require("../util/walk");
 
 var ast = acorn.parse(acornSrc);
-var touchups = [];
-var uses = [], declaration;
+var touchups = [], uses = [];
 
 walk.simple(ast, {
   FunctionDeclaration: function(node) {
-    if (node.id.name == "makePredicate") {
+    if (node.id.name == "makePredicate")
       touchups.push({text: "// Removed to create an eval-free library", from: node.start, to: node.end});
-      declaration = node;
-    }
   },
   VariableDeclaration: function(node) {
     node.declarations.forEach(function(decl) {
diff --git a/package.json b/package.json
index 8f029de5cb..808e0a8ca7 100644
--- a/package.json
+++ b/package.json
@@ -12,7 +12,10 @@
                    "url": "http://marijnhaverbeke.nl/git/acorn"},
     "licenses": [{"type": "MIT",
                   "url": "http://marijnhaverbeke.nl/acorn/LICENSE"}],
-    "scripts": {"test": "node test/run.js"},
+    "scripts": {
+      "test": "node test/run.js",
+      "prepublish": "bin/without_eval > acorn_csp.js"
+    },
     "bin": {"acorn": "./bin/acorn"},
     "devDependencies": {"regenerate": "~0.6.2",
                         "unicode-7.0.0": "~0.1.5"}

From d98a43267346e3dec33632a3084c2a94b0f4fe03 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke 
Date: Fri, 12 Sep 2014 16:55:42 +0200
Subject: [PATCH 04/25] Really remove html from git repository

(The hook was still in place last time.)
---
 index.html | 1995 ----------------------------------------------------
 1 file changed, 1995 deletions(-)
 delete mode 100644 index.html

diff --git a/index.html b/index.html
deleted file mode 100644
index 855387dbb8..0000000000
--- a/index.html
+++ /dev/null
@@ -1,1995 +0,0 @@
-      acorn.js           
     
          
                
                        
               acorn.js             
           		                               
                                             
                            
                                
               
Acorn is a tiny, fast JavaScript parser written in JavaScript.

-
-
Acorn was written by Marijn Haverbeke and various contributors and
-released under an MIT license. The Unicode regexps (for identifiers
-and whitespace) were taken from Esprima by
-Ariya Hidayat.

-
-
Git repositories for Acorn are available at

-
-
http://marijnhaverbeke.nl/git/acorn
-https://github.com/marijnh/acorn.git
-

-
-
Please use the github bug tracker to report issues.

-
-
This file defines the main parser interface. The library also comes
-with a error-tolerant parser and an
-abstract syntax tree walker, defined in other files.
             		                            
(function(root, mod) {
-  if (typeof exports == "object" && typeof module == "object") return mod(exports); // CommonJS
-  if (typeof define == "function" && define.amd) return define(["exports"], mod); // AMD
-  mod(root.acorn || (root.acorn = {})); // Plain browser env
-})(this, function(exports) {
-  "use strict";
-
-  exports.version = "0.7.1";
             		           
                               
                            
                                
               
The main exported interface (under self.acorn when in the
-browser) is a parse function that takes a code string and
-returns an abstract syntax tree as specified by Mozilla parser
-API, with the caveat that inline XML is not recognized.
             		                            
  var options, input, inputLen, sourceFile;
-
-  exports.parse = function(inpt, opts) {
-    input = String(inpt); inputLen = input.length;
-    setOptions(opts);
-    initTokenState();
-    return parseTopLevel(options.program);
-  };
             		           
                               
                            
                                
               
A second optional argument can be given to further configure
-the parser process. These options are recognized:
             		                            
  var defaultOptions = exports.defaultOptions = {
             		           
                               
                            
                                
               
ecmaVersion indicates the ECMAScript version to parse. Must
-be either 3, or 5, or 6. This influences support for strict
-mode, the set of reserved words, support for getters and
-setters and other features.
             		                            
    ecmaVersion: 5,
             		           
                               
                            
                                
               
Turn on strictSemicolons to prevent the parser from doing
-automatic semicolon insertion.
             		                            
    strictSemicolons: false,
             		           
                               
                            
                                
               
When allowTrailingCommas is false, the parser will not allow
-trailing commas in array and object literals.
             		                            
    allowTrailingCommas: true,
             		           
                               
                            
                                
               
By default, reserved words are not enforced. Enable
-forbidReserved to enforce them. When this option has the
-value "everywhere", reserved words and keywords can also not be
-used as property names.
             		                            
    forbidReserved: false,
             		           
                               
                            
                                
               
When enabled, a return at the top level is not considered an
-error.
             		                            
    allowReturnOutsideFunction: false,
             		           
                               
                            
                                
               
When locations is on, loc properties holding objects with
-start and end properties in {line, column} form (with
-line being 1-based and column 0-based) will be attached to the
-nodes.
             		                            
    locations: false,
             		           
                               
                            
                                
               
A function can be passed as onToken option, which will
-cause Acorn to call that function with object in the same
-format as tokenize() returns. Note that you are not
-allowed to call the parser from the callback—that will
-corrupt its internal state.
             		                            
    onToken: null,
             		           
                               
                            
                                
               
A function can be passed as onComment option, which will
-cause Acorn to call that function with (block, text, start,
-end) parameters whenever a comment is skipped. block is a
-boolean indicating whether this is a block (/* */) comment,
-text is the content of the comment, and start and end are
-character offsets that denote the start and end of the comment.
-When the locations option is on, two more parameters are
-passed, the full {line, column} locations of the start and
-end of the comments. Note that you are not allowed to call the
-parser from the callback—that will corrupt its internal state.
             		                            
    onComment: null,
             		           
                               
                            
                                
               
Nodes have their start and end characters offsets recorded in
-start and end properties (directly on the node, rather than
-the loc object, which holds line/column data. To also add a
-semi-standardized range property holding a [start,
-end] array with the same numbers, set the ranges option to
-true.
             		                            
    ranges: false,
             		           
                               
                            
                                
               
It is possible to parse multiple files into a single AST by
-passing the tree produced by parsing the first file as
-program option in subsequent parses. This will add the
-toplevel forms of the parsed file to the Program (top) node
-of an existing parse tree.
             		                            
    program: null,
             		           
                               
                            
                                
               
When locations is on, you can pass this to record the source
-file in every node's loc object.
             		                            
    sourceFile: null,
             		           
                               
                            
                                
               
This value, if given, is stored in every node, whether
-locations is on or off.
             		                            
    directSourceFile: null
-  };
-
-  var isArray = function (obj) {
-    return Object.prototype.toString.call(obj) === "[object Array]";
-  };
-
-  function setOptions(opts) {
-    options = opts || {};
-    for (var opt in defaultOptions) if (!has(options, opt))
-      options[opt] = defaultOptions[opt];
-    sourceFile = options.sourceFile || null;
-    if (isArray(options.onToken)) {
-      var tokens = options.onToken;
-      options.onToken = function (token) {
-        tokens.push(token);
-      };
-    }
-    if (isArray(options.onComment)) {
-      var comments = options.onComment;
-      options.onComment = function (block, text, start, end, startLoc, endLoc) {
-        var comment = {
-          type: block ? 'Block' : 'Line',
-          value: text,
-          start: start,
-          end: end
-        };
-        if (options.locations) {
-          comment.loc = new SourceLocation();
-          comment.loc.start = startLoc;
-          comment.loc.end = endLoc;
-        }
-        if (options.ranges)
-          comment.range = [start, end];
-        comments.push(comment);
-      };
-    }
-    isKeyword = options.ecmaVersion >= 6 ? isEcma6Keyword : isEcma5AndLessKeyword;
-  }
             		           
                               
                            
                                
               
The getLineInfo function is mostly useful when the
-locations option is off (for performance reasons) and you
-want to find the line/column position for a given character
-offset. input should be the code string that the offset refers
-into.
             		                            
  var getLineInfo = exports.getLineInfo = function(input, offset) {
-    for (var line = 1, cur = 0;;) {
-      lineBreak.lastIndex = cur;
-      var match = lineBreak.exec(input);
-      if (match && match.index < offset) {
-        ++line;
-        cur = match.index + match[0].length;
-      } else break;
-    }
-    return {line: line, column: offset - cur};
-  };
-
-  function Token() {
-    this.type = tokType;
-    this.value = tokVal;
-    this.start = tokStart;
-    this.end = tokEnd;
-    if (options.locations) {
-      this.loc = new SourceLocation();
-      this.loc.end = tokEndLoc;
             		           
                               
                            
                                
               
TODO: remove in next major release
             		                            
      this.startLoc = tokStartLoc;
-      this.endLoc = tokEndLoc;
-    }
-    if (options.ranges)
-      this.range = [tokStart, tokEnd];
-  }
-
-  exports.Token = Token;
             		           
                               
                            
                                
               
Acorn is organized as a tokenizer and a recursive-descent parser.
-The tokenize export provides an interface to the tokenizer.
-Because the tokenizer is optimized for being efficiently used by
-the Acorn parser itself, this interface is somewhat crude and not
-very modular. Performing another parse or call to tokenize will
-reset the internal state, and invalidate existing tokenizers.
             		                            
  exports.tokenize = function(inpt, opts) {
-    input = String(inpt); inputLen = input.length;
-    setOptions(opts);
-    initTokenState();
-
-    function getToken(forceRegexp) {
-      lastEnd = tokEnd;
-      readToken(forceRegexp);
-      return new Token();
-    }
-    getToken.jumpTo = function(pos, reAllowed) {
-      tokPos = pos;
-      if (options.locations) {
-        tokCurLine = 1;
-        tokLineStart = lineBreak.lastIndex = 0;
-        var match;
-        while ((match = lineBreak.exec(input)) && match.index < pos) {
-          ++tokCurLine;
-          tokLineStart = match.index + match[0].length;
-        }
-      }
-      tokRegexpAllowed = reAllowed;
-      skipSpace();
-    };
-    return getToken;
-  };
             		           
                               
                            
                                
               
State is kept in (closure-)global variables. We already saw the
-options, input, and inputLen variables above.
             		                            
             		           
                               
                            
                                
               
The current position of the tokenizer in the input.
             		                            
  var tokPos;
             		           
                               
                            
                                
               
The start and end offsets of the current token.
             		                            
  var tokStart, tokEnd;
             		           
                               
                            
                                
               
When options.locations is true, these hold objects
-containing the tokens start and end line/column pairs.
             		                            
  var tokStartLoc, tokEndLoc;
             		           
                               
                            
                                
               
The type and value of the current token. Token types are objects,
-named by variables against which they can be compared, and
-holding properties that describe them (indicating, for example,
-the precedence of an infix operator, and the original name of a
-keyword token). The kind of value that's held in tokVal depends
-on the type of the token. For literals, it is the literal value,
-for operators, the operator name, and so on.
             		                            
  var tokType, tokVal;
             		           
                               
                            
                                
               
Internal state for the tokenizer. To distinguish between division
-operators and regular expressions, it remembers whether the last
-token was one that is allowed to be followed by an expression.
-(If it is, a slash is probably a regexp, if it isn't it's a
-division operator. See the parseStatement function for a
-caveat.)
             		                            
  var tokRegexpAllowed;
             		           
                               
                            
                                
               
When options.locations is true, these are used to keep
-track of the current line, and know when a new line has been
-entered.
             		                            
  var tokCurLine, tokLineStart;
             		           
                               
                            
                                
               
These store the position of the previous token, which is useful
-when finishing a node and assigning its end position.
             		                            
  var lastStart, lastEnd, lastEndLoc;
             		           
                               
                            
                                
               
This is the parser's state. inFunction is used to reject
-return statements outside of functions, inGenerator to
-reject yields outside of generators, labels to verify
-that break and continue have somewhere to jump to, and
-strict indicates whether strict mode is on.
             		                            
  var inFunction, inGenerator, labels, strict;
             		           
                               
                            
                                
               
This counter is used for checking that arrow expressions did
-not contain nested parentheses in argument list.
             		                            
  var metParenL;
             		           
                               
                            
                                
               
This is used by parser for detecting if it's inside ES6
-Template String. If it is, it should treat '$' as prefix before
-'{expression}' and everything else as string literals.
             		                            
  var inTemplate;
             		           
                               
                            
                                
               
This function is used to raise exceptions on parse errors. It
-takes an offset integer (into the current input) to indicate
-the location of the error, attaches the position to the end
-of the error message, and then raises a SyntaxError with that
-message.
             		                            
  function raise(pos, message) {
-    var loc = getLineInfo(input, pos);
-    message += " (" + loc.line + ":" + loc.column + ")";
-    var err = new SyntaxError(message);
-    err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
-    throw err;
-  }
             		           
                               
                            
                                
               
Reused empty array added for node fields that are always empty.
             		                            
  var empty = [];
             		           
                               
                            
                                
               
Token types
             		                            
             		           
                               
                            
                                
               
The assignment of fine-grained, information-carrying type objects
-allows the tokenizer to store the information it has about a
-token in a way that is very cheap for the parser to look up.
             		                            
             		           
                               
                            
                                
               
All token type variables start with an underscore, to make them
-easy to recognize.
             		                            
             		           
                               
                            
                                
               
These are the general types. The type property is only used to
-make them recognizeable when debugging.
             		                            
  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
-  var _name = {type: "name"}, _eof = {type: "eof"};
             		           
                               
                            
                                
               
Keyword tokens. The keyword property (also used in keyword-like
-operators) indicates that the token originated from an
-identifier-like word, which is used when parsing property names.

-
-
The beforeExpr property is used to disambiguate between regular
-expressions and divisions. It is set on all token types that can
-be followed by an expression (thus, a slash after them would be a
-regular expression).

-
-
isLoop marks a keyword as starting a loop, which is important
-to know when parsing a label, in order to allow or disallow
-continue jumps to that label.
             		                            
  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
-  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
-  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
-  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
-  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
-  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
-  var _let = {keyword: "let"}, _const = {keyword: "const"};
-  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
-  var _this = {keyword: "this"};
-  var _class = {keyword: "class"}, _extends = {keyword: "extends", beforeExpr: true};
-  var _export = {keyword: "export"}, _import = {keyword: "import"};
-  var _yield = {keyword: "yield", beforeExpr: true};
             		           
                               
                            
                                
               
The keywords that denote values.
             		                            
  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
-  var _false = {keyword: "false", atomValue: false};
             		           
                               
                            
                                
               
Some keywords are treated as regular operators. in sometimes
-(when parsing for) needs to be tested against specifically, so
-we assign a variable name to it for quick comparing.
             		                            
  var _in = {keyword: "in", binop: 7, beforeExpr: true};
             		           
                               
                            
                                
               
Map keyword names to token types.
             		                            
  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
-                      "continue": _continue, "debugger": _debugger, "default": _default,
-                      "do": _do, "else": _else, "finally": _finally, "for": _for,
-                      "function": _function, "if": _if, "return": _return, "switch": _switch,
-                      "throw": _throw, "try": _try, "var": _var, "let": _let, "const": _const,
-                      "while": _while, "with": _with,
-                      "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
-                      "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
-                      "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
-                      "void": {keyword: "void", prefix: true, beforeExpr: true},
-                      "delete": {keyword: "delete", prefix: true, beforeExpr: true},
-                      "class": _class, "extends": _extends,
-                      "export": _export, "import": _import, "yield": _yield};
             		           
                               
                            
                                
               
Punctuation token types. Again, the type property is purely for debugging.
             		                            
  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
-  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
-  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
-  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _ellipsis = {type: "..."}, _question = {type: "?", beforeExpr: true};
-  var _arrow = {type: "=>", beforeExpr: true}, _bquote = {type: "`"}, _dollarBraceL = {type: "${", beforeExpr: true};
             		           
                               
                            
                                
               
Operators. These carry several kinds of properties to help the
-parser use them properly (the presence of these properties is
-what categorizes them as operators).

-
-
binop, when present, specifies that this operator is a binary
-operator, and will refer to its precedence.

-
-
prefix and postfix mark the operator as a prefix or postfix
-unary operator. isUpdate specifies that the node produced by
-the operator should be of type UpdateExpression rather than
-simply UnaryExpression (++ and --).

-
-
isAssign marks all of =, +=, -= etcetera, which act as
-binary operators with a very low precedence, that should result
-in AssignmentExpression nodes.
             		                            
  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
-  var _assign = {isAssign: true, beforeExpr: true};
-  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
-  var _logicalOR = {binop: 1, beforeExpr: true};
-  var _logicalAND = {binop: 2, beforeExpr: true};
-  var _bitwiseOR = {binop: 3, beforeExpr: true};
-  var _bitwiseXOR = {binop: 4, beforeExpr: true};
-  var _bitwiseAND = {binop: 5, beforeExpr: true};
-  var _equality = {binop: 6, beforeExpr: true};
-  var _relational = {binop: 7, beforeExpr: true};
-  var _bitShift = {binop: 8, beforeExpr: true};
-  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
-  var _modulo = {binop: 10, beforeExpr: true};
             		           
                               
                            
                                
               
'*' may be multiply or have special meaning in ES6
             		                            
  var _star = {binop: 10, beforeExpr: true};
             		           
                               
                            
                                
               
Provide access to the token types for external users of the
-tokenizer.
             		                            
  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
-                      parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
-                      dot: _dot, ellipsis: _ellipsis, question: _question, slash: _slash, eq: _eq,
-                      name: _name, eof: _eof, num: _num, regexp: _regexp, string: _string,
-                      arrow: _arrow, bquote: _bquote, dollarBraceL: _dollarBraceL};
-  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
             		           
                               
                            
                                
               
This is a trick taken from Esprima. It turns out that, on
-non-Chrome browsers, to check whether a string is in a set, a
-predicate containing a big ugly switch statement is faster than
-a regular expression, and on Chrome the two are about on par.
-This function uses eval (non-lexical) to produce such a
-predicate from a space-separated string of words.

-
-
It starts by sorting the words by length.
             		                            
  function makePredicate(words) {
-    words = words.split(" ");
-    var f = "", cats = [];
-    out: for (var i = 0; i < words.length; ++i) {
-      for (var j = 0; j < cats.length; ++j)
-        if (cats[j][0].length == words[i].length) {
-          cats[j].push(words[i]);
-          continue out;
-        }
-      cats.push([words[i]]);
-    }
-    function compareTo(arr) {
-      if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
-      f += "switch(str){";
-      for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
-      f += "return true}return false;";
-    }
             		           
                               
                            
                                
               
When there are more than three length categories, an outer
-switch first dispatches on the lengths, to save on comparisons.
             		                            
    if (cats.length > 3) {
-      cats.sort(function(a, b) {return b.length - a.length;});
-      f += "switch(str.length){";
-      for (var i = 0; i < cats.length; ++i) {
-        var cat = cats[i];
-        f += "case " + cat[0].length + ":";
-        compareTo(cat);
-      }
-      f += "}";
             		           
                               
                            
                                
               
Otherwise, simply generate a flat switch statement.
             		                            
    } else {
-      compareTo(words);
-    }
-    return new Function("str", f);
-  }
             		           
                               
                            
                                
               
The ECMAScript 3 reserved word list.
             		                            
  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
             		           
                               
                            
                                
               
ECMAScript 5 reserved words.
             		                            
  var isReservedWord5 = makePredicate("class enum extends super const export import");
             		           
                               
                            
                                
               
The additional reserved words in strict mode.
             		                            
  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
             		           
                               
                            
                                
               
The forbidden variable names in strict mode.
             		                            
  var isStrictBadIdWord = makePredicate("eval arguments");
             		           
                               
                            
                                
               
And the keywords.
             		                            
  var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
-
-  var isEcma5AndLessKeyword = makePredicate(ecma5AndLessKeywords);
-
-  var isEcma6Keyword = makePredicate(ecma5AndLessKeywords + " let const class extends export import yield");
-
-  var isKeyword = isEcma5AndLessKeyword;
             		           
                               
                            
                                
               
Character categories
             		                            
             		           
                               
                            
                                
               
Big ugly regular expressions that match characters in the
-whitespace, identifier, and identifier-start categories. These
-are only applied when a character is found to actually have a
-code point above 128.
-Generated by tools/generate-identifier-regex.js.
             		                            
  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
-  var nonASCIIidentifierStartChars = "\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-\u08B2\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\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\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\u0C59\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\u0D60\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-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\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\u19C1-\u19C7\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\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\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-\uAB5F\uAB64\uAB65\uABC0-\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";
-  var nonASCIIidentifierChars = "\u0300-\u036F\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E4-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0D01-\u0D03\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19B0-\u19C0\u19C8\u19C9\u19D0-\u19D9\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u200C\u200D\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA620-\uA629\uA66F\uA674-\uA67D\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F1\uA900-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F";
-  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
             		           
                               
                            
                                
               
Whether a single character denotes a newline.
             		                            
  var newline = /[\n\r\u2028\u2029]/;
             		           
                               
                            
                                
               
Matches a whole line break (where CRLF is considered a single
-line break). Used to count lines.
             		                            
  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
             		           
                               
                            
                                
               
Test whether a given character code starts an identifier.
             		                            
  var isIdentifierStart = exports.isIdentifierStart = function(code) {
-    if (code < 65) return code === 36;
-    if (code < 91) return true;
-    if (code < 97) return code === 95;
-    if (code < 123)return true;
-    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  };
             		           
                               
                            
                                
               
Test whether a given character is part of an identifier.
             		                            
  var isIdentifierChar = exports.isIdentifierChar = function(code) {
-    if (code < 48) return code === 36;
-    if (code < 58) return true;
-    if (code < 65) return false;
-    if (code < 91) return true;
-    if (code < 97) return code === 95;
-    if (code < 123)return true;
-    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  };
             		           
                               
                            
                                
               
Tokenizer
             		                            
             		           
                               
                            
                                
               
These are used when options.locations is on, for the
-tokStartLoc and tokEndLoc properties.
             		                            
  function Position() {
-    this.line = tokCurLine;
-    this.column = tokPos - tokLineStart;
-  }
             		           
                               
                            
                                
               
Reset the token state. Used at the start of a parse.
             		                            
  function initTokenState() {
-    tokCurLine = 1;
-    tokPos = tokLineStart = 0;
-    tokRegexpAllowed = true;
-    metParenL = 0;
-    inTemplate = false;
-    skipSpace();
-  }
             		           
                               
                            
                                
               
Called at the end of every token. Sets tokEnd, tokVal, and
-tokRegexpAllowed, and skips the space after the token, so that
-the next one's tokStart will point at the right position.
             		                            
  function finishToken(type, val, shouldSkipSpace) {
-    tokEnd = tokPos;
-    if (options.locations) tokEndLoc = new Position;
-    tokType = type;
-    if (shouldSkipSpace !== false) skipSpace();
-    tokVal = val;
-    tokRegexpAllowed = type.beforeExpr;
-    if (options.onToken) {
-      options.onToken(new Token());
-    }
-  }
-
-  function skipBlockComment() {
-    var startLoc = options.onComment && options.locations && new Position;
-    var start = tokPos, end = input.indexOf("*/", tokPos += 2);
-    if (end === -1) raise(tokPos - 2, "Unterminated comment");
-    tokPos = end + 2;
-    if (options.locations) {
-      lineBreak.lastIndex = start;
-      var match;
-      while ((match = lineBreak.exec(input)) && match.index < tokPos) {
-        ++tokCurLine;
-        tokLineStart = match.index + match[0].length;
-      }
-    }
-    if (options.onComment)
-      options.onComment(true, input.slice(start + 2, end), start, tokPos,
-                        startLoc, options.locations && new Position);
-  }
-
-  function skipLineComment(startSkip) {
-    var start = tokPos;
-    var startLoc = options.onComment && options.locations && new Position;
-    var ch = input.charCodeAt(tokPos+=startSkip);
-    while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
-      ++tokPos;
-      ch = input.charCodeAt(tokPos);
-    }
-    if (options.onComment)
-      options.onComment(false, input.slice(start + startSkip, tokPos), start, tokPos,
-                        startLoc, options.locations && new Position);
-  }
             		           
                               
                            
                                
               
Called at the start of the parse and after every token. Skips
-whitespace and comments, and.
             		                            
  function skipSpace() {
-    while (tokPos < inputLen) {
-      var ch = input.charCodeAt(tokPos);
-      if (ch === 32) { // ' '
-        ++tokPos;
-      } else if (ch === 13) {
-        ++tokPos;
-        var next = input.charCodeAt(tokPos);
-        if (next === 10) {
-          ++tokPos;
-        }
-        if (options.locations) {
-          ++tokCurLine;
-          tokLineStart = tokPos;
-        }
-      } else if (ch === 10 || ch === 8232 || ch === 8233) {
-        ++tokPos;
-        if (options.locations) {
-          ++tokCurLine;
-          tokLineStart = tokPos;
-        }
-      } else if (ch > 8 && ch < 14) {
-        ++tokPos;
-      } else if (ch === 47) { // '/'
-        var next = input.charCodeAt(tokPos + 1);
-        if (next === 42) { // '*'
-          skipBlockComment();
-        } else if (next === 47) { // '/'
-          skipLineComment(2);
-        } else break;
-      } else if (ch === 160) { // '\xa0'
-        ++tokPos;
-      } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
-        ++tokPos;
-      } else {
-        break;
-      }
-    }
-  }
             		           
                               
                            
                                
               
Token reading
             		                            
             		           
                               
                            
                                
               
This is the function that is called to fetch the next token. It
-is somewhat obscure, because it works in character codes rather
-than characters, and because operator parsing has been inlined
-into it.

-
-
All in the name of speed.

-
-
The forceRegexp parameter is used in the one case where the
-tokRegexpAllowed trick does not work. See parseStatement.
             		                            
  function readToken_dot() {
-    var next = input.charCodeAt(tokPos + 1);
-    if (next >= 48 && next <= 57) return readNumber(true);
-    var next2 = input.charCodeAt(tokPos + 2);
-    if (options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
-      tokPos += 3;
-      return finishToken(_ellipsis);
-    } else {
-      ++tokPos;
-      return finishToken(_dot);
-    }
-  }
-
-  function readToken_slash() { // '/'
-    var next = input.charCodeAt(tokPos + 1);
-    if (tokRegexpAllowed) {++tokPos; return readRegexp();}
-    if (next === 61) return finishOp(_assign, 2);
-    return finishOp(_slash, 1);
-  }
-
-  function readToken_mult_modulo(code) { // '%*'
-    var next = input.charCodeAt(tokPos + 1);
-    if (next === 61) return finishOp(_assign, 2);
-    return finishOp(code === 42 ? _star : _modulo, 1);
-  }
-
-  function readToken_pipe_amp(code) { // '|&'
-    var next = input.charCodeAt(tokPos + 1);
-    if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
-    if (next === 61) return finishOp(_assign, 2);
-    return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
-  }
-
-  function readToken_caret() { // '^'
-    var next = input.charCodeAt(tokPos + 1);
-    if (next === 61) return finishOp(_assign, 2);
-    return finishOp(_bitwiseXOR, 1);
-  }
-
-  function readToken_plus_min(code) { // '+-'
-    var next = input.charCodeAt(tokPos + 1);
-    if (next === code) {
-      if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
-          newline.test(input.slice(lastEnd, tokPos))) {
             		           
                               
                            
                                
               
A --> line comment
             		                            
        skipLineComment(3);
-        skipSpace();
-        return readToken();
-      }
-      return finishOp(_incDec, 2);
-    }
-    if (next === 61) return finishOp(_assign, 2);
-    return finishOp(_plusMin, 1);
-  }
-
-  function readToken_lt_gt(code) { // '<>'
-    var next = input.charCodeAt(tokPos + 1);
-    var size = 1;
-    if (next === code) {
-      size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
-      if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
-      return finishOp(_bitShift, size);
-    }
-    if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
-        input.charCodeAt(tokPos + 3) == 45) {
             		           
                               
                            
                                
               
<!--, an XML-style comment that should be interpreted as a line comment
             		                            
      skipLineComment(4);
-      skipSpace();
-      return readToken();
-    }
-    if (next === 61)
-      size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
-    return finishOp(_relational, size);
-  }
-
-  function readToken_eq_excl(code) { // '=!', '=>'
-    var next = input.charCodeAt(tokPos + 1);
-    if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
-    if (code === 61 && next === 62 && options.ecmaVersion >= 6) { // '=>'
-      tokPos += 2;
-      return finishToken(_arrow);
-    }
-    return finishOp(code === 61 ? _eq : _prefix, 1);
-  }
             		           
                               
                            
                                
               
Get token inside ES6 template (special rules work there).
             		                            
  function getTemplateToken(code) {
             		           
                               
                            
                                
               
'`' and '${' have special meanings, but they should follow
-string (can be empty)
             		                            
    if (tokType === _string) {
-      if (code === 96) { // '`'
-        ++tokPos;
-        return finishToken(_bquote);
-      } else
-      if (code === 36 && input.charCodeAt(tokPos + 1) === 123) { // '${'
-        tokPos += 2;
-        return finishToken(_dollarBraceL);
-      }
-    }
-
-    if (code === 125) { // '}'
-      ++tokPos;
-      return finishToken(_braceR, undefined, false);
-    }
             		           
                               
                            
                                
               
anything else is considered string literal
             		                            
    return readTmplString();
-  }
-
-  function getTokenFromCode(code) {
-    switch (code) {
             		           
                               
                            
                                
               
The interpretation of a dot depends on whether it is followed
-by a digit or another two dots.
             		                            
    case 46: // '.'
-      return readToken_dot();
             		           
                               
                            
                                
               
Punctuation tokens.
             		                            
    case 40: ++tokPos; return finishToken(_parenL);
-    case 41: ++tokPos; return finishToken(_parenR);
-    case 59: ++tokPos; return finishToken(_semi);
-    case 44: ++tokPos; return finishToken(_comma);
-    case 91: ++tokPos; return finishToken(_bracketL);
-    case 93: ++tokPos; return finishToken(_bracketR);
-    case 123: ++tokPos; return finishToken(_braceL);
-    case 125: ++tokPos; return finishToken(_braceR);
-    case 58: ++tokPos; return finishToken(_colon);
-    case 63: ++tokPos; return finishToken(_question);
-
-    case 96: // '`'
-      if (options.ecmaVersion >= 6) {
-        ++tokPos;
-        return finishToken(_bquote, undefined, false);
-      }
-
-    case 48: // '0'
-      var next = input.charCodeAt(tokPos + 1);
-      if (next === 120 || next === 88) return readRadixNumber(16); // '0x', '0X' - hex number
-      if (options.ecmaVersion >= 6) {
-        if (next === 111 || next === 79) return readRadixNumber(8); // '0o', '0O' - octal number
-        if (next === 98 || next === 66) return readRadixNumber(2); // '0b', '0B' - binary number
-      }
             		           
                               
                            
                                
               
Anything else beginning with a digit is an integer, octal
-number, or float.
             		                            
    case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9
-      return readNumber(false);
             		           
                               
                            
                                
               
Quotes produce strings.
             		                            
    case 34: case 39: // '"', "'"
-      return readString(code);
             		           
                               
                            
                                
               
Operators are parsed inline in tiny state machines. '=' (61) is
-often referred to. finishOp simply skips the amount of
-characters it is given as second argument, and returns a token
-of the type given by its first argument.
             		                            
    case 47: // '/'
-      return readToken_slash();
-
-    case 37: case 42: // '%*'
-      return readToken_mult_modulo(code);
-
-    case 124: case 38: // '|&'
-      return readToken_pipe_amp(code);
-
-    case 94: // '^'
-      return readToken_caret();
-
-    case 43: case 45: // '+-'
-      return readToken_plus_min(code);
-
-    case 60: case 62: // '<>'
-      return readToken_lt_gt(code);
-
-    case 61: case 33: // '=!'
-      return readToken_eq_excl(code);
-
-    case 126: // '~'
-      return finishOp(_prefix, 1);
-    }
-
-    return false;
-  }
-
-  function readToken(forceRegexp) {
-    if (!forceRegexp) tokStart = tokPos;
-    else tokPos = tokStart + 1;
-    if (options.locations) tokStartLoc = new Position;
-    if (forceRegexp) return readRegexp();
-    if (tokPos >= inputLen) return finishToken(_eof);
-
-    var code = input.charCodeAt(tokPos);
-
-    if (inTemplate) return getTemplateToken(code);
             		           
                               
                            
                                
               
Identifier or keyword. '\uXXXX' sequences are allowed in
-identifiers, so '\' also dispatches to that.
             		                            
    if (isIdentifierStart(code) || code === 92 /* '\' */) return readWord();
-
-    var tok = getTokenFromCode(code);
-
-    if (tok === false) {
             		           
                               
                            
                                
               
If we are here, we either found a non-ASCII identifier
-character, or something that's entirely disallowed.
             		                            
      var ch = String.fromCharCode(code);
-      if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
-      raise(tokPos, "Unexpected character '" + ch + "'");
-    }
-    return tok;
-  }
-
-  function finishOp(type, size) {
-    var str = input.slice(tokPos, tokPos + size);
-    tokPos += size;
-    finishToken(type, str);
-  }
             		           
                               
                            
                                
               
Parse a regular expression. Some context-awareness is necessary,
-since a '/' inside a '[]' set does not end the expression.
             		                            
  function readRegexp() {
-    var content = "", escaped, inClass, start = tokPos;
-    for (;;) {
-      if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
-      var ch = input.charAt(tokPos);
-      if (newline.test(ch)) raise(start, "Unterminated regular expression");
-      if (!escaped) {
-        if (ch === "[") inClass = true;
-        else if (ch === "]" && inClass) inClass = false;
-        else if (ch === "/" && !inClass) break;
-        escaped = ch === "\\";
-      } else escaped = false;
-      ++tokPos;
-    }
-    var content = input.slice(start, tokPos);
-    ++tokPos;
             		           
                               
                            
                                
               
Need to use readWord1 because '\uXXXX' sequences are allowed
-here (don't ask).
             		                            
    var mods = readWord1();
-    if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regular expression flag");
-    try {
-      var value = new RegExp(content, mods);
-    } catch (e) {
-      if (e instanceof SyntaxError) raise(start, "Error parsing regular expression: " + e.message);
-      raise(e);
-    }
-    return finishToken(_regexp, value);
-  }
             		           
                               
                            
                                
               
Read an integer in the given radix. Return null if zero digits
-were read, the integer value otherwise. When len is given, this
-will return null unless the integer has exactly len digits.
             		                            
  function readInt(radix, len) {
-    var start = tokPos, total = 0;
-    for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-      var code = input.charCodeAt(tokPos), val;
-      if (code >= 97) val = code - 97 + 10; // a
-      else if (code >= 65) val = code - 65 + 10; // A
-      else if (code >= 48 && code <= 57) val = code - 48; // 0-9
-      else val = Infinity;
-      if (val >= radix) break;
-      ++tokPos;
-      total = total * radix + val;
-    }
-    if (tokPos === start || len != null && tokPos - start !== len) return null;
-
-    return total;
-  }
-
-  function readRadixNumber(radix) {
-    tokPos += 2; // 0x
-    var val = readInt(radix);
-    if (val == null) raise(tokStart + 2, "Expected number in radix " + radix);
-    if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-    return finishToken(_num, val);
-  }
             		           
                               
                            
                                
               
Read an integer, octal integer, or floating-point number.
             		                            
  function readNumber(startsWithDot) {
-    var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
-    if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
-    if (input.charCodeAt(tokPos) === 46) {
-      ++tokPos;
-      readInt(10);
-      isFloat = true;
-    }
-    var next = input.charCodeAt(tokPos);
-    if (next === 69 || next === 101) { // 'eE'
-      next = input.charCodeAt(++tokPos);
-      if (next === 43 || next === 45) ++tokPos; // '+-'
-      if (readInt(10) === null) raise(start, "Invalid number");
-      isFloat = true;
-    }
-    if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-
-    var str = input.slice(start, tokPos), val;
-    if (isFloat) val = parseFloat(str);
-    else if (!octal || str.length === 1) val = parseInt(str, 10);
-    else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
-    else val = parseInt(str, 8);
-    return finishToken(_num, val);
-  }
             		           
                               
                            
                                
               
Read a string value, interpreting backslash-escapes.
             		                            
  function readCodePoint() {
-    var ch = input.charCodeAt(tokPos), code;
-
-    if (ch === 123) {
-      if (options.ecmaVersion < 6) unexpected();
-      ++tokPos;
-      code = readHexChar(input.indexOf('}', tokPos) - tokPos);
-      ++tokPos;
-      if (code > 0x10FFFF) unexpected();
-    } else {
-      code = readHexChar(4);
-    }
             		           
                               
                            
                                
               
UTF-16 Encoding
             		                            
    if (code <= 0xFFFF) {
-      return String.fromCharCode(code);
-    }
-    var cu1 = ((code - 0x10000) >> 10) + 0xD800;
-    var cu2 = ((code - 0x10000) & 1023) + 0xDC00;
-    return String.fromCharCode(cu1, cu2);
-  }
-
-  function readString(quote) {
-    ++tokPos;
-    var out = "";
-    for (;;) {
-      if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
-      var ch = input.charCodeAt(tokPos);
-      if (ch === quote) {
-        ++tokPos;
-        return finishToken(_string, out);
-      }
-      if (ch === 92) { // '\'
-        out += readEscapedChar();
-      } else {
-        ++tokPos;
-        if (newline.test(String.fromCharCode(ch))) {
-          raise(tokStart, "Unterminated string constant");
-        }
-        out += String.fromCharCode(ch); // '\'
-      }
-    }
-  }
-
-  function readTmplString() {
-    var out = "";
-    for (;;) {
-      if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
-      var ch = input.charCodeAt(tokPos);
-      if (ch === 96 || ch === 36 && input.charCodeAt(tokPos + 1) === 123) // '`', '${'
-        return finishToken(_string, out);
-      if (ch === 92) { // '\'
-        out += readEscapedChar();
-      } else {
-        ++tokPos;
-        if (newline.test(String.fromCharCode(ch))) {
-          if (ch === 13 && input.charCodeAt(tokPos) === 10) {
-            ++tokPos;
-            ch = 10;
-          }
-          if (options.locations) {
-            ++tokCurLine;
-            tokLineStart = tokPos;
-          }
-        }
-        out += String.fromCharCode(ch); // '\'
-      }
-    }
-  }
             		           
                               
                            
                                
               
Used to read escaped characters
             		                            
  function readEscapedChar() {
-    var ch = input.charCodeAt(++tokPos);
-    var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
-    if (octal) octal = octal[0];
-    while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
-    if (octal === "0") octal = null;
-    ++tokPos;
-    if (octal) {
-      if (strict) raise(tokPos - 2, "Octal literal in strict mode");
-      tokPos += octal.length - 1;
-      return String.fromCharCode(parseInt(octal, 8));
-    } else {
-      switch (ch) {
-        case 110: return "\n"; // 'n' -> '\n'
-        case 114: return "\r"; // 'r' -> '\r'
-        case 120: return String.fromCharCode(readHexChar(2)); // 'x'
-        case 117: return readCodePoint(); // 'u'
-        case 85: return String.fromCharCode(readHexChar(8)); // 'U'
-        case 116: return "\t"; // 't' -> '\t'
-        case 98: return "\b"; // 'b' -> '\b'
-        case 118: return "\u000b"; // 'v' -> '\u000b'
-        case 102: return "\f"; // 'f' -> '\f'
-        case 48: return "\0"; // 0 -> '\0'
-        case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos; // '\r\n'
-        case 10: // ' \n'
-          if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
-          return "";
-        default: return String.fromCharCode(ch);
-      }
-    }
-  }
             		           
                               
                            
                                
               
Used to read character escape sequences ('\x', '\u', '\U').
             		                            
  function readHexChar(len) {
-    var n = readInt(16, len);
-    if (n === null) raise(tokStart, "Bad character escape sequence");
-    return n;
-  }
             		           
                               
                            
                                
               
Used to signal to callers of readWord1 whether the word
-contained any escape sequences. This is needed because words with
-escape sequences must not be interpreted as keywords.
             		                            
  var containsEsc;
             		           
                               
                            
                                
               
Read an identifier, and return it as a string. Sets containsEsc
-to whether the word contained a '\u' escape.

-
-
Only builds up the word character-by-character when it actually
-containeds an escape, as a micro-optimization.
             		                            
  function readWord1() {
-    containsEsc = false;
-    var word, first = true, start = tokPos;
-    for (;;) {
-      var ch = input.charCodeAt(tokPos);
-      if (isIdentifierChar(ch)) {
-        if (containsEsc) word += input.charAt(tokPos);
-        ++tokPos;
-      } else if (ch === 92) { // "\"
-        if (!containsEsc) word = input.slice(start, tokPos);
-        containsEsc = true;
-        if (input.charCodeAt(++tokPos) != 117) // "u"
-          raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
-        ++tokPos;
-        var esc = readHexChar(4);
-        var escStr = String.fromCharCode(esc);
-        if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
-        if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
-          raise(tokPos - 4, "Invalid Unicode escape");
-        word += escStr;
-      } else {
-        break;
-      }
-      first = false;
-    }
-    return containsEsc ? word : input.slice(start, tokPos);
-  }
             		           
                               
                            
                                
               
Read an identifier or keyword token. Will check for reserved
-words when necessary.
             		                            
  function readWord() {
-    var word = readWord1();
-    var type = _name;
-    if (!containsEsc && isKeyword(word))
-      type = keywordTypes[word];
-    return finishToken(type, word);
-  }
             		           
                               
                            
                                
               
Parser
             		                            
             		           
                               
                            
                                
               
A recursive descent parser operates by defining functions for all
-syntactic elements, and recursively calling those, each function
-advancing the input stream and returning an AST node. Precedence
-of constructs (for example, the fact that !x[1] means !(x[1])
-instead of (!x)[1] is handled by the fact that the parser
-function that parses unary prefix operators is called first, and
-in turn calls the function that parses [] subscripts — that
-way, it'll receive the node for x[1] already parsed, and wraps
-that in the unary operator node.

-
-
Acorn uses an operator precedence parser to handle binary
-operator precedence, because it is much more compact than using
-the technique outlined above, which uses different, nesting
-functions to specify precedence, for all of the ten binary
-precedence levels that JavaScript defines.
             		                            
             		           
                               
                            
                                
               
Parser utilities
             		                            
             		           
                               
                            
                                
               
Continue to the next token.
             		                            
  function next() {
-    lastStart = tokStart;
-    lastEnd = tokEnd;
-    lastEndLoc = tokEndLoc;
-    readToken();
-  }
             		           
                               
                            
                                
               
Enter strict mode. Re-reads the next token to please pedantic
-tests ("use strict"; 010; -- should fail).
             		                            
  function setStrict(strct) {
-    strict = strct;
-    tokPos = tokStart;
-    if (options.locations) {
-      while (tokPos < tokLineStart) {
-        tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
-        --tokCurLine;
-      }
-    }
-    skipSpace();
-    readToken();
-  }
             		           
                               
                            
                                
               
Start an AST node, attaching a start offset.
             		                            
  function Node() {
-    this.type = null;
-    this.start = tokStart;
-    this.end = null;
-  }
-
-  exports.Node = Node;
-
-  function SourceLocation() {
-    this.start = tokStartLoc;
-    this.end = null;
-    if (sourceFile !== null) this.source = sourceFile;
-  }
-
-  function startNode() {
-    var node = new Node();
-    if (options.locations)
-      node.loc = new SourceLocation();
-    if (options.directSourceFile)
-      node.sourceFile = options.directSourceFile;
-    if (options.ranges)
-      node.range = [tokStart, 0];
-    return node;
-  }
             		           
                               
                            
                                
               
Start a node whose start offset information should be based on
-the start of another node. For example, a binary operator node is
-only started after its left-hand side has already been parsed.
             		                            
  function startNodeFrom(other) {
-    var node = new Node();
-    node.start = other.start;
-    if (options.locations) {
-      node.loc = new SourceLocation();
-      node.loc.start = other.loc.start;
-    }
-    if (options.ranges)
-      node.range = [other.range[0], 0];
-
-    return node;
-  }
             		           
                               
                            
                                
               
Finish an AST node, adding type and end properties.
             		                            
  function finishNode(node, type) {
-    node.type = type;
-    node.end = lastEnd;
-    if (options.locations)
-      node.loc.end = lastEndLoc;
-    if (options.ranges)
-      node.range[1] = lastEnd;
-    return node;
-  }
             		           
                               
                            
                                
               
Test whether a statement node is the string literal "use strict".
             		                            
  function isUseStrict(stmt) {
-    return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
-      stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
-  }
             		           
                               
                            
                                
               
Predicate that tests whether the next token is of the given
-type, and if yes, consumes it as a side effect.
             		                            
  function eat(type) {
-    if (tokType === type) {
-      next();
-      return true;
-    } else {
-      return false;
-    }
-  }
             		           
                               
                            
                                
               
Test whether a semicolon can be inserted at the current position.
             		                            
  function canInsertSemicolon() {
-    return !options.strictSemicolons &&
-      (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
-  }
             		           
                               
                            
                                
               
Consume a semicolon, or, failing that, see if we are allowed to
-pretend that there is a semicolon at this position.
             		                            
  function semicolon() {
-    if (!eat(_semi) && !canInsertSemicolon()) unexpected();
-  }
             		           
                               
                            
                                
               
Expect a token of a given type. If found, consume it, otherwise,
-raise an unexpected token error.
             		                            
  function expect(type) {
-    eat(type) || unexpected();
-  }
             		           
                               
                            
                                
               
Raise an unexpected token error.
             		                            
  function unexpected(pos) {
-    raise(pos != null ? pos : tokStart, "Unexpected token");
-  }
             		           
                               
                            
                                
               
Checks if hash object has a property.
             		                            
  function has(obj, propName) {
-    return Object.prototype.hasOwnProperty.call(obj, propName);
-  }
             		           
                               
                            
                                
               
Convert existing expression atom to assignable pattern
-if possible.
             		                            
  function toAssignable(node, allowSpread, checkType) {
-    if (options.ecmaVersion >= 6 && node) {
-      switch (node.type) {
-        case "Identifier":
-        case "MemberExpression":
-          break;
-
-        case "ObjectExpression":
-          node.type = "ObjectPattern";
-          for (var i = 0; i < node.properties.length; i++) {
-            var prop = node.properties[i];
-            if (prop.kind !== "init") unexpected(prop.key.start);
-            toAssignable(prop.value, false, checkType);
-          }
-          break;
-
-        case "ArrayExpression":
-          node.type = "ArrayPattern";
-          for (var i = 0, lastI = node.elements.length - 1; i <= lastI; i++) {
-            toAssignable(node.elements[i], i === lastI, checkType);
-          }
-          break;
-
-        case "SpreadElement":
-          if (allowSpread) {
-            toAssignable(node.argument, false, checkType);
-            checkSpreadAssign(node.argument);
-          } else {
-            unexpected(node.start);
-          }
-          break;
-
-        default:
-          if (checkType) unexpected(node.start);
-      }
-    }
-    return node;
-  }
             		           
                               
                            
                                
               
Checks if node can be assignable spread argument.
             		                            
  function checkSpreadAssign(node) {
-    if (node.type !== "Identifier" && node.type !== "ArrayPattern")
-      unexpected(node.start);
-  }
             		           
                               
                            
                                
               
Verify that argument names are not repeated, and it does not
-try to bind the words eval or arguments.
             		                            
  function checkFunctionParam(param, nameHash) {
-    switch (param.type) {
-      case "Identifier":
-        if (isStrictReservedWord(param.name) || isStrictBadIdWord(param.name))
-          raise(param.start, "Defining '" + param.name + "' in strict mode");
-        if (has(nameHash, param.name))
-          raise(param.start, "Argument name clash in strict mode");
-        nameHash[param.name] = true;
-        break;
-
-      case "ObjectPattern":
-        for (var i = 0; i < param.properties.length; i++)
-          checkFunctionParam(param.properties[i].value, nameHash);
-        break;
-
-      case "ArrayPattern":
-        for (var i = 0; i < param.elements.length; i++)
-          checkFunctionParam(param.elements[i], nameHash);
-        break;
-    }
-  }
             		           
                               
                            
                                
               
Check if property name clashes with already added.
-Object/class getters and setters are not allowed to clash —
-either with each other or with an init property — and in
-strict mode, init properties are also not allowed to be repeated.
             		                            
  function checkPropClash(prop, propHash) {
-    if (prop.computed) return;
-    var key = prop.key, name;
-    switch (key.type) {
-      case "Identifier": name = key.name; break;
-      case "Literal": name = String(key.value); break;
-      default: return;
-    }
-    var kind = prop.kind || "init", other;
-    if (has(propHash, name)) {
-      other = propHash[name];
-      var isGetSet = kind !== "init";
-      if ((strict || isGetSet) && other[kind] || !(isGetSet ^ other.init))
-        raise(key.start, "Redefinition of property");
-    } else {
-      other = propHash[name] = {
-        init: false,
-        get: false,
-        set: false
-      };
-    }
-    other[kind] = true;
-  }
             		           
                               
                            
                                
               
Verify that a node is an lval — something that can be assigned
-to.
             		                            
  function checkLVal(expr, isBinding) {
-    switch (expr.type) {
-      case "Identifier":
-        if (strict && (isStrictBadIdWord(expr.name) || isStrictReservedWord(expr.name)))
-          raise(expr.start, isBinding
-            ? "Binding " + expr.name + " in strict mode"
-            : "Assigning to " + expr.name + " in strict mode"
-          );
-        break;
-
-      case "MemberExpression":
-        if (!isBinding) break;
-
-      case "ObjectPattern":
-        for (var i = 0; i < expr.properties.length; i++)
-          checkLVal(expr.properties[i].value, isBinding);
-        break;
-
-      case "ArrayPattern":
-        for (var i = 0; i < expr.elements.length; i++) {
-          var elem = expr.elements[i];
-          if (elem) checkLVal(elem, isBinding);
-        }
-        break;
-
-      case "SpreadElement":
-        break;
-
-      default:
-        raise(expr.start, "Assigning to rvalue");
-    }
-  }
             		           
                               
                            
                                
               
Statement parsing
             		                            
             		           
                               
                            
                                
               
Parse a program. Initializes the parser, reads any number of
-statements, and wraps them in a Program node.  Optionally takes a
-program argument.  If present, the statements will be appended
-to its body instead of creating a new node.
             		                            
  function parseTopLevel(program) {
-    lastStart = lastEnd = tokPos;
-    if (options.locations) lastEndLoc = new Position;
-    inFunction = inGenerator = strict = null;
-    labels = [];
-    readToken();
-
-    var node = program || startNode(), first = true;
-    if (!program) node.body = [];
-    while (tokType !== _eof) {
-      var stmt = parseStatement();
-      node.body.push(stmt);
-      if (first && isUseStrict(stmt)) setStrict(true);
-      first = false;
-    }
-    return finishNode(node, "Program");
-  }
-
-  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
             		           
                               
                            
                                
               
Parse a single statement.

-
-
If expecting a statement and finding a slash operator, parse a
-regular expression literal. This is to handle cases like
-if (foo) /blah/.exec(foo);, where looking at the previous token
-does not help.
             		                            
  function parseStatement() {
-    if (tokType === _slash || tokType === _assign && tokVal == "/=")
-      readToken(true);
-
-    var starttype = tokType, node = startNode();
             		           
                               
                            
                                
               
Most types of statements are recognized by the keyword they
-start with. Many are trivial to parse, some require a bit of
-complexity.
             		                            
    switch (starttype) {
-    case _break: case _continue: return parseBreakContinueStatement(node, starttype.keyword);
-    case _debugger: return parseDebuggerStatement(node);
-    case _do: return parseDoStatement(node);
-    case _for: return parseForStatement(node);
-    case _function: return parseFunctionStatement(node);
-    case _class: return parseClass(node, true);
-    case _if: return parseIfStatement(node);
-    case _return: return parseReturnStatement(node);
-    case _switch: return parseSwitchStatement(node);
-    case _throw: return parseThrowStatement(node);
-    case _try: return parseTryStatement(node);
-    case _var: case _let: case _const: return parseVarStatement(node, starttype.keyword);
-    case _while: return parseWhileStatement(node);
-    case _with: return parseWithStatement(node);
-    case _braceL: return parseBlock(); // no point creating a function for this
-    case _semi: return parseEmptyStatement(node);
-    case _export: return parseExport(node);
-    case _import: return parseImport(node);
             		           
                               
                            
                                
               
If the statement does not start with a statement keyword or a
-brace, it's an ExpressionStatement or LabeledStatement. We
-simply start parsing an expression, and afterwards, if the
-next token is a colon and the expression was a simple
-Identifier node, we switch to interpreting it as a label.
             		                            
    default:
-      var maybeName = tokVal, expr = parseExpression();
-      if (starttype === _name && expr.type === "Identifier" && eat(_colon))
-        return parseLabeledStatement(node, maybeName, expr);
-      else return parseExpressionStatement(node, expr);
-    }
-  }
-
-  function parseBreakContinueStatement(node, keyword) {
-    var isBreak = keyword == "break";
-    next();
-    if (eat(_semi) || canInsertSemicolon()) node.label = null;
-    else if (tokType !== _name) unexpected();
-    else {
-      node.label = parseIdent();
-      semicolon();
-    }
             		           
                               
                            
                                
               
Verify that there is an actual destination to break or
-continue to.
             		                            
    for (var i = 0; i < labels.length; ++i) {
-      var lab = labels[i];
-      if (node.label == null || lab.name === node.label.name) {
-        if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
-        if (node.label && isBreak) break;
-      }
-    }
-    if (i === labels.length) raise(node.start, "Unsyntactic " + keyword);
-    return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-  }
-
-  function parseDebuggerStatement(node) {
-    next();
-    semicolon();
-    return finishNode(node, "DebuggerStatement");
-  }
-
-  function parseDoStatement(node) {
-    next();
-    labels.push(loopLabel);
-    node.body = parseStatement();
-    labels.pop();
-    expect(_while);
-    node.test = parseParenExpression();
-    semicolon();
-    return finishNode(node, "DoWhileStatement");
-  }
             		           
                               
                            
                                
               
Disambiguating between a for and a for/in or for/of
-loop is non-trivial. Basically, we have to parse the init var
-statement or expression, disallowing the in operator (see
-the second parameter to parseExpression), and then check
-whether the next token is in or of. When there is no init
-part (semicolon immediately after the opening parenthesis), it
-is a regular for loop.
             		                            
  function parseForStatement(node) {
-    next();
-    labels.push(loopLabel);
-    expect(_parenL);
-    if (tokType === _semi) return parseFor(node, null);
-    if (tokType === _var || tokType === _let) {
-      var init = startNode(), varKind = tokType.keyword, isLet = tokType === _let;
-      next();
-      parseVar(init, true, varKind);
-      finishNode(init, "VariableDeclaration");
-      if ((tokType === _in || (tokType === _name && tokVal === "of")) && init.declarations.length === 1 &&
-          !(isLet && init.declarations[0].init))
-        return parseForIn(node, init);
-      return parseFor(node, init);
-    }
-    var init = parseExpression(false, true);
-    if (tokType === _in || (tokType === _name && tokVal === "of")) {
-      checkLVal(init);
-      return parseForIn(node, init);
-    }
-    return parseFor(node, init);
-  }
-
-  function parseFunctionStatement(node) {
-    next();
-    return parseFunction(node, true);
-  }
-
-  function parseIfStatement(node) {
-    next();
-    node.test = parseParenExpression();
-    node.consequent = parseStatement();
-    node.alternate = eat(_else) ? parseStatement() : null;
-    return finishNode(node, "IfStatement");
-  }
-
-  function parseReturnStatement(node) {
-    if (!inFunction && !options.allowReturnOutsideFunction)
-      raise(tokStart, "'return' outside of function");
-    next();
             		           
                               
                            
                                
               
In return (and break/continue), the keywords with
-optional arguments, we eagerly look for a semicolon or the
-possibility to insert one.
             		                            
    if (eat(_semi) || canInsertSemicolon()) node.argument = null;
-    else { node.argument = parseExpression(); semicolon(); }
-    return finishNode(node, "ReturnStatement");
-  }
-
-  function parseSwitchStatement(node) {
-    next();
-    node.discriminant = parseParenExpression();
-    node.cases = [];
-    expect(_braceL);
-    labels.push(switchLabel);
             		           
                               
                            
                                
               
Statements under must be grouped (by label) in SwitchCase
-nodes. cur is used to keep the node that we are currently
-adding statements to.
             		                            
    for (var cur, sawDefault; tokType != _braceR;) {
-      if (tokType === _case || tokType === _default) {
-        var isCase = tokType === _case;
-        if (cur) finishNode(cur, "SwitchCase");
-        node.cases.push(cur = startNode());
-        cur.consequent = [];
-        next();
-        if (isCase) cur.test = parseExpression();
-        else {
-          if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
-          cur.test = null;
-        }
-        expect(_colon);
-      } else {
-        if (!cur) unexpected();
-        cur.consequent.push(parseStatement());
-      }
-    }
-    if (cur) finishNode(cur, "SwitchCase");
-    next(); // Closing brace
-    labels.pop();
-    return finishNode(node, "SwitchStatement");
-  }
-
-  function parseThrowStatement(node) {
-    next();
-    if (newline.test(input.slice(lastEnd, tokStart)))
-      raise(lastEnd, "Illegal newline after throw");
-    node.argument = parseExpression();
-    semicolon();
-    return finishNode(node, "ThrowStatement");
-  }
-
-  function parseTryStatement(node) {
-    next();
-    node.block = parseBlock();
-    node.handler = null;
-    if (tokType === _catch) {
-      var clause = startNode();
-      next();
-      expect(_parenL);
-      clause.param = parseIdent();
-      if (strict && isStrictBadIdWord(clause.param.name))
-        raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
-      expect(_parenR);
-      clause.guard = null;
-      clause.body = parseBlock();
-      node.handler = finishNode(clause, "CatchClause");
-    }
-    node.guardedHandlers = empty;
-    node.finalizer = eat(_finally) ? parseBlock() : null;
-    if (!node.handler && !node.finalizer)
-      raise(node.start, "Missing catch or finally clause");
-    return finishNode(node, "TryStatement");
-  }
-
-  function parseVarStatement(node, kind) {
-    next();
-    parseVar(node, false, kind);
-    semicolon();
-    return finishNode(node, "VariableDeclaration");
-  }
-
-  function parseWhileStatement(node) {
-    next();
-    node.test = parseParenExpression();
-    labels.push(loopLabel);
-    node.body = parseStatement();
-    labels.pop();
-    return finishNode(node, "WhileStatement");
-  }
-
-  function parseWithStatement(node) {
-    if (strict) raise(tokStart, "'with' in strict mode");
-    next();
-    node.object = parseParenExpression();
-    node.body = parseStatement();
-    return finishNode(node, "WithStatement");
-  }
-
-  function parseEmptyStatement(node) {
-    next();
-    return finishNode(node, "EmptyStatement");
-  }
-
-  function parseLabeledStatement(node, maybeName, expr) {
-    for (var i = 0; i < labels.length; ++i)
-      if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
-    var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
-    labels.push({name: maybeName, kind: kind});
-    node.body = parseStatement();
-    labels.pop();
-    node.label = expr;
-    return finishNode(node, "LabeledStatement");
-  }
-
-  function parseExpressionStatement(node, expr) {
-    node.expression = expr;
-    semicolon();
-    return finishNode(node, "ExpressionStatement");
-  }
             		           
                               
                            
                                
               
Used for constructs like switch and if that insist on
-parentheses around their expression.
             		                            
  function parseParenExpression() {
-    expect(_parenL);
-    var val = parseExpression();
-    expect(_parenR);
-    return val;
-  }
             		           
                               
                            
                                
               
Parse a semicolon-enclosed block of statements, handling "use
-strict" declarations when allowStrict is true (used for
-function bodies).
             		                            
  function parseBlock(allowStrict) {
-    var node = startNode(), first = true, strict = false, oldStrict;
-    node.body = [];
-    expect(_braceL);
-    while (!eat(_braceR)) {
-      var stmt = parseStatement();
-      node.body.push(stmt);
-      if (first && allowStrict && isUseStrict(stmt)) {
-        oldStrict = strict;
-        setStrict(strict = true);
-      }
-      first = false;
-    }
-    if (strict && !oldStrict) setStrict(false);
-    return finishNode(node, "BlockStatement");
-  }
             		           
                               
                            
                                
               
Parse a regular for loop. The disambiguation code in
-parseStatement will already have parsed the init statement or
-expression.
             		                            
  function parseFor(node, init) {
-    node.init = init;
-    expect(_semi);
-    node.test = tokType === _semi ? null : parseExpression();
-    expect(_semi);
-    node.update = tokType === _parenR ? null : parseExpression();
-    expect(_parenR);
-    node.body = parseStatement();
-    labels.pop();
-    return finishNode(node, "ForStatement");
-  }
             		           
                               
                            
                                
               
Parse a for/in and for/of loop, which are almost
-same from parser's perspective.
             		                            
  function parseForIn(node, init) {
-    var type = tokType === _in ? "ForInStatement" : "ForOfStatement";
-    next();
-    node.left = init;
-    node.right = parseExpression();
-    expect(_parenR);
-    node.body = parseStatement();
-    labels.pop();
-    return finishNode(node, type);
-  }
             		           
                               
                            
                                
               
Parse a list of variable declarations.
             		                            
  function parseVar(node, noIn, kind) {
-    node.declarations = [];
-    node.kind = kind;
-    for (;;) {
-      var decl = startNode();
-      decl.id = options.ecmaVersion >= 6 ? toAssignable(parseExprAtom()) : parseIdent();
-      checkLVal(decl.id, true);
-      decl.init = eat(_eq) ? parseExpression(true, noIn) : (kind === _const.keyword ? unexpected() : null);
-      node.declarations.push(finishNode(decl, "VariableDeclarator"));
-      if (!eat(_comma)) break;
-    }
-    return node;
-  }
             		           
                               
                            
                                
               
Expression parsing
             		                            
             		           
                               
                            
                                
               
These nest, from the most general expression type at the top to
-'atomic', nondivisible expression types at the bottom. Most of
-the functions will simply let the function(s) below them parse,
-and, if the syntactic construct they handle is present, wrap
-the AST node that the inner parser gave them in another node.
             		                            
             		           
                               
                            
                                
               
Parse a full expression. The arguments are used to forbid comma
-sequences (in argument lists, array literals, or object literals)
-or the in operator (in for loops initalization expressions).
             		                            
  function parseExpression(noComma, noIn) {
-    var expr = parseMaybeAssign(noIn);
-    if (!noComma && tokType === _comma) {
-      var node = startNodeFrom(expr);
-      node.expressions = [expr];
-      while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
-      return finishNode(node, "SequenceExpression");
-    }
-    return expr;
-  }
             		           
                               
                            
                                
               
Parse an assignment expression. This includes applications of
-operators like +=.
             		                            
  function parseMaybeAssign(noIn) {
-    var left = parseMaybeConditional(noIn);
-    if (tokType.isAssign) {
-      var node = startNodeFrom(left);
-      node.operator = tokVal;
-      node.left = tokType === _eq ? toAssignable(left) : left;
-      checkLVal(left);
-      next();
-      node.right = parseMaybeAssign(noIn);
-      return finishNode(node, "AssignmentExpression");
-    }
-    return left;
-  }
             		           
                               
                            
                                
               
Parse a ternary conditional (?:) operator.
             		                            
  function parseMaybeConditional(noIn) {
-    var expr = parseExprOps(noIn);
-    if (eat(_question)) {
-      var node = startNodeFrom(expr);
-      node.test = expr;
-      node.consequent = parseExpression(true);
-      expect(_colon);
-      node.alternate = parseExpression(true, noIn);
-      return finishNode(node, "ConditionalExpression");
-    }
-    return expr;
-  }
             		           
                               
                            
                                
               
Start the precedence parser.
             		                            
  function parseExprOps(noIn) {
-    return parseExprOp(parseMaybeUnary(), -1, noIn);
-  }
             		           
                               
                            
                                
               
Parse binary operators with the operator precedence parsing
-algorithm. left is the left-hand side of the operator.
-minPrec provides context that allows the function to stop and
-defer further parser to one of its callers when it encounters an
-operator that has a lower precedence than the set it is parsing.
             		                            
  function parseExprOp(left, minPrec, noIn) {
-    var prec = tokType.binop;
-    if (prec != null && (!noIn || tokType !== _in)) {
-      if (prec > minPrec) {
-        var node = startNodeFrom(left);
-        node.left = left;
-        node.operator = tokVal;
-        var op = tokType;
-        next();
-        node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
-        var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
-        return parseExprOp(exprNode, minPrec, noIn);
-      }
-    }
-    return left;
-  }
             		           
                               
                            
                                
               
Parse unary operators, both prefix and postfix.
             		                            
  function parseMaybeUnary() {
-    if (tokType.prefix) {
-      var node = startNode(), update = tokType.isUpdate;
-      node.operator = tokVal;
-      node.prefix = true;
-      tokRegexpAllowed = true;
-      next();
-      node.argument = parseMaybeUnary();
-      if (update) checkLVal(node.argument);
-      else if (strict && node.operator === "delete" &&
-               node.argument.type === "Identifier")
-        raise(node.start, "Deleting local variable in strict mode");
-      return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
-    }
-    var expr = parseExprSubscripts();
-    while (tokType.postfix && !canInsertSemicolon()) {
-      var node = startNodeFrom(expr);
-      node.operator = tokVal;
-      node.prefix = false;
-      node.argument = expr;
-      checkLVal(expr);
-      next();
-      expr = finishNode(node, "UpdateExpression");
-    }
-    return expr;
-  }
             		           
                               
                            
                                
               
Parse call, dot, and []-subscript expressions.
             		                            
  function parseExprSubscripts() {
-    return parseSubscripts(parseExprAtom());
-  }
-
-  function parseSubscripts(base, noCalls) {
-    if (eat(_dot)) {
-      var node = startNodeFrom(base);
-      node.object = base;
-      node.property = parseIdent(true);
-      node.computed = false;
-      return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-    } else if (eat(_bracketL)) {
-      var node = startNodeFrom(base);
-      node.object = base;
-      node.property = parseExpression();
-      node.computed = true;
-      expect(_bracketR);
-      return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-    } else if (!noCalls && eat(_parenL)) {
-      var node = startNodeFrom(base);
-      node.callee = base;
-      node.arguments = parseExprList(_parenR, false);
-      return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
-    } else if (tokType === _bquote) {
-      var node = startNodeFrom(base);
-      node.tag = base;
-      node.quasi = parseTemplate();
-      return parseSubscripts(finishNode(node, "TaggedTemplateExpression"), noCalls);
-    } return base;
-  }
             		           
                               
                            
                                
               
Parse an atomic expression — either a single token that is an
-expression, an expression started by a keyword like function or
-new, or an expression wrapped in punctuation like (), [],
-or {}.
             		                            
  function parseExprAtom() {
-    switch (tokType) {
-    case _this:
-      var node = startNode();
-      next();
-      return finishNode(node, "ThisExpression");
-
-    case _yield:
-      if (inGenerator) return parseYield();
-
-    case _name:
-      var id = parseIdent(tokType !== _name);
-      if (eat(_arrow)) {
-        return parseArrowExpression(startNodeFrom(id), [id]);
-      }
-      return id;
-
-    case _num: case _string: case _regexp:
-      var node = startNode();
-      node.value = tokVal;
-      node.raw = input.slice(tokStart, tokEnd);
-      next();
-      return finishNode(node, "Literal");
-
-    case _null: case _true: case _false:
-      var node = startNode();
-      node.value = tokType.atomValue;
-      node.raw = tokType.keyword;
-      next();
-      return finishNode(node, "Literal");
-
-    case _parenL:
-      var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart, val, exprList;
-      next();
             		           
                               
                            
                                
               
check whether this is generator comprehension or regular expression
             		                            
      if (options.ecmaVersion >= 6 && tokType === _for) {
-        val = parseComprehension(startNode(), true);
-      } else {
-        var oldParenL = ++metParenL;
-        if (tokType !== _parenR) {
-          val = parseExpression();
-          exprList = val.type === "SequenceExpression" ? val.expressions : [val];
-        } else {
-          exprList = [];
-        }
-        expect(_parenR);
             		           
                               
                            
                                
               
if '=>' follows '(...)', convert contents to arguments
             		                            
        if (metParenL === oldParenL && eat(_arrow)) {
-          val = parseArrowExpression(startNode(), exprList);
-        } else {
             		           
                               
                            
                                
               
forbid '()' before everything but '=>'
             		                            
          if (!val) unexpected(lastStart);
             		           
                               
                            
                                
               
forbid '...' in sequence expressions
             		                            
          if (options.ecmaVersion >= 6) {
-            for (var i = 0; i < exprList.length; i++) {
-              if (exprList[i].type === "SpreadElement") unexpected();
-            }
-          }
-        }
-      }
-      val.start = tokStart1;
-      val.end = lastEnd;
-      if (options.locations) {
-        val.loc.start = tokStartLoc1;
-        val.loc.end = lastEndLoc;
-      }
-      if (options.ranges) {
-        val.range = [tokStart1, lastEnd];
-      }
-      return val;
-
-    case _bracketL:
-      var node = startNode();
-      next();
             		           
                               
                            
                                
               
check whether this is array comprehension or regular array
             		                            
      if (options.ecmaVersion >= 6 && tokType === _for) {
-        return parseComprehension(node, false);
-      }
-      node.elements = parseExprList(_bracketR, true, true);
-      return finishNode(node, "ArrayExpression");
-
-    case _braceL:
-      return parseObj();
-
-    case _function:
-      var node = startNode();
-      next();
-      return parseFunction(node, false);
-
-    case _class:
-      return parseClass(startNode(), false);
-
-    case _new:
-      return parseNew();
-
-    case _ellipsis:
-      return parseSpread();
-
-    case _bquote:
-      return parseTemplate();
-
-    default:
-      unexpected();
-    }
-  }
             		           
                               
                            
                                
               
New's precedence is slightly tricky. It must allow its argument
-to be a [] or dot subscript expression, but not a call — at
-least, not without wrapping it in parentheses. Thus, it uses the
             		                            
  function parseNew() {
-    var node = startNode();
-    next();
-    node.callee = parseSubscripts(parseExprAtom(), true);
-    if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
-    else node.arguments = empty;
-    return finishNode(node, "NewExpression");
-  }
             		           
                               
                            
                                
               
Parse spread element '...expr'
             		                            
  function parseSpread() {
-    var node = startNode();
-    next();
-    node.argument = parseExpression(true);
-    return finishNode(node, "SpreadElement");
-  }
             		           
                               
                            
                                
               
Parse template expression.
             		                            
  function parseTemplate() {
-    var node = startNode();
-    node.expressions = [];
-    node.quasis = [];
-    inTemplate = true;
-    next();
-    for (;;) {
-      var elem = startNode();
-      elem.value = {cooked: tokVal, raw: input.slice(tokStart, tokEnd)};
-      elem.tail = false;
-      next();
-      node.quasis.push(finishNode(elem, "TemplateElement"));
-      if (eat(_bquote)) { // '`', end of template
-        elem.tail = true;
-        break;
-      }
-      inTemplate = false;
-      expect(_dollarBraceL);
-      node.expressions.push(parseExpression());
-      inTemplate = true;
-      expect(_braceR);
-    }
-    inTemplate = false;
-    return finishNode(node, "TemplateLiteral");
-  }
             		           
                               
                            
                                
               
Parse an object literal.
             		                            
  function parseObj() {
-    var node = startNode(), first = true, propHash = {};
-    node.properties = [];
-    next();
-    while (!eat(_braceR)) {
-      if (!first) {
-        expect(_comma);
-        if (options.allowTrailingCommas && eat(_braceR)) break;
-      } else first = false;
-
-      var prop = startNode(), isGenerator;
-      if (options.ecmaVersion >= 6) {
-        prop.method = false;
-        prop.shorthand = false;
-        isGenerator = eat(_star);
-      }
-      parsePropertyName(prop);
-      if (eat(_colon)) {
-        prop.value = parseExpression(true);
-        prop.kind = "init";
-      } else if (options.ecmaVersion >= 6 && tokType === _parenL) {
-        prop.kind = "init";
-        prop.method = true;
-        prop.value = parseMethod(isGenerator);
-      } else if (options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
-                 (prop.key.name === "get" || prop.key.name === "set")) {
-        if (isGenerator) unexpected();
-        prop.kind = prop.key.name;
-        parsePropertyName(prop);
-        prop.value = parseMethod(false);
-      } else if (options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
-        prop.kind = "init";
-        prop.value = prop.key;
-        prop.shorthand = true;
-      } else unexpected();
-
-      checkPropClash(prop, propHash);
-      node.properties.push(finishNode(prop, "Property"));
-    }
-    return finishNode(node, "ObjectExpression");
-  }
-
-  function parsePropertyName(prop) {
-    if (options.ecmaVersion >= 6) {
-      if (eat(_bracketL)) {
-        prop.computed = true;
-        prop.key = parseExpression();
-        expect(_bracketR);
-        return;
-      } else {
-        prop.computed = false;
-      }
-    }
-    prop.key = (tokType === _num || tokType === _string) ? parseExprAtom() : parseIdent(true);
-  }
             		           
                               
                            
                                
               
Initialize empty function node.
             		                            
  function initFunction(node) {
-    node.id = null;
-    node.params = [];
-    if (options.ecmaVersion >= 6) {
-      node.defaults = [];
-      node.rest = null;
-      node.generator = false;
-    }
-  }
             		           
                               
                            
                                
               
Parse a function declaration or literal (depending on the
-isStatement parameter).
             		                            
  function parseFunction(node, isStatement, allowExpressionBody) {
-    initFunction(node);
-    if (options.ecmaVersion >= 6) {
-      node.generator = eat(_star);
-    }
-    if (isStatement || tokType === _name) {
-      node.id = parseIdent();
-    }
-    parseFunctionParams(node);
-    parseFunctionBody(node, allowExpressionBody);
-    return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  }
             		           
                               
                            
                                
               
Parse object or class method.
             		                            
  function parseMethod(isGenerator) {
-    var node = startNode();
-    initFunction(node);
-    parseFunctionParams(node);
-    var allowExpressionBody;
-    if (options.ecmaVersion >= 6) {
-      node.generator = isGenerator;
-      allowExpressionBody = true;
-    } else {
-      allowExpressionBody = false;
-    }
-    parseFunctionBody(node, allowExpressionBody);
-    return finishNode(node, "FunctionExpression");
-  }
             		           
                               
                            
                                
               
Parse arrow function expression with given parameters.
             		                            
  function parseArrowExpression(node, params) {
-    initFunction(node);
-
-    var defaults = node.defaults, hasDefaults = false;
-
-    for (var i = 0, lastI = params.length - 1; i <= lastI; i++) {
-      var param = params[i];
-
-      if (param.type === "AssignmentExpression" && param.operator === "=") {
-        hasDefaults = true;
-        params[i] = param.left;
-        defaults.push(param.right);
-      } else {
-        toAssignable(param, i === lastI, true);
-        defaults.push(null);
-        if (param.type === "SpreadElement") {
-          params.length--;
-          node.rest = param.argument;
-          break;
-        }
-      }
-    }
-
-    node.params = params;
-    if (!hasDefaults) node.defaults = [];
-
-    parseFunctionBody(node, true);
-    return finishNode(node, "ArrowFunctionExpression");
-  }
             		           
                               
                            
                                
               
Parse function parameters.
             		                            
  function parseFunctionParams(node) {
-    var defaults = [], hasDefaults = false;
-
-    expect(_parenL);
-    for (;;) {
-      if (eat(_parenR)) {
-        break;
-      } else if (options.ecmaVersion >= 6 && eat(_ellipsis)) {
-        node.rest = toAssignable(parseExprAtom(), false, true);
-        checkSpreadAssign(node.rest);
-        expect(_parenR);
-        break;
-      } else {
-        node.params.push(options.ecmaVersion >= 6 ? toAssignable(parseExprAtom(), false, true) : parseIdent());
-        if (options.ecmaVersion >= 6 && tokType === _eq) {
-          next();
-          hasDefaults = true;
-          defaults.push(parseExpression(true));
-        }
-        if (!eat(_comma)) {
-          expect(_parenR);
-          break;
-        }
-      }
-    }
-
-    if (hasDefaults) node.defaults = defaults;
-  }
             		           
                               
                            
                                
               
Parse function body and check parameters.
             		                            
  function parseFunctionBody(node, allowExpression) {
-    var isExpression = allowExpression && tokType !== _braceL;
-
-    if (isExpression) {
-      node.body = parseExpression(true);
-      node.expression = true;
-    } else {
             		           
                               
                            
                                
               
Start a new scope with regard to labels and the inFunction
-flag (restore them to their old value afterwards).
             		                            
      var oldInFunc = inFunction, oldInGen = inGenerator, oldLabels = labels;
-      inFunction = true; inGenerator = node.generator; labels = [];
-      node.body = parseBlock(true);
-      node.expression = false;
-      inFunction = oldInFunc; inGenerator = oldInGen; labels = oldLabels;
-    }
             		           
                               
                            
                                
               
If this is a strict mode function, verify that argument names
-are not repeated, and it does not try to bind the words eval
-or arguments.
             		                            
    if (strict || !isExpression && node.body.body.length && isUseStrict(node.body.body[0])) {
-      var nameHash = {};
-      if (node.id)
-        checkFunctionParam(node.id, {});
-      for (var i = 0; i < node.params.length; i++)
-        checkFunctionParam(node.params[i], nameHash);
-      if (node.rest)
-        checkFunctionParam(node.rest, nameHash);
-    }
-  }
             		           
                               
                            
                                
               
Parse a class declaration or literal (depending on the
-isStatement parameter).
             		                            
  function parseClass(node, isStatement) {
-    next();
-    node.id = tokType === _name ? parseIdent() : isStatement ? unexpected() : null;
-    node.superClass = eat(_extends) ? parseExpression() : null;
-    var classBody = startNode(), methodHash = {}, staticMethodHash = {};
-    classBody.body = [];
-    expect(_braceL);
-    while (!eat(_braceR)) {
-      var method = startNode();
-      if (tokType === _name && tokVal === "static") {
-        next();
-        method['static'] = true;
-      } else {
-        method['static'] = false;
-      }
-      var isGenerator = eat(_star);
-      parsePropertyName(method);
-      if (tokType === _name && !method.computed && method.key.type === "Identifier" &&
-          (method.key.name === "get" || method.key.name === "set")) {
-        if (isGenerator) unexpected();
-        method.kind = method.key.name;
-        parsePropertyName(method);
-      } else {
-        method.kind = "";
-      }
-      method.value = parseMethod(isGenerator);
-      checkPropClash(method, method['static'] ? staticMethodHash : methodHash);
-      classBody.body.push(finishNode(method, "MethodDefinition"));
-      eat(_semi);
-    }
-    node.body = finishNode(classBody, "ClassBody");
-    return finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
-  }
             		           
                               
                            
                                
               
Parses a comma-separated list of expressions, and returns them as
-an array. close is the token type that ends the list, and
-allowEmpty can be turned on to allow subsequent commas with
-nothing in between them to be parsed as null (which is needed
-for array literals).
             		                            
  function parseExprList(close, allowTrailingComma, allowEmpty) {
-    var elts = [], first = true;
-    while (!eat(close)) {
-      if (!first) {
-        expect(_comma);
-        if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
-      } else first = false;
-
-      if (allowEmpty && tokType === _comma) elts.push(null);
-      else elts.push(parseExpression(true));
-    }
-    return elts;
-  }
             		           
                               
                            
                                
               
Parse the next token as an identifier. If liberal is true (used
-when parsing properties), it will also convert keywords into
-identifiers.
             		                            
  function parseIdent(liberal) {
-    var node = startNode();
-    if (liberal && options.forbidReserved == "everywhere") liberal = false;
-    if (tokType === _name) {
-      if (!liberal &&
-          (options.forbidReserved &&
-           (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
-           strict && isStrictReservedWord(tokVal)) &&
-          input.slice(tokStart, tokEnd).indexOf("\\") == -1)
-        raise(tokStart, "The keyword '" + tokVal + "' is reserved");
-      node.name = tokVal;
-    } else if (liberal && tokType.keyword) {
-      node.name = tokType.keyword;
-    } else {
-      unexpected();
-    }
-    tokRegexpAllowed = false;
-    next();
-    return finishNode(node, "Identifier");
-  }
             		           
                               
                            
                                
               
Parses module export declaration.
             		                            
  function parseExport(node) {
-    next();
             		           
                               
                            
                                
               
export var|const|let|function|class ...;
             		                            
    if (tokType === _var || tokType === _const || tokType === _let || tokType === _function || tokType === _class) {
-      node.declaration = parseStatement();
-      node['default'] = false;
-      node.specifiers = null;
-      node.source = null;
-    } else
             		           
                               
                            
                                
               
export default ...;
             		                            
    if (eat(_default)) {
-      node.declaration = parseExpression(true);
-      node['default'] = true;
-      node.specifiers = null;
-      node.source = null;
-      semicolon();
-    } else {
             		           
                               
                            
                                
               
export * from '...'
-export { x, y as z } [from '...']
             		                            
      var isBatch = tokType === _star;
-      node.declaration = null;
-      node['default'] = false;
-      node.specifiers = parseExportSpecifiers();
-      if (tokType === _name && tokVal === "from") {
-        next();
-        node.source = tokType === _string ? parseExprAtom() : unexpected();
-      } else {
-        if (isBatch) unexpected();
-        node.source = null;
-      }
-    }
-    return finishNode(node, "ExportDeclaration");
-  }
             		           
                               
                            
                                
               
Parses a comma-separated list of module exports.
             		                            
  function parseExportSpecifiers() {
-    var nodes = [], first = true;
-    if (tokType === _star) {
             		           
                               
                            
                                
               
export * from '...'
             		                            
      var node = startNode();
-      next();
-      nodes.push(finishNode(node, "ExportBatchSpecifier"));
-    } else {
             		           
                               
                            
                                
               
export { x, y as z } [from '...']
             		                            
      expect(_braceL);
-      while (!eat(_braceR)) {
-        if (!first) {
-          expect(_comma);
-          if (options.allowTrailingCommas && eat(_braceR)) break;
-        } else first = false;
-
-        var node = startNode();
-        node.id = parseIdent();
-        if (tokType === _name && tokVal === "as") {
-          next();
-          node.name = parseIdent(true);
-        } else {
-          node.name = null;
-        }
-        nodes.push(finishNode(node, "ExportSpecifier"));
-      }
-    }
-    return nodes;
-  }
             		           
                               
                            
                                
               
Parses import declaration.
             		                            
  function parseImport(node) {
-    next();
             		           
                               
                            
                                
               
import '...';
             		                            
    if (tokType === _string) {
-      node.specifiers = [];
-      node.source = parseExprAtom();
-      node.kind = "";
-    } else {
-      node.specifiers = parseImportSpecifiers();
-      if (tokType !== _name || tokVal !== "from") unexpected();
-      next();
-      node.source = tokType === _string ? parseExprAtom() : unexpected();
             		           
                               
                            
                                
               
only for backward compatibility with Esprima's AST
-(it doesn't support mixed default + named yet)
             		                            
      node.kind = node.specifiers[0]['default'] ? "default" : "named";
-    }
-    return finishNode(node, "ImportDeclaration");
-  }
             		           
                               
                            
                                
               
Parses a comma-separated list of module imports.
             		                            
  function parseImportSpecifiers() {
-    var nodes = [], first = true;
-    if (tokType === _star) {
-      var node = startNode();
-      next();
-      if (tokType !== _name || tokVal !== "as") unexpected();
-      next();
-      node.name = parseIdent();
-      checkLVal(node.name, true);
-      nodes.push(finishNode(node, "ImportBatchSpecifier"));
-      return nodes;
-    }
-    if (tokType === _name) {
             		           
                               
                            
                                
               
import defaultObj, { x, y as z } from '...'
             		                            
      var node = startNode();
-      node.id = parseIdent();
-      checkLVal(node.id, true);
-      node.name = null;
-      node['default'] = true;
-      nodes.push(finishNode(node, "ImportSpecifier"));
-      if (!eat(_comma)) return nodes;
-    }
-    expect(_braceL);
-    while (!eat(_braceR)) {
-      if (!first) {
-        expect(_comma);
-        if (options.allowTrailingCommas && eat(_braceR)) break;
-      } else first = false;
-
-      var node = startNode();
-      node.id = parseIdent(true);
-      if (tokType === _name && tokVal === "as") {
-        next();
-        node.name = parseIdent();
-      } else {
-        node.name = null;
-      }
-      checkLVal(node.name || node.id, true);
-      node['default'] = false;
-      nodes.push(finishNode(node, "ImportSpecifier"));
-    }
-    return nodes;
-  }
             		           
                               
                            
                                
               
Parses yield expression inside generator.
             		                            
  function parseYield() {
-    var node = startNode();
-    next();
-    if (eat(_semi) || canInsertSemicolon()) {
-      node.delegate = false;
-      node.argument = null;
-    } else {
-      node.delegate = eat(_star);
-      node.argument = parseExpression(true);
-    }
-    return finishNode(node, "YieldExpression");
-  }
             		           
                               
                            
                                
               
Parses array and generator comprehensions.
             		                            
  function parseComprehension(node, isGenerator) {
-    node.blocks = [];
-    while (tokType === _for) {
-      var block = startNode();
-      next();
-      expect(_parenL);
-      block.left = toAssignable(parseExprAtom());
-      checkLVal(block.left, true);
-      if (tokType !== _name || tokVal !== "of") unexpected();
-      next();
             		           
                               
                            
                                
               
of property is here for compatibility with Esprima's AST
-which also supports deprecated [for (... in ...) expr]
             		                            
      block.of = true;
-      block.right = parseExpression();
-      expect(_parenR);
-      node.blocks.push(finishNode(block, "ComprehensionBlock"));
-    }
-    node.filter = eat(_if) ? parseParenExpression() : null;
-    node.body = parseExpression();
-    expect(isGenerator ? _parenR : _bracketR);
-    node.generator = isGenerator;
-    return finishNode(node, "ComprehensionExpression");
-  }
-
-});
-
-
             		           
                     
   
   
\ No newline at end of file

From 456f74e34fb6bb6dbed3329f30e3a397414e4d07 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke 
Date: Fri, 12 Sep 2014 16:56:07 +0200
Subject: [PATCH 05/25] Mark version 0.8.0

---
 AUTHORS      | 1 +
 acorn.js     | 2 +-
 package.json | 2 +-
 3 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/AUTHORS b/AUTHORS
index 276eaace8a..8bb9fd76a0 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -19,6 +19,7 @@ Marijn Haverbeke
 Martin Carlberg
 Mathias Bynens
 Mathieu 'p01' Henri
+Max Schaefer
 Mihai Bazon
 Oskar Schöldström
 Paul Harper
diff --git a/acorn.js b/acorn.js
index 05124c7edb..da2b19c778 100644
--- a/acorn.js
+++ b/acorn.js
@@ -28,7 +28,7 @@
 })(this, function(exports) {
   "use strict";
 
-  exports.version = "0.7.1";
+  exports.version = "0.8.0";
 
   // The main exported interface (under `self.acorn` when in the
   // browser) is a `parse` function that takes a code string and
diff --git a/package.json b/package.json
index 808e0a8ca7..269ca95464 100644
--- a/package.json
+++ b/package.json
@@ -3,7 +3,7 @@
     "description": "ECMAScript parser",
     "homepage": "http://marijnhaverbeke.nl/acorn/",
     "main": "acorn.js",
-    "version": "0.7.1",
+    "version": "0.8.0",
     "engines": {"node": ">=0.4.0"},
     "maintainers": [{"name": "Marijn Haverbeke",
                      "email": "marijnh@gmail.com",

From ac31b0314c6baa5831805e28f6d782bf18e12fde Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke 
Date: Fri, 12 Sep 2014 16:57:40 +0200
Subject: [PATCH 06/25] Bump version number post-0.8

---
 acorn.js     | 2 +-
 package.json | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/acorn.js b/acorn.js
index da2b19c778..bf3a397b64 100644
--- a/acorn.js
+++ b/acorn.js
@@ -28,7 +28,7 @@
 })(this, function(exports) {
   "use strict";
 
-  exports.version = "0.8.0";
+  exports.version = "0.8.1";
 
   // The main exported interface (under `self.acorn` when in the
   // browser) is a `parse` function that takes a code string and
diff --git a/package.json b/package.json
index 269ca95464..7b01a78540 100644
--- a/package.json
+++ b/package.json
@@ -3,7 +3,7 @@
     "description": "ECMAScript parser",
     "homepage": "http://marijnhaverbeke.nl/acorn/",
     "main": "acorn.js",
-    "version": "0.8.0",
+    "version": "0.8.1",
     "engines": {"node": ">=0.4.0"},
     "maintainers": [{"name": "Marijn Haverbeke",
                      "email": "marijnh@gmail.com",

From d0497ab21229e15ac535d76b87c7034edf6f3bd8 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke 
Date: Mon, 15 Sep 2014 20:56:04 +0200
Subject: [PATCH 07/25] Add parseExpressionAt function to the API

---
 README.md |  4 ++++
 acorn.js  | 39 ++++++++++++++++++++++++++++++---------
 2 files changed, 34 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index 531f38063a..bf53c31b87 100644
--- a/README.md
+++ b/README.md
@@ -134,6 +134,10 @@ object referring to that same position.
 
 [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
 
+**parseExpressionAt**`(input, offset, options)` will parse a single
+expression in a string, and return its AST. It will not complain if
+there is more of the string left after the expression.
+
 **getLineInfo**`(input, offset)` can be used to get a `{line,
 column}` object for a given program string and character offset.
 
diff --git a/acorn.js b/acorn.js
index bf3a397b64..7fec92f7d0 100644
--- a/acorn.js
+++ b/acorn.js
@@ -43,6 +43,7 @@
     input = String(inpt); inputLen = input.length;
     setOptions(opts);
     initTokenState();
+    initParserState();
     return parseTopLevel(options.program);
   };
 
@@ -114,6 +115,18 @@
     directSourceFile: null
   };
 
+  // This function tries to parse a single expression at a given
+  // offset in a string. Useful for parsing mixed-language formats
+  // that embed JavaScript expressions.
+
+  exports.parseExpressionAt = function(inpt, pos, opts) {
+    input = String(inpt); inputLen = input.length;
+    setOptions(opts);
+    initTokenState(pos);
+    initParserState();
+    return parseExpression();
+  };
+
   var isArray = function (obj) {
     return Object.prototype.toString.call(obj) === "[object Array]";
   };
@@ -286,6 +299,14 @@
 
   var inTemplate;
 
+  function initParserState() {
+    lastStart = lastEnd = tokPos;
+    if (options.locations) lastEndLoc = new Position;
+    inFunction = inGenerator = strict = null;
+    labels = [];
+    readToken();
+  }
+
   // This function is used to raise exceptions on parse errors. It
   // takes an offset integer (into the current `input`) to indicate
   // the location of the error, attaches the position to the end
@@ -554,9 +575,15 @@
 
   // Reset the token state. Used at the start of a parse.
 
-  function initTokenState() {
-    tokCurLine = 1;
-    tokPos = tokLineStart = 0;
+  function initTokenState(pos) {
+    if (pos) {
+      tokPos = pos;
+      tokLineStart = Math.max(0, input.lastIndexOf("\n", pos));
+      tokCurLine = input.slice(0, tokLineStart).split(newline).length;
+    } else {
+      tokCurLine = 1;
+      tokPos = tokLineStart = 0;
+    }
     tokRegexpAllowed = true;
     metParenL = 0;
     inTemplate = false;
@@ -1436,12 +1463,6 @@
   // to its body instead of creating a new node.
 
   function parseTopLevel(program) {
-    lastStart = lastEnd = tokPos;
-    if (options.locations) lastEndLoc = new Position;
-    inFunction = inGenerator = strict = null;
-    labels = [];
-    readToken();
-
     var node = program || startNode(), first = true;
     if (!program) node.body = [];
     while (tokType !== _eof) {

From 12cbfed34f3eae4c0e19ac547806a6be7ecefca2 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke 
Date: Mon, 22 Sep 2014 14:46:41 +0200
Subject: [PATCH 08/25] [loose parser] Don't omit unfinished object literal
 properties

---
 acorn_loose.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/acorn_loose.js b/acorn_loose.js
index b3506b46b5..e7967f1d30 100644
--- a/acorn_loose.js
+++ b/acorn_loose.js
@@ -712,9 +712,7 @@
         prop.key = parsePropertyName() || dummyIdent();
         prop.value = parseFunction(startNode(), false);
       } else {
-        next();
-        eat(tt.comma);
-        continue;
+        prop.value = dummyIdent();
       }
 
       node.properties.push(finishNode(prop, "Property"));

From 39fa62e90fa3a9fc269493ceaee9fce2c747bf43 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke 
Date: Mon, 22 Sep 2014 15:03:54 +0200
Subject: [PATCH 09/25] [loose parser] Be slightly more agressive about
 heuristically closing object literals

---
 acorn_loose.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/acorn_loose.js b/acorn_loose.js
index e7967f1d30..e490eb2761 100644
--- a/acorn_loose.js
+++ b/acorn_loose.js
@@ -698,7 +698,7 @@
     pushCx();
     next();
     var propIndent = curIndent, line = curLineStart;
-    while (!closes(tt.braceR, propIndent, line)) {
+    while (!closes(tt.braceR, propIndent + 1, line)) {
       var name = parsePropertyName();
       if (!name) { if (isDummy(parseExpression(true))) next(); eat(tt.comma); continue; }
       var prop = startNode();

From 49680b1c60f21751f5e09756fb78fb573a2e59f0 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke 
Date: Mon, 22 Sep 2014 15:15:12 +0200
Subject: [PATCH 10/25] [loose parser] Take brace-line indentation into account
 for objlit closing heuristic

---
 acorn_loose.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/acorn_loose.js b/acorn_loose.js
index e490eb2761..c6b7f46bce 100644
--- a/acorn_loose.js
+++ b/acorn_loose.js
@@ -696,9 +696,10 @@
     var node = startNode();
     node.properties = [];
     pushCx();
+    var indent = curIndent + 1, line = curLineStart;
     next();
-    var propIndent = curIndent, line = curLineStart;
-    while (!closes(tt.braceR, propIndent + 1, line)) {
+    if (curIndent + 1 < indent) { indent = curIndent; line = curLineStart; }
+    while (!closes(tt.braceR, indent, line)) {
       var name = parsePropertyName();
       if (!name) { if (isDummy(parseExpression(true))) next(); eat(tt.comma); continue; }
       var prop = startNode();

From 6ea4139be150308cf42e5db82cfda78dba260dd4 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke 
Date: Mon, 22 Sep 2014 17:08:50 +0200
Subject: [PATCH 11/25] Add note about deprecated scopeVisitor object

See issue #126
---
 util/walk.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/util/walk.js b/util/walk.js
index 04268f2c71..117f56f93c 100644
--- a/util/walk.js
+++ b/util/walk.js
@@ -306,6 +306,8 @@
     c(node.body, st, "Expression");
   };
 
+  // NOTE: the stuff below is deprecated, and will be removed when 1.0 is released
+
   // A custom walker that keeps track of the scope chain and the
   // variables defined in it.
   function makeScope(prev, isCatch) {

From 203384f7c23d169a0af96f223098985415f117df Mon Sep 17 00:00:00 2001
From: Ingvar Stepanyan 
Date: Tue, 23 Sep 2014 23:51:39 +0300
Subject: [PATCH 12/25] Fixes marijnh/acorn#127.

---
 acorn.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/acorn.js b/acorn.js
index 7fec92f7d0..22a9ca1326 100644
--- a/acorn.js
+++ b/acorn.js
@@ -2107,7 +2107,7 @@
       elem.tail = false;
       next();
       node.quasis.push(finishNode(elem, "TemplateElement"));
-      if (eat(_bquote)) { // '`', end of template
+      if (tokType === _bquote) { // '`', end of template
         elem.tail = true;
         break;
       }
@@ -2118,6 +2118,7 @@
       expect(_braceR);
     }
     inTemplate = false;
+    next();
     return finishNode(node, "TemplateLiteral");
   }
 

From daedc6fcb323cd6e205a87d1d8e5b78d1fbca090 Mon Sep 17 00:00:00 2001
From: Ingvar Stepanyan 
Date: Wed, 24 Sep 2014 14:07:24 +0300
Subject: [PATCH 13/25] Fixes #129 and spaces in template quasi literals.

* Added hack to correctly handle skipped spaces after= template expressions.
* Added `null` default values for regular functions.
* Added regression tests for both.
---
 acorn.js              |  14 +++--
 test/tests-harmony.js | 143 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 153 insertions(+), 4 deletions(-)

diff --git a/acorn.js b/acorn.js
index 22a9ca1326..aafc34d2bd 100644
--- a/acorn.js
+++ b/acorn.js
@@ -2115,6 +2115,8 @@
       expect(_dollarBraceL);
       node.expressions.push(parseExpression());
       inTemplate = true;
+      // hack to include previously skipped space
+      tokPos = tokEnd;
       expect(_braceR);
     }
     inTemplate = false;
@@ -2270,13 +2272,17 @@
         node.rest = toAssignable(parseExprAtom(), false, true);
         checkSpreadAssign(node.rest);
         expect(_parenR);
+        defaults.push(null);
         break;
       } else {
         node.params.push(options.ecmaVersion >= 6 ? toAssignable(parseExprAtom(), false, true) : parseIdent());
-        if (options.ecmaVersion >= 6 && tokType === _eq) {
-          next();
-          hasDefaults = true;
-          defaults.push(parseExpression(true));
+        if (options.ecmaVersion >= 6) {
+          if (eat(_eq)) {
+            hasDefaults = true;
+            defaults.push(parseExpression(true));
+          } else {
+            defaults.push(null);
+          }
         }
         if (!eat(_comma)) {
           expect(_parenR);
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index 5bfba14a3a..e0d36665ad 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -15246,3 +15246,146 @@ testFail("\"use strict\"; (eval) => 42", "Defining 'eval' in strict mode (1:15)"
 testFail("(eval) => { \"use strict\"; 42 }", "Defining 'eval' in strict mode (1:1)", {ecmaVersion: 6});
 
 testFail("({ get test() { } }) => 42", "Unexpected token (1:7)", {ecmaVersion: 6});
+
+/* Regression tests */
+
+// # https://github.com/marijnh/acorn/issues/127
+test('doSmth(`${x} + ${y} = ${x + y}`)', {
+  type: "Program",
+  start: 0,
+  end: 32,
+  body: [{
+    type: "ExpressionStatement",
+    start: 0,
+    end: 32,
+    expression: {
+      type: "CallExpression",
+      start: 0,
+      end: 32,
+      callee: {
+        type: "Identifier",
+        start: 0,
+        end: 6,
+        name: "doSmth"
+      },
+      arguments: [{
+        type: "TemplateLiteral",
+        start: 7,
+        end: 31,
+        expressions: [
+          {
+            type: "Identifier",
+            start: 10,
+            end: 11,
+            name: "x"
+          },
+          {
+            type: "Identifier",
+            start: 17,
+            end: 18,
+            name: "y"
+          },
+          {
+            type: "BinaryExpression",
+            start: 24,
+            end: 29,
+            left: {
+              type: "Identifier",
+              start: 24,
+              end: 25,
+              name: "x"
+            },
+            operator: "+",
+            right: {
+              type: "Identifier",
+              start: 28,
+              end: 29,
+              name: "y"
+            }
+          }
+        ],
+        quasis: [
+          {
+            type: "TemplateElement",
+            start: 8,
+            end: 8,
+            value: {cooked: "", raw: ""},
+            tail: false
+          },
+          {
+            type: "TemplateElement",
+            start: 12,
+            end: 15,
+            value: {cooked: " + ", raw: " + "},
+            tail: false
+          },
+          {
+            type: "TemplateElement",
+            start: 19,
+            end: 22,
+            value: {cooked: " = ", raw: " = "},
+            tail: false
+          },
+          {
+            type: "TemplateElement",
+            start: 30,
+            end: 30,
+            value: {cooked: "", raw: ""},
+            tail: true
+          }
+        ]
+      }]
+    }
+  }]
+}, {ecmaVersion: 6});
+
+// # https://github.com/marijnh/acorn/issues/129
+test('function normal(x, y = 10) {}', {
+  type: "Program",
+  start: 0,
+  end: 29,
+  body: [{
+    type: "FunctionDeclaration",
+    start: 0,
+    end: 29,
+    id: {
+      type: "Identifier",
+      start: 9,
+      end: 15,
+      name: "normal"
+    },
+    params: [
+      {
+        type: "Identifier",
+        start: 16,
+        end: 17,
+        name: "x"
+      },
+      {
+        type: "Identifier",
+        start: 19,
+        end: 20,
+        name: "y"
+      }
+    ],
+    defaults: [
+      null,
+      {
+        type: "Literal",
+        start: 23,
+        end: 25,
+        value: 10,
+        raw: "10"
+      }
+    ],
+    rest: null,
+    generator: false,
+    body: {
+      type: "BlockStatement",
+      start: 27,
+      end: 29,
+      body: []
+    },
+    expression: false
+  }]
+}, {ecmaVersion: 6});
\ No newline at end of file

From 015a0e90bcbd5c4093650917d1373d211c086a41 Mon Sep 17 00:00:00 2001
From: Max Schaefer 
Date: Mon, 29 Sep 2014 10:16:22 +0100
Subject: [PATCH 14/25] Only accept for-of loops in ECMA6 mode.

---
 acorn.js      | 4 ++--
 test/tests.js | 4 ++++
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/acorn.js b/acorn.js
index aafc34d2bd..8d4760d520 100644
--- a/acorn.js
+++ b/acorn.js
@@ -1584,13 +1584,13 @@
       next();
       parseVar(init, true, varKind);
       finishNode(init, "VariableDeclaration");
-      if ((tokType === _in || (tokType === _name && tokVal === "of")) && init.declarations.length === 1 &&
+      if ((tokType === _in || (options.ecmaVersion >= 6 && tokType === _name && tokVal === "of")) && init.declarations.length === 1 &&
           !(isLet && init.declarations[0].init))
         return parseForIn(node, init);
       return parseFor(node, init);
     }
     var init = parseExpression(false, true);
-    if (tokType === _in || (tokType === _name && tokVal === "of")) {
+    if (tokType === _in || (options.ecmaVersion >= 6 && tokType === _name && tokVal === "of")) {
       checkLVal(init);
       return parseForIn(node, init);
     }
diff --git a/test/tests.js b/test/tests.js
index 936e73a5fb..40069ee697 100644
--- a/test/tests.js
+++ b/test/tests.js
@@ -28594,6 +28594,10 @@ testFail("const a;", "Unexpected token (1:7)", {ecmaVersion: 6});
 
 testFail("for(const x = 0;;);", "Unexpected token (1:4)", {ecmaVersion: 6});
 
+testFail("for(x of a);", "Unexpected token (1:6)");
+
+testFail("for(var x of a);", "Unexpected token (1:10)");
+
 // Assertion Tests
 (function() {
   var actualComments = [],

From f3e759cd03e575239b521a577d53ca8d6c400c64 Mon Sep 17 00:00:00 2001
From: r-e-d 
Date: Tue, 30 Sep 2014 10:58:21 +0200
Subject: [PATCH 15/25] Strict mode incorrectly reset after function

---
 acorn.js      | 6 +++---
 test/tests.js | 3 +++
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/acorn.js b/acorn.js
index 8d4760d520..24b7ff5bef 100644
--- a/acorn.js
+++ b/acorn.js
@@ -302,7 +302,7 @@
   function initParserState() {
     lastStart = lastEnd = tokPos;
     if (options.locations) lastEndLoc = new Position;
-    inFunction = inGenerator = strict = null;
+    inFunction = inGenerator = strict = false;
     labels = [];
     readToken();
   }
@@ -1752,7 +1752,7 @@
   // function bodies).
 
   function parseBlock(allowStrict) {
-    var node = startNode(), first = true, strict = false, oldStrict;
+    var node = startNode(), first = true, oldStrict;
     node.body = [];
     expect(_braceL);
     while (!eat(_braceR)) {
@@ -1764,7 +1764,7 @@
       }
       first = false;
     }
-    if (strict && !oldStrict) setStrict(false);
+    if (oldStrict === false) setStrict(false);
     return finishNode(node, "BlockStatement");
   }
 
diff --git a/test/tests.js b/test/tests.js
index 40069ee697..c39aa3cde6 100644
--- a/test/tests.js
+++ b/test/tests.js
@@ -27285,6 +27285,9 @@ testFail("(function a(eval) { \"use strict\"; })",
 testFail("(function a(package) { \"use strict\"; })",
          "Defining 'package' in strict mode (1:12)");
 
+testFail("\"use strict\";function foo(){\"use strict\";}function bar(){var v = 015}",
+         "Invalid number (1:65)");
+
 testFail("var this = 10;", "Unexpected token (1:4)");
 
 testFail("throw\n10;", "Illegal newline after throw (1:5)");

From 01a89cfec14fa4875b98c3e829e5a76a2a1208f7 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke 
Date: Wed, 1 Oct 2014 23:21:25 +0200
Subject: [PATCH 16/25] Mark release 0.9.0

---
 AUTHORS               | 1 +
 acorn.js              | 2 +-
 bin/update_authors.sh | 2 +-
 package.json          | 2 +-
 4 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/AUTHORS b/AUTHORS
index 8bb9fd76a0..a9e6016d75 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -25,4 +25,5 @@ Oskar Schöldström
 Paul Harper
 Peter Rust
 PlNG
+r-e-d
 zsjforcn
diff --git a/acorn.js b/acorn.js
index 24b7ff5bef..6360d112f0 100644
--- a/acorn.js
+++ b/acorn.js
@@ -28,7 +28,7 @@
 })(this, function(exports) {
   "use strict";
 
-  exports.version = "0.8.1";
+  exports.version = "0.9.0";
 
   // The main exported interface (under `self.acorn` when in the
   // browser) is a `parse` function that takes a code string and
diff --git a/bin/update_authors.sh b/bin/update_authors.sh
index 466c8db586..a517bc0999 100755
--- a/bin/update_authors.sh
+++ b/bin/update_authors.sh
@@ -1,6 +1,6 @@
 # Combine existing list of authors with everyone known in git, sort, add header.
 tail --lines=+3 AUTHORS > AUTHORS.tmp
 git log --format='%aN' | grep -v abraidwood >> AUTHORS.tmp
-echo -e "List of Acorn contributors. Updated before every release.\n" > AUTHORS
+echo "List of Acorn contributors. Updated before every release.\n" > AUTHORS
 sort -u AUTHORS.tmp >> AUTHORS
 rm -f AUTHORS.tmp
diff --git a/package.json b/package.json
index 7b01a78540..572f3c9fd5 100644
--- a/package.json
+++ b/package.json
@@ -3,7 +3,7 @@
     "description": "ECMAScript parser",
     "homepage": "http://marijnhaverbeke.nl/acorn/",
     "main": "acorn.js",
-    "version": "0.8.1",
+    "version": "0.9.0",
     "engines": {"node": ">=0.4.0"},
     "maintainers": [{"name": "Marijn Haverbeke",
                      "email": "marijnh@gmail.com",

From 1c9e0a92729a88e016c561c34a62b67b9728aa74 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke 
Date: Wed, 1 Oct 2014 23:21:56 +0200
Subject: [PATCH 17/25] Bump version number post 0.9

---
 acorn.js     | 2 +-
 package.json | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/acorn.js b/acorn.js
index 6360d112f0..6ac1979e40 100644
--- a/acorn.js
+++ b/acorn.js
@@ -28,7 +28,7 @@
 })(this, function(exports) {
   "use strict";
 
-  exports.version = "0.9.0";
+  exports.version = "0.9.1";
 
   // The main exported interface (under `self.acorn` when in the
   // browser) is a `parse` function that takes a code string and
diff --git a/package.json b/package.json
index 572f3c9fd5..77c0d1915b 100644
--- a/package.json
+++ b/package.json
@@ -3,7 +3,7 @@
     "description": "ECMAScript parser",
     "homepage": "http://marijnhaverbeke.nl/acorn/",
     "main": "acorn.js",
-    "version": "0.9.0",
+    "version": "0.9.1",
     "engines": {"node": ">=0.4.0"},
     "maintainers": [{"name": "Marijn Haverbeke",
                      "email": "marijnh@gmail.com",

From 3603f7d0b1d311f99a506549b9024f3e790e68e7 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke 
Date: Wed, 8 Oct 2014 11:52:40 +0200
Subject: [PATCH 18/25] Adjust start positions of parenthesized expressions to
 not include parentheses

Issue #136
---
 acorn.js              |  88 +++++++++---------
 test/driver.js        |   9 +-
 test/tests-harmony.js | 176 ++++++++++++++++++------------------
 test/tests.js         | 201 ++++++++----------------------------------
 4 files changed, 174 insertions(+), 300 deletions(-)

diff --git a/acorn.js b/acorn.js
index 6ac1979e40..8b5cb15aed 100644
--- a/acorn.js
+++ b/acorn.js
@@ -1236,19 +1236,24 @@
     return node;
   }
 
-  // Start a node whose start offset information should be based on
-  // the start of another node. For example, a binary operator node is
-  // only started after its left-hand side has already been parsed.
+  // Sometimes, a node is only started *after* the token stream passed
+  // its start position. The functions below help storing a position
+  // and creating a node from a previous position.
 
-  function startNodeFrom(other) {
-    var node = new Node();
-    node.start = other.start;
+  function storeCurrentPos() {
+    return options.locations ? [tokStart, tokStartLoc] : tokStart;
+  }
+
+  function startNodeAt(pos) {
+    var node = new Node(), start = pos;
     if (options.locations) {
       node.loc = new SourceLocation();
-      node.loc.start = other.loc.start;
+      node.loc.start = start[1];
+      start = pos[0];
     }
+    node.start = start;
     if (options.ranges)
-      node.range = [other.range[0], 0];
+      node.range = [start, 0];
 
     return node;
   }
@@ -1827,9 +1832,10 @@
   // or the `in` operator (in for loops initalization expressions).
 
   function parseExpression(noComma, noIn) {
+    var start = storeCurrentPos();
     var expr = parseMaybeAssign(noIn);
     if (!noComma && tokType === _comma) {
-      var node = startNodeFrom(expr);
+      var node = startNodeAt(start);
       node.expressions = [expr];
       while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
       return finishNode(node, "SequenceExpression");
@@ -1841,9 +1847,10 @@
   // operators like `+=`.
 
   function parseMaybeAssign(noIn) {
+    var start = storeCurrentPos();
     var left = parseMaybeConditional(noIn);
     if (tokType.isAssign) {
-      var node = startNodeFrom(left);
+      var node = startNodeAt(start);
       node.operator = tokVal;
       node.left = tokType === _eq ? toAssignable(left) : left;
       checkLVal(left);
@@ -1857,9 +1864,10 @@
   // Parse a ternary conditional (`?:`) operator.
 
   function parseMaybeConditional(noIn) {
+    var start = storeCurrentPos();
     var expr = parseExprOps(noIn);
     if (eat(_question)) {
-      var node = startNodeFrom(expr);
+      var node = startNodeAt(start);
       node.test = expr;
       node.consequent = parseExpression(true);
       expect(_colon);
@@ -1872,7 +1880,8 @@
   // Start the precedence parser.
 
   function parseExprOps(noIn) {
-    return parseExprOp(parseMaybeUnary(), -1, noIn);
+    var start = storeCurrentPos();
+    return parseExprOp(parseMaybeUnary(), start, -1, noIn);
   }
 
   // Parse binary operators with the operator precedence parsing
@@ -1881,18 +1890,19 @@
   // defer further parser to one of its callers when it encounters an
   // operator that has a lower precedence than the set it is parsing.
 
-  function parseExprOp(left, minPrec, noIn) {
+  function parseExprOp(left, leftStart, minPrec, noIn) {
     var prec = tokType.binop;
     if (prec != null && (!noIn || tokType !== _in)) {
       if (prec > minPrec) {
-        var node = startNodeFrom(left);
+        var node = startNodeAt(leftStart);
         node.left = left;
         node.operator = tokVal;
         var op = tokType;
         next();
-        node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
-        var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
-        return parseExprOp(exprNode, minPrec, noIn);
+        var start = storeCurrentPos();
+        node.right = parseExprOp(parseMaybeUnary(), start, prec, noIn);
+        finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
+        return parseExprOp(node, leftStart, minPrec, noIn);
       }
     }
     return left;
@@ -1914,9 +1924,10 @@
         raise(node.start, "Deleting local variable in strict mode");
       return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
     }
+    var start = storeCurrentPos();
     var expr = parseExprSubscripts();
     while (tokType.postfix && !canInsertSemicolon()) {
-      var node = startNodeFrom(expr);
+      var node = startNodeAt(start);
       node.operator = tokVal;
       node.prefix = false;
       node.argument = expr;
@@ -1930,33 +1941,34 @@
   // Parse call, dot, and `[]`-subscript expressions.
 
   function parseExprSubscripts() {
-    return parseSubscripts(parseExprAtom());
+    var start = storeCurrentPos();
+    return parseSubscripts(parseExprAtom(), start);
   }
 
-  function parseSubscripts(base, noCalls) {
+  function parseSubscripts(base, start, noCalls) {
     if (eat(_dot)) {
-      var node = startNodeFrom(base);
+      var node = startNodeAt(start);
       node.object = base;
       node.property = parseIdent(true);
       node.computed = false;
-      return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+      return parseSubscripts(finishNode(node, "MemberExpression"), start, noCalls);
     } else if (eat(_bracketL)) {
-      var node = startNodeFrom(base);
+      var node = startNodeAt(start);
       node.object = base;
       node.property = parseExpression();
       node.computed = true;
       expect(_bracketR);
-      return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+      return parseSubscripts(finishNode(node, "MemberExpression"), start, noCalls);
     } else if (!noCalls && eat(_parenL)) {
-      var node = startNodeFrom(base);
+      var node = startNodeAt(start);
       node.callee = base;
       node.arguments = parseExprList(_parenR, false);
-      return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
+      return parseSubscripts(finishNode(node, "CallExpression"), start, noCalls);
     } else if (tokType === _bquote) {
-      var node = startNodeFrom(base);
+      var node = startNodeAt(start);
       node.tag = base;
       node.quasi = parseTemplate();
-      return parseSubscripts(finishNode(node, "TaggedTemplateExpression"), noCalls);
+      return parseSubscripts(finishNode(node, "TaggedTemplateExpression"), start, noCalls);
     } return base;
   }
 
@@ -1976,9 +1988,10 @@
       if (inGenerator) return parseYield();
 
     case _name:
+      var start = storeCurrentPos();
       var id = parseIdent(tokType !== _name);
       if (eat(_arrow)) {
-        return parseArrowExpression(startNodeFrom(id), [id]);
+        return parseArrowExpression(startNodeAt(start), [id]);
       }
       return id;
 
@@ -1997,11 +2010,12 @@
       return finishNode(node, "Literal");
 
     case _parenL:
+      var start = storeCurrentPos();
       var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart, val, exprList;
       next();
       // check whether this is generator comprehension or regular expression
       if (options.ecmaVersion >= 6 && tokType === _for) {
-        val = parseComprehension(startNode(), true);
+        val = parseComprehension(startNodeAt(start), true);
       } else {
         var oldParenL = ++metParenL;
         if (tokType !== _parenR) {
@@ -2013,7 +2027,7 @@
         expect(_parenR);
         // if '=>' follows '(...)', convert contents to arguments
         if (metParenL === oldParenL && eat(_arrow)) {
-          val = parseArrowExpression(startNode(), exprList);
+          val = parseArrowExpression(startNodeAt(start), exprList);
         } else {
           // forbid '()' before everything but '=>'
           if (!val) unexpected(lastStart);
@@ -2025,15 +2039,6 @@
           }
         }
       }
-      val.start = tokStart1;
-      val.end = lastEnd;
-      if (options.locations) {
-        val.loc.start = tokStartLoc1;
-        val.loc.end = lastEndLoc;
-      }
-      if (options.ranges) {
-        val.range = [tokStart1, lastEnd];
-      }
       return val;
 
     case _bracketL:
@@ -2078,7 +2083,8 @@
   function parseNew() {
     var node = startNode();
     next();
-    node.callee = parseSubscripts(parseExprAtom(), true);
+    var start = storeCurrentPos();
+    node.callee = parseSubscripts(parseExprAtom(), start, true);
     if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
     else node.arguments = empty;
     return finishNode(node, "NewExpression");
diff --git a/test/driver.js b/test/driver.js
index 3b1551092a..a08bf6e837 100644
--- a/test/driver.js
+++ b/test/driver.js
@@ -43,10 +43,9 @@
           else callback("ok", test.code);
         } else {
           var mis = misMatch(test.ast, ast);
+          if (!mis && test.comments) mis = misMatch(test.comments, comments);
           if (mis) callback("fail", test.code, mis);
-          if (test.comments) mis = misMatch(test.comments, comments);
-          if (!mis) callback("ok", test.code);
-          else callback("fail", test.code, mis);
+          else callback("ok", test.code);
         }
       } catch(e) {
         if (test.error && e instanceof SyntaxError) {
@@ -67,7 +66,7 @@
     return str + " (" + pt + ")";
   }
 
-  function misMatch(exp, act) {
+  var misMatch = exports.misMatch = function(exp, act) {
     if (!exp || !act || (typeof exp != "object") || (typeof act != "object")) {
       if (exp !== act) return ppJSON(exp) + " !== " + ppJSON(act);
     } else if (exp.splice) {
@@ -83,7 +82,7 @@
         if (mis) return addPath(mis, prop);
       }
     }
-  }
+  };
 
   function mangle(ast) {
     if (typeof ast != "object" || !ast) return;
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index e0d36665ad..deeb049f65 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -1511,10 +1511,10 @@ test("e => ({ property: 42 })", {
             end: {line: 1, column: 20}
           }
         }],
-        range: [5, 23],
+        range: [6, 22],
         loc: {
-          start: {line: 1, column: 5},
-          end: {line: 1, column: 23}
+          start: {line: 1, column: 6},
+          end: {line: 1, column: 22}
         }
       },
       rest: null,
@@ -2330,10 +2330,10 @@ test("(x => x)", {
       rest: null,
       generator: false,
       expression: true,
-      range: [0, 8],
+      range: [1, 7],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 8}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 7}
       }
     },
     range: [0, 8],
@@ -2500,19 +2500,19 @@ test("(x) => ((y, z) => (x, y, z))", {
               }
             }
           ],
-          range: [18, 27],
+          range: [19, 26],
           loc: {
-            start: {line: 1, column: 18},
-            end: {line: 1, column: 27}
+            start: {line: 1, column: 19},
+            end: {line: 1, column: 26}
           }
         },
         rest: null,
         generator: false,
         expression: true,
-        range: [7, 28],
+        range: [8, 27],
         loc: {
-          start: {line: 1, column: 7},
-          end: {line: 1, column: 28}
+          start: {line: 1, column: 8},
+          end: {line: 1, column: 27}
         }
       },
       rest: null,
@@ -4268,10 +4268,10 @@ test("({ responseText: text }) = res", {
             end: {line: 1, column: 21}
           }
         }],
-        range: [0, 24],
+        range: [1, 23],
         loc: {
-          start: {line: 1, column: 0},
-          end: {line: 1, column: 24}
+          start: {line: 1, column: 1},
+          end: {line: 1, column: 23}
         }
       },
       right: {
@@ -6115,10 +6115,10 @@ test("(function* () { yield v })", {
       rest: null,
       generator: true,
       expression: false,
-      range: [0, 26],
+      range: [1, 25],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 26}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 25}
       }
     },
     range: [0, 26],
@@ -6195,10 +6195,10 @@ test("(function* () { yield\nv })", {
       rest: null,
       generator: true,
       expression: false,
-      range: [0, 26],
+      range: [1, 25],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 2, column: 4}
+        start: {line: 1, column: 1},
+        end: {line: 2, column: 3}
       }
     },
     range: [0, 26],
@@ -6264,10 +6264,10 @@ test("(function* () { yield *v })", {
       rest: null,
       generator: true,
       expression: false,
-      range: [0, 27],
+      range: [1, 26],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 27}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 26}
       }
     },
     range: [0, 27],
@@ -6572,10 +6572,10 @@ test("(function* () { yield yield 10 })", {
       rest: null,
       generator: true,
       expression: false,
-      range: [0, 33],
+      range: [1, 32],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 33}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 32}
       }
     },
     range: [0, 33],
@@ -8138,10 +8138,10 @@ test("\"use strict\"; (class A {constructor() { super() }})", {
             end: {line: 1, column: 50}
           }
         },
-        range: [14, 51],
+        range: [15, 50],
         loc: {
-          start: {line: 1, column: 14},
-          end: {line: 1, column: 51}
+          start: {line: 1, column: 15},
+          end: {line: 1, column: 50}
         }
       },
       range: [14, 51],
@@ -8482,10 +8482,10 @@ test("\"use strict\"; (class A { static constructor() { super() }})", {
             end: {line: 1, column: 58}
           }
         },
-        range: [14, 59],
+        range: [15, 58],
         loc: {
-          start: {line: 1, column: 14},
-          end: {line: 1, column: 59}
+          start: {line: 1, column: 15},
+          end: {line: 1, column: 58}
         }
       },
       range: [14, 59],
@@ -9437,10 +9437,10 @@ test("({[x]: 10})", {
           end: {line: 1, column: 9}
         }
       }],
-      range: [0, 11],
+      range: [1, 10],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 11}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 10}
       }
     },
     range: [0, 11],
@@ -9517,10 +9517,10 @@ test("({[\"x\" + \"y\"]: 10})", {
           end: {line: 1, column: 17}
         }
       }],
-      range: [0, 19],
+      range: [1, 18],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 19}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 18}
       }
     },
     range: [0, 19],
@@ -9590,10 +9590,10 @@ test("({[x]: function() {}})", {
           end: {line: 1, column: 20}
         }
       }],
-      range: [0, 22],
+      range: [1, 21],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 22}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 21}
       }
     },
     range: [0, 22],
@@ -9683,10 +9683,10 @@ test("({[x]: 10, y: 20})", {
           }
         }
       ],
-      range: [0, 18],
+      range: [1, 17],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 18}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 17}
       }
     },
     range: [0, 18],
@@ -9810,10 +9810,10 @@ test("({get [x]() {}, set [x](v) {}})", {
           }
         }
       ],
-      range: [0, 31],
+      range: [1, 30],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 31}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 30}
       }
     },
     range: [0, 31],
@@ -9883,10 +9883,10 @@ test("({[x]() {}})", {
           end: {line: 1, column: 10}
         }
       }],
-      range: [0, 12],
+      range: [1, 11],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 12}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 11}
       }
     },
     range: [0, 12],
@@ -10769,10 +10769,10 @@ test("({f: function({x} = {x: 10}) {}})", {
           end: {line: 1, column: 31}
         }
       }],
-      range: [0, 33],
+      range: [1, 32],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 33}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 32}
       }
     },
     range: [0, 33],
@@ -10917,10 +10917,10 @@ test("({f({x} = {x: 10}) {}})", {
           end: {line: 1, column: 21}
         }
       }],
-      range: [0, 23],
+      range: [1, 22],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 23}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 22}
       }
     },
     range: [0, 23],
@@ -11073,10 +11073,10 @@ test("(class {f({x} = {x: 10}) {}})", {
           end: {line: 1, column: 28}
         }
       },
-      range: [0, 29],
+      range: [1, 28],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 29}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 28}
       }
     },
     range: [0, 29],
@@ -11192,10 +11192,10 @@ test("(({x} = {x: 10}) => {})", {
       rest: null,
       generator: false,
       expression: false,
-      range: [0, 23],
+      range: [1, 22],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 23}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 22}
       }
     },
     range: [0, 23],
@@ -12267,10 +12267,10 @@ test("(function x([ a, b ]){})", {
       rest: null,
       generator: false,
       expression: false,
-      range: [0, 24],
+      range: [1, 23],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 24}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 23}
       }
     },
     range: [0, 24],
@@ -12388,10 +12388,10 @@ test("(function x({ a, b }){})", {
       rest: null,
       generator: false,
       expression: false,
-      range: [0, 24],
+      range: [1, 23],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 24}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 23}
       }
     },
     range: [0, 24],
@@ -12467,10 +12467,10 @@ test("(function x(...[ a, b ]){})", {
       },
       generator: false,
       expression: false,
-      range: [0, 27],
+      range: [1, 26],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 27}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 26}
       }
     },
     range: [0, 27],
@@ -12704,10 +12704,10 @@ test("(function x({ a: { w, x }, b: [y, z] }, ...[a, b, c]){})", {
       },
       generator: false,
       expression: false,
-      range: [0, 56],
+      range: [1, 55],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 56}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 55}
       }
     },
     range: [0, 56],
@@ -12804,10 +12804,10 @@ test("({ x([ a, b ]){} })", {
           end: {line: 1, column: 16}
         }
       }],
-      range: [0, 19],
+      range: [1, 18],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 19}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 18}
       }
     },
     range: [0, 19],
@@ -12904,10 +12904,10 @@ test("({ x(...[ a, b ]){} })", {
           end: {line: 1, column: 19}
         }
       }],
-      range: [0, 22],
+      range: [1, 21],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 22}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 21}
       }
     },
     range: [0, 22],
@@ -13162,10 +13162,10 @@ test("({ x({ a: { w, x }, b: [y, z] }, ...[a, b, c]){} })", {
           end: {line: 1, column: 48}
         }
       }],
-      range: [0, 51],
+      range: [1, 50],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 51}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 50}
       }
     },
     range: [0, 51],
@@ -15086,10 +15086,10 @@ test("(function () { yield* 10 })", {
       rest: null,
       generator: false,
       expression: false,
-      range: [0, 27],
+      range: [1, 26],
       loc: {
-        start: {line: 1, column: 0},
-        end: {line: 1, column: 27}
+        start: {line: 1, column: 1},
+        end: {line: 1, column: 26}
       }
     },
     range: [0, 27],
@@ -15388,4 +15388,4 @@ test('function normal(x, y = 10) {}', {
     },
     expression: false
   }]
-}, {ecmaVersion: 6});
\ No newline at end of file
+}, {ecmaVersion: 6});
diff --git a/test/tests.js b/test/tests.js
index c39aa3cde6..5a86572a93 100644
--- a/test/tests.js
+++ b/test/tests.js
@@ -2,9 +2,8 @@
 // (http://esprima.org/test/)
 
 if (typeof exports != "undefined") {
-  var test = require("./driver.js").test;
-  var testFail = require("./driver.js").testFail;
-  var testAssert = require("./driver.js").testAssert;
+  var driver = require("./driver.js");
+  var test = driver.test, testFail = driver.testFail, testAssert = driver.testAssert, misMatch = driver.misMatch;
   var acorn = require("..");
 }
 
@@ -177,11 +176,11 @@ test("(1 + 2 ) * 3", {
           loc: {
             start: {
               line: 1,
-              column: 0
+              column: 1
             },
             end: {
               line: 1,
-              column: 8
+              column: 6
             }
           }
         },
@@ -8202,11 +8201,11 @@ test("( new foo).bar()", {
             loc: {
               start: {
                 line: 1,
-                column: 0
+                column: 2
               },
               end: {
                 line: 1,
-                column: 10
+                column: 9
               }
             }
           },
@@ -8371,11 +8370,11 @@ test("(    foo  )()", {
           loc: {
             start: {
               line: 1,
-              column: 0
+              column: 5
             },
             end: {
               line: 1,
-              column: 11
+              column: 8
             }
           }
         },
@@ -17217,11 +17216,11 @@ test("if (morning) (function(){})", {
           loc: {
             start: {
               line: 1,
-              column: 13
+              column: 14
             },
             end: {
               line: 1,
-              column: 27
+              column: 26
             }
           }
         },
@@ -20508,11 +20507,11 @@ test("(function(){ return })", {
         loc: {
           start: {
             line: 1,
-            column: 0
+            column: 1
           },
           end: {
             line: 1,
-            column: 22
+            column: 21
           }
         }
       },
@@ -20581,11 +20580,11 @@ test("(function(){ return; })", {
         loc: {
           start: {
             line: 1,
-            column: 0
+            column: 1
           },
           end: {
             line: 1,
-            column: 23
+            column: 22
           }
         }
       },
@@ -20667,11 +20666,11 @@ test("(function(){ return x; })", {
         loc: {
           start: {
             line: 1,
-            column: 0
+            column: 1
           },
           end: {
             line: 1,
-            column: 25
+            column: 24
           }
         }
       },
@@ -20781,11 +20780,11 @@ test("(function(){ return x * y })", {
         loc: {
           start: {
             line: 1,
-            column: 0
+            column: 1
           },
           end: {
             line: 1,
-            column: 28
+            column: 27
           }
         }
       },
@@ -23194,11 +23193,11 @@ test("(function test(t, t) { })", {
         loc: {
           start: {
             line: 1,
-            column: 0
+            column: 1
           },
           end: {
             line: 1,
-            column: 25
+            column: 24
           }
         }
       },
@@ -24412,11 +24411,11 @@ test("(function(){})", {
         loc: {
           start: {
             line: 1,
-            column: 0
+            column: 1
           },
           end: {
             line: 1,
-            column: 14
+            column: 13
           }
         }
       },
@@ -25522,11 +25521,11 @@ test("(function(){ return\nx; })", {
         loc: {
           start: {
             line: 1,
-            column: 0
+            column: 1
           },
           end: {
             line: 2,
-            column: 5
+            column: 4
           }
         }
       },
@@ -25622,11 +25621,11 @@ test("(function(){ return // Comment\nx; })", {
         loc: {
           start: {
             line: 1,
-            column: 0
+            column: 1
           },
           end: {
             line: 2,
-            column: 5
+            column: 4
           }
         }
       },
@@ -25722,11 +25721,11 @@ test("(function(){ return/* Multiline\nComment */x; })", {
         loc: {
           start: {
             line: 1,
-            column: 0
+            column: 1
           },
           end: {
             line: 2,
-            column: 15
+            column: 14
           }
         }
       },
@@ -26026,8 +26025,6 @@ test("", {
 
 test("foo: if (true) break foo;", {
   type: "Program",
-  start: 0,
-  end: 25,
   loc: {
     start: {
       line: 1,
@@ -26041,8 +26038,6 @@ test("foo: if (true) break foo;", {
   body: [
     {
       type: "LabeledStatement",
-      start: 0,
-      end: 25,
       loc: {
         start: {
           line: 1,
@@ -26055,8 +26050,6 @@ test("foo: if (true) break foo;", {
       },
       body: {
         type: "IfStatement",
-        start: 5,
-        end: 25,
         loc: {
           start: {
             line: 1,
@@ -26069,8 +26062,6 @@ test("foo: if (true) break foo;", {
         },
         test: {
           type: "Literal",
-          start: 9,
-          end: 13,
           loc: {
             start: {
               line: 1,
@@ -26085,8 +26076,6 @@ test("foo: if (true) break foo;", {
         },
         consequent: {
           type: "BreakStatement",
-          start: 15,
-          end: 25,
           loc: {
             start: {
               line: 1,
@@ -26099,8 +26088,6 @@ test("foo: if (true) break foo;", {
           },
           label: {
             type: "Identifier",
-            start: 21,
-            end: 24,
             loc: {
               start: {
                 line: 1,
@@ -26118,8 +26105,6 @@ test("foo: if (true) break foo;", {
       },
       label: {
         type: "Identifier",
-        start: 0,
-        end: 3,
         loc: {
           start: {
             line: 1,
@@ -26138,8 +26123,6 @@ test("foo: if (true) break foo;", {
 
 test("(function () {\n 'use strict';\n '\0';\n}())", {
   type: "Program",
-  start: 0,
-  end: 40,
   loc: {
     start: {
       line: 1,
@@ -26153,8 +26136,6 @@ test("(function () {\n 'use strict';\n '\0';\n}())", {
   body: [
     {
       type: "ExpressionStatement",
-      start: 0,
-      end: 40,
       loc: {
         start: {
           line: 1,
@@ -26167,21 +26148,18 @@ test("(function () {\n 'use strict';\n '\0';\n}())", {
       },
       expression: {
         type: "CallExpression",
-        start: 0,
         loc: {
           start: {
             line: 1,
-            column: 0
+            column: 1
           },
           end: {
             line: 4,
-            column: 4
+            column: 3
           }
         },
         callee: {
           type: "FunctionExpression",
-          start: 1,
-          end: 37,
           loc: {
             start: {
               line: 1,
@@ -26196,8 +26174,6 @@ test("(function () {\n 'use strict';\n '\0';\n}())", {
           params: [],
           body: {
             type: "BlockStatement",
-            start: 13,
-            end: 37,
             loc: {
               start: {
                 line: 1,
@@ -26211,8 +26187,6 @@ test("(function () {\n 'use strict';\n '\0';\n}())", {
             body: [
               {
                 type: "ExpressionStatement",
-                start: 16,
-                end: 29,
                 loc: {
                   start: {
                     line: 2,
@@ -26225,8 +26199,6 @@ test("(function () {\n 'use strict';\n '\0';\n}())", {
                 },
                 expression: {
                   type: "Literal",
-                  start: 16,
-                  end: 28,
                   loc: {
                     start: {
                       line: 2,
@@ -26242,8 +26214,6 @@ test("(function () {\n 'use strict';\n '\0';\n}())", {
               },
               {
                 type: "ExpressionStatement",
-                start: 31,
-                end: 35,
                 loc: {
                   start: {
                     line: 3,
@@ -26256,8 +26226,6 @@ test("(function () {\n 'use strict';\n '\0';\n}())", {
                 },
                 expression: {
                   type: "Literal",
-                  start: 31,
-                  end: 34,
                   loc: {
                     start: {
                       line: 3,
@@ -26275,7 +26243,6 @@ test("(function () {\n 'use strict';\n '\0';\n}())", {
           }
         },
         arguments: [],
-        end: 40
       }
     }
   ]
@@ -26283,43 +26250,29 @@ test("(function () {\n 'use strict';\n '\0';\n}())", {
 
 test("123..toString(10)", {
   type: "Program",
-  start: 0,
-  end: 17,
   body: [
     {
       type: "ExpressionStatement",
-      start: 0,
-      end: 17,
       expression: {
         type: "CallExpression",
-        start: 0,
         callee: {
           type: "MemberExpression",
-          start: 0,
           object: {
             type: "Literal",
-            start: 0,
-            end: 4,
             value: 123
           },
           property: {
             type: "Identifier",
-            start: 5,
-            end: 13,
             name: "toString"
           },
           computed: false,
-          end: 13
         },
         arguments: [
           {
             type: "Literal",
-            start: 14,
-            end: 16,
             value: 10
           }
         ],
-        end: 17
       }
     }
   ]
@@ -26327,30 +26280,20 @@ test("123..toString(10)", {
 
 test("123.+2", {
   type: "Program",
-  start: 0,
-  end: 6,
   body: [
     {
       type: "ExpressionStatement",
-      start: 0,
-      end: 6,
       expression: {
         type: "BinaryExpression",
-        start: 0,
         left: {
           type: "Literal",
-          start: 0,
-          end: 4,
           value: 123
         },
         operator: "+",
         right: {
           type: "Literal",
-          start: 5,
-          end: 6,
           value: 2
         },
-        end: 6
       }
     }
   ]
@@ -26358,28 +26301,18 @@ test("123.+2", {
 
 test("a\u2028b", {
   type: "Program",
-  start: 0,
-  end: 3,
   body: [
     {
       type: "ExpressionStatement",
-      start: 0,
-      end: 1,
       expression: {
         type: "Identifier",
-        start: 0,
-        end: 1,
         name: "a"
       }
     },
     {
       type: "ExpressionStatement",
-      start: 2,
-      end: 3,
       expression: {
         type: "Identifier",
-        start: 2,
-        end: 3,
         name: "b"
       }
     }
@@ -26437,28 +26370,18 @@ test("foo: 10; foo: 20;", {
 
 test("if(1)/  foo/", {
   type: "Program",
-  start: 0,
-  end: 12,
   body: [
     {
       type: "IfStatement",
-      start: 0,
-      end: 12,
       test: {
         type: "Literal",
-        start: 3,
-        end: 4,
         value: 1,
         raw: "1"
       },
       consequent: {
         type: "ExpressionStatement",
-        start: 5,
-        end: 12,
         expression: {
           type: "Literal",
-          start: 5,
-          end: 12,
           raw: "/  foo/"
         }
       },
@@ -26475,8 +26398,6 @@ test("price_9̶9̶_89", {
       expression: {
         type: "Identifier",
         name: "price_9̶9̶_89",
-        start: 0,
-        end: 13
       }
     }
   ]
@@ -26486,8 +26407,6 @@ test("price_9̶9̶_89", {
 
 test("var a = 1;", {
   type: "Program",
-  start: 0,
-  end: 10,
   loc: {
     start: {
       line: 1,
@@ -26502,8 +26421,6 @@ test("var a = 1;", {
   body: [
     {
       type: "VariableDeclaration",
-      start: 0,
-      end: 10,
       loc: {
         start: {
           line: 1,
@@ -26518,8 +26435,6 @@ test("var a = 1;", {
       declarations: [
         {
           type: "VariableDeclarator",
-          start: 4,
-          end: 9,
           loc: {
             start: {
               line: 1,
@@ -26533,8 +26448,6 @@ test("var a = 1;", {
           },
           id: {
             type: "Identifier",
-            start: 4,
-            end: 5,
             loc: {
               start: {
                 line: 1,
@@ -26550,8 +26463,6 @@ test("var a = 1;", {
           },
           init: {
             type: "Literal",
-            start: 8,
-            end: 9,
             loc: {
               start: {
                 line: 1,
@@ -26624,28 +26535,18 @@ test("{}/=/", {
 
 test("foo