From 722bc65e7937ce6557fdc08c290d15736b75ebb3 Mon Sep 17 00:00:00 2001
From: Ingvar Stepanyan <me@rreverser.com>
Date: Tue, 10 Mar 2015 02:27:24 +0200
Subject: [PATCH 01/43] [estree] Align Import specifiers.

---
 acorn.js              | 21 +++++-------
 acorn_loose.js        | 52 ++++++++++++++++++++++-------
 test/tests-harmony.js | 78 +++++++++++++++++++++++++------------------
 3 files changed, 95 insertions(+), 56 deletions(-)

diff --git a/acorn.js b/acorn.js
index add13940b2..01d54b4870 100644
--- a/acorn.js
+++ b/acorn.js
@@ -2785,20 +2785,18 @@
     if (this.type === tt.name) {
       // import defaultObj, { x, y as z } from '...'
       var node = this.startNode();
-      node.id = this.parseIdent();
-      this.checkLVal(node.id, true);
-      node.name = null;
-      node['default'] = true;
-      nodes.push(this.finishNode(node, "ImportSpecifier"));
+      node.local = this.parseIdent();
+      this.checkLVal(node.local, true);
+      nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
       if (!this.eat(tt.comma)) return nodes;
     }
     if (this.type === tt.star) {
       var node = this.startNode();
       this.next();
       this.expectContextual("as");
-      node.name = this.parseIdent();
-      this.checkLVal(node.name, true);
-      nodes.push(this.finishNode(node, "ImportBatchSpecifier"));
+      node.local = this.parseIdent();
+      this.checkLVal(node.local, true);
+      nodes.push(this.finishNode(node, "ImportNamespaceSpecifier"));
       return nodes;
     }
     this.expect(tt.braceL);
@@ -2809,10 +2807,9 @@
       } else first = false;
 
       var node = this.startNode();
-      node.id = this.parseIdent(true);
-      node.name = this.eatContextual("as") ? this.parseIdent() : null;
-      this.checkLVal(node.name || node.id, true);
-      node['default'] = false;
+      node.imported = this.parseIdent(true);
+      node.local = this.eatContextual("as") ? this.parseIdent() : node.imported;
+      this.checkLVal(node.local, true);
       nodes.push(this.finishNode(node, "ImportSpecifier"));
     }
     return nodes;
diff --git a/acorn_loose.js b/acorn_loose.js
index 67236abbb7..6edf3b1f0c 100644
--- a/acorn_loose.js
+++ b/acorn_loose.js
@@ -1058,7 +1058,7 @@
       node.declaration = this.parseStatement();
     } else {
       node.declaration = null;
-      this.parseSpecifierList(node, "Export");
+      this.parseExportSpecifierList(node);
     }
     this.semicolon();
     return this.finishNode(node, "ExportDeclaration");
@@ -1074,28 +1074,56 @@
     } else {
       if (this.tok.type === tt.name && this.tok.value !== "from") {
         var elt = this.startNode();
-        elt.id = this.parseIdent();
-        elt.name = null;
-        elt['default'] = true;
-        this.finishNode(elt, "ImportSpecifier");
+        elt.local = this.parseIdent();
+        this.finishNode(elt, "ImportDefaultSpecifier");
         this.eat(tt.comma);
       }
-      this.parseSpecifierList(node, "Import");
-      var specs = node.specifiers;
-      for (var i = 0; i < specs.length; i++) specs[i]['default'] = false;
+      this.parseImportSpecifierList(node);
       if (elt) node.specifiers.unshift(elt);
     }
     this.semicolon();
     return this.finishNode(node, "ImportDeclaration");
   };
 
-  lp.parseSpecifierList = function(node, prefix) {
+  lp.parseImportSpecifierList = function(node) {
+    var elts = node.specifiers = [];
+    if (this.tok.type === tt.star) {
+      var elt = this.startNode();
+      this.next();
+      if (this.eatContextual("as")) elt.local = this.parseIdent();
+      elts.push(this.finishNode(elt, "ImportNamespaceSpecifier"));
+    } else {
+      var indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart;
+      this.pushCx();
+      this.eat(tt.braceL);
+      if (this.curLineStart > continuedLine) continuedLine = this.curLineStart;
+      while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
+        var elt = this.startNode();
+        if (this.eat(tt.star)) {
+          if (this.eatContextual("as")) elt.local = this.parseIdent();
+          this.finishNode(elt, "ImportNamespaceSpecifier");
+        } else {
+          if (this.isContextual("from")) break;
+          elt.imported = this.parseIdent();
+          elt.local = this.eatContextual("as") ? this.parseIdent() : elt.imported;
+          this.finishNode(elt, "ImportSpecifier");
+        }
+        elts.push(elt);
+        this.eat(tt.comma);
+      }
+      this.eat(tt.braceR);
+      this.popCx();
+    }
+    node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
+  };
+
+  lp.parseExportSpecifierList = function(node) {
     var elts = node.specifiers = [];
     if (this.tok.type === tt.star) {
       var elt = this.startNode();
       this.next();
       if (this.eatContextual("as")) elt.name = this.parseIdent();
-      elts.push(this.finishNode(elt, prefix + "BatchSpecifier"));
+      elts.push(this.finishNode(elt, "ExportBatchSpecifier"));
     } else {
       var indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart;
       this.pushCx();
@@ -1105,12 +1133,12 @@
         var elt = this.startNode();
         if (this.eat(tt.star)) {
           if (this.eatContextual("as")) elt.name = this.parseIdent();
-          this.finishNode(elt, prefix + "BatchSpecifier");
+          this.finishNode(elt, "ExportBatchSpecifier");
         } else {
           if (this.isContextual("from")) break;
           elt.id = this.parseIdent();
           elt.name = this.eatContextual("as") ? this.parseIdent() : null;
-          this.finishNode(elt, prefix + "Specifier");
+          this.finishNode(elt, "ExportSpecifier");
         }
         elts.push(elt);
         this.eat(tt.comma);
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index 8e3dd24c13..48a613207e 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -5253,8 +5253,8 @@ test("import $ from \"jquery\"", {
   body: [{
     type: "ImportDeclaration",
     specifiers: [{
-      type: "ImportSpecifier",
-      id: {
+      type: "ImportDefaultSpecifier",
+      local: {
         type: "Identifier",
         name: "$",
         loc: {
@@ -5262,7 +5262,6 @@ test("import $ from \"jquery\"", {
           end: {line: 1, column: 8}
         }
       },
-      name: null,
       loc: {
         start: {line: 1, column: 7},
         end: {line: 1, column: 8}
@@ -5299,7 +5298,15 @@ test("import { encrypt, decrypt } from \"crypto\"", {
     specifiers: [
       {
         type: "ImportSpecifier",
-        id: {
+        imported: {
+          type: "Identifier",
+          name: "encrypt",
+          loc: {
+            start: {line: 1, column: 9},
+            end: {line: 1, column: 16}
+          }
+        },
+        local: {
           type: "Identifier",
           name: "encrypt",
           loc: {
@@ -5307,7 +5314,6 @@ test("import { encrypt, decrypt } from \"crypto\"", {
             end: {line: 1, column: 16}
           }
         },
-        name: null,
         loc: {
           start: {line: 1, column: 9},
           end: {line: 1, column: 16}
@@ -5315,7 +5321,15 @@ test("import { encrypt, decrypt } from \"crypto\"", {
       },
       {
         type: "ImportSpecifier",
-        id: {
+        imported: {
+          type: "Identifier",
+          name: "decrypt",
+          loc: {
+            start: {line: 1, column: 18},
+            end: {line: 1, column: 25}
+          }
+        },
+        local: {
           type: "Identifier",
           name: "decrypt",
           loc: {
@@ -5323,7 +5337,6 @@ test("import { encrypt, decrypt } from \"crypto\"", {
             end: {line: 1, column: 25}
           }
         },
-        name: null,
         loc: {
           start: {line: 1, column: 18},
           end: {line: 1, column: 25}
@@ -5360,7 +5373,7 @@ test("import { encrypt as enc } from \"crypto\"", {
     type: "ImportDeclaration",
     specifiers: [{
       type: "ImportSpecifier",
-      id: {
+      imported: {
         type: "Identifier",
         name: "encrypt",
         loc: {
@@ -5368,7 +5381,7 @@ test("import { encrypt as enc } from \"crypto\"", {
           end: {line: 1, column: 16}
         }
       },
-      name: {
+      local: {
         type: "Identifier",
         name: "enc",
         loc: {
@@ -5419,21 +5432,19 @@ test("import crypto, { decrypt, encrypt as enc } from \"crypto\"", {
     },
     specifiers: [
       {
-        type: "ImportSpecifier",
+        type: "ImportDefaultSpecifier",
         loc: {
           start: {line: 1, column: 7},
           end: {line: 1, column: 13}
         },
-        id: {
+        local: {
           type: "Identifier",
           loc: {
             start: {line: 1, column: 7},
             end: {line: 1, column: 13}
           },
           name: "crypto"
-        },
-        name: null,
-        default: true
+        }
       },
       {
         type: "ImportSpecifier",
@@ -5441,7 +5452,7 @@ test("import crypto, { decrypt, encrypt as enc } from \"crypto\"", {
           start: {line: 1, column: 17},
           end: {line: 1, column: 24}
         },
-        id: {
+        imported: {
           type: "Identifier",
           loc: {
             start: {line: 1, column: 17},
@@ -5449,8 +5460,14 @@ test("import crypto, { decrypt, encrypt as enc } from \"crypto\"", {
           },
           name: "decrypt"
         },
-        name: null,
-        default: false
+        local: {
+          type: "Identifier",
+          loc: {
+            start: {line: 1, column: 17},
+            end: {line: 1, column: 24}
+          },
+          name: "decrypt"
+        }
       },
       {
         type: "ImportSpecifier",
@@ -5458,7 +5475,7 @@ test("import crypto, { decrypt, encrypt as enc } from \"crypto\"", {
           start: {line: 1, column: 26},
           end: {line: 1, column: 40}
         },
-        id: {
+        imported: {
           type: "Identifier",
           loc: {
             start: {line: 1, column: 26},
@@ -5466,15 +5483,14 @@ test("import crypto, { decrypt, encrypt as enc } from \"crypto\"", {
           },
           name: "encrypt"
         },
-        name: {
+        local: {
           type: "Identifier",
           loc: {
             start: {line: 1, column: 37},
             end: {line: 1, column: 40}
           },
           name: "enc"
-        },
-        default: false
+        }
       }
     ],
     source: {
@@ -5501,7 +5517,7 @@ test("import { null as nil } from \"bar\"", {
     type: "ImportDeclaration",
     specifiers: [{
       type: "ImportSpecifier",
-      id: {
+      imported: {
         type: "Identifier",
         name: "null",
         loc: {
@@ -5509,7 +5525,7 @@ test("import { null as nil } from \"bar\"", {
           end: {line: 1, column: 13}
         }
       },
-      name: {
+      local: {
         type: "Identifier",
         name: "nil",
         loc: {
@@ -5559,12 +5575,12 @@ test("import * as crypto from \"crypto\"", {
       end: {line: 1, column: 32}
     },
     specifiers: [{
-      type: "ImportBatchSpecifier",
+      type: "ImportNamespaceSpecifier",
       loc: {
         start: {line: 1, column: 7},
         end: {line: 1, column: 18}
       },
-      name: {
+      local: {
         type: "Identifier",
         loc: {
           start: {line: 1, column: 12},
@@ -14346,17 +14362,15 @@ test("import foo, * as bar from 'baz';", {
     type: "ImportDeclaration",
     specifiers: [
       {
-        type: "ImportSpecifier",
-        id: {
+        type: "ImportDefaultSpecifier",
+        local: {
           type: "Identifier",
           name: "foo"
-        },
-        name: null,
-        default: true
+        }
       },
       {
-        type: "ImportBatchSpecifier",
-        name: {
+        type: "ImportNamespaceSpecifier",
+        local: {
           type: "Identifier",
           name: "bar"
         }

From ff60ee4fdbe7d6cf1accdfba162adf3a5d43bcce Mon Sep 17 00:00:00 2001
From: Ingvar Stepanyan <me@rreverser.com>
Date: Tue, 10 Mar 2015 10:37:00 +0200
Subject: [PATCH 02/43] [estree] Align `export ...` representations.

---
 acorn.js              |  64 +++++++--------
 acorn_loose.js        |  74 +++++++++--------
 test/tests-harmony.js | 179 ++++++++++++++++++++++--------------------
 3 files changed, 154 insertions(+), 163 deletions(-)

diff --git a/acorn.js b/acorn.js
index 01d54b4870..d50d0cf428 100644
--- a/acorn.js
+++ b/acorn.js
@@ -2694,15 +2694,13 @@
 
   pp.parseExport = function(node) {
     this.next();
-    // export var|const|let|function|class ...;
-    if (this.type === tt._var || this.type === tt._const || this.type === tt._let || this.type === tt._function || this.type === tt._class) {
-      node.declaration = this.parseStatement(true);
-      node['default'] = false;
-      node.specifiers = null;
-      node.source = null;
-    } else
-    // export default ...;
-    if (this.eat(tt._default)) {
+    // export * from '...';
+    if (this.eat(tt.star)) {
+      this.expectContextual("from");
+      node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
+      return this.finishNode(node, "ExportAllDeclaration");
+    }
+    if (this.eat(tt._default)) { // export default ...;
       var expr = this.parseMaybeAssign();
       if (expr.id) {
         switch (expr.type) {
@@ -2711,51 +2709,43 @@
         }
       }
       node.declaration = expr;
-      node['default'] = true;
-      node.specifiers = null;
-      node.source = null;
       this.semicolon();
-    } else {
-      // export * from '...';
-      // export { x, y as z } [from '...'];
-      var isBatch = this.type === tt.star;
+      return this.finishNode(node, "ExportDefaultDeclaration");
+    }
+    // export var|const|let|function|class ...;
+    if (this.type.keyword) {
+      node.declaration = this.parseStatement(true);
+      node.specifiers = [];
+      node.source = null;
+    } else { // export { x, y as z } [from '...'];
       node.declaration = null;
-      node['default'] = false;
       node.specifiers = this.parseExportSpecifiers();
       if (this.eatContextual("from")) {
         node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
       } else {
-        if (isBatch) this.unexpected();
         node.source = null;
       }
       this.semicolon();
     }
-    return this.finishNode(node, "ExportDeclaration");
+    return this.finishNode(node, "ExportNamedDeclaration");
   };
 
   // Parses a comma-separated list of module exports.
 
   pp.parseExportSpecifiers = function() {
     var nodes = [], first = true;
-    if (this.type === tt.star) {
-      // export * from '...'
-      var node = this.startNode();
-      this.next();
-      nodes.push(this.finishNode(node, "ExportBatchSpecifier"));
-    } else {
-      // export { x, y as z } [from '...']
-      this.expect(tt.braceL);
-      while (!this.eat(tt.braceR)) {
-        if (!first) {
-          this.expect(tt.comma);
-          if (this.options.allowTrailingCommas && this.eat(tt.braceR)) break;
-        } else first = false;
+    // export { x, y as z } [from '...']
+    this.expect(tt.braceL);
+    while (!this.eat(tt.braceR)) {
+      if (!first) {
+        this.expect(tt.comma);
+        if (this.options.allowTrailingCommas && this.eat(tt.braceR)) break;
+      } else first = false;
 
-        var node = this.startNode();
-        node.id = this.parseIdent(this.type === tt._default);
-        node.name = this.eatContextual("as") ? this.parseIdent(true) : null;
-        nodes.push(this.finishNode(node, "ExportSpecifier"));
-      }
+      var node = this.startNode();
+      node.local = this.parseIdent(this.type === tt._default);
+      node.exported = this.eatContextual("as") ? this.parseIdent(true) : node.local;
+      nodes.push(this.finishNode(node, "ExportSpecifier"));
     }
     return nodes;
   };
diff --git a/acorn_loose.js b/acorn_loose.js
index 6edf3b1f0c..7d6cd8be84 100644
--- a/acorn_loose.js
+++ b/acorn_loose.js
@@ -1042,9 +1042,11 @@
   lp.parseExport = function() {
     var node = this.startNode();
     this.next();
-    node['default'] = this.eat(tt._default);
-    node.specifiers = node.source = null;
-    if (node['default']) {
+    if (this.eat(tt.star)) {
+      node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
+      return this.finishNode(node, "ExportAllDeclaration");
+    }
+    if (this.eat(tt._default)) {
       var expr = this.parseMaybeAssign();
       if (expr.id) {
         switch (expr.type) {
@@ -1054,14 +1056,19 @@
       }
       node.declaration = expr;
       this.semicolon();
-    } else if (this.tok.type.keyword) {
+      return this.finishNode(node, "ExportDefaultDeclaration");
+    }
+    if (this.tok.type.keyword) {
       node.declaration = this.parseStatement();
+      node.specifiers = [];
+      node.source = null;
     } else {
       node.declaration = null;
-      this.parseExportSpecifierList(node);
+      node.specifiers = this.parseExportSpecifierList();
+      node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
+      this.semicolon();
     }
-    this.semicolon();
-    return this.finishNode(node, "ExportDeclaration");
+    return this.finishNode(node, "ExportNamedDeclaration");
   };
 
   lp.parseImport = function() {
@@ -1078,15 +1085,16 @@
         this.finishNode(elt, "ImportDefaultSpecifier");
         this.eat(tt.comma);
       }
-      this.parseImportSpecifierList(node);
+      node.specifiers = this.parseImportSpecifierList();
+      node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
       if (elt) node.specifiers.unshift(elt);
     }
     this.semicolon();
     return this.finishNode(node, "ImportDeclaration");
   };
 
-  lp.parseImportSpecifierList = function(node) {
-    var elts = node.specifiers = [];
+  lp.parseImportSpecifierList = function() {
+    var elts = [];
     if (this.tok.type === tt.star) {
       var elt = this.startNode();
       this.next();
@@ -1114,39 +1122,27 @@
       this.eat(tt.braceR);
       this.popCx();
     }
-    node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
+    return elts;
   };
 
-  lp.parseExportSpecifierList = function(node) {
-    var elts = node.specifiers = [];
-    if (this.tok.type === tt.star) {
+  lp.parseExportSpecifierList = function() {
+    var elts = [];
+    var indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart;
+    this.pushCx();
+    this.eat(tt.braceL);
+    if (this.curLineStart > continuedLine) continuedLine = this.curLineStart;
+    while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
+      if (this.isContextual("from")) break;
       var elt = this.startNode();
-      this.next();
-      if (this.eatContextual("as")) elt.name = this.parseIdent();
-      elts.push(this.finishNode(elt, "ExportBatchSpecifier"));
-    } else {
-      var indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart;
-      this.pushCx();
-      this.eat(tt.braceL);
-      if (this.curLineStart > continuedLine) continuedLine = this.curLineStart;
-      while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
-        var elt = this.startNode();
-        if (this.eat(tt.star)) {
-          if (this.eatContextual("as")) elt.name = this.parseIdent();
-          this.finishNode(elt, "ExportBatchSpecifier");
-        } else {
-          if (this.isContextual("from")) break;
-          elt.id = this.parseIdent();
-          elt.name = this.eatContextual("as") ? this.parseIdent() : null;
-          this.finishNode(elt, "ExportSpecifier");
-        }
-        elts.push(elt);
-        this.eat(tt.comma);
-      }
-      this.eat(tt.braceR);
-      this.popCx();
+      elt.local = this.parseIdent();
+      elt.exported = this.eatContextual("as") ? this.parseIdent() : elt.local;
+      this.finishNode(elt, "ExportSpecifier");
+      elts.push(elt);
+      this.eat(tt.comma);
     }
-    node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
+    this.eat(tt.braceR);
+    this.popCx();
+    return elts;
   };
 
   lp.parseExprList = function(close, allowEmpty) {
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index 48a613207e..c155978041 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -4453,7 +4453,7 @@ test("var {a:b} = {}", {
 test("export var document", {
   type: "Program",
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportNamedDeclaration",
     declaration: {
       type: "VariableDeclaration",
       declarations: [{
@@ -4478,8 +4478,7 @@ test("export var document", {
         end: {line: 1, column: 19}
       }
     },
-    default: false,
-    specifiers: null,
+    specifiers: [],
     source: null,
     loc: {
       start: {line: 1, column: 0},
@@ -4499,7 +4498,7 @@ test("export var document", {
 test("export var document = { }", {
   type: "Program",
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportNamedDeclaration",
     declaration: {
       type: "VariableDeclaration",
       declarations: [{
@@ -4531,8 +4530,7 @@ test("export var document = { }", {
         end: {line: 1, column: 25}
       }
     },
-    default: false,
-    specifiers: null,
+    specifiers: [],
     source: null,
     loc: {
       start: {line: 1, column: 0},
@@ -4552,7 +4550,7 @@ test("export var document = { }", {
 test("export let document", {
   type: "Program",
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportNamedDeclaration",
     declaration: {
       type: "VariableDeclaration",
       declarations: [{
@@ -4577,8 +4575,7 @@ test("export let document", {
         end: {line: 1, column: 19}
       }
     },
-    default: false,
-    specifiers: null,
+    specifiers: [],
     source: null,
     loc: {
       start: {line: 1, column: 0},
@@ -4598,7 +4595,7 @@ test("export let document", {
 test("export let document = { }", {
   type: "Program",
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportNamedDeclaration",
     declaration: {
       type: "VariableDeclaration",
       declarations: [{
@@ -4630,8 +4627,7 @@ test("export let document = { }", {
         end: {line: 1, column: 25}
       }
     },
-    default: false,
-    specifiers: null,
+    specifiers: [],
     source: null,
     loc: {
       start: {line: 1, column: 0},
@@ -4651,7 +4647,7 @@ test("export let document = { }", {
 test("export const document = { }", {
   type: "Program",
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportNamedDeclaration",
     declaration: {
       type: "VariableDeclaration",
       declarations: [{
@@ -4683,8 +4679,7 @@ test("export const document = { }", {
         end: {line: 1, column: 27}
       }
     },
-    default: false,
-    specifiers: null,
+    specifiers: [],
     source: null,
     loc: {
       start: {line: 1, column: 0},
@@ -4704,7 +4699,7 @@ test("export const document = { }", {
 test("export function parse() { }", {
   type: "Program",
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportNamedDeclaration",
     declaration: {
       type: "FunctionDeclaration",
       id: {
@@ -4731,8 +4726,7 @@ test("export function parse() { }", {
         end: {line: 1, column: 27}
       }
     },
-    default: false,
-    specifiers: null,
+    specifiers: [],
     source: null,
     loc: {
       start: {line: 1, column: 0},
@@ -4752,7 +4746,7 @@ test("export function parse() { }", {
 test("export class Class {}", {
   type: "Program",
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportNamedDeclaration",
     declaration: {
       type: "ClassDeclaration",
       id: {
@@ -4777,8 +4771,7 @@ test("export class Class {}", {
         end: {line: 1, column: 21}
       }
     },
-    default: false,
-    specifiers: null,
+    specifiers: [],
     source: null,
     loc: {
       start: {line: 1, column: 0},
@@ -4798,7 +4791,7 @@ test("export class Class {}", {
 test("export default 42", {
   type: "Program",
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportDefaultDeclaration",
     declaration: {
       type: "Literal",
       value: 42,
@@ -4808,9 +4801,6 @@ test("export default 42", {
         end: {line: 1, column: 17}
       }
     },
-    default: true,
-    specifiers: null,
-    source: null,
     loc: {
       start: {line: 1, column: 0},
       end: {line: 1, column: 17}
@@ -4830,7 +4820,7 @@ test("export default function () {}", {
   type: "Program",
   range: [0, 29],
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportDefaultDeclaration",
     range: [0, 29],
     declaration: {
       type: "FunctionExpression",
@@ -4844,10 +4834,7 @@ test("export default function () {}", {
         range: [27, 29],
         body: []
       }
-    },
-    default: true,
-    specifiers: null,
-    source: null
+    }
   }]
 }, {ecmaVersion: 6, ranges: true});
 
@@ -4855,7 +4842,7 @@ test("export default function f() {}", {
   type: "Program",
   range: [0, 30],
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportDefaultDeclaration",
     range: [0, 30],
     declaration: {
       type: "FunctionDeclaration",
@@ -4873,10 +4860,7 @@ test("export default function f() {}", {
         range: [28, 30],
         body: []
       }
-    },
-    default: true,
-    specifiers: null,
-    source: null
+    }
   }]
 }, {ecmaVersion: 6, ranges: true});
 
@@ -4884,7 +4868,7 @@ test("export default class {}", {
   type: "Program",
   range: [0, 23],
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportDefaultDeclaration",
     range: [0, 23],
     declaration: {
       type: "ClassExpression",
@@ -4896,10 +4880,7 @@ test("export default class {}", {
         range: [21, 23],
         body: []
       }
-    },
-    default: true,
-    specifiers: null,
-    source: null
+    }
   }]
 }, {ecmaVersion: 6, ranges: true});
 
@@ -4907,7 +4888,7 @@ test("export default class A {}", {
   type: "Program",
   range: [0, 25],
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportDefaultDeclaration",
     range: [0, 25],
     declaration: {
       type: "ClassDeclaration",
@@ -4923,10 +4904,7 @@ test("export default class A {}", {
         range: [23, 25],
         body: []
       }
-    },
-    default: true,
-    specifiers: null,
-    source: null
+    }
   }]
 }, {ecmaVersion: 6, ranges: true});
 
@@ -4935,15 +4913,7 @@ testFail("export *", "Unexpected token (1:8)", {ecmaVersion: 6});
 test("export * from \"crypto\"", {
   type: "Program",
   body: [{
-    type: "ExportDeclaration",
-    declaration: null,
-    specifiers: [{
-      type: "ExportBatchSpecifier",
-      loc: {
-        start: {line: 1, column: 7},
-        end: {line: 1, column: 8}
-      }
-    }],
+    type: "ExportAllDeclaration",
     source: {
       type: "Literal",
       value: "crypto",
@@ -4971,11 +4941,19 @@ test("export * from \"crypto\"", {
 test("export { encrypt }", {
   type: "Program",
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportNamedDeclaration",
     declaration: null,
     specifiers: [{
       type: "ExportSpecifier",
-      id: {
+      exported: {
+        type: "Identifier",
+        name: "encrypt",
+        loc: {
+          start: {line: 1, column: 9},
+          end: {line: 1, column: 16}
+        }
+      },
+      local: {
         type: "Identifier",
         name: "encrypt",
         loc: {
@@ -4983,7 +4961,6 @@ test("export { encrypt }", {
           end: {line: 1, column: 16}
         }
       },
-      name: null,
       loc: {
         start: {line: 1, column: 9},
         end: {line: 1, column: 16}
@@ -5008,12 +4985,20 @@ test("export { encrypt }", {
 test("export { encrypt, decrypt }", {
   type: "Program",
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportNamedDeclaration",
     declaration: null,
     specifiers: [
       {
         type: "ExportSpecifier",
-        id: {
+        exported: {
+          type: "Identifier",
+          name: "encrypt",
+          loc: {
+            start: {line: 1, column: 9},
+            end: {line: 1, column: 16}
+          }
+        },
+        local: {
           type: "Identifier",
           name: "encrypt",
           loc: {
@@ -5021,7 +5006,6 @@ test("export { encrypt, decrypt }", {
             end: {line: 1, column: 16}
           }
         },
-        name: null,
         loc: {
           start: {line: 1, column: 9},
           end: {line: 1, column: 16}
@@ -5029,7 +5013,15 @@ test("export { encrypt, decrypt }", {
       },
       {
         type: "ExportSpecifier",
-        id: {
+        exported: {
+          type: "Identifier",
+          name: "decrypt",
+          loc: {
+            start: {line: 1, column: 18},
+            end: {line: 1, column: 25}
+          }
+        },
+        local: {
           type: "Identifier",
           name: "decrypt",
           loc: {
@@ -5037,7 +5029,6 @@ test("export { encrypt, decrypt }", {
             end: {line: 1, column: 25}
           }
         },
-        name: null,
         loc: {
           start: {line: 1, column: 18},
           end: {line: 1, column: 25}
@@ -5063,19 +5054,11 @@ test("export { encrypt, decrypt }", {
 test("export { encrypt as default }", {
   type: "Program",
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportNamedDeclaration",
     declaration: null,
     specifiers: [{
       type: "ExportSpecifier",
-      id: {
-        type: "Identifier",
-        name: "encrypt",
-        loc: {
-          start: {line: 1, column: 9},
-          end: {line: 1, column: 16}
-        }
-      },
-      name: {
+      exported: {
         type: "Identifier",
         name: "default",
         loc: {
@@ -5083,6 +5066,14 @@ test("export { encrypt as default }", {
           end: {line: 1, column: 27}
         }
       },
+      local: {
+        type: "Identifier",
+        name: "encrypt",
+        loc: {
+          start: {line: 1, column: 9},
+          end: {line: 1, column: 16}
+        }
+      },
       loc: {
         start: {line: 1, column: 9},
         end: {line: 1, column: 27}
@@ -5107,12 +5098,20 @@ test("export { encrypt as default }", {
 test("export { encrypt, decrypt as dec }", {
   type: "Program",
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportNamedDeclaration",
     declaration: null,
     specifiers: [
       {
         type: "ExportSpecifier",
-        id: {
+        exported: {
+          type: "Identifier",
+          name: "encrypt",
+          loc: {
+            start: {line: 1, column: 9},
+            end: {line: 1, column: 16}
+          }
+        },
+        local: {
           type: "Identifier",
           name: "encrypt",
           loc: {
@@ -5120,7 +5119,6 @@ test("export { encrypt, decrypt as dec }", {
             end: {line: 1, column: 16}
           }
         },
-        name: null,
         loc: {
           start: {line: 1, column: 9},
           end: {line: 1, column: 16}
@@ -5128,15 +5126,7 @@ test("export { encrypt, decrypt as dec }", {
       },
       {
         type: "ExportSpecifier",
-        id: {
-          type: "Identifier",
-          name: "decrypt",
-          loc: {
-            start: {line: 1, column: 18},
-            end: {line: 1, column: 25}
-          }
-        },
-        name: {
+        exported: {
           type: "Identifier",
           name: "dec",
           loc: {
@@ -5144,6 +5134,14 @@ test("export { encrypt, decrypt as dec }", {
             end: {line: 1, column: 32}
           }
         },
+        local: {
+          type: "Identifier",
+          name: "decrypt",
+          loc: {
+            start: {line: 1, column: 18},
+            end: {line: 1, column: 25}
+          }
+        },
         loc: {
           start: {line: 1, column: 18},
           end: {line: 1, column: 32}
@@ -5169,12 +5167,20 @@ test("export { encrypt, decrypt as dec }", {
 test("export { default } from \"other\"", {
   type: "Program",
   body: [{
-    type: "ExportDeclaration",
+    type: "ExportNamedDeclaration",
     declaration: null,
     specifiers: [
       {
         type: "ExportSpecifier",
-        id: {
+        exported: {
+          type: "Identifier",
+          name: "default",
+          loc: {
+            start: {line: 1, column: 9},
+            end: {line: 1, column: 16}
+          }
+        },
+        local: {
           type: "Identifier",
           name: "default",
           loc: {
@@ -5182,7 +5188,6 @@ test("export { default } from \"other\"", {
             end: {line: 1, column: 16}
           }
         },
-        name: null,
         loc: {
           start: {line: 1, column: 9},
           end: {line: 1, column: 16}

From 34050d3917aa8f1bd2e430015d692e2e60e338bd Mon Sep 17 00:00:00 2001
From: Ingvar Stepanyan <me@rreverser.com>
Date: Tue, 10 Mar 2015 11:36:15 +0200
Subject: [PATCH 03/43] Support for `for (const ...)`.

Fixes #213.

Also changes API to pass token type to `parseVar` to reduce string comparison ops.
---
 acorn.js              | 18 ++++++++++------
 acorn_loose.js        |  2 +-
 test/tests-harmony.js | 49 +++++++++++++++++++++++++++++++++++++++++++
 test/tests.js         | 34 +++++++++++++++++++++++++++++-
 4 files changed, 95 insertions(+), 8 deletions(-)

diff --git a/acorn.js b/acorn.js
index d50d0cf428..570813e3f1 100644
--- a/acorn.js
+++ b/acorn.js
@@ -1773,7 +1773,7 @@
     case tt._throw: return this.parseThrowStatement(node);
     case tt._try: return this.parseTryStatement(node);
     case tt._let: case tt._const: if (!declaration) this.unexpected(); // NOTE: falls through to _var
-    case tt._var: return this.parseVarStatement(node, starttype.keyword);
+    case tt._var: return this.parseVarStatement(node, starttype);
     case tt._while: return this.parseWhileStatement(node);
     case tt._with: return this.parseWithStatement(node);
     case tt.braceL: return this.parseBlock(); // no point creating a function for this
@@ -1853,13 +1853,13 @@
     this.labels.push(loopLabel);
     this.expect(tt.parenL);
     if (this.type === tt.semi) return this.parseFor(node, null);
-    if (this.type === tt._var || this.type === tt._let) {
-      var init = this.startNode(), varKind = this.type.keyword, isLet = this.type === tt._let;
+    if (this.type === tt._var || this.type === tt._let || this.type === tt._const) {
+      var init = this.startNode(), varKind = this.type;
       this.next();
       this.parseVar(init, true, varKind);
       this.finishNode(init, "VariableDeclaration");
       if ((this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init.declarations.length === 1 &&
-          !(isLet && init.declarations[0].init))
+          !(varKind !== tt._var && init.declarations[0].init))
         return this.parseForIn(node, init);
       return this.parseFor(node, init);
     }
@@ -2079,12 +2079,18 @@
 
   pp.parseVar = function(node, noIn, kind) {
     node.declarations = [];
-    node.kind = kind;
+    node.kind = kind.keyword;
     for (;;) {
       var decl = this.startNode();
       decl.id = this.parseBindingAtom();
       this.checkLVal(decl.id, true);
-      decl.init = this.eat(tt.eq) ? this.parseMaybeAssign(noIn) : (kind === tt._const.keyword ? this.unexpected() : null);
+      if (this.eat(tt.eq)) {
+        decl.init = this.parseMaybeAssign(noIn);
+      } else if (kind === tt._const && !(this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
+        this.unexpected();
+      } else {
+        decl.init = null;
+      }
       node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
       if (!this.eat(tt.comma)) break;
     }
diff --git a/acorn_loose.js b/acorn_loose.js
index 7d6cd8be84..c936b4f0e9 100644
--- a/acorn_loose.js
+++ b/acorn_loose.js
@@ -346,7 +346,7 @@
       this.pushCx();
       this.expect(tt.parenL);
       if (this.tok.type === tt.semi) return this.parseFor(node, null);
-      if (this.tok.type === tt._var || this.tok.type === tt._let) {
+      if (this.tok.type === tt._var || this.tok.type === tt._let || this.tok.type === tt._const) {
         var init = this.parseVar(true);
         if (init.declarations.length === 1 && (this.tok.type === tt._in || this.isContextual("of"))) {
           return this.parseForIn(node, init);
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index c155978041..552b98dc3c 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -14970,6 +14970,55 @@ test("class A { static() {} }", {
   locations: true
 });
 
+// https://github.com/marijnh/acorn/issues/213
+
+test("for (const x of list) process(x);", {
+  type: "Program",
+  body: [{
+    type: "ForOfStatement",
+    left: {
+      type: "VariableDeclaration",
+      declarations: [{
+        type: "VariableDeclarator",
+        id: {
+          type: "Identifier",
+          name: "x",
+          range: [11, 12]
+        },
+        init: null,
+        range: [11, 12]
+      }],
+      kind: "const",
+      range: [5, 12]
+    },
+    right: {
+      type: "Identifier",
+      name: "list",
+      range: [16, 20]
+    },
+    body: {
+      type: "ExpressionStatement",
+      expression: {
+        type: "CallExpression",
+        callee: {
+          type: "Identifier",
+          name: "process",
+          range: [22, 29]
+        },
+        arguments: [{
+          type: "Identifier",
+          name: "x",
+          range: [30, 31]
+        }],
+        range: [22, 32]
+      },
+      range: [22, 33]
+    },
+    range: [0, 33]
+  }],
+  range: [0, 33]
+}, {ecmaVersion: 6, ranges: true});
+
 test("class A { *static() {} }", {
   type: "Program",
   range: [0, 24],
diff --git a/test/tests.js b/test/tests.js
index 92f23f2ac4..c54e04ad47 100644
--- a/test/tests.js
+++ b/test/tests.js
@@ -28682,7 +28682,39 @@ test("const x = 14, y = 3, z = 1977", {
 
 testFail("const a;", "Unexpected token (1:7)", {ecmaVersion: 6});
 
-testFail("for(const x = 0;;);", "Unexpected token (1:4)", {ecmaVersion: 6});
+test("for(const x = 0;;);", {
+  type: "Program",
+  body: [{
+    type: "ForStatement",
+    init: {
+      type: "VariableDeclaration",
+      declarations: [{
+        type: "VariableDeclarator",
+        id: {
+          type: "Identifier",
+          name: "x",
+          range: [10, 11]
+        },
+        init: {
+          type: "Literal",
+          value: 0,
+          range: [14, 15]
+        },
+        range: [10, 15]
+      }],
+      kind: "const",
+      range: [4, 15]
+    },
+    test: null,
+    update: null,
+    body: {
+      type: "EmptyStatement",
+      range: [18, 19]
+    },
+    range: [0, 19]
+  }],
+  range: [0, 19]
+}, {ecmaVersion: 6, ranges: true});
 
 testFail("for(x of a);", "Unexpected token (1:6)");
 

From 9fb3a4f5ceae395e03a279f4673c8587f222f7a4 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 12 Mar 2015 21:40:12 +0100
Subject: [PATCH 04/43] Move as much as possible code in test driver out of try
 block

---
 test/driver.js | 63 +++++++++++++++++++++++---------------------------
 1 file changed, 29 insertions(+), 34 deletions(-)

diff --git a/test/driver.js b/test/driver.js
index 6de53dc9e3..d8998b930b 100644
--- a/test/driver.js
+++ b/test/driver.js
@@ -17,43 +17,17 @@
     for (var i = 0; i < tests.length; ++i) {
       var test = tests[i];
       if (config.filter && !config.filter(test)) continue;
+      var testOpts = test.options || {locations: true};
+      var expected = {};
+      if (expected.onComment = testOpts.onComment)
+        testOpts.onComment = []
+      if (expected.onToken = testOpts.onToken)
+        testOpts.onToken = [];
+
       try {
-        var testOpts = test.options || {locations: true};
-        var expected = {};
-        if (expected.onComment = testOpts.onComment) {
-          testOpts.onComment = []
-        }
-        if (expected.onToken = testOpts.onToken) {
-          testOpts.onToken = [];
-        }
         var ast = parse(test.code, testOpts);
-        if (test.error) {
-          if (config.loose) {
-            callback("ok", test.code);
-          } else {
-            callback("fail", test.code, "Expected error message: " + test.error + "\nBut parsing succeeded.");
-          }
-        } else if (test.assert) {
-          var error = test.assert(ast);
-          if (error) callback("fail", test.code,
-                                 "\n  Assertion failed:\n " + error);
-          else callback("ok", test.code);
-        } else {
-          var mis = misMatch(test.ast, ast);
-          for (var name in expected) {
-            if (mis) break;
-            if (expected[name]) {
-              mis = misMatch(expected[name], testOpts[name]);
-              testOpts[name] = expected[name];
-            }
-          }
-          if (mis) callback("fail", test.code, mis);
-          else callback("ok", test.code);
-        }
       } catch(e) {
-        if (!(e instanceof SyntaxError)) {
-          throw e;
-        }
+        if (!(e instanceof SyntaxError)) throw e;
         if (test.error) {
           if (e.message == test.error) callback("ok", test.code);
           else callback("fail", test.code,
@@ -61,6 +35,27 @@
         } else {
           callback("error", test.code, e.message || e.toString());
         }
+        continue
+      }
+
+      if (test.error) {
+        if (config.loose) callback("ok", test.code);
+        else callback("fail", test.code, "Expected error message: " + test.error + "\nBut parsing succeeded.");
+      } else if (test.assert) {
+        var error = test.assert(ast);
+        if (error) callback("fail", test.code, "\n  Assertion failed:\n " + error);
+        else callback("ok", test.code);
+      } else {
+        var mis = misMatch(test.ast, ast);
+        for (var name in expected) {
+          if (mis) break;
+          if (expected[name]) {
+            mis = misMatch(expected[name], testOpts[name]);
+            testOpts[name] = expected[name];
+          }
+        }
+        if (mis) callback("fail", test.code, mis);
+        else callback("ok", test.code);
       }
     }
   };

From ba750b253b26662b69b2aa932b116ffc56b92ee6 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 12 Mar 2015 21:57:40 +0100
Subject: [PATCH 05/43] Replace strictSemicolons and allowTrailingCommas with
 onInsertedSemicolon and onTrailingComma

---
 README.md     | 12 ++++++-----
 acorn.js      | 56 +++++++++++++++++++++++++++++++++++----------------
 test/tests.js | 19 +++++++++++++++++
 3 files changed, 65 insertions(+), 22 deletions(-)

diff --git a/README.md b/README.md
index 0b0d841c34..1a8afd8e86 100644
--- a/README.md
+++ b/README.md
@@ -54,12 +54,14 @@ object referring to that same position.
   either 3, 5, or 6. This influences support for strict mode, the set
   of reserved words, and support for new syntax features. Default is 5.
 
-- **strictSemicolons**: If `true`, prevents the parser from doing
-  automatic semicolon insertion, and statements that do not end with
-  a semicolon will generate an error. Defaults to `false`.
+- **onInsertedSemicolon**: If given a callback, that callback will be
+  called whenever a missing semicolon is inserted by the parser. The
+  callback will be given the character offset of the point where the
+  semicolon is inserted as argument, and if `locations` is on, also a
+  `{line, column}` object representing this position.
 
-- **allowTrailingCommas**: If `false`, the parser will not allow
-  trailing commas in array and object literals. Default is `true`.
+- **onTrailingComma**: Like `onInsertedSemicolon`, but for trailing
+  commas.
 
 - **forbidReserved**: If `true`, using a reserved word will generate
   an error. Defaults to `false`. When given the value `"everywhere"`,
diff --git a/acorn.js b/acorn.js
index 570813e3f1..8eb6feb988 100644
--- a/acorn.js
+++ b/acorn.js
@@ -51,12 +51,15 @@
     // 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,
+    // `onInsertedSemicolon` can be a callback that will be called
+    // when a semicolon is automatically inserted. It will be passed
+    // th position of the comma as an offset, and if `locations` is
+    // enabled, it is given the location as a `{line, column}` object
+    // as second argument.
+    onInsertedSemicolon: null,
+    // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
+    // trailing commas.
+    onTrailingComma: null,
     // 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
@@ -566,7 +569,7 @@
     this.startLoc = this.endLoc = null;
 
     // Position information for the previous token
-    this.lastTokEndLoc = null;
+    this.lastTokEndLoc = this.lastTokStartLoc = null;
     this.lastTokStart = this.lastTokEnd = this.pos;
 
     // The context stack is used to superficially track syntactic
@@ -611,6 +614,7 @@
     this.lastTokEnd = this.end;
     this.lastTokStart = this.start;
     this.lastTokEndLoc = this.endLoc;
+    this.lastTokStartLoc = this.startLoc;
     this.nextToken();
   };
 
@@ -1453,15 +1457,33 @@
   // Test whether a semicolon can be inserted at the current position.
 
   pp.canInsertSemicolon = function() {
-    return !this.options.strictSemicolons &&
-      (this.type === tt.eof || this.type === tt.braceR || newline.test(this.input.slice(this.lastTokEnd, this.start)));
+    return this.type === tt.eof ||
+      this.type === tt.braceR ||
+      newline.test(this.input.slice(this.lastTokEnd, this.start));
+  };
+
+  pp.insertSemicolon = function() {
+    if (this.canInsertSemicolon()) {
+      if (this.options.onInsertedSemicolon)
+        this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc)
+      return true;
+    }
   };
 
   // Consume a semicolon, or, failing that, see if we are allowed to
   // pretend that there is a semicolon at this position.
 
   pp.semicolon = function() {
-    if (!this.eat(tt.semi) && !this.canInsertSemicolon()) this.unexpected();
+    if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected();
+  };
+
+  pp.afterTrailingComma = function(tokType) {
+    if (this.type == tokType) {
+      if (this.options.onTrailingComma)
+        this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc);
+      this.next();
+      return true;
+    }
   };
 
   // Expect a token of a given type. If found, consume it, otherwise,
@@ -1800,7 +1822,7 @@
   pp.parseBreakContinueStatement = function(node, keyword) {
     var isBreak = keyword == "break";
     this.next();
-    if (this.eat(tt.semi) || this.canInsertSemicolon()) node.label = null;
+    if (this.eat(tt.semi) || this.insertSemicolon()) node.label = null;
     else if (this.type !== tt.name) this.unexpected();
     else {
       node.label = this.parseIdent();
@@ -1897,7 +1919,7 @@
     // optional arguments, we eagerly look for a semicolon or the
     // possibility to insert one.
 
-    if (this.eat(tt.semi) || this.canInsertSemicolon()) node.argument = null;
+    if (this.eat(tt.semi) || this.insertSemicolon()) node.argument = null;
     else { node.argument = this.parseExpression(); this.semicolon(); }
     return this.finishNode(node, "ReturnStatement");
   };
@@ -2459,7 +2481,7 @@
     while (!this.eat(tt.braceR)) {
       if (!first) {
         this.expect(tt.comma);
-        if (this.options.allowTrailingCommas && this.eat(tt.braceR)) break;
+        if (this.afterTrailingComma(tt.braceR)) break;
       } else first = false;
 
       var prop = this.startNode(), isGenerator, start;
@@ -2657,7 +2679,7 @@
     while (!this.eat(close)) {
       if (!first) {
         this.expect(tt.comma);
-        if (allowTrailingComma && this.options.allowTrailingCommas && this.eat(close)) break;
+        if (allowTrailingComma && this.afterTrailingComma(close)) break;
       } else first = false;
 
       if (allowEmpty && this.type === tt.comma) {
@@ -2745,7 +2767,7 @@
     while (!this.eat(tt.braceR)) {
       if (!first) {
         this.expect(tt.comma);
-        if (this.options.allowTrailingCommas && this.eat(tt.braceR)) break;
+        if (this.afterTrailingComma(tt.braceR)) break;
       } else first = false;
 
       var node = this.startNode();
@@ -2799,7 +2821,7 @@
     while (!this.eat(tt.braceR)) {
       if (!first) {
         this.expect(tt.comma);
-        if (this.options.allowTrailingCommas && this.eat(tt.braceR)) break;
+        if (this.afterTrailingComma(tt.braceR)) break;
       } else first = false;
 
       var node = this.startNode();
@@ -2816,7 +2838,7 @@
   pp.parseYield = function() {
     var node = this.startNode();
     this.next();
-    if (this.eat(tt.semi) || this.canInsertSemicolon()) {
+    if (this.eat(tt.semi) || this.insertSemicolon()) {
       node.delegate = false;
       node.argument = null;
     } else {
diff --git a/test/tests.js b/test/tests.js
index c54e04ad47..f3d499dd11 100644
--- a/test/tests.js
+++ b/test/tests.js
@@ -28946,3 +28946,22 @@ test("function f() {} / 1 /", {
     }
   ]
 });
+
+var semicolons = []
+testAssert("var x\nreturn\n10", function() {
+  var result = semicolons.join(" ");
+  semicolons.length = 0;
+  if (result != "5 12 15")
+    return "Unexpected result for onInsertedSemicolon: " + result;
+}, {onInsertedSemicolon: function(pos) { semicolons.push(pos); },
+    allowReturnOutsideFunction: true,
+    loose: false})
+
+var trailingCommas = []
+testAssert("[1,2,] + {foo: 1,}", function() {
+  var result = trailingCommas.join(" ");
+  trailingCommas.length = 0;
+  if (result != "4 16")
+    return "Unexpected result for onTrailingComma: " + result;
+}, {onTrailingComma: function(pos) { trailingCommas.push(pos); },
+    loose: false})

From 4735ef53ef19914b290af0dd9eaafe2917c4d4df Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 12 Mar 2015 22:00:45 +0100
Subject: [PATCH 06/43] Replace the forbidReserved option with an allowReserved
 option

For consistency with similar options
---
 README.md             |  4 ++--
 acorn.js              | 12 ++++++------
 test/tests-harmony.js |  2 +-
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index 1a8afd8e86..b685917d11 100644
--- a/README.md
+++ b/README.md
@@ -63,8 +63,8 @@ object referring to that same position.
 - **onTrailingComma**: Like `onInsertedSemicolon`, but for trailing
   commas.
 
-- **forbidReserved**: If `true`, using a reserved word will generate
-  an error. Defaults to `false`. When given the value `"everywhere"`,
+- **allowReserved**: If `false`, using a reserved word will generate
+  an error. Defaults to `true`. When given the value `"never"`,
   reserved words and keywords can also not be used as property names
   (as in Internet Explorer's old parser).
   
diff --git a/acorn.js b/acorn.js
index 8eb6feb988..24740de6b5 100644
--- a/acorn.js
+++ b/acorn.js
@@ -60,11 +60,11 @@
     // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
     // trailing commas.
     onTrailingComma: null,
-    // 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
+    // By default, reserved words are not enforced. Disable
+    // `allowReserved` to enforce them. When this option has the
+    // value "never", reserved words and keywords can also not be
     // used as property names.
-    forbidReserved: false,
+    allowReserved: true,
     // When enabled, a return at the top level is not considered an
     // error.
     allowReturnOutsideFunction: false,
@@ -2700,10 +2700,10 @@
 
   pp.parseIdent = function(liberal) {
     var node = this.startNode();
-    if (liberal && this.options.forbidReserved == "everywhere") liberal = false;
+    if (liberal && this.options.allowReserved == "never") liberal = false;
     if (this.type === tt.name) {
       if (!liberal &&
-          (this.options.forbidReserved &&
+          (!this.options.allowReserved &&
            (this.options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(this.value) ||
            this.strict && isStrictReservedWord(this.value)) &&
           this.input.slice(this.start, this.end).indexOf("\\") == -1)
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index 552b98dc3c..288b74a8ef 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -13871,7 +13871,7 @@ testFail("function hello() {'use strict'; ({ i: 10, s(eval) { } }); }", "Definin
 
 testFail("function a() { \"use strict\"; ({ b(t, t) { } }); }", "Argument name clash in strict mode (1:37)", {ecmaVersion: 6});
 
-testFail("var super", "The keyword 'super' is reserved (1:4)", {ecmaVersion: 6, forbidReserved: true});
+testFail("var super", "The keyword 'super' is reserved (1:4)", {ecmaVersion: 6, allowReserved: false});
 
 testFail("var default", "Unexpected token (1:4)", {ecmaVersion: 6});
 

From 811d19ab76eeba5146393167b53c48e7a0b70f8d Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 12 Mar 2015 22:26:31 +0100
Subject: [PATCH 07/43] Allow any number of digits when killing \u{} sequences
 in regexps

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

diff --git a/acorn.js b/acorn.js
index 24740de6b5..3156eaf4c6 100644
--- a/acorn.js
+++ b/acorn.js
@@ -1082,7 +1082,7 @@
         // ASCII symbol to avoid throwing on regular expressions that
         // are only valid in combination with the `/u` flag.
         tmp = tmp
-          .replace(/\\u\{([0-9a-fA-F]{5,6})\}/g, "x")
+          .replace(/\\u\{([0-9a-fA-F]+)\}/g, "x")
           .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x");
       }
     }

From 16a342082a6009563cf3f2c0380495035d26e84c Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 12 Mar 2015 22:39:00 +0100
Subject: [PATCH 08/43] Allow trailing commas in array patterns

Closes #975
---
 acorn.js              |  20 +++++---
 test/tests-harmony.js | 103 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 116 insertions(+), 7 deletions(-)

diff --git a/acorn.js b/acorn.js
index 3156eaf4c6..65905a3703 100644
--- a/acorn.js
+++ b/acorn.js
@@ -1605,7 +1605,7 @@
       case tt.bracketL:
         var node = this.startNode();
         this.next();
-        node.elements = this.parseBindingList(tt.bracketR, true);
+        node.elements = this.parseBindingList(tt.bracketR, true, true);
         return this.finishNode(node, "ArrayPattern");
 
       case tt.braceL:
@@ -1616,16 +1616,22 @@
     }
   };
 
-  pp.parseBindingList = function(close, allowEmpty) {
+  pp.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
     var elts = [], first = true;
     while (!this.eat(close)) {
-      first ? first = false : this.expect(tt.comma);
-      if (this.type === tt.ellipsis) {
+      if (first) first = false;
+      else this.expect(tt.comma);
+      if (allowEmpty && this.type === tt.comma) {
+        elts.push(null);
+      } else if (allowTrailingComma && this.afterTrailingComma(close)) {
+        break;
+      } else if (this.type === tt.ellipsis) {
         elts.push(this.parseRest());
         this.expect(close);
         break;
+      } else {
+        elts.push(this.parseMaybeDefault());
       }
-      elts.push(allowEmpty && this.type === tt.comma ? null : this.parseMaybeDefault());
     }
     return elts;
   };
@@ -2567,7 +2573,7 @@
       node.id = this.parseIdent();
     }
     this.expect(tt.parenL);
-    node.params = this.parseBindingList(tt.parenR, false);
+    node.params = this.parseBindingList(tt.parenR, false, false);
     this.parseFunctionBody(node, allowExpressionBody);
     return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
   };
@@ -2578,7 +2584,7 @@
     var node = this.startNode();
     this.initFunction(node);
     this.expect(tt.parenL);
-    node.params = this.parseBindingList(tt.parenR, false);
+    node.params = this.parseBindingList(tt.parenR, false, false);
     var allowExpressionBody;
     if (this.options.ecmaVersion >= 6) {
       node.generator = isGenerator;
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index 288b74a8ef..3fde855cfb 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -15263,6 +15263,109 @@ test("var _\\u{104A6} = 10;", {
   ]
 }, {ecmaVersion: 6});
 
+test("let [x,] = [1]", {
+  "start": 0,
+  "body": [
+    {
+      "start": 0,
+      "declarations": [
+        {
+          "start": 4,
+          "id": {
+            "start": 4,
+            "elements": [
+              {
+                "start": 5,
+                "name": "x",
+                "type": "Identifier",
+                "end": 6
+              }
+            ],
+            "type": "ArrayPattern",
+            "end": 8
+          },
+          "init": {
+            "start": 11,
+            "elements": [
+              {
+                "start": 12,
+                "value": 1,
+                "raw": "1",
+                "type": "Literal",
+                "end": 13
+              }
+            ],
+            "type": "ArrayExpression",
+            "end": 14
+          },
+          "type": "VariableDeclarator",
+          "end": 14
+        }
+      ],
+      "kind": "let",
+      "type": "VariableDeclaration",
+      "end": 14
+    }
+  ],
+  "type": "Program",
+  "end": 14
+}, {ecmaVersion: 6});
+
+test("let {x} = y", {
+  "start": 0,
+  "body": [
+    {
+      "start": 0,
+      "declarations": [
+        {
+          "start": 4,
+          "id": {
+            "start": 4,
+            "properties": [
+              {
+                "start": 5,
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "start": 5,
+                  "name": "x",
+                  "type": "Identifier",
+                  "end": 6
+                },
+                "kind": "init",
+                "value": {
+                  "start": 5,
+                  "name": "x",
+                  "type": "Identifier",
+                  "end": 6
+                },
+                "type": "Property",
+                "end": 6
+              }
+            ],
+            "type": "ObjectPattern",
+            "end": 7
+          },
+          "init": {
+            "start": 10,
+            "name": "y",
+            "type": "Identifier",
+            "end": 11
+          },
+          "type": "VariableDeclarator",
+          "end": 11
+        }
+      ],
+      "kind": "let",
+      "type": "VariableDeclaration",
+      "end": 11
+    }
+  ],
+  "type": "Program",
+  "end": 11
+}, {ecmaVersion: 6})
+
 testFail("var _𖫵 = 11;", "Unexpected character '𖫵' (1:5)", {ecmaVersion: 6});
 testFail("var 𫠞_ = 12;", "Unexpected character '𫠞' (1:4)", {ecmaVersion: 6});
 testFail("var 𫠝_ = 10;", "Unexpected character '𫠝' (1:4)", {ecmaVersion: 5});

From 57bc9b1b0a09133b91e714e3605a9cc302da76e1 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 12 Mar 2015 23:11:33 +0100
Subject: [PATCH 09/43] Move parsing of yield into parseMaybeAssign

Issue #219
---
 acorn.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/acorn.js b/acorn.js
index 65905a3703..c246fa8f37 100644
--- a/acorn.js
+++ b/acorn.js
@@ -2156,6 +2156,8 @@
   // operators like `+=`.
 
   pp.parseMaybeAssign = function(noIn, refShorthandDefaultPos) {
+    if (this.type == tt._yield && this.inGenerator) return this.parseYield();
+
     var failOnShorthandAssign;
     if (!refShorthandDefaultPos) {
       refShorthandDefaultPos = {start: 0};
@@ -2310,7 +2312,7 @@
       return this.finishNode(node, "ThisExpression");
 
     case tt._yield:
-      if (this.inGenerator) return this.parseYield();
+      if (this.inGenerator) unexpected();
 
     case tt.name:
       var start = this.currentPos();
@@ -2844,7 +2846,7 @@
   pp.parseYield = function() {
     var node = this.startNode();
     this.next();
-    if (this.eat(tt.semi) || this.insertSemicolon()) {
+    if (this.type == tt.semi || this.canInsertSemicolon()) {
       node.delegate = false;
       node.argument = null;
     } else {

From 19ef4ef69cce3bdb46632df34afd837b9673904d Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Tue, 17 Mar 2015 12:30:12 +0100
Subject: [PATCH 10/43] Require semicolon after 'import * from ...'

---
 acorn.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/acorn.js b/acorn.js
index c246fa8f37..f82b9753fd 100644
--- a/acorn.js
+++ b/acorn.js
@@ -2734,6 +2734,7 @@
     if (this.eat(tt.star)) {
       this.expectContextual("from");
       node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
+      this.semicolon();
       return this.finishNode(node, "ExportAllDeclaration");
     }
     if (this.eat(tt._default)) { // export default ...;

From 876e774bfe8d656571e6bfdcf3b78d31a2ee9fa1 Mon Sep 17 00:00:00 2001
From: Ingvar Stepanyan <me@rreverser.com>
Date: Tue, 17 Mar 2015 22:33:46 +0200
Subject: [PATCH 11/43] [estree] Align method kinds.

[loose] Split parseObj and parseClass.
---
 acorn.js              |  19 ++++---
 acorn_loose.js        | 127 ++++++++++++++++++++++++------------------
 test/tests-harmony.js |  68 +++++++++++++++-------
 3 files changed, 133 insertions(+), 81 deletions(-)

diff --git a/acorn.js b/acorn.js
index f82b9753fd..5389e3dbbd 100644
--- a/acorn.js
+++ b/acorn.js
@@ -2661,13 +2661,18 @@
       } else {
         method['static'] = false;
       }
-      if (this.type !== tt.parenL && !method.computed && method.key.type === "Identifier" &&
-          (method.key.name === "get" || method.key.name === "set")) {
-        if (isGenerator) this.unexpected();
-        method.kind = method.key.name;
-        this.parsePropertyName(method);
-      } else {
-        method.kind = "";
+      method.kind = "method";
+      if (!method.computed && !isGenerator) {
+        if (method.key.type === "Identifier") {
+          if (this.type !== tt.parenL && (method.key.name === "get" || method.key.name === "set")) {
+            method.kind = method.key.name;
+            this.parsePropertyName(method);
+          } else if (!method['static'] && method.key.name === "constructor") {
+            method.kind = "constructor";
+          }
+        } else if (!method['static'] && method.key.type === "Literal" && method.key.value === "constructor") {
+          method.kind = "constructor";
+        }
       }
       method.value = this.parseMethod(isGenerator);
       classBody.body.push(this.finishNode(method, "MethodDefinition"));
diff --git a/acorn_loose.js b/acorn_loose.js
index c936b4f0e9..94b5919bb6 100644
--- a/acorn_loose.js
+++ b/acorn_loose.js
@@ -456,7 +456,7 @@
       return this.finishNode(node, "EmptyStatement");
 
     case tt._class:
-      return this.parseObj(true, true);
+      return this.parseClass(true);
 
     case tt._import:
       return this.parseImport();
@@ -751,7 +751,7 @@
       return this.parseObj();
 
     case tt._class:
-      return this.parseObj(true);
+      return this.parseClass();
 
     case tt._function:
       var node = this.startNode();
@@ -828,58 +828,29 @@
     return this.finishNode(node, "TemplateLiteral");
   };
 
-  lp.parseObj = function(isClass, isStatement) {
+  lp.parseObj = function() {
     var node = this.startNode();
-    if (isClass) {
-      this.next();
-      if (this.tok.type === tt.name) node.id = this.parseIdent();
-      else if (isStatement) node.id = this.dummyIdent();
-      else node.id = null;
-      node.superClass = this.eat(tt._extends) ? this.parseExpression() : null;
-      node.body = this.startNode();
-      node.body.body = [];
-    } else {
-      node.properties = [];
-    }
+    node.properties = [];
     this.pushCx();
     var indent = this.curIndent + 1, line = this.curLineStart;
     this.eat(tt.braceL);
     if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart; }
     while (!this.closes(tt.braceR, indent, line)) {
-      if (isClass && this.semicolon()) continue;
       var prop = this.startNode(), isGenerator, start;
       if (this.options.ecmaVersion >= 6) {
-        if (isClass) {
-          prop['static'] = false;
-        } else {
-          start = this.storeCurrentPos();
-          prop.method = false;
-          prop.shorthand = false;
-        }
+        start = this.storeCurrentPos();
+        prop.method = false;
+        prop.shorthand = false;
         isGenerator = this.eat(tt.star);
       }
       this.parsePropertyName(prop);
       if (isDummy(prop.key)) { if (isDummy(this.parseMaybeAssign())) this.next(); this.eat(tt.comma); continue; }
-      if (isClass) {
-        if (prop.key.type === "Identifier" && !prop.computed && prop.key.name === "static" &&
-            (this.tok.type != tt.parenL && this.tok.type != tt.braceL)) {
-          prop['static'] = true;
-          isGenerator = this.eat(tt.star);
-          this.parsePropertyName(prop);
-        } else {
-          prop['static'] = false;
-        }
-      }
-      if (!isClass && this.eat(tt.colon)) {
+      if (this.eat(tt.colon)) {
         prop.kind = "init";
         prop.value = this.parseMaybeAssign();
       } else if (this.options.ecmaVersion >= 6 && (this.tok.type === tt.parenL || this.tok.type === tt.braceL)) {
-        if (isClass) {
-          prop.kind = "";
-        } else {
-          prop.kind = "init";
-          prop.method = true;
-        }
+        prop.kind = "init";
+        prop.method = true;
         prop.value = this.parseMethod(isGenerator);
       } else if (this.options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
                  !prop.computed && (prop.key.name === "get" || prop.key.name === "set") &&
@@ -887,9 +858,6 @@
         prop.kind = prop.key.name;
         this.parsePropertyName(prop);
         prop.value = this.parseMethod(false);
-      } else if (isClass) {
-        prop.kind = "";
-        prop.value = this.parseMethod(isGenerator);
       } else {
         prop.kind = "init";
         if (this.options.ecmaVersion >= 6) {
@@ -907,13 +875,8 @@
         }
         prop.shorthand = true;
       }
-
-      if (isClass) {
-        node.body.body.push(this.finishNode(prop, "MethodDefinition"));
-      } else {
-        node.properties.push(this.finishNode(prop, "Property"));
-        this.eat(tt.comma);
-      }
+      node.properties.push(this.finishNode(prop, "Property"));
+      this.eat(tt.comma);
     }
     this.popCx();
     if (!this.eat(tt.braceR)) {
@@ -922,13 +885,67 @@
       this.last.end = this.tok.start;
       if (this.options.locations) this.last.loc.end = this.tok.loc.start;
     }
-    if (isClass) {
-      this.semicolon();
-      this.finishNode(node.body, "ClassBody");
-      return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
-    } else {
-      return this.finishNode(node, "ObjectExpression");
+    return this.finishNode(node, "ObjectExpression");
+  };
+
+  lp.parseClass = function(isStatement) {
+    var node = this.startNode();
+    this.next();
+    if (this.tok.type === tt.name) node.id = this.parseIdent();
+    else if (isStatement) node.id = this.dummyIdent();
+    else node.id = null;
+    node.superClass = this.eat(tt._extends) ? this.parseExpression() : null;
+    node.body = this.startNode();
+    node.body.body = [];
+    this.pushCx();
+    var indent = this.curIndent + 1, line = this.curLineStart;
+    this.eat(tt.braceL);
+    if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart; }
+    while (!this.closes(tt.braceR, indent, line)) {
+      if (this.semicolon()) continue;
+      var method = this.startNode(), isGenerator, start;
+      if (this.options.ecmaVersion >= 6) {
+        method['static'] = false;
+        isGenerator = this.eat(tt.star);
+      }
+      this.parsePropertyName(method);
+      if (isDummy(method.key)) { if (isDummy(this.parseMaybeAssign())) this.next(); this.eat(tt.comma); continue; }
+      if (method.key.type === "Identifier" && !method.computed && method.key.name === "static" &&
+          (this.tok.type != tt.parenL && this.tok.type != tt.braceL)) {
+        method['static'] = true;
+        isGenerator = this.eat(tt.star);
+        this.parsePropertyName(method);
+      } else {
+        method['static'] = false;
+      }
+      if (this.options.ecmaVersion >= 5 && method.key.type === "Identifier" &&
+          !method.computed && (method.key.name === "get" || method.key.name === "set") &&
+          this.tok.type !== tt.parenL && this.tok.type !== tt.braceL) {
+        method.kind = method.key.name;
+        this.parsePropertyName(method);
+        method.value = this.parseMethod(false);
+      } else {
+        if (!method.computed && !method['static'] && !isGenerator && (
+          method.key.type === "Identifier" && method.key.name === "constructor" ||
+          method.key.type === "Literal" && method.key.value === "constructor")) {
+          method.kind = "constructor";
+        } else {
+          method.kind =  "method";
+        }
+        method.value = this.parseMethod(isGenerator);
+      }
+      node.body.body.push(this.finishNode(method, "MethodDefinition"));
     }
+    this.popCx();
+    if (!this.eat(tt.braceR)) {
+      // If there is no closing brace, make the node span to the start
+      // of the next token (this is useful for Tern)
+      this.last.end = this.tok.start;
+      if (this.options.locations) this.last.loc.end = this.tok.loc.start;
+    }
+    this.semicolon();
+    this.finishNode(node.body, "ClassBody");
+    return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
   };
 
   lp.parsePropertyName = function(prop) {
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index 3fde855cfb..d9699915fb 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -6560,7 +6560,7 @@ test("class A {get() {}}", {
             end: {line: 1, column: 17}
           }
         },
-        kind: "",
+        kind: "method",
         static: false,
         loc: {
           start: {line: 1, column: 9},
@@ -6632,7 +6632,7 @@ test("class A { static get() {}}", {
             end: {line: 1, column: 25}
           }
         },
-        kind: "",
+        kind: "method",
         static: true,
         loc: {
           start: {line: 1, column: 10},
@@ -7027,7 +7027,7 @@ test("class A {set(v) {};}", {
             end: {line: 1, column: 18}
           }
         },
-        kind: "",
+        kind: "method",
         static: false,
         loc: {
           start: {line: 1, column: 9},
@@ -7106,7 +7106,7 @@ test("class A { static set(v) {};}", {
             end: {line: 1, column: 26}
           }
         },
-        kind: "",
+        kind: "method",
         static: true,
         loc: {
           start: {line: 1, column: 10},
@@ -7207,7 +7207,7 @@ test("class A {*gen(v) { yield v; }}", {
             end: {line: 1, column: 29}
           }
         },
-        kind: "",
+        kind: "method",
         static: false,
         loc: {
           start: {line: 1, column: 9},
@@ -7308,7 +7308,7 @@ test("class A { static *gen(v) { yield v; }}", {
             end: {line: 1, column: 37}
           }
         },
-        kind: "",
+        kind: "method",
         static: true,
         loc: {
           start: {line: 1, column: 10},
@@ -7421,7 +7421,7 @@ test("\"use strict\"; (class A {constructor() { super() }})", {
                 end: {line: 1, column: 49}
               }
             },
-            kind: "",
+            kind: "constructor",
             static: false,
             loc: {
               start: {line: 1, column: 24},
@@ -7454,6 +7454,36 @@ test("\"use strict\"; (class A {constructor() { super() }})", {
   locations: true
 });
 
+test("class A {'constructor'() {}}", {
+  type: "Program",
+  body: [{
+    type: "ClassDeclaration",
+    id: {type: "Identifier", name: "A"},
+    superClass: null,
+    body: {
+      type: "ClassBody",
+      body: [{
+        type: "MethodDefinition",
+        computed: false,
+        key: {type: "Literal", value: "constructor"},
+        static: false,
+        kind: "constructor",
+        value: {
+          type: "FunctionExpression",
+          id: null,
+          generator: false,
+          expression: false,
+          params: [],
+          body: {
+            type: "BlockStatement",
+            body: []
+          }
+        }
+      }]
+    }
+  }]
+}, {ecmaVersion: 6});
+
 test("class A {static foo() {}}", {
   type: "Program",
   body: [{
@@ -7499,7 +7529,7 @@ test("class A {static foo() {}}", {
             end: {line: 1, column: 24}
           }
         },
-        kind: "",
+        kind: "method",
         static: true,
         loc: {
           start: {line: 1, column: 9},
@@ -7572,7 +7602,7 @@ test("class A {foo() {} static bar() {}}", {
               end: {line: 1, column: 17}
             }
           },
-          kind: "",
+          kind: "method",
           static: false,
           loc: {
             start: {line: 1, column: 9},
@@ -7609,7 +7639,7 @@ test("class A {foo() {} static bar() {}}", {
               end: {line: 1, column: 33}
             }
           },
-          kind: "",
+          kind: "method",
           static: true,
           loc: {
             start: {line: 1, column: 18},
@@ -7723,7 +7753,7 @@ test("\"use strict\"; (class A { static constructor() { super() }})", {
                 end: {line: 1, column: 57}
               }
             },
-            kind: "",
+            kind: "method",
             static: true,
             loc: {
               start: {line: 1, column: 25},
@@ -7802,7 +7832,7 @@ test("class A { foo() {} bar() {}}", {
               end: {line: 1, column: 18}
             }
           },
-          kind: "",
+          kind: "method",
           static: false,
           loc: {
             start: {line: 1, column: 10},
@@ -7839,7 +7869,7 @@ test("class A { foo() {} bar() {}}", {
               end: {line: 1, column: 27}
             }
           },
-          kind: "",
+          kind: "method",
           static: false,
           loc: {
             start: {line: 1, column: 19},
@@ -8450,7 +8480,7 @@ test("class A { static [foo]() {} }", {
           },
           name: "foo"
         },
-        kind: "",
+        kind: "method",
         value: {
           type: "FunctionExpression",
           loc: {
@@ -8717,7 +8747,7 @@ test("class A { foo() {} get foo() {} }",{
             },
             name: "foo"
           },
-          kind: "",
+          kind: "method",
           value: {
             type: "FunctionExpression",
             loc: {
@@ -9582,7 +9612,7 @@ test("class A {[x]() {}}", {
           },
           name: "x"
         },
-        kind: "",
+        kind: "method",
         value: {
           type: "FunctionExpression",
           loc: {
@@ -10324,7 +10354,7 @@ test("(class {f({x} = {x: 10}) {}})", {
               end: {line: 1, column: 27}
             }
           },
-          kind: "",
+          kind: "method",
           static: false,
           loc: {
             start: {line: 1, column: 8},
@@ -14947,7 +14977,7 @@ test("class A { static() {} }", {
           name: "static"
         },
         static: false,
-        kind: "",
+        kind: "method",
         value: {
           type: "FunctionExpression",
           range: [16, 21],
@@ -15044,7 +15074,7 @@ test("class A { *static() {} }", {
           name: "static"
         },
         static: false,
-        kind: "",
+        kind: "method",
         value: {
           type: "FunctionExpression",
           range: [17, 22],

From 024a98431d54c4b88dc209d2270a70350dca32be Mon Sep 17 00:00:00 2001
From: Ingvar Stepanyan <me@rreverser.com>
Date: Tue, 17 Mar 2015 23:01:42 +0200
Subject: [PATCH 12/43] [estree] Add SuperExpression.

(we're almost there)
---
 acorn.js              | 5 +++++
 acorn_loose.js        | 5 +++++
 test/tests-harmony.js | 6 ++----
 3 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/acorn.js b/acorn.js
index 5389e3dbbd..5c0412a068 100644
--- a/acorn.js
+++ b/acorn.js
@@ -2315,6 +2315,11 @@
       if (this.inGenerator) unexpected();
 
     case tt.name:
+      if (this.value === "super") {
+        var node = this.startNode();
+        this.next();
+        return this.finishNode(node, "SuperExpression");
+      }
       var start = this.currentPos();
       var id = this.parseIdent(this.type !== tt.name);
       if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
diff --git a/acorn_loose.js b/acorn_loose.js
index 94b5919bb6..62500963c5 100644
--- a/acorn_loose.js
+++ b/acorn_loose.js
@@ -699,6 +699,11 @@
       return this.finishNode(node, "ThisExpression");
 
     case tt.name:
+      if (this.tok.value === "super") {
+        var node = this.startNode();
+        this.next();
+        return this.finishNode(node, "SuperExpression");
+      }
       var start = this.storeCurrentPos();
       var id = this.parseIdent();
       return this.eat(tt.arrow) ? this.parseArrowExpression(this.startNodeAt(start), [id]) : id;
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index d9699915fb..c81fca1423 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -7391,8 +7391,7 @@ test("\"use strict\"; (class A {constructor() { super() }})", {
                   expression: {
                     type: "CallExpression",
                     callee: {
-                      type: "Identifier",
-                      name: "super",
+                      type: "SuperExpression",
                       loc: {
                         start: {line: 1, column: 40},
                         end: {line: 1, column: 45}
@@ -7723,8 +7722,7 @@ test("\"use strict\"; (class A { static constructor() { super() }})", {
                   expression: {
                     type: "CallExpression",
                     callee: {
-                      type: "Identifier",
-                      name: "super",
+                      type: "SuperExpression",
                       loc: {
                         start: {line: 1, column: 48},
                         end: {line: 1, column: 53}

From 0473c368e615e94bf0d3d9c23c98349f7ee9f8c6 Mon Sep 17 00:00:00 2001
From: Ingvar Stepanyan <me@rreverser.com>
Date: Wed, 18 Mar 2015 13:42:49 +0200
Subject: [PATCH 13/43] [es6][estree] Add support for `sourceType:
 script|module` modes.

+ Fix list of keywords and reserved words in ES6.
---
 README.md             |  3 +++
 acorn.js              | 42 ++++++++++++++++++++++++-------------
 acorn_loose.js        | 12 +++++------
 test/tests-harmony.js | 49 +++++++++++++++++++++++++++++++++----------
 4 files changed, 75 insertions(+), 31 deletions(-)

diff --git a/README.md b/README.md
index b685917d11..3ab7882203 100644
--- a/README.md
+++ b/README.md
@@ -54,6 +54,9 @@ object referring to that same position.
   either 3, 5, or 6. This influences support for strict mode, the set
   of reserved words, and support for new syntax features. Default is 5.
 
+- **sourceType**: Indicate the mode the code should be parsed in. Can be
+  either `"script"` or `"module"`.
+
 - **onInsertedSemicolon**: If given a callback, that callback will be
   called whenever a missing semicolon is inserted by the parser. The
   callback will be given the character offset of the point where the
diff --git a/acorn.js b/acorn.js
index 5c0412a068..89a8818415 100644
--- a/acorn.js
+++ b/acorn.js
@@ -51,6 +51,8 @@
     // mode, the set of reserved words, support for getters and
     // setters and other features.
     ecmaVersion: 5,
+    // Source type ("script" or "module") for different semantics
+    sourceType: "script",
     // `onInsertedSemicolon` can be a callback that will be called
     // when a semicolon is automatically inserted. It will be passed
     // th position of the comma as an offset, and if `locations` is
@@ -342,6 +344,7 @@
   kw("with");
   kw("new", beforeExpr);
   kw("this");
+  kw("super");
   kw("class");
   kw("extends", beforeExpr);
   kw("export");
@@ -412,6 +415,10 @@
 
   var isReservedWord5 = makePredicate("class enum extends super const export import");
 
+  // ECMAScript 6 reserved words.
+
+  var isReservedWord6 = makePredicate("enum await");
+
   // The additional reserved words in strict mode.
 
   var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
@@ -426,7 +433,7 @@
 
   var isEcma5AndLessKeyword = makePredicate(ecma5AndLessKeywords);
 
-  var isEcma6Keyword = makePredicate(ecma5AndLessKeywords + " let const class extends export import yield");
+  var isEcma6Keyword = makePredicate(ecma5AndLessKeywords + " let const class extends export import yield super");
 
   // ## Character categories
 
@@ -543,6 +550,7 @@
     this.loadPlugins(this.options.plugins);
     this.sourceFile = this.options.sourceFile || null;
     this.isKeyword = this.options.ecmaVersion >= 6 ? isEcma6Keyword : isEcma5AndLessKeyword;
+    this.isReservedWord = this.options.ecmaVersion === 3 ? isReservedWord3 : this.options.ecmaVersion === 5 ? isReservedWord5 : isReservedWord6;
     this.input = String(input);
 
     // Set up token state
@@ -578,9 +586,11 @@
     this.context = [tc.b_stat];
     this.exprAllowed = true;
 
-    // Flags to track whether we are in strict mode, a function, a
-    // generator.
-    this.strict = this.inFunction = this.inGenerator = false;
+    // Figure out if it's a module code.
+    this.strict = this.inModule = this.options.sourceType === "module";
+
+    // Flags to track whether we are in a function, a generator.
+    this.inFunction = this.inGenerator = false;
     // Labels in scope.
     this.labels = [];
 
@@ -946,6 +956,7 @@
     }
     if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 &&
         this.input.charCodeAt(this.pos + 3) == 45) {
+      if (this.inModule) unexpected();
       // `<!--`, an XML-style comment that should be interpreted as a line comment
       this.skipLineComment(4);
       this.skipSpace();
@@ -1763,8 +1774,10 @@
       if (first && this.isUseStrict(stmt)) this.setStrict(true);
       first = false;
     }
-
     this.next();
+    if (this.options.ecmaVersion >= 6) {
+      node.sourceType = this.options.sourceType;
+    }
     return this.finishNode(node, "Program");
   };
 
@@ -1808,8 +1821,12 @@
     case tt.semi: return this.parseEmptyStatement(node);
     case tt._export:
     case tt._import:
-      if (!topLevel && !this.options.allowImportExportEverywhere)
-        this.raise(this.start, "'import' and 'export' may only appear at the top level");
+      if (!this.options.allowImportExportEverywhere) {
+        if (!topLevel)
+          this.raise(this.start, "'import' and 'export' may only appear at the top level");
+        if (!this.inModule)
+          this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
+      }
       return starttype === tt._import ? this.parseImport(node) : this.parseExport(node);
 
       // If the statement does not start with a statement keyword or a
@@ -2307,19 +2324,16 @@
   pp.parseExprAtom = function(refShorthandDefaultPos) {
     switch (this.type) {
     case tt._this:
+    case tt._super:
+      var type = this.type === tt._this ? "ThisExpression" : "SuperExpression";
       var node = this.startNode();
       this.next();
-      return this.finishNode(node, "ThisExpression");
+      return this.finishNode(node, type);
 
     case tt._yield:
       if (this.inGenerator) unexpected();
 
     case tt.name:
-      if (this.value === "super") {
-        var node = this.startNode();
-        this.next();
-        return this.finishNode(node, "SuperExpression");
-      }
       var start = this.currentPos();
       var id = this.parseIdent(this.type !== tt.name);
       if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
@@ -2722,7 +2736,7 @@
     if (this.type === tt.name) {
       if (!liberal &&
           (!this.options.allowReserved &&
-           (this.options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(this.value) ||
+           this.isReservedWord(this.value) ||
            this.strict && isStrictReservedWord(this.value)) &&
           this.input.slice(this.start, this.end).indexOf("\\") == -1)
         this.raise(this.start, "The keyword '" + this.value + "' is reserved");
diff --git a/acorn_loose.js b/acorn_loose.js
index 62500963c5..619ecdcb22 100644
--- a/acorn_loose.js
+++ b/acorn_loose.js
@@ -311,6 +311,9 @@
     node.body = [];
     while (this.tok.type !== tt.eof) node.body.push(this.parseStatement());
     this.last = this.tok;
+    if (this.options.ecmaVersion >= 6) {
+      node.sourceType = this.options.sourceType;
+    }
     return this.finishNode(node, "Program");
   };
 
@@ -694,16 +697,13 @@
   lp.parseExprAtom = function() {
     switch (this.tok.type) {
     case tt._this:
+    case tt._super:
+      var type = this.tok.type === tt._this ? "ThisExpression" : "SuperExpression";
       var node = this.startNode();
       this.next();
-      return this.finishNode(node, "ThisExpression");
+      return this.finishNode(node, type);
 
     case tt.name:
-      if (this.tok.value === "super") {
-        var node = this.startNode();
-        this.next();
-        return this.finishNode(node, "SuperExpression");
-      }
       var start = this.storeCurrentPos();
       var id = this.parseIdent();
       return this.eat(tt.arrow) ? this.parseArrowExpression(this.startNodeAt(start), [id]) : id;
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index c81fca1423..72154470c7 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -4381,6 +4381,7 @@ test("let {a:b} = {}", {
 
 test("var {a:b} = {}", {
   type: "Program",
+  sourceType: "script",
   body: [{
     type: "VariableDeclaration",
     declarations: [{
@@ -4452,6 +4453,7 @@ test("var {a:b} = {}", {
 
 test("export var document", {
   type: "Program",
+  sourceType: "module",
   body: [{
     type: "ExportNamedDeclaration",
     declaration: {
@@ -4491,6 +4493,7 @@ test("export var document", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -4543,6 +4546,7 @@ test("export var document = { }", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -4588,6 +4592,7 @@ test("export let document", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -4640,6 +4645,7 @@ test("export let document = { }", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -4692,6 +4698,7 @@ test("export const document = { }", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -4739,6 +4746,7 @@ test("export function parse() { }", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -4784,6 +4792,7 @@ test("export class Class {}", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -4812,6 +4821,7 @@ test("export default 42", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -4836,7 +4846,7 @@ test("export default function () {}", {
       }
     }
   }]
-}, {ecmaVersion: 6, ranges: true});
+}, {ecmaVersion: 6, sourceType: "module", ranges: true});
 
 test("export default function f() {}", {
   type: "Program",
@@ -4862,7 +4872,7 @@ test("export default function f() {}", {
       }
     }
   }]
-}, {ecmaVersion: 6, ranges: true});
+}, {ecmaVersion: 6, sourceType: "module", ranges: true});
 
 test("export default class {}", {
   type: "Program",
@@ -4882,7 +4892,7 @@ test("export default class {}", {
       }
     }
   }]
-}, {ecmaVersion: 6, ranges: true});
+}, {ecmaVersion: 6, sourceType: "module", ranges: true});
 
 test("export default class A {}", {
   type: "Program",
@@ -4906,9 +4916,9 @@ test("export default class A {}", {
       }
     }
   }]
-}, {ecmaVersion: 6, ranges: true});
+}, {ecmaVersion: 6, sourceType: "module", ranges: true});
 
-testFail("export *", "Unexpected token (1:8)", {ecmaVersion: 6});
+testFail("export *", "Unexpected token (1:8)", {ecmaVersion: 6, sourceType: "module"});
 
 test("export * from \"crypto\"", {
   type: "Program",
@@ -4934,6 +4944,7 @@ test("export * from \"crypto\"", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -4978,6 +4989,7 @@ test("export { encrypt }", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -5047,6 +5059,7 @@ test("export { encrypt, decrypt }", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -5091,6 +5104,7 @@ test("export { encrypt as default }", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -5160,6 +5174,7 @@ test("export { encrypt, decrypt as dec }", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -5220,6 +5235,7 @@ test("export { default } from \"other\"", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -5249,6 +5265,7 @@ test("import \"jquery\"", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -5292,6 +5309,7 @@ test("import $ from \"jquery\"", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -5368,6 +5386,7 @@ test("import { encrypt, decrypt } from \"crypto\"", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -5419,6 +5438,7 @@ test("import { encrypt as enc } from \"crypto\"", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -5510,11 +5530,12 @@ test("import crypto, { decrypt, encrypt as enc } from \"crypto\"", {
   }]
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
 
-testFail("import default from \"foo\"", "Unexpected token (1:7)", {ecmaVersion: 6});
+testFail("import default from \"foo\"", "Unexpected token (1:7)", {ecmaVersion: 6, sourceType: "module"});
 
 test("import { null as nil } from \"bar\"", {
   type: "Program",
@@ -5563,6 +5584,7 @@ test("import { null as nil } from \"bar\"", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -5606,6 +5628,7 @@ test("import * as crypto from \"crypto\"", {
   }]
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -5668,6 +5691,7 @@ test("(function* () { yield v })", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -5738,6 +5762,7 @@ test("(function* () { yield\nv })", {
   }
 }, {
   ecmaVersion: 6,
+  sourceType: "module",
   ranges: true,
   locations: true
 });
@@ -13899,7 +13924,7 @@ testFail("function hello() {'use strict'; ({ i: 10, s(eval) { } }); }", "Definin
 
 testFail("function a() { \"use strict\"; ({ b(t, t) { } }); }", "Argument name clash in strict mode (1:37)", {ecmaVersion: 6});
 
-testFail("var super", "The keyword 'super' is reserved (1:4)", {ecmaVersion: 6, allowReserved: false});
+testFail("var super", "Unexpected token (1:4)", {ecmaVersion: 6});
 
 testFail("var default", "Unexpected token (1:4)", {ecmaVersion: 6});
 
@@ -13915,11 +13940,11 @@ testFail("for (let x = 42 in list) process(x);", "Unexpected token (1:16)", {ecm
 
 testFail("for (let x = 42 of list) process(x);", "Unexpected token (1:16)", {ecmaVersion: 6});
 
-testFail("import foo", "Unexpected token (1:10)", {ecmaVersion: 6});
+testFail("import foo", "Unexpected token (1:10)", {ecmaVersion: 6, sourceType: "module"});
 
-testFail("import { foo, bar }", "Unexpected token (1:19)", {ecmaVersion: 6});
+testFail("import { foo, bar }", "Unexpected token (1:19)", {ecmaVersion: 6, sourceType: "module"});
 
-testFail("import foo from bar", "Unexpected token (1:16)", {ecmaVersion: 6});
+testFail("import foo from bar", "Unexpected token (1:16)", {ecmaVersion: 6, sourceType: "module"});
 
 testFail("((a)) => 42", "Unexpected token (1:1)", {ecmaVersion: 6});
 
@@ -14415,7 +14440,7 @@ test("import foo, * as bar from 'baz';", {
       raw: "'baz'"
     }
   }]
-}, {ecmaVersion: 6});
+}, {ecmaVersion: 6, sourceType: "module"});
 
 // https://github.com/marijnh/acorn/issues/173
 test("`{${x}}`, `}`", {
@@ -15404,3 +15429,5 @@ testFail("if (1) ; else class Cls {}", "Unexpected token (1:14)", {ecmaVersion:
 
 testFail("'use strict'; [...eval] = arr", "Assigning to eval in strict mode (1:18)", {ecmaVersion: 6});
 testFail("'use strict'; ({eval = defValue} = obj)", "Assigning to eval in strict mode (1:16)", {ecmaVersion: 6});
+
+testFail("[...eval] = arr", "Assigning to eval in strict mode (1:4)", {ecmaVersion: 6, sourceType: "module"});

From a75a68561057c28d489f77497d507cb431fd1188 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 19 Mar 2015 12:34:41 +0100
Subject: [PATCH 14/43] Add a startsExpr property to token types, use it to
 properly parse yield

Issue #219
---
 acorn.js              | 49 ++++++++++++++++++++++---------------------
 acorn_loose.js        |  2 +-
 test/tests-harmony.js | 47 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 73 insertions(+), 25 deletions(-)

diff --git a/acorn.js b/acorn.js
index 89a8818415..17ca02ce82 100644
--- a/acorn.js
+++ b/acorn.js
@@ -240,6 +240,7 @@
     this.label = label;
     this.keyword = conf.keyword;
     this.beforeExpr = !!conf.beforeExpr;
+    this.startsExpr = !!conf.startsExpr;
     this.isLoop = !!conf.isLoop;
     this.isAssign = !!conf.isAssign;
     this.prefix = !!conf.prefix;
@@ -251,21 +252,21 @@
   function binop(name, prec) {
     return new TokenType(name, {beforeExpr: true, binop: prec});
   }
-  var beforeExpr = {beforeExpr: true};
+  var beforeExpr = {beforeExpr: true}, startsExpr = {startsExpr: true};
 
   var tt = exports.tokTypes = {
-    num: new TokenType("num"),
-    regexp: new TokenType("regexp"),
-    string: new TokenType("string"),
-    name: new TokenType("name"),
+    num: new TokenType("num", startsExpr),
+    regexp: new TokenType("regexp", startsExpr),
+    string: new TokenType("string", startsExpr),
+    name: new TokenType("name", startsExpr),
     eof: new TokenType("eof"),
 
     // Punctuation token types.
-    bracketL: new TokenType("[", beforeExpr),
+    bracketL: new TokenType("[", {beforeExpr: true, startsExpr: true}),
     bracketR: new TokenType("]"),
-    braceL: new TokenType("{", beforeExpr),
+    braceL: new TokenType("{", {beforeExpr: true, startsExpr: true}),
     braceR: new TokenType("}"),
-    parenL: new TokenType("(", beforeExpr),
+    parenL: new TokenType("(", {beforeExpr: true, startsExpr: true}),
     parenR: new TokenType(")"),
     comma: new TokenType(",", beforeExpr),
     semi: new TokenType(";", beforeExpr),
@@ -275,8 +276,8 @@
     arrow: new TokenType("=>", beforeExpr),
     template: new TokenType("template"),
     ellipsis: new TokenType("...", beforeExpr),
-    backQuote: new TokenType("`"),
-    dollarBraceL: new TokenType("${", beforeExpr),
+    backQuote: new TokenType("`", startsExpr),
+    dollarBraceL: new TokenType("${", {beforeExpr: true, startsExpr: true}),
 
     // Operators. These carry several kinds of properties to help the
     // parser use them properly (the presence of these properties is
@@ -294,8 +295,8 @@
 
     eq: new TokenType("=", {beforeExpr: true, isAssign: true}),
     assign: new TokenType("_=", {beforeExpr: true, isAssign: true}),
-    incDec: new TokenType("++/--", {prefix: true, postfix: true}),
-    prefix: new TokenType("prefix", {beforeExpr: true, prefix: true}),
+    incDec: new TokenType("++/--", {prefix: true, postfix: true, startsExpr: true}),
+    prefix: new TokenType("prefix", {beforeExpr: true, prefix: true, startsExpr: true}),
     logicalOR: binop("||", 1),
     logicalAND: binop("&&", 2),
     bitwiseOR: binop("|", 3),
@@ -304,7 +305,7 @@
     equality: binop("==/!=", 6),
     relational: binop("</>", 7),
     bitShift: binop("<</>>", 8),
-    plusMin: new TokenType("+/-", {beforeExpr: true, binop: 9, prefix: true}),
+    plusMin: new TokenType("+/-", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),
     modulo: binop("%", 10),
     star: binop("*", 10),
     slash: binop("/", 10)
@@ -342,22 +343,22 @@
   kw("const");
   kw("while", {isLoop: true});
   kw("with");
-  kw("new", beforeExpr);
-  kw("this");
-  kw("super");
+  kw("new", {beforeExpr: true, startsExpr: true});
+  kw("this", startsExpr);
+  kw("super", startsExpr);
   kw("class");
   kw("extends", beforeExpr);
   kw("export");
   kw("import");
-  kw("yield", beforeExpr);
-  kw("null");
-  kw("true");
-  kw("false");
+  kw("yield", {beforeExpr: true, startsExpr: true});
+  kw("null", startsExpr);
+  kw("true", startsExpr);
+  kw("false", startsExpr);
   kw("in", {beforeExpr: true, binop: 7});
   kw("instanceof", {beforeExpr: true, binop: 7});
-  kw("typeof", {beforeExpr: true, prefix: true});
-  kw("void", {beforeExpr: true, prefix: true});
-  kw("delete", {beforeExpr: true, prefix: true});
+  kw("typeof", {beforeExpr: true, prefix: true, startsExpr: true});
+  kw("void", {beforeExpr: true, prefix: true, startsExpr: true});
+  kw("delete", {beforeExpr: true, prefix: true, startsExpr: true});
 
   // 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
@@ -2871,7 +2872,7 @@
   pp.parseYield = function() {
     var node = this.startNode();
     this.next();
-    if (this.type == tt.semi || this.canInsertSemicolon()) {
+    if (this.type == tt.semi || this.canInsertSemicolon() || (this.type != tt.star && !this.type.startsExpr)) {
       node.delegate = false;
       node.argument = null;
     } else {
diff --git a/acorn_loose.js b/acorn_loose.js
index 619ecdcb22..b8207e242b 100644
--- a/acorn_loose.js
+++ b/acorn_loose.js
@@ -769,7 +769,7 @@
     case tt._yield:
       var node = this.startNode();
       this.next();
-      if (this.semicolon() || this.canInsertSemicolon()) {
+      if (this.semicolon() || this.canInsertSemicolon() || (this.tok.type != tt.star && !this.tok.type.startsExpr)) {
         node.delegate = false;
         node.argument = null;
       } else {
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index 72154470c7..3a8c55db7c 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -5989,6 +5989,53 @@ test("var x = { *test () { yield *v } };", {
   locations: true
 });
 
+test("function* foo() { console.log(yield); }", {
+  body: [
+    {
+      id: {
+        name: "foo",
+        type: "Identifier",
+      },
+      generator: true,
+      expression: false,
+      params: [],
+      body: {
+        body: [
+          {
+            expression: {
+              callee: {
+                object: {
+                  name: "console",
+                  type: "Identifier",
+                },
+                property: {
+                  name: "log",
+                  type: "Identifier",
+                },
+                computed: false,
+                type: "MemberExpression",
+              },
+              arguments: [
+                {
+                  delegate: false,
+                  argument: null,
+                  type: "YieldExpression",
+                }
+              ],
+              type: "CallExpression",
+            },
+            type: "ExpressionStatement",
+          }
+        ],
+        type: "BlockStatement",
+      },
+      type: "FunctionDeclaration",
+    }
+  ],
+  sourceType: "script",
+  type: "Program"
+}, {ecmaVersion: 6})
+
 test("function* t() {}", {
   type: "Program",
   body: [{

From b6e83108482aec1d6a4e68d42993c59a7271eeee Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 19 Mar 2015 12:46:36 +0100
Subject: [PATCH 15/43] Require an initalization value when
 let/var/const-declaring a complex pattern

Closes #222
---
 acorn.js              | 2 ++
 test/tests-harmony.js | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/acorn.js b/acorn.js
index 17ca02ce82..0e9845a2d5 100644
--- a/acorn.js
+++ b/acorn.js
@@ -2134,6 +2134,8 @@
         decl.init = this.parseMaybeAssign(noIn);
       } else if (kind === tt._const && !(this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
         this.unexpected();
+      } else if (decl.id.type != "Identifier") {
+        this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value")
       } else {
         decl.init = null;
       }
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index 3a8c55db7c..e4b0ee4ff8 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -15466,6 +15466,8 @@ test("let {x} = y", {
   "end": 11
 }, {ecmaVersion: 6})
 
+testFail("let [x]", "Complex binding patterns require an initialization value (1:7)", {ecmaVersion: 6})
+testFail("var [x]", "Complex binding patterns require an initialization value (1:7)", {ecmaVersion: 6})
 testFail("var _𖫵 = 11;", "Unexpected character '𖫵' (1:5)", {ecmaVersion: 6});
 testFail("var 𫠞_ = 12;", "Unexpected character '𫠞' (1:4)", {ecmaVersion: 6});
 testFail("var 𫠝_ = 10;", "Unexpected character '𫠝' (1:4)", {ecmaVersion: 5});

From 5d5b8eb3c8ed268c100ca28ab23d1f3c205cc362 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 19 Mar 2015 12:56:19 +0100
Subject: [PATCH 16/43] Don't crash when converting missing array elements to
 assignable

Closes #220
---
 acorn.js              | 33 ++++++++++++++++-----------------
 test/tests-harmony.js | 28 ++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+), 17 deletions(-)

diff --git a/acorn.js b/acorn.js
index 0e9845a2d5..3fefa233ba 100644
--- a/acorn.js
+++ b/acorn.js
@@ -1568,25 +1568,24 @@
   // Convert list of expression atoms to binding list.
 
   pp.toAssignableList = function(exprList, isBinding) {
-    if (exprList.length) {
-      for (var i = 0; i < exprList.length - 1; i++) {
-        this.toAssignable(exprList[i], isBinding);
-      }
-      var last = exprList[exprList.length - 1];
-      switch (last.type) {
-        case "RestElement":
-          break;
-        case "SpreadElement":
-          last.type = "RestElement";
-          var arg = last.argument;
-          this.toAssignable(arg, isBinding);
-          if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern")
-            this.unexpected(arg.start);
-          break;
-        default:
-          this.toAssignable(last, isBinding);
+    var end = exprList.length;
+    if (end) {
+      var last = exprList[end - 1];
+      if (last && last.type == "RestElement") {
+        --end;
+      } else if (last && last.type == "SpreadElement") {
+        last.type = "RestElement";
+        var arg = last.argument;
+        this.toAssignable(arg, isBinding);
+        if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern")
+          this.unexpected(arg.start);
+        --end;
       }
     }
+    for (var i = 0; i < end; i++) {
+      var elt = exprList[i];
+      if (elt) this.toAssignable(elt, isBinding);
+    }
     return exprList;
   };
 
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index e4b0ee4ff8..a300fa8d84 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -15466,6 +15466,34 @@ test("let {x} = y", {
   "end": 11
 }, {ecmaVersion: 6})
 
+test("[x,,] = 1", {
+  type: "Program",
+  body: [
+    {
+      type: "ExpressionStatement",
+      expression: {
+        type: "AssignmentExpression",
+        operator: "=",
+        left: {
+          type: "ArrayPattern",
+          elements: [
+            {
+              type: "Identifier",
+              name: "x"
+            },
+            null
+          ]
+        },
+        right: {
+          type: "Literal",
+          value: 1,
+          raw: "1"
+        }
+      }
+    }
+  ]
+}, {ecmaVersion: 6});
+
 testFail("let [x]", "Complex binding patterns require an initialization value (1:7)", {ecmaVersion: 6})
 testFail("var [x]", "Complex binding patterns require an initialization value (1:7)", {ecmaVersion: 6})
 testFail("var _𖫵 = 11;", "Unexpected character '𖫵' (1:5)", {ecmaVersion: 6});

From 0a755156a8f3191b6f13be17b5c6ac88dae0cade Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 19 Mar 2015 13:11:17 +0100
Subject: [PATCH 17/43] Ignore backslash-escapes in identifiers in ES6 mode

---
 acorn.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/acorn.js b/acorn.js
index 3fefa233ba..2fe39a2d90 100644
--- a/acorn.js
+++ b/acorn.js
@@ -2737,10 +2737,10 @@
     if (liberal && this.options.allowReserved == "never") liberal = false;
     if (this.type === tt.name) {
       if (!liberal &&
-          (!this.options.allowReserved &&
-           this.isReservedWord(this.value) ||
-           this.strict && isStrictReservedWord(this.value)) &&
-          this.input.slice(this.start, this.end).indexOf("\\") == -1)
+          ((!this.options.allowReserved && this.isReservedWord(this.value)) ||
+           (this.strict && isStrictReservedWord(this.value)) &&
+           (this.options.ecmaVersion >= 6 || 
+            this.input.slice(this.start, this.end).indexOf("\\") == -1)))
         this.raise(this.start, "The keyword '" + this.value + "' is reserved");
       node.name = this.value;
     } else if (liberal && this.type.keyword) {

From a45172e04449f3decb8d81a89aa92e0a0dabd892 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 19 Mar 2015 13:42:26 +0100
Subject: [PATCH 18/43] Unify checkLVal and checkFunctionParam

---
 acorn.js              | 57 +++++++++++++------------------------------
 test/tests-harmony.js | 18 +++++++-------
 test/tests.js         | 46 +++++++++++++++++-----------------
 3 files changed, 49 insertions(+), 72 deletions(-)

diff --git a/acorn.js b/acorn.js
index 2fe39a2d90..00402ed773 100644
--- a/acorn.js
+++ b/acorn.js
@@ -1660,36 +1660,6 @@
     return this.finishNode(node, "AssignmentPattern");
   };
 
-  // Verify that argument names are not repeated, and it does not
-  // try to bind the words `eval` or `arguments`.
-
-  pp.checkFunctionParam = function(param, nameHash) {
-    switch (param.type) {
-      case "Identifier":
-        if (isStrictReservedWord(param.name) || isStrictBadIdWord(param.name))
-          this.raise(param.start, "Defining '" + param.name + "' in strict mode");
-        if (has(nameHash, param.name))
-          this.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++)
-          this.checkFunctionParam(param.properties[i].value, nameHash);
-        break;
-
-      case "ArrayPattern":
-        for (var i = 0; i < param.elements.length; i++) {
-          var elem = param.elements[i];
-          if (elem) this.checkFunctionParam(elem, nameHash);
-        }
-        break;
-
-      case "RestElement":
-        return this.checkFunctionParam(param.argument, nameHash);
-    }
-  };
-
   // 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
@@ -1722,39 +1692,44 @@
   // Verify that a node is an lval — something that can be assigned
   // to.
 
-  pp.checkLVal = function(expr, isBinding) {
+  pp.checkLVal = function(expr, isBinding, checkClashes) {
     switch (expr.type) {
       case "Identifier":
         if (this.strict && (isStrictBadIdWord(expr.name) || isStrictReservedWord(expr.name)))
           this.raise(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode");
+        if (checkClashes) {
+          if (has(checkClashes, expr.name))
+            this.raise(expr.start, "Argument name clash in strict mode");
+          checkClashes[expr.name] = true;
+        }
         break;
 
       case "MemberExpression":
-        if (isBinding) this.raise(expr.start, "Binding to member expression");
+        if (isBinding) this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " member expression");
         break;
 
       case "ObjectPattern":
         for (var i = 0; i < expr.properties.length; i++)
-          this.checkLVal(expr.properties[i].value, isBinding);
+          this.checkLVal(expr.properties[i].value, isBinding, checkClashes);
         break;
 
       case "ArrayPattern":
         for (var i = 0; i < expr.elements.length; i++) {
           var elem = expr.elements[i];
-          if (elem) this.checkLVal(elem, isBinding);
+          if (elem) this.checkLVal(elem, isBinding, checkClashes);
         }
         break;
 
       case "AssignmentPattern":
-        this.checkLVal(expr.left);
+        this.checkLVal(expr.left, isBinding, checkClashes);
         break;
 
       case "RestElement":
-        this.checkLVal(expr.argument);
+        this.checkLVal(expr.argument, isBinding, checkClashes);
         break;
 
       default:
-        this.raise(expr.start, "Assigning to rvalue");
+        this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " rvalue");
     }
   };
 
@@ -2650,11 +2625,13 @@
     // are not repeated, and it does not try to bind the words `eval`
     // or `arguments`.
     if (this.strict || !isExpression && node.body.body.length && this.isUseStrict(node.body.body[0])) {
-      var nameHash = {};
+      var nameHash = {}, oldStrict = this.strict;
+      this.strict = true;
       if (node.id)
-        this.checkFunctionParam(node.id, {});
+        this.checkLVal(node.id, true);
       for (var i = 0; i < node.params.length; i++)
-        this.checkFunctionParam(node.params[i], nameHash);
+        this.checkLVal(node.params[i], true, nameHash);
+      this.strict = oldStrict;
     }
   };
 
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index a300fa8d84..15fcd92c1e 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -13967,7 +13967,7 @@ testFail("x \n isnt y", "Unexpected token (2:6)", {ecmaVersion: 6});
 
 testFail("function default() {}", "Unexpected token (1:9)", {ecmaVersion: 6});
 
-testFail("function hello() {'use strict'; ({ i: 10, s(eval) { } }); }", "Defining 'eval' in strict mode (1:44)", {ecmaVersion: 6});
+testFail("function hello() {'use strict'; ({ i: 10, s(eval) { } }); }", "Binding eval in strict mode (1:44)", {ecmaVersion: 6});
 
 testFail("function a() { \"use strict\"; ({ b(t, t) { } }); }", "Argument name clash in strict mode (1:37)", {ecmaVersion: 6});
 
@@ -13999,15 +13999,15 @@ testFail("(a, (b)) => 42", "Unexpected token (1:4)", {ecmaVersion: 6});
 
 testFail("\"use strict\"; (eval = 10) => 42", "Assigning to eval in strict mode (1:15)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; eval => 42", "Defining 'eval' in strict mode (1:14)", {ecmaVersion: 6});
+testFail("\"use strict\"; eval => 42", "Binding eval in strict mode (1:14)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; arguments => 42", "Defining 'arguments' in strict mode (1:14)", {ecmaVersion: 6});
+testFail("\"use strict\"; arguments => 42", "Binding arguments in strict mode (1:14)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; (eval, a) => 42", "Defining 'eval' in strict mode (1:15)", {ecmaVersion: 6});
+testFail("\"use strict\"; (eval, a) => 42", "Binding eval in strict mode (1:15)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; (arguments, a) => 42", "Defining 'arguments' in strict mode (1:15)", {ecmaVersion: 6});
+testFail("\"use strict\"; (arguments, a) => 42", "Binding arguments in strict mode (1:15)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; (eval, a = 10) => 42", "Defining 'eval' in strict mode (1:15)", {ecmaVersion: 6});
+testFail("\"use strict\"; (eval, a = 10) => 42", "Binding eval in strict mode (1:15)", {ecmaVersion: 6});
 
 testFail("\"use strict\"; (a, a) => 42", "Argument name clash in strict mode (1:18)", {ecmaVersion: 6});
 
@@ -14261,7 +14261,7 @@ testFail("[...{ a }] = b", "Unexpected token (1:4)", {ecmaVersion: 6});
 
 testFail("[...a, b] = c", "Assigning to rvalue (1:1)", {ecmaVersion: 6});
 
-testFail("({ t(eval) { \"use strict\"; } });", "Defining 'eval' in strict mode (1:5)", {ecmaVersion: 6});
+testFail("({ t(eval) { \"use strict\"; } });", "Binding eval in strict mode (1:5)", {ecmaVersion: 6});
 
 testFail("\"use strict\"; `${test}\\02`;", "Octal literal in strict mode (1:22)", {ecmaVersion: 6});
 
@@ -14330,9 +14330,9 @@ testFail("(b, ...a)", "Unexpected token (1:4)", {ecmaVersion: 6});
 
 testFail("switch (cond) { case 10: let a = 20; ", "Unexpected token (1:37)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; (eval) => 42", "Defining 'eval' in strict mode (1:15)", {ecmaVersion: 6});
+testFail("\"use strict\"; (eval) => 42", "Binding eval in strict mode (1:15)", {ecmaVersion: 6});
 
-testFail("(eval) => { \"use strict\"; 42 }", "Defining 'eval' in strict mode (1:1)", {ecmaVersion: 6});
+testFail("(eval) => { \"use strict\"; 42 }", "Binding eval in strict mode (1:1)", {ecmaVersion: 6});
 
 testFail("({ get test() { } }) => 42", "Object pattern can't contain getter or setter (1:7)", {ecmaVersion: 6});
 
diff --git a/test/tests.js b/test/tests.js
index f3d499dd11..b13dfb2e2e 100644
--- a/test/tests.js
+++ b/test/tests.js
@@ -27261,55 +27261,55 @@ testFail("function hello() {'use strict'; arguments--; }",
          "Assigning to arguments in strict mode (1:32)");
 
 testFail("function hello() {'use strict'; function eval() { } }",
-         "Defining 'eval' in strict mode (1:41)");
+         "Binding eval in strict mode (1:41)");
 
 testFail("function hello() {'use strict'; function arguments() { } }",
-         "Defining 'arguments' in strict mode (1:41)");
+         "Binding arguments in strict mode (1:41)");
 
 testFail("function eval() {'use strict'; }",
-         "Defining 'eval' in strict mode (1:9)");
+         "Binding eval in strict mode (1:9)");
 
 testFail("function arguments() {'use strict'; }",
-         "Defining 'arguments' in strict mode (1:9)");
+         "Binding arguments in strict mode (1:9)");
 
 testFail("function hello() {'use strict'; (function eval() { }()) }",
-         "Defining 'eval' in strict mode (1:42)");
+         "Binding eval in strict mode (1:42)");
 
 testFail("function hello() {'use strict'; (function arguments() { }()) }",
-         "Defining 'arguments' in strict mode (1:42)");
+         "Binding arguments in strict mode (1:42)");
 
 testFail("(function eval() {'use strict'; })()",
-         "Defining 'eval' in strict mode (1:10)");
+         "Binding eval in strict mode (1:10)");
 
 testFail("(function arguments() {'use strict'; })()",
-         "Defining 'arguments' in strict mode (1:10)");
+         "Binding arguments in strict mode (1:10)");
 
 testFail("function hello() {'use strict'; ({ s: function eval() { } }); }",
-         "Defining 'eval' in strict mode (1:47)");
+         "Binding eval in strict mode (1:47)");
 
 testFail("(function package() {'use strict'; })()",
-         "Defining 'package' in strict mode (1:10)");
+         "Binding package in strict mode (1:10)");
 
 testFail("function hello() {'use strict'; ({ i: 10, set s(eval) { } }); }",
-         "Defining 'eval' in strict mode (1:48)");
+         "Binding eval in strict mode (1:48)");
 
 testFail("function hello() {'use strict'; ({ set s(eval) { } }); }",
-         "Defining 'eval' in strict mode (1:41)");
+         "Binding eval in strict mode (1:41)");
 
 testFail("function hello() {'use strict'; ({ s: function s(eval) { } }); }",
-         "Defining 'eval' in strict mode (1:49)");
+         "Binding eval in strict mode (1:49)");
 
 testFail("function hello(eval) {'use strict';}",
-         "Defining 'eval' in strict mode (1:15)");
+         "Binding eval in strict mode (1:15)");
 
 testFail("function hello(arguments) {'use strict';}",
-         "Defining 'arguments' in strict mode (1:15)");
+         "Binding arguments in strict mode (1:15)");
 
 testFail("function hello() { 'use strict'; function inner(eval) {} }",
-         "Defining 'eval' in strict mode (1:48)");
+         "Binding eval in strict mode (1:48)");
 
 testFail("function hello() { 'use strict'; function inner(arguments) {} }",
-         "Defining 'arguments' in strict mode (1:48)");
+         "Binding arguments in strict mode (1:48)");
 
 testFail("function hello() { 'use strict'; \"\\1\"; }",
          "Octal literal in strict mode (1:34)");
@@ -27348,10 +27348,10 @@ testFail("function hello() { \"use strict\"; var static; }",
          "The keyword 'static' is reserved (1:37)");
 
 testFail("function hello(static) { \"use strict\"; }",
-         "Defining 'static' in strict mode (1:15)");
+         "Binding static in strict mode (1:15)");
 
 testFail("function static() { \"use strict\"; }",
-         "Defining 'static' in strict mode (1:9)");
+         "Binding static in strict mode (1:9)");
 
 testFail("\"use strict\"; function static() { }",
          "The keyword 'static' is reserved (1:23)");
@@ -27360,10 +27360,10 @@ testFail("function a(t, t) { \"use strict\"; }",
          "Argument name clash in strict mode (1:14)");
 
 testFail("function a(eval) { \"use strict\"; }",
-         "Defining 'eval' in strict mode (1:11)");
+         "Binding eval in strict mode (1:11)");
 
 testFail("function a(package) { \"use strict\"; }",
-         "Defining 'package' in strict mode (1:11)");
+         "Binding package in strict mode (1:11)");
 
 testFail("function a() { \"use strict\"; function b(t, t) { }; }",
          "Argument name clash in strict mode (1:43)");
@@ -27375,10 +27375,10 @@ testFail("function a() { \"use strict\"; (function b(t, t) { }); }",
          "Argument name clash in strict mode (1:44)");
 
 testFail("(function a(eval) { \"use strict\"; })",
-         "Defining 'eval' in strict mode (1:12)");
+         "Binding eval in strict mode (1:12)");
 
 testFail("(function a(package) { \"use strict\"; })",
-         "Defining 'package' in strict mode (1:12)");
+         "Binding package in strict mode (1:12)");
 
 testFail("\"use strict\";function foo(){\"use strict\";}function bar(){var v = 015}",
          "Invalid number (1:65)");

From 9673146cc1e8059c0d0b946ab9df4a46e541b11c Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 19 Mar 2015 14:05:08 +0100
Subject: [PATCH 19/43] Verify that property name can be bound to in short-hand
 object pattern properties

Issue #221
---
 acorn.js              | 10 ++++++----
 test/tests-harmony.js |  2 ++
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/acorn.js b/acorn.js
index 00402ed773..7caacb8377 100644
--- a/acorn.js
+++ b/acorn.js
@@ -2492,12 +2492,10 @@
       if (this.options.ecmaVersion >= 6) {
         prop.method = false;
         prop.shorthand = false;
-        if (isPattern || refShorthandDefaultPos) {
+        if (isPattern || refShorthandDefaultPos)
           start = this.currentPos();
-        }
-        if (!isPattern) {
+        if (!isPattern)
           isGenerator = this.eat(tt.star);
-        }
       }
       this.parsePropertyName(prop);
       if (this.eat(tt.colon)) {
@@ -2518,6 +2516,10 @@
       } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
         prop.kind = "init";
         if (isPattern) {
+          if (this.isKeyword(prop.key.name) ||
+              (this.strict && (isStrictBadIdWord(prop.key.name) || isStrictReservedWord(prop.key.name))) ||
+              (!this.options.allowReserved && this.isReservedWord(prop.key.name)))
+            this.raise(prop.key.start, "Binding " + prop.key.name);
           prop.value = this.parseMaybeDefault(start, prop.key);
         } else if (this.type === tt.eq && refShorthandDefaultPos) {
           if (!refShorthandDefaultPos.start)
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index 15fcd92c1e..4f2480e12a 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -15508,3 +15508,5 @@ testFail("'use strict'; [...eval] = arr", "Assigning to eval in strict mode (1:1
 testFail("'use strict'; ({eval = defValue} = obj)", "Assigning to eval in strict mode (1:16)", {ecmaVersion: 6});
 
 testFail("[...eval] = arr", "Assigning to eval in strict mode (1:4)", {ecmaVersion: 6, sourceType: "module"});
+
+testFail("function* y({yield}) {}", "Binding yield (1:13)", {ecmaVersion: 6});

From 575421b3c251a63c248878ad9f26b0cff8cd46db Mon Sep 17 00:00:00 2001
From: Mathias Bynens <mathias@qiwi.be>
Date: Sun, 8 Mar 2015 09:31:54 +0100
Subject: [PATCH 20/43] Make `readRegexp` more tolerant

---
 acorn.js              | 14 ++++++++------
 test/tests-harmony.js | 28 ++++++++++++++++++++++++++++
 2 files changed, 36 insertions(+), 6 deletions(-)

diff --git a/acorn.js b/acorn.js
index 7caacb8377..122c8729e9 100644
--- a/acorn.js
+++ b/acorn.js
@@ -1089,13 +1089,15 @@
       if (this.options.ecmaVersion >= 6) validFlags = /^[gmsiyu]*$/;
       if (!validFlags.test(mods)) this.raise(start, "Invalid regular expression flag");
       if (mods.indexOf('u') >= 0 && !regexpUnicodeSupport) {
-        // Replace each astral symbol and every Unicode code point
-        // escape sequence that represents such a symbol with a single
-        // ASCII symbol to avoid throwing on regular expressions that
+        // Replace each astral symbol and every Unicode escape sequence that
+        // possibly represents an astral symbol or a paired surrogate with a
+        // single ASCII symbol to avoid throwing on regular expressions that
         // are only valid in combination with the `/u` flag.
-        tmp = tmp
-          .replace(/\\u\{([0-9a-fA-F]+)\}/g, "x")
-          .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x");
+        // Note: replacing with the ASCII symbol `x` might cause false
+        // negatives in unlikely scenarios. For example, `[\u{61}-b]` is a
+        // perfectly valid pattern that is equivalent to `[a-b]`, but it would
+        // be replaced by `[x-b]` which throws an error.
+        tmp = tmp.replace(/\\u([a-fA-F0-9]{4})|\\u\{([0-9a-fA-F]+)\}|[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x")
       }
     }
     // Detect invalid regular expressions.
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index 4f2480e12a..75019ce3af 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -13861,6 +13861,34 @@ test("/[a-z]/u", {
   ecmaVersion: 6
 });
 
+test("/[\\uD834\\uDF06-\\uD834\\uDF08a-z]/u", {
+  type: "Program",
+  body: [
+    {
+      type: "ExpressionStatement",
+      expression: {
+        type: "Literal",
+        regex: {
+          pattern: "[\\uD834\\uDF06-\\uD834\\uDF08a-z]",
+          flags: "u"
+        },
+        loc: {
+          start: {
+            line: 1,
+            column: 0
+          },
+          end: {
+            line: 1,
+            column: 33
+          }
+        }
+      }
+    }
+  ]
+}, {
+  locations: true,
+  ecmaVersion: 6
+});
 
 test("do {} while (false) foo();", {
   type: "Program",

From 980845994016f67f7c4b4ac606355477e487d441 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 19 Mar 2015 15:40:12 +0100
Subject: [PATCH 21/43] Start on ES6 port

---
 src/index.js     | 2743 ++++++++++++++++++++++++++++++++++++++++++++++
 src/tokentype.js |  142 +++
 src/util.js      |    9 +
 3 files changed, 2894 insertions(+)
 create mode 100644 src/index.js
 create mode 100644 src/tokentype.js
 create mode 100644 src/util.js

diff --git a/src/index.js b/src/index.js
new file mode 100644
index 0000000000..cdb1db1a7f
--- /dev/null
+++ b/src/index.js
@@ -0,0 +1,2743 @@
+// Acorn is a tiny, fast JavaScript parser written in JavaScript.
+//
+// Acorn was written by Marijn Haverbeke, Ingvar Stepanyan, and
+// various contributors and released under an MIT license.
+//
+// Git repositories for Acorn are available at
+//
+//     http://marijnhaverbeke.nl/git/acorn
+//     https://github.com/marijnh/acorn.git
+//
+// Please use the [github bug tracker][ghbt] to report issues.
+//
+// [ghbt]: https://github.com/marijnh/acorn/issues
+//
+// This file defines the main parser interface. The library also comes
+// with a [error-tolerant parser][dammit] and an
+// [abstract syntax tree walker][walk], defined in other files.
+//
+// [dammit]: acorn_loose.js
+// [walk]: util/walk.js
+
+import {has, isArray} from "./util"
+import {types as tt, keywords as keywordTypes} from "./tokentype"
+
+export const version = "0.12.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][api].
+//
+// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
+
+export function parse(input, options) {
+  let p = parser(options, input)
+  let startPos = p.options.locations ? [p.pos, p.curPosition()] : p.pos
+  p.nextToken()
+  return p.parseTopLevel(p.options.program || p.startNodeAt(startPos))
+}
+
+// A second optional argument can be given to further configure
+// the parser process. These options are recognized:
+
+export const 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,
+  // Source type ("script" or "module") for different semantics
+  sourceType: "script",
+  // `onInsertedSemicolon` can be a callback that will be called
+  // when a semicolon is automatically inserted. It will be passed
+  // th position of the comma as an offset, and if `locations` is
+  // enabled, it is given the location as a `{line, column}` object
+  // as second argument.
+  onInsertedSemicolon: null,
+  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
+  // trailing commas.
+  onTrailingComma: null,
+  // By default, reserved words are not enforced. Disable
+  // `allowReserved` to enforce them. When this option has the
+  // value "never", reserved words and keywords can also not be
+  // used as property names.
+  allowReserved: true,
+  // When enabled, a return at the top level is not considered an
+  // error.
+  allowReturnOutsideFunction: false,
+  // When enabled, import/export statements are not constrained to
+  // appearing at the top of the program.
+  allowImportExportEverywhere: false,
+  // When enabled, hashbang directive in the beginning of file
+  // is allowed and treated as a line comment.
+  allowHashBang: 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] `range` property holding a `[start,
+  // end]` array with the same numbers, set the `ranges` option to
+  // `true`.
+  //
+  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
+  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,
+  // When enabled, parenthesized expressions are represented by
+  // (non-standard) ParenthesizedExpression nodes
+  preserveParens: false,
+  plugins: {}
+}
+
+// Registered plugins
+
+export const plugins = {}
+
+// Interpret and default an options object
+
+function getOptions(opts) {
+  let options = {}
+  for (let opt in defaultOptions)
+    options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]
+
+  if (isArray(options.onToken)) {
+    var tokens = options.onToken;
+    options.onToken = (token) => tokens.push(token)
+  }
+  if (isArray(options.onComment))
+    options.onComment = pushComment(options, options.onComment);
+
+  return options;
+}
+
+function pushComment(options, array) {
+  return function (block, text, start, end, startLoc, endLoc) {
+    let comment = {
+      type: block ? 'Block' : 'Line',
+      value: text,
+      start: start,
+      end: end
+    }
+    if (options.locations)
+      comment.loc = new SourceLocation(this, startLoc, endLoc)
+    if (options.ranges)
+      comment.range = [start, end]
+    array.push(comment)
+  }
+}
+
+function parser(options, input) {
+  return new Parser(getOptions(options), String(input))
+}
+
+// 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.
+
+export function parseExpressionAt(input, pos, options) {
+  let p = parser(options, input, pos)
+  p.nextToken()
+  return p.parseExpression()
+}
+
+// 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.
+
+export function getLineInfo(input, offset) {
+  for (let line = 1, cur = 0;;) {
+    lineBreak.lastIndex = cur
+    let match = lineBreak.exec(input)
+    if (match && match.index < offset) {
+      ++line
+      cur = match.index + match[0].length
+    } else {
+      return new Position(line, offset - cur)
+    }
+  }
+}
+
+// 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.
+
+export function tokenizer(input, options) {
+  return parser(options, input)
+}
+
+// Object type used to represent tokens. Note that normally, tokens
+// simply exist as properties on the parser object. This is only
+// used for the onToken callback and the external tokenizer.
+
+class Token {
+  constructor(p) {
+    this.type = p.type;
+    this.value = p.value;
+    this.start = p.start;
+    this.end = p.end;
+    if (p.options.locations)
+      this.loc = new SourceLocation(p, p.startLoc, p.endLoc);
+    if (p.options.ranges)
+      this.range = [p.start, p.end];
+  }
+}
+
+// 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");
+
+// ECMAScript 6 reserved words.
+
+var isReservedWord6 = makePredicate("enum await");
+
+// 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 super");
+
+// ## 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\u2118-\u211d\u2124\u2126\u2128\u212a-\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\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\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 = "\u200c\u200d\xb7\u0300-\u036f\u0387\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\u1369-\u1371\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-\u19da\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\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 + "]");
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+
+// These are a run-length and offset encoded representation of the
+// >0xffff code points that are a valid part of identifiers. The
+// offset starts at 0x10000, and each pair of numbers represents an
+// offset to the next range, and then a size of the range. They were
+// generated by tools/generate-identifier-regex.js
+var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,17,26,6,37,11,29,3,35,5,7,2,4,43,157,99,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,98,21,11,25,71,55,7,1,65,0,16,3,2,2,2,26,45,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,955,52,76,44,33,24,27,35,42,34,4,0,13,47,15,3,22,0,38,17,2,24,133,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,32,4,287,47,21,1,2,0,185,46,82,47,21,0,60,42,502,63,32,0,449,56,1288,920,104,110,2962,1070,13266,568,8,30,114,29,19,47,17,3,32,20,6,18,881,68,12,0,67,12,16481,1,3071,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,1340,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,16355,541];
+var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,1306,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,52,0,13,2,49,13,16,9,83,11,168,11,6,9,8,2,57,0,2,6,3,1,3,2,10,0,11,1,3,6,4,4,316,19,13,9,214,6,3,8,112,16,16,9,82,12,9,9,535,9,20855,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,4305,6,792618,239];
+
+// This has a complexity linear to the value of the code. The
+// assumption is that looking up astral identifier characters is
+// rare.
+function isInAstralSet(code, set) {
+  var pos = 0x10000;
+  for (var i = 0; i < set.length; i += 2) {
+    pos += set[i];
+    if (pos > code) return false;
+    pos += set[i + 1];
+    if (pos >= code) return true;
+  }
+}
+
+// Whether a single character denotes a newline.
+
+var newline = exports.newline = /[\n\r\u2028\u2029]/;
+
+var isNewLine = exports.isNewLine = function(code) {
+  return code === 10 || code === 13 || code === 0x2028 || code == 0x2029;
+};
+
+// Matches a whole line break (where CRLF is considered a single
+// line break). Used to count lines.
+
+var lineBreak = exports.lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
+
+// Test whether a given character code starts an identifier.
+
+var isIdentifierStart = exports.isIdentifierStart = function(code, astral) {
+  if (code < 65) return code === 36;
+  if (code < 91) return true;
+  if (code < 97) return code === 95;
+  if (code < 123) return true;
+  if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  if (astral === false) return false;
+  return isInAstralSet(code, astralIdentifierStartCodes);
+};
+
+// Test whether a given character is part of an identifier.
+
+var isIdentifierChar = exports.isIdentifierChar = function(code, astral) {
+  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;
+  if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  if (astral === false) return false;
+  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+};
+
+// ## Tokenizer
+
+// These are used when `options.locations` is on, for the
+// `startLoc` and `endLoc` properties.
+
+function Position(line, col) {
+  this.line = line;
+  this.column = col;
+}
+
+Position.prototype.offset = function(n) {
+  return new Position(this.line, this.column + n);
+};
+
+// ## 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][opp] 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.
+//
+// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser
+
+var Parser = exports.Parser = function(options, input, startPos) {
+  this.options = options
+  this.loadPlugins(this.options.plugins)
+  this.sourceFile = this.options.sourceFile || null
+  this.isKeyword = this.options.ecmaVersion >= 6 ? isEcma6Keyword : isEcma5AndLessKeyword
+  this.isReservedWord =
+      this.options.ecmaVersion === 3 ? isReservedWord3
+    : this.options.ecmaVersion === 5 ? isReservedWord5
+    : isReservedWord6
+  this.input = input
+
+  // Set up token state
+
+  // The current position of the tokenizer in the input.
+  if (startPos) {
+    this.pos = startPos;
+    this.lineStart = Math.max(0, this.input.lastIndexOf("\n", startPos));
+    this.curLine = this.input.slice(0, this.lineStart).split(newline).length;
+  } else {
+    this.pos = this.lineStart = 0;
+    this.curLine = 1;
+  }
+
+  // Properties of the current token:
+  // Its type
+  this.type = tt.eof;
+  // For tokens that include more information than their type, the value
+  this.value = null;
+  // Its start and end offset
+  this.start = this.end = this.pos;
+  // And, if locations are used, the {line, column} object
+  // corresponding to those offsets
+  this.startLoc = this.endLoc = null;
+
+  // Position information for the previous token
+  this.lastTokEndLoc = this.lastTokStartLoc = null;
+  this.lastTokStart = this.lastTokEnd = this.pos;
+
+  // The context stack is used to superficially track syntactic
+  // context to predict whether a regular expression is allowed in a
+  // given position.
+  this.context = [tc.b_stat];
+  this.exprAllowed = true;
+
+  // Figure out if it's a module code.
+  this.strict = this.inModule = this.options.sourceType === "module";
+
+  // Flags to track whether we are in a function, a generator.
+  this.inFunction = this.inGenerator = false;
+  // Labels in scope.
+  this.labels = [];
+
+  // If enabled, skip leading hashbang line.
+  if (this.pos === 0 && this.options.allowHashBang && this.input.slice(0, 2) === '#!')
+    this.skipLineComment(2);
+};
+
+// Shorthand because we are going to be adding a _lot_ of methods to
+// this.
+var pp = Parser.prototype;
+
+pp.extend = function(name, f) {
+  this[name] = f(this[name]);
+};
+
+pp.loadPlugins = function(plugins) {
+  for (var name in plugins) {
+    var plugin = exports.plugins[name];
+    if (!plugin) throw new Error("Plugin '" + name + "' not found");
+    plugin(this, plugins[name]);
+  }
+};
+
+// Move to the next token
+
+pp.next = function() {
+  if (this.options.onToken)
+    this.options.onToken(new Token(this));
+
+  this.lastTokEnd = this.end;
+  this.lastTokStart = this.start;
+  this.lastTokEndLoc = this.endLoc;
+  this.lastTokStartLoc = this.startLoc;
+  this.nextToken();
+};
+
+pp.getToken = function() {
+  this.next();
+  return new Token(this);
+};
+
+// If we're in an ES6 environment, make parsers iterable
+if (typeof Symbol !== "undefined")
+  pp[Symbol.iterator] = function () {
+    var self = this;
+    return {next: function () {
+      var token = self.getToken();
+      return {
+        done: token.type === tt.eof,
+        value: token
+      };
+    }};
+  };
+
+// Toggle strict mode. Re-reads the next number or string to please
+// pedantic tests (`"use strict"; 010;` should fail).
+
+pp.setStrict = function(strict) {
+  this.strict = strict;
+  if (this.type !== tt.num && this.type !== tt.string) return;
+  this.pos = this.start;
+  if (this.options.locations) {
+    while (this.pos < this.lineStart) {
+      this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1;
+      --this.curLine;
+    }
+  }
+  this.nextToken();
+};
+
+pp.curContext = function() {
+  return this.context[this.context.length - 1];
+};
+
+// Read a single token, updating the parser object's token-related
+// properties.
+
+pp.nextToken = function() {
+  var curContext = this.curContext();
+  if (!curContext || !curContext.preserveSpace) this.skipSpace();
+
+  this.start = this.pos;
+  if (this.options.locations) this.startLoc = this.curPosition();
+  if (this.pos >= this.input.length) return this.finishToken(tt.eof);
+
+  if (curContext === tc.q_tmpl) return this.readTmplToken();
+
+  this.readToken(this.fullCharCodeAtPos());
+};
+
+pp.readToken = function(code) {
+  // Identifier or keyword. '\uXXXX' sequences are allowed in
+  // identifiers, so '\' also dispatches to that.
+  if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */)
+    return this.readWord();
+
+  return this.getTokenFromCode(code);
+};
+
+pp.fullCharCodeAtPos = function() {
+  var code = this.input.charCodeAt(this.pos);
+  if (code <= 0xd7ff || code >= 0xe000) return code;
+  var next = this.input.charCodeAt(this.pos + 1);
+  return (code << 10) + next - 0x35fdc00;
+};
+
+pp.skipBlockComment = function() {
+  var startLoc = this.options.onComment && this.options.locations && this.curPosition();
+  var start = this.pos, end = this.input.indexOf("*/", this.pos += 2);
+  if (end === -1) this.raise(this.pos - 2, "Unterminated comment");
+  this.pos = end + 2;
+  if (this.options.locations) {
+    lineBreak.lastIndex = start;
+    var match;
+    while ((match = lineBreak.exec(this.input)) && match.index < this.pos) {
+      ++this.curLine;
+      this.lineStart = match.index + match[0].length;
+    }
+  }
+  if (this.options.onComment)
+    this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,
+                           startLoc, this.options.locations && this.curPosition());
+};
+
+pp.skipLineComment = function(startSkip) {
+  var start = this.pos;
+  var startLoc = this.options.onComment && this.options.locations && this.curPosition();
+  var ch = this.input.charCodeAt(this.pos+=startSkip);
+  while (this.pos < this.input.length && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+    ++this.pos;
+    ch = this.input.charCodeAt(this.pos);
+  }
+  if (this.options.onComment)
+    this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,
+                           startLoc, this.options.locations && this.curPosition());
+};
+
+// Called at the start of the parse and after every token. Skips
+// whitespace and comments, and.
+
+pp.skipSpace = function() {
+  while (this.pos < this.input.length) {
+    var ch = this.input.charCodeAt(this.pos);
+    if (ch === 32) { // ' '
+      ++this.pos;
+    } else if (ch === 13) {
+      ++this.pos;
+      var next = this.input.charCodeAt(this.pos);
+      if (next === 10) {
+        ++this.pos;
+      }
+      if (this.options.locations) {
+        ++this.curLine;
+        this.lineStart = this.pos;
+      }
+    } else if (ch === 10 || ch === 8232 || ch === 8233) {
+      ++this.pos;
+      if (this.options.locations) {
+        ++this.curLine;
+        this.lineStart = this.pos;
+      }
+    } else if (ch > 8 && ch < 14) {
+      ++this.pos;
+    } else if (ch === 47) { // '/'
+      var next = this.input.charCodeAt(this.pos + 1);
+      if (next === 42) { // '*'
+        this.skipBlockComment();
+      } else if (next === 47) { // '/'
+        this.skipLineComment(2);
+      } else break;
+    } else if (ch === 160) { // '\xa0'
+      ++this.pos;
+    } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+      ++this.pos;
+    } else {
+      break;
+    }
+  }
+};
+
+pp.curPosition = function() {
+  return new Position(this.curLine, this.pos - this.lineStart);
+};
+
+// The algorithm used to determine whether a regexp can appear at a
+// given point in the program is loosely based on sweet.js' approach.
+// See https://github.com/mozilla/sweet.js/wiki/design
+
+var TokContext = exports.TokContext = function(token, isExpr, preserveSpace) {
+  this.token = token;
+  this.isExpr = isExpr;
+  this.preserveSpace = preserveSpace;
+};
+
+var tc = exports.tokContexts = {
+  b_stat: new TokContext("{", false),
+  b_expr: new TokContext("{", true),
+  b_tmpl: new TokContext("${", true),
+  p_stat: new TokContext("(", false),
+  p_expr: new TokContext("(", true),
+  q_tmpl: new TokContext("`", true, true),
+  f_expr: new TokContext("function", true)
+};
+
+pp.braceIsBlock = function(prevType) {
+  var parent;
+  if (prevType === tt.colon && (parent = this.curContext()).token == "{")
+    return !parent.isExpr;
+  if (prevType === tt._return)
+    return newline.test(this.input.slice(this.lastTokEnd, this.start));
+  if (prevType === tt._else || prevType === tt.semi || prevType === tt.eof)
+    return true;
+  if (prevType == tt.braceL)
+    return this.curContext() === tc.b_stat;
+  return !this.exprAllowed;
+};
+
+// Called at the end of every token. Sets `end`, `val`, and
+// maintains `context` and `exprAllowed`, and skips the space after
+// the token, so that the next one's `start` will point at the
+// right position.
+
+pp.finishToken = function(type, val) {
+  this.end = this.pos;
+  if (this.options.locations) this.endLoc = this.curPosition();
+  var prevType = this.type;
+  this.type = type;
+  this.value = val;
+
+  this.updateContext(prevType);
+};
+
+pp.updateContext = function(prevType) {
+  var update, type = this.type;
+  if (type.keyword && prevType == tt.dot)
+    this.exprAllowed = false;
+  else if (update = type.updateContext)
+    update.call(this, prevType);
+  else
+    this.exprAllowed = type.beforeExpr;
+};
+
+// Token-specific context update code
+
+tt.parenR.updateContext = tt.braceR.updateContext = function() {
+  var out = this.context.pop();
+  if (out === tc.b_stat && this.curContext() === tc.f_expr) {
+    this.context.pop();
+    this.exprAllowed = false;
+  } else if (out === tc.b_tmpl) {
+    this.exprAllowed = true;
+  } else {
+    this.exprAllowed = !(out && out.isExpr);
+  }
+};
+
+tt.braceL.updateContext = function(prevType) {
+  this.context.push(this.braceIsBlock(prevType) ? tc.b_stat : tc.b_expr);
+  this.exprAllowed = true;
+};
+
+tt.dollarBraceL.updateContext = function() {
+  this.context.push(tc.b_tmpl);
+  this.exprAllowed = true;
+};
+
+tt.parenL.updateContext = function(prevType) {
+  var statementParens = prevType === tt._if || prevType === tt._for || prevType === tt._with || prevType === tt._while;
+  this.context.push(statementParens ? tc.p_stat : tc.p_expr);
+  this.exprAllowed = true;
+};
+
+tt.incDec.updateContext = function() {
+  // tokExprAllowed stays unchanged
+};
+
+tt._function.updateContext = function() {
+  if (this.curContext() !== tc.b_stat)
+    this.context.push(tc.f_expr);
+  this.exprAllowed = false;
+};
+
+tt.backQuote.updateContext = function() {
+  if (this.curContext() === tc.q_tmpl)
+    this.context.pop();
+  else
+    this.context.push(tc.q_tmpl);
+  this.exprAllowed = false;
+};
+
+// ### 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.
+//
+pp.readToken_dot = function() {
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next >= 48 && next <= 57) return this.readNumber(true);
+  var next2 = this.input.charCodeAt(this.pos + 2);
+  if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
+    this.pos += 3;
+    return this.finishToken(tt.ellipsis);
+  } else {
+    ++this.pos;
+    return this.finishToken(tt.dot);
+  }
+};
+
+pp.readToken_slash = function() { // '/'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (this.exprAllowed) {++this.pos; return this.readRegexp();}
+  if (next === 61) return this.finishOp(tt.assign, 2);
+  return this.finishOp(tt.slash, 1);
+};
+
+pp.readToken_mult_modulo = function(code) { // '%*'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === 61) return this.finishOp(tt.assign, 2);
+  return this.finishOp(code === 42 ? tt.star : tt.modulo, 1);
+};
+
+pp.readToken_pipe_amp = function(code) { // '|&'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === code) return this.finishOp(code === 124 ? tt.logicalOR : tt.logicalAND, 2);
+  if (next === 61) return this.finishOp(tt.assign, 2);
+  return this.finishOp(code === 124 ? tt.bitwiseOR : tt.bitwiseAND, 1);
+};
+
+pp.readToken_caret = function() { // '^'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === 61) return this.finishOp(tt.assign, 2);
+  return this.finishOp(tt.bitwiseXOR, 1);
+};
+
+pp.readToken_plus_min = function(code) { // '+-'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === code) {
+    if (next == 45 && this.input.charCodeAt(this.pos + 2) == 62 &&
+        newline.test(this.input.slice(this.lastTokEnd, this.pos))) {
+      // A `-->` line comment
+      this.skipLineComment(3);
+      this.skipSpace();
+      return this.nextToken();
+    }
+    return this.finishOp(tt.incDec, 2);
+  }
+  if (next === 61) return this.finishOp(tt.assign, 2);
+  return this.finishOp(tt.plusMin, 1);
+};
+
+pp.readToken_lt_gt = function(code) { // '<>'
+  var next = this.input.charCodeAt(this.pos + 1);
+  var size = 1;
+  if (next === code) {
+    size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
+    if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1);
+    return this.finishOp(tt.bitShift, size);
+  }
+  if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 &&
+      this.input.charCodeAt(this.pos + 3) == 45) {
+    if (this.inModule) unexpected();
+    // `<!--`, an XML-style comment that should be interpreted as a line comment
+    this.skipLineComment(4);
+    this.skipSpace();
+    return this.nextToken();
+  }
+  if (next === 61)
+    size = this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2;
+  return this.finishOp(tt.relational, size);
+};
+
+pp.readToken_eq_excl = function(code) { // '=!'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === 61) return this.finishOp(tt.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2);
+  if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'
+    this.pos += 2;
+    return this.finishToken(tt.arrow);
+  }
+  return this.finishOp(code === 61 ? tt.eq : tt.prefix, 1);
+};
+
+pp.getTokenFromCode = function(code) {
+  switch (code) {
+    // The interpretation of a dot depends on whether it is followed
+    // by a digit or another two dots.
+  case 46: // '.'
+    return this.readToken_dot();
+
+    // Punctuation tokens.
+  case 40: ++this.pos; return this.finishToken(tt.parenL);
+  case 41: ++this.pos; return this.finishToken(tt.parenR);
+  case 59: ++this.pos; return this.finishToken(tt.semi);
+  case 44: ++this.pos; return this.finishToken(tt.comma);
+  case 91: ++this.pos; return this.finishToken(tt.bracketL);
+  case 93: ++this.pos; return this.finishToken(tt.bracketR);
+  case 123: ++this.pos; return this.finishToken(tt.braceL);
+  case 125: ++this.pos; return this.finishToken(tt.braceR);
+  case 58: ++this.pos; return this.finishToken(tt.colon);
+  case 63: ++this.pos; return this.finishToken(tt.question);
+
+  case 96: // '`'
+    if (this.options.ecmaVersion < 6) break;
+    ++this.pos;
+    return this.finishToken(tt.backQuote);
+
+  case 48: // '0'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === 120 || next === 88) return this.readRadixNumber(16); // '0x', '0X' - hex number
+    if (this.options.ecmaVersion >= 6) {
+      if (next === 111 || next === 79) return this.readRadixNumber(8); // '0o', '0O' - octal number
+      if (next === 98 || next === 66) return this.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 this.readNumber(false);
+
+    // Quotes produce strings.
+  case 34: case 39: // '"', "'"
+    return this.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 this.readToken_slash();
+
+  case 37: case 42: // '%*'
+    return this.readToken_mult_modulo(code);
+
+  case 124: case 38: // '|&'
+    return this.readToken_pipe_amp(code);
+
+  case 94: // '^'
+    return this.readToken_caret();
+
+  case 43: case 45: // '+-'
+    return this.readToken_plus_min(code);
+
+  case 60: case 62: // '<>'
+    return this.readToken_lt_gt(code);
+
+  case 61: case 33: // '=!'
+    return this.readToken_eq_excl(code);
+
+  case 126: // '~'
+    return this.finishOp(tt.prefix, 1);
+  }
+
+  this.raise(this.pos, "Unexpected character '" + codePointToString(code) + "'");
+};
+
+pp.finishOp = function(type, size) {
+  var str = this.input.slice(this.pos, this.pos + size);
+  this.pos += size;
+  return this.finishToken(type, str);
+};
+
+var regexpUnicodeSupport = false;
+try { new RegExp("\uffff", "u"); regexpUnicodeSupport = true; }
+catch(e) {}
+
+// Parse a regular expression. Some context-awareness is necessary,
+// since a '/' inside a '[]' set does not end the expression.
+
+pp.readRegexp = function() {
+  var content = "", escaped, inClass, start = this.pos;
+  for (;;) {
+    if (this.pos >= this.input.length) this.raise(start, "Unterminated regular expression");
+    var ch = this.input.charAt(this.pos);
+    if (newline.test(ch)) this.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;
+    ++this.pos;
+  }
+  var content = this.input.slice(start, this.pos);
+  ++this.pos;
+  // Need to use `readWord1` because '\uXXXX' sequences are allowed
+  // here (don't ask).
+  var mods = this.readWord1();
+  var tmp = content;
+  if (mods) {
+    var validFlags = /^[gmsiy]*$/;
+    if (this.options.ecmaVersion >= 6) validFlags = /^[gmsiyu]*$/;
+    if (!validFlags.test(mods)) this.raise(start, "Invalid regular expression flag");
+    if (mods.indexOf('u') >= 0 && !regexpUnicodeSupport) {
+      // Replace each astral symbol and every Unicode escape sequence that
+      // possibly represents an astral symbol or a paired surrogate with a
+      // single ASCII symbol to avoid throwing on regular expressions that
+      // are only valid in combination with the `/u` flag.
+      // Note: replacing with the ASCII symbol `x` might cause false
+      // negatives in unlikely scenarios. For example, `[\u{61}-b]` is a
+      // perfectly valid pattern that is equivalent to `[a-b]`, but it would
+      // be replaced by `[x-b]` which throws an error.
+      tmp = tmp.replace(/\\u([a-fA-F0-9]{4})|\\u\{([0-9a-fA-F]+)\}|[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x")
+    }
+  }
+  // Detect invalid regular expressions.
+  try {
+    new RegExp(tmp);
+  } catch (e) {
+    if (e instanceof SyntaxError) this.raise(start, "Error parsing regular expression: " + e.message);
+    this.raise(e);
+  }
+  // Get a regular expression object for this pattern-flag pair, or `null` in
+  // case the current environment doesn't support the flags it uses.
+  try {
+    var value = new RegExp(content, mods);
+  } catch (err) {
+    value = null;
+  }
+  return this.finishToken(tt.regexp, {pattern: content, flags: mods, value: 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.
+
+pp.readInt = function(radix, len) {
+  var start = this.pos, total = 0;
+  for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+    var code = this.input.charCodeAt(this.pos), 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;
+    ++this.pos;
+    total = total * radix + val;
+  }
+  if (this.pos === start || len != null && this.pos - start !== len) return null;
+
+  return total;
+};
+
+pp.readRadixNumber = function(radix) {
+  this.pos += 2; // 0x
+  var val = this.readInt(radix);
+  if (val == null) this.raise(this.start + 2, "Expected number in radix " + radix);
+  if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
+  return this.finishToken(tt.num, val);
+};
+
+// Read an integer, octal integer, or floating-point number.
+
+pp.readNumber = function(startsWithDot) {
+  var start = this.pos, isFloat = false, octal = this.input.charCodeAt(this.pos) === 48;
+  if (!startsWithDot && this.readInt(10) === null) this.raise(start, "Invalid number");
+  if (this.input.charCodeAt(this.pos) === 46) {
+    ++this.pos;
+    this.readInt(10);
+    isFloat = true;
+  }
+  var next = this.input.charCodeAt(this.pos);
+  if (next === 69 || next === 101) { // 'eE'
+    next = this.input.charCodeAt(++this.pos);
+    if (next === 43 || next === 45) ++this.pos; // '+-'
+    if (this.readInt(10) === null) this.raise(start, "Invalid number");
+    isFloat = true;
+  }
+  if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
+
+  var str = this.input.slice(start, this.pos), val;
+  if (isFloat) val = parseFloat(str);
+  else if (!octal || str.length === 1) val = parseInt(str, 10);
+  else if (/[89]/.test(str) || this.strict) this.raise(start, "Invalid number");
+  else val = parseInt(str, 8);
+  return this.finishToken(tt.num, val);
+};
+
+// Read a string value, interpreting backslash-escapes.
+
+pp.readCodePoint = function() {
+  var ch = this.input.charCodeAt(this.pos), code;
+
+  if (ch === 123) {
+    if (this.options.ecmaVersion < 6) this.unexpected();
+    ++this.pos;
+    code = this.readHexChar(this.input.indexOf('}', this.pos) - this.pos);
+    ++this.pos;
+    if (code > 0x10FFFF) this.unexpected();
+  } else {
+    code = this.readHexChar(4);
+  }
+  return code;
+};
+
+function codePointToString(code) {
+  // UTF-16 Decoding
+  if (code <= 0xFFFF) return String.fromCharCode(code);
+  return String.fromCharCode(((code - 0x10000) >> 10) + 0xD800,
+                             ((code - 0x10000) & 1023) + 0xDC00);
+}
+
+pp.readString = function(quote) {
+  var out = "", chunkStart = ++this.pos;
+  for (;;) {
+    if (this.pos >= this.input.length) this.raise(this.start, "Unterminated string constant");
+    var ch = this.input.charCodeAt(this.pos);
+    if (ch === quote) break;
+    if (ch === 92) { // '\'
+      out += this.input.slice(chunkStart, this.pos);
+      out += this.readEscapedChar();
+      chunkStart = this.pos;
+    } else {
+      if (isNewLine(ch)) this.raise(this.start, "Unterminated string constant");
+      ++this.pos;
+    }
+  }
+  out += this.input.slice(chunkStart, this.pos++);
+  return this.finishToken(tt.string, out);
+};
+
+// Reads template string tokens.
+
+pp.readTmplToken = function() {
+  var out = "", chunkStart = this.pos;
+  for (;;) {
+    if (this.pos >= this.input.length) this.raise(this.start, "Unterminated template");
+    var ch = this.input.charCodeAt(this.pos);
+    if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) { // '`', '${'
+      if (this.pos === this.start && this.type === tt.template) {
+        if (ch === 36) {
+          this.pos += 2;
+          return this.finishToken(tt.dollarBraceL);
+        } else {
+          ++this.pos;
+          return this.finishToken(tt.backQuote);
+        }
+      }
+      out += this.input.slice(chunkStart, this.pos);
+      return this.finishToken(tt.template, out);
+    }
+    if (ch === 92) { // '\'
+      out += this.input.slice(chunkStart, this.pos);
+      out += this.readEscapedChar();
+      chunkStart = this.pos;
+    } else if (isNewLine(ch)) {
+      out += this.input.slice(chunkStart, this.pos);
+      ++this.pos;
+      if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
+        ++this.pos;
+        out += "\n";
+      } else {
+        out += String.fromCharCode(ch);
+      }
+      if (this.options.locations) {
+        ++this.curLine;
+        this.lineStart = this.pos;
+      }
+      chunkStart = this.pos;
+    } else {
+      ++this.pos;
+    }
+  }
+};
+
+// Used to read escaped characters
+
+pp.readEscapedChar = function() {
+  var ch = this.input.charCodeAt(++this.pos);
+  var octal = /^[0-7]+/.exec(this.input.slice(this.pos, this.pos + 3));
+  if (octal) octal = octal[0];
+  while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
+  if (octal === "0") octal = null;
+  ++this.pos;
+  if (octal) {
+    if (this.strict) this.raise(this.pos - 2, "Octal literal in strict mode");
+    this.pos += 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(this.readHexChar(2)); // 'x'
+    case 117: return codePointToString(this.readCodePoint()); // '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 (this.input.charCodeAt(this.pos) === 10) ++this.pos; // '\r\n'
+    case 10: // ' \n'
+      if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }
+      return "";
+    default: return String.fromCharCode(ch);
+    }
+  }
+};
+
+// Used to read character escape sequences ('\x', '\u', '\U').
+
+pp.readHexChar = function(len) {
+  var n = this.readInt(16, len);
+  if (n === null) this.raise(this.start, "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.
+//
+// Incrementally adds only escaped chars, adding other chunks as-is
+// as a micro-optimization.
+
+pp.readWord1 = function() {
+  containsEsc = false;
+  var word = "", first = true, chunkStart = this.pos;
+  var astral = this.options.ecmaVersion >= 6;
+  while (this.pos < this.input.length) {
+    var ch = this.fullCharCodeAtPos();
+    if (isIdentifierChar(ch, astral)) {
+      this.pos += ch <= 0xffff ? 1 : 2;
+    } else if (ch === 92) { // "\"
+      containsEsc = true;
+      word += this.input.slice(chunkStart, this.pos);
+      var escStart = this.pos;
+      if (this.input.charCodeAt(++this.pos) != 117) // "u"
+        this.raise(this.pos, "Expecting Unicode escape sequence \\uXXXX");
+      ++this.pos;
+      var esc = this.readCodePoint();
+      if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))
+        this.raise(escStart, "Invalid Unicode escape");
+      word += codePointToString(esc);
+      chunkStart = this.pos;
+    } else {
+      break;
+    }
+    first = false;
+  }
+  return word + this.input.slice(chunkStart, this.pos);
+};
+
+// Read an identifier or keyword token. Will check for reserved
+// words when necessary.
+
+pp.readWord = function() {
+  var word = this.readWord1();
+  var type = tt.name;
+  if ((this.options.ecmaVersion >= 6 || !containsEsc) && this.isKeyword(word))
+    type = keywordTypes[word];
+  return this.finishToken(type, word);
+};
+
+// 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.
+
+pp.raise = function(pos, message) {
+  var loc = getLineInfo(this.input, pos);
+  message += " (" + loc.line + ":" + loc.column + ")";
+  var err = new SyntaxError(message);
+  err.pos = pos; err.loc = loc; err.raisedAt = this.pos;
+  throw err;
+};
+
+pp.currentPos = function() {
+  return this.options.locations ? [this.start, this.startLoc] : this.start;
+};
+
+// ### Parser utilities
+
+// Start an AST node, attaching a start offset.
+
+var Node = exports.Node = function() {};
+
+var SourceLocation = exports.SourceLocation = function(p, start, end) {
+  this.start = start;
+  this.end = end;
+  if (p.sourceFile !== null) this.source = p.sourceFile;
+};
+
+pp.startNode = function() {
+  var node = new Node;
+  node.start = this.start;
+  if (this.options.locations)
+    node.loc = new SourceLocation(this, this.startLoc);
+  if (this.options.directSourceFile)
+    node.sourceFile = this.options.directSourceFile;
+  if (this.options.ranges)
+    node.range = [this.start, 0];
+  return node;
+};
+
+pp.startNodeAt = function(pos) {
+  var node = new Node, start = pos;
+  if (this.options.locations) {
+    node.loc = new SourceLocation(this, start[1]);
+    start = pos[0];
+  }
+  node.start = start;
+  if (this.options.directSourceFile)
+    node.sourceFile = this.options.directSourceFile;
+  if (this.options.ranges)
+    node.range = [start, 0];
+  return node;
+};
+
+// Finish an AST node, adding `type` and `end` properties.
+
+pp.finishNode = function(node, type) {
+  node.type = type;
+  node.end = this.lastTokEnd;
+  if (this.options.locations)
+    node.loc.end = this.lastTokEndLoc;
+  if (this.options.ranges)
+    node.range[1] = this.lastTokEnd;
+  return node;
+};
+
+// Finish node at given position
+
+pp.finishNodeAt = function(node, type, pos) {
+  if (this.options.locations) { node.loc.end = pos[1]; pos = pos[0]; }
+  node.type = type;
+  node.end = pos;
+  if (this.options.ranges)
+    node.range[1] = pos;
+  return node;
+};
+
+// Test whether a statement node is the string literal `"use strict"`.
+
+pp.isUseStrict = function(stmt) {
+  return this.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.
+
+pp.eat = function(type) {
+  if (this.type === type) {
+    this.next();
+    return true;
+  } else {
+    return false;
+  }
+};
+
+// Tests whether parsed token is a contextual keyword.
+
+pp.isContextual = function(name) {
+  return this.type === tt.name && this.value === name;
+};
+
+// Consumes contextual keyword if possible.
+
+pp.eatContextual = function(name) {
+  return this.value === name && this.eat(tt.name);
+};
+
+// Asserts that following token is given contextual keyword.
+
+pp.expectContextual = function(name) {
+  if (!this.eatContextual(name)) this.unexpected();
+};
+
+// Test whether a semicolon can be inserted at the current position.
+
+pp.canInsertSemicolon = function() {
+  return this.type === tt.eof ||
+    this.type === tt.braceR ||
+    newline.test(this.input.slice(this.lastTokEnd, this.start));
+};
+
+pp.insertSemicolon = function() {
+  if (this.canInsertSemicolon()) {
+    if (this.options.onInsertedSemicolon)
+      this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc)
+    return true;
+  }
+};
+
+// Consume a semicolon, or, failing that, see if we are allowed to
+// pretend that there is a semicolon at this position.
+
+pp.semicolon = function() {
+  if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected();
+};
+
+pp.afterTrailingComma = function(tokType) {
+  if (this.type == tokType) {
+    if (this.options.onTrailingComma)
+      this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc);
+    this.next();
+    return true;
+  }
+};
+
+// Expect a token of a given type. If found, consume it, otherwise,
+// raise an unexpected token error.
+
+pp.expect = function(type) {
+  this.eat(type) || this.unexpected();
+};
+
+// Raise an unexpected token error.
+
+pp.unexpected = function(pos) {
+  this.raise(pos != null ? pos : this.start, "Unexpected token");
+};
+
+// Convert existing expression atom to assignable pattern
+// if possible.
+
+pp.toAssignable = function(node, isBinding) {
+  if (this.options.ecmaVersion >= 6 && node) {
+    switch (node.type) {
+    case "Identifier":
+    case "ObjectPattern":
+    case "ArrayPattern":
+    case "AssignmentPattern":
+      break;
+
+    case "ObjectExpression":
+      node.type = "ObjectPattern";
+      for (var i = 0; i < node.properties.length; i++) {
+        var prop = node.properties[i];
+        if (prop.kind !== "init") this.raise(prop.key.start, "Object pattern can't contain getter or setter");
+        this.toAssignable(prop.value, isBinding);
+      }
+      break;
+
+    case "ArrayExpression":
+      node.type = "ArrayPattern";
+      this.toAssignableList(node.elements, isBinding);
+      break;
+
+    case "AssignmentExpression":
+      if (node.operator === "=") {
+        node.type = "AssignmentPattern";
+      } else {
+        this.raise(node.left.end, "Only '=' operator can be used for specifying default value.");
+      }
+      break;
+
+    case "MemberExpression":
+      if (!isBinding) break;
+
+    default:
+      this.raise(node.start, "Assigning to rvalue");
+    }
+  }
+  return node;
+};
+
+// Convert list of expression atoms to binding list.
+
+pp.toAssignableList = function(exprList, isBinding) {
+  var end = exprList.length;
+  if (end) {
+    var last = exprList[end - 1];
+    if (last && last.type == "RestElement") {
+      --end;
+    } else if (last && last.type == "SpreadElement") {
+      last.type = "RestElement";
+      var arg = last.argument;
+      this.toAssignable(arg, isBinding);
+      if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern")
+        this.unexpected(arg.start);
+      --end;
+    }
+  }
+  for (var i = 0; i < end; i++) {
+    var elt = exprList[i];
+    if (elt) this.toAssignable(elt, isBinding);
+  }
+  return exprList;
+};
+
+// Parses spread element.
+
+pp.parseSpread = function(refShorthandDefaultPos) {
+  var node = this.startNode();
+  this.next();
+  node.argument = this.parseMaybeAssign(refShorthandDefaultPos);
+  return this.finishNode(node, "SpreadElement");
+};
+
+pp.parseRest = function() {
+  var node = this.startNode();
+  this.next();
+  node.argument = this.type === tt.name || this.type === tt.bracketL ? this.parseBindingAtom() : this.unexpected();
+  return this.finishNode(node, "RestElement");
+};
+
+// Parses lvalue (assignable) atom.
+
+pp.parseBindingAtom = function() {
+  if (this.options.ecmaVersion < 6) return this.parseIdent();
+  switch (this.type) {
+  case tt.name:
+    return this.parseIdent();
+
+  case tt.bracketL:
+    var node = this.startNode();
+    this.next();
+    node.elements = this.parseBindingList(tt.bracketR, true, true);
+    return this.finishNode(node, "ArrayPattern");
+
+  case tt.braceL:
+    return this.parseObj(true);
+
+  default:
+    this.unexpected();
+  }
+};
+
+pp.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
+  var elts = [], first = true;
+  while (!this.eat(close)) {
+    if (first) first = false;
+    else this.expect(tt.comma);
+    if (allowEmpty && this.type === tt.comma) {
+      elts.push(null);
+    } else if (allowTrailingComma && this.afterTrailingComma(close)) {
+      break;
+    } else if (this.type === tt.ellipsis) {
+      elts.push(this.parseRest());
+      this.expect(close);
+      break;
+    } else {
+      elts.push(this.parseMaybeDefault());
+    }
+  }
+  return elts;
+};
+
+// Parses assignment pattern around given atom if possible.
+
+pp.parseMaybeDefault = function(startPos, left) {
+  startPos = startPos || this.currentPos();
+  left = left || this.parseBindingAtom();
+  if (!this.eat(tt.eq)) return left;
+  var node = this.startNodeAt(startPos);
+  node.operator = "=";
+  node.left = left;
+  node.right = this.parseMaybeAssign();
+  return this.finishNode(node, "AssignmentPattern");
+};
+
+// 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.
+
+pp.checkPropClash = function(prop, propHash) {
+  if (this.options.ecmaVersion >= 6) 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 ((this.strict || isGetSet) && other[kind] || !(isGetSet ^ other.init))
+      this.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.
+
+pp.checkLVal = function(expr, isBinding, checkClashes) {
+  switch (expr.type) {
+  case "Identifier":
+    if (this.strict && (isStrictBadIdWord(expr.name) || isStrictReservedWord(expr.name)))
+      this.raise(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode");
+    if (checkClashes) {
+      if (has(checkClashes, expr.name))
+        this.raise(expr.start, "Argument name clash in strict mode");
+      checkClashes[expr.name] = true;
+    }
+    break;
+
+  case "MemberExpression":
+    if (isBinding) this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " member expression");
+    break;
+
+  case "ObjectPattern":
+    for (var i = 0; i < expr.properties.length; i++)
+      this.checkLVal(expr.properties[i].value, isBinding, checkClashes);
+    break;
+
+  case "ArrayPattern":
+    for (var i = 0; i < expr.elements.length; i++) {
+      var elem = expr.elements[i];
+      if (elem) this.checkLVal(elem, isBinding, checkClashes);
+    }
+    break;
+
+  case "AssignmentPattern":
+    this.checkLVal(expr.left, isBinding, checkClashes);
+    break;
+
+  case "RestElement":
+    this.checkLVal(expr.argument, isBinding, checkClashes);
+    break;
+
+  default:
+    this.raise(expr.start, (isBinding ? "Binding" : "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.
+
+pp.parseTopLevel = function(node) {
+  var first = true;
+  if (!node.body) node.body = [];
+  while (this.type !== tt.eof) {
+    var stmt = this.parseStatement(true, true);
+    node.body.push(stmt);
+    if (first && this.isUseStrict(stmt)) this.setStrict(true);
+    first = false;
+  }
+  this.next();
+  if (this.options.ecmaVersion >= 6) {
+    node.sourceType = this.options.sourceType;
+  }
+  return this.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.
+
+pp.parseStatement = function(declaration, topLevel) {
+  var starttype = this.type, node = this.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 tt._break: case tt._continue: return this.parseBreakContinueStatement(node, starttype.keyword);
+  case tt._debugger: return this.parseDebuggerStatement(node);
+  case tt._do: return this.parseDoStatement(node);
+  case tt._for: return this.parseForStatement(node);
+  case tt._function:
+    if (!declaration && this.options.ecmaVersion >= 6) this.unexpected();
+    return this.parseFunctionStatement(node);
+  case tt._class:
+    if (!declaration) this.unexpected();
+    return this.parseClass(node, true);
+  case tt._if: return this.parseIfStatement(node);
+  case tt._return: return this.parseReturnStatement(node);
+  case tt._switch: return this.parseSwitchStatement(node);
+  case tt._throw: return this.parseThrowStatement(node);
+  case tt._try: return this.parseTryStatement(node);
+  case tt._let: case tt._const: if (!declaration) this.unexpected(); // NOTE: falls through to _var
+  case tt._var: return this.parseVarStatement(node, starttype);
+  case tt._while: return this.parseWhileStatement(node);
+  case tt._with: return this.parseWithStatement(node);
+  case tt.braceL: return this.parseBlock(); // no point creating a function for this
+  case tt.semi: return this.parseEmptyStatement(node);
+  case tt._export:
+  case tt._import:
+    if (!this.options.allowImportExportEverywhere) {
+      if (!topLevel)
+        this.raise(this.start, "'import' and 'export' may only appear at the top level");
+      if (!this.inModule)
+        this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
+    }
+    return starttype === tt._import ? this.parseImport(node) : this.parseExport(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 = this.value, expr = this.parseExpression();
+    if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon))
+      return this.parseLabeledStatement(node, maybeName, expr);
+    else return this.parseExpressionStatement(node, expr);
+  }
+};
+
+pp.parseBreakContinueStatement = function(node, keyword) {
+  var isBreak = keyword == "break";
+  this.next();
+  if (this.eat(tt.semi) || this.insertSemicolon()) node.label = null;
+  else if (this.type !== tt.name) this.unexpected();
+  else {
+    node.label = this.parseIdent();
+    this.semicolon();
+  }
+
+  // Verify that there is an actual destination to break or
+  // continue to.
+  for (var i = 0; i < this.labels.length; ++i) {
+    var lab = this.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 === this.labels.length) this.raise(node.start, "Unsyntactic " + keyword);
+  return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+};
+
+pp.parseDebuggerStatement = function(node) {
+  this.next();
+  this.semicolon();
+  return this.finishNode(node, "DebuggerStatement");
+};
+
+pp.parseDoStatement = function(node) {
+  this.next();
+  this.labels.push(loopLabel);
+  node.body = this.parseStatement(false);
+  this.labels.pop();
+  this.expect(tt._while);
+  node.test = this.parseParenExpression();
+  if (this.options.ecmaVersion >= 6)
+    this.eat(tt.semi);
+  else
+    this.semicolon();
+  return this.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.
+
+pp.parseForStatement = function(node) {
+  this.next();
+  this.labels.push(loopLabel);
+  this.expect(tt.parenL);
+  if (this.type === tt.semi) return this.parseFor(node, null);
+  if (this.type === tt._var || this.type === tt._let || this.type === tt._const) {
+    var init = this.startNode(), varKind = this.type;
+    this.next();
+    this.parseVar(init, true, varKind);
+    this.finishNode(init, "VariableDeclaration");
+    if ((this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init.declarations.length === 1 &&
+        !(varKind !== tt._var && init.declarations[0].init))
+      return this.parseForIn(node, init);
+    return this.parseFor(node, init);
+  }
+  var refShorthandDefaultPos = {start: 0};
+  var init = this.parseExpression(true, refShorthandDefaultPos);
+  if (this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
+    this.toAssignable(init);
+    this.checkLVal(init);
+    return this.parseForIn(node, init);
+  } else if (refShorthandDefaultPos.start) {
+    this.unexpected(refShorthandDefaultPos.start);
+  }
+  return this.parseFor(node, init);
+};
+
+pp.parseFunctionStatement = function(node) {
+  this.next();
+  return this.parseFunction(node, true);
+};
+
+pp.parseIfStatement = function(node) {
+  this.next();
+  node.test = this.parseParenExpression();
+  node.consequent = this.parseStatement(false);
+  node.alternate = this.eat(tt._else) ? this.parseStatement(false) : null;
+  return this.finishNode(node, "IfStatement");
+};
+
+pp.parseReturnStatement = function(node) {
+  if (!this.inFunction && !this.options.allowReturnOutsideFunction)
+    this.raise(this.start, "'return' outside of function");
+  this.next();
+
+  // In `return` (and `break`/`continue`), the keywords with
+  // optional arguments, we eagerly look for a semicolon or the
+  // possibility to insert one.
+
+  if (this.eat(tt.semi) || this.insertSemicolon()) node.argument = null;
+  else { node.argument = this.parseExpression(); this.semicolon(); }
+  return this.finishNode(node, "ReturnStatement");
+};
+
+pp.parseSwitchStatement = function(node) {
+  this.next();
+  node.discriminant = this.parseParenExpression();
+  node.cases = [];
+  this.expect(tt.braceL);
+  this.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; this.type != tt.braceR;) {
+    if (this.type === tt._case || this.type === tt._default) {
+      var isCase = this.type === tt._case;
+      if (cur) this.finishNode(cur, "SwitchCase");
+      node.cases.push(cur = this.startNode());
+      cur.consequent = [];
+      this.next();
+      if (isCase) cur.test = this.parseExpression();
+      else {
+        if (sawDefault) this.raise(this.lastTokStart, "Multiple default clauses"); sawDefault = true;
+        cur.test = null;
+      }
+      this.expect(tt.colon);
+    } else {
+      if (!cur) this.unexpected();
+      cur.consequent.push(this.parseStatement(true));
+    }
+  }
+  if (cur) this.finishNode(cur, "SwitchCase");
+  this.next(); // Closing brace
+  this.labels.pop();
+  return this.finishNode(node, "SwitchStatement");
+};
+
+pp.parseThrowStatement = function(node) {
+  this.next();
+  if (newline.test(this.input.slice(this.lastTokEnd, this.start)))
+    this.raise(this.lastTokEnd, "Illegal newline after throw");
+  node.argument = this.parseExpression();
+  this.semicolon();
+  return this.finishNode(node, "ThrowStatement");
+};
+
+// Reused empty array added for node fields that are always empty.
+
+var empty = [];
+
+
+pp.parseTryStatement = function(node) {
+  this.next();
+  node.block = this.parseBlock();
+  node.handler = null;
+  if (this.type === tt._catch) {
+    var clause = this.startNode();
+    this.next();
+    this.expect(tt.parenL);
+    clause.param = this.parseBindingAtom();
+    this.checkLVal(clause.param, true);
+    this.expect(tt.parenR);
+    clause.guard = null;
+    clause.body = this.parseBlock();
+    node.handler = this.finishNode(clause, "CatchClause");
+  }
+  node.guardedHandlers = empty;
+  node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;
+  if (!node.handler && !node.finalizer)
+    this.raise(node.start, "Missing catch or finally clause");
+  return this.finishNode(node, "TryStatement");
+};
+
+pp.parseVarStatement = function(node, kind) {
+  this.next();
+  this.parseVar(node, false, kind);
+  this.semicolon();
+  return this.finishNode(node, "VariableDeclaration");
+};
+
+pp.parseWhileStatement = function(node) {
+  this.next();
+  node.test = this.parseParenExpression();
+  this.labels.push(loopLabel);
+  node.body = this.parseStatement(false);
+  this.labels.pop();
+  return this.finishNode(node, "WhileStatement");
+};
+
+pp.parseWithStatement = function(node) {
+  if (this.strict) this.raise(this.start, "'with' in strict mode");
+  this.next();
+  node.object = this.parseParenExpression();
+  node.body = this.parseStatement(false);
+  return this.finishNode(node, "WithStatement");
+};
+
+pp.parseEmptyStatement = function(node) {
+  this.next();
+  return this.finishNode(node, "EmptyStatement");
+};
+
+pp.parseLabeledStatement = function(node, maybeName, expr) {
+  for (var i = 0; i < this.labels.length; ++i)
+    if (this.labels[i].name === maybeName) this.raise(expr.start, "Label '" + maybeName + "' is already declared");
+  var kind = this.type.isLoop ? "loop" : this.type === tt._switch ? "switch" : null;
+  this.labels.push({name: maybeName, kind: kind});
+  node.body = this.parseStatement(true);
+  this.labels.pop();
+  node.label = expr;
+  return this.finishNode(node, "LabeledStatement");
+};
+
+pp.parseExpressionStatement = function(node, expr) {
+  node.expression = expr;
+  this.semicolon();
+  return this.finishNode(node, "ExpressionStatement");
+};
+
+// Used for constructs like `switch` and `if` that insist on
+// parentheses around their expression.
+
+pp.parseParenExpression = function() {
+  this.expect(tt.parenL);
+  var val = this.parseExpression();
+  this.expect(tt.parenR);
+  return val;
+};
+
+// Parse a semicolon-enclosed block of statements, handling `"use
+// strict"` declarations when `allowStrict` is true (used for
+// function bodies).
+
+pp.parseBlock = function(allowStrict) {
+  var node = this.startNode(), first = true, oldStrict;
+  node.body = [];
+  this.expect(tt.braceL);
+  while (!this.eat(tt.braceR)) {
+    var stmt = this.parseStatement(true);
+    node.body.push(stmt);
+    if (first && allowStrict && this.isUseStrict(stmt)) {
+      oldStrict = this.strict;
+      this.setStrict(this.strict = true);
+    }
+    first = false;
+  }
+  if (oldStrict === false) this.setStrict(false);
+  return this.finishNode(node, "BlockStatement");
+};
+
+// Parse a regular `for` loop. The disambiguation code in
+// `parseStatement` will already have parsed the init statement or
+// expression.
+
+pp.parseFor = function(node, init) {
+  node.init = init;
+  this.expect(tt.semi);
+  node.test = this.type === tt.semi ? null : this.parseExpression();
+  this.expect(tt.semi);
+  node.update = this.type === tt.parenR ? null : this.parseExpression();
+  this.expect(tt.parenR);
+  node.body = this.parseStatement(false);
+  this.labels.pop();
+  return this.finishNode(node, "ForStatement");
+};
+
+// Parse a `for`/`in` and `for`/`of` loop, which are almost
+// same from parser's perspective.
+
+pp.parseForIn = function(node, init) {
+  var type = this.type === tt._in ? "ForInStatement" : "ForOfStatement";
+  this.next();
+  node.left = init;
+  node.right = this.parseExpression();
+  this.expect(tt.parenR);
+  node.body = this.parseStatement(false);
+  this.labels.pop();
+  return this.finishNode(node, type);
+};
+
+// Parse a list of variable declarations.
+
+pp.parseVar = function(node, noIn, kind) {
+  node.declarations = [];
+  node.kind = kind.keyword;
+  for (;;) {
+    var decl = this.startNode();
+    decl.id = this.parseBindingAtom();
+    this.checkLVal(decl.id, true);
+    if (this.eat(tt.eq)) {
+      decl.init = this.parseMaybeAssign(noIn);
+    } else if (kind === tt._const && !(this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
+      this.unexpected();
+    } else if (decl.id.type != "Identifier") {
+      this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value")
+    } else {
+      decl.init = null;
+    }
+    node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
+    if (!this.eat(tt.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 optional arguments are used to
+// forbid the `in` operator (in for loops initalization expressions)
+// and provide reference for storing '=' operator inside shorthand
+// property assignment in contexts where both object expression
+// and object pattern might appear (so it's possible to raise
+// delayed syntax error at correct position).
+
+pp.parseExpression = function(noIn, refShorthandDefaultPos) {
+  var start = this.currentPos();
+  var expr = this.parseMaybeAssign(noIn, refShorthandDefaultPos);
+  if (this.type === tt.comma) {
+    var node = this.startNodeAt(start);
+    node.expressions = [expr];
+    while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn, refShorthandDefaultPos));
+    return this.finishNode(node, "SequenceExpression");
+  }
+  return expr;
+};
+
+// Parse an assignment expression. This includes applications of
+// operators like `+=`.
+
+pp.parseMaybeAssign = function(noIn, refShorthandDefaultPos) {
+  if (this.type == tt._yield && this.inGenerator) return this.parseYield();
+
+  var failOnShorthandAssign;
+  if (!refShorthandDefaultPos) {
+    refShorthandDefaultPos = {start: 0};
+    failOnShorthandAssign = true;
+  } else {
+    failOnShorthandAssign = false;
+  }
+  var start = this.currentPos();
+  var left = this.parseMaybeConditional(noIn, refShorthandDefaultPos);
+  if (this.type.isAssign) {
+    var node = this.startNodeAt(start);
+    node.operator = this.value;
+    node.left = this.type === tt.eq ? this.toAssignable(left) : left;
+    refShorthandDefaultPos.start = 0; // reset because shorthand default was used correctly
+    this.checkLVal(left);
+    this.next();
+    node.right = this.parseMaybeAssign(noIn);
+    return this.finishNode(node, "AssignmentExpression");
+  } else if (failOnShorthandAssign && refShorthandDefaultPos.start) {
+    this.unexpected(refShorthandDefaultPos.start);
+  }
+  return left;
+};
+
+// Parse a ternary conditional (`?:`) operator.
+
+pp.parseMaybeConditional = function(noIn, refShorthandDefaultPos) {
+  var start = this.currentPos();
+  var expr = this.parseExprOps(noIn, refShorthandDefaultPos);
+  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
+  if (this.eat(tt.question)) {
+    var node = this.startNodeAt(start);
+    node.test = expr;
+    node.consequent = this.parseMaybeAssign();
+    this.expect(tt.colon);
+    node.alternate = this.parseMaybeAssign(noIn);
+    return this.finishNode(node, "ConditionalExpression");
+  }
+  return expr;
+};
+
+// Start the precedence parser.
+
+pp.parseExprOps = function(noIn, refShorthandDefaultPos) {
+  var start = this.currentPos();
+  var expr = this.parseMaybeUnary(refShorthandDefaultPos);
+  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
+  return this.parseExprOp(expr, start, -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.
+
+pp.parseExprOp = function(left, leftStart, minPrec, noIn) {
+  var prec = this.type.binop;
+  if (prec != null && (!noIn || this.type !== tt._in)) {
+    if (prec > minPrec) {
+      var node = this.startNodeAt(leftStart);
+      node.left = left;
+      node.operator = this.value;
+      var op = this.type;
+      this.next();
+      var start = this.currentPos();
+      node.right = this.parseExprOp(this.parseMaybeUnary(), start, prec, noIn);
+      this.finishNode(node, (op === tt.logicalOR || op === tt.logicalAND) ? "LogicalExpression" : "BinaryExpression");
+      return this.parseExprOp(node, leftStart, minPrec, noIn);
+    }
+  }
+  return left;
+};
+
+// Parse unary operators, both prefix and postfix.
+
+pp.parseMaybeUnary = function(refShorthandDefaultPos) {
+  if (this.type.prefix) {
+    var node = this.startNode(), update = this.type === tt.incDec;
+    node.operator = this.value;
+    node.prefix = true;
+    this.next();
+    node.argument = this.parseMaybeUnary();
+    if (refShorthandDefaultPos && refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
+    if (update) this.checkLVal(node.argument);
+    else if (this.strict && node.operator === "delete" &&
+             node.argument.type === "Identifier")
+      this.raise(node.start, "Deleting local variable in strict mode");
+    return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+  }
+  var start = this.currentPos();
+  var expr = this.parseExprSubscripts(refShorthandDefaultPos);
+  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
+  while (this.type.postfix && !this.canInsertSemicolon()) {
+    var node = this.startNodeAt(start);
+    node.operator = this.value;
+    node.prefix = false;
+    node.argument = expr;
+    this.checkLVal(expr);
+    this.next();
+    expr = this.finishNode(node, "UpdateExpression");
+  }
+  return expr;
+};
+
+// Parse call, dot, and `[]`-subscript expressions.
+
+pp.parseExprSubscripts = function(refShorthandDefaultPos) {
+  var start = this.currentPos();
+  var expr = this.parseExprAtom(refShorthandDefaultPos);
+  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
+  return this.parseSubscripts(expr, start);
+};
+
+pp.parseSubscripts = function(base, start, noCalls) {
+  if (this.eat(tt.dot)) {
+    var node = this.startNodeAt(start);
+    node.object = base;
+    node.property = this.parseIdent(true);
+    node.computed = false;
+    return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls);
+  } else if (this.eat(tt.bracketL)) {
+    var node = this.startNodeAt(start);
+    node.object = base;
+    node.property = this.parseExpression();
+    node.computed = true;
+    this.expect(tt.bracketR);
+    return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls);
+  } else if (!noCalls && this.eat(tt.parenL)) {
+    var node = this.startNodeAt(start);
+    node.callee = base;
+    node.arguments = this.parseExprList(tt.parenR, false);
+    return this.parseSubscripts(this.finishNode(node, "CallExpression"), start, noCalls);
+  } else if (this.type === tt.backQuote) {
+    var node = this.startNodeAt(start);
+    node.tag = base;
+    node.quasi = this.parseTemplate();
+    return this.parseSubscripts(this.finishNode(node, "TaggedTemplateExpression"), start, 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 `{}`.
+
+pp.parseExprAtom = function(refShorthandDefaultPos) {
+  switch (this.type) {
+  case tt._this:
+  case tt._super:
+    var type = this.type === tt._this ? "ThisExpression" : "SuperExpression";
+    var node = this.startNode();
+    this.next();
+    return this.finishNode(node, type);
+
+  case tt._yield:
+    if (this.inGenerator) unexpected();
+
+  case tt.name:
+    var start = this.currentPos();
+    var id = this.parseIdent(this.type !== tt.name);
+    if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
+      return this.parseArrowExpression(this.startNodeAt(start), [id]);
+    }
+    return id;
+
+  case tt.regexp:
+    var value = this.value;
+    var node = this.parseLiteral(value.value);
+    node.regex = {pattern: value.pattern, flags: value.flags};
+    return node;
+
+  case tt.num: case tt.string:
+    return this.parseLiteral(this.value);
+
+  case tt._null: case tt._true: case tt._false:
+    var node = this.startNode();
+    node.value = this.type === tt._null ? null : this.type === tt._true;
+    node.raw = this.type.keyword;
+    this.next();
+    return this.finishNode(node, "Literal");
+
+  case tt.parenL:
+    return this.parseParenAndDistinguishExpression();
+
+  case tt.bracketL:
+    var node = this.startNode();
+    this.next();
+    // check whether this is array comprehension or regular array
+    if (this.options.ecmaVersion >= 7 && this.type === tt._for) {
+      return this.parseComprehension(node, false);
+    }
+    node.elements = this.parseExprList(tt.bracketR, true, true, refShorthandDefaultPos);
+    return this.finishNode(node, "ArrayExpression");
+
+  case tt.braceL:
+    return this.parseObj(false, refShorthandDefaultPos);
+
+  case tt._function:
+    var node = this.startNode();
+    this.next();
+    return this.parseFunction(node, false);
+
+  case tt._class:
+    return this.parseClass(this.startNode(), false);
+
+  case tt._new:
+    return this.parseNew();
+
+  case tt.backQuote:
+    return this.parseTemplate();
+
+  default:
+    this.unexpected();
+  }
+};
+
+pp.parseLiteral = function(value) {
+  var node = this.startNode();
+  node.value = value;
+  node.raw = this.input.slice(this.start, this.end);
+  this.next();
+  return this.finishNode(node, "Literal");
+};
+
+pp.parseParenAndDistinguishExpression = function() {
+  var start = this.currentPos(), val;
+  if (this.options.ecmaVersion >= 6) {
+    this.next();
+
+    if (this.options.ecmaVersion >= 7 && this.type === tt._for) {
+      return this.parseComprehension(this.startNodeAt(start), true);
+    }
+
+    var innerStart = this.currentPos(), exprList = [], first = true;
+    var refShorthandDefaultPos = {start: 0}, spreadStart, innerParenStart;
+    while (this.type !== tt.parenR) {
+      first ? first = false : this.expect(tt.comma);
+      if (this.type === tt.ellipsis) {
+        spreadStart = this.start;
+        exprList.push(this.parseRest());
+        break;
+      } else {
+        if (this.type === tt.parenL && !innerParenStart) {
+          innerParenStart = this.start;
+        }
+        exprList.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
+      }
+    }
+    var innerEnd = this.currentPos();
+    this.expect(tt.parenR);
+
+    if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
+      if (innerParenStart) this.unexpected(innerParenStart);
+      return this.parseArrowExpression(this.startNodeAt(start), exprList);
+    }
+
+    if (!exprList.length) this.unexpected(this.lastTokStart);
+    if (spreadStart) this.unexpected(spreadStart);
+    if (refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
+
+    if (exprList.length > 1) {
+      val = this.startNodeAt(innerStart);
+      val.expressions = exprList;
+      this.finishNodeAt(val, "SequenceExpression", innerEnd);
+    } else {
+      val = exprList[0];
+    }
+  } else {
+    val = this.parseParenExpression();
+  }
+
+  if (this.options.preserveParens) {
+    var par = this.startNodeAt(start);
+    par.expression = val;
+    return this.finishNode(par, "ParenthesizedExpression");
+  } else {
+    return val;
+  }
+};
+
+// 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
+
+pp.parseNew = function() {
+  var node = this.startNode();
+  this.next();
+  var start = this.currentPos();
+  node.callee = this.parseSubscripts(this.parseExprAtom(), start, true);
+  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false);
+  else node.arguments = empty;
+  return this.finishNode(node, "NewExpression");
+};
+
+// Parse template expression.
+
+pp.parseTemplateElement = function() {
+  var elem = this.startNode();
+  elem.value = {
+    raw: this.input.slice(this.start, this.end),
+    cooked: this.value
+  };
+  this.next();
+  elem.tail = this.type === tt.backQuote;
+  return this.finishNode(elem, "TemplateElement");
+};
+
+pp.parseTemplate = function() {
+  var node = this.startNode();
+  this.next();
+  node.expressions = [];
+  var curElt = this.parseTemplateElement();
+  node.quasis = [curElt];
+  while (!curElt.tail) {
+    this.expect(tt.dollarBraceL);
+    node.expressions.push(this.parseExpression());
+    this.expect(tt.braceR);
+    node.quasis.push(curElt = this.parseTemplateElement());
+  }
+  this.next();
+  return this.finishNode(node, "TemplateLiteral");
+};
+
+// Parse an object literal or binding pattern.
+
+pp.parseObj = function(isPattern, refShorthandDefaultPos) {
+  var node = this.startNode(), first = true, propHash = {};
+  node.properties = [];
+  this.next();
+  while (!this.eat(tt.braceR)) {
+    if (!first) {
+      this.expect(tt.comma);
+      if (this.afterTrailingComma(tt.braceR)) break;
+    } else first = false;
+
+    var prop = this.startNode(), isGenerator, start;
+    if (this.options.ecmaVersion >= 6) {
+      prop.method = false;
+      prop.shorthand = false;
+      if (isPattern || refShorthandDefaultPos)
+        start = this.currentPos();
+      if (!isPattern)
+        isGenerator = this.eat(tt.star);
+    }
+    this.parsePropertyName(prop);
+    if (this.eat(tt.colon)) {
+      prop.value = isPattern ? this.parseMaybeDefault() : this.parseMaybeAssign(false, refShorthandDefaultPos);
+      prop.kind = "init";
+    } else if (this.options.ecmaVersion >= 6 && this.type === tt.parenL) {
+      if (isPattern) this.unexpected();
+      prop.kind = "init";
+      prop.method = true;
+      prop.value = this.parseMethod(isGenerator);
+    } else if (this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
+               (prop.key.name === "get" || prop.key.name === "set") &&
+               (this.type != tt.comma && this.type != tt.braceR)) {
+      if (isGenerator || isPattern) this.unexpected();
+      prop.kind = prop.key.name;
+      this.parsePropertyName(prop);
+      prop.value = this.parseMethod(false);
+    } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
+      prop.kind = "init";
+      if (isPattern) {
+        if (this.isKeyword(prop.key.name) ||
+            (this.strict && (isStrictBadIdWord(prop.key.name) || isStrictReservedWord(prop.key.name))) ||
+            (!this.options.allowReserved && this.isReservedWord(prop.key.name)))
+          this.raise(prop.key.start, "Binding " + prop.key.name);
+        prop.value = this.parseMaybeDefault(start, prop.key);
+      } else if (this.type === tt.eq && refShorthandDefaultPos) {
+        if (!refShorthandDefaultPos.start)
+          refShorthandDefaultPos.start = this.start;
+        prop.value = this.parseMaybeDefault(start, prop.key);
+      } else {
+        prop.value = prop.key;
+      }
+      prop.shorthand = true;
+    } else this.unexpected();
+
+    this.checkPropClash(prop, propHash);
+    node.properties.push(this.finishNode(prop, "Property"));
+  }
+  return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");
+};
+
+pp.parsePropertyName = function(prop) {
+  if (this.options.ecmaVersion >= 6) {
+    if (this.eat(tt.bracketL)) {
+      prop.computed = true;
+      prop.key = this.parseExpression();
+      this.expect(tt.bracketR);
+      return;
+    } else {
+      prop.computed = false;
+    }
+  }
+  prop.key = (this.type === tt.num || this.type === tt.string) ? this.parseExprAtom() : this.parseIdent(true);
+};
+
+// Initialize empty function node.
+
+pp.initFunction = function(node) {
+  node.id = null;
+  if (this.options.ecmaVersion >= 6) {
+    node.generator = false;
+    node.expression = false;
+  }
+};
+
+// Parse a function declaration or literal (depending on the
+// `isStatement` parameter).
+
+pp.parseFunction = function(node, isStatement, allowExpressionBody) {
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 6) {
+    node.generator = this.eat(tt.star);
+  }
+  if (isStatement || this.type === tt.name) {
+    node.id = this.parseIdent();
+  }
+  this.expect(tt.parenL);
+  node.params = this.parseBindingList(tt.parenR, false, false);
+  this.parseFunctionBody(node, allowExpressionBody);
+  return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+};
+
+// Parse object or class method.
+
+pp.parseMethod = function(isGenerator) {
+  var node = this.startNode();
+  this.initFunction(node);
+  this.expect(tt.parenL);
+  node.params = this.parseBindingList(tt.parenR, false, false);
+  var allowExpressionBody;
+  if (this.options.ecmaVersion >= 6) {
+    node.generator = isGenerator;
+    allowExpressionBody = true;
+  } else {
+    allowExpressionBody = false;
+  }
+  this.parseFunctionBody(node, allowExpressionBody);
+  return this.finishNode(node, "FunctionExpression");
+};
+
+// Parse arrow function expression with given parameters.
+
+pp.parseArrowExpression = function(node, params) {
+  this.initFunction(node);
+  node.params = this.toAssignableList(params, true);
+  this.parseFunctionBody(node, true);
+  return this.finishNode(node, "ArrowFunctionExpression");
+};
+
+// Parse function body and check parameters.
+
+pp.parseFunctionBody = function(node, allowExpression) {
+  var isExpression = allowExpression && this.type !== tt.braceL;
+
+  if (isExpression) {
+    node.body = this.parseMaybeAssign();
+    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 = this.inFunction, oldInGen = this.inGenerator, oldLabels = this.labels;
+    this.inFunction = true; this.inGenerator = node.generator; this.labels = [];
+    node.body = this.parseBlock(true);
+    node.expression = false;
+    this.inFunction = oldInFunc; this.inGenerator = oldInGen; this.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 (this.strict || !isExpression && node.body.body.length && this.isUseStrict(node.body.body[0])) {
+    var nameHash = {}, oldStrict = this.strict;
+    this.strict = true;
+    if (node.id)
+      this.checkLVal(node.id, true);
+    for (var i = 0; i < node.params.length; i++)
+      this.checkLVal(node.params[i], true, nameHash);
+    this.strict = oldStrict;
+  }
+};
+
+// Parse a class declaration or literal (depending on the
+// `isStatement` parameter).
+
+pp.parseClass = function(node, isStatement) {
+  this.next();
+  node.id = this.type === tt.name ? this.parseIdent() : isStatement ? this.unexpected() : null;
+  node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null;
+  var classBody = this.startNode();
+  classBody.body = [];
+  this.expect(tt.braceL);
+  while (!this.eat(tt.braceR)) {
+    if (this.eat(tt.semi)) continue;
+    var method = this.startNode();
+    var isGenerator = this.eat(tt.star);
+    this.parsePropertyName(method);
+    if (this.type !== tt.parenL && !method.computed && method.key.type === "Identifier" &&
+        method.key.name === "static") {
+      if (isGenerator) this.unexpected();
+      method['static'] = true;
+      isGenerator = this.eat(tt.star);
+      this.parsePropertyName(method);
+    } else {
+      method['static'] = false;
+    }
+    method.kind = "method";
+    if (!method.computed && !isGenerator) {
+      if (method.key.type === "Identifier") {
+        if (this.type !== tt.parenL && (method.key.name === "get" || method.key.name === "set")) {
+          method.kind = method.key.name;
+          this.parsePropertyName(method);
+        } else if (!method['static'] && method.key.name === "constructor") {
+          method.kind = "constructor";
+        }
+      } else if (!method['static'] && method.key.type === "Literal" && method.key.value === "constructor") {
+        method.kind = "constructor";
+      }
+    }
+    method.value = this.parseMethod(isGenerator);
+    classBody.body.push(this.finishNode(method, "MethodDefinition"));
+  }
+  node.body = this.finishNode(classBody, "ClassBody");
+  return this.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).
+
+pp.parseExprList = function(close, allowTrailingComma, allowEmpty, refShorthandDefaultPos) {
+  var elts = [], first = true;
+  while (!this.eat(close)) {
+    if (!first) {
+      this.expect(tt.comma);
+      if (allowTrailingComma && this.afterTrailingComma(close)) break;
+    } else first = false;
+
+    if (allowEmpty && this.type === tt.comma) {
+      elts.push(null);
+    } else {
+      if (this.type === tt.ellipsis)
+        elts.push(this.parseSpread(refShorthandDefaultPos));
+      else
+        elts.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
+    }
+  }
+  return elts;
+};
+
+// Parse the next token as an identifier. If `liberal` is true (used
+// when parsing properties), it will also convert keywords into
+// identifiers.
+
+pp.parseIdent = function(liberal) {
+  var node = this.startNode();
+  if (liberal && this.options.allowReserved == "never") liberal = false;
+  if (this.type === tt.name) {
+    if (!liberal &&
+        ((!this.options.allowReserved && this.isReservedWord(this.value)) ||
+         (this.strict && isStrictReservedWord(this.value)) &&
+         (this.options.ecmaVersion >= 6 || 
+          this.input.slice(this.start, this.end).indexOf("\\") == -1)))
+      this.raise(this.start, "The keyword '" + this.value + "' is reserved");
+    node.name = this.value;
+  } else if (liberal && this.type.keyword) {
+    node.name = this.type.keyword;
+  } else {
+    this.unexpected();
+  }
+  this.next();
+  return this.finishNode(node, "Identifier");
+};
+
+// Parses module export declaration.
+
+pp.parseExport = function(node) {
+  this.next();
+  // export * from '...';
+  if (this.eat(tt.star)) {
+    this.expectContextual("from");
+    node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
+    this.semicolon();
+    return this.finishNode(node, "ExportAllDeclaration");
+  }
+  if (this.eat(tt._default)) { // export default ...;
+    var expr = this.parseMaybeAssign();
+    if (expr.id) {
+      switch (expr.type) {
+      case "FunctionExpression": expr.type = "FunctionDeclaration"; break;
+      case "ClassExpression": expr.type = "ClassDeclaration"; break;
+      }
+    }
+    node.declaration = expr;
+    this.semicolon();
+    return this.finishNode(node, "ExportDefaultDeclaration");
+  }
+  // export var|const|let|function|class ...;
+  if (this.type.keyword) {
+    node.declaration = this.parseStatement(true);
+    node.specifiers = [];
+    node.source = null;
+  } else { // export { x, y as z } [from '...'];
+    node.declaration = null;
+    node.specifiers = this.parseExportSpecifiers();
+    if (this.eatContextual("from")) {
+      node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
+    } else {
+      node.source = null;
+    }
+    this.semicolon();
+  }
+  return this.finishNode(node, "ExportNamedDeclaration");
+};
+
+// Parses a comma-separated list of module exports.
+
+pp.parseExportSpecifiers = function() {
+  var nodes = [], first = true;
+  // export { x, y as z } [from '...']
+  this.expect(tt.braceL);
+  while (!this.eat(tt.braceR)) {
+    if (!first) {
+      this.expect(tt.comma);
+      if (this.afterTrailingComma(tt.braceR)) break;
+    } else first = false;
+
+    var node = this.startNode();
+    node.local = this.parseIdent(this.type === tt._default);
+    node.exported = this.eatContextual("as") ? this.parseIdent(true) : node.local;
+    nodes.push(this.finishNode(node, "ExportSpecifier"));
+  }
+  return nodes;
+};
+
+// Parses import declaration.
+
+pp.parseImport = function(node) {
+  this.next();
+  // import '...';
+  if (this.type === tt.string) {
+    node.specifiers = empty;
+    node.source = this.parseExprAtom();
+    node.kind = "";
+  } else {
+    node.specifiers = this.parseImportSpecifiers();
+    this.expectContextual("from");
+    node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
+  }
+  this.semicolon();
+  return this.finishNode(node, "ImportDeclaration");
+};
+
+// Parses a comma-separated list of module imports.
+
+pp.parseImportSpecifiers = function() {
+  var nodes = [], first = true;
+  if (this.type === tt.name) {
+    // import defaultObj, { x, y as z } from '...'
+    var node = this.startNode();
+    node.local = this.parseIdent();
+    this.checkLVal(node.local, true);
+    nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
+    if (!this.eat(tt.comma)) return nodes;
+  }
+  if (this.type === tt.star) {
+    var node = this.startNode();
+    this.next();
+    this.expectContextual("as");
+    node.local = this.parseIdent();
+    this.checkLVal(node.local, true);
+    nodes.push(this.finishNode(node, "ImportNamespaceSpecifier"));
+    return nodes;
+  }
+  this.expect(tt.braceL);
+  while (!this.eat(tt.braceR)) {
+    if (!first) {
+      this.expect(tt.comma);
+      if (this.afterTrailingComma(tt.braceR)) break;
+    } else first = false;
+
+    var node = this.startNode();
+    node.imported = this.parseIdent(true);
+    node.local = this.eatContextual("as") ? this.parseIdent() : node.imported;
+    this.checkLVal(node.local, true);
+    nodes.push(this.finishNode(node, "ImportSpecifier"));
+  }
+  return nodes;
+};
+
+// Parses yield expression inside generator.
+
+pp.parseYield = function() {
+  var node = this.startNode();
+  this.next();
+  if (this.type == tt.semi || this.canInsertSemicolon() || (this.type != tt.star && !this.type.startsExpr)) {
+    node.delegate = false;
+    node.argument = null;
+  } else {
+    node.delegate = this.eat(tt.star);
+    node.argument = this.parseMaybeAssign();
+  }
+  return this.finishNode(node, "YieldExpression");
+};
+
+// Parses array and generator comprehensions.
+
+pp.parseComprehension = function(node, isGenerator) {
+  node.blocks = [];
+  while (this.type === tt._for) {
+    var block = this.startNode();
+    this.next();
+    this.expect(tt.parenL);
+    block.left = this.parseBindingAtom();
+    this.checkLVal(block.left, true);
+    this.expectContextual("of");
+    block.right = this.parseExpression();
+    this.expect(tt.parenR);
+    node.blocks.push(this.finishNode(block, "ComprehensionBlock"));
+  }
+  node.filter = this.eat(tt._if) ? this.parseParenExpression() : null;
+  node.body = this.parseExpression();
+  this.expect(isGenerator ? tt.parenR : tt.bracketR);
+  node.generator = isGenerator;
+  return this.finishNode(node, "ComprehensionExpression");
+};
diff --git a/src/tokentype.js b/src/tokentype.js
new file mode 100644
index 0000000000..5f2bdb2380
--- /dev/null
+++ b/src/tokentype.js
@@ -0,0 +1,142 @@
+// ## 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.
+
+// 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.
+
+export class TokenType {
+  constructor(label, conf = {}) {
+    this.label = label
+    this.keyword = conf.keyword
+    this.beforeExpr = !!conf.beforeExpr
+    this.startsExpr = !!conf.startsExpr
+    this.isLoop = !!conf.isLoop
+    this.isAssign = !!conf.isAssign
+    this.prefix = !!conf.prefix
+    this.postfix = !!conf.postfix
+    this.binop = conf.binop || null
+    this.updateContext = null
+  }
+}
+
+function binop(name, prec) {
+  return new TokenType(name, {beforeExpr: true, binop: prec})
+}
+const beforeExpr = {beforeExpr: true}, startsExpr = {startsExpr: true}
+
+export const types = {
+  num: new TokenType("num", startsExpr),
+  regexp: new TokenType("regexp", startsExpr),
+  string: new TokenType("string", startsExpr),
+  name: new TokenType("name", startsExpr),
+  eof: new TokenType("eof"),
+
+  // Punctuation token types.
+  bracketL: new TokenType("[", {beforeExpr: true, startsExpr: true}),
+  bracketR: new TokenType("]"),
+  braceL: new TokenType("{", {beforeExpr: true, startsExpr: true}),
+  braceR: new TokenType("}"),
+  parenL: new TokenType("(", {beforeExpr: true, startsExpr: true}),
+  parenR: new TokenType(")"),
+  comma: new TokenType(",", beforeExpr),
+  semi: new TokenType(";", beforeExpr),
+  colon: new TokenType(":", beforeExpr),
+  dot: new TokenType("."),
+  question: new TokenType("?", beforeExpr),
+  arrow: new TokenType("=>", beforeExpr),
+  template: new TokenType("template"),
+  ellipsis: new TokenType("...", beforeExpr),
+  backQuote: new TokenType("`", startsExpr),
+  dollarBraceL: new TokenType("${", {beforeExpr: true, startsExpr: 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.
+  //
+  // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as
+  // binary operators with a very low precedence, that should result
+  // in AssignmentExpression nodes.
+
+  eq: new TokenType("=", {beforeExpr: true, isAssign: true}),
+  assign: new TokenType("_=", {beforeExpr: true, isAssign: true}),
+  incDec: new TokenType("++/--", {prefix: true, postfix: true, startsExpr: true}),
+  prefix: new TokenType("prefix", {beforeExpr: true, prefix: true, startsExpr: true}),
+  logicalOR: binop("||", 1),
+  logicalAND: binop("&&", 2),
+  bitwiseOR: binop("|", 3),
+  bitwiseXOR: binop("^", 4),
+  bitwiseAND: binop("&", 5),
+  equality: binop("==/!=", 6),
+  relational: binop("</>", 7),
+  bitShift: binop("<</>>", 8),
+  plusMin: new TokenType("+/-", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),
+  modulo: binop("%", 10),
+  star: binop("*", 10),
+  slash: binop("/", 10)
+}
+
+// Map keyword names to token types.
+
+export const keywords = {}
+
+// Succinct definitions of keyword token types
+function kw(name, options = {}) {
+  options.keyword = name
+  keywords[name] = types["_" + name] = new TokenType(name, options)
+}
+
+kw("break")
+kw("case", beforeExpr)
+kw("catch")
+kw("continue")
+kw("debugger")
+kw("default")
+kw("do", {isLoop: true})
+kw("else", beforeExpr)
+kw("finally")
+kw("for", {isLoop: true})
+kw("function")
+kw("if")
+kw("return", beforeExpr)
+kw("switch")
+kw("throw", beforeExpr)
+kw("try")
+kw("var")
+kw("let")
+kw("const")
+kw("while", {isLoop: true})
+kw("with")
+kw("new", {beforeExpr: true, startsExpr: true})
+kw("this", startsExpr)
+kw("super", startsExpr)
+kw("class")
+kw("extends", beforeExpr)
+kw("export")
+kw("import")
+kw("yield", {beforeExpr: true, startsExpr: true})
+kw("null", startsExpr)
+kw("true", startsExpr)
+kw("false", startsExpr)
+kw("in", {beforeExpr: true, binop: 7})
+kw("instanceof", {beforeExpr: true, binop: 7})
+kw("typeof", {beforeExpr: true, prefix: true, startsExpr: true})
+kw("void", {beforeExpr: true, prefix: true, startsExpr: true})
+kw("delete", {beforeExpr: true, prefix: true, startsExpr: true})
diff --git a/src/util.js b/src/util.js
new file mode 100644
index 0000000000..3517f8d212
--- /dev/null
+++ b/src/util.js
@@ -0,0 +1,9 @@
+export function isArray(obj) {
+  return Object.prototype.toString.call(obj) === "[object Array]"
+}
+
+// Checks if an object has a property.
+
+export function has(obj, propName) {
+  return Object.prototype.hasOwnProperty.call(obj, propName)
+}

From 93b919c1a04023f662ee084530735a853aed9068 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 19 Mar 2015 15:49:58 +0100
Subject: [PATCH 22/43] Split out identifier-related code

---
 src/identifier.js | 129 ++++++++++++++++++++++++++++++++++++++++
 src/index.js      | 148 ++--------------------------------------------
 2 files changed, 133 insertions(+), 144 deletions(-)
 create mode 100644 src/identifier.js

diff --git a/src/identifier.js b/src/identifier.js
new file mode 100644
index 0000000000..ea009f6fb1
--- /dev/null
+++ b/src/identifier.js
@@ -0,0 +1,129 @@
+// 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);
+}
+
+// Reserved word lists for various dialects of the language
+
+export const reservedWords = {
+  3: 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"),
+  5: makePredicate("class enum extends super const export import"),
+  6: makePredicate("enum await"),
+  strict: makePredicate("implements interface let package private protected public static yield"),
+  strictBind: 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";
+
+export const keywords = {
+  5: makePredicate(ecma5AndLessKeywords),
+  6: makePredicate(ecma5AndLessKeywords + " let const class extends export import yield super")
+}
+
+// ## 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\u2118-\u211d\u2124\u2126\u2128\u212a-\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\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\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 = "\u200c\u200d\xb7\u0300-\u036f\u0387\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\u1369-\u1371\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-\u19da\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\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 + "]");
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+
+// These are a run-length and offset encoded representation of the
+// >0xffff code points that are a valid part of identifiers. The
+// offset starts at 0x10000, and each pair of numbers represents an
+// offset to the next range, and then a size of the range. They were
+// generated by tools/generate-identifier-regex.js
+var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,17,26,6,37,11,29,3,35,5,7,2,4,43,157,99,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,98,21,11,25,71,55,7,1,65,0,16,3,2,2,2,26,45,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,955,52,76,44,33,24,27,35,42,34,4,0,13,47,15,3,22,0,38,17,2,24,133,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,32,4,287,47,21,1,2,0,185,46,82,47,21,0,60,42,502,63,32,0,449,56,1288,920,104,110,2962,1070,13266,568,8,30,114,29,19,47,17,3,32,20,6,18,881,68,12,0,67,12,16481,1,3071,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,1340,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,16355,541];
+var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,1306,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,52,0,13,2,49,13,16,9,83,11,168,11,6,9,8,2,57,0,2,6,3,1,3,2,10,0,11,1,3,6,4,4,316,19,13,9,214,6,3,8,112,16,16,9,82,12,9,9,535,9,20855,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,4305,6,792618,239];
+
+// This has a complexity linear to the value of the code. The
+// assumption is that looking up astral identifier characters is
+// rare.
+function isInAstralSet(code, set) {
+  var pos = 0x10000;
+  for (var i = 0; i < set.length; i += 2) {
+    pos += set[i];
+    if (pos > code) return false;
+    pos += set[i + 1];
+    if (pos >= code) return true;
+  }
+}
+
+// Test whether a given character code starts an identifier.
+
+export function isIdentifierStart(code, astral) {
+  if (code < 65) return code === 36;
+  if (code < 91) return true;
+  if (code < 97) return code === 95;
+  if (code < 123) return true;
+  if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  if (astral === false) return false;
+  return isInAstralSet(code, astralIdentifierStartCodes);
+}
+
+// Test whether a given character is part of an identifier.
+
+export function isIdentifierChar(code, astral) {
+  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;
+  if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  if (astral === false) return false;
+  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+}
diff --git a/src/index.js b/src/index.js
index cdb1db1a7f..d49aff7c03 100644
--- a/src/index.js
+++ b/src/index.js
@@ -218,119 +218,6 @@ class Token {
   }
 }
 
-// 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");
-
-// ECMAScript 6 reserved words.
-
-var isReservedWord6 = makePredicate("enum await");
-
-// 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 super");
-
-// ## 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\u2118-\u211d\u2124\u2126\u2128\u212a-\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\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\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 = "\u200c\u200d\xb7\u0300-\u036f\u0387\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\u1369-\u1371\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-\u19da\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\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 + "]");
-nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
-
-// These are a run-length and offset encoded representation of the
-// >0xffff code points that are a valid part of identifiers. The
-// offset starts at 0x10000, and each pair of numbers represents an
-// offset to the next range, and then a size of the range. They were
-// generated by tools/generate-identifier-regex.js
-var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,17,26,6,37,11,29,3,35,5,7,2,4,43,157,99,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,98,21,11,25,71,55,7,1,65,0,16,3,2,2,2,26,45,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,955,52,76,44,33,24,27,35,42,34,4,0,13,47,15,3,22,0,38,17,2,24,133,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,32,4,287,47,21,1,2,0,185,46,82,47,21,0,60,42,502,63,32,0,449,56,1288,920,104,110,2962,1070,13266,568,8,30,114,29,19,47,17,3,32,20,6,18,881,68,12,0,67,12,16481,1,3071,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,1340,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,16355,541];
-var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,1306,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,52,0,13,2,49,13,16,9,83,11,168,11,6,9,8,2,57,0,2,6,3,1,3,2,10,0,11,1,3,6,4,4,316,19,13,9,214,6,3,8,112,16,16,9,82,12,9,9,535,9,20855,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,4305,6,792618,239];
-
-// This has a complexity linear to the value of the code. The
-// assumption is that looking up astral identifier characters is
-// rare.
-function isInAstralSet(code, set) {
-  var pos = 0x10000;
-  for (var i = 0; i < set.length; i += 2) {
-    pos += set[i];
-    if (pos > code) return false;
-    pos += set[i + 1];
-    if (pos >= code) return true;
-  }
-}
-
 // Whether a single character denotes a newline.
 
 var newline = exports.newline = /[\n\r\u2028\u2029]/;
@@ -344,32 +231,6 @@ var isNewLine = exports.isNewLine = function(code) {
 
 var lineBreak = exports.lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
 
-// Test whether a given character code starts an identifier.
-
-var isIdentifierStart = exports.isIdentifierStart = function(code, astral) {
-  if (code < 65) return code === 36;
-  if (code < 91) return true;
-  if (code < 97) return code === 95;
-  if (code < 123) return true;
-  if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  if (astral === false) return false;
-  return isInAstralSet(code, astralIdentifierStartCodes);
-};
-
-// Test whether a given character is part of an identifier.
-
-var isIdentifierChar = exports.isIdentifierChar = function(code, astral) {
-  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;
-  if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  if (astral === false) return false;
-  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
-};
-
 // ## Tokenizer
 
 // These are used when `options.locations` is on, for the
@@ -404,15 +265,14 @@ Position.prototype.offset = function(n) {
 //
 // [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser
 
+import {reservedWords, keywords, isIdentifierStart, isIdentifierChar} from "./identifier"
+
 var Parser = exports.Parser = function(options, input, startPos) {
   this.options = options
   this.loadPlugins(this.options.plugins)
   this.sourceFile = this.options.sourceFile || null
-  this.isKeyword = this.options.ecmaVersion >= 6 ? isEcma6Keyword : isEcma5AndLessKeyword
-  this.isReservedWord =
-      this.options.ecmaVersion === 3 ? isReservedWord3
-    : this.options.ecmaVersion === 5 ? isReservedWord5
-    : isReservedWord6
+  this.isKeyword = keywords[this.options.ecmaVersion >= 6 ? 6 : 5]
+  this.isReservedWord = reservedWords[this.options.ecmaVersion]
   this.input = input
 
   // Set up token state

From fec42cb5962aa665c7caf4b7e67fad6f0da7e857 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 19 Mar 2015 16:17:43 +0100
Subject: [PATCH 23/43] Move tokenizer into modules

---
 src/state.js        |  56 ++++
 src/tokencontext.js | 102 +++++++
 src/tokenize.js     | 724 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 882 insertions(+)
 create mode 100644 src/state.js
 create mode 100644 src/tokencontext.js
 create mode 100644 src/tokenize.js

diff --git a/src/state.js b/src/state.js
new file mode 100644
index 0000000000..cb5e4b4fbe
--- /dev/null
+++ b/src/state.js
@@ -0,0 +1,56 @@
+import {reservedWords, keywords} from "./identifier"
+import {types as tt} from "./tokentype"
+
+export default function Parser(options, input, startPos) {
+  this.options = options
+  this.loadPlugins(this.options.plugins)
+  this.sourceFile = this.options.sourceFile || null
+  this.isKeyword = keywords[this.options.ecmaVersion >= 6 ? 6 : 5]
+  this.isReservedWord = reservedWords[this.options.ecmaVersion]
+  this.input = input
+
+  // Set up token state
+
+  // The current position of the tokenizer in the input.
+  if (startPos) {
+    this.pos = startPos;
+    this.lineStart = Math.max(0, this.input.lastIndexOf("\n", startPos));
+    this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length;
+  } else {
+    this.pos = this.lineStart = 0;
+    this.curLine = 1;
+  }
+
+  // Properties of the current token:
+  // Its type
+  this.type = tt.eof;
+  // For tokens that include more information than their type, the value
+  this.value = null;
+  // Its start and end offset
+  this.start = this.end = this.pos;
+  // And, if locations are used, the {line, column} object
+  // corresponding to those offsets
+  this.startLoc = this.endLoc = null;
+
+  // Position information for the previous token
+  this.lastTokEndLoc = this.lastTokStartLoc = null;
+  this.lastTokStart = this.lastTokEnd = this.pos;
+
+  // The context stack is used to superficially track syntactic
+  // context to predict whether a regular expression is allowed in a
+  // given position.
+  this.context = this.initialContext()
+  this.exprAllowed = true
+
+  // Figure out if it's a module code.
+  this.strict = this.inModule = this.options.sourceType === "module";
+
+  // Flags to track whether we are in a function, a generator.
+  this.inFunction = this.inGenerator = false;
+  // Labels in scope.
+  this.labels = [];
+
+  // If enabled, skip leading hashbang line.
+  if (this.pos === 0 && this.options.allowHashBang && this.input.slice(0, 2) === '#!')
+    this.skipLineComment(2);
+}
diff --git a/src/tokencontext.js b/src/tokencontext.js
new file mode 100644
index 0000000000..870f3f1325
--- /dev/null
+++ b/src/tokencontext.js
@@ -0,0 +1,102 @@
+// The algorithm used to determine whether a regexp can appear at a
+// given point in the program is loosely based on sweet.js' approach.
+// See https://github.com/mozilla/sweet.js/wiki/design
+
+import Parser from "./state"
+import {types as tt} from "./tokentype"
+
+export class TokContext {
+  constructor(token, isExpr, preserveSpace, override) {
+    this.token = token
+    this.isExpr = isExpr
+    this.preserveSpace = preserveSpace
+    this.override = override
+  }
+}
+
+export const types = {
+  b_stat: new TokContext("{", false),
+  b_expr: new TokContext("{", true),
+  b_tmpl: new TokContext("${", true, null, p => p.readTmplToken()),
+  p_stat: new TokContext("(", false),
+  p_expr: new TokContext("(", true),
+  q_tmpl: new TokContext("`", true, true),
+  f_expr: new TokContext("function", true)
+}
+
+const pp = Parser.prototype
+
+pp.initialContext = function() {
+  return [types.b_stat]
+}
+
+pp.braceIsBlock = function(prevType) {
+  var parent;
+  if (prevType === tt.colon && (parent = this.curContext()).token == "{")
+    return !parent.isExpr;
+  if (prevType === tt._return)
+    return lineBreak.test(this.input.slice(this.lastTokEnd, this.start));
+  if (prevType === tt._else || prevType === tt.semi || prevType === tt.eof)
+    return true;
+  if (prevType == tt.braceL)
+    return this.curContext() === types.b_stat;
+  return !this.exprAllowed;
+};
+
+pp.updateContext = function(prevType) {
+  var update, type = this.type;
+  if (type.keyword && prevType == tt.dot)
+    this.exprAllowed = false;
+  else if (update = type.updateContext)
+    update.call(this, prevType);
+  else
+    this.exprAllowed = type.beforeExpr;
+};
+
+// Token-specific context update code
+
+tt.parenR.updateContext = tt.braceR.updateContext = function() {
+  var out = this.context.pop();
+  if (out === types.b_stat && this.curContext() === types.f_expr) {
+    this.context.pop();
+    this.exprAllowed = false;
+  } else if (out === types.b_tmpl) {
+    this.exprAllowed = true;
+  } else {
+    this.exprAllowed = !(out && out.isExpr);
+  }
+};
+
+tt.braceL.updateContext = function(prevType) {
+  this.context.push(this.braceIsBlock(prevType) ? types.b_stat : types.b_expr);
+  this.exprAllowed = true;
+};
+
+tt.dollarBraceL.updateContext = function() {
+  this.context.push(types.b_tmpl);
+  this.exprAllowed = true;
+};
+
+tt.parenL.updateContext = function(prevType) {
+  var statementParens = prevType === tt._if || prevType === tt._for || prevType === tt._with || prevType === tt._while;
+  this.context.push(statementParens ? types.p_stat : types.p_expr);
+  this.exprAllowed = true;
+};
+
+tt.incDec.updateContext = function() {
+  // tokExprAllowed stays unchanged
+};
+
+tt._function.updateContext = function() {
+  if (this.curContext() !== types.b_stat)
+    this.context.push(types.f_expr);
+  this.exprAllowed = false;
+};
+
+tt.backQuote.updateContext = function() {
+  if (this.curContext() === types.q_tmpl)
+    this.context.pop();
+  else
+    this.context.push(types.q_tmpl);
+  this.exprAllowed = false;
+};
diff --git a/src/tokenize.js b/src/tokenize.js
new file mode 100644
index 0000000000..9a2007e15d
--- /dev/null
+++ b/src/tokenize.js
@@ -0,0 +1,724 @@
+import {isIdentifierStart, isIdentifierChar} from "./identifier"
+import {types as tt, keywords as keywordTypes} from "./tokentype"
+import Parser from "./state"
+import "./tokencontext"
+
+// Object type used to represent tokens. Note that normally, tokens
+// simply exist as properties on the parser object. This is only
+// used for the onToken callback and the external tokenizer.
+
+export class Token {
+  constructor(p) {
+    this.type = p.type;
+    this.value = p.value;
+    this.start = p.start;
+    this.end = p.end;
+    if (p.options.locations)
+      this.loc = new SourceLocation(p, p.startLoc, p.endLoc);
+    if (p.options.ranges)
+      this.range = [p.start, p.end];
+  }
+}
+
+// Matches a whole line break (where CRLF is considered a single
+// line break). Used to count lines.
+
+export const lineBreak = /\r\n?|\n|\u2028|\u2029/g
+
+export function isNewLine(code) {
+  return code === 10 || code === 13 || code === 0x2028 || code == 0x2029
+}
+
+// ## Tokenizer
+
+// These are used when `options.locations` is on, for the
+// `startLoc` and `endLoc` properties.
+
+class Position {
+  constructor(line, col) {
+    this.line = line
+    this.column = col
+  }
+
+  offset(n) {
+    return new Position(this.line, this.column + n)
+  }
+}
+
+// Shorthand because we are going to be adding a _lot_ of methods to
+// this.
+const pp = Parser.prototype
+
+pp.extend = function(name, f) {
+  this[name] = f(this[name]);
+};
+
+pp.loadPlugins = function(plugins) {
+  for (var name in plugins) {
+    var plugin = exports.plugins[name];
+    if (!plugin) throw new Error("Plugin '" + name + "' not found");
+    plugin(this, plugins[name]);
+  }
+};
+
+// Move to the next token
+
+pp.next = function() {
+  if (this.options.onToken)
+    this.options.onToken(new Token(this));
+
+  this.lastTokEnd = this.end;
+  this.lastTokStart = this.start;
+  this.lastTokEndLoc = this.endLoc;
+  this.lastTokStartLoc = this.startLoc;
+  this.nextToken();
+};
+
+pp.getToken = function() {
+  this.next();
+  return new Token(this);
+};
+
+// If we're in an ES6 environment, make parsers iterable
+if (typeof Symbol !== "undefined")
+  pp[Symbol.iterator] = function () {
+    var self = this;
+    return {next: function () {
+      var token = self.getToken();
+      return {
+        done: token.type === tt.eof,
+        value: token
+      };
+    }};
+  };
+
+// Toggle strict mode. Re-reads the next number or string to please
+// pedantic tests (`"use strict"; 010;` should fail).
+
+pp.setStrict = function(strict) {
+  this.strict = strict;
+  if (this.type !== tt.num && this.type !== tt.string) return;
+  this.pos = this.start;
+  if (this.options.locations) {
+    while (this.pos < this.lineStart) {
+      this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1;
+      --this.curLine;
+    }
+  }
+  this.nextToken();
+};
+
+pp.curContext = function() {
+  return this.context[this.context.length - 1];
+};
+
+// Read a single token, updating the parser object's token-related
+// properties.
+
+pp.nextToken = function() {
+  let curContext = this.curContext()
+  if (!curContext || !curContext.preserveSpace) this.skipSpace()
+
+  this.start = this.pos
+  if (this.options.locations) this.startLoc = this.curPosition()
+  if (this.pos >= this.input.length) return this.finishToken(tt.eof)
+
+  if (curContext.override) return curContext.override(this)
+  else this.readToken(this.fullCharCodeAtPos())
+}
+
+pp.readToken = function(code) {
+  // Identifier or keyword. '\uXXXX' sequences are allowed in
+  // identifiers, so '\' also dispatches to that.
+  if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */)
+    return this.readWord();
+
+  return this.getTokenFromCode(code);
+};
+
+pp.fullCharCodeAtPos = function() {
+  var code = this.input.charCodeAt(this.pos);
+  if (code <= 0xd7ff || code >= 0xe000) return code;
+  var next = this.input.charCodeAt(this.pos + 1);
+  return (code << 10) + next - 0x35fdc00;
+};
+
+pp.skipBlockComment = function() {
+  var startLoc = this.options.onComment && this.options.locations && this.curPosition();
+  var start = this.pos, end = this.input.indexOf("*/", this.pos += 2);
+  if (end === -1) this.raise(this.pos - 2, "Unterminated comment");
+  this.pos = end + 2;
+  if (this.options.locations) {
+    lineBreak.lastIndex = start;
+    var match;
+    while ((match = lineBreak.exec(this.input)) && match.index < this.pos) {
+      ++this.curLine;
+      this.lineStart = match.index + match[0].length;
+    }
+  }
+  if (this.options.onComment)
+    this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,
+                           startLoc, this.options.locations && this.curPosition());
+};
+
+pp.skipLineComment = function(startSkip) {
+  var start = this.pos;
+  var startLoc = this.options.onComment && this.options.locations && this.curPosition();
+  var ch = this.input.charCodeAt(this.pos+=startSkip);
+  while (this.pos < this.input.length && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+    ++this.pos;
+    ch = this.input.charCodeAt(this.pos);
+  }
+  if (this.options.onComment)
+    this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,
+                           startLoc, this.options.locations && this.curPosition());
+};
+
+// Called at the start of the parse and after every token. Skips
+// whitespace and comments, and.
+
+pp.skipSpace = function() {
+  while (this.pos < this.input.length) {
+    var ch = this.input.charCodeAt(this.pos);
+    if (ch === 32) { // ' '
+      ++this.pos;
+    } else if (ch === 13) {
+      ++this.pos;
+      var next = this.input.charCodeAt(this.pos);
+      if (next === 10) {
+        ++this.pos;
+      }
+      if (this.options.locations) {
+        ++this.curLine;
+        this.lineStart = this.pos;
+      }
+    } else if (ch === 10 || ch === 8232 || ch === 8233) {
+      ++this.pos;
+      if (this.options.locations) {
+        ++this.curLine;
+        this.lineStart = this.pos;
+      }
+    } else if (ch > 8 && ch < 14) {
+      ++this.pos;
+    } else if (ch === 47) { // '/'
+      var next = this.input.charCodeAt(this.pos + 1);
+      if (next === 42) { // '*'
+        this.skipBlockComment();
+      } else if (next === 47) { // '/'
+        this.skipLineComment(2);
+      } else break;
+    } else if (ch === 160) { // '\xa0'
+      ++this.pos;
+    } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+      ++this.pos;
+    } else {
+      break;
+    }
+  }
+};
+
+pp.curPosition = function() {
+  return new Position(this.curLine, this.pos - this.lineStart);
+};
+
+// Called at the end of every token. Sets `end`, `val`, and
+// maintains `context` and `exprAllowed`, and skips the space after
+// the token, so that the next one's `start` will point at the
+// right position.
+
+pp.finishToken = function(type, val) {
+  this.end = this.pos;
+  if (this.options.locations) this.endLoc = this.curPosition();
+  var prevType = this.type;
+  this.type = type;
+  this.value = val;
+
+  this.updateContext(prevType);
+};
+
+// ### 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.
+//
+pp.readToken_dot = function() {
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next >= 48 && next <= 57) return this.readNumber(true);
+  var next2 = this.input.charCodeAt(this.pos + 2);
+  if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
+    this.pos += 3;
+    return this.finishToken(tt.ellipsis);
+  } else {
+    ++this.pos;
+    return this.finishToken(tt.dot);
+  }
+};
+
+pp.readToken_slash = function() { // '/'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (this.exprAllowed) {++this.pos; return this.readRegexp();}
+  if (next === 61) return this.finishOp(tt.assign, 2);
+  return this.finishOp(tt.slash, 1);
+};
+
+pp.readToken_mult_modulo = function(code) { // '%*'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === 61) return this.finishOp(tt.assign, 2);
+  return this.finishOp(code === 42 ? tt.star : tt.modulo, 1);
+};
+
+pp.readToken_pipe_amp = function(code) { // '|&'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === code) return this.finishOp(code === 124 ? tt.logicalOR : tt.logicalAND, 2);
+  if (next === 61) return this.finishOp(tt.assign, 2);
+  return this.finishOp(code === 124 ? tt.bitwiseOR : tt.bitwiseAND, 1);
+};
+
+pp.readToken_caret = function() { // '^'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === 61) return this.finishOp(tt.assign, 2);
+  return this.finishOp(tt.bitwiseXOR, 1);
+};
+
+pp.readToken_plus_min = function(code) { // '+-'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === code) {
+    if (next == 45 && this.input.charCodeAt(this.pos + 2) == 62 &&
+        lineBreak.test(this.input.slice(this.lastTokEnd, this.pos))) {
+      // A `-->` line comment
+      this.skipLineComment(3);
+      this.skipSpace();
+      return this.nextToken();
+    }
+    return this.finishOp(tt.incDec, 2);
+  }
+  if (next === 61) return this.finishOp(tt.assign, 2);
+  return this.finishOp(tt.plusMin, 1);
+};
+
+pp.readToken_lt_gt = function(code) { // '<>'
+  var next = this.input.charCodeAt(this.pos + 1);
+  var size = 1;
+  if (next === code) {
+    size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
+    if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1);
+    return this.finishOp(tt.bitShift, size);
+  }
+  if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 &&
+      this.input.charCodeAt(this.pos + 3) == 45) {
+    if (this.inModule) unexpected();
+    // `<!--`, an XML-style comment that should be interpreted as a line comment
+    this.skipLineComment(4);
+    this.skipSpace();
+    return this.nextToken();
+  }
+  if (next === 61)
+    size = this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2;
+  return this.finishOp(tt.relational, size);
+};
+
+pp.readToken_eq_excl = function(code) { // '=!'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === 61) return this.finishOp(tt.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2);
+  if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'
+    this.pos += 2;
+    return this.finishToken(tt.arrow);
+  }
+  return this.finishOp(code === 61 ? tt.eq : tt.prefix, 1);
+};
+
+pp.getTokenFromCode = function(code) {
+  switch (code) {
+    // The interpretation of a dot depends on whether it is followed
+    // by a digit or another two dots.
+  case 46: // '.'
+    return this.readToken_dot();
+
+    // Punctuation tokens.
+  case 40: ++this.pos; return this.finishToken(tt.parenL);
+  case 41: ++this.pos; return this.finishToken(tt.parenR);
+  case 59: ++this.pos; return this.finishToken(tt.semi);
+  case 44: ++this.pos; return this.finishToken(tt.comma);
+  case 91: ++this.pos; return this.finishToken(tt.bracketL);
+  case 93: ++this.pos; return this.finishToken(tt.bracketR);
+  case 123: ++this.pos; return this.finishToken(tt.braceL);
+  case 125: ++this.pos; return this.finishToken(tt.braceR);
+  case 58: ++this.pos; return this.finishToken(tt.colon);
+  case 63: ++this.pos; return this.finishToken(tt.question);
+
+  case 96: // '`'
+    if (this.options.ecmaVersion < 6) break;
+    ++this.pos;
+    return this.finishToken(tt.backQuote);
+
+  case 48: // '0'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === 120 || next === 88) return this.readRadixNumber(16); // '0x', '0X' - hex number
+    if (this.options.ecmaVersion >= 6) {
+      if (next === 111 || next === 79) return this.readRadixNumber(8); // '0o', '0O' - octal number
+      if (next === 98 || next === 66) return this.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 this.readNumber(false);
+
+    // Quotes produce strings.
+  case 34: case 39: // '"', "'"
+    return this.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 this.readToken_slash();
+
+  case 37: case 42: // '%*'
+    return this.readToken_mult_modulo(code);
+
+  case 124: case 38: // '|&'
+    return this.readToken_pipe_amp(code);
+
+  case 94: // '^'
+    return this.readToken_caret();
+
+  case 43: case 45: // '+-'
+    return this.readToken_plus_min(code);
+
+  case 60: case 62: // '<>'
+    return this.readToken_lt_gt(code);
+
+  case 61: case 33: // '=!'
+    return this.readToken_eq_excl(code);
+
+  case 126: // '~'
+    return this.finishOp(tt.prefix, 1);
+  }
+
+  this.raise(this.pos, "Unexpected character '" + codePointToString(code) + "'");
+};
+
+pp.finishOp = function(type, size) {
+  var str = this.input.slice(this.pos, this.pos + size);
+  this.pos += size;
+  return this.finishToken(type, str);
+};
+
+var regexpUnicodeSupport = false;
+try { new RegExp("\uffff", "u"); regexpUnicodeSupport = true; }
+catch(e) {}
+
+// Parse a regular expression. Some context-awareness is necessary,
+// since a '/' inside a '[]' set does not end the expression.
+
+pp.readRegexp = function() {
+  var content = "", escaped, inClass, start = this.pos;
+  for (;;) {
+    if (this.pos >= this.input.length) this.raise(start, "Unterminated regular expression");
+    var ch = this.input.charAt(this.pos);
+    if (lineBreak.test(ch)) this.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;
+    ++this.pos;
+  }
+  var content = this.input.slice(start, this.pos);
+  ++this.pos;
+  // Need to use `readWord1` because '\uXXXX' sequences are allowed
+  // here (don't ask).
+  var mods = this.readWord1();
+  var tmp = content;
+  if (mods) {
+    var validFlags = /^[gmsiy]*$/;
+    if (this.options.ecmaVersion >= 6) validFlags = /^[gmsiyu]*$/;
+    if (!validFlags.test(mods)) this.raise(start, "Invalid regular expression flag");
+    if (mods.indexOf('u') >= 0 && !regexpUnicodeSupport) {
+      // Replace each astral symbol and every Unicode escape sequence that
+      // possibly represents an astral symbol or a paired surrogate with a
+      // single ASCII symbol to avoid throwing on regular expressions that
+      // are only valid in combination with the `/u` flag.
+      // Note: replacing with the ASCII symbol `x` might cause false
+      // negatives in unlikely scenarios. For example, `[\u{61}-b]` is a
+      // perfectly valid pattern that is equivalent to `[a-b]`, but it would
+      // be replaced by `[x-b]` which throws an error.
+      tmp = tmp.replace(/\\u([a-fA-F0-9]{4})|\\u\{([0-9a-fA-F]+)\}|[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x")
+    }
+  }
+  // Detect invalid regular expressions.
+  try {
+    new RegExp(tmp);
+  } catch (e) {
+    if (e instanceof SyntaxError) this.raise(start, "Error parsing regular expression: " + e.message);
+    this.raise(e);
+  }
+  // Get a regular expression object for this pattern-flag pair, or `null` in
+  // case the current environment doesn't support the flags it uses.
+  try {
+    var value = new RegExp(content, mods);
+  } catch (err) {
+    value = null;
+  }
+  return this.finishToken(tt.regexp, {pattern: content, flags: mods, value: 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.
+
+pp.readInt = function(radix, len) {
+  var start = this.pos, total = 0;
+  for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+    var code = this.input.charCodeAt(this.pos), 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;
+    ++this.pos;
+    total = total * radix + val;
+  }
+  if (this.pos === start || len != null && this.pos - start !== len) return null;
+
+  return total;
+};
+
+pp.readRadixNumber = function(radix) {
+  this.pos += 2; // 0x
+  var val = this.readInt(radix);
+  if (val == null) this.raise(this.start + 2, "Expected number in radix " + radix);
+  if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
+  return this.finishToken(tt.num, val);
+};
+
+// Read an integer, octal integer, or floating-point number.
+
+pp.readNumber = function(startsWithDot) {
+  var start = this.pos, isFloat = false, octal = this.input.charCodeAt(this.pos) === 48;
+  if (!startsWithDot && this.readInt(10) === null) this.raise(start, "Invalid number");
+  if (this.input.charCodeAt(this.pos) === 46) {
+    ++this.pos;
+    this.readInt(10);
+    isFloat = true;
+  }
+  var next = this.input.charCodeAt(this.pos);
+  if (next === 69 || next === 101) { // 'eE'
+    next = this.input.charCodeAt(++this.pos);
+    if (next === 43 || next === 45) ++this.pos; // '+-'
+    if (this.readInt(10) === null) this.raise(start, "Invalid number");
+    isFloat = true;
+  }
+  if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
+
+  var str = this.input.slice(start, this.pos), val;
+  if (isFloat) val = parseFloat(str);
+  else if (!octal || str.length === 1) val = parseInt(str, 10);
+  else if (/[89]/.test(str) || this.strict) this.raise(start, "Invalid number");
+  else val = parseInt(str, 8);
+  return this.finishToken(tt.num, val);
+};
+
+// Read a string value, interpreting backslash-escapes.
+
+pp.readCodePoint = function() {
+  var ch = this.input.charCodeAt(this.pos), code;
+
+  if (ch === 123) {
+    if (this.options.ecmaVersion < 6) this.unexpected();
+    ++this.pos;
+    code = this.readHexChar(this.input.indexOf('}', this.pos) - this.pos);
+    ++this.pos;
+    if (code > 0x10FFFF) this.unexpected();
+  } else {
+    code = this.readHexChar(4);
+  }
+  return code;
+};
+
+function codePointToString(code) {
+  // UTF-16 Decoding
+  if (code <= 0xFFFF) return String.fromCharCode(code);
+  return String.fromCharCode(((code - 0x10000) >> 10) + 0xD800,
+                             ((code - 0x10000) & 1023) + 0xDC00);
+}
+
+pp.readString = function(quote) {
+  var out = "", chunkStart = ++this.pos;
+  for (;;) {
+    if (this.pos >= this.input.length) this.raise(this.start, "Unterminated string constant");
+    var ch = this.input.charCodeAt(this.pos);
+    if (ch === quote) break;
+    if (ch === 92) { // '\'
+      out += this.input.slice(chunkStart, this.pos);
+      out += this.readEscapedChar();
+      chunkStart = this.pos;
+    } else {
+      if (isNewLine(ch)) this.raise(this.start, "Unterminated string constant");
+      ++this.pos;
+    }
+  }
+  out += this.input.slice(chunkStart, this.pos++);
+  return this.finishToken(tt.string, out);
+};
+
+// Reads template string tokens.
+
+pp.readTmplToken = function() {
+  var out = "", chunkStart = this.pos;
+  for (;;) {
+    if (this.pos >= this.input.length) this.raise(this.start, "Unterminated template");
+    var ch = this.input.charCodeAt(this.pos);
+    if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) { // '`', '${'
+      if (this.pos === this.start && this.type === tt.template) {
+        if (ch === 36) {
+          this.pos += 2;
+          return this.finishToken(tt.dollarBraceL);
+        } else {
+          ++this.pos;
+          return this.finishToken(tt.backQuote);
+        }
+      }
+      out += this.input.slice(chunkStart, this.pos);
+      return this.finishToken(tt.template, out);
+    }
+    if (ch === 92) { // '\'
+      out += this.input.slice(chunkStart, this.pos);
+      out += this.readEscapedChar();
+      chunkStart = this.pos;
+    } else if (isNewLine(ch)) {
+      out += this.input.slice(chunkStart, this.pos);
+      ++this.pos;
+      if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
+        ++this.pos;
+        out += "\n";
+      } else {
+        out += String.fromCharCode(ch);
+      }
+      if (this.options.locations) {
+        ++this.curLine;
+        this.lineStart = this.pos;
+      }
+      chunkStart = this.pos;
+    } else {
+      ++this.pos;
+    }
+  }
+};
+
+// Used to read escaped characters
+
+pp.readEscapedChar = function() {
+  var ch = this.input.charCodeAt(++this.pos);
+  var octal = /^[0-7]+/.exec(this.input.slice(this.pos, this.pos + 3));
+  if (octal) octal = octal[0];
+  while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
+  if (octal === "0") octal = null;
+  ++this.pos;
+  if (octal) {
+    if (this.strict) this.raise(this.pos - 2, "Octal literal in strict mode");
+    this.pos += 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(this.readHexChar(2)); // 'x'
+    case 117: return codePointToString(this.readCodePoint()); // '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 (this.input.charCodeAt(this.pos) === 10) ++this.pos; // '\r\n'
+    case 10: // ' \n'
+      if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }
+      return "";
+    default: return String.fromCharCode(ch);
+    }
+  }
+};
+
+// Used to read character escape sequences ('\x', '\u', '\U').
+
+pp.readHexChar = function(len) {
+  var n = this.readInt(16, len);
+  if (n === null) this.raise(this.start, "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.
+//
+// Incrementally adds only escaped chars, adding other chunks as-is
+// as a micro-optimization.
+
+pp.readWord1 = function() {
+  containsEsc = false;
+  var word = "", first = true, chunkStart = this.pos;
+  var astral = this.options.ecmaVersion >= 6;
+  while (this.pos < this.input.length) {
+    var ch = this.fullCharCodeAtPos();
+    if (isIdentifierChar(ch, astral)) {
+      this.pos += ch <= 0xffff ? 1 : 2;
+    } else if (ch === 92) { // "\"
+      containsEsc = true;
+      word += this.input.slice(chunkStart, this.pos);
+      var escStart = this.pos;
+      if (this.input.charCodeAt(++this.pos) != 117) // "u"
+        this.raise(this.pos, "Expecting Unicode escape sequence \\uXXXX");
+      ++this.pos;
+      var esc = this.readCodePoint();
+      if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))
+        this.raise(escStart, "Invalid Unicode escape");
+      word += codePointToString(esc);
+      chunkStart = this.pos;
+    } else {
+      break;
+    }
+    first = false;
+  }
+  return word + this.input.slice(chunkStart, this.pos);
+};
+
+// Read an identifier or keyword token. Will check for reserved
+// words when necessary.
+
+pp.readWord = function() {
+  var word = this.readWord1();
+  var type = tt.name;
+  if ((this.options.ecmaVersion >= 6 || !containsEsc) && this.isKeyword(word))
+    type = keywordTypes[word];
+  return this.finishToken(type, word);
+};
+
+// 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.
+
+pp.raise = function(pos, message) {
+  var loc = getLineInfo(this.input, pos);
+  message += " (" + loc.line + ":" + loc.column + ")";
+  var err = new SyntaxError(message);
+  err.pos = pos; err.loc = loc; err.raisedAt = this.pos;
+  throw err;
+};
+
+pp.currentPos = function() {
+  return this.options.locations ? [this.start, this.startLoc] : this.start;
+};

From 7b05e660b428903f8b86d2ddb049886fb8225e22 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 19 Mar 2015 16:28:28 +0100
Subject: [PATCH 24/43] Move location-related code into location.js

---
 src/index.js    | 972 +++---------------------------------------------
 src/location.js |  66 ++++
 src/tokenize.js |  36 --
 3 files changed, 109 insertions(+), 965 deletions(-)
 create mode 100644 src/location.js

diff --git a/src/index.js b/src/index.js
index d49aff7c03..dc10882782 100644
--- a/src/index.js
+++ b/src/index.js
@@ -20,7 +20,8 @@
 // [walk]: util/walk.js
 
 import {has, isArray} from "./util"
-import {types as tt, keywords as keywordTypes} from "./tokentype"
+import {lineBreak} from "./tokenize"
+import {getLineInfo as getLineInfo_, SourceLocation} from "./location"
 
 export const version = "0.12.1"
 
@@ -162,89 +163,6 @@ function parser(options, input) {
   return new Parser(getOptions(options), String(input))
 }
 
-// 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.
-
-export function parseExpressionAt(input, pos, options) {
-  let p = parser(options, input, pos)
-  p.nextToken()
-  return p.parseExpression()
-}
-
-// 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.
-
-export function getLineInfo(input, offset) {
-  for (let line = 1, cur = 0;;) {
-    lineBreak.lastIndex = cur
-    let match = lineBreak.exec(input)
-    if (match && match.index < offset) {
-      ++line
-      cur = match.index + match[0].length
-    } else {
-      return new Position(line, offset - cur)
-    }
-  }
-}
-
-// 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.
-
-export function tokenizer(input, options) {
-  return parser(options, input)
-}
-
-// Object type used to represent tokens. Note that normally, tokens
-// simply exist as properties on the parser object. This is only
-// used for the onToken callback and the external tokenizer.
-
-class Token {
-  constructor(p) {
-    this.type = p.type;
-    this.value = p.value;
-    this.start = p.start;
-    this.end = p.end;
-    if (p.options.locations)
-      this.loc = new SourceLocation(p, p.startLoc, p.endLoc);
-    if (p.options.ranges)
-      this.range = [p.start, p.end];
-  }
-}
-
-// Whether a single character denotes a newline.
-
-var newline = exports.newline = /[\n\r\u2028\u2029]/;
-
-var isNewLine = exports.isNewLine = function(code) {
-  return code === 10 || code === 13 || code === 0x2028 || code == 0x2029;
-};
-
-// Matches a whole line break (where CRLF is considered a single
-// line break). Used to count lines.
-
-var lineBreak = exports.lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
-
-// ## Tokenizer
-
-// These are used when `options.locations` is on, for the
-// `startLoc` and `endLoc` properties.
-
-function Position(line, col) {
-  this.line = line;
-  this.column = col;
-}
-
-Position.prototype.offset = function(n) {
-  return new Position(this.line, this.column + n);
-};
-
 // ## Parser
 
 // A recursive descent parser operates by defining functions for all
@@ -265,831 +183,31 @@ Position.prototype.offset = function(n) {
 //
 // [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser
 
-import {reservedWords, keywords, isIdentifierStart, isIdentifierChar} from "./identifier"
-
-var Parser = exports.Parser = function(options, input, startPos) {
-  this.options = options
-  this.loadPlugins(this.options.plugins)
-  this.sourceFile = this.options.sourceFile || null
-  this.isKeyword = keywords[this.options.ecmaVersion >= 6 ? 6 : 5]
-  this.isReservedWord = reservedWords[this.options.ecmaVersion]
-  this.input = input
-
-  // Set up token state
-
-  // The current position of the tokenizer in the input.
-  if (startPos) {
-    this.pos = startPos;
-    this.lineStart = Math.max(0, this.input.lastIndexOf("\n", startPos));
-    this.curLine = this.input.slice(0, this.lineStart).split(newline).length;
-  } else {
-    this.pos = this.lineStart = 0;
-    this.curLine = 1;
-  }
-
-  // Properties of the current token:
-  // Its type
-  this.type = tt.eof;
-  // For tokens that include more information than their type, the value
-  this.value = null;
-  // Its start and end offset
-  this.start = this.end = this.pos;
-  // And, if locations are used, the {line, column} object
-  // corresponding to those offsets
-  this.startLoc = this.endLoc = null;
-
-  // Position information for the previous token
-  this.lastTokEndLoc = this.lastTokStartLoc = null;
-  this.lastTokStart = this.lastTokEnd = this.pos;
-
-  // The context stack is used to superficially track syntactic
-  // context to predict whether a regular expression is allowed in a
-  // given position.
-  this.context = [tc.b_stat];
-  this.exprAllowed = true;
-
-  // Figure out if it's a module code.
-  this.strict = this.inModule = this.options.sourceType === "module";
-
-  // Flags to track whether we are in a function, a generator.
-  this.inFunction = this.inGenerator = false;
-  // Labels in scope.
-  this.labels = [];
-
-  // If enabled, skip leading hashbang line.
-  if (this.pos === 0 && this.options.allowHashBang && this.input.slice(0, 2) === '#!')
-    this.skipLineComment(2);
-};
-
-// Shorthand because we are going to be adding a _lot_ of methods to
-// this.
-var pp = Parser.prototype;
-
-pp.extend = function(name, f) {
-  this[name] = f(this[name]);
-};
-
-pp.loadPlugins = function(plugins) {
-  for (var name in plugins) {
-    var plugin = exports.plugins[name];
-    if (!plugin) throw new Error("Plugin '" + name + "' not found");
-    plugin(this, plugins[name]);
-  }
-};
-
-// Move to the next token
-
-pp.next = function() {
-  if (this.options.onToken)
-    this.options.onToken(new Token(this));
-
-  this.lastTokEnd = this.end;
-  this.lastTokStart = this.start;
-  this.lastTokEndLoc = this.endLoc;
-  this.lastTokStartLoc = this.startLoc;
-  this.nextToken();
-};
-
-pp.getToken = function() {
-  this.next();
-  return new Token(this);
-};
-
-// If we're in an ES6 environment, make parsers iterable
-if (typeof Symbol !== "undefined")
-  pp[Symbol.iterator] = function () {
-    var self = this;
-    return {next: function () {
-      var token = self.getToken();
-      return {
-        done: token.type === tt.eof,
-        value: token
-      };
-    }};
-  };
-
-// Toggle strict mode. Re-reads the next number or string to please
-// pedantic tests (`"use strict"; 010;` should fail).
-
-pp.setStrict = function(strict) {
-  this.strict = strict;
-  if (this.type !== tt.num && this.type !== tt.string) return;
-  this.pos = this.start;
-  if (this.options.locations) {
-    while (this.pos < this.lineStart) {
-      this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1;
-      --this.curLine;
-    }
-  }
-  this.nextToken();
-};
-
-pp.curContext = function() {
-  return this.context[this.context.length - 1];
-};
-
-// Read a single token, updating the parser object's token-related
-// properties.
-
-pp.nextToken = function() {
-  var curContext = this.curContext();
-  if (!curContext || !curContext.preserveSpace) this.skipSpace();
-
-  this.start = this.pos;
-  if (this.options.locations) this.startLoc = this.curPosition();
-  if (this.pos >= this.input.length) return this.finishToken(tt.eof);
-
-  if (curContext === tc.q_tmpl) return this.readTmplToken();
-
-  this.readToken(this.fullCharCodeAtPos());
-};
-
-pp.readToken = function(code) {
-  // Identifier or keyword. '\uXXXX' sequences are allowed in
-  // identifiers, so '\' also dispatches to that.
-  if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */)
-    return this.readWord();
-
-  return this.getTokenFromCode(code);
-};
-
-pp.fullCharCodeAtPos = function() {
-  var code = this.input.charCodeAt(this.pos);
-  if (code <= 0xd7ff || code >= 0xe000) return code;
-  var next = this.input.charCodeAt(this.pos + 1);
-  return (code << 10) + next - 0x35fdc00;
-};
-
-pp.skipBlockComment = function() {
-  var startLoc = this.options.onComment && this.options.locations && this.curPosition();
-  var start = this.pos, end = this.input.indexOf("*/", this.pos += 2);
-  if (end === -1) this.raise(this.pos - 2, "Unterminated comment");
-  this.pos = end + 2;
-  if (this.options.locations) {
-    lineBreak.lastIndex = start;
-    var match;
-    while ((match = lineBreak.exec(this.input)) && match.index < this.pos) {
-      ++this.curLine;
-      this.lineStart = match.index + match[0].length;
-    }
-  }
-  if (this.options.onComment)
-    this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,
-                           startLoc, this.options.locations && this.curPosition());
-};
-
-pp.skipLineComment = function(startSkip) {
-  var start = this.pos;
-  var startLoc = this.options.onComment && this.options.locations && this.curPosition();
-  var ch = this.input.charCodeAt(this.pos+=startSkip);
-  while (this.pos < this.input.length && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
-    ++this.pos;
-    ch = this.input.charCodeAt(this.pos);
-  }
-  if (this.options.onComment)
-    this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,
-                           startLoc, this.options.locations && this.curPosition());
-};
-
-// Called at the start of the parse and after every token. Skips
-// whitespace and comments, and.
-
-pp.skipSpace = function() {
-  while (this.pos < this.input.length) {
-    var ch = this.input.charCodeAt(this.pos);
-    if (ch === 32) { // ' '
-      ++this.pos;
-    } else if (ch === 13) {
-      ++this.pos;
-      var next = this.input.charCodeAt(this.pos);
-      if (next === 10) {
-        ++this.pos;
-      }
-      if (this.options.locations) {
-        ++this.curLine;
-        this.lineStart = this.pos;
-      }
-    } else if (ch === 10 || ch === 8232 || ch === 8233) {
-      ++this.pos;
-      if (this.options.locations) {
-        ++this.curLine;
-        this.lineStart = this.pos;
-      }
-    } else if (ch > 8 && ch < 14) {
-      ++this.pos;
-    } else if (ch === 47) { // '/'
-      var next = this.input.charCodeAt(this.pos + 1);
-      if (next === 42) { // '*'
-        this.skipBlockComment();
-      } else if (next === 47) { // '/'
-        this.skipLineComment(2);
-      } else break;
-    } else if (ch === 160) { // '\xa0'
-      ++this.pos;
-    } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
-      ++this.pos;
-    } else {
-      break;
-    }
-  }
-};
-
-pp.curPosition = function() {
-  return new Position(this.curLine, this.pos - this.lineStart);
-};
-
-// The algorithm used to determine whether a regexp can appear at a
-// given point in the program is loosely based on sweet.js' approach.
-// See https://github.com/mozilla/sweet.js/wiki/design
-
-var TokContext = exports.TokContext = function(token, isExpr, preserveSpace) {
-  this.token = token;
-  this.isExpr = isExpr;
-  this.preserveSpace = preserveSpace;
-};
-
-var tc = exports.tokContexts = {
-  b_stat: new TokContext("{", false),
-  b_expr: new TokContext("{", true),
-  b_tmpl: new TokContext("${", true),
-  p_stat: new TokContext("(", false),
-  p_expr: new TokContext("(", true),
-  q_tmpl: new TokContext("`", true, true),
-  f_expr: new TokContext("function", true)
-};
-
-pp.braceIsBlock = function(prevType) {
-  var parent;
-  if (prevType === tt.colon && (parent = this.curContext()).token == "{")
-    return !parent.isExpr;
-  if (prevType === tt._return)
-    return newline.test(this.input.slice(this.lastTokEnd, this.start));
-  if (prevType === tt._else || prevType === tt.semi || prevType === tt.eof)
-    return true;
-  if (prevType == tt.braceL)
-    return this.curContext() === tc.b_stat;
-  return !this.exprAllowed;
-};
-
-// Called at the end of every token. Sets `end`, `val`, and
-// maintains `context` and `exprAllowed`, and skips the space after
-// the token, so that the next one's `start` will point at the
-// right position.
-
-pp.finishToken = function(type, val) {
-  this.end = this.pos;
-  if (this.options.locations) this.endLoc = this.curPosition();
-  var prevType = this.type;
-  this.type = type;
-  this.value = val;
-
-  this.updateContext(prevType);
-};
-
-pp.updateContext = function(prevType) {
-  var update, type = this.type;
-  if (type.keyword && prevType == tt.dot)
-    this.exprAllowed = false;
-  else if (update = type.updateContext)
-    update.call(this, prevType);
-  else
-    this.exprAllowed = type.beforeExpr;
-};
-
-// Token-specific context update code
-
-tt.parenR.updateContext = tt.braceR.updateContext = function() {
-  var out = this.context.pop();
-  if (out === tc.b_stat && this.curContext() === tc.f_expr) {
-    this.context.pop();
-    this.exprAllowed = false;
-  } else if (out === tc.b_tmpl) {
-    this.exprAllowed = true;
-  } else {
-    this.exprAllowed = !(out && out.isExpr);
-  }
-};
-
-tt.braceL.updateContext = function(prevType) {
-  this.context.push(this.braceIsBlock(prevType) ? tc.b_stat : tc.b_expr);
-  this.exprAllowed = true;
-};
-
-tt.dollarBraceL.updateContext = function() {
-  this.context.push(tc.b_tmpl);
-  this.exprAllowed = true;
-};
-
-tt.parenL.updateContext = function(prevType) {
-  var statementParens = prevType === tt._if || prevType === tt._for || prevType === tt._with || prevType === tt._while;
-  this.context.push(statementParens ? tc.p_stat : tc.p_expr);
-  this.exprAllowed = true;
-};
-
-tt.incDec.updateContext = function() {
-  // tokExprAllowed stays unchanged
-};
-
-tt._function.updateContext = function() {
-  if (this.curContext() !== tc.b_stat)
-    this.context.push(tc.f_expr);
-  this.exprAllowed = false;
-};
-
-tt.backQuote.updateContext = function() {
-  if (this.curContext() === tc.q_tmpl)
-    this.context.pop();
-  else
-    this.context.push(tc.q_tmpl);
-  this.exprAllowed = false;
-};
-
-// ### 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.
-//
-pp.readToken_dot = function() {
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next >= 48 && next <= 57) return this.readNumber(true);
-  var next2 = this.input.charCodeAt(this.pos + 2);
-  if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
-    this.pos += 3;
-    return this.finishToken(tt.ellipsis);
-  } else {
-    ++this.pos;
-    return this.finishToken(tt.dot);
-  }
-};
-
-pp.readToken_slash = function() { // '/'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (this.exprAllowed) {++this.pos; return this.readRegexp();}
-  if (next === 61) return this.finishOp(tt.assign, 2);
-  return this.finishOp(tt.slash, 1);
-};
-
-pp.readToken_mult_modulo = function(code) { // '%*'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next === 61) return this.finishOp(tt.assign, 2);
-  return this.finishOp(code === 42 ? tt.star : tt.modulo, 1);
-};
-
-pp.readToken_pipe_amp = function(code) { // '|&'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next === code) return this.finishOp(code === 124 ? tt.logicalOR : tt.logicalAND, 2);
-  if (next === 61) return this.finishOp(tt.assign, 2);
-  return this.finishOp(code === 124 ? tt.bitwiseOR : tt.bitwiseAND, 1);
-};
-
-pp.readToken_caret = function() { // '^'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next === 61) return this.finishOp(tt.assign, 2);
-  return this.finishOp(tt.bitwiseXOR, 1);
-};
-
-pp.readToken_plus_min = function(code) { // '+-'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next === code) {
-    if (next == 45 && this.input.charCodeAt(this.pos + 2) == 62 &&
-        newline.test(this.input.slice(this.lastTokEnd, this.pos))) {
-      // A `-->` line comment
-      this.skipLineComment(3);
-      this.skipSpace();
-      return this.nextToken();
-    }
-    return this.finishOp(tt.incDec, 2);
-  }
-  if (next === 61) return this.finishOp(tt.assign, 2);
-  return this.finishOp(tt.plusMin, 1);
-};
-
-pp.readToken_lt_gt = function(code) { // '<>'
-  var next = this.input.charCodeAt(this.pos + 1);
-  var size = 1;
-  if (next === code) {
-    size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
-    if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1);
-    return this.finishOp(tt.bitShift, size);
-  }
-  if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 &&
-      this.input.charCodeAt(this.pos + 3) == 45) {
-    if (this.inModule) unexpected();
-    // `<!--`, an XML-style comment that should be interpreted as a line comment
-    this.skipLineComment(4);
-    this.skipSpace();
-    return this.nextToken();
-  }
-  if (next === 61)
-    size = this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2;
-  return this.finishOp(tt.relational, size);
-};
-
-pp.readToken_eq_excl = function(code) { // '=!'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next === 61) return this.finishOp(tt.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2);
-  if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'
-    this.pos += 2;
-    return this.finishToken(tt.arrow);
-  }
-  return this.finishOp(code === 61 ? tt.eq : tt.prefix, 1);
-};
-
-pp.getTokenFromCode = function(code) {
-  switch (code) {
-    // The interpretation of a dot depends on whether it is followed
-    // by a digit or another two dots.
-  case 46: // '.'
-    return this.readToken_dot();
-
-    // Punctuation tokens.
-  case 40: ++this.pos; return this.finishToken(tt.parenL);
-  case 41: ++this.pos; return this.finishToken(tt.parenR);
-  case 59: ++this.pos; return this.finishToken(tt.semi);
-  case 44: ++this.pos; return this.finishToken(tt.comma);
-  case 91: ++this.pos; return this.finishToken(tt.bracketL);
-  case 93: ++this.pos; return this.finishToken(tt.bracketR);
-  case 123: ++this.pos; return this.finishToken(tt.braceL);
-  case 125: ++this.pos; return this.finishToken(tt.braceR);
-  case 58: ++this.pos; return this.finishToken(tt.colon);
-  case 63: ++this.pos; return this.finishToken(tt.question);
-
-  case 96: // '`'
-    if (this.options.ecmaVersion < 6) break;
-    ++this.pos;
-    return this.finishToken(tt.backQuote);
-
-  case 48: // '0'
-    var next = this.input.charCodeAt(this.pos + 1);
-    if (next === 120 || next === 88) return this.readRadixNumber(16); // '0x', '0X' - hex number
-    if (this.options.ecmaVersion >= 6) {
-      if (next === 111 || next === 79) return this.readRadixNumber(8); // '0o', '0O' - octal number
-      if (next === 98 || next === 66) return this.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 this.readNumber(false);
-
-    // Quotes produce strings.
-  case 34: case 39: // '"', "'"
-    return this.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 this.readToken_slash();
-
-  case 37: case 42: // '%*'
-    return this.readToken_mult_modulo(code);
-
-  case 124: case 38: // '|&'
-    return this.readToken_pipe_amp(code);
-
-  case 94: // '^'
-    return this.readToken_caret();
-
-  case 43: case 45: // '+-'
-    return this.readToken_plus_min(code);
-
-  case 60: case 62: // '<>'
-    return this.readToken_lt_gt(code);
-
-  case 61: case 33: // '=!'
-    return this.readToken_eq_excl(code);
-
-  case 126: // '~'
-    return this.finishOp(tt.prefix, 1);
-  }
-
-  this.raise(this.pos, "Unexpected character '" + codePointToString(code) + "'");
-};
-
-pp.finishOp = function(type, size) {
-  var str = this.input.slice(this.pos, this.pos + size);
-  this.pos += size;
-  return this.finishToken(type, str);
-};
-
-var regexpUnicodeSupport = false;
-try { new RegExp("\uffff", "u"); regexpUnicodeSupport = true; }
-catch(e) {}
-
-// Parse a regular expression. Some context-awareness is necessary,
-// since a '/' inside a '[]' set does not end the expression.
-
-pp.readRegexp = function() {
-  var content = "", escaped, inClass, start = this.pos;
-  for (;;) {
-    if (this.pos >= this.input.length) this.raise(start, "Unterminated regular expression");
-    var ch = this.input.charAt(this.pos);
-    if (newline.test(ch)) this.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;
-    ++this.pos;
-  }
-  var content = this.input.slice(start, this.pos);
-  ++this.pos;
-  // Need to use `readWord1` because '\uXXXX' sequences are allowed
-  // here (don't ask).
-  var mods = this.readWord1();
-  var tmp = content;
-  if (mods) {
-    var validFlags = /^[gmsiy]*$/;
-    if (this.options.ecmaVersion >= 6) validFlags = /^[gmsiyu]*$/;
-    if (!validFlags.test(mods)) this.raise(start, "Invalid regular expression flag");
-    if (mods.indexOf('u') >= 0 && !regexpUnicodeSupport) {
-      // Replace each astral symbol and every Unicode escape sequence that
-      // possibly represents an astral symbol or a paired surrogate with a
-      // single ASCII symbol to avoid throwing on regular expressions that
-      // are only valid in combination with the `/u` flag.
-      // Note: replacing with the ASCII symbol `x` might cause false
-      // negatives in unlikely scenarios. For example, `[\u{61}-b]` is a
-      // perfectly valid pattern that is equivalent to `[a-b]`, but it would
-      // be replaced by `[x-b]` which throws an error.
-      tmp = tmp.replace(/\\u([a-fA-F0-9]{4})|\\u\{([0-9a-fA-F]+)\}|[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x")
-    }
-  }
-  // Detect invalid regular expressions.
-  try {
-    new RegExp(tmp);
-  } catch (e) {
-    if (e instanceof SyntaxError) this.raise(start, "Error parsing regular expression: " + e.message);
-    this.raise(e);
-  }
-  // Get a regular expression object for this pattern-flag pair, or `null` in
-  // case the current environment doesn't support the flags it uses.
-  try {
-    var value = new RegExp(content, mods);
-  } catch (err) {
-    value = null;
-  }
-  return this.finishToken(tt.regexp, {pattern: content, flags: mods, value: 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.
-
-pp.readInt = function(radix, len) {
-  var start = this.pos, total = 0;
-  for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-    var code = this.input.charCodeAt(this.pos), 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;
-    ++this.pos;
-    total = total * radix + val;
-  }
-  if (this.pos === start || len != null && this.pos - start !== len) return null;
-
-  return total;
-};
-
-pp.readRadixNumber = function(radix) {
-  this.pos += 2; // 0x
-  var val = this.readInt(radix);
-  if (val == null) this.raise(this.start + 2, "Expected number in radix " + radix);
-  if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
-  return this.finishToken(tt.num, val);
-};
-
-// Read an integer, octal integer, or floating-point number.
-
-pp.readNumber = function(startsWithDot) {
-  var start = this.pos, isFloat = false, octal = this.input.charCodeAt(this.pos) === 48;
-  if (!startsWithDot && this.readInt(10) === null) this.raise(start, "Invalid number");
-  if (this.input.charCodeAt(this.pos) === 46) {
-    ++this.pos;
-    this.readInt(10);
-    isFloat = true;
-  }
-  var next = this.input.charCodeAt(this.pos);
-  if (next === 69 || next === 101) { // 'eE'
-    next = this.input.charCodeAt(++this.pos);
-    if (next === 43 || next === 45) ++this.pos; // '+-'
-    if (this.readInt(10) === null) this.raise(start, "Invalid number");
-    isFloat = true;
-  }
-  if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
-
-  var str = this.input.slice(start, this.pos), val;
-  if (isFloat) val = parseFloat(str);
-  else if (!octal || str.length === 1) val = parseInt(str, 10);
-  else if (/[89]/.test(str) || this.strict) this.raise(start, "Invalid number");
-  else val = parseInt(str, 8);
-  return this.finishToken(tt.num, val);
-};
-
-// Read a string value, interpreting backslash-escapes.
-
-pp.readCodePoint = function() {
-  var ch = this.input.charCodeAt(this.pos), code;
-
-  if (ch === 123) {
-    if (this.options.ecmaVersion < 6) this.unexpected();
-    ++this.pos;
-    code = this.readHexChar(this.input.indexOf('}', this.pos) - this.pos);
-    ++this.pos;
-    if (code > 0x10FFFF) this.unexpected();
-  } else {
-    code = this.readHexChar(4);
-  }
-  return code;
-};
-
-function codePointToString(code) {
-  // UTF-16 Decoding
-  if (code <= 0xFFFF) return String.fromCharCode(code);
-  return String.fromCharCode(((code - 0x10000) >> 10) + 0xD800,
-                             ((code - 0x10000) & 1023) + 0xDC00);
+import {types as tt} from "./tokentype"
+import Parser from "./state"
+import {reservedWords} from "./identifier"
+
+// 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.
+
+export function parseExpressionAt(input, pos, options) {
+  let p = parser(options, input, pos)
+  p.nextToken()
+  return p.parseExpression()
 }
 
-pp.readString = function(quote) {
-  var out = "", chunkStart = ++this.pos;
-  for (;;) {
-    if (this.pos >= this.input.length) this.raise(this.start, "Unterminated string constant");
-    var ch = this.input.charCodeAt(this.pos);
-    if (ch === quote) break;
-    if (ch === 92) { // '\'
-      out += this.input.slice(chunkStart, this.pos);
-      out += this.readEscapedChar();
-      chunkStart = this.pos;
-    } else {
-      if (isNewLine(ch)) this.raise(this.start, "Unterminated string constant");
-      ++this.pos;
-    }
-  }
-  out += this.input.slice(chunkStart, this.pos++);
-  return this.finishToken(tt.string, out);
-};
+// 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.
 
-// Reads template string tokens.
+export function tokenizer(input, options) {
+  return parser(options, input)
+}
 
-pp.readTmplToken = function() {
-  var out = "", chunkStart = this.pos;
-  for (;;) {
-    if (this.pos >= this.input.length) this.raise(this.start, "Unterminated template");
-    var ch = this.input.charCodeAt(this.pos);
-    if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) { // '`', '${'
-      if (this.pos === this.start && this.type === tt.template) {
-        if (ch === 36) {
-          this.pos += 2;
-          return this.finishToken(tt.dollarBraceL);
-        } else {
-          ++this.pos;
-          return this.finishToken(tt.backQuote);
-        }
-      }
-      out += this.input.slice(chunkStart, this.pos);
-      return this.finishToken(tt.template, out);
-    }
-    if (ch === 92) { // '\'
-      out += this.input.slice(chunkStart, this.pos);
-      out += this.readEscapedChar();
-      chunkStart = this.pos;
-    } else if (isNewLine(ch)) {
-      out += this.input.slice(chunkStart, this.pos);
-      ++this.pos;
-      if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
-        ++this.pos;
-        out += "\n";
-      } else {
-        out += String.fromCharCode(ch);
-      }
-      if (this.options.locations) {
-        ++this.curLine;
-        this.lineStart = this.pos;
-      }
-      chunkStart = this.pos;
-    } else {
-      ++this.pos;
-    }
-  }
-};
-
-// Used to read escaped characters
-
-pp.readEscapedChar = function() {
-  var ch = this.input.charCodeAt(++this.pos);
-  var octal = /^[0-7]+/.exec(this.input.slice(this.pos, this.pos + 3));
-  if (octal) octal = octal[0];
-  while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
-  if (octal === "0") octal = null;
-  ++this.pos;
-  if (octal) {
-    if (this.strict) this.raise(this.pos - 2, "Octal literal in strict mode");
-    this.pos += 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(this.readHexChar(2)); // 'x'
-    case 117: return codePointToString(this.readCodePoint()); // '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 (this.input.charCodeAt(this.pos) === 10) ++this.pos; // '\r\n'
-    case 10: // ' \n'
-      if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }
-      return "";
-    default: return String.fromCharCode(ch);
-    }
-  }
-};
-
-// Used to read character escape sequences ('\x', '\u', '\U').
-
-pp.readHexChar = function(len) {
-  var n = this.readInt(16, len);
-  if (n === null) this.raise(this.start, "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.
-//
-// Incrementally adds only escaped chars, adding other chunks as-is
-// as a micro-optimization.
-
-pp.readWord1 = function() {
-  containsEsc = false;
-  var word = "", first = true, chunkStart = this.pos;
-  var astral = this.options.ecmaVersion >= 6;
-  while (this.pos < this.input.length) {
-    var ch = this.fullCharCodeAtPos();
-    if (isIdentifierChar(ch, astral)) {
-      this.pos += ch <= 0xffff ? 1 : 2;
-    } else if (ch === 92) { // "\"
-      containsEsc = true;
-      word += this.input.slice(chunkStart, this.pos);
-      var escStart = this.pos;
-      if (this.input.charCodeAt(++this.pos) != 117) // "u"
-        this.raise(this.pos, "Expecting Unicode escape sequence \\uXXXX");
-      ++this.pos;
-      var esc = this.readCodePoint();
-      if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))
-        this.raise(escStart, "Invalid Unicode escape");
-      word += codePointToString(esc);
-      chunkStart = this.pos;
-    } else {
-      break;
-    }
-    first = false;
-  }
-  return word + this.input.slice(chunkStart, this.pos);
-};
-
-// Read an identifier or keyword token. Will check for reserved
-// words when necessary.
-
-pp.readWord = function() {
-  var word = this.readWord1();
-  var type = tt.name;
-  if ((this.options.ecmaVersion >= 6 || !containsEsc) && this.isKeyword(word))
-    type = keywordTypes[word];
-  return this.finishToken(type, word);
-};
-
-// 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.
-
-pp.raise = function(pos, message) {
-  var loc = getLineInfo(this.input, pos);
-  message += " (" + loc.line + ":" + loc.column + ")";
-  var err = new SyntaxError(message);
-  err.pos = pos; err.loc = loc; err.raisedAt = this.pos;
-  throw err;
-};
-
-pp.currentPos = function() {
-  return this.options.locations ? [this.start, this.startLoc] : this.start;
-};
+export const getLineInfo = getLineInfo_ // FIXME cleaner way?
 
 // ### Parser utilities
 
@@ -1097,11 +215,7 @@ pp.currentPos = function() {
 
 var Node = exports.Node = function() {};
 
-var SourceLocation = exports.SourceLocation = function(p, start, end) {
-  this.start = start;
-  this.end = end;
-  if (p.sourceFile !== null) this.source = p.sourceFile;
-};
+const pp = Parser.prototype
 
 pp.startNode = function() {
   var node = new Node;
@@ -1194,7 +308,7 @@ pp.expectContextual = function(name) {
 pp.canInsertSemicolon = function() {
   return this.type === tt.eof ||
     this.type === tt.braceR ||
-    newline.test(this.input.slice(this.lastTokEnd, this.start));
+    lineBreak.test(this.input.slice(this.lastTokEnd, this.start));
 };
 
 pp.insertSemicolon = function() {
@@ -1363,7 +477,7 @@ pp.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
 // Parses assignment pattern around given atom if possible.
 
 pp.parseMaybeDefault = function(startPos, left) {
-  startPos = startPos || this.currentPos();
+  startPos = startPos || this.markPosition();
   left = left || this.parseBindingAtom();
   if (!this.eat(tt.eq)) return left;
   var node = this.startNodeAt(startPos);
@@ -1408,7 +522,7 @@ pp.checkPropClash = function(prop, propHash) {
 pp.checkLVal = function(expr, isBinding, checkClashes) {
   switch (expr.type) {
   case "Identifier":
-    if (this.strict && (isStrictBadIdWord(expr.name) || isStrictReservedWord(expr.name)))
+    if (this.strict && (reservedWords.strictBind(expr.name) || reservedWords.strict(expr.name)))
       this.raise(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode");
     if (checkClashes) {
       if (has(checkClashes, expr.name))
@@ -1672,7 +786,7 @@ pp.parseSwitchStatement = function(node) {
 
 pp.parseThrowStatement = function(node) {
   this.next();
-  if (newline.test(this.input.slice(this.lastTokEnd, this.start)))
+  if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))
     this.raise(this.lastTokEnd, "Illegal newline after throw");
   node.argument = this.parseExpression();
   this.semicolon();
@@ -1853,7 +967,7 @@ pp.parseVar = function(node, noIn, kind) {
 // delayed syntax error at correct position).
 
 pp.parseExpression = function(noIn, refShorthandDefaultPos) {
-  var start = this.currentPos();
+  var start = this.markPosition();
   var expr = this.parseMaybeAssign(noIn, refShorthandDefaultPos);
   if (this.type === tt.comma) {
     var node = this.startNodeAt(start);
@@ -1877,7 +991,7 @@ pp.parseMaybeAssign = function(noIn, refShorthandDefaultPos) {
   } else {
     failOnShorthandAssign = false;
   }
-  var start = this.currentPos();
+  var start = this.markPosition();
   var left = this.parseMaybeConditional(noIn, refShorthandDefaultPos);
   if (this.type.isAssign) {
     var node = this.startNodeAt(start);
@@ -1897,7 +1011,7 @@ pp.parseMaybeAssign = function(noIn, refShorthandDefaultPos) {
 // Parse a ternary conditional (`?:`) operator.
 
 pp.parseMaybeConditional = function(noIn, refShorthandDefaultPos) {
-  var start = this.currentPos();
+  var start = this.markPosition();
   var expr = this.parseExprOps(noIn, refShorthandDefaultPos);
   if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
   if (this.eat(tt.question)) {
@@ -1914,7 +1028,7 @@ pp.parseMaybeConditional = function(noIn, refShorthandDefaultPos) {
 // Start the precedence parser.
 
 pp.parseExprOps = function(noIn, refShorthandDefaultPos) {
-  var start = this.currentPos();
+  var start = this.markPosition();
   var expr = this.parseMaybeUnary(refShorthandDefaultPos);
   if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
   return this.parseExprOp(expr, start, -1, noIn);
@@ -1935,7 +1049,7 @@ pp.parseExprOp = function(left, leftStart, minPrec, noIn) {
       node.operator = this.value;
       var op = this.type;
       this.next();
-      var start = this.currentPos();
+      var start = this.markPosition();
       node.right = this.parseExprOp(this.parseMaybeUnary(), start, prec, noIn);
       this.finishNode(node, (op === tt.logicalOR || op === tt.logicalAND) ? "LogicalExpression" : "BinaryExpression");
       return this.parseExprOp(node, leftStart, minPrec, noIn);
@@ -1960,7 +1074,7 @@ pp.parseMaybeUnary = function(refShorthandDefaultPos) {
       this.raise(node.start, "Deleting local variable in strict mode");
     return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
   }
-  var start = this.currentPos();
+  var start = this.markPosition();
   var expr = this.parseExprSubscripts(refShorthandDefaultPos);
   if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
   while (this.type.postfix && !this.canInsertSemicolon()) {
@@ -1978,7 +1092,7 @@ pp.parseMaybeUnary = function(refShorthandDefaultPos) {
 // Parse call, dot, and `[]`-subscript expressions.
 
 pp.parseExprSubscripts = function(refShorthandDefaultPos) {
-  var start = this.currentPos();
+  var start = this.markPosition();
   var expr = this.parseExprAtom(refShorthandDefaultPos);
   if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
   return this.parseSubscripts(expr, start);
@@ -2029,7 +1143,7 @@ pp.parseExprAtom = function(refShorthandDefaultPos) {
     if (this.inGenerator) unexpected();
 
   case tt.name:
-    var start = this.currentPos();
+    var start = this.markPosition();
     var id = this.parseIdent(this.type !== tt.name);
     if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
       return this.parseArrowExpression(this.startNodeAt(start), [id]);
@@ -2096,7 +1210,7 @@ pp.parseLiteral = function(value) {
 };
 
 pp.parseParenAndDistinguishExpression = function() {
-  var start = this.currentPos(), val;
+  var start = this.markPosition(), val;
   if (this.options.ecmaVersion >= 6) {
     this.next();
 
@@ -2104,7 +1218,7 @@ pp.parseParenAndDistinguishExpression = function() {
       return this.parseComprehension(this.startNodeAt(start), true);
     }
 
-    var innerStart = this.currentPos(), exprList = [], first = true;
+    var innerStart = this.markPosition(), exprList = [], first = true;
     var refShorthandDefaultPos = {start: 0}, spreadStart, innerParenStart;
     while (this.type !== tt.parenR) {
       first ? first = false : this.expect(tt.comma);
@@ -2119,7 +1233,7 @@ pp.parseParenAndDistinguishExpression = function() {
         exprList.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
       }
     }
-    var innerEnd = this.currentPos();
+    var innerEnd = this.markPosition();
     this.expect(tt.parenR);
 
     if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
@@ -2158,7 +1272,7 @@ pp.parseParenAndDistinguishExpression = function() {
 pp.parseNew = function() {
   var node = this.startNode();
   this.next();
-  var start = this.currentPos();
+  var start = this.markPosition();
   node.callee = this.parseSubscripts(this.parseExprAtom(), start, true);
   if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false);
   else node.arguments = empty;
@@ -2211,7 +1325,7 @@ pp.parseObj = function(isPattern, refShorthandDefaultPos) {
       prop.method = false;
       prop.shorthand = false;
       if (isPattern || refShorthandDefaultPos)
-        start = this.currentPos();
+        start = this.markPosition();
       if (!isPattern)
         isGenerator = this.eat(tt.star);
     }
@@ -2235,7 +1349,7 @@ pp.parseObj = function(isPattern, refShorthandDefaultPos) {
       prop.kind = "init";
       if (isPattern) {
         if (this.isKeyword(prop.key.name) ||
-            (this.strict && (isStrictBadIdWord(prop.key.name) || isStrictReservedWord(prop.key.name))) ||
+            (this.strict && (reservedWords.strictBind(prop.key.name) || reservedWords.strict(prop.key.name))) ||
             (!this.options.allowReserved && this.isReservedWord(prop.key.name)))
           this.raise(prop.key.start, "Binding " + prop.key.name);
         prop.value = this.parseMaybeDefault(start, prop.key);
@@ -2435,7 +1549,7 @@ pp.parseIdent = function(liberal) {
   if (this.type === tt.name) {
     if (!liberal &&
         ((!this.options.allowReserved && this.isReservedWord(this.value)) ||
-         (this.strict && isStrictReservedWord(this.value)) &&
+         (this.strict && reservedWords.strict(this.value)) &&
          (this.options.ecmaVersion >= 6 || 
           this.input.slice(this.start, this.end).indexOf("\\") == -1)))
       this.raise(this.start, "The keyword '" + this.value + "' is reserved");
diff --git a/src/location.js b/src/location.js
new file mode 100644
index 0000000000..6adbd48d98
--- /dev/null
+++ b/src/location.js
@@ -0,0 +1,66 @@
+import Parser from "./state"
+
+// These are used when `options.locations` is on, for the
+// `startLoc` and `endLoc` properties.
+
+export class Position {
+  constructor(line, col) {
+    this.line = line
+    this.column = col
+  }
+
+  offset(n) {
+    return new Position(this.line, this.column + n)
+  }
+}
+
+export class SourceLocation {
+  constructor(p, start, end) {
+    this.start = start
+    this.end = end
+    if (p.sourceFile !== null) this.source = p.sourceFile
+  }
+}
+
+// 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.
+
+export function getLineInfo(input, offset) {
+  for (let line = 1, cur = 0;;) {
+    lineBreak.lastIndex = cur
+    let match = lineBreak.exec(input)
+    if (match && match.index < offset) {
+      ++line
+      cur = match.index + match[0].length
+    } else {
+      return new Position(line, offset - cur)
+    }
+  }
+}
+
+const pp = Parser.prototype
+
+// 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.
+
+pp.raise = function(pos, message) {
+  var loc = getLineInfo(this.input, pos);
+  message += " (" + loc.line + ":" + loc.column + ")";
+  var err = new SyntaxError(message);
+  err.pos = pos; err.loc = loc; err.raisedAt = this.pos;
+  throw err;
+};
+
+pp.curPosition = function() {
+  return new Position(this.curLine, this.pos - this.lineStart);
+};
+
+pp.markPosition = function() {
+  return this.options.locations ? [this.start, this.startLoc] : this.start;
+};
diff --git a/src/tokenize.js b/src/tokenize.js
index 9a2007e15d..c8f21c749e 100644
--- a/src/tokenize.js
+++ b/src/tokenize.js
@@ -31,20 +31,6 @@ export function isNewLine(code) {
 
 // ## Tokenizer
 
-// These are used when `options.locations` is on, for the
-// `startLoc` and `endLoc` properties.
-
-class Position {
-  constructor(line, col) {
-    this.line = line
-    this.column = col
-  }
-
-  offset(n) {
-    return new Position(this.line, this.column + n)
-  }
-}
-
 // Shorthand because we are going to be adding a _lot_ of methods to
 // this.
 const pp = Parser.prototype
@@ -217,10 +203,6 @@ pp.skipSpace = function() {
   }
 };
 
-pp.curPosition = function() {
-  return new Position(this.curLine, this.pos - this.lineStart);
-};
-
 // Called at the end of every token. Sets `end`, `val`, and
 // maintains `context` and `exprAllowed`, and skips the space after
 // the token, so that the next one's `start` will point at the
@@ -704,21 +686,3 @@ pp.readWord = function() {
     type = keywordTypes[word];
   return this.finishToken(type, word);
 };
-
-// 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.
-
-pp.raise = function(pos, message) {
-  var loc = getLineInfo(this.input, pos);
-  message += " (" + loc.line + ":" + loc.column + ")";
-  var err = new SyntaxError(message);
-  err.pos = pos; err.loc = loc; err.raisedAt = this.pos;
-  throw err;
-};
-
-pp.currentPos = function() {
-  return this.options.locations ? [this.start, this.startLoc] : this.start;
-};

From a1fe3a1859731e0b98acb5369b604500296ad50d Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 11:47:31 +0100
Subject: [PATCH 25/43] Finish splitting up main parser

---
 src/expression.js   |  768 +++++++++++++++++++++
 src/identifier.js   |   12 +-
 src/index.js        | 1557 +------------------------------------------
 src/location.js     |    7 +-
 src/lval.js         |  189 ++++++
 src/node.js         |   57 ++
 src/parseutil.js    |   89 +++
 src/state.js        |   46 +-
 src/statement.js    |  446 +++++++++++++
 src/tokencontext.js |    7 +-
 src/tokenize.js     |   32 +-
 src/whitespace.js   |   12 +
 12 files changed, 1628 insertions(+), 1594 deletions(-)
 create mode 100644 src/expression.js
 create mode 100644 src/lval.js
 create mode 100644 src/node.js
 create mode 100644 src/parseutil.js
 create mode 100644 src/statement.js
 create mode 100644 src/whitespace.js

diff --git a/src/expression.js b/src/expression.js
new file mode 100644
index 0000000000..af0f229859
--- /dev/null
+++ b/src/expression.js
@@ -0,0 +1,768 @@
+// ## 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][opp] 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.
+//
+// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser
+
+import {types as tt} from "./tokentype"
+import {Parser} from "./state"
+import {reservedWords} from "./identifier"
+import {has} from "./util"
+
+const pp = Parser.prototype
+
+// 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.
+
+pp.checkPropClash = function(prop, propHash) {
+  if (this.options.ecmaVersion >= 6) 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 ((this.strict || isGetSet) && other[kind] || !(isGetSet ^ other.init))
+      this.raise(key.start, "Redefinition of property");
+  } else {
+    other = propHash[name] = {
+      init: false,
+      get: false,
+      set: false
+    };
+  }
+  other[kind] = true;
+};
+
+// ### 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 optional arguments are used to
+// forbid the `in` operator (in for loops initalization expressions)
+// and provide reference for storing '=' operator inside shorthand
+// property assignment in contexts where both object expression
+// and object pattern might appear (so it's possible to raise
+// delayed syntax error at correct position).
+
+pp.parseExpression = function(noIn, refShorthandDefaultPos) {
+  var start = this.markPosition();
+  var expr = this.parseMaybeAssign(noIn, refShorthandDefaultPos);
+  if (this.type === tt.comma) {
+    var node = this.startNodeAt(start);
+    node.expressions = [expr];
+    while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn, refShorthandDefaultPos));
+    return this.finishNode(node, "SequenceExpression");
+  }
+  return expr;
+};
+
+// Parse an assignment expression. This includes applications of
+// operators like `+=`.
+
+pp.parseMaybeAssign = function(noIn, refShorthandDefaultPos) {
+  if (this.type == tt._yield && this.inGenerator) return this.parseYield();
+
+  var failOnShorthandAssign;
+  if (!refShorthandDefaultPos) {
+    refShorthandDefaultPos = {start: 0};
+    failOnShorthandAssign = true;
+  } else {
+    failOnShorthandAssign = false;
+  }
+  var start = this.markPosition();
+  var left = this.parseMaybeConditional(noIn, refShorthandDefaultPos);
+  if (this.type.isAssign) {
+    var node = this.startNodeAt(start);
+    node.operator = this.value;
+    node.left = this.type === tt.eq ? this.toAssignable(left) : left;
+    refShorthandDefaultPos.start = 0; // reset because shorthand default was used correctly
+    this.checkLVal(left);
+    this.next();
+    node.right = this.parseMaybeAssign(noIn);
+    return this.finishNode(node, "AssignmentExpression");
+  } else if (failOnShorthandAssign && refShorthandDefaultPos.start) {
+    this.unexpected(refShorthandDefaultPos.start);
+  }
+  return left;
+};
+
+// Parse a ternary conditional (`?:`) operator.
+
+pp.parseMaybeConditional = function(noIn, refShorthandDefaultPos) {
+  var start = this.markPosition();
+  var expr = this.parseExprOps(noIn, refShorthandDefaultPos);
+  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
+  if (this.eat(tt.question)) {
+    var node = this.startNodeAt(start);
+    node.test = expr;
+    node.consequent = this.parseMaybeAssign();
+    this.expect(tt.colon);
+    node.alternate = this.parseMaybeAssign(noIn);
+    return this.finishNode(node, "ConditionalExpression");
+  }
+  return expr;
+};
+
+// Start the precedence parser.
+
+pp.parseExprOps = function(noIn, refShorthandDefaultPos) {
+  var start = this.markPosition();
+  var expr = this.parseMaybeUnary(refShorthandDefaultPos);
+  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
+  return this.parseExprOp(expr, start, -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.
+
+pp.parseExprOp = function(left, leftStart, minPrec, noIn) {
+  var prec = this.type.binop;
+  if (prec != null && (!noIn || this.type !== tt._in)) {
+    if (prec > minPrec) {
+      var node = this.startNodeAt(leftStart);
+      node.left = left;
+      node.operator = this.value;
+      var op = this.type;
+      this.next();
+      var start = this.markPosition();
+      node.right = this.parseExprOp(this.parseMaybeUnary(), start, prec, noIn);
+      this.finishNode(node, (op === tt.logicalOR || op === tt.logicalAND) ? "LogicalExpression" : "BinaryExpression");
+      return this.parseExprOp(node, leftStart, minPrec, noIn);
+    }
+  }
+  return left;
+};
+
+// Parse unary operators, both prefix and postfix.
+
+pp.parseMaybeUnary = function(refShorthandDefaultPos) {
+  if (this.type.prefix) {
+    var node = this.startNode(), update = this.type === tt.incDec;
+    node.operator = this.value;
+    node.prefix = true;
+    this.next();
+    node.argument = this.parseMaybeUnary();
+    if (refShorthandDefaultPos && refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
+    if (update) this.checkLVal(node.argument);
+    else if (this.strict && node.operator === "delete" &&
+             node.argument.type === "Identifier")
+      this.raise(node.start, "Deleting local variable in strict mode");
+    return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+  }
+  var start = this.markPosition();
+  var expr = this.parseExprSubscripts(refShorthandDefaultPos);
+  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
+  while (this.type.postfix && !this.canInsertSemicolon()) {
+    var node = this.startNodeAt(start);
+    node.operator = this.value;
+    node.prefix = false;
+    node.argument = expr;
+    this.checkLVal(expr);
+    this.next();
+    expr = this.finishNode(node, "UpdateExpression");
+  }
+  return expr;
+};
+
+// Parse call, dot, and `[]`-subscript expressions.
+
+pp.parseExprSubscripts = function(refShorthandDefaultPos) {
+  var start = this.markPosition();
+  var expr = this.parseExprAtom(refShorthandDefaultPos);
+  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
+  return this.parseSubscripts(expr, start);
+};
+
+pp.parseSubscripts = function(base, start, noCalls) {
+  if (this.eat(tt.dot)) {
+    var node = this.startNodeAt(start);
+    node.object = base;
+    node.property = this.parseIdent(true);
+    node.computed = false;
+    return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls);
+  } else if (this.eat(tt.bracketL)) {
+    var node = this.startNodeAt(start);
+    node.object = base;
+    node.property = this.parseExpression();
+    node.computed = true;
+    this.expect(tt.bracketR);
+    return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls);
+  } else if (!noCalls && this.eat(tt.parenL)) {
+    var node = this.startNodeAt(start);
+    node.callee = base;
+    node.arguments = this.parseExprList(tt.parenR, false);
+    return this.parseSubscripts(this.finishNode(node, "CallExpression"), start, noCalls);
+  } else if (this.type === tt.backQuote) {
+    var node = this.startNodeAt(start);
+    node.tag = base;
+    node.quasi = this.parseTemplate();
+    return this.parseSubscripts(this.finishNode(node, "TaggedTemplateExpression"), start, 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 `{}`.
+
+pp.parseExprAtom = function(refShorthandDefaultPos) {
+  switch (this.type) {
+  case tt._this:
+  case tt._super:
+    var type = this.type === tt._this ? "ThisExpression" : "SuperExpression";
+    var node = this.startNode();
+    this.next();
+    return this.finishNode(node, type);
+
+  case tt._yield:
+    if (this.inGenerator) unexpected();
+
+  case tt.name:
+    var start = this.markPosition();
+    var id = this.parseIdent(this.type !== tt.name);
+    if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
+      return this.parseArrowExpression(this.startNodeAt(start), [id]);
+    }
+    return id;
+
+  case tt.regexp:
+    var value = this.value;
+    var node = this.parseLiteral(value.value);
+    node.regex = {pattern: value.pattern, flags: value.flags};
+    return node;
+
+  case tt.num: case tt.string:
+    return this.parseLiteral(this.value);
+
+  case tt._null: case tt._true: case tt._false:
+    var node = this.startNode();
+    node.value = this.type === tt._null ? null : this.type === tt._true;
+    node.raw = this.type.keyword;
+    this.next();
+    return this.finishNode(node, "Literal");
+
+  case tt.parenL:
+    return this.parseParenAndDistinguishExpression();
+
+  case tt.bracketL:
+    var node = this.startNode();
+    this.next();
+    // check whether this is array comprehension or regular array
+    if (this.options.ecmaVersion >= 7 && this.type === tt._for) {
+      return this.parseComprehension(node, false);
+    }
+    node.elements = this.parseExprList(tt.bracketR, true, true, refShorthandDefaultPos);
+    return this.finishNode(node, "ArrayExpression");
+
+  case tt.braceL:
+    return this.parseObj(false, refShorthandDefaultPos);
+
+  case tt._function:
+    var node = this.startNode();
+    this.next();
+    return this.parseFunction(node, false);
+
+  case tt._class:
+    return this.parseClass(this.startNode(), false);
+
+  case tt._new:
+    return this.parseNew();
+
+  case tt.backQuote:
+    return this.parseTemplate();
+
+  default:
+    this.unexpected();
+  }
+};
+
+pp.parseLiteral = function(value) {
+  var node = this.startNode();
+  node.value = value;
+  node.raw = this.input.slice(this.start, this.end);
+  this.next();
+  return this.finishNode(node, "Literal");
+};
+
+pp.parseParenExpression = function() {
+  this.expect(tt.parenL);
+  var val = this.parseExpression();
+  this.expect(tt.parenR);
+  return val;
+};
+
+pp.parseParenAndDistinguishExpression = function() {
+  var start = this.markPosition(), val;
+  if (this.options.ecmaVersion >= 6) {
+    this.next();
+
+    if (this.options.ecmaVersion >= 7 && this.type === tt._for) {
+      return this.parseComprehension(this.startNodeAt(start), true);
+    }
+
+    var innerStart = this.markPosition(), exprList = [], first = true;
+    var refShorthandDefaultPos = {start: 0}, spreadStart, innerParenStart;
+    while (this.type !== tt.parenR) {
+      first ? first = false : this.expect(tt.comma);
+      if (this.type === tt.ellipsis) {
+        spreadStart = this.start;
+        exprList.push(this.parseRest());
+        break;
+      } else {
+        if (this.type === tt.parenL && !innerParenStart) {
+          innerParenStart = this.start;
+        }
+        exprList.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
+      }
+    }
+    var innerEnd = this.markPosition();
+    this.expect(tt.parenR);
+
+    if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
+      if (innerParenStart) this.unexpected(innerParenStart);
+      return this.parseArrowExpression(this.startNodeAt(start), exprList);
+    }
+
+    if (!exprList.length) this.unexpected(this.lastTokStart);
+    if (spreadStart) this.unexpected(spreadStart);
+    if (refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
+
+    if (exprList.length > 1) {
+      val = this.startNodeAt(innerStart);
+      val.expressions = exprList;
+      this.finishNodeAt(val, "SequenceExpression", innerEnd);
+    } else {
+      val = exprList[0];
+    }
+  } else {
+    val = this.parseParenExpression();
+  }
+
+  if (this.options.preserveParens) {
+    var par = this.startNodeAt(start);
+    par.expression = val;
+    return this.finishNode(par, "ParenthesizedExpression");
+  } else {
+    return val;
+  }
+};
+
+// 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
+
+const empty = []
+
+pp.parseNew = function() {
+  var node = this.startNode();
+  this.next();
+  var start = this.markPosition();
+  node.callee = this.parseSubscripts(this.parseExprAtom(), start, true);
+  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false);
+  else node.arguments = empty;
+  return this.finishNode(node, "NewExpression");
+};
+
+// Parse template expression.
+
+pp.parseTemplateElement = function() {
+  var elem = this.startNode();
+  elem.value = {
+    raw: this.input.slice(this.start, this.end),
+    cooked: this.value
+  };
+  this.next();
+  elem.tail = this.type === tt.backQuote;
+  return this.finishNode(elem, "TemplateElement");
+};
+
+pp.parseTemplate = function() {
+  var node = this.startNode();
+  this.next();
+  node.expressions = [];
+  var curElt = this.parseTemplateElement();
+  node.quasis = [curElt];
+  while (!curElt.tail) {
+    this.expect(tt.dollarBraceL);
+    node.expressions.push(this.parseExpression());
+    this.expect(tt.braceR);
+    node.quasis.push(curElt = this.parseTemplateElement());
+  }
+  this.next();
+  return this.finishNode(node, "TemplateLiteral");
+};
+
+// Parse an object literal or binding pattern.
+
+pp.parseObj = function(isPattern, refShorthandDefaultPos) {
+  var node = this.startNode(), first = true, propHash = {};
+  node.properties = [];
+  this.next();
+  while (!this.eat(tt.braceR)) {
+    if (!first) {
+      this.expect(tt.comma);
+      if (this.afterTrailingComma(tt.braceR)) break;
+    } else first = false;
+
+    var prop = this.startNode(), isGenerator, start;
+    if (this.options.ecmaVersion >= 6) {
+      prop.method = false;
+      prop.shorthand = false;
+      if (isPattern || refShorthandDefaultPos)
+        start = this.markPosition();
+      if (!isPattern)
+        isGenerator = this.eat(tt.star);
+    }
+    this.parsePropertyName(prop);
+    if (this.eat(tt.colon)) {
+      prop.value = isPattern ? this.parseMaybeDefault() : this.parseMaybeAssign(false, refShorthandDefaultPos);
+      prop.kind = "init";
+    } else if (this.options.ecmaVersion >= 6 && this.type === tt.parenL) {
+      if (isPattern) this.unexpected();
+      prop.kind = "init";
+      prop.method = true;
+      prop.value = this.parseMethod(isGenerator);
+    } else if (this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
+               (prop.key.name === "get" || prop.key.name === "set") &&
+               (this.type != tt.comma && this.type != tt.braceR)) {
+      if (isGenerator || isPattern) this.unexpected();
+      prop.kind = prop.key.name;
+      this.parsePropertyName(prop);
+      prop.value = this.parseMethod(false);
+    } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
+      prop.kind = "init";
+      if (isPattern) {
+        if (this.isKeyword(prop.key.name) ||
+            (this.strict && (reservedWords.strictBind(prop.key.name) || reservedWords.strict(prop.key.name))) ||
+            (!this.options.allowReserved && this.isReservedWord(prop.key.name)))
+          this.raise(prop.key.start, "Binding " + prop.key.name);
+        prop.value = this.parseMaybeDefault(start, prop.key);
+      } else if (this.type === tt.eq && refShorthandDefaultPos) {
+        if (!refShorthandDefaultPos.start)
+          refShorthandDefaultPos.start = this.start;
+        prop.value = this.parseMaybeDefault(start, prop.key);
+      } else {
+        prop.value = prop.key;
+      }
+      prop.shorthand = true;
+    } else this.unexpected();
+
+    this.checkPropClash(prop, propHash);
+    node.properties.push(this.finishNode(prop, "Property"));
+  }
+  return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");
+};
+
+pp.parsePropertyName = function(prop) {
+  if (this.options.ecmaVersion >= 6) {
+    if (this.eat(tt.bracketL)) {
+      prop.computed = true;
+      prop.key = this.parseExpression();
+      this.expect(tt.bracketR);
+      return;
+    } else {
+      prop.computed = false;
+    }
+  }
+  prop.key = (this.type === tt.num || this.type === tt.string) ? this.parseExprAtom() : this.parseIdent(true);
+};
+
+// Initialize empty function node.
+
+pp.initFunction = function(node) {
+  node.id = null;
+  if (this.options.ecmaVersion >= 6) {
+    node.generator = false;
+    node.expression = false;
+  }
+};
+
+// Parse object or class method.
+
+pp.parseMethod = function(isGenerator) {
+  var node = this.startNode();
+  this.initFunction(node);
+  this.expect(tt.parenL);
+  node.params = this.parseBindingList(tt.parenR, false, false);
+  var allowExpressionBody;
+  if (this.options.ecmaVersion >= 6) {
+    node.generator = isGenerator;
+    allowExpressionBody = true;
+  } else {
+    allowExpressionBody = false;
+  }
+  this.parseFunctionBody(node, allowExpressionBody);
+  return this.finishNode(node, "FunctionExpression");
+};
+
+// Parse arrow function expression with given parameters.
+
+pp.parseArrowExpression = function(node, params) {
+  this.initFunction(node);
+  node.params = this.toAssignableList(params, true);
+  this.parseFunctionBody(node, true);
+  return this.finishNode(node, "ArrowFunctionExpression");
+};
+
+// Parse function body and check parameters.
+
+pp.parseFunctionBody = function(node, allowExpression) {
+  var isExpression = allowExpression && this.type !== tt.braceL;
+
+  if (isExpression) {
+    node.body = this.parseMaybeAssign();
+    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 = this.inFunction, oldInGen = this.inGenerator, oldLabels = this.labels;
+    this.inFunction = true; this.inGenerator = node.generator; this.labels = [];
+    node.body = this.parseBlock(true);
+    node.expression = false;
+    this.inFunction = oldInFunc; this.inGenerator = oldInGen; this.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 (this.strict || !isExpression && node.body.body.length && this.isUseStrict(node.body.body[0])) {
+    var nameHash = {}, oldStrict = this.strict;
+    this.strict = true;
+    if (node.id)
+      this.checkLVal(node.id, true);
+    for (var i = 0; i < node.params.length; i++)
+      this.checkLVal(node.params[i], true, nameHash);
+    this.strict = oldStrict;
+  }
+};
+
+// 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).
+
+pp.parseExprList = function(close, allowTrailingComma, allowEmpty, refShorthandDefaultPos) {
+  var elts = [], first = true;
+  while (!this.eat(close)) {
+    if (!first) {
+      this.expect(tt.comma);
+      if (allowTrailingComma && this.afterTrailingComma(close)) break;
+    } else first = false;
+
+    if (allowEmpty && this.type === tt.comma) {
+      elts.push(null);
+    } else {
+      if (this.type === tt.ellipsis)
+        elts.push(this.parseSpread(refShorthandDefaultPos));
+      else
+        elts.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
+    }
+  }
+  return elts;
+};
+
+// Parse the next token as an identifier. If `liberal` is true (used
+// when parsing properties), it will also convert keywords into
+// identifiers.
+
+pp.parseIdent = function(liberal) {
+  var node = this.startNode();
+  if (liberal && this.options.allowReserved == "never") liberal = false;
+  if (this.type === tt.name) {
+    if (!liberal &&
+        ((!this.options.allowReserved && this.isReservedWord(this.value)) ||
+         (this.strict && reservedWords.strict(this.value)) &&
+         (this.options.ecmaVersion >= 6 || 
+          this.input.slice(this.start, this.end).indexOf("\\") == -1)))
+      this.raise(this.start, "The keyword '" + this.value + "' is reserved");
+    node.name = this.value;
+  } else if (liberal && this.type.keyword) {
+    node.name = this.type.keyword;
+  } else {
+    this.unexpected();
+  }
+  this.next();
+  return this.finishNode(node, "Identifier");
+};
+
+// Parses module export declaration.
+
+pp.parseExport = function(node) {
+  this.next();
+  // export * from '...';
+  if (this.eat(tt.star)) {
+    this.expectContextual("from");
+    node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
+    this.semicolon();
+    return this.finishNode(node, "ExportAllDeclaration");
+  }
+  if (this.eat(tt._default)) { // export default ...;
+    var expr = this.parseMaybeAssign();
+    if (expr.id) {
+      switch (expr.type) {
+      case "FunctionExpression": expr.type = "FunctionDeclaration"; break;
+      case "ClassExpression": expr.type = "ClassDeclaration"; break;
+      }
+    }
+    node.declaration = expr;
+    this.semicolon();
+    return this.finishNode(node, "ExportDefaultDeclaration");
+  }
+  // export var|const|let|function|class ...;
+  if (this.type.keyword) {
+    node.declaration = this.parseStatement(true);
+    node.specifiers = [];
+    node.source = null;
+  } else { // export { x, y as z } [from '...'];
+    node.declaration = null;
+    node.specifiers = this.parseExportSpecifiers();
+    if (this.eatContextual("from")) {
+      node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
+    } else {
+      node.source = null;
+    }
+    this.semicolon();
+  }
+  return this.finishNode(node, "ExportNamedDeclaration");
+};
+
+// Parses a comma-separated list of module exports.
+
+pp.parseExportSpecifiers = function() {
+  var nodes = [], first = true;
+  // export { x, y as z } [from '...']
+  this.expect(tt.braceL);
+  while (!this.eat(tt.braceR)) {
+    if (!first) {
+      this.expect(tt.comma);
+      if (this.afterTrailingComma(tt.braceR)) break;
+    } else first = false;
+
+    var node = this.startNode();
+    node.local = this.parseIdent(this.type === tt._default);
+    node.exported = this.eatContextual("as") ? this.parseIdent(true) : node.local;
+    nodes.push(this.finishNode(node, "ExportSpecifier"));
+  }
+  return nodes;
+};
+
+// Parses import declaration.
+
+pp.parseImport = function(node) {
+  this.next();
+  // import '...';
+  if (this.type === tt.string) {
+    node.specifiers = empty;
+    node.source = this.parseExprAtom();
+    node.kind = "";
+  } else {
+    node.specifiers = this.parseImportSpecifiers();
+    this.expectContextual("from");
+    node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
+  }
+  this.semicolon();
+  return this.finishNode(node, "ImportDeclaration");
+};
+
+// Parses a comma-separated list of module imports.
+
+pp.parseImportSpecifiers = function() {
+  var nodes = [], first = true;
+  if (this.type === tt.name) {
+    // import defaultObj, { x, y as z } from '...'
+    var node = this.startNode();
+    node.local = this.parseIdent();
+    this.checkLVal(node.local, true);
+    nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
+    if (!this.eat(tt.comma)) return nodes;
+  }
+  if (this.type === tt.star) {
+    var node = this.startNode();
+    this.next();
+    this.expectContextual("as");
+    node.local = this.parseIdent();
+    this.checkLVal(node.local, true);
+    nodes.push(this.finishNode(node, "ImportNamespaceSpecifier"));
+    return nodes;
+  }
+  this.expect(tt.braceL);
+  while (!this.eat(tt.braceR)) {
+    if (!first) {
+      this.expect(tt.comma);
+      if (this.afterTrailingComma(tt.braceR)) break;
+    } else first = false;
+
+    var node = this.startNode();
+    node.imported = this.parseIdent(true);
+    node.local = this.eatContextual("as") ? this.parseIdent() : node.imported;
+    this.checkLVal(node.local, true);
+    nodes.push(this.finishNode(node, "ImportSpecifier"));
+  }
+  return nodes;
+};
+
+// Parses yield expression inside generator.
+
+pp.parseYield = function() {
+  var node = this.startNode();
+  this.next();
+  if (this.type == tt.semi || this.canInsertSemicolon() || (this.type != tt.star && !this.type.startsExpr)) {
+    node.delegate = false;
+    node.argument = null;
+  } else {
+    node.delegate = this.eat(tt.star);
+    node.argument = this.parseMaybeAssign();
+  }
+  return this.finishNode(node, "YieldExpression");
+};
+
+// Parses array and generator comprehensions.
+
+pp.parseComprehension = function(node, isGenerator) {
+  node.blocks = [];
+  while (this.type === tt._for) {
+    var block = this.startNode();
+    this.next();
+    this.expect(tt.parenL);
+    block.left = this.parseBindingAtom();
+    this.checkLVal(block.left, true);
+    this.expectContextual("of");
+    block.right = this.parseExpression();
+    this.expect(tt.parenR);
+    node.blocks.push(this.finishNode(block, "ComprehensionBlock"));
+  }
+  node.filter = this.eat(tt._if) ? this.parseParenExpression() : null;
+  node.body = this.parseExpression();
+  this.expect(isGenerator ? tt.parenR : tt.bracketR);
+  node.generator = isGenerator;
+  return this.finishNode(node, "ComprehensionExpression");
+};
diff --git a/src/identifier.js b/src/identifier.js
index ea009f6fb1..fd2794c27a 100644
--- a/src/identifier.js
+++ b/src/identifier.js
@@ -73,13 +73,13 @@ export const keywords = {
 // 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\u2118-\u211d\u2124\u2126\u2128\u212a-\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\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\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 = "\u200c\u200d\xb7\u0300-\u036f\u0387\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\u1369-\u1371\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-\u19da\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\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";
+let 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\u2118-\u211d\u2124\u2126\u2128\u212a-\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\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\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"
+let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\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\u1369-\u1371\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-\u19da\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\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 + "]");
-nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]")
+const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]")
+
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null
 
 // These are a run-length and offset encoded representation of the
 // >0xffff code points that are a valid part of identifiers. The
diff --git a/src/index.js b/src/index.js
index dc10882782..0842ab400d 100644
--- a/src/index.js
+++ b/src/index.js
@@ -19,9 +19,23 @@
 // [dammit]: acorn_loose.js
 // [walk]: util/walk.js
 
+import {Parser} from "./state"
 import {has, isArray} from "./util"
-import {lineBreak} from "./tokenize"
-import {getLineInfo as getLineInfo_, SourceLocation} from "./location"
+import {SourceLocation} from "./location"
+import "./parseutil"
+import "./statement"
+import "./lval"
+import "./expression"
+
+export {Parser} from "./state"
+export {SourceLocation} from "./location"
+export {getLineInfo} from "./location"
+export {Node} from "./node"
+export {TokenType, types as tokTypes} from "./tokentype"
+export {TokContext, types as tokContexts} from "./tokencontext"
+export {isIdentifierChar, isIdentifierStart} from "./identifier"
+export {Token} from "./tokenize"
+export {isNewLine, lineBreak} from "./whitespace"
 
 export const version = "0.12.1"
 
@@ -159,34 +173,6 @@ function pushComment(options, array) {
   }
 }
 
-function parser(options, input) {
-  return new Parser(getOptions(options), String(input))
-}
-
-// ## 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][opp] 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.
-//
-// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser
-
-import {types as tt} from "./tokentype"
-import Parser from "./state"
-import {reservedWords} from "./identifier"
-
 // 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.
@@ -207,1511 +193,6 @@ export function tokenizer(input, options) {
   return parser(options, input)
 }
 
-export const getLineInfo = getLineInfo_ // FIXME cleaner way?
-
-// ### Parser utilities
-
-// Start an AST node, attaching a start offset.
-
-var Node = exports.Node = function() {};
-
-const pp = Parser.prototype
-
-pp.startNode = function() {
-  var node = new Node;
-  node.start = this.start;
-  if (this.options.locations)
-    node.loc = new SourceLocation(this, this.startLoc);
-  if (this.options.directSourceFile)
-    node.sourceFile = this.options.directSourceFile;
-  if (this.options.ranges)
-    node.range = [this.start, 0];
-  return node;
-};
-
-pp.startNodeAt = function(pos) {
-  var node = new Node, start = pos;
-  if (this.options.locations) {
-    node.loc = new SourceLocation(this, start[1]);
-    start = pos[0];
-  }
-  node.start = start;
-  if (this.options.directSourceFile)
-    node.sourceFile = this.options.directSourceFile;
-  if (this.options.ranges)
-    node.range = [start, 0];
-  return node;
-};
-
-// Finish an AST node, adding `type` and `end` properties.
-
-pp.finishNode = function(node, type) {
-  node.type = type;
-  node.end = this.lastTokEnd;
-  if (this.options.locations)
-    node.loc.end = this.lastTokEndLoc;
-  if (this.options.ranges)
-    node.range[1] = this.lastTokEnd;
-  return node;
-};
-
-// Finish node at given position
-
-pp.finishNodeAt = function(node, type, pos) {
-  if (this.options.locations) { node.loc.end = pos[1]; pos = pos[0]; }
-  node.type = type;
-  node.end = pos;
-  if (this.options.ranges)
-    node.range[1] = pos;
-  return node;
-};
-
-// Test whether a statement node is the string literal `"use strict"`.
-
-pp.isUseStrict = function(stmt) {
-  return this.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.
-
-pp.eat = function(type) {
-  if (this.type === type) {
-    this.next();
-    return true;
-  } else {
-    return false;
-  }
-};
-
-// Tests whether parsed token is a contextual keyword.
-
-pp.isContextual = function(name) {
-  return this.type === tt.name && this.value === name;
-};
-
-// Consumes contextual keyword if possible.
-
-pp.eatContextual = function(name) {
-  return this.value === name && this.eat(tt.name);
-};
-
-// Asserts that following token is given contextual keyword.
-
-pp.expectContextual = function(name) {
-  if (!this.eatContextual(name)) this.unexpected();
-};
-
-// Test whether a semicolon can be inserted at the current position.
-
-pp.canInsertSemicolon = function() {
-  return this.type === tt.eof ||
-    this.type === tt.braceR ||
-    lineBreak.test(this.input.slice(this.lastTokEnd, this.start));
-};
-
-pp.insertSemicolon = function() {
-  if (this.canInsertSemicolon()) {
-    if (this.options.onInsertedSemicolon)
-      this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc)
-    return true;
-  }
-};
-
-// Consume a semicolon, or, failing that, see if we are allowed to
-// pretend that there is a semicolon at this position.
-
-pp.semicolon = function() {
-  if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected();
-};
-
-pp.afterTrailingComma = function(tokType) {
-  if (this.type == tokType) {
-    if (this.options.onTrailingComma)
-      this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc);
-    this.next();
-    return true;
-  }
-};
-
-// Expect a token of a given type. If found, consume it, otherwise,
-// raise an unexpected token error.
-
-pp.expect = function(type) {
-  this.eat(type) || this.unexpected();
-};
-
-// Raise an unexpected token error.
-
-pp.unexpected = function(pos) {
-  this.raise(pos != null ? pos : this.start, "Unexpected token");
-};
-
-// Convert existing expression atom to assignable pattern
-// if possible.
-
-pp.toAssignable = function(node, isBinding) {
-  if (this.options.ecmaVersion >= 6 && node) {
-    switch (node.type) {
-    case "Identifier":
-    case "ObjectPattern":
-    case "ArrayPattern":
-    case "AssignmentPattern":
-      break;
-
-    case "ObjectExpression":
-      node.type = "ObjectPattern";
-      for (var i = 0; i < node.properties.length; i++) {
-        var prop = node.properties[i];
-        if (prop.kind !== "init") this.raise(prop.key.start, "Object pattern can't contain getter or setter");
-        this.toAssignable(prop.value, isBinding);
-      }
-      break;
-
-    case "ArrayExpression":
-      node.type = "ArrayPattern";
-      this.toAssignableList(node.elements, isBinding);
-      break;
-
-    case "AssignmentExpression":
-      if (node.operator === "=") {
-        node.type = "AssignmentPattern";
-      } else {
-        this.raise(node.left.end, "Only '=' operator can be used for specifying default value.");
-      }
-      break;
-
-    case "MemberExpression":
-      if (!isBinding) break;
-
-    default:
-      this.raise(node.start, "Assigning to rvalue");
-    }
-  }
-  return node;
-};
-
-// Convert list of expression atoms to binding list.
-
-pp.toAssignableList = function(exprList, isBinding) {
-  var end = exprList.length;
-  if (end) {
-    var last = exprList[end - 1];
-    if (last && last.type == "RestElement") {
-      --end;
-    } else if (last && last.type == "SpreadElement") {
-      last.type = "RestElement";
-      var arg = last.argument;
-      this.toAssignable(arg, isBinding);
-      if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern")
-        this.unexpected(arg.start);
-      --end;
-    }
-  }
-  for (var i = 0; i < end; i++) {
-    var elt = exprList[i];
-    if (elt) this.toAssignable(elt, isBinding);
-  }
-  return exprList;
-};
-
-// Parses spread element.
-
-pp.parseSpread = function(refShorthandDefaultPos) {
-  var node = this.startNode();
-  this.next();
-  node.argument = this.parseMaybeAssign(refShorthandDefaultPos);
-  return this.finishNode(node, "SpreadElement");
-};
-
-pp.parseRest = function() {
-  var node = this.startNode();
-  this.next();
-  node.argument = this.type === tt.name || this.type === tt.bracketL ? this.parseBindingAtom() : this.unexpected();
-  return this.finishNode(node, "RestElement");
-};
-
-// Parses lvalue (assignable) atom.
-
-pp.parseBindingAtom = function() {
-  if (this.options.ecmaVersion < 6) return this.parseIdent();
-  switch (this.type) {
-  case tt.name:
-    return this.parseIdent();
-
-  case tt.bracketL:
-    var node = this.startNode();
-    this.next();
-    node.elements = this.parseBindingList(tt.bracketR, true, true);
-    return this.finishNode(node, "ArrayPattern");
-
-  case tt.braceL:
-    return this.parseObj(true);
-
-  default:
-    this.unexpected();
-  }
-};
-
-pp.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
-  var elts = [], first = true;
-  while (!this.eat(close)) {
-    if (first) first = false;
-    else this.expect(tt.comma);
-    if (allowEmpty && this.type === tt.comma) {
-      elts.push(null);
-    } else if (allowTrailingComma && this.afterTrailingComma(close)) {
-      break;
-    } else if (this.type === tt.ellipsis) {
-      elts.push(this.parseRest());
-      this.expect(close);
-      break;
-    } else {
-      elts.push(this.parseMaybeDefault());
-    }
-  }
-  return elts;
-};
-
-// Parses assignment pattern around given atom if possible.
-
-pp.parseMaybeDefault = function(startPos, left) {
-  startPos = startPos || this.markPosition();
-  left = left || this.parseBindingAtom();
-  if (!this.eat(tt.eq)) return left;
-  var node = this.startNodeAt(startPos);
-  node.operator = "=";
-  node.left = left;
-  node.right = this.parseMaybeAssign();
-  return this.finishNode(node, "AssignmentPattern");
-};
-
-// 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.
-
-pp.checkPropClash = function(prop, propHash) {
-  if (this.options.ecmaVersion >= 6) 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 ((this.strict || isGetSet) && other[kind] || !(isGetSet ^ other.init))
-      this.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.
-
-pp.checkLVal = function(expr, isBinding, checkClashes) {
-  switch (expr.type) {
-  case "Identifier":
-    if (this.strict && (reservedWords.strictBind(expr.name) || reservedWords.strict(expr.name)))
-      this.raise(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode");
-    if (checkClashes) {
-      if (has(checkClashes, expr.name))
-        this.raise(expr.start, "Argument name clash in strict mode");
-      checkClashes[expr.name] = true;
-    }
-    break;
-
-  case "MemberExpression":
-    if (isBinding) this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " member expression");
-    break;
-
-  case "ObjectPattern":
-    for (var i = 0; i < expr.properties.length; i++)
-      this.checkLVal(expr.properties[i].value, isBinding, checkClashes);
-    break;
-
-  case "ArrayPattern":
-    for (var i = 0; i < expr.elements.length; i++) {
-      var elem = expr.elements[i];
-      if (elem) this.checkLVal(elem, isBinding, checkClashes);
-    }
-    break;
-
-  case "AssignmentPattern":
-    this.checkLVal(expr.left, isBinding, checkClashes);
-    break;
-
-  case "RestElement":
-    this.checkLVal(expr.argument, isBinding, checkClashes);
-    break;
-
-  default:
-    this.raise(expr.start, (isBinding ? "Binding" : "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.
-
-pp.parseTopLevel = function(node) {
-  var first = true;
-  if (!node.body) node.body = [];
-  while (this.type !== tt.eof) {
-    var stmt = this.parseStatement(true, true);
-    node.body.push(stmt);
-    if (first && this.isUseStrict(stmt)) this.setStrict(true);
-    first = false;
-  }
-  this.next();
-  if (this.options.ecmaVersion >= 6) {
-    node.sourceType = this.options.sourceType;
-  }
-  return this.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.
-
-pp.parseStatement = function(declaration, topLevel) {
-  var starttype = this.type, node = this.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 tt._break: case tt._continue: return this.parseBreakContinueStatement(node, starttype.keyword);
-  case tt._debugger: return this.parseDebuggerStatement(node);
-  case tt._do: return this.parseDoStatement(node);
-  case tt._for: return this.parseForStatement(node);
-  case tt._function:
-    if (!declaration && this.options.ecmaVersion >= 6) this.unexpected();
-    return this.parseFunctionStatement(node);
-  case tt._class:
-    if (!declaration) this.unexpected();
-    return this.parseClass(node, true);
-  case tt._if: return this.parseIfStatement(node);
-  case tt._return: return this.parseReturnStatement(node);
-  case tt._switch: return this.parseSwitchStatement(node);
-  case tt._throw: return this.parseThrowStatement(node);
-  case tt._try: return this.parseTryStatement(node);
-  case tt._let: case tt._const: if (!declaration) this.unexpected(); // NOTE: falls through to _var
-  case tt._var: return this.parseVarStatement(node, starttype);
-  case tt._while: return this.parseWhileStatement(node);
-  case tt._with: return this.parseWithStatement(node);
-  case tt.braceL: return this.parseBlock(); // no point creating a function for this
-  case tt.semi: return this.parseEmptyStatement(node);
-  case tt._export:
-  case tt._import:
-    if (!this.options.allowImportExportEverywhere) {
-      if (!topLevel)
-        this.raise(this.start, "'import' and 'export' may only appear at the top level");
-      if (!this.inModule)
-        this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
-    }
-    return starttype === tt._import ? this.parseImport(node) : this.parseExport(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 = this.value, expr = this.parseExpression();
-    if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon))
-      return this.parseLabeledStatement(node, maybeName, expr);
-    else return this.parseExpressionStatement(node, expr);
-  }
-};
-
-pp.parseBreakContinueStatement = function(node, keyword) {
-  var isBreak = keyword == "break";
-  this.next();
-  if (this.eat(tt.semi) || this.insertSemicolon()) node.label = null;
-  else if (this.type !== tt.name) this.unexpected();
-  else {
-    node.label = this.parseIdent();
-    this.semicolon();
-  }
-
-  // Verify that there is an actual destination to break or
-  // continue to.
-  for (var i = 0; i < this.labels.length; ++i) {
-    var lab = this.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 === this.labels.length) this.raise(node.start, "Unsyntactic " + keyword);
-  return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-};
-
-pp.parseDebuggerStatement = function(node) {
-  this.next();
-  this.semicolon();
-  return this.finishNode(node, "DebuggerStatement");
-};
-
-pp.parseDoStatement = function(node) {
-  this.next();
-  this.labels.push(loopLabel);
-  node.body = this.parseStatement(false);
-  this.labels.pop();
-  this.expect(tt._while);
-  node.test = this.parseParenExpression();
-  if (this.options.ecmaVersion >= 6)
-    this.eat(tt.semi);
-  else
-    this.semicolon();
-  return this.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.
-
-pp.parseForStatement = function(node) {
-  this.next();
-  this.labels.push(loopLabel);
-  this.expect(tt.parenL);
-  if (this.type === tt.semi) return this.parseFor(node, null);
-  if (this.type === tt._var || this.type === tt._let || this.type === tt._const) {
-    var init = this.startNode(), varKind = this.type;
-    this.next();
-    this.parseVar(init, true, varKind);
-    this.finishNode(init, "VariableDeclaration");
-    if ((this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init.declarations.length === 1 &&
-        !(varKind !== tt._var && init.declarations[0].init))
-      return this.parseForIn(node, init);
-    return this.parseFor(node, init);
-  }
-  var refShorthandDefaultPos = {start: 0};
-  var init = this.parseExpression(true, refShorthandDefaultPos);
-  if (this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
-    this.toAssignable(init);
-    this.checkLVal(init);
-    return this.parseForIn(node, init);
-  } else if (refShorthandDefaultPos.start) {
-    this.unexpected(refShorthandDefaultPos.start);
-  }
-  return this.parseFor(node, init);
-};
-
-pp.parseFunctionStatement = function(node) {
-  this.next();
-  return this.parseFunction(node, true);
-};
-
-pp.parseIfStatement = function(node) {
-  this.next();
-  node.test = this.parseParenExpression();
-  node.consequent = this.parseStatement(false);
-  node.alternate = this.eat(tt._else) ? this.parseStatement(false) : null;
-  return this.finishNode(node, "IfStatement");
-};
-
-pp.parseReturnStatement = function(node) {
-  if (!this.inFunction && !this.options.allowReturnOutsideFunction)
-    this.raise(this.start, "'return' outside of function");
-  this.next();
-
-  // In `return` (and `break`/`continue`), the keywords with
-  // optional arguments, we eagerly look for a semicolon or the
-  // possibility to insert one.
-
-  if (this.eat(tt.semi) || this.insertSemicolon()) node.argument = null;
-  else { node.argument = this.parseExpression(); this.semicolon(); }
-  return this.finishNode(node, "ReturnStatement");
-};
-
-pp.parseSwitchStatement = function(node) {
-  this.next();
-  node.discriminant = this.parseParenExpression();
-  node.cases = [];
-  this.expect(tt.braceL);
-  this.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; this.type != tt.braceR;) {
-    if (this.type === tt._case || this.type === tt._default) {
-      var isCase = this.type === tt._case;
-      if (cur) this.finishNode(cur, "SwitchCase");
-      node.cases.push(cur = this.startNode());
-      cur.consequent = [];
-      this.next();
-      if (isCase) cur.test = this.parseExpression();
-      else {
-        if (sawDefault) this.raise(this.lastTokStart, "Multiple default clauses"); sawDefault = true;
-        cur.test = null;
-      }
-      this.expect(tt.colon);
-    } else {
-      if (!cur) this.unexpected();
-      cur.consequent.push(this.parseStatement(true));
-    }
-  }
-  if (cur) this.finishNode(cur, "SwitchCase");
-  this.next(); // Closing brace
-  this.labels.pop();
-  return this.finishNode(node, "SwitchStatement");
-};
-
-pp.parseThrowStatement = function(node) {
-  this.next();
-  if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))
-    this.raise(this.lastTokEnd, "Illegal newline after throw");
-  node.argument = this.parseExpression();
-  this.semicolon();
-  return this.finishNode(node, "ThrowStatement");
-};
-
-// Reused empty array added for node fields that are always empty.
-
-var empty = [];
-
-
-pp.parseTryStatement = function(node) {
-  this.next();
-  node.block = this.parseBlock();
-  node.handler = null;
-  if (this.type === tt._catch) {
-    var clause = this.startNode();
-    this.next();
-    this.expect(tt.parenL);
-    clause.param = this.parseBindingAtom();
-    this.checkLVal(clause.param, true);
-    this.expect(tt.parenR);
-    clause.guard = null;
-    clause.body = this.parseBlock();
-    node.handler = this.finishNode(clause, "CatchClause");
-  }
-  node.guardedHandlers = empty;
-  node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;
-  if (!node.handler && !node.finalizer)
-    this.raise(node.start, "Missing catch or finally clause");
-  return this.finishNode(node, "TryStatement");
-};
-
-pp.parseVarStatement = function(node, kind) {
-  this.next();
-  this.parseVar(node, false, kind);
-  this.semicolon();
-  return this.finishNode(node, "VariableDeclaration");
-};
-
-pp.parseWhileStatement = function(node) {
-  this.next();
-  node.test = this.parseParenExpression();
-  this.labels.push(loopLabel);
-  node.body = this.parseStatement(false);
-  this.labels.pop();
-  return this.finishNode(node, "WhileStatement");
-};
-
-pp.parseWithStatement = function(node) {
-  if (this.strict) this.raise(this.start, "'with' in strict mode");
-  this.next();
-  node.object = this.parseParenExpression();
-  node.body = this.parseStatement(false);
-  return this.finishNode(node, "WithStatement");
-};
-
-pp.parseEmptyStatement = function(node) {
-  this.next();
-  return this.finishNode(node, "EmptyStatement");
-};
-
-pp.parseLabeledStatement = function(node, maybeName, expr) {
-  for (var i = 0; i < this.labels.length; ++i)
-    if (this.labels[i].name === maybeName) this.raise(expr.start, "Label '" + maybeName + "' is already declared");
-  var kind = this.type.isLoop ? "loop" : this.type === tt._switch ? "switch" : null;
-  this.labels.push({name: maybeName, kind: kind});
-  node.body = this.parseStatement(true);
-  this.labels.pop();
-  node.label = expr;
-  return this.finishNode(node, "LabeledStatement");
-};
-
-pp.parseExpressionStatement = function(node, expr) {
-  node.expression = expr;
-  this.semicolon();
-  return this.finishNode(node, "ExpressionStatement");
-};
-
-// Used for constructs like `switch` and `if` that insist on
-// parentheses around their expression.
-
-pp.parseParenExpression = function() {
-  this.expect(tt.parenL);
-  var val = this.parseExpression();
-  this.expect(tt.parenR);
-  return val;
-};
-
-// Parse a semicolon-enclosed block of statements, handling `"use
-// strict"` declarations when `allowStrict` is true (used for
-// function bodies).
-
-pp.parseBlock = function(allowStrict) {
-  var node = this.startNode(), first = true, oldStrict;
-  node.body = [];
-  this.expect(tt.braceL);
-  while (!this.eat(tt.braceR)) {
-    var stmt = this.parseStatement(true);
-    node.body.push(stmt);
-    if (first && allowStrict && this.isUseStrict(stmt)) {
-      oldStrict = this.strict;
-      this.setStrict(this.strict = true);
-    }
-    first = false;
-  }
-  if (oldStrict === false) this.setStrict(false);
-  return this.finishNode(node, "BlockStatement");
-};
-
-// Parse a regular `for` loop. The disambiguation code in
-// `parseStatement` will already have parsed the init statement or
-// expression.
-
-pp.parseFor = function(node, init) {
-  node.init = init;
-  this.expect(tt.semi);
-  node.test = this.type === tt.semi ? null : this.parseExpression();
-  this.expect(tt.semi);
-  node.update = this.type === tt.parenR ? null : this.parseExpression();
-  this.expect(tt.parenR);
-  node.body = this.parseStatement(false);
-  this.labels.pop();
-  return this.finishNode(node, "ForStatement");
-};
-
-// Parse a `for`/`in` and `for`/`of` loop, which are almost
-// same from parser's perspective.
-
-pp.parseForIn = function(node, init) {
-  var type = this.type === tt._in ? "ForInStatement" : "ForOfStatement";
-  this.next();
-  node.left = init;
-  node.right = this.parseExpression();
-  this.expect(tt.parenR);
-  node.body = this.parseStatement(false);
-  this.labels.pop();
-  return this.finishNode(node, type);
-};
-
-// Parse a list of variable declarations.
-
-pp.parseVar = function(node, noIn, kind) {
-  node.declarations = [];
-  node.kind = kind.keyword;
-  for (;;) {
-    var decl = this.startNode();
-    decl.id = this.parseBindingAtom();
-    this.checkLVal(decl.id, true);
-    if (this.eat(tt.eq)) {
-      decl.init = this.parseMaybeAssign(noIn);
-    } else if (kind === tt._const && !(this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
-      this.unexpected();
-    } else if (decl.id.type != "Identifier") {
-      this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value")
-    } else {
-      decl.init = null;
-    }
-    node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
-    if (!this.eat(tt.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 optional arguments are used to
-// forbid the `in` operator (in for loops initalization expressions)
-// and provide reference for storing '=' operator inside shorthand
-// property assignment in contexts where both object expression
-// and object pattern might appear (so it's possible to raise
-// delayed syntax error at correct position).
-
-pp.parseExpression = function(noIn, refShorthandDefaultPos) {
-  var start = this.markPosition();
-  var expr = this.parseMaybeAssign(noIn, refShorthandDefaultPos);
-  if (this.type === tt.comma) {
-    var node = this.startNodeAt(start);
-    node.expressions = [expr];
-    while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn, refShorthandDefaultPos));
-    return this.finishNode(node, "SequenceExpression");
-  }
-  return expr;
-};
-
-// Parse an assignment expression. This includes applications of
-// operators like `+=`.
-
-pp.parseMaybeAssign = function(noIn, refShorthandDefaultPos) {
-  if (this.type == tt._yield && this.inGenerator) return this.parseYield();
-
-  var failOnShorthandAssign;
-  if (!refShorthandDefaultPos) {
-    refShorthandDefaultPos = {start: 0};
-    failOnShorthandAssign = true;
-  } else {
-    failOnShorthandAssign = false;
-  }
-  var start = this.markPosition();
-  var left = this.parseMaybeConditional(noIn, refShorthandDefaultPos);
-  if (this.type.isAssign) {
-    var node = this.startNodeAt(start);
-    node.operator = this.value;
-    node.left = this.type === tt.eq ? this.toAssignable(left) : left;
-    refShorthandDefaultPos.start = 0; // reset because shorthand default was used correctly
-    this.checkLVal(left);
-    this.next();
-    node.right = this.parseMaybeAssign(noIn);
-    return this.finishNode(node, "AssignmentExpression");
-  } else if (failOnShorthandAssign && refShorthandDefaultPos.start) {
-    this.unexpected(refShorthandDefaultPos.start);
-  }
-  return left;
-};
-
-// Parse a ternary conditional (`?:`) operator.
-
-pp.parseMaybeConditional = function(noIn, refShorthandDefaultPos) {
-  var start = this.markPosition();
-  var expr = this.parseExprOps(noIn, refShorthandDefaultPos);
-  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-  if (this.eat(tt.question)) {
-    var node = this.startNodeAt(start);
-    node.test = expr;
-    node.consequent = this.parseMaybeAssign();
-    this.expect(tt.colon);
-    node.alternate = this.parseMaybeAssign(noIn);
-    return this.finishNode(node, "ConditionalExpression");
-  }
-  return expr;
-};
-
-// Start the precedence parser.
-
-pp.parseExprOps = function(noIn, refShorthandDefaultPos) {
-  var start = this.markPosition();
-  var expr = this.parseMaybeUnary(refShorthandDefaultPos);
-  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-  return this.parseExprOp(expr, start, -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.
-
-pp.parseExprOp = function(left, leftStart, minPrec, noIn) {
-  var prec = this.type.binop;
-  if (prec != null && (!noIn || this.type !== tt._in)) {
-    if (prec > minPrec) {
-      var node = this.startNodeAt(leftStart);
-      node.left = left;
-      node.operator = this.value;
-      var op = this.type;
-      this.next();
-      var start = this.markPosition();
-      node.right = this.parseExprOp(this.parseMaybeUnary(), start, prec, noIn);
-      this.finishNode(node, (op === tt.logicalOR || op === tt.logicalAND) ? "LogicalExpression" : "BinaryExpression");
-      return this.parseExprOp(node, leftStart, minPrec, noIn);
-    }
-  }
-  return left;
-};
-
-// Parse unary operators, both prefix and postfix.
-
-pp.parseMaybeUnary = function(refShorthandDefaultPos) {
-  if (this.type.prefix) {
-    var node = this.startNode(), update = this.type === tt.incDec;
-    node.operator = this.value;
-    node.prefix = true;
-    this.next();
-    node.argument = this.parseMaybeUnary();
-    if (refShorthandDefaultPos && refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
-    if (update) this.checkLVal(node.argument);
-    else if (this.strict && node.operator === "delete" &&
-             node.argument.type === "Identifier")
-      this.raise(node.start, "Deleting local variable in strict mode");
-    return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
-  }
-  var start = this.markPosition();
-  var expr = this.parseExprSubscripts(refShorthandDefaultPos);
-  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-  while (this.type.postfix && !this.canInsertSemicolon()) {
-    var node = this.startNodeAt(start);
-    node.operator = this.value;
-    node.prefix = false;
-    node.argument = expr;
-    this.checkLVal(expr);
-    this.next();
-    expr = this.finishNode(node, "UpdateExpression");
-  }
-  return expr;
-};
-
-// Parse call, dot, and `[]`-subscript expressions.
-
-pp.parseExprSubscripts = function(refShorthandDefaultPos) {
-  var start = this.markPosition();
-  var expr = this.parseExprAtom(refShorthandDefaultPos);
-  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-  return this.parseSubscripts(expr, start);
-};
-
-pp.parseSubscripts = function(base, start, noCalls) {
-  if (this.eat(tt.dot)) {
-    var node = this.startNodeAt(start);
-    node.object = base;
-    node.property = this.parseIdent(true);
-    node.computed = false;
-    return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls);
-  } else if (this.eat(tt.bracketL)) {
-    var node = this.startNodeAt(start);
-    node.object = base;
-    node.property = this.parseExpression();
-    node.computed = true;
-    this.expect(tt.bracketR);
-    return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls);
-  } else if (!noCalls && this.eat(tt.parenL)) {
-    var node = this.startNodeAt(start);
-    node.callee = base;
-    node.arguments = this.parseExprList(tt.parenR, false);
-    return this.parseSubscripts(this.finishNode(node, "CallExpression"), start, noCalls);
-  } else if (this.type === tt.backQuote) {
-    var node = this.startNodeAt(start);
-    node.tag = base;
-    node.quasi = this.parseTemplate();
-    return this.parseSubscripts(this.finishNode(node, "TaggedTemplateExpression"), start, 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 `{}`.
-
-pp.parseExprAtom = function(refShorthandDefaultPos) {
-  switch (this.type) {
-  case tt._this:
-  case tt._super:
-    var type = this.type === tt._this ? "ThisExpression" : "SuperExpression";
-    var node = this.startNode();
-    this.next();
-    return this.finishNode(node, type);
-
-  case tt._yield:
-    if (this.inGenerator) unexpected();
-
-  case tt.name:
-    var start = this.markPosition();
-    var id = this.parseIdent(this.type !== tt.name);
-    if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
-      return this.parseArrowExpression(this.startNodeAt(start), [id]);
-    }
-    return id;
-
-  case tt.regexp:
-    var value = this.value;
-    var node = this.parseLiteral(value.value);
-    node.regex = {pattern: value.pattern, flags: value.flags};
-    return node;
-
-  case tt.num: case tt.string:
-    return this.parseLiteral(this.value);
-
-  case tt._null: case tt._true: case tt._false:
-    var node = this.startNode();
-    node.value = this.type === tt._null ? null : this.type === tt._true;
-    node.raw = this.type.keyword;
-    this.next();
-    return this.finishNode(node, "Literal");
-
-  case tt.parenL:
-    return this.parseParenAndDistinguishExpression();
-
-  case tt.bracketL:
-    var node = this.startNode();
-    this.next();
-    // check whether this is array comprehension or regular array
-    if (this.options.ecmaVersion >= 7 && this.type === tt._for) {
-      return this.parseComprehension(node, false);
-    }
-    node.elements = this.parseExprList(tt.bracketR, true, true, refShorthandDefaultPos);
-    return this.finishNode(node, "ArrayExpression");
-
-  case tt.braceL:
-    return this.parseObj(false, refShorthandDefaultPos);
-
-  case tt._function:
-    var node = this.startNode();
-    this.next();
-    return this.parseFunction(node, false);
-
-  case tt._class:
-    return this.parseClass(this.startNode(), false);
-
-  case tt._new:
-    return this.parseNew();
-
-  case tt.backQuote:
-    return this.parseTemplate();
-
-  default:
-    this.unexpected();
-  }
-};
-
-pp.parseLiteral = function(value) {
-  var node = this.startNode();
-  node.value = value;
-  node.raw = this.input.slice(this.start, this.end);
-  this.next();
-  return this.finishNode(node, "Literal");
-};
-
-pp.parseParenAndDistinguishExpression = function() {
-  var start = this.markPosition(), val;
-  if (this.options.ecmaVersion >= 6) {
-    this.next();
-
-    if (this.options.ecmaVersion >= 7 && this.type === tt._for) {
-      return this.parseComprehension(this.startNodeAt(start), true);
-    }
-
-    var innerStart = this.markPosition(), exprList = [], first = true;
-    var refShorthandDefaultPos = {start: 0}, spreadStart, innerParenStart;
-    while (this.type !== tt.parenR) {
-      first ? first = false : this.expect(tt.comma);
-      if (this.type === tt.ellipsis) {
-        spreadStart = this.start;
-        exprList.push(this.parseRest());
-        break;
-      } else {
-        if (this.type === tt.parenL && !innerParenStart) {
-          innerParenStart = this.start;
-        }
-        exprList.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
-      }
-    }
-    var innerEnd = this.markPosition();
-    this.expect(tt.parenR);
-
-    if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
-      if (innerParenStart) this.unexpected(innerParenStart);
-      return this.parseArrowExpression(this.startNodeAt(start), exprList);
-    }
-
-    if (!exprList.length) this.unexpected(this.lastTokStart);
-    if (spreadStart) this.unexpected(spreadStart);
-    if (refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
-
-    if (exprList.length > 1) {
-      val = this.startNodeAt(innerStart);
-      val.expressions = exprList;
-      this.finishNodeAt(val, "SequenceExpression", innerEnd);
-    } else {
-      val = exprList[0];
-    }
-  } else {
-    val = this.parseParenExpression();
-  }
-
-  if (this.options.preserveParens) {
-    var par = this.startNodeAt(start);
-    par.expression = val;
-    return this.finishNode(par, "ParenthesizedExpression");
-  } else {
-    return val;
-  }
-};
-
-// 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
-
-pp.parseNew = function() {
-  var node = this.startNode();
-  this.next();
-  var start = this.markPosition();
-  node.callee = this.parseSubscripts(this.parseExprAtom(), start, true);
-  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false);
-  else node.arguments = empty;
-  return this.finishNode(node, "NewExpression");
-};
-
-// Parse template expression.
-
-pp.parseTemplateElement = function() {
-  var elem = this.startNode();
-  elem.value = {
-    raw: this.input.slice(this.start, this.end),
-    cooked: this.value
-  };
-  this.next();
-  elem.tail = this.type === tt.backQuote;
-  return this.finishNode(elem, "TemplateElement");
-};
-
-pp.parseTemplate = function() {
-  var node = this.startNode();
-  this.next();
-  node.expressions = [];
-  var curElt = this.parseTemplateElement();
-  node.quasis = [curElt];
-  while (!curElt.tail) {
-    this.expect(tt.dollarBraceL);
-    node.expressions.push(this.parseExpression());
-    this.expect(tt.braceR);
-    node.quasis.push(curElt = this.parseTemplateElement());
-  }
-  this.next();
-  return this.finishNode(node, "TemplateLiteral");
-};
-
-// Parse an object literal or binding pattern.
-
-pp.parseObj = function(isPattern, refShorthandDefaultPos) {
-  var node = this.startNode(), first = true, propHash = {};
-  node.properties = [];
-  this.next();
-  while (!this.eat(tt.braceR)) {
-    if (!first) {
-      this.expect(tt.comma);
-      if (this.afterTrailingComma(tt.braceR)) break;
-    } else first = false;
-
-    var prop = this.startNode(), isGenerator, start;
-    if (this.options.ecmaVersion >= 6) {
-      prop.method = false;
-      prop.shorthand = false;
-      if (isPattern || refShorthandDefaultPos)
-        start = this.markPosition();
-      if (!isPattern)
-        isGenerator = this.eat(tt.star);
-    }
-    this.parsePropertyName(prop);
-    if (this.eat(tt.colon)) {
-      prop.value = isPattern ? this.parseMaybeDefault() : this.parseMaybeAssign(false, refShorthandDefaultPos);
-      prop.kind = "init";
-    } else if (this.options.ecmaVersion >= 6 && this.type === tt.parenL) {
-      if (isPattern) this.unexpected();
-      prop.kind = "init";
-      prop.method = true;
-      prop.value = this.parseMethod(isGenerator);
-    } else if (this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
-               (prop.key.name === "get" || prop.key.name === "set") &&
-               (this.type != tt.comma && this.type != tt.braceR)) {
-      if (isGenerator || isPattern) this.unexpected();
-      prop.kind = prop.key.name;
-      this.parsePropertyName(prop);
-      prop.value = this.parseMethod(false);
-    } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
-      prop.kind = "init";
-      if (isPattern) {
-        if (this.isKeyword(prop.key.name) ||
-            (this.strict && (reservedWords.strictBind(prop.key.name) || reservedWords.strict(prop.key.name))) ||
-            (!this.options.allowReserved && this.isReservedWord(prop.key.name)))
-          this.raise(prop.key.start, "Binding " + prop.key.name);
-        prop.value = this.parseMaybeDefault(start, prop.key);
-      } else if (this.type === tt.eq && refShorthandDefaultPos) {
-        if (!refShorthandDefaultPos.start)
-          refShorthandDefaultPos.start = this.start;
-        prop.value = this.parseMaybeDefault(start, prop.key);
-      } else {
-        prop.value = prop.key;
-      }
-      prop.shorthand = true;
-    } else this.unexpected();
-
-    this.checkPropClash(prop, propHash);
-    node.properties.push(this.finishNode(prop, "Property"));
-  }
-  return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");
-};
-
-pp.parsePropertyName = function(prop) {
-  if (this.options.ecmaVersion >= 6) {
-    if (this.eat(tt.bracketL)) {
-      prop.computed = true;
-      prop.key = this.parseExpression();
-      this.expect(tt.bracketR);
-      return;
-    } else {
-      prop.computed = false;
-    }
-  }
-  prop.key = (this.type === tt.num || this.type === tt.string) ? this.parseExprAtom() : this.parseIdent(true);
-};
-
-// Initialize empty function node.
-
-pp.initFunction = function(node) {
-  node.id = null;
-  if (this.options.ecmaVersion >= 6) {
-    node.generator = false;
-    node.expression = false;
-  }
-};
-
-// Parse a function declaration or literal (depending on the
-// `isStatement` parameter).
-
-pp.parseFunction = function(node, isStatement, allowExpressionBody) {
-  this.initFunction(node);
-  if (this.options.ecmaVersion >= 6) {
-    node.generator = this.eat(tt.star);
-  }
-  if (isStatement || this.type === tt.name) {
-    node.id = this.parseIdent();
-  }
-  this.expect(tt.parenL);
-  node.params = this.parseBindingList(tt.parenR, false, false);
-  this.parseFunctionBody(node, allowExpressionBody);
-  return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-};
-
-// Parse object or class method.
-
-pp.parseMethod = function(isGenerator) {
-  var node = this.startNode();
-  this.initFunction(node);
-  this.expect(tt.parenL);
-  node.params = this.parseBindingList(tt.parenR, false, false);
-  var allowExpressionBody;
-  if (this.options.ecmaVersion >= 6) {
-    node.generator = isGenerator;
-    allowExpressionBody = true;
-  } else {
-    allowExpressionBody = false;
-  }
-  this.parseFunctionBody(node, allowExpressionBody);
-  return this.finishNode(node, "FunctionExpression");
-};
-
-// Parse arrow function expression with given parameters.
-
-pp.parseArrowExpression = function(node, params) {
-  this.initFunction(node);
-  node.params = this.toAssignableList(params, true);
-  this.parseFunctionBody(node, true);
-  return this.finishNode(node, "ArrowFunctionExpression");
-};
-
-// Parse function body and check parameters.
-
-pp.parseFunctionBody = function(node, allowExpression) {
-  var isExpression = allowExpression && this.type !== tt.braceL;
-
-  if (isExpression) {
-    node.body = this.parseMaybeAssign();
-    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 = this.inFunction, oldInGen = this.inGenerator, oldLabels = this.labels;
-    this.inFunction = true; this.inGenerator = node.generator; this.labels = [];
-    node.body = this.parseBlock(true);
-    node.expression = false;
-    this.inFunction = oldInFunc; this.inGenerator = oldInGen; this.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 (this.strict || !isExpression && node.body.body.length && this.isUseStrict(node.body.body[0])) {
-    var nameHash = {}, oldStrict = this.strict;
-    this.strict = true;
-    if (node.id)
-      this.checkLVal(node.id, true);
-    for (var i = 0; i < node.params.length; i++)
-      this.checkLVal(node.params[i], true, nameHash);
-    this.strict = oldStrict;
-  }
-};
-
-// Parse a class declaration or literal (depending on the
-// `isStatement` parameter).
-
-pp.parseClass = function(node, isStatement) {
-  this.next();
-  node.id = this.type === tt.name ? this.parseIdent() : isStatement ? this.unexpected() : null;
-  node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null;
-  var classBody = this.startNode();
-  classBody.body = [];
-  this.expect(tt.braceL);
-  while (!this.eat(tt.braceR)) {
-    if (this.eat(tt.semi)) continue;
-    var method = this.startNode();
-    var isGenerator = this.eat(tt.star);
-    this.parsePropertyName(method);
-    if (this.type !== tt.parenL && !method.computed && method.key.type === "Identifier" &&
-        method.key.name === "static") {
-      if (isGenerator) this.unexpected();
-      method['static'] = true;
-      isGenerator = this.eat(tt.star);
-      this.parsePropertyName(method);
-    } else {
-      method['static'] = false;
-    }
-    method.kind = "method";
-    if (!method.computed && !isGenerator) {
-      if (method.key.type === "Identifier") {
-        if (this.type !== tt.parenL && (method.key.name === "get" || method.key.name === "set")) {
-          method.kind = method.key.name;
-          this.parsePropertyName(method);
-        } else if (!method['static'] && method.key.name === "constructor") {
-          method.kind = "constructor";
-        }
-      } else if (!method['static'] && method.key.type === "Literal" && method.key.value === "constructor") {
-        method.kind = "constructor";
-      }
-    }
-    method.value = this.parseMethod(isGenerator);
-    classBody.body.push(this.finishNode(method, "MethodDefinition"));
-  }
-  node.body = this.finishNode(classBody, "ClassBody");
-  return this.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).
-
-pp.parseExprList = function(close, allowTrailingComma, allowEmpty, refShorthandDefaultPos) {
-  var elts = [], first = true;
-  while (!this.eat(close)) {
-    if (!first) {
-      this.expect(tt.comma);
-      if (allowTrailingComma && this.afterTrailingComma(close)) break;
-    } else first = false;
-
-    if (allowEmpty && this.type === tt.comma) {
-      elts.push(null);
-    } else {
-      if (this.type === tt.ellipsis)
-        elts.push(this.parseSpread(refShorthandDefaultPos));
-      else
-        elts.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
-    }
-  }
-  return elts;
-};
-
-// Parse the next token as an identifier. If `liberal` is true (used
-// when parsing properties), it will also convert keywords into
-// identifiers.
-
-pp.parseIdent = function(liberal) {
-  var node = this.startNode();
-  if (liberal && this.options.allowReserved == "never") liberal = false;
-  if (this.type === tt.name) {
-    if (!liberal &&
-        ((!this.options.allowReserved && this.isReservedWord(this.value)) ||
-         (this.strict && reservedWords.strict(this.value)) &&
-         (this.options.ecmaVersion >= 6 || 
-          this.input.slice(this.start, this.end).indexOf("\\") == -1)))
-      this.raise(this.start, "The keyword '" + this.value + "' is reserved");
-    node.name = this.value;
-  } else if (liberal && this.type.keyword) {
-    node.name = this.type.keyword;
-  } else {
-    this.unexpected();
-  }
-  this.next();
-  return this.finishNode(node, "Identifier");
-};
-
-// Parses module export declaration.
-
-pp.parseExport = function(node) {
-  this.next();
-  // export * from '...';
-  if (this.eat(tt.star)) {
-    this.expectContextual("from");
-    node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
-    this.semicolon();
-    return this.finishNode(node, "ExportAllDeclaration");
-  }
-  if (this.eat(tt._default)) { // export default ...;
-    var expr = this.parseMaybeAssign();
-    if (expr.id) {
-      switch (expr.type) {
-      case "FunctionExpression": expr.type = "FunctionDeclaration"; break;
-      case "ClassExpression": expr.type = "ClassDeclaration"; break;
-      }
-    }
-    node.declaration = expr;
-    this.semicolon();
-    return this.finishNode(node, "ExportDefaultDeclaration");
-  }
-  // export var|const|let|function|class ...;
-  if (this.type.keyword) {
-    node.declaration = this.parseStatement(true);
-    node.specifiers = [];
-    node.source = null;
-  } else { // export { x, y as z } [from '...'];
-    node.declaration = null;
-    node.specifiers = this.parseExportSpecifiers();
-    if (this.eatContextual("from")) {
-      node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
-    } else {
-      node.source = null;
-    }
-    this.semicolon();
-  }
-  return this.finishNode(node, "ExportNamedDeclaration");
-};
-
-// Parses a comma-separated list of module exports.
-
-pp.parseExportSpecifiers = function() {
-  var nodes = [], first = true;
-  // export { x, y as z } [from '...']
-  this.expect(tt.braceL);
-  while (!this.eat(tt.braceR)) {
-    if (!first) {
-      this.expect(tt.comma);
-      if (this.afterTrailingComma(tt.braceR)) break;
-    } else first = false;
-
-    var node = this.startNode();
-    node.local = this.parseIdent(this.type === tt._default);
-    node.exported = this.eatContextual("as") ? this.parseIdent(true) : node.local;
-    nodes.push(this.finishNode(node, "ExportSpecifier"));
-  }
-  return nodes;
-};
-
-// Parses import declaration.
-
-pp.parseImport = function(node) {
-  this.next();
-  // import '...';
-  if (this.type === tt.string) {
-    node.specifiers = empty;
-    node.source = this.parseExprAtom();
-    node.kind = "";
-  } else {
-    node.specifiers = this.parseImportSpecifiers();
-    this.expectContextual("from");
-    node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
-  }
-  this.semicolon();
-  return this.finishNode(node, "ImportDeclaration");
-};
-
-// Parses a comma-separated list of module imports.
-
-pp.parseImportSpecifiers = function() {
-  var nodes = [], first = true;
-  if (this.type === tt.name) {
-    // import defaultObj, { x, y as z } from '...'
-    var node = this.startNode();
-    node.local = this.parseIdent();
-    this.checkLVal(node.local, true);
-    nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
-    if (!this.eat(tt.comma)) return nodes;
-  }
-  if (this.type === tt.star) {
-    var node = this.startNode();
-    this.next();
-    this.expectContextual("as");
-    node.local = this.parseIdent();
-    this.checkLVal(node.local, true);
-    nodes.push(this.finishNode(node, "ImportNamespaceSpecifier"));
-    return nodes;
-  }
-  this.expect(tt.braceL);
-  while (!this.eat(tt.braceR)) {
-    if (!first) {
-      this.expect(tt.comma);
-      if (this.afterTrailingComma(tt.braceR)) break;
-    } else first = false;
-
-    var node = this.startNode();
-    node.imported = this.parseIdent(true);
-    node.local = this.eatContextual("as") ? this.parseIdent() : node.imported;
-    this.checkLVal(node.local, true);
-    nodes.push(this.finishNode(node, "ImportSpecifier"));
-  }
-  return nodes;
-};
-
-// Parses yield expression inside generator.
-
-pp.parseYield = function() {
-  var node = this.startNode();
-  this.next();
-  if (this.type == tt.semi || this.canInsertSemicolon() || (this.type != tt.star && !this.type.startsExpr)) {
-    node.delegate = false;
-    node.argument = null;
-  } else {
-    node.delegate = this.eat(tt.star);
-    node.argument = this.parseMaybeAssign();
-  }
-  return this.finishNode(node, "YieldExpression");
-};
-
-// Parses array and generator comprehensions.
-
-pp.parseComprehension = function(node, isGenerator) {
-  node.blocks = [];
-  while (this.type === tt._for) {
-    var block = this.startNode();
-    this.next();
-    this.expect(tt.parenL);
-    block.left = this.parseBindingAtom();
-    this.checkLVal(block.left, true);
-    this.expectContextual("of");
-    block.right = this.parseExpression();
-    this.expect(tt.parenR);
-    node.blocks.push(this.finishNode(block, "ComprehensionBlock"));
-  }
-  node.filter = this.eat(tt._if) ? this.parseParenExpression() : null;
-  node.body = this.parseExpression();
-  this.expect(isGenerator ? tt.parenR : tt.bracketR);
-  node.generator = isGenerator;
-  return this.finishNode(node, "ComprehensionExpression");
-};
+function parser(options, input) {
+  return new Parser(getOptions(options), String(input))
+}
diff --git a/src/location.js b/src/location.js
index 6adbd48d98..83bae82121 100644
--- a/src/location.js
+++ b/src/location.js
@@ -1,4 +1,5 @@
-import Parser from "./state"
+import {Parser} from "./state"
+import {lineBreakG} from "./whitespace"
 
 // These are used when `options.locations` is on, for the
 // `startLoc` and `endLoc` properties.
@@ -30,8 +31,8 @@ export class SourceLocation {
 
 export function getLineInfo(input, offset) {
   for (let line = 1, cur = 0;;) {
-    lineBreak.lastIndex = cur
-    let match = lineBreak.exec(input)
+    lineBreakG.lastIndex = cur
+    let match = lineBreakG.exec(input)
     if (match && match.index < offset) {
       ++line
       cur = match.index + match[0].length
diff --git a/src/lval.js b/src/lval.js
new file mode 100644
index 0000000000..75ef38147c
--- /dev/null
+++ b/src/lval.js
@@ -0,0 +1,189 @@
+import {types as tt} from "./tokentype"
+import {Parser} from "./state"
+import {reservedWords} from "./identifier"
+import {has} from "./util"
+
+const pp = Parser.prototype
+
+// Convert existing expression atom to assignable pattern
+// if possible.
+
+pp.toAssignable = function(node, isBinding) {
+  if (this.options.ecmaVersion >= 6 && node) {
+    switch (node.type) {
+    case "Identifier":
+    case "ObjectPattern":
+    case "ArrayPattern":
+    case "AssignmentPattern":
+      break;
+
+    case "ObjectExpression":
+      node.type = "ObjectPattern";
+      for (var i = 0; i < node.properties.length; i++) {
+        var prop = node.properties[i];
+        if (prop.kind !== "init") this.raise(prop.key.start, "Object pattern can't contain getter or setter");
+        this.toAssignable(prop.value, isBinding);
+      }
+      break;
+
+    case "ArrayExpression":
+      node.type = "ArrayPattern";
+      this.toAssignableList(node.elements, isBinding);
+      break;
+
+    case "AssignmentExpression":
+      if (node.operator === "=") {
+        node.type = "AssignmentPattern";
+      } else {
+        this.raise(node.left.end, "Only '=' operator can be used for specifying default value.");
+      }
+      break;
+
+    case "MemberExpression":
+      if (!isBinding) break;
+
+    default:
+      this.raise(node.start, "Assigning to rvalue");
+    }
+  }
+  return node;
+};
+
+// Convert list of expression atoms to binding list.
+
+pp.toAssignableList = function(exprList, isBinding) {
+  var end = exprList.length;
+  if (end) {
+    var last = exprList[end - 1];
+    if (last && last.type == "RestElement") {
+      --end;
+    } else if (last && last.type == "SpreadElement") {
+      last.type = "RestElement";
+      var arg = last.argument;
+      this.toAssignable(arg, isBinding);
+      if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern")
+        this.unexpected(arg.start);
+      --end;
+    }
+  }
+  for (var i = 0; i < end; i++) {
+    var elt = exprList[i];
+    if (elt) this.toAssignable(elt, isBinding);
+  }
+  return exprList;
+};
+
+// Parses spread element.
+
+pp.parseSpread = function(refShorthandDefaultPos) {
+  var node = this.startNode();
+  this.next();
+  node.argument = this.parseMaybeAssign(refShorthandDefaultPos);
+  return this.finishNode(node, "SpreadElement");
+};
+
+pp.parseRest = function() {
+  var node = this.startNode();
+  this.next();
+  node.argument = this.type === tt.name || this.type === tt.bracketL ? this.parseBindingAtom() : this.unexpected();
+  return this.finishNode(node, "RestElement");
+};
+
+// Parses lvalue (assignable) atom.
+
+pp.parseBindingAtom = function() {
+  if (this.options.ecmaVersion < 6) return this.parseIdent();
+  switch (this.type) {
+  case tt.name:
+    return this.parseIdent();
+
+  case tt.bracketL:
+    var node = this.startNode();
+    this.next();
+    node.elements = this.parseBindingList(tt.bracketR, true, true);
+    return this.finishNode(node, "ArrayPattern");
+
+  case tt.braceL:
+    return this.parseObj(true);
+
+  default:
+    this.unexpected();
+  }
+};
+
+pp.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
+  var elts = [], first = true;
+  while (!this.eat(close)) {
+    if (first) first = false;
+    else this.expect(tt.comma);
+    if (allowEmpty && this.type === tt.comma) {
+      elts.push(null);
+    } else if (allowTrailingComma && this.afterTrailingComma(close)) {
+      break;
+    } else if (this.type === tt.ellipsis) {
+      elts.push(this.parseRest());
+      this.expect(close);
+      break;
+    } else {
+      elts.push(this.parseMaybeDefault());
+    }
+  }
+  return elts;
+};
+
+// Parses assignment pattern around given atom if possible.
+
+pp.parseMaybeDefault = function(startPos, left) {
+  startPos = startPos || this.markPosition();
+  left = left || this.parseBindingAtom();
+  if (!this.eat(tt.eq)) return left;
+  var node = this.startNodeAt(startPos);
+  node.operator = "=";
+  node.left = left;
+  node.right = this.parseMaybeAssign();
+  return this.finishNode(node, "AssignmentPattern");
+};
+
+// Verify that a node is an lval — something that can be assigned
+// to.
+
+pp.checkLVal = function(expr, isBinding, checkClashes) {
+  switch (expr.type) {
+  case "Identifier":
+    if (this.strict && (reservedWords.strictBind(expr.name) || reservedWords.strict(expr.name)))
+      this.raise(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode");
+    if (checkClashes) {
+      if (has(checkClashes, expr.name))
+        this.raise(expr.start, "Argument name clash in strict mode");
+      checkClashes[expr.name] = true;
+    }
+    break;
+
+  case "MemberExpression":
+    if (isBinding) this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " member expression");
+    break;
+
+  case "ObjectPattern":
+    for (var i = 0; i < expr.properties.length; i++)
+      this.checkLVal(expr.properties[i].value, isBinding, checkClashes);
+    break;
+
+  case "ArrayPattern":
+    for (var i = 0; i < expr.elements.length; i++) {
+      var elem = expr.elements[i];
+      if (elem) this.checkLVal(elem, isBinding, checkClashes);
+    }
+    break;
+
+  case "AssignmentPattern":
+    this.checkLVal(expr.left, isBinding, checkClashes);
+    break;
+
+  case "RestElement":
+    this.checkLVal(expr.argument, isBinding, checkClashes);
+    break;
+
+  default:
+    this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " rvalue");
+  }
+};
diff --git a/src/node.js b/src/node.js
new file mode 100644
index 0000000000..e756a9df0f
--- /dev/null
+++ b/src/node.js
@@ -0,0 +1,57 @@
+import {Parser} from "./state"
+import {SourceLocation} from "./location"
+
+// Start an AST node, attaching a start offset.
+
+const pp = Parser.prototype
+
+export class Node {}
+
+pp.startNode = function() {
+  var node = new Node;
+  node.start = this.start;
+  if (this.options.locations)
+    node.loc = new SourceLocation(this, this.startLoc);
+  if (this.options.directSourceFile)
+    node.sourceFile = this.options.directSourceFile;
+  if (this.options.ranges)
+    node.range = [this.start, 0];
+  return node;
+};
+
+pp.startNodeAt = function(pos) {
+  var node = new Node, start = pos;
+  if (this.options.locations) {
+    node.loc = new SourceLocation(this, start[1]);
+    start = pos[0];
+  }
+  node.start = start;
+  if (this.options.directSourceFile)
+    node.sourceFile = this.options.directSourceFile;
+  if (this.options.ranges)
+    node.range = [start, 0];
+  return node;
+};
+
+// Finish an AST node, adding `type` and `end` properties.
+
+pp.finishNode = function(node, type) {
+  node.type = type;
+  node.end = this.lastTokEnd;
+  if (this.options.locations)
+    node.loc.end = this.lastTokEndLoc;
+  if (this.options.ranges)
+    node.range[1] = this.lastTokEnd;
+  return node;
+};
+
+// Finish node at given position
+
+pp.finishNodeAt = function(node, type, pos) {
+  if (this.options.locations) { node.loc.end = pos[1]; pos = pos[0]; }
+  node.type = type;
+  node.end = pos;
+  if (this.options.ranges)
+    node.range[1] = pos;
+  return node;
+};
diff --git a/src/parseutil.js b/src/parseutil.js
new file mode 100644
index 0000000000..24461fabd3
--- /dev/null
+++ b/src/parseutil.js
@@ -0,0 +1,89 @@
+import {types as tt} from "./tokentype"
+import {Parser} from "./state"
+import {lineBreak} from "./whitespace"
+
+const pp = Parser.prototype
+
+// ## Parser utilities
+
+// Test whether a statement node is the string literal `"use strict"`.
+
+pp.isUseStrict = function(stmt) {
+  return this.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.
+
+pp.eat = function(type) {
+  if (this.type === type) {
+    this.next();
+    return true;
+  } else {
+    return false;
+  }
+};
+
+// Tests whether parsed token is a contextual keyword.
+
+pp.isContextual = function(name) {
+  return this.type === tt.name && this.value === name;
+};
+
+// Consumes contextual keyword if possible.
+
+pp.eatContextual = function(name) {
+  return this.value === name && this.eat(tt.name);
+};
+
+// Asserts that following token is given contextual keyword.
+
+pp.expectContextual = function(name) {
+  if (!this.eatContextual(name)) this.unexpected();
+};
+
+// Test whether a semicolon can be inserted at the current position.
+
+pp.canInsertSemicolon = function() {
+  return this.type === tt.eof ||
+    this.type === tt.braceR ||
+    lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
+};
+
+pp.insertSemicolon = function() {
+  if (this.canInsertSemicolon()) {
+    if (this.options.onInsertedSemicolon)
+      this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc)
+    return true;
+  }
+};
+
+// Consume a semicolon, or, failing that, see if we are allowed to
+// pretend that there is a semicolon at this position.
+
+pp.semicolon = function() {
+  if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected();
+};
+
+pp.afterTrailingComma = function(tokType) {
+  if (this.type == tokType) {
+    if (this.options.onTrailingComma)
+      this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc);
+    this.next();
+    return true;
+  }
+};
+
+// Expect a token of a given type. If found, consume it, otherwise,
+// raise an unexpected token error.
+
+pp.expect = function(type) {
+  this.eat(type) || this.unexpected();
+};
+
+// Raise an unexpected token error.
+
+pp.unexpected = function(pos) {
+  this.raise(pos != null ? pos : this.start, "Unexpected token");
+};
diff --git a/src/state.js b/src/state.js
index cb5e4b4fbe..3ef232de3d 100644
--- a/src/state.js
+++ b/src/state.js
@@ -1,7 +1,7 @@
 import {reservedWords, keywords} from "./identifier"
-import {types as tt} from "./tokentype"
+import {types as tt, lineBreak} from "./tokentype"
 
-export default function Parser(options, input, startPos) {
+export function Parser(options, input, startPos) {
   this.options = options
   this.loadPlugins(this.options.plugins)
   this.sourceFile = this.options.sourceFile || null
@@ -13,28 +13,28 @@ export default function Parser(options, input, startPos) {
 
   // The current position of the tokenizer in the input.
   if (startPos) {
-    this.pos = startPos;
-    this.lineStart = Math.max(0, this.input.lastIndexOf("\n", startPos));
-    this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length;
+    this.pos = startPos
+    this.lineStart = Math.max(0, this.input.lastIndexOf("\n", startPos))
+    this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length
   } else {
-    this.pos = this.lineStart = 0;
-    this.curLine = 1;
+    this.pos = this.lineStart = 0
+    this.curLine = 1
   }
 
   // Properties of the current token:
   // Its type
-  this.type = tt.eof;
+  this.type = tt.eof
   // For tokens that include more information than their type, the value
-  this.value = null;
+  this.value = null
   // Its start and end offset
-  this.start = this.end = this.pos;
+  this.start = this.end = this.pos
   // And, if locations are used, the {line, column} object
   // corresponding to those offsets
-  this.startLoc = this.endLoc = null;
+  this.startLoc = this.endLoc = null
 
   // Position information for the previous token
-  this.lastTokEndLoc = this.lastTokStartLoc = null;
-  this.lastTokStart = this.lastTokEnd = this.pos;
+  this.lastTokEndLoc = this.lastTokStartLoc = null
+  this.lastTokStart = this.lastTokEnd = this.pos
 
   // The context stack is used to superficially track syntactic
   // context to predict whether a regular expression is allowed in a
@@ -43,14 +43,26 @@ export default function Parser(options, input, startPos) {
   this.exprAllowed = true
 
   // Figure out if it's a module code.
-  this.strict = this.inModule = this.options.sourceType === "module";
+  this.strict = this.inModule = this.options.sourceType === "module"
 
   // Flags to track whether we are in a function, a generator.
-  this.inFunction = this.inGenerator = false;
+  this.inFunction = this.inGenerator = false
   // Labels in scope.
-  this.labels = [];
+  this.labels = []
 
   // If enabled, skip leading hashbang line.
   if (this.pos === 0 && this.options.allowHashBang && this.input.slice(0, 2) === '#!')
-    this.skipLineComment(2);
+    this.skipLineComment(2)
+}
+
+Parser.prototype.extend = function(name, f) {
+  this[name] = f(this[name])
+}
+
+Parser.prototype.loadPlugins = function(plugins) {
+  for (let name in plugins) {
+    let plugin = exports.plugins[name]
+    if (!plugin) throw new Error("Plugin '" + name + "' not found")
+    plugin(this, plugins[name])
+  }
 }
diff --git a/src/statement.js b/src/statement.js
new file mode 100644
index 0000000000..9014d062ea
--- /dev/null
+++ b/src/statement.js
@@ -0,0 +1,446 @@
+import {types as tt} from "./tokentype"
+import {Parser} from "./state"
+import {lineBreak} from "./whitespace"
+
+const pp = Parser.prototype
+
+// ### 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.
+
+pp.parseTopLevel = function(node) {
+  var first = true;
+  if (!node.body) node.body = [];
+  while (this.type !== tt.eof) {
+    var stmt = this.parseStatement(true, true);
+    node.body.push(stmt);
+    if (first && this.isUseStrict(stmt)) this.setStrict(true);
+    first = false;
+  }
+  this.next();
+  if (this.options.ecmaVersion >= 6) {
+    node.sourceType = this.options.sourceType;
+  }
+  return this.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.
+
+pp.parseStatement = function(declaration, topLevel) {
+  var starttype = this.type, node = this.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 tt._break: case tt._continue: return this.parseBreakContinueStatement(node, starttype.keyword);
+  case tt._debugger: return this.parseDebuggerStatement(node);
+  case tt._do: return this.parseDoStatement(node);
+  case tt._for: return this.parseForStatement(node);
+  case tt._function:
+    if (!declaration && this.options.ecmaVersion >= 6) this.unexpected();
+    return this.parseFunctionStatement(node);
+  case tt._class:
+    if (!declaration) this.unexpected();
+    return this.parseClass(node, true);
+  case tt._if: return this.parseIfStatement(node);
+  case tt._return: return this.parseReturnStatement(node);
+  case tt._switch: return this.parseSwitchStatement(node);
+  case tt._throw: return this.parseThrowStatement(node);
+  case tt._try: return this.parseTryStatement(node);
+  case tt._let: case tt._const: if (!declaration) this.unexpected(); // NOTE: falls through to _var
+  case tt._var: return this.parseVarStatement(node, starttype);
+  case tt._while: return this.parseWhileStatement(node);
+  case tt._with: return this.parseWithStatement(node);
+  case tt.braceL: return this.parseBlock(); // no point creating a function for this
+  case tt.semi: return this.parseEmptyStatement(node);
+  case tt._export:
+  case tt._import:
+    if (!this.options.allowImportExportEverywhere) {
+      if (!topLevel)
+        this.raise(this.start, "'import' and 'export' may only appear at the top level");
+      if (!this.inModule)
+        this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
+    }
+    return starttype === tt._import ? this.parseImport(node) : this.parseExport(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 = this.value, expr = this.parseExpression();
+    if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon))
+      return this.parseLabeledStatement(node, maybeName, expr);
+    else return this.parseExpressionStatement(node, expr);
+  }
+};
+
+pp.parseBreakContinueStatement = function(node, keyword) {
+  var isBreak = keyword == "break";
+  this.next();
+  if (this.eat(tt.semi) || this.insertSemicolon()) node.label = null;
+  else if (this.type !== tt.name) this.unexpected();
+  else {
+    node.label = this.parseIdent();
+    this.semicolon();
+  }
+
+  // Verify that there is an actual destination to break or
+  // continue to.
+  for (var i = 0; i < this.labels.length; ++i) {
+    var lab = this.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 === this.labels.length) this.raise(node.start, "Unsyntactic " + keyword);
+  return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+};
+
+pp.parseDebuggerStatement = function(node) {
+  this.next();
+  this.semicolon();
+  return this.finishNode(node, "DebuggerStatement");
+};
+
+pp.parseDoStatement = function(node) {
+  this.next();
+  this.labels.push(loopLabel);
+  node.body = this.parseStatement(false);
+  this.labels.pop();
+  this.expect(tt._while);
+  node.test = this.parseParenExpression();
+  if (this.options.ecmaVersion >= 6)
+    this.eat(tt.semi);
+  else
+    this.semicolon();
+  return this.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.
+
+pp.parseForStatement = function(node) {
+  this.next();
+  this.labels.push(loopLabel);
+  this.expect(tt.parenL);
+  if (this.type === tt.semi) return this.parseFor(node, null);
+  if (this.type === tt._var || this.type === tt._let || this.type === tt._const) {
+    var init = this.startNode(), varKind = this.type;
+    this.next();
+    this.parseVar(init, true, varKind);
+    this.finishNode(init, "VariableDeclaration");
+    if ((this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init.declarations.length === 1 &&
+        !(varKind !== tt._var && init.declarations[0].init))
+      return this.parseForIn(node, init);
+    return this.parseFor(node, init);
+  }
+  var refShorthandDefaultPos = {start: 0};
+  var init = this.parseExpression(true, refShorthandDefaultPos);
+  if (this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
+    this.toAssignable(init);
+    this.checkLVal(init);
+    return this.parseForIn(node, init);
+  } else if (refShorthandDefaultPos.start) {
+    this.unexpected(refShorthandDefaultPos.start);
+  }
+  return this.parseFor(node, init);
+};
+
+pp.parseFunctionStatement = function(node) {
+  this.next();
+  return this.parseFunction(node, true);
+};
+
+pp.parseIfStatement = function(node) {
+  this.next();
+  node.test = this.parseParenExpression();
+  node.consequent = this.parseStatement(false);
+  node.alternate = this.eat(tt._else) ? this.parseStatement(false) : null;
+  return this.finishNode(node, "IfStatement");
+};
+
+pp.parseReturnStatement = function(node) {
+  if (!this.inFunction && !this.options.allowReturnOutsideFunction)
+    this.raise(this.start, "'return' outside of function");
+  this.next();
+
+  // In `return` (and `break`/`continue`), the keywords with
+  // optional arguments, we eagerly look for a semicolon or the
+  // possibility to insert one.
+
+  if (this.eat(tt.semi) || this.insertSemicolon()) node.argument = null;
+  else { node.argument = this.parseExpression(); this.semicolon(); }
+  return this.finishNode(node, "ReturnStatement");
+};
+
+pp.parseSwitchStatement = function(node) {
+  this.next();
+  node.discriminant = this.parseParenExpression();
+  node.cases = [];
+  this.expect(tt.braceL);
+  this.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; this.type != tt.braceR;) {
+    if (this.type === tt._case || this.type === tt._default) {
+      var isCase = this.type === tt._case;
+      if (cur) this.finishNode(cur, "SwitchCase");
+      node.cases.push(cur = this.startNode());
+      cur.consequent = [];
+      this.next();
+      if (isCase) cur.test = this.parseExpression();
+      else {
+        if (sawDefault) this.raise(this.lastTokStart, "Multiple default clauses"); sawDefault = true;
+        cur.test = null;
+      }
+      this.expect(tt.colon);
+    } else {
+      if (!cur) this.unexpected();
+      cur.consequent.push(this.parseStatement(true));
+    }
+  }
+  if (cur) this.finishNode(cur, "SwitchCase");
+  this.next(); // Closing brace
+  this.labels.pop();
+  return this.finishNode(node, "SwitchStatement");
+};
+
+pp.parseThrowStatement = function(node) {
+  this.next();
+  if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))
+    this.raise(this.lastTokEnd, "Illegal newline after throw");
+  node.argument = this.parseExpression();
+  this.semicolon();
+  return this.finishNode(node, "ThrowStatement");
+};
+
+// Reused empty array added for node fields that are always empty.
+
+const empty = []
+
+pp.parseTryStatement = function(node) {
+  this.next();
+  node.block = this.parseBlock();
+  node.handler = null;
+  if (this.type === tt._catch) {
+    var clause = this.startNode();
+    this.next();
+    this.expect(tt.parenL);
+    clause.param = this.parseBindingAtom();
+    this.checkLVal(clause.param, true);
+    this.expect(tt.parenR);
+    clause.guard = null;
+    clause.body = this.parseBlock();
+    node.handler = this.finishNode(clause, "CatchClause");
+  }
+  node.guardedHandlers = empty;
+  node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;
+  if (!node.handler && !node.finalizer)
+    this.raise(node.start, "Missing catch or finally clause");
+  return this.finishNode(node, "TryStatement");
+};
+
+pp.parseVarStatement = function(node, kind) {
+  this.next();
+  this.parseVar(node, false, kind);
+  this.semicolon();
+  return this.finishNode(node, "VariableDeclaration");
+};
+
+pp.parseWhileStatement = function(node) {
+  this.next();
+  node.test = this.parseParenExpression();
+  this.labels.push(loopLabel);
+  node.body = this.parseStatement(false);
+  this.labels.pop();
+  return this.finishNode(node, "WhileStatement");
+};
+
+pp.parseWithStatement = function(node) {
+  if (this.strict) this.raise(this.start, "'with' in strict mode");
+  this.next();
+  node.object = this.parseParenExpression();
+  node.body = this.parseStatement(false);
+  return this.finishNode(node, "WithStatement");
+};
+
+pp.parseEmptyStatement = function(node) {
+  this.next();
+  return this.finishNode(node, "EmptyStatement");
+};
+
+pp.parseLabeledStatement = function(node, maybeName, expr) {
+  for (var i = 0; i < this.labels.length; ++i)
+    if (this.labels[i].name === maybeName) this.raise(expr.start, "Label '" + maybeName + "' is already declared");
+  var kind = this.type.isLoop ? "loop" : this.type === tt._switch ? "switch" : null;
+  this.labels.push({name: maybeName, kind: kind});
+  node.body = this.parseStatement(true);
+  this.labels.pop();
+  node.label = expr;
+  return this.finishNode(node, "LabeledStatement");
+};
+
+pp.parseExpressionStatement = function(node, expr) {
+  node.expression = expr;
+  this.semicolon();
+  return this.finishNode(node, "ExpressionStatement");
+};
+
+// Parse a semicolon-enclosed block of statements, handling `"use
+// strict"` declarations when `allowStrict` is true (used for
+// function bodies).
+
+pp.parseBlock = function(allowStrict) {
+  var node = this.startNode(), first = true, oldStrict;
+  node.body = [];
+  this.expect(tt.braceL);
+  while (!this.eat(tt.braceR)) {
+    var stmt = this.parseStatement(true);
+    node.body.push(stmt);
+    if (first && allowStrict && this.isUseStrict(stmt)) {
+      oldStrict = this.strict;
+      this.setStrict(this.strict = true);
+    }
+    first = false;
+  }
+  if (oldStrict === false) this.setStrict(false);
+  return this.finishNode(node, "BlockStatement");
+};
+
+// Parse a regular `for` loop. The disambiguation code in
+// `parseStatement` will already have parsed the init statement or
+// expression.
+
+pp.parseFor = function(node, init) {
+  node.init = init;
+  this.expect(tt.semi);
+  node.test = this.type === tt.semi ? null : this.parseExpression();
+  this.expect(tt.semi);
+  node.update = this.type === tt.parenR ? null : this.parseExpression();
+  this.expect(tt.parenR);
+  node.body = this.parseStatement(false);
+  this.labels.pop();
+  return this.finishNode(node, "ForStatement");
+};
+
+// Parse a `for`/`in` and `for`/`of` loop, which are almost
+// same from parser's perspective.
+
+pp.parseForIn = function(node, init) {
+  var type = this.type === tt._in ? "ForInStatement" : "ForOfStatement";
+  this.next();
+  node.left = init;
+  node.right = this.parseExpression();
+  this.expect(tt.parenR);
+  node.body = this.parseStatement(false);
+  this.labels.pop();
+  return this.finishNode(node, type);
+};
+
+// Parse a list of variable declarations.
+
+pp.parseVar = function(node, noIn, kind) {
+  node.declarations = [];
+  node.kind = kind.keyword;
+  for (;;) {
+    var decl = this.startNode();
+    decl.id = this.parseBindingAtom();
+    this.checkLVal(decl.id, true);
+    if (this.eat(tt.eq)) {
+      decl.init = this.parseMaybeAssign(noIn);
+    } else if (kind === tt._const && !(this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
+      this.unexpected();
+    } else if (decl.id.type != "Identifier") {
+      this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value")
+    } else {
+      decl.init = null;
+    }
+    node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
+    if (!this.eat(tt.comma)) break;
+  }
+  return node;
+};
+
+// Parse a function declaration or literal (depending on the
+// `isStatement` parameter).
+
+pp.parseFunction = function(node, isStatement, allowExpressionBody) {
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 6) {
+    node.generator = this.eat(tt.star);
+  }
+  if (isStatement || this.type === tt.name) {
+    node.id = this.parseIdent();
+  }
+  this.expect(tt.parenL);
+  node.params = this.parseBindingList(tt.parenR, false, false);
+  this.parseFunctionBody(node, allowExpressionBody);
+  return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+};
+
+// Parse a class declaration or literal (depending on the
+// `isStatement` parameter).
+
+pp.parseClass = function(node, isStatement) {
+  this.next();
+  node.id = this.type === tt.name ? this.parseIdent() : isStatement ? this.unexpected() : null;
+  node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null;
+  var classBody = this.startNode();
+  classBody.body = [];
+  this.expect(tt.braceL);
+  while (!this.eat(tt.braceR)) {
+    if (this.eat(tt.semi)) continue;
+    var method = this.startNode();
+    var isGenerator = this.eat(tt.star);
+    this.parsePropertyName(method);
+    if (this.type !== tt.parenL && !method.computed && method.key.type === "Identifier" &&
+        method.key.name === "static") {
+      if (isGenerator) this.unexpected();
+      method['static'] = true;
+      isGenerator = this.eat(tt.star);
+      this.parsePropertyName(method);
+    } else {
+      method['static'] = false;
+    }
+    method.kind = "method";
+    if (!method.computed && !isGenerator) {
+      if (method.key.type === "Identifier") {
+        if (this.type !== tt.parenL && (method.key.name === "get" || method.key.name === "set")) {
+          method.kind = method.key.name;
+          this.parsePropertyName(method);
+        } else if (!method['static'] && method.key.name === "constructor") {
+          method.kind = "constructor";
+        }
+      } else if (!method['static'] && method.key.type === "Literal" && method.key.value === "constructor") {
+        method.kind = "constructor";
+      }
+    }
+    method.value = this.parseMethod(isGenerator);
+    classBody.body.push(this.finishNode(method, "MethodDefinition"));
+  }
+  node.body = this.finishNode(classBody, "ClassBody");
+  return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
+};
diff --git a/src/tokencontext.js b/src/tokencontext.js
index 870f3f1325..a23b5fab16 100644
--- a/src/tokencontext.js
+++ b/src/tokencontext.js
@@ -2,8 +2,9 @@
 // given point in the program is loosely based on sweet.js' approach.
 // See https://github.com/mozilla/sweet.js/wiki/design
 
-import Parser from "./state"
+import {Parser} from "./state"
 import {types as tt} from "./tokentype"
+import {lineBreak} from "./whitespace"
 
 export class TokContext {
   constructor(token, isExpr, preserveSpace, override) {
@@ -17,10 +18,10 @@ export class TokContext {
 export const types = {
   b_stat: new TokContext("{", false),
   b_expr: new TokContext("{", true),
-  b_tmpl: new TokContext("${", true, null, p => p.readTmplToken()),
+  b_tmpl: new TokContext("${", true),
   p_stat: new TokContext("(", false),
   p_expr: new TokContext("(", true),
-  q_tmpl: new TokContext("`", true, true),
+  q_tmpl: new TokContext("`", true, true, p => p.readTmplToken()),
   f_expr: new TokContext("function", true)
 }
 
diff --git a/src/tokenize.js b/src/tokenize.js
index c8f21c749e..470a9b49b6 100644
--- a/src/tokenize.js
+++ b/src/tokenize.js
@@ -1,7 +1,8 @@
 import {isIdentifierStart, isIdentifierChar} from "./identifier"
 import {types as tt, keywords as keywordTypes} from "./tokentype"
-import Parser from "./state"
-import "./tokencontext"
+import {Parser} from "./state"
+import {SourceLocation} from "./location"
+import {lineBreak, lineBreakG, isNewLine, nonASCIIwhitespace} from "./whitespace"
 
 // Object type used to represent tokens. Note that normally, tokens
 // simply exist as properties on the parser object. This is only
@@ -20,33 +21,10 @@ export class Token {
   }
 }
 
-// Matches a whole line break (where CRLF is considered a single
-// line break). Used to count lines.
-
-export const lineBreak = /\r\n?|\n|\u2028|\u2029/g
-
-export function isNewLine(code) {
-  return code === 10 || code === 13 || code === 0x2028 || code == 0x2029
-}
-
 // ## Tokenizer
 
-// Shorthand because we are going to be adding a _lot_ of methods to
-// this.
 const pp = Parser.prototype
 
-pp.extend = function(name, f) {
-  this[name] = f(this[name]);
-};
-
-pp.loadPlugins = function(plugins) {
-  for (var name in plugins) {
-    var plugin = exports.plugins[name];
-    if (!plugin) throw new Error("Plugin '" + name + "' not found");
-    plugin(this, plugins[name]);
-  }
-};
-
 // Move to the next token
 
 pp.next = function() {
@@ -135,9 +113,9 @@ pp.skipBlockComment = function() {
   if (end === -1) this.raise(this.pos - 2, "Unterminated comment");
   this.pos = end + 2;
   if (this.options.locations) {
-    lineBreak.lastIndex = start;
+    lineBreakG.lastIndex = start;
     var match;
-    while ((match = lineBreak.exec(this.input)) && match.index < this.pos) {
+    while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {
       ++this.curLine;
       this.lineStart = match.index + match[0].length;
     }
diff --git a/src/whitespace.js b/src/whitespace.js
new file mode 100644
index 0000000000..1f4404ac79
--- /dev/null
+++ b/src/whitespace.js
@@ -0,0 +1,12 @@
+// Matches a whole line break (where CRLF is considered a single
+// line break). Used to count lines.
+
+export const lineBreak = /\r\n?|\n|\u2028|\u2029/
+export const lineBreakG = new RegExp(lineBreak.source, "g")
+
+export function isNewLine(code) {
+  return code === 10 || code === 13 || code === 0x2028 || code == 0x2029
+}
+
+export const nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/
+

From dd89c6e11264f8f016831b1ce699f376dc5282d7 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 12:04:33 +0100
Subject: [PATCH 26/43] Make loose parser work with minor interface changes
 introduced by modularization

---
 acorn_loose.js |  10 ++--
 src/index.js   | 128 ++-----------------------------------------------
 src/options.js | 119 +++++++++++++++++++++++++++++++++++++++++++++
 src/state.js   |   4 ++
 test/driver.js |   2 +-
 5 files changed, 133 insertions(+), 130 deletions(-)
 create mode 100644 src/options.js

diff --git a/acorn_loose.js b/acorn_loose.js
index b8207e242b..b2165715ec 100644
--- a/acorn_loose.js
+++ b/acorn_loose.js
@@ -41,13 +41,13 @@
   acorn.defaultOptions.tabSize = 4;
 
   exports.parse_dammit = function(input, options) {
-    var p = new LooseParser(options, input);
+    var p = new LooseParser(input, options);
     p.next();
     return p.parseTopLevel();
   };
 
   var LooseParser = exports.LooseParser = function(input, options) {
-    this.toks = new acorn.Parser(input, options);
+    this.toks = acorn.tokenizer(input, options)
     this.options = this.toks.options;
     this.input = this.toks.input;
     this.tok = this.last = {type: tt.eof, start: 0, end: 0};
@@ -149,9 +149,9 @@
 
     if (this.options.locations) {
       this.toks.curLine = 1;
-      this.toks.lineStart = acorn.lineBreak.lastIndex = 0;
+      this.toks.lineStart = acorn.lineBreakG.lastIndex = 0;
       var match;
-      while ((match = acorn.lineBreak.exec(this.input)) && match.index < pos) {
+      while ((match = acorn.lineBreakG.exec(this.input)) && match.index < pos) {
         ++this.toks.curLine;
         this.toks.lineStart = match.index + match[0].length;
       }
@@ -273,7 +273,7 @@
 
   lp.canInsertSemicolon = function() {
     return this.tok.type === tt.eof || this.tok.type === tt.braceR ||
-      acorn.newline.test(this.input.slice(this.last.end, this.tok.start));
+      acorn.lineBreak.test(this.input.slice(this.last.end, this.tok.start));
   };
 
   lp.semicolon = function() {
diff --git a/src/index.js b/src/index.js
index 0842ab400d..055f99b77c 100644
--- a/src/index.js
+++ b/src/index.js
@@ -19,15 +19,15 @@
 // [dammit]: acorn_loose.js
 // [walk]: util/walk.js
 
-import {Parser} from "./state"
-import {has, isArray} from "./util"
-import {SourceLocation} from "./location"
+import {Parser, plugins} from "./state"
+import {getOptions} from "./options"
 import "./parseutil"
 import "./statement"
 import "./lval"
 import "./expression"
 
 export {Parser} from "./state"
+export {defaultOptions} from "./options"
 export {SourceLocation} from "./location"
 export {getLineInfo} from "./location"
 export {Node} from "./node"
@@ -35,7 +35,7 @@ export {TokenType, types as tokTypes} from "./tokentype"
 export {TokContext, types as tokContexts} from "./tokencontext"
 export {isIdentifierChar, isIdentifierStart} from "./identifier"
 export {Token} from "./tokenize"
-export {isNewLine, lineBreak} from "./whitespace"
+export {isNewLine, lineBreak, lineBreakG} from "./whitespace"
 
 export const version = "0.12.1"
 
@@ -53,126 +53,6 @@ export function parse(input, options) {
   return p.parseTopLevel(p.options.program || p.startNodeAt(startPos))
 }
 
-// A second optional argument can be given to further configure
-// the parser process. These options are recognized:
-
-export const 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,
-  // Source type ("script" or "module") for different semantics
-  sourceType: "script",
-  // `onInsertedSemicolon` can be a callback that will be called
-  // when a semicolon is automatically inserted. It will be passed
-  // th position of the comma as an offset, and if `locations` is
-  // enabled, it is given the location as a `{line, column}` object
-  // as second argument.
-  onInsertedSemicolon: null,
-  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
-  // trailing commas.
-  onTrailingComma: null,
-  // By default, reserved words are not enforced. Disable
-  // `allowReserved` to enforce them. When this option has the
-  // value "never", reserved words and keywords can also not be
-  // used as property names.
-  allowReserved: true,
-  // When enabled, a return at the top level is not considered an
-  // error.
-  allowReturnOutsideFunction: false,
-  // When enabled, import/export statements are not constrained to
-  // appearing at the top of the program.
-  allowImportExportEverywhere: false,
-  // When enabled, hashbang directive in the beginning of file
-  // is allowed and treated as a line comment.
-  allowHashBang: 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] `range` property holding a `[start,
-  // end]` array with the same numbers, set the `ranges` option to
-  // `true`.
-  //
-  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
-  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,
-  // When enabled, parenthesized expressions are represented by
-  // (non-standard) ParenthesizedExpression nodes
-  preserveParens: false,
-  plugins: {}
-}
-
-// Registered plugins
-
-export const plugins = {}
-
-// Interpret and default an options object
-
-function getOptions(opts) {
-  let options = {}
-  for (let opt in defaultOptions)
-    options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]
-
-  if (isArray(options.onToken)) {
-    var tokens = options.onToken;
-    options.onToken = (token) => tokens.push(token)
-  }
-  if (isArray(options.onComment))
-    options.onComment = pushComment(options, options.onComment);
-
-  return options;
-}
-
-function pushComment(options, array) {
-  return function (block, text, start, end, startLoc, endLoc) {
-    let comment = {
-      type: block ? 'Block' : 'Line',
-      value: text,
-      start: start,
-      end: end
-    }
-    if (options.locations)
-      comment.loc = new SourceLocation(this, startLoc, endLoc)
-    if (options.ranges)
-      comment.range = [start, end]
-    array.push(comment)
-  }
-}
-
 // 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.
diff --git a/src/options.js b/src/options.js
new file mode 100644
index 0000000000..713345a6b3
--- /dev/null
+++ b/src/options.js
@@ -0,0 +1,119 @@
+import {has, isArray} from "./util"
+import {SourceLocation} from "./location"
+
+// A second optional argument can be given to further configure
+// the parser process. These options are recognized:
+
+export const 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,
+  // Source type ("script" or "module") for different semantics
+  sourceType: "script",
+  // `onInsertedSemicolon` can be a callback that will be called
+  // when a semicolon is automatically inserted. It will be passed
+  // th position of the comma as an offset, and if `locations` is
+  // enabled, it is given the location as a `{line, column}` object
+  // as second argument.
+  onInsertedSemicolon: null,
+  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
+  // trailing commas.
+  onTrailingComma: null,
+  // By default, reserved words are not enforced. Disable
+  // `allowReserved` to enforce them. When this option has the
+  // value "never", reserved words and keywords can also not be
+  // used as property names.
+  allowReserved: true,
+  // When enabled, a return at the top level is not considered an
+  // error.
+  allowReturnOutsideFunction: false,
+  // When enabled, import/export statements are not constrained to
+  // appearing at the top of the program.
+  allowImportExportEverywhere: false,
+  // When enabled, hashbang directive in the beginning of file
+  // is allowed and treated as a line comment.
+  allowHashBang: 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] `range` property holding a `[start,
+  // end]` array with the same numbers, set the `ranges` option to
+  // `true`.
+  //
+  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
+  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,
+  // When enabled, parenthesized expressions are represented by
+  // (non-standard) ParenthesizedExpression nodes
+  preserveParens: false,
+  plugins: {}
+}
+
+// Interpret and default an options object
+
+export function getOptions(opts) {
+  let options = {}
+  for (let opt in defaultOptions)
+    options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]
+
+  if (isArray(options.onToken)) {
+    var tokens = options.onToken;
+    options.onToken = (token) => tokens.push(token)
+  }
+  if (isArray(options.onComment))
+    options.onComment = pushComment(options, options.onComment);
+
+  return options;
+}
+
+function pushComment(options, array) {
+  return function (block, text, start, end, startLoc, endLoc) {
+    let comment = {
+      type: block ? 'Block' : 'Line',
+      value: text,
+      start: start,
+      end: end
+    }
+    if (options.locations)
+      comment.loc = new SourceLocation(this, startLoc, endLoc)
+    if (options.ranges)
+      comment.range = [start, end]
+    array.push(comment)
+  }
+}
+
diff --git a/src/state.js b/src/state.js
index 3ef232de3d..f14060be5b 100644
--- a/src/state.js
+++ b/src/state.js
@@ -59,6 +59,10 @@ Parser.prototype.extend = function(name, f) {
   this[name] = f(this[name])
 }
 
+// Registered plugins
+
+export const plugins = {}
+
 Parser.prototype.loadPlugins = function(plugins) {
   for (let name in plugins) {
     let plugin = exports.plugins[name]
diff --git a/test/driver.js b/test/driver.js
index d8998b930b..46e29e547c 100644
--- a/test/driver.js
+++ b/test/driver.js
@@ -27,7 +27,7 @@
       try {
         var ast = parse(test.code, testOpts);
       } catch(e) {
-        if (!(e instanceof SyntaxError)) throw e;
+        if (!(e instanceof SyntaxError)) { console.log(e.stack); throw e; }
         if (test.error) {
           if (e.message == test.error) callback("ok", test.code);
           else callback("fail", test.code,

From cf613ce2872c60b9b62c192167cdc392b8b4c6b4 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 14:41:55 +0100
Subject: [PATCH 27/43] Split up the loose parser, set up a build script

---
 dist/.keep               |   0
 src/loose/acorn_loose.js |   0
 src/loose/expression.js  | 603 +++++++++++++++++++++++++++++++++++++++
 src/loose/index.js       |  50 ++++
 src/loose/parseutil.js   | 126 ++++++++
 src/loose/state.js       |  17 ++
 src/loose/statement.js   | 311 ++++++++++++++++++++
 src/loose/tokenize.js    | 108 +++++++
 tools/build-acorn.js     |  40 +++
 9 files changed, 1255 insertions(+)
 create mode 100644 dist/.keep
 create mode 100644 src/loose/acorn_loose.js
 create mode 100644 src/loose/expression.js
 create mode 100644 src/loose/index.js
 create mode 100644 src/loose/parseutil.js
 create mode 100644 src/loose/state.js
 create mode 100644 src/loose/statement.js
 create mode 100644 src/loose/tokenize.js
 create mode 100644 tools/build-acorn.js

diff --git a/dist/.keep b/dist/.keep
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/loose/acorn_loose.js b/src/loose/acorn_loose.js
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/loose/expression.js b/src/loose/expression.js
new file mode 100644
index 0000000000..ff38374b94
--- /dev/null
+++ b/src/loose/expression.js
@@ -0,0 +1,603 @@
+import {LooseParser} from "./state"
+import {isDummy} from "./parseutil"
+import {tokTypes as tt} from ".."
+
+const lp = LooseParser.prototype
+
+lp.checkLVal = function(expr) {
+  if (!expr) return expr;
+  switch (expr.type) {
+  case "Identifier":
+  case "MemberExpression":
+  case "ObjectPattern":
+  case "ArrayPattern":
+  case "RestElement":
+  case "AssignmentPattern":
+    return expr;
+
+  default:
+    return this.dummyIdent();
+  }
+};
+
+lp.parseExpression = function(noIn) {
+  var start = this.storeCurrentPos();
+  var expr = this.parseMaybeAssign(noIn);
+  if (this.tok.type === tt.comma) {
+    var node = this.startNodeAt(start);
+    node.expressions = [expr];
+    while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn));
+    return this.finishNode(node, "SequenceExpression");
+  }
+  return expr;
+};
+
+lp.parseParenExpression = function() {
+  this.pushCx();
+  this.expect(tt.parenL);
+  var val = this.parseExpression();
+  this.popCx();
+  this.expect(tt.parenR);
+  return val;
+};
+
+lp.parseMaybeAssign = function(noIn) {
+  var start = this.storeCurrentPos();
+  var left = this.parseMaybeConditional(noIn);
+  if (this.tok.type.isAssign) {
+    var node = this.startNodeAt(start);
+    node.operator = this.tok.value;
+    node.left = this.tok.type === tt.eq ? this.toAssignable(left) : this.checkLVal(left);
+    this.next();
+    node.right = this.parseMaybeAssign(noIn);
+    return this.finishNode(node, "AssignmentExpression");
+  }
+  return left;
+};
+
+lp.parseMaybeConditional = function(noIn) {
+  var start = this.storeCurrentPos();
+  var expr = this.parseExprOps(noIn);
+  if (this.eat(tt.question)) {
+    var node = this.startNodeAt(start);
+    node.test = expr;
+    node.consequent = this.parseMaybeAssign();
+    node.alternate = this.expect(tt.colon) ? this.parseMaybeAssign(noIn) : this.dummyIdent();
+    return this.finishNode(node, "ConditionalExpression");
+  }
+  return expr;
+};
+
+lp.parseExprOps = function(noIn) {
+  var start = this.storeCurrentPos();
+  var indent = this.curIndent, line = this.curLineStart;
+  return this.parseExprOp(this.parseMaybeUnary(noIn), start, -1, noIn, indent, line);
+};
+
+lp.parseExprOp = function(left, start, minPrec, noIn, indent, line) {
+  if (this.curLineStart != line && this.curIndent < indent && this.tokenStartsLine()) return left;
+  var prec = this.tok.type.binop;
+  if (prec != null && (!noIn || this.tok.type !== tt._in)) {
+    if (prec > minPrec) {
+      var node = this.startNodeAt(start);
+      node.left = left;
+      node.operator = this.tok.value;
+      this.next();
+      if (this.curLineStart != line && this.curIndent < indent && this.tokenStartsLine()) {
+        node.right = this.dummyIdent();
+      } else {
+        var rightStart = this.storeCurrentPos();
+        node.right = this.parseExprOp(this.parseMaybeUnary(noIn), rightStart, prec, noIn, indent, line);
+      }
+      this.finishNode(node, /&&|\|\|/.test(node.operator) ? "LogicalExpression" : "BinaryExpression");
+      return this.parseExprOp(node, start, minPrec, noIn, indent, line);
+    }
+  }
+  return left;
+};
+
+lp.parseMaybeUnary = function(noIn) {
+  if (this.tok.type.prefix) {
+    var node = this.startNode(), update = this.tok.type === tt.incDec;
+    node.operator = this.tok.value;
+    node.prefix = true;
+    this.next();
+    node.argument = this.parseMaybeUnary(noIn);
+    if (update) node.argument = this.checkLVal(node.argument);
+    return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+  } else if (this.tok.type === tt.ellipsis) {
+    var node = this.startNode();
+    this.next();
+    node.argument = this.parseMaybeUnary(noIn);
+    return this.finishNode(node, "SpreadElement");
+  }
+  var start = this.storeCurrentPos();
+  var expr = this.parseExprSubscripts();
+  while (this.tok.type.postfix && !this.canInsertSemicolon()) {
+    var node = this.startNodeAt(start);
+    node.operator = this.tok.value;
+    node.prefix = false;
+    node.argument = this.checkLVal(expr);
+    this.next();
+    expr = this.finishNode(node, "UpdateExpression");
+  }
+  return expr;
+};
+
+lp.parseExprSubscripts = function() {
+  var start = this.storeCurrentPos();
+  return this.parseSubscripts(this.parseExprAtom(), start, false, this.curIndent, this.curLineStart);
+};
+
+lp.parseSubscripts = function(base, start, noCalls, startIndent, line) {
+  for (;;) {
+    if (this.curLineStart != line && this.curIndent <= startIndent && this.tokenStartsLine()) {
+      if (this.tok.type == tt.dot && this.curIndent == startIndent)
+        --startIndent;
+      else
+        return base;
+    }
+
+    if (this.eat(tt.dot)) {
+      var node = this.startNodeAt(start);
+      node.object = base;
+      if (this.curLineStart != line && this.curIndent <= startIndent && this.tokenStartsLine())
+        node.property = this.dummyIdent();
+      else
+        node.property = this.parsePropertyAccessor() || this.dummyIdent();
+      node.computed = false;
+      base = this.finishNode(node, "MemberExpression");
+    } else if (this.tok.type == tt.bracketL) {
+      this.pushCx();
+      this.next();
+      var node = this.startNodeAt(start);
+      node.object = base;
+      node.property = this.parseExpression();
+      node.computed = true;
+      this.popCx();
+      this.expect(tt.bracketR);
+      base = this.finishNode(node, "MemberExpression");
+    } else if (!noCalls && this.tok.type == tt.parenL) {
+      this.pushCx();
+      var node = this.startNodeAt(start);
+      node.callee = base;
+      node.arguments = this.parseExprList(tt.parenR);
+      base = this.finishNode(node, "CallExpression");
+    } else if (this.tok.type == tt.backQuote) {
+      var node = this.startNodeAt(start);
+      node.tag = base;
+      node.quasi = this.parseTemplate();
+      base = this.finishNode(node, "TaggedTemplateExpression");
+    } else {
+      return base;
+    }
+  }
+};
+
+lp.parseExprAtom = function() {
+  switch (this.tok.type) {
+  case tt._this:
+  case tt._super:
+    var type = this.tok.type === tt._this ? "ThisExpression" : "SuperExpression";
+    var node = this.startNode();
+    this.next();
+    return this.finishNode(node, type);
+
+  case tt.name:
+    var start = this.storeCurrentPos();
+    var id = this.parseIdent();
+    return this.eat(tt.arrow) ? this.parseArrowExpression(this.startNodeAt(start), [id]) : id;
+
+  case tt.regexp:
+    var node = this.startNode();
+    var val = this.tok.value;
+    node.regex = {pattern: val.pattern, flags: val.flags};
+    node.value = val.value;
+    node.raw = this.input.slice(this.tok.start, this.tok.end);
+    this.next();
+    return this.finishNode(node, "Literal");
+
+  case tt.num: case tt.string:
+    var node = this.startNode();
+    node.value = this.tok.value;
+    node.raw = this.input.slice(this.tok.start, this.tok.end);
+    this.next();
+    return this.finishNode(node, "Literal");
+
+  case tt._null: case tt._true: case tt._false:
+    var node = this.startNode();
+    node.value = this.tok.type === tt._null ? null : this.tok.type === tt._true;
+    node.raw = this.tok.type.keyword;
+    this.next();
+    return this.finishNode(node, "Literal");
+
+  case tt.parenL:
+    var start = this.storeCurrentPos();
+    this.next();
+    var val = this.parseExpression();
+    this.expect(tt.parenR);
+    if (this.eat(tt.arrow)) {
+      return this.parseArrowExpression(this.startNodeAt(start), val.expressions || (isDummy(val) ? [] : [val]));
+    }
+    if (this.options.preserveParens) {
+      var par = this.startNodeAt(start);
+      par.expression = val;
+      val = this.finishNode(par, "ParenthesizedExpression");
+    }
+    return val;
+
+  case tt.bracketL:
+    var node = this.startNode();
+    this.pushCx();
+    node.elements = this.parseExprList(tt.bracketR, true);
+    return this.finishNode(node, "ArrayExpression");
+
+  case tt.braceL:
+    return this.parseObj();
+
+  case tt._class:
+    return this.parseClass();
+
+  case tt._function:
+    var node = this.startNode();
+    this.next();
+    return this.parseFunction(node, false);
+
+  case tt._new:
+    return this.parseNew();
+
+  case tt._yield:
+    var node = this.startNode();
+    this.next();
+    if (this.semicolon() || this.canInsertSemicolon() || (this.tok.type != tt.star && !this.tok.type.startsExpr)) {
+      node.delegate = false;
+      node.argument = null;
+    } else {
+      node.delegate = this.eat(tt.star);
+      node.argument = this.parseMaybeAssign();
+    }
+    return this.finishNode(node, "YieldExpression");
+
+  case tt.backQuote:
+    return this.parseTemplate();
+
+  default:
+    return this.dummyIdent();
+  }
+};
+
+lp.parseNew = function() {
+  var node = this.startNode(), startIndent = this.curIndent, line = this.curLineStart;
+  this.next();
+  var start = this.storeCurrentPos();
+  node.callee = this.parseSubscripts(this.parseExprAtom(), start, true, startIndent, line);
+  if (this.tok.type == tt.parenL) {
+    this.pushCx();
+    node.arguments = this.parseExprList(tt.parenR);
+  } else {
+    node.arguments = [];
+  }
+  return this.finishNode(node, "NewExpression");
+};
+
+lp.parseTemplateElement = function() {
+  var elem = this.startNode();
+  elem.value = {
+    raw: this.input.slice(this.tok.start, this.tok.end),
+    cooked: this.tok.value
+  };
+  this.next();
+  elem.tail = this.tok.type === tt.backQuote;
+  return this.finishNode(elem, "TemplateElement");
+};
+
+lp.parseTemplate = function() {
+  var node = this.startNode();
+  this.next();
+  node.expressions = [];
+  var curElt = this.parseTemplateElement();
+  node.quasis = [curElt];
+  while (!curElt.tail) {
+    this.next();
+    node.expressions.push(this.parseExpression());
+    if (this.expect(tt.braceR)) {
+      curElt = this.parseTemplateElement();
+    } else {
+      curElt = this.startNode();
+      curElt.value = {cooked: '', raw: ''};
+      curElt.tail = true;
+    }
+    node.quasis.push(curElt);
+  }
+  this.expect(tt.backQuote);
+  return this.finishNode(node, "TemplateLiteral");
+};
+
+lp.parseObj = function() {
+  var node = this.startNode();
+  node.properties = [];
+  this.pushCx();
+  var indent = this.curIndent + 1, line = this.curLineStart;
+  this.eat(tt.braceL);
+  if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart; }
+  while (!this.closes(tt.braceR, indent, line)) {
+    var prop = this.startNode(), isGenerator, start;
+    if (this.options.ecmaVersion >= 6) {
+      start = this.storeCurrentPos();
+      prop.method = false;
+      prop.shorthand = false;
+      isGenerator = this.eat(tt.star);
+    }
+    this.parsePropertyName(prop);
+    if (isDummy(prop.key)) { if (isDummy(this.parseMaybeAssign())) this.next(); this.eat(tt.comma); continue; }
+    if (this.eat(tt.colon)) {
+      prop.kind = "init";
+      prop.value = this.parseMaybeAssign();
+    } else if (this.options.ecmaVersion >= 6 && (this.tok.type === tt.parenL || this.tok.type === tt.braceL)) {
+      prop.kind = "init";
+      prop.method = true;
+      prop.value = this.parseMethod(isGenerator);
+    } else if (this.options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
+               !prop.computed && (prop.key.name === "get" || prop.key.name === "set") &&
+               (this.tok.type != tt.comma && this.tok.type != tt.braceR)) {
+      prop.kind = prop.key.name;
+      this.parsePropertyName(prop);
+      prop.value = this.parseMethod(false);
+    } else {
+      prop.kind = "init";
+      if (this.options.ecmaVersion >= 6) {
+        if (this.eat(tt.eq)) {
+          var assign = this.startNodeAt(start);
+          assign.operator = "=";
+          assign.left = prop.key;
+          assign.right = this.parseMaybeAssign();
+          prop.value = this.finishNode(assign, "AssignmentExpression");
+        } else {
+          prop.value = prop.key;
+        }
+      } else {
+        prop.value = this.dummyIdent();
+      }
+      prop.shorthand = true;
+    }
+    node.properties.push(this.finishNode(prop, "Property"));
+    this.eat(tt.comma);
+  }
+  this.popCx();
+  if (!this.eat(tt.braceR)) {
+    // If there is no closing brace, make the node span to the start
+    // of the next token (this is useful for Tern)
+    this.last.end = this.tok.start;
+    if (this.options.locations) this.last.loc.end = this.tok.loc.start;
+  }
+  return this.finishNode(node, "ObjectExpression");
+};
+
+lp.parsePropertyName = function(prop) {
+  if (this.options.ecmaVersion >= 6) {
+    if (this.eat(tt.bracketL)) {
+      prop.computed = true;
+      prop.key = this.parseExpression();
+      this.expect(tt.bracketR);
+      return;
+    } else {
+      prop.computed = false;
+    }
+  }
+  var key = (this.tok.type === tt.num || this.tok.type === tt.string) ? this.parseExprAtom() : this.parseIdent();
+  prop.key = key || this.dummyIdent();
+};
+
+lp.parsePropertyAccessor = function() {
+  if (this.tok.type === tt.name || this.tok.type.keyword) return this.parseIdent();
+};
+
+lp.parseIdent = function() {
+  var node = this.startNode();
+  node.name = this.tok.type === tt.name ? this.tok.value : this.tok.type.keyword;
+  this.next();
+  return this.finishNode(node, "Identifier");
+};
+
+lp.initFunction = function(node) {
+  node.id = null;
+  node.params = [];
+  if (this.options.ecmaVersion >= 6) {
+    node.generator = false;
+    node.expression = false;
+  }
+};
+
+// Convert existing expression atom to assignable pattern
+// if possible.
+
+lp.toAssignable = function(node) {
+  if (this.options.ecmaVersion >= 6 && node) {
+    switch (node.type) {
+    case "ObjectExpression":
+      node.type = "ObjectPattern";
+      var props = node.properties;
+      for (var i = 0; i < props.length; i++)
+        this.toAssignable(props[i].value);
+      break;
+
+    case "ArrayExpression":
+      node.type = "ArrayPattern";
+      this.toAssignableList(node.elements);
+      break;
+
+    case "SpreadElement":
+      node.type = "RestElement";
+      node.argument = this.toAssignable(node.argument);
+      break;
+
+    case "AssignmentExpression":
+      node.type = "AssignmentPattern";
+      break;
+    }
+  }
+  return this.checkLVal(node);
+};
+
+lp.toAssignableList = function(exprList) {
+  for (var i = 0; i < exprList.length; i++)
+    this.toAssignable(exprList[i]);
+  return exprList;
+};
+
+lp.parseFunctionParams = function(params) {
+  this.pushCx();
+  params = this.parseExprList(tt.parenR);
+  return this.toAssignableList(params);
+};
+
+lp.parseMethod = function(isGenerator) {
+  var node = this.startNode();
+  this.initFunction(node);
+  node.params = this.parseFunctionParams();
+  node.generator = isGenerator || false;
+  node.expression = this.options.ecmaVersion >= 6 && this.tok.type !== tt.braceL;
+  node.body = node.expression ? this.parseMaybeAssign() : this.parseBlock();
+  return this.finishNode(node, "FunctionExpression");
+};
+
+lp.parseArrowExpression = function(node, params) {
+  this.initFunction(node);
+  node.params = this.toAssignableList(params);
+  node.expression = this.tok.type !== tt.braceL;
+  node.body = node.expression ? this.parseMaybeAssign() : this.parseBlock();
+  return this.finishNode(node, "ArrowFunctionExpression");
+};
+
+lp.parseExport = function() {
+  var node = this.startNode();
+  this.next();
+  if (this.eat(tt.star)) {
+    node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
+    return this.finishNode(node, "ExportAllDeclaration");
+  }
+  if (this.eat(tt._default)) {
+    var expr = this.parseMaybeAssign();
+    if (expr.id) {
+      switch (expr.type) {
+      case "FunctionExpression": expr.type = "FunctionDeclaration"; break;
+      case "ClassExpression": expr.type = "ClassDeclaration"; break;
+      }
+    }
+    node.declaration = expr;
+    this.semicolon();
+    return this.finishNode(node, "ExportDefaultDeclaration");
+  }
+  if (this.tok.type.keyword) {
+    node.declaration = this.parseStatement();
+    node.specifiers = [];
+    node.source = null;
+  } else {
+    node.declaration = null;
+    node.specifiers = this.parseExportSpecifierList();
+    node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
+    this.semicolon();
+  }
+  return this.finishNode(node, "ExportNamedDeclaration");
+};
+
+lp.parseImport = function() {
+  var node = this.startNode();
+  this.next();
+  if (this.tok.type === tt.string) {
+    node.specifiers = [];
+    node.source = this.parseExprAtom();
+    node.kind = '';
+  } else {
+    if (this.tok.type === tt.name && this.tok.value !== "from") {
+      var elt = this.startNode();
+      elt.local = this.parseIdent();
+      this.finishNode(elt, "ImportDefaultSpecifier");
+      this.eat(tt.comma);
+    }
+    node.specifiers = this.parseImportSpecifierList();
+    node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
+    if (elt) node.specifiers.unshift(elt);
+  }
+  this.semicolon();
+  return this.finishNode(node, "ImportDeclaration");
+};
+
+lp.parseImportSpecifierList = function() {
+  var elts = [];
+  if (this.tok.type === tt.star) {
+    var elt = this.startNode();
+    this.next();
+    if (this.eatContextual("as")) elt.local = this.parseIdent();
+    elts.push(this.finishNode(elt, "ImportNamespaceSpecifier"));
+  } else {
+    var indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart;
+    this.pushCx();
+    this.eat(tt.braceL);
+    if (this.curLineStart > continuedLine) continuedLine = this.curLineStart;
+    while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
+      var elt = this.startNode();
+      if (this.eat(tt.star)) {
+        if (this.eatContextual("as")) elt.local = this.parseIdent();
+        this.finishNode(elt, "ImportNamespaceSpecifier");
+      } else {
+        if (this.isContextual("from")) break;
+        elt.imported = this.parseIdent();
+        elt.local = this.eatContextual("as") ? this.parseIdent() : elt.imported;
+        this.finishNode(elt, "ImportSpecifier");
+      }
+      elts.push(elt);
+      this.eat(tt.comma);
+    }
+    this.eat(tt.braceR);
+    this.popCx();
+  }
+  return elts;
+};
+
+lp.parseExportSpecifierList = function() {
+  var elts = [];
+  var indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart;
+  this.pushCx();
+  this.eat(tt.braceL);
+  if (this.curLineStart > continuedLine) continuedLine = this.curLineStart;
+  while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
+    if (this.isContextual("from")) break;
+    var elt = this.startNode();
+    elt.local = this.parseIdent();
+    elt.exported = this.eatContextual("as") ? this.parseIdent() : elt.local;
+    this.finishNode(elt, "ExportSpecifier");
+    elts.push(elt);
+    this.eat(tt.comma);
+  }
+  this.eat(tt.braceR);
+  this.popCx();
+  return elts;
+};
+
+lp.parseExprList = function(close, allowEmpty) {
+  var indent = this.curIndent, line = this.curLineStart, elts = [];
+  this.next(); // Opening bracket
+  while (!this.closes(close, indent + 1, line)) {
+    if (this.eat(tt.comma)) {
+      elts.push(allowEmpty ? null : this.dummyIdent());
+      continue;
+    }
+    var elt = this.parseMaybeAssign();
+    if (isDummy(elt)) {
+      if (this.closes(close, indent, line)) break;
+      this.next();
+    } else {
+      elts.push(elt);
+    }
+    this.eat(tt.comma);
+  }
+  this.popCx();
+  if (!this.eat(close)) {
+    // If there is no closing brace, make the node span to the start
+    // of the next token (this is useful for Tern)
+    this.last.end = this.tok.start;
+    if (this.options.locations) this.last.loc.end = this.tok.loc.start;
+  }
+  return elts;
+};
diff --git a/src/loose/index.js b/src/loose/index.js
new file mode 100644
index 0000000000..acbea8a6c3
--- /dev/null
+++ b/src/loose/index.js
@@ -0,0 +1,50 @@
+// Acorn: Loose parser
+//
+// This module provides an alternative parser (`parse_dammit`) that
+// exposes that same interface as `parse`, but will try to parse
+// anything as JavaScript, repairing syntax error the best it can.
+// There are circumstances in which it will raise an error and give
+// up, but they are very rare. The resulting AST will be a mostly
+// valid JavaScript AST (as per the [Mozilla parser API][api], except
+// that:
+//
+// - Return outside functions is allowed
+//
+// - Label consistency (no conflicts, break only to existing labels)
+//   is not enforced.
+//
+// - Bogus Identifier nodes with a name of `"✖"` are inserted whenever
+//   the parser got too confused to return anything meaningful.
+//
+// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
+//
+// The expected use for this is to *first* try `acorn.parse`, and only
+// if that fails switch to `parse_dammit`. The loose parser might
+// parse badly indented code incorrectly, so **don't** use it as
+// your default parser.
+//
+// Quite a lot of acorn.js is duplicated here. The alternative was to
+// add a *lot* of extra cruft to that file, making it less readable
+// and slower. Copying and editing the code allowed me to make
+// invasive changes and simplifications without creating a complicated
+// tangle.
+
+import * as acorn from ".."
+import {LooseParser} from "./state"
+import "./tokenize"
+import "./parseutil"
+import "./statement"
+import "./expression"
+
+export {LooseParser} from "./state"
+
+acorn.defaultOptions.tabSize = 4
+
+export function parse_dammit(input, options) {
+  let p = new LooseParser(input, options)
+  p.next()
+  return p.parseTopLevel()
+}
+
+acorn.parse_dammit = parse_dammit
+acorn.LooseParser = LooseParser
diff --git a/src/loose/parseutil.js b/src/loose/parseutil.js
new file mode 100644
index 0000000000..5f656ec282
--- /dev/null
+++ b/src/loose/parseutil.js
@@ -0,0 +1,126 @@
+import {LooseParser} from "./state"
+import {Node, SourceLocation, lineBreak, isNewLine, tokTypes as tt} from ".."
+
+const lp = LooseParser.prototype
+
+lp.startNode = function() {
+  var node = new Node;
+  node.start = this.tok.start;
+  if (this.options.locations)
+    node.loc = new SourceLocation(this.toks, this.tok.loc.start);
+  if (this.options.directSourceFile)
+    node.sourceFile = this.options.directSourceFile;
+  if (this.options.ranges)
+    node.range = [this.tok.start, 0];
+  return node;
+};
+
+lp.storeCurrentPos = function() {
+  return this.options.locations ? [this.tok.start, this.tok.loc.start] : this.tok.start;
+};
+
+lp.startNodeAt = function(pos) {
+  var node = new Node;
+  if (this.options.locations) {
+    node.start = pos[0];
+    node.loc = new SourceLocation(this.toks, pos[1]);
+    pos = pos[0];
+  } else {
+    node.start = pos;
+  }
+  if (this.options.directSourceFile)
+    node.sourceFile = this.options.directSourceFile;
+  if (this.options.ranges)
+    node.range = [pos, 0];
+  return node;
+};
+
+lp.finishNode = function(node, type) {
+  node.type = type;
+  node.end = this.last.end;
+  if (this.options.locations)
+    node.loc.end = this.last.loc.end;
+  if (this.options.ranges)
+    node.range[1] = this.last.end;
+  return node;
+};
+
+lp.dummyIdent = function() {
+  var dummy = this.startNode();
+  dummy.name = "✖";
+  return this.finishNode(dummy, "Identifier");
+};
+
+export function isDummy(node) { return node.name == "✖"; }
+
+lp.eat = function(type) {
+  if (this.tok.type === type) {
+    this.next();
+    return true;
+  } else {
+    return false;
+  }
+};
+
+lp.isContextual = function(name) {
+  return this.tok.type === tt.name && this.tok.value === name;
+};
+
+lp.eatContextual = function(name) {
+  return this.tok.value === name && this.eat(tt.name);
+};
+
+lp.canInsertSemicolon = function() {
+  return this.tok.type === tt.eof || this.tok.type === tt.braceR ||
+    lineBreak.test(this.input.slice(this.last.end, this.tok.start));
+};
+
+lp.semicolon = function() {
+  return this.eat(tt.semi);
+};
+
+lp.expect = function(type) {
+  if (this.eat(type)) return true;
+  for (var i = 1; i <= 2; i++) {
+    if (this.lookAhead(i).type == type) {
+      for (var j = 0; j < i; j++) this.next();
+      return true;
+    }
+  }
+};
+
+lp.pushCx = function() {
+  this.context.push(this.curIndent);
+};
+lp.popCx = function() {
+  this.curIndent = this.context.pop();
+};
+
+lp.lineEnd = function(pos) {
+  while (pos < this.input.length && !isNewLine(this.input.charCodeAt(pos))) ++pos;
+  return pos;
+};
+
+lp.indentationAfter = function(pos) {
+  for (var count = 0;; ++pos) {
+    var ch = this.input.charCodeAt(pos);
+    if (ch === 32) ++count;
+    else if (ch === 9) count += this.options.tabSize;
+    else return count;
+  }
+};
+
+lp.closes = function(closeTok, indent, line, blockHeuristic) {
+  if (this.tok.type === closeTok || this.tok.type === tt.eof) return true;
+  return line != this.curLineStart && this.curIndent < indent && this.tokenStartsLine() &&
+    (!blockHeuristic || this.nextLineStart >= this.input.length ||
+     this.indentationAfter(this.nextLineStart) < indent);
+};
+
+lp.tokenStartsLine = function() {
+  for (var p = this.tok.start - 1; p >= this.curLineStart; --p) {
+    var ch = this.input.charCodeAt(p);
+    if (ch !== 9 && ch !== 32) return false;
+  }
+  return true;
+};
diff --git a/src/loose/state.js b/src/loose/state.js
new file mode 100644
index 0000000000..3854da2261
--- /dev/null
+++ b/src/loose/state.js
@@ -0,0 +1,17 @@
+import {tokenizer, SourceLocation, tokTypes as tt} from ".."
+
+export function LooseParser(input, options) {
+  this.toks = tokenizer(input, options)
+  this.options = this.toks.options;
+  this.input = this.toks.input;
+  this.tok = this.last = {type: tt.eof, start: 0, end: 0};
+  if (this.options.locations) {
+    var here = this.toks.curPosition();
+    this.tok.loc = new SourceLocation(this.toks, here, here);
+  }
+  this.ahead = []; // Tokens ahead
+  this.context = []; // Indentation contexted
+  this.curIndent = 0;
+  this.curLineStart = 0;
+  this.nextLineStart = this.lineEnd(this.curLineStart) + 1;
+}
diff --git a/src/loose/statement.js b/src/loose/statement.js
new file mode 100644
index 0000000000..ad7257da21
--- /dev/null
+++ b/src/loose/statement.js
@@ -0,0 +1,311 @@
+import {LooseParser} from "./state"
+import {isDummy} from "./parseutil"
+import {getLineInfo, tokTypes as tt} from ".."
+
+const lp = LooseParser.prototype
+
+lp.parseTopLevel = function() {
+  var node = this.startNodeAt(this.options.locations ? [0, acorn.getLineInfo(this.input, 0)] : 0);
+  node.body = [];
+  while (this.tok.type !== tt.eof) node.body.push(this.parseStatement());
+  this.last = this.tok;
+  if (this.options.ecmaVersion >= 6) {
+    node.sourceType = this.options.sourceType;
+  }
+  return this.finishNode(node, "Program");
+};
+
+lp.parseStatement = function() {
+  var starttype = this.tok.type, node = this.startNode();
+
+  switch (starttype) {
+  case tt._break: case tt._continue:
+    this.next();
+    var isBreak = starttype === tt._break;
+    if (this.semicolon() || this.canInsertSemicolon()) {
+      node.label = null;
+    } else {
+      node.label = this.tok.type === tt.name ? this.parseIdent() : null;
+      this.semicolon();
+    }
+    return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+
+  case tt._debugger:
+    this.next();
+    this.semicolon();
+    return this.finishNode(node, "DebuggerStatement");
+
+  case tt._do:
+    this.next();
+    node.body = this.parseStatement();
+    node.test = this.eat(tt._while) ? this.parseParenExpression() : this.dummyIdent();
+    this.semicolon();
+    return this.finishNode(node, "DoWhileStatement");
+
+  case tt._for:
+    this.next();
+    this.pushCx();
+    this.expect(tt.parenL);
+    if (this.tok.type === tt.semi) return this.parseFor(node, null);
+    if (this.tok.type === tt._var || this.tok.type === tt._let || this.tok.type === tt._const) {
+      var init = this.parseVar(true);
+      if (init.declarations.length === 1 && (this.tok.type === tt._in || this.isContextual("of"))) {
+        return this.parseForIn(node, init);
+      }
+      return this.parseFor(node, init);
+    }
+    var init = this.parseExpression(true);
+    if (this.tok.type === tt._in || this.isContextual("of"))
+      return this.parseForIn(node, this.toAssignable(init));
+    return this.parseFor(node, init);
+
+  case tt._function:
+    this.next();
+    return this.parseFunction(node, true);
+
+  case tt._if:
+    this.next();
+    node.test = this.parseParenExpression();
+    node.consequent = this.parseStatement();
+    node.alternate = this.eat(tt._else) ? this.parseStatement() : null;
+    return this.finishNode(node, "IfStatement");
+
+  case tt._return:
+    this.next();
+    if (this.eat(tt.semi) || this.canInsertSemicolon()) node.argument = null;
+    else { node.argument = this.parseExpression(); this.semicolon(); }
+    return this.finishNode(node, "ReturnStatement");
+
+  case tt._switch:
+    var blockIndent = this.curIndent, line = this.curLineStart;
+    this.next();
+    node.discriminant = this.parseParenExpression();
+    node.cases = [];
+    this.pushCx();
+    this.expect(tt.braceL);
+
+    for (var cur; !this.closes(tt.braceR, blockIndent, line, true);) {
+      if (this.tok.type === tt._case || this.tok.type === tt._default) {
+        var isCase = this.tok.type === tt._case;
+        if (cur) this.finishNode(cur, "SwitchCase");
+        node.cases.push(cur = this.startNode());
+        cur.consequent = [];
+        this.next();
+        if (isCase) cur.test = this.parseExpression();
+        else cur.test = null;
+        this.expect(tt.colon);
+      } else {
+        if (!cur) {
+          node.cases.push(cur = this.startNode());
+          cur.consequent = [];
+          cur.test = null;
+        }
+        cur.consequent.push(this.parseStatement());
+      }
+    }
+    if (cur) this.finishNode(cur, "SwitchCase");
+    this.popCx();
+    this.eat(tt.braceR);
+    return this.finishNode(node, "SwitchStatement");
+
+  case tt._throw:
+    this.next();
+    node.argument = this.parseExpression();
+    this.semicolon();
+    return this.finishNode(node, "ThrowStatement");
+
+  case tt._try:
+    this.next();
+    node.block = this.parseBlock();
+    node.handler = null;
+    if (this.tok.type === tt._catch) {
+      var clause = this.startNode();
+      this.next();
+      this.expect(tt.parenL);
+      clause.param = this.toAssignable(this.parseExprAtom());
+      this.expect(tt.parenR);
+      clause.guard = null;
+      clause.body = this.parseBlock();
+      node.handler = this.finishNode(clause, "CatchClause");
+    }
+    node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;
+    if (!node.handler && !node.finalizer) return node.block;
+    return this.finishNode(node, "TryStatement");
+
+  case tt._var:
+  case tt._let:
+  case tt._const:
+    return this.parseVar();
+
+  case tt._while:
+    this.next();
+    node.test = this.parseParenExpression();
+    node.body = this.parseStatement();
+    return this.finishNode(node, "WhileStatement");
+
+  case tt._with:
+    this.next();
+    node.object = this.parseParenExpression();
+    node.body = this.parseStatement();
+    return this.finishNode(node, "WithStatement");
+
+  case tt.braceL:
+    return this.parseBlock();
+
+  case tt.semi:
+    this.next();
+    return this.finishNode(node, "EmptyStatement");
+
+  case tt._class:
+    return this.parseClass(true);
+
+  case tt._import:
+    return this.parseImport();
+
+  case tt._export:
+    return this.parseExport();
+
+  default:
+    var expr = this.parseExpression();
+    if (isDummy(expr)) {
+      this.next();
+      if (this.tok.type === tt.eof) return this.finishNode(node, "EmptyStatement");
+      return this.parseStatement();
+    } else if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon)) {
+      node.body = this.parseStatement();
+      node.label = expr;
+      return this.finishNode(node, "LabeledStatement");
+    } else {
+      node.expression = expr;
+      this.semicolon();
+      return this.finishNode(node, "ExpressionStatement");
+    }
+  }
+};
+
+lp.parseBlock = function() {
+  var node = this.startNode();
+  this.pushCx();
+  this.expect(tt.braceL);
+  var blockIndent = this.curIndent, line = this.curLineStart;
+  node.body = [];
+  while (!this.closes(tt.braceR, blockIndent, line, true))
+    node.body.push(this.parseStatement());
+  this.popCx();
+  this.eat(tt.braceR);
+  return this.finishNode(node, "BlockStatement");
+};
+
+lp.parseFor = function(node, init) {
+  node.init = init;
+  node.test = node.update = null;
+  if (this.eat(tt.semi) && this.tok.type !== tt.semi) node.test = this.parseExpression();
+  if (this.eat(tt.semi) && this.tok.type !== tt.parenR) node.update = this.parseExpression();
+  this.popCx();
+  this.expect(tt.parenR);
+  node.body = this.parseStatement();
+  return this.finishNode(node, "ForStatement");
+};
+
+lp.parseForIn = function(node, init) {
+  var type = this.tok.type === tt._in ? "ForInStatement" : "ForOfStatement";
+  this.next();
+  node.left = init;
+  node.right = this.parseExpression();
+  this.popCx();
+  this.expect(tt.parenR);
+  node.body = this.parseStatement();
+  return this.finishNode(node, type);
+};
+
+lp.parseVar = function(noIn) {
+  var node = this.startNode();
+  node.kind = this.tok.type.keyword;
+  this.next();
+  node.declarations = [];
+  do {
+    var decl = this.startNode();
+    decl.id = this.options.ecmaVersion >= 6 ? this.toAssignable(this.parseExprAtom()) : this.parseIdent();
+    decl.init = this.eat(tt.eq) ? this.parseMaybeAssign(noIn) : null;
+    node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
+  } while (this.eat(tt.comma));
+  if (!node.declarations.length) {
+    var decl = this.startNode();
+    decl.id = this.dummyIdent();
+    node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
+  }
+  if (!noIn) this.semicolon();
+  return this.finishNode(node, "VariableDeclaration");
+};
+
+lp.parseClass = function(isStatement) {
+  var node = this.startNode();
+  this.next();
+  if (this.tok.type === tt.name) node.id = this.parseIdent();
+  else if (isStatement) node.id = this.dummyIdent();
+  else node.id = null;
+  node.superClass = this.eat(tt._extends) ? this.parseExpression() : null;
+  node.body = this.startNode();
+  node.body.body = [];
+  this.pushCx();
+  var indent = this.curIndent + 1, line = this.curLineStart;
+  this.eat(tt.braceL);
+  if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart; }
+  while (!this.closes(tt.braceR, indent, line)) {
+    if (this.semicolon()) continue;
+    var method = this.startNode(), isGenerator, start;
+    if (this.options.ecmaVersion >= 6) {
+      method['static'] = false;
+      isGenerator = this.eat(tt.star);
+    }
+    this.parsePropertyName(method);
+    if (isDummy(method.key)) { if (isDummy(this.parseMaybeAssign())) this.next(); this.eat(tt.comma); continue; }
+    if (method.key.type === "Identifier" && !method.computed && method.key.name === "static" &&
+        (this.tok.type != tt.parenL && this.tok.type != tt.braceL)) {
+      method['static'] = true;
+      isGenerator = this.eat(tt.star);
+      this.parsePropertyName(method);
+    } else {
+      method['static'] = false;
+    }
+    if (this.options.ecmaVersion >= 5 && method.key.type === "Identifier" &&
+        !method.computed && (method.key.name === "get" || method.key.name === "set") &&
+        this.tok.type !== tt.parenL && this.tok.type !== tt.braceL) {
+      method.kind = method.key.name;
+      this.parsePropertyName(method);
+      method.value = this.parseMethod(false);
+    } else {
+      if (!method.computed && !method['static'] && !isGenerator && (
+        method.key.type === "Identifier" && method.key.name === "constructor" ||
+          method.key.type === "Literal" && method.key.value === "constructor")) {
+        method.kind = "constructor";
+      } else {
+        method.kind =  "method";
+      }
+      method.value = this.parseMethod(isGenerator);
+    }
+    node.body.body.push(this.finishNode(method, "MethodDefinition"));
+  }
+  this.popCx();
+  if (!this.eat(tt.braceR)) {
+    // If there is no closing brace, make the node span to the start
+    // of the next token (this is useful for Tern)
+    this.last.end = this.tok.start;
+    if (this.options.locations) this.last.loc.end = this.tok.loc.start;
+  }
+  this.semicolon();
+  this.finishNode(node.body, "ClassBody");
+  return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
+};
+
+lp.parseFunction = function(node, isStatement) {
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 6) {
+    node.generator = this.eat(tt.star);
+  }
+  if (this.tok.type === tt.name) node.id = this.parseIdent();
+  else if (isStatement) node.id = this.dummyIdent();
+  node.params = this.parseFunctionParams();
+  node.body = this.parseBlock();
+  return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+};
diff --git a/src/loose/tokenize.js b/src/loose/tokenize.js
new file mode 100644
index 0000000000..ba3d14a8df
--- /dev/null
+++ b/src/loose/tokenize.js
@@ -0,0 +1,108 @@
+import {tokTypes as tt, Token, isNewLine, SourceLocation, getLineInfo, lineBreakG} from ".."
+import {LooseParser} from "./state"
+
+const lp = LooseParser.prototype
+
+function isSpace(ch) {
+  return (ch < 14 && ch > 8) || ch === 32 || ch === 160 || isNewLine(ch)
+}
+
+lp.next = function() {
+  this.last = this.tok;
+  if (this.ahead.length)
+    this.tok = this.ahead.shift();
+  else
+    this.tok = this.readToken();
+
+  if (this.tok.start >= this.nextLineStart) {
+    while (this.tok.start >= this.nextLineStart) {
+      this.curLineStart = this.nextLineStart;
+      this.nextLineStart = this.lineEnd(this.curLineStart) + 1;
+    }
+    this.curIndent = this.indentationAfter(this.curLineStart);
+  }
+};
+
+lp.readToken = function() {
+  for (;;) {
+    try {
+      this.toks.next();
+      if (this.toks.type === tt.dot &&
+          this.input.substr(this.toks.end, 1) === "." &&
+          this.options.ecmaVersion >= 6) {
+        this.toks.end++;
+        this.toks.type = tt.ellipsis;
+      }
+      return new Token(this.toks);
+    } catch(e) {
+      if (!(e instanceof SyntaxError)) throw e;
+
+      // Try to skip some text, based on the error message, and then continue
+      var msg = e.message, pos = e.raisedAt, replace = true;
+      if (/unterminated/i.test(msg)) {
+        pos = this.lineEnd(e.pos + 1);
+        if (/string/.test(msg)) {
+          replace = {start: e.pos, end: pos, type: tt.string, value: this.input.slice(e.pos + 1, pos)};
+        } else if (/regular expr/i.test(msg)) {
+          var re = this.input.slice(e.pos, pos);
+          try { re = new RegExp(re); } catch(e) {}
+          replace = {start: e.pos, end: pos, type: tt.regexp, value: re};
+        } else if (/template/.test(msg)) {
+          replace = {start: e.pos, end: pos,
+                     type: tt.template,
+                     value: this.input.slice(e.pos, pos)};
+        } else {
+          replace = false;
+        }
+      } else if (/invalid (unicode|regexp|number)|expecting unicode|octal literal|is reserved|directly after number/i.test(msg)) {
+        while (pos < this.input.length && !isSpace(this.input.charCodeAt(pos))) ++pos;
+      } else if (/character escape|expected hexadecimal/i.test(msg)) {
+        while (pos < this.input.length) {
+          var ch = this.input.charCodeAt(pos++);
+          if (ch === 34 || ch === 39 || isNewLine(ch)) break;
+        }
+      } else if (/unexpected character/i.test(msg)) {
+        pos++;
+        replace = false;
+      } else if (/regular expression/i.test(msg)) {
+        replace = true;
+      } else {
+        throw e;
+      }
+      this.resetTo(pos);
+      if (replace === true) replace = {start: pos, end: pos, type: tt.name, value: "✖"};
+      if (replace) {
+        if (this.options.locations)
+          replace.loc = new SourceLocation(
+            this.toks,
+            getLineInfo(this.input, replace.start),
+            getLineInfo(this.input, replace.end));
+        return replace;
+      }
+    }
+  }
+};
+
+lp.resetTo = function(pos) {
+  this.toks.pos = pos;
+  var ch = this.input.charAt(pos - 1);
+  this.toks.exprAllowed = !ch || /[\[\{\(,;:?\/*=+\-~!|&%^<>]/.test(ch) ||
+    /[enwfd]/.test(ch) &&
+    /\b(keywords|case|else|return|throw|new|in|(instance|type)of|delete|void)$/.test(this.input.slice(pos - 10, pos));
+
+  if (this.options.locations) {
+    this.toks.curLine = 1;
+    this.toks.lineStart = lineBreakG.lastIndex = 0;
+    var match;
+    while ((match = lineBreakG.exec(this.input)) && match.index < pos) {
+      ++this.toks.curLine;
+      this.toks.lineStart = match.index + match[0].length;
+    }
+  }
+};
+
+lp.lookAhead = function(n) {
+  while (n > this.ahead.length)
+    this.ahead.push(this.readToken());
+  return this.ahead[n - 1];
+};
diff --git a/tools/build-acorn.js b/tools/build-acorn.js
new file mode 100644
index 0000000000..01a3ef11c8
--- /dev/null
+++ b/tools/build-acorn.js
@@ -0,0 +1,40 @@
+var fs = require("fs"), path = require("path")
+var stream = require("stream")
+
+var browserify = require("browserify")
+var babelify = require("babelify")
+
+process.chdir(path.resolve(__dirname, ".."))
+
+browserify({standalone: "acorn"})
+  .transform(babelify)
+  .require("./src/index.js", {entry: true})
+  .bundle()
+  .on("error", function (err) { console.log("Error: " + err.message) })
+  .pipe(fs.createWriteStream("dist/acorn.js"))
+
+function acornShim(file) {
+  var tr = new stream.Transform
+  if (file == path.resolve(__dirname, "../src/index.js")) {
+    var sent = false
+    tr._transform = function(chunk, _, callback) {
+      if (!sent) {
+        sent = true
+        callback(null, "module.exports = typeof window != 'undefined' ? window.acorn : require(('suppress', './acorn'))")
+      } else {
+        callback()
+      }
+    }
+  } else {
+    tr._transform = function(chunk, _, callback) { callback(null, chunk) }
+  }
+  return tr
+}
+
+browserify()
+  .transform(acornShim)
+  .transform(babelify)
+  .require("./src/loose/index.js", {entry: true})
+  .bundle()
+  .on("error", function (err) { console.log("Error: " + err.message) })
+  .pipe(fs.createWriteStream("dist/acorn_loose.js"))

From 6dd254d9994de3740a1deb86af2fa88ae103bc02 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 16:36:24 +0100
Subject: [PATCH 28/43] Tie everything together in the new build system

---
 .gitignore                                  |    2 +-
 acorn.js                                    | 2888 -------------------
 acorn_loose.js                              | 1196 --------
 {tools => bin}/build-acorn.js               |   10 +-
 {tools => bin}/generate-identifier-regex.js |    0
 bin/prepublish.sh                           |    2 +
 bin/without_eval                            |   65 +-
 package.json                                |   58 +-
 src/loose/statement.js                      |    2 +-
 src/walk/index.js                           |  291 ++
 test/index.html                             |    4 +-
 test/run.js                                 |   10 +-
 util/walk.js                                |  359 ---
 13 files changed, 385 insertions(+), 4502 deletions(-)
 delete mode 100644 acorn.js
 delete mode 100644 acorn_loose.js
 rename {tools => bin}/build-acorn.js (79%)
 rename {tools => bin}/generate-identifier-regex.js (100%)
 create mode 100755 bin/prepublish.sh
 create mode 100644 src/walk/index.js
 delete mode 100644 util/walk.js

diff --git a/.gitignore b/.gitignore
index 66cc69a8cd..32dc891e92 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,4 @@
 /node_modules
 /.tern-port
-/acorn_csp.js
 /local
+/dist
diff --git a/acorn.js b/acorn.js
deleted file mode 100644
index 122c8729e9..0000000000
--- a/acorn.js
+++ /dev/null
@@ -1,2888 +0,0 @@
-// 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.
-//
-// Git repositories for Acorn are available at
-//
-//     http://marijnhaverbeke.nl/git/acorn
-//     https://github.com/marijnh/acorn.git
-//
-// Please use the [github bug tracker][ghbt] to report issues.
-//
-// [ghbt]: https://github.com/marijnh/acorn/issues
-//
-// This file defines the main parser interface. The library also comes
-// with a [error-tolerant parser][dammit] and an
-// [abstract syntax tree walker][walk], defined in other files.
-//
-// [dammit]: acorn_loose.js
-// [walk]: util/walk.js
-
-(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.12.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][api].
-  //
-  // [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
-
-  exports.parse = function(input, options) {
-    var p = new Parser(options, input);
-    var startPos = p.options.locations ? [p.pos, p.curPosition()] : p.pos;
-    p.nextToken();
-    return p.parseTopLevel(p.options.program || p.startNodeAt(startPos));
-  };
-
-  // 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,
-    // Source type ("script" or "module") for different semantics
-    sourceType: "script",
-    // `onInsertedSemicolon` can be a callback that will be called
-    // when a semicolon is automatically inserted. It will be passed
-    // th position of the comma as an offset, and if `locations` is
-    // enabled, it is given the location as a `{line, column}` object
-    // as second argument.
-    onInsertedSemicolon: null,
-    // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
-    // trailing commas.
-    onTrailingComma: null,
-    // By default, reserved words are not enforced. Disable
-    // `allowReserved` to enforce them. When this option has the
-    // value "never", reserved words and keywords can also not be
-    // used as property names.
-    allowReserved: true,
-    // When enabled, a return at the top level is not considered an
-    // error.
-    allowReturnOutsideFunction: false,
-    // When enabled, import/export statements are not constrained to
-    // appearing at the top of the program.
-    allowImportExportEverywhere: false,
-    // When enabled, hashbang directive in the beginning of file
-    // is allowed and treated as a line comment.
-    allowHashBang: 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] `range` property holding a `[start,
-    // end]` array with the same numbers, set the `ranges` option to
-    // `true`.
-    //
-    // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
-    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,
-    // When enabled, parenthesized expressions are represented by
-    // (non-standard) ParenthesizedExpression nodes
-    preserveParens: false,
-    plugins: {}
-  };
-
-  exports.plugins = {};
-
-  // 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(input, pos, options) {
-    var p = new Parser(options, input, pos);
-    p.nextToken();
-    return p.parseExpression();
-  };
-
-  // 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 new Position(line, offset - cur);
-  };
-
-  // Object type used to represent tokens. Note that normally, tokens
-  // simply exist as properties on the parser object. This is only
-  // used for the onToken callback and the external tokenizer.
-
-  var Token = exports.Token = function(p) {
-    this.type = p.type;
-    this.value = p.value;
-    this.start = p.start;
-    this.end = p.end;
-    if (p.options.locations)
-      this.loc = new SourceLocation(p, p.startLoc, p.endLoc);
-    if (p.options.ranges)
-      this.range = [p.start, p.end];
-  };
-
-  // 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.
-
-  exports.tokenizer = function(input, options) {
-    return new Parser(options, input);
-  };
-
-  // Interpret and default an options object
-
-  function parseOptions(opts) {
-    var options = {};
-    for (var opt in defaultOptions)
-      options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt];
-
-    if (isArray(options.onToken)) {
-      var tokens = options.onToken;
-      options.onToken = function (token) { tokens.push(token); };
-    }
-    if (isArray(options.onComment))
-      options.onComment = pushComment(options, options.onComment);
-
-    return options;
-  }
-
-  function pushComment(options, array) {
-    return 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(this, startLoc, endLoc);
-      if (options.ranges)
-        comment.range = [start, end];
-      array.push(comment);
-    };
-  }
-
-  // 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.
-
-  // 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 TokenType = exports.TokenType = function(label, conf) {
-    if (!conf) conf = {};
-    this.label = label;
-    this.keyword = conf.keyword;
-    this.beforeExpr = !!conf.beforeExpr;
-    this.startsExpr = !!conf.startsExpr;
-    this.isLoop = !!conf.isLoop;
-    this.isAssign = !!conf.isAssign;
-    this.prefix = !!conf.prefix;
-    this.postfix = !!conf.postfix;
-    this.binop = conf.binop || null;
-    this.updateContext = null;
-  };
-
-  function binop(name, prec) {
-    return new TokenType(name, {beforeExpr: true, binop: prec});
-  }
-  var beforeExpr = {beforeExpr: true}, startsExpr = {startsExpr: true};
-
-  var tt = exports.tokTypes = {
-    num: new TokenType("num", startsExpr),
-    regexp: new TokenType("regexp", startsExpr),
-    string: new TokenType("string", startsExpr),
-    name: new TokenType("name", startsExpr),
-    eof: new TokenType("eof"),
-
-    // Punctuation token types.
-    bracketL: new TokenType("[", {beforeExpr: true, startsExpr: true}),
-    bracketR: new TokenType("]"),
-    braceL: new TokenType("{", {beforeExpr: true, startsExpr: true}),
-    braceR: new TokenType("}"),
-    parenL: new TokenType("(", {beforeExpr: true, startsExpr: true}),
-    parenR: new TokenType(")"),
-    comma: new TokenType(",", beforeExpr),
-    semi: new TokenType(";", beforeExpr),
-    colon: new TokenType(":", beforeExpr),
-    dot: new TokenType("."),
-    question: new TokenType("?", beforeExpr),
-    arrow: new TokenType("=>", beforeExpr),
-    template: new TokenType("template"),
-    ellipsis: new TokenType("...", beforeExpr),
-    backQuote: new TokenType("`", startsExpr),
-    dollarBraceL: new TokenType("${", {beforeExpr: true, startsExpr: 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.
-    //
-    // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as
-    // binary operators with a very low precedence, that should result
-    // in AssignmentExpression nodes.
-
-    eq: new TokenType("=", {beforeExpr: true, isAssign: true}),
-    assign: new TokenType("_=", {beforeExpr: true, isAssign: true}),
-    incDec: new TokenType("++/--", {prefix: true, postfix: true, startsExpr: true}),
-    prefix: new TokenType("prefix", {beforeExpr: true, prefix: true, startsExpr: true}),
-    logicalOR: binop("||", 1),
-    logicalAND: binop("&&", 2),
-    bitwiseOR: binop("|", 3),
-    bitwiseXOR: binop("^", 4),
-    bitwiseAND: binop("&", 5),
-    equality: binop("==/!=", 6),
-    relational: binop("</>", 7),
-    bitShift: binop("<</>>", 8),
-    plusMin: new TokenType("+/-", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),
-    modulo: binop("%", 10),
-    star: binop("*", 10),
-    slash: binop("/", 10)
-  };
-
-  // Map keyword names to token types.
-
-  var keywordTypes = {};
-
-  // Succinct definitions of keyword token types
-  function kw(name, options) {
-    if (!options) options = {};
-    options.keyword = name;
-    keywordTypes[name] = tt["_" + name] = new TokenType(name, options);
-  };
-
-  kw("break"),
-  kw("case", beforeExpr),
-  kw("catch"),
-  kw("continue"),
-  kw("debugger"),
-  kw("default"),
-  kw("do", {isLoop: true}),
-  kw("else", beforeExpr),
-  kw("finally"),
-  kw("for", {isLoop: true}),
-  kw("function"),
-  kw("if"),
-  kw("return", beforeExpr),
-  kw("switch");
-  kw("throw", beforeExpr),
-  kw("try"),
-  kw("var"),
-  kw("let");
-  kw("const");
-  kw("while", {isLoop: true});
-  kw("with");
-  kw("new", {beforeExpr: true, startsExpr: true});
-  kw("this", startsExpr);
-  kw("super", startsExpr);
-  kw("class");
-  kw("extends", beforeExpr);
-  kw("export");
-  kw("import");
-  kw("yield", {beforeExpr: true, startsExpr: true});
-  kw("null", startsExpr);
-  kw("true", startsExpr);
-  kw("false", startsExpr);
-  kw("in", {beforeExpr: true, binop: 7});
-  kw("instanceof", {beforeExpr: true, binop: 7});
-  kw("typeof", {beforeExpr: true, prefix: true, startsExpr: true});
-  kw("void", {beforeExpr: true, prefix: true, startsExpr: true});
-  kw("delete", {beforeExpr: true, prefix: true, startsExpr: true});
-
-  // 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");
-
-  // ECMAScript 6 reserved words.
-
-  var isReservedWord6 = makePredicate("enum await");
-
-  // 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 super");
-
-  // ## 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\u2118-\u211d\u2124\u2126\u2128\u212a-\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\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\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 = "\u200c\u200d\xb7\u0300-\u036f\u0387\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\u1369-\u1371\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-\u19da\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\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 + "]");
-  nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
-
-  // These are a run-length and offset encoded representation of the
-  // >0xffff code points that are a valid part of identifiers. The
-  // offset starts at 0x10000, and each pair of numbers represents an
-  // offset to the next range, and then a size of the range. They were
-  // generated by tools/generate-identifier-regex.js
-  var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,17,26,6,37,11,29,3,35,5,7,2,4,43,157,99,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,98,21,11,25,71,55,7,1,65,0,16,3,2,2,2,26,45,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,955,52,76,44,33,24,27,35,42,34,4,0,13,47,15,3,22,0,38,17,2,24,133,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,32,4,287,47,21,1,2,0,185,46,82,47,21,0,60,42,502,63,32,0,449,56,1288,920,104,110,2962,1070,13266,568,8,30,114,29,19,47,17,3,32,20,6,18,881,68,12,0,67,12,16481,1,3071,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,1340,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,16355,541];
-  var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,1306,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,52,0,13,2,49,13,16,9,83,11,168,11,6,9,8,2,57,0,2,6,3,1,3,2,10,0,11,1,3,6,4,4,316,19,13,9,214,6,3,8,112,16,16,9,82,12,9,9,535,9,20855,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,4305,6,792618,239];
-
-  // This has a complexity linear to the value of the code. The
-  // assumption is that looking up astral identifier characters is
-  // rare.
-  function isInAstralSet(code, set) {
-    var pos = 0x10000;
-    for (var i = 0; i < set.length; i += 2) {
-      pos += set[i];
-      if (pos > code) return false;
-      pos += set[i + 1];
-      if (pos >= code) return true;
-    }
-  }
-
-  // Whether a single character denotes a newline.
-
-  var newline = exports.newline = /[\n\r\u2028\u2029]/;
-
-  var isNewLine = exports.isNewLine = function(code) {
-    return code === 10 || code === 13 || code === 0x2028 || code == 0x2029;
-  };
-
-  // Matches a whole line break (where CRLF is considered a single
-  // line break). Used to count lines.
-
-  var lineBreak = exports.lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
-
-  // Test whether a given character code starts an identifier.
-
-  var isIdentifierStart = exports.isIdentifierStart = function(code, astral) {
-    if (code < 65) return code === 36;
-    if (code < 91) return true;
-    if (code < 97) return code === 95;
-    if (code < 123) return true;
-    if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-    if (astral === false) return false;
-    return isInAstralSet(code, astralIdentifierStartCodes);
-  };
-
-  // Test whether a given character is part of an identifier.
-
-  var isIdentifierChar = exports.isIdentifierChar = function(code, astral) {
-    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;
-    if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-    if (astral === false) return false;
-    return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
-  };
-
-  // ## Tokenizer
-
-  // These are used when `options.locations` is on, for the
-  // `startLoc` and `endLoc` properties.
-
-  function Position(line, col) {
-    this.line = line;
-    this.column = col;
-  }
-
-  Position.prototype.offset = function(n) {
-    return new Position(this.line, this.column + n);
-  };
-
-  // ## 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][opp] 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.
-  //
-  // [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser
-
-  var Parser = exports.Parser = function(options, input, startPos) {
-    this.options = parseOptions(options);
-    this.loadPlugins(this.options.plugins);
-    this.sourceFile = this.options.sourceFile || null;
-    this.isKeyword = this.options.ecmaVersion >= 6 ? isEcma6Keyword : isEcma5AndLessKeyword;
-    this.isReservedWord = this.options.ecmaVersion === 3 ? isReservedWord3 : this.options.ecmaVersion === 5 ? isReservedWord5 : isReservedWord6;
-    this.input = String(input);
-
-    // Set up token state
-
-    // The current position of the tokenizer in the input.
-    if (startPos) {
-      this.pos = startPos;
-      this.lineStart = Math.max(0, this.input.lastIndexOf("\n", startPos));
-      this.curLine = this.input.slice(0, this.lineStart).split(newline).length;
-    } else {
-      this.pos = this.lineStart = 0;
-      this.curLine = 1;
-    }
-
-    // Properties of the current token:
-    // Its type
-    this.type = tt.eof;
-    // For tokens that include more information than their type, the value
-    this.value = null;
-    // Its start and end offset
-    this.start = this.end = this.pos;
-    // And, if locations are used, the {line, column} object
-    // corresponding to those offsets
-    this.startLoc = this.endLoc = null;
-
-    // Position information for the previous token
-    this.lastTokEndLoc = this.lastTokStartLoc = null;
-    this.lastTokStart = this.lastTokEnd = this.pos;
-
-    // The context stack is used to superficially track syntactic
-    // context to predict whether a regular expression is allowed in a
-    // given position.
-    this.context = [tc.b_stat];
-    this.exprAllowed = true;
-
-    // Figure out if it's a module code.
-    this.strict = this.inModule = this.options.sourceType === "module";
-
-    // Flags to track whether we are in a function, a generator.
-    this.inFunction = this.inGenerator = false;
-    // Labels in scope.
-    this.labels = [];
-
-    // If enabled, skip leading hashbang line.
-    if (this.pos === 0 && this.options.allowHashBang && this.input.slice(0, 2) === '#!')
-      this.skipLineComment(2);
-  };
-
-  // Shorthand because we are going to be adding a _lot_ of methods to
-  // this.
-  var pp = Parser.prototype;
-
-  pp.extend = function(name, f) {
-    this[name] = f(this[name]);
-  };
-
-  pp.loadPlugins = function(plugins) {
-    for (var name in plugins) {
-      var plugin = exports.plugins[name];
-      if (!plugin) throw new Error("Plugin '" + name + "' not found");
-      plugin(this, plugins[name]);
-    }
-  };
-
-  // Move to the next token
-
-  pp.next = function() {
-    if (this.options.onToken)
-      this.options.onToken(new Token(this));
-
-    this.lastTokEnd = this.end;
-    this.lastTokStart = this.start;
-    this.lastTokEndLoc = this.endLoc;
-    this.lastTokStartLoc = this.startLoc;
-    this.nextToken();
-  };
-
-  pp.getToken = function() {
-    this.next();
-    return new Token(this);
-  };
-
-  // If we're in an ES6 environment, make parsers iterable
-  if (typeof Symbol !== "undefined")
-    pp[Symbol.iterator] = function () {
-      var self = this;
-      return {next: function () {
-        var token = self.getToken();
-        return {
-          done: token.type === tt.eof,
-          value: token
-        };
-      }};
-    };
-
-  // Toggle strict mode. Re-reads the next number or string to please
-  // pedantic tests (`"use strict"; 010;` should fail).
-
-  pp.setStrict = function(strict) {
-    this.strict = strict;
-    if (this.type !== tt.num && this.type !== tt.string) return;
-    this.pos = this.start;
-    if (this.options.locations) {
-      while (this.pos < this.lineStart) {
-        this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1;
-        --this.curLine;
-      }
-    }
-    this.nextToken();
-  };
-
-  pp.curContext = function() {
-    return this.context[this.context.length - 1];
-  };
-
-  // Read a single token, updating the parser object's token-related
-  // properties.
-
-  pp.nextToken = function() {
-    var curContext = this.curContext();
-    if (!curContext || !curContext.preserveSpace) this.skipSpace();
-
-    this.start = this.pos;
-    if (this.options.locations) this.startLoc = this.curPosition();
-    if (this.pos >= this.input.length) return this.finishToken(tt.eof);
-
-    if (curContext === tc.q_tmpl) return this.readTmplToken();
-
-    this.readToken(this.fullCharCodeAtPos());
-  };
-
-  pp.readToken = function(code) {
-    // Identifier or keyword. '\uXXXX' sequences are allowed in
-    // identifiers, so '\' also dispatches to that.
-    if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */)
-      return this.readWord();
-
-    return this.getTokenFromCode(code);
-  };
-
-  pp.fullCharCodeAtPos = function() {
-    var code = this.input.charCodeAt(this.pos);
-    if (code <= 0xd7ff || code >= 0xe000) return code;
-    var next = this.input.charCodeAt(this.pos + 1);
-    return (code << 10) + next - 0x35fdc00;
-  };
-
-  pp.skipBlockComment = function() {
-    var startLoc = this.options.onComment && this.options.locations && this.curPosition();
-    var start = this.pos, end = this.input.indexOf("*/", this.pos += 2);
-    if (end === -1) this.raise(this.pos - 2, "Unterminated comment");
-    this.pos = end + 2;
-    if (this.options.locations) {
-      lineBreak.lastIndex = start;
-      var match;
-      while ((match = lineBreak.exec(this.input)) && match.index < this.pos) {
-        ++this.curLine;
-        this.lineStart = match.index + match[0].length;
-      }
-    }
-    if (this.options.onComment)
-      this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,
-                             startLoc, this.options.locations && this.curPosition());
-  };
-
-  pp.skipLineComment = function(startSkip) {
-    var start = this.pos;
-    var startLoc = this.options.onComment && this.options.locations && this.curPosition();
-    var ch = this.input.charCodeAt(this.pos+=startSkip);
-    while (this.pos < this.input.length && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
-      ++this.pos;
-      ch = this.input.charCodeAt(this.pos);
-    }
-    if (this.options.onComment)
-      this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,
-                             startLoc, this.options.locations && this.curPosition());
-  };
-
-  // Called at the start of the parse and after every token. Skips
-  // whitespace and comments, and.
-
-  pp.skipSpace = function() {
-    while (this.pos < this.input.length) {
-      var ch = this.input.charCodeAt(this.pos);
-      if (ch === 32) { // ' '
-        ++this.pos;
-      } else if (ch === 13) {
-        ++this.pos;
-        var next = this.input.charCodeAt(this.pos);
-        if (next === 10) {
-          ++this.pos;
-        }
-        if (this.options.locations) {
-          ++this.curLine;
-          this.lineStart = this.pos;
-        }
-      } else if (ch === 10 || ch === 8232 || ch === 8233) {
-        ++this.pos;
-        if (this.options.locations) {
-          ++this.curLine;
-          this.lineStart = this.pos;
-        }
-      } else if (ch > 8 && ch < 14) {
-        ++this.pos;
-      } else if (ch === 47) { // '/'
-        var next = this.input.charCodeAt(this.pos + 1);
-        if (next === 42) { // '*'
-          this.skipBlockComment();
-        } else if (next === 47) { // '/'
-          this.skipLineComment(2);
-        } else break;
-      } else if (ch === 160) { // '\xa0'
-        ++this.pos;
-      } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
-        ++this.pos;
-      } else {
-        break;
-      }
-    }
-  };
-
-  pp.curPosition = function() {
-    return new Position(this.curLine, this.pos - this.lineStart);
-  };
-
-  // The algorithm used to determine whether a regexp can appear at a
-  // given point in the program is loosely based on sweet.js' approach.
-  // See https://github.com/mozilla/sweet.js/wiki/design
-
-  var TokContext = exports.TokContext = function(token, isExpr, preserveSpace) {
-    this.token = token;
-    this.isExpr = isExpr;
-    this.preserveSpace = preserveSpace;
-  };
-
-  var tc = exports.tokContexts = {
-    b_stat: new TokContext("{", false),
-    b_expr: new TokContext("{", true),
-    b_tmpl: new TokContext("${", true),
-    p_stat: new TokContext("(", false),
-    p_expr: new TokContext("(", true),
-    q_tmpl: new TokContext("`", true, true),
-    f_expr: new TokContext("function", true)
-  };
-
-  pp.braceIsBlock = function(prevType) {
-    var parent;
-    if (prevType === tt.colon && (parent = this.curContext()).token == "{")
-      return !parent.isExpr;
-    if (prevType === tt._return)
-      return newline.test(this.input.slice(this.lastTokEnd, this.start));
-    if (prevType === tt._else || prevType === tt.semi || prevType === tt.eof)
-      return true;
-    if (prevType == tt.braceL)
-      return this.curContext() === tc.b_stat;
-    return !this.exprAllowed;
-  };
-
-  // Called at the end of every token. Sets `end`, `val`, and
-  // maintains `context` and `exprAllowed`, and skips the space after
-  // the token, so that the next one's `start` will point at the
-  // right position.
-
-  pp.finishToken = function(type, val) {
-    this.end = this.pos;
-    if (this.options.locations) this.endLoc = this.curPosition();
-    var prevType = this.type;
-    this.type = type;
-    this.value = val;
-
-    this.updateContext(prevType);
-  };
-
-  pp.updateContext = function(prevType) {
-    var update, type = this.type;
-    if (type.keyword && prevType == tt.dot)
-      this.exprAllowed = false;
-    else if (update = type.updateContext)
-      update.call(this, prevType);
-    else
-      this.exprAllowed = type.beforeExpr;
-  };
-
-  // Token-specific context update code
-
-  tt.parenR.updateContext = tt.braceR.updateContext = function() {
-    var out = this.context.pop();
-    if (out === tc.b_stat && this.curContext() === tc.f_expr) {
-      this.context.pop();
-      this.exprAllowed = false;
-    } else if (out === tc.b_tmpl) {
-      this.exprAllowed = true;
-    } else {
-      this.exprAllowed = !(out && out.isExpr);
-    }
-  };
-
-  tt.braceL.updateContext = function(prevType) {
-    this.context.push(this.braceIsBlock(prevType) ? tc.b_stat : tc.b_expr);
-    this.exprAllowed = true;
-  };
-
-  tt.dollarBraceL.updateContext = function() {
-    this.context.push(tc.b_tmpl);
-    this.exprAllowed = true;
-  };
-
-  tt.parenL.updateContext = function(prevType) {
-    var statementParens = prevType === tt._if || prevType === tt._for || prevType === tt._with || prevType === tt._while;
-    this.context.push(statementParens ? tc.p_stat : tc.p_expr);
-    this.exprAllowed = true;
-  };
-
-  tt.incDec.updateContext = function() {
-    // tokExprAllowed stays unchanged
-  };
-
-  tt._function.updateContext = function() {
-    if (this.curContext() !== tc.b_stat)
-      this.context.push(tc.f_expr);
-    this.exprAllowed = false;
-  };
-
-  tt.backQuote.updateContext = function() {
-    if (this.curContext() === tc.q_tmpl)
-      this.context.pop();
-    else
-      this.context.push(tc.q_tmpl);
-    this.exprAllowed = false;
-  };
-
-  // ### 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.
-  //
-  pp.readToken_dot = function() {
-    var next = this.input.charCodeAt(this.pos + 1);
-    if (next >= 48 && next <= 57) return this.readNumber(true);
-    var next2 = this.input.charCodeAt(this.pos + 2);
-    if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
-      this.pos += 3;
-      return this.finishToken(tt.ellipsis);
-    } else {
-      ++this.pos;
-      return this.finishToken(tt.dot);
-    }
-  };
-
-  pp.readToken_slash = function() { // '/'
-    var next = this.input.charCodeAt(this.pos + 1);
-    if (this.exprAllowed) {++this.pos; return this.readRegexp();}
-    if (next === 61) return this.finishOp(tt.assign, 2);
-    return this.finishOp(tt.slash, 1);
-  };
-
-  pp.readToken_mult_modulo = function(code) { // '%*'
-    var next = this.input.charCodeAt(this.pos + 1);
-    if (next === 61) return this.finishOp(tt.assign, 2);
-    return this.finishOp(code === 42 ? tt.star : tt.modulo, 1);
-  };
-
-  pp.readToken_pipe_amp = function(code) { // '|&'
-    var next = this.input.charCodeAt(this.pos + 1);
-    if (next === code) return this.finishOp(code === 124 ? tt.logicalOR : tt.logicalAND, 2);
-    if (next === 61) return this.finishOp(tt.assign, 2);
-    return this.finishOp(code === 124 ? tt.bitwiseOR : tt.bitwiseAND, 1);
-  };
-
-  pp.readToken_caret = function() { // '^'
-    var next = this.input.charCodeAt(this.pos + 1);
-    if (next === 61) return this.finishOp(tt.assign, 2);
-    return this.finishOp(tt.bitwiseXOR, 1);
-  };
-
-  pp.readToken_plus_min = function(code) { // '+-'
-    var next = this.input.charCodeAt(this.pos + 1);
-    if (next === code) {
-      if (next == 45 && this.input.charCodeAt(this.pos + 2) == 62 &&
-          newline.test(this.input.slice(this.lastTokEnd, this.pos))) {
-        // A `-->` line comment
-        this.skipLineComment(3);
-        this.skipSpace();
-        return this.nextToken();
-      }
-      return this.finishOp(tt.incDec, 2);
-    }
-    if (next === 61) return this.finishOp(tt.assign, 2);
-    return this.finishOp(tt.plusMin, 1);
-  };
-
-  pp.readToken_lt_gt = function(code) { // '<>'
-    var next = this.input.charCodeAt(this.pos + 1);
-    var size = 1;
-    if (next === code) {
-      size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
-      if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1);
-      return this.finishOp(tt.bitShift, size);
-    }
-    if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 &&
-        this.input.charCodeAt(this.pos + 3) == 45) {
-      if (this.inModule) unexpected();
-      // `<!--`, an XML-style comment that should be interpreted as a line comment
-      this.skipLineComment(4);
-      this.skipSpace();
-      return this.nextToken();
-    }
-    if (next === 61)
-      size = this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2;
-    return this.finishOp(tt.relational, size);
-  };
-
-  pp.readToken_eq_excl = function(code) { // '=!'
-    var next = this.input.charCodeAt(this.pos + 1);
-    if (next === 61) return this.finishOp(tt.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2);
-    if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'
-      this.pos += 2;
-      return this.finishToken(tt.arrow);
-    }
-    return this.finishOp(code === 61 ? tt.eq : tt.prefix, 1);
-  };
-
-  pp.getTokenFromCode = function(code) {
-    switch (code) {
-    // The interpretation of a dot depends on whether it is followed
-    // by a digit or another two dots.
-    case 46: // '.'
-      return this.readToken_dot();
-
-    // Punctuation tokens.
-    case 40: ++this.pos; return this.finishToken(tt.parenL);
-    case 41: ++this.pos; return this.finishToken(tt.parenR);
-    case 59: ++this.pos; return this.finishToken(tt.semi);
-    case 44: ++this.pos; return this.finishToken(tt.comma);
-    case 91: ++this.pos; return this.finishToken(tt.bracketL);
-    case 93: ++this.pos; return this.finishToken(tt.bracketR);
-    case 123: ++this.pos; return this.finishToken(tt.braceL);
-    case 125: ++this.pos; return this.finishToken(tt.braceR);
-    case 58: ++this.pos; return this.finishToken(tt.colon);
-    case 63: ++this.pos; return this.finishToken(tt.question);
-
-    case 96: // '`'
-      if (this.options.ecmaVersion < 6) break;
-      ++this.pos;
-      return this.finishToken(tt.backQuote);
-
-    case 48: // '0'
-      var next = this.input.charCodeAt(this.pos + 1);
-      if (next === 120 || next === 88) return this.readRadixNumber(16); // '0x', '0X' - hex number
-      if (this.options.ecmaVersion >= 6) {
-        if (next === 111 || next === 79) return this.readRadixNumber(8); // '0o', '0O' - octal number
-        if (next === 98 || next === 66) return this.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 this.readNumber(false);
-
-    // Quotes produce strings.
-    case 34: case 39: // '"', "'"
-      return this.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 this.readToken_slash();
-
-    case 37: case 42: // '%*'
-      return this.readToken_mult_modulo(code);
-
-    case 124: case 38: // '|&'
-      return this.readToken_pipe_amp(code);
-
-    case 94: // '^'
-      return this.readToken_caret();
-
-    case 43: case 45: // '+-'
-      return this.readToken_plus_min(code);
-
-    case 60: case 62: // '<>'
-      return this.readToken_lt_gt(code);
-
-    case 61: case 33: // '=!'
-      return this.readToken_eq_excl(code);
-
-    case 126: // '~'
-      return this.finishOp(tt.prefix, 1);
-    }
-
-    this.raise(this.pos, "Unexpected character '" + codePointToString(code) + "'");
-  };
-
-  pp.finishOp = function(type, size) {
-    var str = this.input.slice(this.pos, this.pos + size);
-    this.pos += size;
-    return this.finishToken(type, str);
-  };
-
-  var regexpUnicodeSupport = false;
-  try { new RegExp("\uffff", "u"); regexpUnicodeSupport = true; }
-  catch(e) {}
-
-  // Parse a regular expression. Some context-awareness is necessary,
-  // since a '/' inside a '[]' set does not end the expression.
-
-  pp.readRegexp = function() {
-    var content = "", escaped, inClass, start = this.pos;
-    for (;;) {
-      if (this.pos >= this.input.length) this.raise(start, "Unterminated regular expression");
-      var ch = this.input.charAt(this.pos);
-      if (newline.test(ch)) this.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;
-      ++this.pos;
-    }
-    var content = this.input.slice(start, this.pos);
-    ++this.pos;
-    // Need to use `readWord1` because '\uXXXX' sequences are allowed
-    // here (don't ask).
-    var mods = this.readWord1();
-    var tmp = content;
-    if (mods) {
-      var validFlags = /^[gmsiy]*$/;
-      if (this.options.ecmaVersion >= 6) validFlags = /^[gmsiyu]*$/;
-      if (!validFlags.test(mods)) this.raise(start, "Invalid regular expression flag");
-      if (mods.indexOf('u') >= 0 && !regexpUnicodeSupport) {
-        // Replace each astral symbol and every Unicode escape sequence that
-        // possibly represents an astral symbol or a paired surrogate with a
-        // single ASCII symbol to avoid throwing on regular expressions that
-        // are only valid in combination with the `/u` flag.
-        // Note: replacing with the ASCII symbol `x` might cause false
-        // negatives in unlikely scenarios. For example, `[\u{61}-b]` is a
-        // perfectly valid pattern that is equivalent to `[a-b]`, but it would
-        // be replaced by `[x-b]` which throws an error.
-        tmp = tmp.replace(/\\u([a-fA-F0-9]{4})|\\u\{([0-9a-fA-F]+)\}|[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x")
-      }
-    }
-    // Detect invalid regular expressions.
-    try {
-      new RegExp(tmp);
-    } catch (e) {
-      if (e instanceof SyntaxError) this.raise(start, "Error parsing regular expression: " + e.message);
-      this.raise(e);
-    }
-    // Get a regular expression object for this pattern-flag pair, or `null` in
-    // case the current environment doesn't support the flags it uses.
-    try {
-      var value = new RegExp(content, mods);
-    } catch (err) {
-      value = null;
-    }
-    return this.finishToken(tt.regexp, {pattern: content, flags: mods, value: 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.
-
-  pp.readInt = function(radix, len) {
-    var start = this.pos, total = 0;
-    for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-      var code = this.input.charCodeAt(this.pos), 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;
-      ++this.pos;
-      total = total * radix + val;
-    }
-    if (this.pos === start || len != null && this.pos - start !== len) return null;
-
-    return total;
-  };
-
-  pp.readRadixNumber = function(radix) {
-    this.pos += 2; // 0x
-    var val = this.readInt(radix);
-    if (val == null) this.raise(this.start + 2, "Expected number in radix " + radix);
-    if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
-    return this.finishToken(tt.num, val);
-  };
-
-  // Read an integer, octal integer, or floating-point number.
-
-  pp.readNumber = function(startsWithDot) {
-    var start = this.pos, isFloat = false, octal = this.input.charCodeAt(this.pos) === 48;
-    if (!startsWithDot && this.readInt(10) === null) this.raise(start, "Invalid number");
-    if (this.input.charCodeAt(this.pos) === 46) {
-      ++this.pos;
-      this.readInt(10);
-      isFloat = true;
-    }
-    var next = this.input.charCodeAt(this.pos);
-    if (next === 69 || next === 101) { // 'eE'
-      next = this.input.charCodeAt(++this.pos);
-      if (next === 43 || next === 45) ++this.pos; // '+-'
-      if (this.readInt(10) === null) this.raise(start, "Invalid number");
-      isFloat = true;
-    }
-    if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
-
-    var str = this.input.slice(start, this.pos), val;
-    if (isFloat) val = parseFloat(str);
-    else if (!octal || str.length === 1) val = parseInt(str, 10);
-    else if (/[89]/.test(str) || this.strict) this.raise(start, "Invalid number");
-    else val = parseInt(str, 8);
-    return this.finishToken(tt.num, val);
-  };
-
-  // Read a string value, interpreting backslash-escapes.
-
-  pp.readCodePoint = function() {
-    var ch = this.input.charCodeAt(this.pos), code;
-
-    if (ch === 123) {
-      if (this.options.ecmaVersion < 6) this.unexpected();
-      ++this.pos;
-      code = this.readHexChar(this.input.indexOf('}', this.pos) - this.pos);
-      ++this.pos;
-      if (code > 0x10FFFF) this.unexpected();
-    } else {
-      code = this.readHexChar(4);
-    }
-    return code;
-  };
-
-  function codePointToString(code) {
-    // UTF-16 Decoding
-    if (code <= 0xFFFF) return String.fromCharCode(code);
-    return String.fromCharCode(((code - 0x10000) >> 10) + 0xD800,
-                               ((code - 0x10000) & 1023) + 0xDC00);
-  }
-
-  pp.readString = function(quote) {
-    var out = "", chunkStart = ++this.pos;
-    for (;;) {
-      if (this.pos >= this.input.length) this.raise(this.start, "Unterminated string constant");
-      var ch = this.input.charCodeAt(this.pos);
-      if (ch === quote) break;
-      if (ch === 92) { // '\'
-        out += this.input.slice(chunkStart, this.pos);
-        out += this.readEscapedChar();
-        chunkStart = this.pos;
-      } else {
-        if (isNewLine(ch)) this.raise(this.start, "Unterminated string constant");
-        ++this.pos;
-      }
-    }
-    out += this.input.slice(chunkStart, this.pos++);
-    return this.finishToken(tt.string, out);
-  };
-
-  // Reads template string tokens.
-
-  pp.readTmplToken = function() {
-    var out = "", chunkStart = this.pos;
-    for (;;) {
-      if (this.pos >= this.input.length) this.raise(this.start, "Unterminated template");
-      var ch = this.input.charCodeAt(this.pos);
-      if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) { // '`', '${'
-        if (this.pos === this.start && this.type === tt.template) {
-          if (ch === 36) {
-            this.pos += 2;
-            return this.finishToken(tt.dollarBraceL);
-          } else {
-            ++this.pos;
-            return this.finishToken(tt.backQuote);
-          }
-        }
-        out += this.input.slice(chunkStart, this.pos);
-        return this.finishToken(tt.template, out);
-      }
-      if (ch === 92) { // '\'
-        out += this.input.slice(chunkStart, this.pos);
-        out += this.readEscapedChar();
-        chunkStart = this.pos;
-      } else if (isNewLine(ch)) {
-        out += this.input.slice(chunkStart, this.pos);
-        ++this.pos;
-        if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
-          ++this.pos;
-          out += "\n";
-        } else {
-          out += String.fromCharCode(ch);
-        }
-        if (this.options.locations) {
-          ++this.curLine;
-          this.lineStart = this.pos;
-        }
-        chunkStart = this.pos;
-      } else {
-        ++this.pos;
-      }
-    }
-  };
-
-  // Used to read escaped characters
-
-  pp.readEscapedChar = function() {
-    var ch = this.input.charCodeAt(++this.pos);
-    var octal = /^[0-7]+/.exec(this.input.slice(this.pos, this.pos + 3));
-    if (octal) octal = octal[0];
-    while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
-    if (octal === "0") octal = null;
-    ++this.pos;
-    if (octal) {
-      if (this.strict) this.raise(this.pos - 2, "Octal literal in strict mode");
-      this.pos += 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(this.readHexChar(2)); // 'x'
-        case 117: return codePointToString(this.readCodePoint()); // '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 (this.input.charCodeAt(this.pos) === 10) ++this.pos; // '\r\n'
-        case 10: // ' \n'
-          if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }
-          return "";
-        default: return String.fromCharCode(ch);
-      }
-    }
-  };
-
-  // Used to read character escape sequences ('\x', '\u', '\U').
-
-  pp.readHexChar = function(len) {
-    var n = this.readInt(16, len);
-    if (n === null) this.raise(this.start, "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.
-  //
-  // Incrementally adds only escaped chars, adding other chunks as-is
-  // as a micro-optimization.
-
-  pp.readWord1 = function() {
-    containsEsc = false;
-    var word = "", first = true, chunkStart = this.pos;
-    var astral = this.options.ecmaVersion >= 6;
-    while (this.pos < this.input.length) {
-      var ch = this.fullCharCodeAtPos();
-      if (isIdentifierChar(ch, astral)) {
-        this.pos += ch <= 0xffff ? 1 : 2;
-      } else if (ch === 92) { // "\"
-        containsEsc = true;
-        word += this.input.slice(chunkStart, this.pos);
-        var escStart = this.pos;
-        if (this.input.charCodeAt(++this.pos) != 117) // "u"
-          this.raise(this.pos, "Expecting Unicode escape sequence \\uXXXX");
-        ++this.pos;
-        var esc = this.readCodePoint();
-        if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))
-          this.raise(escStart, "Invalid Unicode escape");
-        word += codePointToString(esc);
-        chunkStart = this.pos;
-      } else {
-        break;
-      }
-      first = false;
-    }
-    return word + this.input.slice(chunkStart, this.pos);
-  };
-
-  // Read an identifier or keyword token. Will check for reserved
-  // words when necessary.
-
-  pp.readWord = function() {
-    var word = this.readWord1();
-    var type = tt.name;
-    if ((this.options.ecmaVersion >= 6 || !containsEsc) && this.isKeyword(word))
-      type = keywordTypes[word];
-    return this.finishToken(type, word);
-  };
-
-  // 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.
-
-  pp.raise = function(pos, message) {
-    var loc = getLineInfo(this.input, pos);
-    message += " (" + loc.line + ":" + loc.column + ")";
-    var err = new SyntaxError(message);
-    err.pos = pos; err.loc = loc; err.raisedAt = this.pos;
-    throw err;
-  };
-
-  pp.currentPos = function() {
-    return this.options.locations ? [this.start, this.startLoc] : this.start;
-  };
-
-  // ### Parser utilities
-
-  // Start an AST node, attaching a start offset.
-
-  var Node = exports.Node = function() {};
-
-  var SourceLocation = exports.SourceLocation = function(p, start, end) {
-    this.start = start;
-    this.end = end;
-    if (p.sourceFile !== null) this.source = p.sourceFile;
-  };
-
-  pp.startNode = function() {
-    var node = new Node;
-    node.start = this.start;
-    if (this.options.locations)
-      node.loc = new SourceLocation(this, this.startLoc);
-    if (this.options.directSourceFile)
-      node.sourceFile = this.options.directSourceFile;
-    if (this.options.ranges)
-      node.range = [this.start, 0];
-    return node;
-  };
-
-  pp.startNodeAt = function(pos) {
-    var node = new Node, start = pos;
-    if (this.options.locations) {
-      node.loc = new SourceLocation(this, start[1]);
-      start = pos[0];
-    }
-    node.start = start;
-    if (this.options.directSourceFile)
-      node.sourceFile = this.options.directSourceFile;
-    if (this.options.ranges)
-      node.range = [start, 0];
-    return node;
-  };
-
-  // Finish an AST node, adding `type` and `end` properties.
-
-  pp.finishNode = function(node, type) {
-    node.type = type;
-    node.end = this.lastTokEnd;
-    if (this.options.locations)
-      node.loc.end = this.lastTokEndLoc;
-    if (this.options.ranges)
-      node.range[1] = this.lastTokEnd;
-    return node;
-  };
-
-  // Finish node at given position
-
-  pp.finishNodeAt = function(node, type, pos) {
-    if (this.options.locations) { node.loc.end = pos[1]; pos = pos[0]; }
-    node.type = type;
-    node.end = pos;
-    if (this.options.ranges)
-      node.range[1] = pos;
-    return node;
-  };
-
-  // Test whether a statement node is the string literal `"use strict"`.
-
-  pp.isUseStrict = function(stmt) {
-    return this.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.
-
-  pp.eat = function(type) {
-    if (this.type === type) {
-      this.next();
-      return true;
-    } else {
-      return false;
-    }
-  };
-
-  // Tests whether parsed token is a contextual keyword.
-
-  pp.isContextual = function(name) {
-    return this.type === tt.name && this.value === name;
-  };
-
-  // Consumes contextual keyword if possible.
-
-  pp.eatContextual = function(name) {
-    return this.value === name && this.eat(tt.name);
-  };
-
-  // Asserts that following token is given contextual keyword.
-
-  pp.expectContextual = function(name) {
-    if (!this.eatContextual(name)) this.unexpected();
-  };
-
-  // Test whether a semicolon can be inserted at the current position.
-
-  pp.canInsertSemicolon = function() {
-    return this.type === tt.eof ||
-      this.type === tt.braceR ||
-      newline.test(this.input.slice(this.lastTokEnd, this.start));
-  };
-
-  pp.insertSemicolon = function() {
-    if (this.canInsertSemicolon()) {
-      if (this.options.onInsertedSemicolon)
-        this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc)
-      return true;
-    }
-  };
-
-  // Consume a semicolon, or, failing that, see if we are allowed to
-  // pretend that there is a semicolon at this position.
-
-  pp.semicolon = function() {
-    if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected();
-  };
-
-  pp.afterTrailingComma = function(tokType) {
-    if (this.type == tokType) {
-      if (this.options.onTrailingComma)
-        this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc);
-      this.next();
-      return true;
-    }
-  };
-
-  // Expect a token of a given type. If found, consume it, otherwise,
-  // raise an unexpected token error.
-
-  pp.expect = function(type) {
-    this.eat(type) || this.unexpected();
-  };
-
-  // Raise an unexpected token error.
-
-  pp.unexpected = function(pos) {
-    this.raise(pos != null ? pos : this.start, "Unexpected token");
-  };
-
-  function isArray(obj) {
-    return Object.prototype.toString.call(obj) === "[object Array]";
-  }
-
-  // Checks if an object has a property.
-
-  function has(obj, propName) {
-    return Object.prototype.hasOwnProperty.call(obj, propName);
-  }
-
-  // Convert existing expression atom to assignable pattern
-  // if possible.
-
-  pp.toAssignable = function(node, isBinding) {
-    if (this.options.ecmaVersion >= 6 && node) {
-      switch (node.type) {
-        case "Identifier":
-        case "ObjectPattern":
-        case "ArrayPattern":
-        case "AssignmentPattern":
-          break;
-
-        case "ObjectExpression":
-          node.type = "ObjectPattern";
-          for (var i = 0; i < node.properties.length; i++) {
-            var prop = node.properties[i];
-            if (prop.kind !== "init") this.raise(prop.key.start, "Object pattern can't contain getter or setter");
-            this.toAssignable(prop.value, isBinding);
-          }
-          break;
-
-        case "ArrayExpression":
-          node.type = "ArrayPattern";
-          this.toAssignableList(node.elements, isBinding);
-          break;
-
-        case "AssignmentExpression":
-          if (node.operator === "=") {
-            node.type = "AssignmentPattern";
-          } else {
-            this.raise(node.left.end, "Only '=' operator can be used for specifying default value.");
-          }
-          break;
-
-        case "MemberExpression":
-          if (!isBinding) break;
-
-        default:
-          this.raise(node.start, "Assigning to rvalue");
-      }
-    }
-    return node;
-  };
-
-  // Convert list of expression atoms to binding list.
-
-  pp.toAssignableList = function(exprList, isBinding) {
-    var end = exprList.length;
-    if (end) {
-      var last = exprList[end - 1];
-      if (last && last.type == "RestElement") {
-        --end;
-      } else if (last && last.type == "SpreadElement") {
-        last.type = "RestElement";
-        var arg = last.argument;
-        this.toAssignable(arg, isBinding);
-        if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern")
-          this.unexpected(arg.start);
-        --end;
-      }
-    }
-    for (var i = 0; i < end; i++) {
-      var elt = exprList[i];
-      if (elt) this.toAssignable(elt, isBinding);
-    }
-    return exprList;
-  };
-
-  // Parses spread element.
-
-  pp.parseSpread = function(refShorthandDefaultPos) {
-    var node = this.startNode();
-    this.next();
-    node.argument = this.parseMaybeAssign(refShorthandDefaultPos);
-    return this.finishNode(node, "SpreadElement");
-  };
-
-  pp.parseRest = function() {
-    var node = this.startNode();
-    this.next();
-    node.argument = this.type === tt.name || this.type === tt.bracketL ? this.parseBindingAtom() : this.unexpected();
-    return this.finishNode(node, "RestElement");
-  };
-
-  // Parses lvalue (assignable) atom.
-
-  pp.parseBindingAtom = function() {
-    if (this.options.ecmaVersion < 6) return this.parseIdent();
-    switch (this.type) {
-      case tt.name:
-        return this.parseIdent();
-
-      case tt.bracketL:
-        var node = this.startNode();
-        this.next();
-        node.elements = this.parseBindingList(tt.bracketR, true, true);
-        return this.finishNode(node, "ArrayPattern");
-
-      case tt.braceL:
-        return this.parseObj(true);
-
-      default:
-        this.unexpected();
-    }
-  };
-
-  pp.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
-    var elts = [], first = true;
-    while (!this.eat(close)) {
-      if (first) first = false;
-      else this.expect(tt.comma);
-      if (allowEmpty && this.type === tt.comma) {
-        elts.push(null);
-      } else if (allowTrailingComma && this.afterTrailingComma(close)) {
-        break;
-      } else if (this.type === tt.ellipsis) {
-        elts.push(this.parseRest());
-        this.expect(close);
-        break;
-      } else {
-        elts.push(this.parseMaybeDefault());
-      }
-    }
-    return elts;
-  };
-
-  // Parses assignment pattern around given atom if possible.
-
-  pp.parseMaybeDefault = function(startPos, left) {
-    startPos = startPos || this.currentPos();
-    left = left || this.parseBindingAtom();
-    if (!this.eat(tt.eq)) return left;
-    var node = this.startNodeAt(startPos);
-    node.operator = "=";
-    node.left = left;
-    node.right = this.parseMaybeAssign();
-    return this.finishNode(node, "AssignmentPattern");
-  };
-
-  // 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.
-
-  pp.checkPropClash = function(prop, propHash) {
-    if (this.options.ecmaVersion >= 6) 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 ((this.strict || isGetSet) && other[kind] || !(isGetSet ^ other.init))
-        this.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.
-
-  pp.checkLVal = function(expr, isBinding, checkClashes) {
-    switch (expr.type) {
-      case "Identifier":
-        if (this.strict && (isStrictBadIdWord(expr.name) || isStrictReservedWord(expr.name)))
-          this.raise(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode");
-        if (checkClashes) {
-          if (has(checkClashes, expr.name))
-            this.raise(expr.start, "Argument name clash in strict mode");
-          checkClashes[expr.name] = true;
-        }
-        break;
-
-      case "MemberExpression":
-        if (isBinding) this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " member expression");
-        break;
-
-      case "ObjectPattern":
-        for (var i = 0; i < expr.properties.length; i++)
-          this.checkLVal(expr.properties[i].value, isBinding, checkClashes);
-        break;
-
-      case "ArrayPattern":
-        for (var i = 0; i < expr.elements.length; i++) {
-          var elem = expr.elements[i];
-          if (elem) this.checkLVal(elem, isBinding, checkClashes);
-        }
-        break;
-
-      case "AssignmentPattern":
-        this.checkLVal(expr.left, isBinding, checkClashes);
-        break;
-
-      case "RestElement":
-        this.checkLVal(expr.argument, isBinding, checkClashes);
-        break;
-
-      default:
-        this.raise(expr.start, (isBinding ? "Binding" : "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.
-
-  pp.parseTopLevel = function(node) {
-    var first = true;
-    if (!node.body) node.body = [];
-    while (this.type !== tt.eof) {
-      var stmt = this.parseStatement(true, true);
-      node.body.push(stmt);
-      if (first && this.isUseStrict(stmt)) this.setStrict(true);
-      first = false;
-    }
-    this.next();
-    if (this.options.ecmaVersion >= 6) {
-      node.sourceType = this.options.sourceType;
-    }
-    return this.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.
-
-  pp.parseStatement = function(declaration, topLevel) {
-    var starttype = this.type, node = this.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 tt._break: case tt._continue: return this.parseBreakContinueStatement(node, starttype.keyword);
-    case tt._debugger: return this.parseDebuggerStatement(node);
-    case tt._do: return this.parseDoStatement(node);
-    case tt._for: return this.parseForStatement(node);
-    case tt._function:
-      if (!declaration && this.options.ecmaVersion >= 6) this.unexpected();
-      return this.parseFunctionStatement(node);
-    case tt._class:
-      if (!declaration) this.unexpected();
-      return this.parseClass(node, true);
-    case tt._if: return this.parseIfStatement(node);
-    case tt._return: return this.parseReturnStatement(node);
-    case tt._switch: return this.parseSwitchStatement(node);
-    case tt._throw: return this.parseThrowStatement(node);
-    case tt._try: return this.parseTryStatement(node);
-    case tt._let: case tt._const: if (!declaration) this.unexpected(); // NOTE: falls through to _var
-    case tt._var: return this.parseVarStatement(node, starttype);
-    case tt._while: return this.parseWhileStatement(node);
-    case tt._with: return this.parseWithStatement(node);
-    case tt.braceL: return this.parseBlock(); // no point creating a function for this
-    case tt.semi: return this.parseEmptyStatement(node);
-    case tt._export:
-    case tt._import:
-      if (!this.options.allowImportExportEverywhere) {
-        if (!topLevel)
-          this.raise(this.start, "'import' and 'export' may only appear at the top level");
-        if (!this.inModule)
-          this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
-      }
-      return starttype === tt._import ? this.parseImport(node) : this.parseExport(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 = this.value, expr = this.parseExpression();
-      if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon))
-        return this.parseLabeledStatement(node, maybeName, expr);
-      else return this.parseExpressionStatement(node, expr);
-    }
-  };
-
-  pp.parseBreakContinueStatement = function(node, keyword) {
-    var isBreak = keyword == "break";
-    this.next();
-    if (this.eat(tt.semi) || this.insertSemicolon()) node.label = null;
-    else if (this.type !== tt.name) this.unexpected();
-    else {
-      node.label = this.parseIdent();
-      this.semicolon();
-    }
-
-    // Verify that there is an actual destination to break or
-    // continue to.
-    for (var i = 0; i < this.labels.length; ++i) {
-      var lab = this.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 === this.labels.length) this.raise(node.start, "Unsyntactic " + keyword);
-    return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-  };
-
-  pp.parseDebuggerStatement = function(node) {
-    this.next();
-    this.semicolon();
-    return this.finishNode(node, "DebuggerStatement");
-  };
-
-  pp.parseDoStatement = function(node) {
-    this.next();
-    this.labels.push(loopLabel);
-    node.body = this.parseStatement(false);
-    this.labels.pop();
-    this.expect(tt._while);
-    node.test = this.parseParenExpression();
-    if (this.options.ecmaVersion >= 6)
-      this.eat(tt.semi);
-    else
-      this.semicolon();
-    return this.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.
-
-  pp.parseForStatement = function(node) {
-    this.next();
-    this.labels.push(loopLabel);
-    this.expect(tt.parenL);
-    if (this.type === tt.semi) return this.parseFor(node, null);
-    if (this.type === tt._var || this.type === tt._let || this.type === tt._const) {
-      var init = this.startNode(), varKind = this.type;
-      this.next();
-      this.parseVar(init, true, varKind);
-      this.finishNode(init, "VariableDeclaration");
-      if ((this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init.declarations.length === 1 &&
-          !(varKind !== tt._var && init.declarations[0].init))
-        return this.parseForIn(node, init);
-      return this.parseFor(node, init);
-    }
-    var refShorthandDefaultPos = {start: 0};
-    var init = this.parseExpression(true, refShorthandDefaultPos);
-    if (this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
-      this.toAssignable(init);
-      this.checkLVal(init);
-      return this.parseForIn(node, init);
-    } else if (refShorthandDefaultPos.start) {
-      this.unexpected(refShorthandDefaultPos.start);
-    }
-    return this.parseFor(node, init);
-  };
-
-  pp.parseFunctionStatement = function(node) {
-    this.next();
-    return this.parseFunction(node, true);
-  };
-
-  pp.parseIfStatement = function(node) {
-    this.next();
-    node.test = this.parseParenExpression();
-    node.consequent = this.parseStatement(false);
-    node.alternate = this.eat(tt._else) ? this.parseStatement(false) : null;
-    return this.finishNode(node, "IfStatement");
-  };
-
-  pp.parseReturnStatement = function(node) {
-    if (!this.inFunction && !this.options.allowReturnOutsideFunction)
-      this.raise(this.start, "'return' outside of function");
-    this.next();
-
-    // In `return` (and `break`/`continue`), the keywords with
-    // optional arguments, we eagerly look for a semicolon or the
-    // possibility to insert one.
-
-    if (this.eat(tt.semi) || this.insertSemicolon()) node.argument = null;
-    else { node.argument = this.parseExpression(); this.semicolon(); }
-    return this.finishNode(node, "ReturnStatement");
-  };
-
-  pp.parseSwitchStatement = function(node) {
-    this.next();
-    node.discriminant = this.parseParenExpression();
-    node.cases = [];
-    this.expect(tt.braceL);
-    this.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; this.type != tt.braceR;) {
-      if (this.type === tt._case || this.type === tt._default) {
-        var isCase = this.type === tt._case;
-        if (cur) this.finishNode(cur, "SwitchCase");
-        node.cases.push(cur = this.startNode());
-        cur.consequent = [];
-        this.next();
-        if (isCase) cur.test = this.parseExpression();
-        else {
-          if (sawDefault) this.raise(this.lastTokStart, "Multiple default clauses"); sawDefault = true;
-          cur.test = null;
-        }
-        this.expect(tt.colon);
-      } else {
-        if (!cur) this.unexpected();
-        cur.consequent.push(this.parseStatement(true));
-      }
-    }
-    if (cur) this.finishNode(cur, "SwitchCase");
-    this.next(); // Closing brace
-    this.labels.pop();
-    return this.finishNode(node, "SwitchStatement");
-  };
-
-  pp.parseThrowStatement = function(node) {
-    this.next();
-    if (newline.test(this.input.slice(this.lastTokEnd, this.start)))
-      this.raise(this.lastTokEnd, "Illegal newline after throw");
-    node.argument = this.parseExpression();
-    this.semicolon();
-    return this.finishNode(node, "ThrowStatement");
-  };
-
-  pp.parseTryStatement = function(node) {
-    this.next();
-    node.block = this.parseBlock();
-    node.handler = null;
-    if (this.type === tt._catch) {
-      var clause = this.startNode();
-      this.next();
-      this.expect(tt.parenL);
-      clause.param = this.parseBindingAtom();
-      this.checkLVal(clause.param, true);
-      this.expect(tt.parenR);
-      clause.guard = null;
-      clause.body = this.parseBlock();
-      node.handler = this.finishNode(clause, "CatchClause");
-    }
-    node.guardedHandlers = empty;
-    node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;
-    if (!node.handler && !node.finalizer)
-      this.raise(node.start, "Missing catch or finally clause");
-    return this.finishNode(node, "TryStatement");
-  };
-
-  pp.parseVarStatement = function(node, kind) {
-    this.next();
-    this.parseVar(node, false, kind);
-    this.semicolon();
-    return this.finishNode(node, "VariableDeclaration");
-  };
-
-  pp.parseWhileStatement = function(node) {
-    this.next();
-    node.test = this.parseParenExpression();
-    this.labels.push(loopLabel);
-    node.body = this.parseStatement(false);
-    this.labels.pop();
-    return this.finishNode(node, "WhileStatement");
-  };
-
-  pp.parseWithStatement = function(node) {
-    if (this.strict) this.raise(this.start, "'with' in strict mode");
-    this.next();
-    node.object = this.parseParenExpression();
-    node.body = this.parseStatement(false);
-    return this.finishNode(node, "WithStatement");
-  };
-
-  pp.parseEmptyStatement = function(node) {
-    this.next();
-    return this.finishNode(node, "EmptyStatement");
-  };
-
-  pp.parseLabeledStatement = function(node, maybeName, expr) {
-    for (var i = 0; i < this.labels.length; ++i)
-      if (this.labels[i].name === maybeName) this.raise(expr.start, "Label '" + maybeName + "' is already declared");
-    var kind = this.type.isLoop ? "loop" : this.type === tt._switch ? "switch" : null;
-    this.labels.push({name: maybeName, kind: kind});
-    node.body = this.parseStatement(true);
-    this.labels.pop();
-    node.label = expr;
-    return this.finishNode(node, "LabeledStatement");
-  };
-
-  pp.parseExpressionStatement = function(node, expr) {
-    node.expression = expr;
-    this.semicolon();
-    return this.finishNode(node, "ExpressionStatement");
-  };
-
-  // Used for constructs like `switch` and `if` that insist on
-  // parentheses around their expression.
-
-  pp.parseParenExpression = function() {
-    this.expect(tt.parenL);
-    var val = this.parseExpression();
-    this.expect(tt.parenR);
-    return val;
-  };
-
-  // Parse a semicolon-enclosed block of statements, handling `"use
-  // strict"` declarations when `allowStrict` is true (used for
-  // function bodies).
-
-  pp.parseBlock = function(allowStrict) {
-    var node = this.startNode(), first = true, oldStrict;
-    node.body = [];
-    this.expect(tt.braceL);
-    while (!this.eat(tt.braceR)) {
-      var stmt = this.parseStatement(true);
-      node.body.push(stmt);
-      if (first && allowStrict && this.isUseStrict(stmt)) {
-        oldStrict = this.strict;
-        this.setStrict(this.strict = true);
-      }
-      first = false;
-    }
-    if (oldStrict === false) this.setStrict(false);
-    return this.finishNode(node, "BlockStatement");
-  };
-
-  // Parse a regular `for` loop. The disambiguation code in
-  // `parseStatement` will already have parsed the init statement or
-  // expression.
-
-  pp.parseFor = function(node, init) {
-    node.init = init;
-    this.expect(tt.semi);
-    node.test = this.type === tt.semi ? null : this.parseExpression();
-    this.expect(tt.semi);
-    node.update = this.type === tt.parenR ? null : this.parseExpression();
-    this.expect(tt.parenR);
-    node.body = this.parseStatement(false);
-    this.labels.pop();
-    return this.finishNode(node, "ForStatement");
-  };
-
-  // Parse a `for`/`in` and `for`/`of` loop, which are almost
-  // same from parser's perspective.
-
-  pp.parseForIn = function(node, init) {
-    var type = this.type === tt._in ? "ForInStatement" : "ForOfStatement";
-    this.next();
-    node.left = init;
-    node.right = this.parseExpression();
-    this.expect(tt.parenR);
-    node.body = this.parseStatement(false);
-    this.labels.pop();
-    return this.finishNode(node, type);
-  };
-
-  // Parse a list of variable declarations.
-
-  pp.parseVar = function(node, noIn, kind) {
-    node.declarations = [];
-    node.kind = kind.keyword;
-    for (;;) {
-      var decl = this.startNode();
-      decl.id = this.parseBindingAtom();
-      this.checkLVal(decl.id, true);
-      if (this.eat(tt.eq)) {
-        decl.init = this.parseMaybeAssign(noIn);
-      } else if (kind === tt._const && !(this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
-        this.unexpected();
-      } else if (decl.id.type != "Identifier") {
-        this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value")
-      } else {
-        decl.init = null;
-      }
-      node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
-      if (!this.eat(tt.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 optional arguments are used to
-  // forbid the `in` operator (in for loops initalization expressions)
-  // and provide reference for storing '=' operator inside shorthand
-  // property assignment in contexts where both object expression
-  // and object pattern might appear (so it's possible to raise
-  // delayed syntax error at correct position).
-
-  pp.parseExpression = function(noIn, refShorthandDefaultPos) {
-    var start = this.currentPos();
-    var expr = this.parseMaybeAssign(noIn, refShorthandDefaultPos);
-    if (this.type === tt.comma) {
-      var node = this.startNodeAt(start);
-      node.expressions = [expr];
-      while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn, refShorthandDefaultPos));
-      return this.finishNode(node, "SequenceExpression");
-    }
-    return expr;
-  };
-
-  // Parse an assignment expression. This includes applications of
-  // operators like `+=`.
-
-  pp.parseMaybeAssign = function(noIn, refShorthandDefaultPos) {
-    if (this.type == tt._yield && this.inGenerator) return this.parseYield();
-
-    var failOnShorthandAssign;
-    if (!refShorthandDefaultPos) {
-      refShorthandDefaultPos = {start: 0};
-      failOnShorthandAssign = true;
-    } else {
-      failOnShorthandAssign = false;
-    }
-    var start = this.currentPos();
-    var left = this.parseMaybeConditional(noIn, refShorthandDefaultPos);
-    if (this.type.isAssign) {
-      var node = this.startNodeAt(start);
-      node.operator = this.value;
-      node.left = this.type === tt.eq ? this.toAssignable(left) : left;
-      refShorthandDefaultPos.start = 0; // reset because shorthand default was used correctly
-      this.checkLVal(left);
-      this.next();
-      node.right = this.parseMaybeAssign(noIn);
-      return this.finishNode(node, "AssignmentExpression");
-    } else if (failOnShorthandAssign && refShorthandDefaultPos.start) {
-      this.unexpected(refShorthandDefaultPos.start);
-    }
-    return left;
-  };
-
-  // Parse a ternary conditional (`?:`) operator.
-
-  pp.parseMaybeConditional = function(noIn, refShorthandDefaultPos) {
-    var start = this.currentPos();
-    var expr = this.parseExprOps(noIn, refShorthandDefaultPos);
-    if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-    if (this.eat(tt.question)) {
-      var node = this.startNodeAt(start);
-      node.test = expr;
-      node.consequent = this.parseMaybeAssign();
-      this.expect(tt.colon);
-      node.alternate = this.parseMaybeAssign(noIn);
-      return this.finishNode(node, "ConditionalExpression");
-    }
-    return expr;
-  };
-
-  // Start the precedence parser.
-
-  pp.parseExprOps = function(noIn, refShorthandDefaultPos) {
-    var start = this.currentPos();
-    var expr = this.parseMaybeUnary(refShorthandDefaultPos);
-    if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-    return this.parseExprOp(expr, start, -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.
-
-  pp.parseExprOp = function(left, leftStart, minPrec, noIn) {
-    var prec = this.type.binop;
-    if (prec != null && (!noIn || this.type !== tt._in)) {
-      if (prec > minPrec) {
-        var node = this.startNodeAt(leftStart);
-        node.left = left;
-        node.operator = this.value;
-        var op = this.type;
-        this.next();
-        var start = this.currentPos();
-        node.right = this.parseExprOp(this.parseMaybeUnary(), start, prec, noIn);
-        this.finishNode(node, (op === tt.logicalOR || op === tt.logicalAND) ? "LogicalExpression" : "BinaryExpression");
-        return this.parseExprOp(node, leftStart, minPrec, noIn);
-      }
-    }
-    return left;
-  };
-
-  // Parse unary operators, both prefix and postfix.
-
-  pp.parseMaybeUnary = function(refShorthandDefaultPos) {
-    if (this.type.prefix) {
-      var node = this.startNode(), update = this.type === tt.incDec;
-      node.operator = this.value;
-      node.prefix = true;
-      this.next();
-      node.argument = this.parseMaybeUnary();
-      if (refShorthandDefaultPos && refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
-      if (update) this.checkLVal(node.argument);
-      else if (this.strict && node.operator === "delete" &&
-               node.argument.type === "Identifier")
-        this.raise(node.start, "Deleting local variable in strict mode");
-      return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
-    }
-    var start = this.currentPos();
-    var expr = this.parseExprSubscripts(refShorthandDefaultPos);
-    if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-    while (this.type.postfix && !this.canInsertSemicolon()) {
-      var node = this.startNodeAt(start);
-      node.operator = this.value;
-      node.prefix = false;
-      node.argument = expr;
-      this.checkLVal(expr);
-      this.next();
-      expr = this.finishNode(node, "UpdateExpression");
-    }
-    return expr;
-  };
-
-  // Parse call, dot, and `[]`-subscript expressions.
-
-  pp.parseExprSubscripts = function(refShorthandDefaultPos) {
-    var start = this.currentPos();
-    var expr = this.parseExprAtom(refShorthandDefaultPos);
-    if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-    return this.parseSubscripts(expr, start);
-  };
-
-  pp.parseSubscripts = function(base, start, noCalls) {
-    if (this.eat(tt.dot)) {
-      var node = this.startNodeAt(start);
-      node.object = base;
-      node.property = this.parseIdent(true);
-      node.computed = false;
-      return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls);
-    } else if (this.eat(tt.bracketL)) {
-      var node = this.startNodeAt(start);
-      node.object = base;
-      node.property = this.parseExpression();
-      node.computed = true;
-      this.expect(tt.bracketR);
-      return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls);
-    } else if (!noCalls && this.eat(tt.parenL)) {
-      var node = this.startNodeAt(start);
-      node.callee = base;
-      node.arguments = this.parseExprList(tt.parenR, false);
-      return this.parseSubscripts(this.finishNode(node, "CallExpression"), start, noCalls);
-    } else if (this.type === tt.backQuote) {
-      var node = this.startNodeAt(start);
-      node.tag = base;
-      node.quasi = this.parseTemplate();
-      return this.parseSubscripts(this.finishNode(node, "TaggedTemplateExpression"), start, 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 `{}`.
-
-  pp.parseExprAtom = function(refShorthandDefaultPos) {
-    switch (this.type) {
-    case tt._this:
-    case tt._super:
-      var type = this.type === tt._this ? "ThisExpression" : "SuperExpression";
-      var node = this.startNode();
-      this.next();
-      return this.finishNode(node, type);
-
-    case tt._yield:
-      if (this.inGenerator) unexpected();
-
-    case tt.name:
-      var start = this.currentPos();
-      var id = this.parseIdent(this.type !== tt.name);
-      if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
-        return this.parseArrowExpression(this.startNodeAt(start), [id]);
-      }
-      return id;
-
-    case tt.regexp:
-      var value = this.value;
-      var node = this.parseLiteral(value.value);
-      node.regex = {pattern: value.pattern, flags: value.flags};
-      return node;
-
-    case tt.num: case tt.string:
-      return this.parseLiteral(this.value);
-
-    case tt._null: case tt._true: case tt._false:
-      var node = this.startNode();
-      node.value = this.type === tt._null ? null : this.type === tt._true;
-      node.raw = this.type.keyword;
-      this.next();
-      return this.finishNode(node, "Literal");
-
-    case tt.parenL:
-      return this.parseParenAndDistinguishExpression();
-
-    case tt.bracketL:
-      var node = this.startNode();
-      this.next();
-      // check whether this is array comprehension or regular array
-      if (this.options.ecmaVersion >= 7 && this.type === tt._for) {
-        return this.parseComprehension(node, false);
-      }
-      node.elements = this.parseExprList(tt.bracketR, true, true, refShorthandDefaultPos);
-      return this.finishNode(node, "ArrayExpression");
-
-    case tt.braceL:
-      return this.parseObj(false, refShorthandDefaultPos);
-
-    case tt._function:
-      var node = this.startNode();
-      this.next();
-      return this.parseFunction(node, false);
-
-    case tt._class:
-      return this.parseClass(this.startNode(), false);
-
-    case tt._new:
-      return this.parseNew();
-
-    case tt.backQuote:
-      return this.parseTemplate();
-
-    default:
-      this.unexpected();
-    }
-  };
-
-  pp.parseLiteral = function(value) {
-    var node = this.startNode();
-    node.value = value;
-    node.raw = this.input.slice(this.start, this.end);
-    this.next();
-    return this.finishNode(node, "Literal");
-  };
-
-  pp.parseParenAndDistinguishExpression = function() {
-    var start = this.currentPos(), val;
-    if (this.options.ecmaVersion >= 6) {
-      this.next();
-
-      if (this.options.ecmaVersion >= 7 && this.type === tt._for) {
-        return this.parseComprehension(this.startNodeAt(start), true);
-      }
-
-      var innerStart = this.currentPos(), exprList = [], first = true;
-      var refShorthandDefaultPos = {start: 0}, spreadStart, innerParenStart;
-      while (this.type !== tt.parenR) {
-        first ? first = false : this.expect(tt.comma);
-        if (this.type === tt.ellipsis) {
-          spreadStart = this.start;
-          exprList.push(this.parseRest());
-          break;
-        } else {
-          if (this.type === tt.parenL && !innerParenStart) {
-            innerParenStart = this.start;
-          }
-          exprList.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
-        }
-      }
-      var innerEnd = this.currentPos();
-      this.expect(tt.parenR);
-
-      if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
-        if (innerParenStart) this.unexpected(innerParenStart);
-        return this.parseArrowExpression(this.startNodeAt(start), exprList);
-      }
-
-      if (!exprList.length) this.unexpected(this.lastTokStart);
-      if (spreadStart) this.unexpected(spreadStart);
-      if (refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
-
-      if (exprList.length > 1) {
-        val = this.startNodeAt(innerStart);
-        val.expressions = exprList;
-        this.finishNodeAt(val, "SequenceExpression", innerEnd);
-      } else {
-        val = exprList[0];
-      }
-    } else {
-      val = this.parseParenExpression();
-    }
-
-    if (this.options.preserveParens) {
-      var par = this.startNodeAt(start);
-      par.expression = val;
-      return this.finishNode(par, "ParenthesizedExpression");
-    } else {
-      return val;
-    }
-  };
-
-  // 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
-
-  pp.parseNew = function() {
-    var node = this.startNode();
-    this.next();
-    var start = this.currentPos();
-    node.callee = this.parseSubscripts(this.parseExprAtom(), start, true);
-    if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false);
-    else node.arguments = empty;
-    return this.finishNode(node, "NewExpression");
-  };
-
-  // Parse template expression.
-
-  pp.parseTemplateElement = function() {
-    var elem = this.startNode();
-    elem.value = {
-      raw: this.input.slice(this.start, this.end),
-      cooked: this.value
-    };
-    this.next();
-    elem.tail = this.type === tt.backQuote;
-    return this.finishNode(elem, "TemplateElement");
-  };
-
-  pp.parseTemplate = function() {
-    var node = this.startNode();
-    this.next();
-    node.expressions = [];
-    var curElt = this.parseTemplateElement();
-    node.quasis = [curElt];
-    while (!curElt.tail) {
-      this.expect(tt.dollarBraceL);
-      node.expressions.push(this.parseExpression());
-      this.expect(tt.braceR);
-      node.quasis.push(curElt = this.parseTemplateElement());
-    }
-    this.next();
-    return this.finishNode(node, "TemplateLiteral");
-  };
-
-  // Parse an object literal or binding pattern.
-
-  pp.parseObj = function(isPattern, refShorthandDefaultPos) {
-    var node = this.startNode(), first = true, propHash = {};
-    node.properties = [];
-    this.next();
-    while (!this.eat(tt.braceR)) {
-      if (!first) {
-        this.expect(tt.comma);
-        if (this.afterTrailingComma(tt.braceR)) break;
-      } else first = false;
-
-      var prop = this.startNode(), isGenerator, start;
-      if (this.options.ecmaVersion >= 6) {
-        prop.method = false;
-        prop.shorthand = false;
-        if (isPattern || refShorthandDefaultPos)
-          start = this.currentPos();
-        if (!isPattern)
-          isGenerator = this.eat(tt.star);
-      }
-      this.parsePropertyName(prop);
-      if (this.eat(tt.colon)) {
-        prop.value = isPattern ? this.parseMaybeDefault() : this.parseMaybeAssign(false, refShorthandDefaultPos);
-        prop.kind = "init";
-      } else if (this.options.ecmaVersion >= 6 && this.type === tt.parenL) {
-        if (isPattern) this.unexpected();
-        prop.kind = "init";
-        prop.method = true;
-        prop.value = this.parseMethod(isGenerator);
-      } else if (this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
-                 (prop.key.name === "get" || prop.key.name === "set") &&
-                 (this.type != tt.comma && this.type != tt.braceR)) {
-        if (isGenerator || isPattern) this.unexpected();
-        prop.kind = prop.key.name;
-        this.parsePropertyName(prop);
-        prop.value = this.parseMethod(false);
-      } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
-        prop.kind = "init";
-        if (isPattern) {
-          if (this.isKeyword(prop.key.name) ||
-              (this.strict && (isStrictBadIdWord(prop.key.name) || isStrictReservedWord(prop.key.name))) ||
-              (!this.options.allowReserved && this.isReservedWord(prop.key.name)))
-            this.raise(prop.key.start, "Binding " + prop.key.name);
-          prop.value = this.parseMaybeDefault(start, prop.key);
-        } else if (this.type === tt.eq && refShorthandDefaultPos) {
-          if (!refShorthandDefaultPos.start)
-            refShorthandDefaultPos.start = this.start;
-          prop.value = this.parseMaybeDefault(start, prop.key);
-        } else {
-          prop.value = prop.key;
-        }
-        prop.shorthand = true;
-      } else this.unexpected();
-
-      this.checkPropClash(prop, propHash);
-      node.properties.push(this.finishNode(prop, "Property"));
-    }
-    return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");
-  };
-
-  pp.parsePropertyName = function(prop) {
-    if (this.options.ecmaVersion >= 6) {
-      if (this.eat(tt.bracketL)) {
-        prop.computed = true;
-        prop.key = this.parseExpression();
-        this.expect(tt.bracketR);
-        return;
-      } else {
-        prop.computed = false;
-      }
-    }
-    prop.key = (this.type === tt.num || this.type === tt.string) ? this.parseExprAtom() : this.parseIdent(true);
-  };
-
-  // Initialize empty function node.
-
-  pp.initFunction = function(node) {
-    node.id = null;
-    if (this.options.ecmaVersion >= 6) {
-      node.generator = false;
-      node.expression = false;
-    }
-  };
-
-  // Parse a function declaration or literal (depending on the
-  // `isStatement` parameter).
-
-  pp.parseFunction = function(node, isStatement, allowExpressionBody) {
-    this.initFunction(node);
-    if (this.options.ecmaVersion >= 6) {
-      node.generator = this.eat(tt.star);
-    }
-    if (isStatement || this.type === tt.name) {
-      node.id = this.parseIdent();
-    }
-    this.expect(tt.parenL);
-    node.params = this.parseBindingList(tt.parenR, false, false);
-    this.parseFunctionBody(node, allowExpressionBody);
-    return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  };
-
-  // Parse object or class method.
-
-  pp.parseMethod = function(isGenerator) {
-    var node = this.startNode();
-    this.initFunction(node);
-    this.expect(tt.parenL);
-    node.params = this.parseBindingList(tt.parenR, false, false);
-    var allowExpressionBody;
-    if (this.options.ecmaVersion >= 6) {
-      node.generator = isGenerator;
-      allowExpressionBody = true;
-    } else {
-      allowExpressionBody = false;
-    }
-    this.parseFunctionBody(node, allowExpressionBody);
-    return this.finishNode(node, "FunctionExpression");
-  };
-
-  // Parse arrow function expression with given parameters.
-
-  pp.parseArrowExpression = function(node, params) {
-    this.initFunction(node);
-    node.params = this.toAssignableList(params, true);
-    this.parseFunctionBody(node, true);
-    return this.finishNode(node, "ArrowFunctionExpression");
-  };
-
-  // Parse function body and check parameters.
-
-  pp.parseFunctionBody = function(node, allowExpression) {
-    var isExpression = allowExpression && this.type !== tt.braceL;
-
-    if (isExpression) {
-      node.body = this.parseMaybeAssign();
-      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 = this.inFunction, oldInGen = this.inGenerator, oldLabels = this.labels;
-      this.inFunction = true; this.inGenerator = node.generator; this.labels = [];
-      node.body = this.parseBlock(true);
-      node.expression = false;
-      this.inFunction = oldInFunc; this.inGenerator = oldInGen; this.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 (this.strict || !isExpression && node.body.body.length && this.isUseStrict(node.body.body[0])) {
-      var nameHash = {}, oldStrict = this.strict;
-      this.strict = true;
-      if (node.id)
-        this.checkLVal(node.id, true);
-      for (var i = 0; i < node.params.length; i++)
-        this.checkLVal(node.params[i], true, nameHash);
-      this.strict = oldStrict;
-    }
-  };
-
-  // Parse a class declaration or literal (depending on the
-  // `isStatement` parameter).
-
-  pp.parseClass = function(node, isStatement) {
-    this.next();
-    node.id = this.type === tt.name ? this.parseIdent() : isStatement ? this.unexpected() : null;
-    node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null;
-    var classBody = this.startNode();
-    classBody.body = [];
-    this.expect(tt.braceL);
-    while (!this.eat(tt.braceR)) {
-      if (this.eat(tt.semi)) continue;
-      var method = this.startNode();
-      var isGenerator = this.eat(tt.star);
-      this.parsePropertyName(method);
-      if (this.type !== tt.parenL && !method.computed && method.key.type === "Identifier" &&
-          method.key.name === "static") {
-        if (isGenerator) this.unexpected();
-        method['static'] = true;
-        isGenerator = this.eat(tt.star);
-        this.parsePropertyName(method);
-      } else {
-        method['static'] = false;
-      }
-      method.kind = "method";
-      if (!method.computed && !isGenerator) {
-        if (method.key.type === "Identifier") {
-          if (this.type !== tt.parenL && (method.key.name === "get" || method.key.name === "set")) {
-            method.kind = method.key.name;
-            this.parsePropertyName(method);
-          } else if (!method['static'] && method.key.name === "constructor") {
-            method.kind = "constructor";
-          }
-        } else if (!method['static'] && method.key.type === "Literal" && method.key.value === "constructor") {
-          method.kind = "constructor";
-        }
-      }
-      method.value = this.parseMethod(isGenerator);
-      classBody.body.push(this.finishNode(method, "MethodDefinition"));
-    }
-    node.body = this.finishNode(classBody, "ClassBody");
-    return this.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).
-
-  pp.parseExprList = function(close, allowTrailingComma, allowEmpty, refShorthandDefaultPos) {
-    var elts = [], first = true;
-    while (!this.eat(close)) {
-      if (!first) {
-        this.expect(tt.comma);
-        if (allowTrailingComma && this.afterTrailingComma(close)) break;
-      } else first = false;
-
-      if (allowEmpty && this.type === tt.comma) {
-        elts.push(null);
-      } else {
-        if (this.type === tt.ellipsis)
-          elts.push(this.parseSpread(refShorthandDefaultPos));
-        else
-          elts.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
-      }
-    }
-    return elts;
-  };
-
-  // Parse the next token as an identifier. If `liberal` is true (used
-  // when parsing properties), it will also convert keywords into
-  // identifiers.
-
-  pp.parseIdent = function(liberal) {
-    var node = this.startNode();
-    if (liberal && this.options.allowReserved == "never") liberal = false;
-    if (this.type === tt.name) {
-      if (!liberal &&
-          ((!this.options.allowReserved && this.isReservedWord(this.value)) ||
-           (this.strict && isStrictReservedWord(this.value)) &&
-           (this.options.ecmaVersion >= 6 || 
-            this.input.slice(this.start, this.end).indexOf("\\") == -1)))
-        this.raise(this.start, "The keyword '" + this.value + "' is reserved");
-      node.name = this.value;
-    } else if (liberal && this.type.keyword) {
-      node.name = this.type.keyword;
-    } else {
-      this.unexpected();
-    }
-    this.next();
-    return this.finishNode(node, "Identifier");
-  };
-
-  // Parses module export declaration.
-
-  pp.parseExport = function(node) {
-    this.next();
-    // export * from '...';
-    if (this.eat(tt.star)) {
-      this.expectContextual("from");
-      node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
-      this.semicolon();
-      return this.finishNode(node, "ExportAllDeclaration");
-    }
-    if (this.eat(tt._default)) { // export default ...;
-      var expr = this.parseMaybeAssign();
-      if (expr.id) {
-        switch (expr.type) {
-          case "FunctionExpression": expr.type = "FunctionDeclaration"; break;
-          case "ClassExpression": expr.type = "ClassDeclaration"; break;
-        }
-      }
-      node.declaration = expr;
-      this.semicolon();
-      return this.finishNode(node, "ExportDefaultDeclaration");
-    }
-    // export var|const|let|function|class ...;
-    if (this.type.keyword) {
-      node.declaration = this.parseStatement(true);
-      node.specifiers = [];
-      node.source = null;
-    } else { // export { x, y as z } [from '...'];
-      node.declaration = null;
-      node.specifiers = this.parseExportSpecifiers();
-      if (this.eatContextual("from")) {
-        node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
-      } else {
-        node.source = null;
-      }
-      this.semicolon();
-    }
-    return this.finishNode(node, "ExportNamedDeclaration");
-  };
-
-  // Parses a comma-separated list of module exports.
-
-  pp.parseExportSpecifiers = function() {
-    var nodes = [], first = true;
-    // export { x, y as z } [from '...']
-    this.expect(tt.braceL);
-    while (!this.eat(tt.braceR)) {
-      if (!first) {
-        this.expect(tt.comma);
-        if (this.afterTrailingComma(tt.braceR)) break;
-      } else first = false;
-
-      var node = this.startNode();
-      node.local = this.parseIdent(this.type === tt._default);
-      node.exported = this.eatContextual("as") ? this.parseIdent(true) : node.local;
-      nodes.push(this.finishNode(node, "ExportSpecifier"));
-    }
-    return nodes;
-  };
-
-  // Parses import declaration.
-
-  pp.parseImport = function(node) {
-    this.next();
-    // import '...';
-    if (this.type === tt.string) {
-      node.specifiers = [];
-      node.source = this.parseExprAtom();
-      node.kind = "";
-    } else {
-      node.specifiers = this.parseImportSpecifiers();
-      this.expectContextual("from");
-      node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
-    }
-    this.semicolon();
-    return this.finishNode(node, "ImportDeclaration");
-  };
-
-  // Parses a comma-separated list of module imports.
-
-  pp.parseImportSpecifiers = function() {
-    var nodes = [], first = true;
-    if (this.type === tt.name) {
-      // import defaultObj, { x, y as z } from '...'
-      var node = this.startNode();
-      node.local = this.parseIdent();
-      this.checkLVal(node.local, true);
-      nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
-      if (!this.eat(tt.comma)) return nodes;
-    }
-    if (this.type === tt.star) {
-      var node = this.startNode();
-      this.next();
-      this.expectContextual("as");
-      node.local = this.parseIdent();
-      this.checkLVal(node.local, true);
-      nodes.push(this.finishNode(node, "ImportNamespaceSpecifier"));
-      return nodes;
-    }
-    this.expect(tt.braceL);
-    while (!this.eat(tt.braceR)) {
-      if (!first) {
-        this.expect(tt.comma);
-        if (this.afterTrailingComma(tt.braceR)) break;
-      } else first = false;
-
-      var node = this.startNode();
-      node.imported = this.parseIdent(true);
-      node.local = this.eatContextual("as") ? this.parseIdent() : node.imported;
-      this.checkLVal(node.local, true);
-      nodes.push(this.finishNode(node, "ImportSpecifier"));
-    }
-    return nodes;
-  };
-
-  // Parses yield expression inside generator.
-
-  pp.parseYield = function() {
-    var node = this.startNode();
-    this.next();
-    if (this.type == tt.semi || this.canInsertSemicolon() || (this.type != tt.star && !this.type.startsExpr)) {
-      node.delegate = false;
-      node.argument = null;
-    } else {
-      node.delegate = this.eat(tt.star);
-      node.argument = this.parseMaybeAssign();
-    }
-    return this.finishNode(node, "YieldExpression");
-  };
-
-  // Parses array and generator comprehensions.
-
-  pp.parseComprehension = function(node, isGenerator) {
-    node.blocks = [];
-    while (this.type === tt._for) {
-      var block = this.startNode();
-      this.next();
-      this.expect(tt.parenL);
-      block.left = this.parseBindingAtom();
-      this.checkLVal(block.left, true);
-      this.expectContextual("of");
-      block.right = this.parseExpression();
-      this.expect(tt.parenR);
-      node.blocks.push(this.finishNode(block, "ComprehensionBlock"));
-    }
-    node.filter = this.eat(tt._if) ? this.parseParenExpression() : null;
-    node.body = this.parseExpression();
-    this.expect(isGenerator ? tt.parenR : tt.bracketR);
-    node.generator = isGenerator;
-    return this.finishNode(node, "ComprehensionExpression");
-  };
-});
diff --git a/acorn_loose.js b/acorn_loose.js
deleted file mode 100644
index b2165715ec..0000000000
--- a/acorn_loose.js
+++ /dev/null
@@ -1,1196 +0,0 @@
-// Acorn: Loose parser
-//
-// This module provides an alternative parser (`parse_dammit`) that
-// exposes that same interface as `parse`, but will try to parse
-// anything as JavaScript, repairing syntax error the best it can.
-// There are circumstances in which it will raise an error and give
-// up, but they are very rare. The resulting AST will be a mostly
-// valid JavaScript AST (as per the [Mozilla parser API][api], except
-// that:
-//
-// - Return outside functions is allowed
-//
-// - Label consistency (no conflicts, break only to existing labels)
-//   is not enforced.
-//
-// - Bogus Identifier nodes with a name of `"✖"` are inserted whenever
-//   the parser got too confused to return anything meaningful.
-//
-// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
-//
-// The expected use for this is to *first* try `acorn.parse`, and only
-// if that fails switch to `parse_dammit`. The loose parser might
-// parse badly indented code incorrectly, so **don't** use it as
-// your default parser.
-//
-// Quite a lot of acorn.js is duplicated here. The alternative was to
-// add a *lot* of extra cruft to that file, making it less readable
-// and slower. Copying and editing the code allowed me to make
-// invasive changes and simplifications without creating a complicated
-// tangle.
-
-(function(root, mod) {
-  if (typeof exports == "object" && typeof module == "object") return mod(exports, require("./acorn")); // CommonJS
-  if (typeof define == "function" && define.amd) return define(["exports", "./acorn"], mod); // AMD
-  mod(root.acorn || (root.acorn = {}), root.acorn); // Plain browser env
-})(this, function(exports, acorn) {
-  "use strict";
-
-  var tt = acorn.tokTypes;
-
-  acorn.defaultOptions.tabSize = 4;
-
-  exports.parse_dammit = function(input, options) {
-    var p = new LooseParser(input, options);
-    p.next();
-    return p.parseTopLevel();
-  };
-
-  var LooseParser = exports.LooseParser = function(input, options) {
-    this.toks = acorn.tokenizer(input, options)
-    this.options = this.toks.options;
-    this.input = this.toks.input;
-    this.tok = this.last = {type: tt.eof, start: 0, end: 0};
-    if (this.options.locations) {
-      var here = this.toks.curPosition();
-      this.tok.loc = new acorn.SourceLocation(this.toks, here, here);
-    }
-    this.ahead = []; // Tokens ahead
-    this.context = []; // Indentation contexted
-    this.curIndent = 0;
-    this.curLineStart = 0;
-    this.nextLineStart = this.lineEnd(this.curLineStart) + 1;
-  };
-
-  var lp = LooseParser.prototype;
-
-  lp.next = function() {
-    this.last = this.tok;
-    if (this.ahead.length)
-      this.tok = this.ahead.shift();
-    else
-      this.tok = this.readToken();
-
-    if (this.tok.start >= this.nextLineStart) {
-      while (this.tok.start >= this.nextLineStart) {
-        this.curLineStart = this.nextLineStart;
-        this.nextLineStart = this.lineEnd(this.curLineStart) + 1;
-      }
-      this.curIndent = this.indentationAfter(this.curLineStart);
-    }
-  };
-
-  lp.readToken = function() {
-    for (;;) {
-      try {
-        this.toks.next();
-        if (this.toks.type === tt.dot &&
-            this.input.substr(this.toks.end, 1) === "." &&
-            this.options.ecmaVersion >= 6) {
-          this.toks.end++;
-          this.toks.type = tt.ellipsis;
-        }
-        return new acorn.Token(this.toks);
-      } catch(e) {
-        if (!(e instanceof SyntaxError)) throw e;
-
-        // Try to skip some text, based on the error message, and then continue
-        var msg = e.message, pos = e.raisedAt, replace = true;
-        if (/unterminated/i.test(msg)) {
-          pos = this.lineEnd(e.pos + 1);
-          if (/string/.test(msg)) {
-            replace = {start: e.pos, end: pos, type: tt.string, value: this.input.slice(e.pos + 1, pos)};
-          } else if (/regular expr/i.test(msg)) {
-            var re = this.input.slice(e.pos, pos);
-            try { re = new RegExp(re); } catch(e) {}
-            replace = {start: e.pos, end: pos, type: tt.regexp, value: re};
-          } else if (/template/.test(msg)) {
-            replace = {start: e.pos, end: pos,
-                       type: tt.template,
-                       value: this.input.slice(e.pos, pos)};
-          } else {
-            replace = false;
-          }
-        } else if (/invalid (unicode|regexp|number)|expecting unicode|octal literal|is reserved|directly after number/i.test(msg)) {
-          while (pos < this.input.length && !isSpace(this.input.charCodeAt(pos))) ++pos;
-        } else if (/character escape|expected hexadecimal/i.test(msg)) {
-          while (pos < this.input.length) {
-            var ch = this.input.charCodeAt(pos++);
-            if (ch === 34 || ch === 39 || acorn.isNewLine(ch)) break;
-          }
-        } else if (/unexpected character/i.test(msg)) {
-          pos++;
-          replace = false;
-        } else if (/regular expression/i.test(msg)) {
-          replace = true;
-        } else {
-          throw e;
-        }
-        this.resetTo(pos);
-        if (replace === true) replace = {start: pos, end: pos, type: tt.name, value: "✖"};
-        if (replace) {
-          if (this.options.locations)
-            replace.loc = new acorn.SourceLocation(
-              this.toks,
-              acorn.getLineInfo(this.input, replace.start),
-              acorn.getLineInfo(this.input, replace.end));
-          return replace;
-        }
-      }
-    }
-  };
-
-  lp.resetTo = function(pos) {
-    this.toks.pos = pos;
-    var ch = this.input.charAt(pos - 1);
-    this.toks.exprAllowed = !ch || /[\[\{\(,;:?\/*=+\-~!|&%^<>]/.test(ch) ||
-      /[enwfd]/.test(ch) &&
-      /\b(keywords|case|else|return|throw|new|in|(instance|type)of|delete|void)$/.test(this.input.slice(pos - 10, pos));
-
-    if (this.options.locations) {
-      this.toks.curLine = 1;
-      this.toks.lineStart = acorn.lineBreakG.lastIndex = 0;
-      var match;
-      while ((match = acorn.lineBreakG.exec(this.input)) && match.index < pos) {
-        ++this.toks.curLine;
-        this.toks.lineStart = match.index + match[0].length;
-      }
-    }
-  };
-
-  lp.lookAhead = function(n) {
-    while (n > this.ahead.length)
-      this.ahead.push(this.readToken());
-    return this.ahead[n - 1];
-  };
-
-  function isSpace(ch) {
-    return (ch < 14 && ch > 8) || ch === 32 || ch === 160 || acorn.isNewLine(ch);
-  }
-
-  lp.pushCx = function() {
-    this.context.push(this.curIndent);
-  };
-  lp.popCx = function() {
-    this.curIndent = this.context.pop();
-  };
-
-  lp.lineEnd = function(pos) {
-    while (pos < this.input.length && !acorn.isNewLine(this.input.charCodeAt(pos))) ++pos;
-    return pos;
-  };
-
-  lp.indentationAfter = function(pos) {
-    for (var count = 0;; ++pos) {
-      var ch = this.input.charCodeAt(pos);
-      if (ch === 32) ++count;
-      else if (ch === 9) count += this.options.tabSize;
-      else return count;
-    }
-  };
-
-  lp.closes = function(closeTok, indent, line, blockHeuristic) {
-    if (this.tok.type === closeTok || this.tok.type === tt.eof) return true;
-    return line != this.curLineStart && this.curIndent < indent && this.tokenStartsLine() &&
-      (!blockHeuristic || this.nextLineStart >= this.input.length ||
-       this.indentationAfter(this.nextLineStart) < indent);
-  };
-
-  lp.tokenStartsLine = function() {
-    for (var p = this.tok.start - 1; p >= this.curLineStart; --p) {
-      var ch = this.input.charCodeAt(p);
-      if (ch !== 9 && ch !== 32) return false;
-    }
-    return true;
-  };
-
-  lp.startNode = function() {
-    var node = new acorn.Node;
-    node.start = this.tok.start;
-    if (this.options.locations)
-      node.loc = new acorn.SourceLocation(this.toks, this.tok.loc.start);
-    if (this.options.directSourceFile)
-      node.sourceFile = this.options.directSourceFile;
-    if (this.options.ranges)
-      node.range = [this.tok.start, 0];
-    return node;
-  };
-
-  lp.storeCurrentPos = function() {
-    return this.options.locations ? [this.tok.start, this.tok.loc.start] : this.tok.start;
-  };
-
-  lp.startNodeAt = function(pos) {
-    var node = new acorn.Node;
-    if (this.options.locations) {
-      node.start = pos[0];
-      node.loc = new acorn.SourceLocation(this.toks, pos[1]);
-      pos = pos[0];
-    } else {
-      node.start = pos;
-    }
-    if (this.options.directSourceFile)
-      node.sourceFile = this.options.directSourceFile;
-    if (this.options.ranges)
-      node.range = [pos, 0];
-    return node;
-  };
-
-  lp.finishNode = function(node, type) {
-    node.type = type;
-    node.end = this.last.end;
-    if (this.options.locations)
-      node.loc.end = this.last.loc.end;
-    if (this.options.ranges)
-      node.range[1] = this.last.end;
-    return node;
-  };
-
-  lp.dummyIdent = function() {
-    var dummy = this.startNode();
-    dummy.name = "✖";
-    return this.finishNode(dummy, "Identifier");
-  };
-
-  function isDummy(node) { return node.name == "✖"; }
-
-  lp.eat = function(type) {
-    if (this.tok.type === type) {
-      this.next();
-      return true;
-    } else {
-      return false;
-    }
-  };
-
-  lp.isContextual = function(name) {
-    return this.tok.type === tt.name && this.tok.value === name;
-  };
-
-  lp.eatContextual = function(name) {
-    return this.tok.value === name && this.eat(tt.name);
-  };
-
-  lp.canInsertSemicolon = function() {
-    return this.tok.type === tt.eof || this.tok.type === tt.braceR ||
-      acorn.lineBreak.test(this.input.slice(this.last.end, this.tok.start));
-  };
-
-  lp.semicolon = function() {
-    return this.eat(tt.semi);
-  };
-
-  lp.expect = function(type) {
-    if (this.eat(type)) return true;
-    for (var i = 1; i <= 2; i++) {
-      if (this.lookAhead(i).type == type) {
-        for (var j = 0; j < i; j++) this.next();
-        return true;
-      }
-    }
-  };
-
-  lp.checkLVal = function(expr) {
-    if (!expr) return expr;
-    switch (expr.type) {
-      case "Identifier":
-      case "MemberExpression":
-      case "ObjectPattern":
-      case "ArrayPattern":
-      case "RestElement":
-      case "AssignmentPattern":
-        return expr;
-
-      default:
-        return this.dummyIdent();
-    }
-  };
-
-  lp.parseTopLevel = function() {
-    var node = this.startNodeAt(this.options.locations ? [0, acorn.getLineInfo(this.input, 0)] : 0);
-    node.body = [];
-    while (this.tok.type !== tt.eof) node.body.push(this.parseStatement());
-    this.last = this.tok;
-    if (this.options.ecmaVersion >= 6) {
-      node.sourceType = this.options.sourceType;
-    }
-    return this.finishNode(node, "Program");
-  };
-
-  lp.parseStatement = function() {
-    var starttype = this.tok.type, node = this.startNode();
-
-    switch (starttype) {
-    case tt._break: case tt._continue:
-      this.next();
-      var isBreak = starttype === tt._break;
-      if (this.semicolon() || this.canInsertSemicolon()) {
-        node.label = null;
-      } else {
-        node.label = this.tok.type === tt.name ? this.parseIdent() : null;
-        this.semicolon();
-      }
-      return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-
-    case tt._debugger:
-      this.next();
-      this.semicolon();
-      return this.finishNode(node, "DebuggerStatement");
-
-    case tt._do:
-      this.next();
-      node.body = this.parseStatement();
-      node.test = this.eat(tt._while) ? this.parseParenExpression() : this.dummyIdent();
-      this.semicolon();
-      return this.finishNode(node, "DoWhileStatement");
-
-    case tt._for:
-      this.next();
-      this.pushCx();
-      this.expect(tt.parenL);
-      if (this.tok.type === tt.semi) return this.parseFor(node, null);
-      if (this.tok.type === tt._var || this.tok.type === tt._let || this.tok.type === tt._const) {
-        var init = this.parseVar(true);
-        if (init.declarations.length === 1 && (this.tok.type === tt._in || this.isContextual("of"))) {
-          return this.parseForIn(node, init);
-        }
-        return this.parseFor(node, init);
-      }
-      var init = this.parseExpression(true);
-      if (this.tok.type === tt._in || this.isContextual("of"))
-        return this.parseForIn(node, this.toAssignable(init));
-      return this.parseFor(node, init);
-
-    case tt._function:
-      this.next();
-      return this.parseFunction(node, true);
-
-    case tt._if:
-      this.next();
-      node.test = this.parseParenExpression();
-      node.consequent = this.parseStatement();
-      node.alternate = this.eat(tt._else) ? this.parseStatement() : null;
-      return this.finishNode(node, "IfStatement");
-
-    case tt._return:
-      this.next();
-      if (this.eat(tt.semi) || this.canInsertSemicolon()) node.argument = null;
-      else { node.argument = this.parseExpression(); this.semicolon(); }
-      return this.finishNode(node, "ReturnStatement");
-
-    case tt._switch:
-      var blockIndent = this.curIndent, line = this.curLineStart;
-      this.next();
-      node.discriminant = this.parseParenExpression();
-      node.cases = [];
-      this.pushCx();
-      this.expect(tt.braceL);
-
-      for (var cur; !this.closes(tt.braceR, blockIndent, line, true);) {
-        if (this.tok.type === tt._case || this.tok.type === tt._default) {
-          var isCase = this.tok.type === tt._case;
-          if (cur) this.finishNode(cur, "SwitchCase");
-          node.cases.push(cur = this.startNode());
-          cur.consequent = [];
-          this.next();
-          if (isCase) cur.test = this.parseExpression();
-          else cur.test = null;
-          this.expect(tt.colon);
-        } else {
-          if (!cur) {
-            node.cases.push(cur = this.startNode());
-            cur.consequent = [];
-            cur.test = null;
-          }
-          cur.consequent.push(this.parseStatement());
-        }
-      }
-      if (cur) this.finishNode(cur, "SwitchCase");
-      this.popCx();
-      this.eat(tt.braceR);
-      return this.finishNode(node, "SwitchStatement");
-
-    case tt._throw:
-      this.next();
-      node.argument = this.parseExpression();
-      this.semicolon();
-      return this.finishNode(node, "ThrowStatement");
-
-    case tt._try:
-      this.next();
-      node.block = this.parseBlock();
-      node.handler = null;
-      if (this.tok.type === tt._catch) {
-        var clause = this.startNode();
-        this.next();
-        this.expect(tt.parenL);
-        clause.param = this.toAssignable(this.parseExprAtom());
-        this.expect(tt.parenR);
-        clause.guard = null;
-        clause.body = this.parseBlock();
-        node.handler = this.finishNode(clause, "CatchClause");
-      }
-      node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;
-      if (!node.handler && !node.finalizer) return node.block;
-      return this.finishNode(node, "TryStatement");
-
-    case tt._var:
-    case tt._let:
-    case tt._const:
-      return this.parseVar();
-
-    case tt._while:
-      this.next();
-      node.test = this.parseParenExpression();
-      node.body = this.parseStatement();
-      return this.finishNode(node, "WhileStatement");
-
-    case tt._with:
-      this.next();
-      node.object = this.parseParenExpression();
-      node.body = this.parseStatement();
-      return this.finishNode(node, "WithStatement");
-
-    case tt.braceL:
-      return this.parseBlock();
-
-    case tt.semi:
-      this.next();
-      return this.finishNode(node, "EmptyStatement");
-
-    case tt._class:
-      return this.parseClass(true);
-
-    case tt._import:
-      return this.parseImport();
-
-    case tt._export:
-      return this.parseExport();
-
-    default:
-      var expr = this.parseExpression();
-      if (isDummy(expr)) {
-        this.next();
-        if (this.tok.type === tt.eof) return this.finishNode(node, "EmptyStatement");
-        return this.parseStatement();
-      } else if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon)) {
-        node.body = this.parseStatement();
-        node.label = expr;
-        return this.finishNode(node, "LabeledStatement");
-      } else {
-        node.expression = expr;
-        this.semicolon();
-        return this.finishNode(node, "ExpressionStatement");
-      }
-    }
-  };
-
-  lp.parseBlock = function() {
-    var node = this.startNode();
-    this.pushCx();
-    this.expect(tt.braceL);
-    var blockIndent = this.curIndent, line = this.curLineStart;
-    node.body = [];
-    while (!this.closes(tt.braceR, blockIndent, line, true))
-      node.body.push(this.parseStatement());
-    this.popCx();
-    this.eat(tt.braceR);
-    return this.finishNode(node, "BlockStatement");
-  };
-
-  lp.parseFor = function(node, init) {
-    node.init = init;
-    node.test = node.update = null;
-    if (this.eat(tt.semi) && this.tok.type !== tt.semi) node.test = this.parseExpression();
-    if (this.eat(tt.semi) && this.tok.type !== tt.parenR) node.update = this.parseExpression();
-    this.popCx();
-    this.expect(tt.parenR);
-    node.body = this.parseStatement();
-    return this.finishNode(node, "ForStatement");
-  };
-
-  lp.parseForIn = function(node, init) {
-    var type = this.tok.type === tt._in ? "ForInStatement" : "ForOfStatement";
-    this.next();
-    node.left = init;
-    node.right = this.parseExpression();
-    this.popCx();
-    this.expect(tt.parenR);
-    node.body = this.parseStatement();
-    return this.finishNode(node, type);
-  };
-
-  lp.parseVar = function(noIn) {
-    var node = this.startNode();
-    node.kind = this.tok.type.keyword;
-    this.next();
-    node.declarations = [];
-    do {
-      var decl = this.startNode();
-      decl.id = this.options.ecmaVersion >= 6 ? this.toAssignable(this.parseExprAtom()) : this.parseIdent();
-      decl.init = this.eat(tt.eq) ? this.parseMaybeAssign(noIn) : null;
-      node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
-    } while (this.eat(tt.comma));
-    if (!node.declarations.length) {
-      var decl = this.startNode();
-      decl.id = this.dummyIdent();
-      node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
-    }
-    if (!noIn) this.semicolon();
-    return this.finishNode(node, "VariableDeclaration");
-  };
-
-  lp.parseExpression = function(noIn) {
-    var start = this.storeCurrentPos();
-    var expr = this.parseMaybeAssign(noIn);
-    if (this.tok.type === tt.comma) {
-      var node = this.startNodeAt(start);
-      node.expressions = [expr];
-      while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn));
-      return this.finishNode(node, "SequenceExpression");
-    }
-    return expr;
-  };
-
-  lp.parseParenExpression = function() {
-    this.pushCx();
-    this.expect(tt.parenL);
-    var val = this.parseExpression();
-    this.popCx();
-    this.expect(tt.parenR);
-    return val;
-  };
-
-  lp.parseMaybeAssign = function(noIn) {
-    var start = this.storeCurrentPos();
-    var left = this.parseMaybeConditional(noIn);
-    if (this.tok.type.isAssign) {
-      var node = this.startNodeAt(start);
-      node.operator = this.tok.value;
-      node.left = this.tok.type === tt.eq ? this.toAssignable(left) : this.checkLVal(left);
-      this.next();
-      node.right = this.parseMaybeAssign(noIn);
-      return this.finishNode(node, "AssignmentExpression");
-    }
-    return left;
-  };
-
-  lp.parseMaybeConditional = function(noIn) {
-    var start = this.storeCurrentPos();
-    var expr = this.parseExprOps(noIn);
-    if (this.eat(tt.question)) {
-      var node = this.startNodeAt(start);
-      node.test = expr;
-      node.consequent = this.parseMaybeAssign();
-      node.alternate = this.expect(tt.colon) ? this.parseMaybeAssign(noIn) : this.dummyIdent();
-      return this.finishNode(node, "ConditionalExpression");
-    }
-    return expr;
-  };
-
-  lp.parseExprOps = function(noIn) {
-    var start = this.storeCurrentPos();
-    var indent = this.curIndent, line = this.curLineStart;
-    return this.parseExprOp(this.parseMaybeUnary(noIn), start, -1, noIn, indent, line);
-  };
-
-  lp.parseExprOp = function(left, start, minPrec, noIn, indent, line) {
-    if (this.curLineStart != line && this.curIndent < indent && this.tokenStartsLine()) return left;
-    var prec = this.tok.type.binop;
-    if (prec != null && (!noIn || this.tok.type !== tt._in)) {
-      if (prec > minPrec) {
-        var node = this.startNodeAt(start);
-        node.left = left;
-        node.operator = this.tok.value;
-        this.next();
-        if (this.curLineStart != line && this.curIndent < indent && this.tokenStartsLine()) {
-          node.right = this.dummyIdent();
-        } else {
-          var rightStart = this.storeCurrentPos();
-          node.right = this.parseExprOp(this.parseMaybeUnary(noIn), rightStart, prec, noIn, indent, line);
-        }
-        this.finishNode(node, /&&|\|\|/.test(node.operator) ? "LogicalExpression" : "BinaryExpression");
-        return this.parseExprOp(node, start, minPrec, noIn, indent, line);
-      }
-    }
-    return left;
-  };
-
-  lp.parseMaybeUnary = function(noIn) {
-    if (this.tok.type.prefix) {
-      var node = this.startNode(), update = this.tok.type === tt.incDec;
-      node.operator = this.tok.value;
-      node.prefix = true;
-      this.next();
-      node.argument = this.parseMaybeUnary(noIn);
-      if (update) node.argument = this.checkLVal(node.argument);
-      return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
-    } else if (this.tok.type === tt.ellipsis) {
-      var node = this.startNode();
-      this.next();
-      node.argument = this.parseMaybeUnary(noIn);
-      return this.finishNode(node, "SpreadElement");
-    }
-    var start = this.storeCurrentPos();
-    var expr = this.parseExprSubscripts();
-    while (this.tok.type.postfix && !this.canInsertSemicolon()) {
-      var node = this.startNodeAt(start);
-      node.operator = this.tok.value;
-      node.prefix = false;
-      node.argument = this.checkLVal(expr);
-      this.next();
-      expr = this.finishNode(node, "UpdateExpression");
-    }
-    return expr;
-  };
-
-  lp.parseExprSubscripts = function() {
-    var start = this.storeCurrentPos();
-    return this.parseSubscripts(this.parseExprAtom(), start, false, this.curIndent, this.curLineStart);
-  };
-
-  lp.parseSubscripts = function(base, start, noCalls, startIndent, line) {
-    for (;;) {
-      if (this.curLineStart != line && this.curIndent <= startIndent && this.tokenStartsLine()) {
-        if (this.tok.type == tt.dot && this.curIndent == startIndent)
-          --startIndent;
-        else
-          return base;
-      }
-
-      if (this.eat(tt.dot)) {
-        var node = this.startNodeAt(start);
-        node.object = base;
-        if (this.curLineStart != line && this.curIndent <= startIndent && this.tokenStartsLine())
-          node.property = this.dummyIdent();
-        else
-          node.property = this.parsePropertyAccessor() || this.dummyIdent();
-        node.computed = false;
-        base = this.finishNode(node, "MemberExpression");
-      } else if (this.tok.type == tt.bracketL) {
-        this.pushCx();
-        this.next();
-        var node = this.startNodeAt(start);
-        node.object = base;
-        node.property = this.parseExpression();
-        node.computed = true;
-        this.popCx();
-        this.expect(tt.bracketR);
-        base = this.finishNode(node, "MemberExpression");
-      } else if (!noCalls && this.tok.type == tt.parenL) {
-        this.pushCx();
-        var node = this.startNodeAt(start);
-        node.callee = base;
-        node.arguments = this.parseExprList(tt.parenR);
-        base = this.finishNode(node, "CallExpression");
-      } else if (this.tok.type == tt.backQuote) {
-        var node = this.startNodeAt(start);
-        node.tag = base;
-        node.quasi = this.parseTemplate();
-        base = this.finishNode(node, "TaggedTemplateExpression");
-      } else {
-        return base;
-      }
-    }
-  };
-
-  lp.parseExprAtom = function() {
-    switch (this.tok.type) {
-    case tt._this:
-    case tt._super:
-      var type = this.tok.type === tt._this ? "ThisExpression" : "SuperExpression";
-      var node = this.startNode();
-      this.next();
-      return this.finishNode(node, type);
-
-    case tt.name:
-      var start = this.storeCurrentPos();
-      var id = this.parseIdent();
-      return this.eat(tt.arrow) ? this.parseArrowExpression(this.startNodeAt(start), [id]) : id;
-
-    case tt.regexp:
-      var node = this.startNode();
-      var val = this.tok.value;
-      node.regex = {pattern: val.pattern, flags: val.flags};
-      node.value = val.value;
-      node.raw = this.input.slice(this.tok.start, this.tok.end);
-      this.next();
-      return this.finishNode(node, "Literal");
-
-    case tt.num: case tt.string:
-      var node = this.startNode();
-      node.value = this.tok.value;
-      node.raw = this.input.slice(this.tok.start, this.tok.end);
-      this.next();
-      return this.finishNode(node, "Literal");
-
-    case tt._null: case tt._true: case tt._false:
-      var node = this.startNode();
-      node.value = this.tok.type === tt._null ? null : this.tok.type === tt._true;
-      node.raw = this.tok.type.keyword;
-      this.next();
-      return this.finishNode(node, "Literal");
-
-    case tt.parenL:
-      var start = this.storeCurrentPos();
-      this.next();
-      var val = this.parseExpression();
-      this.expect(tt.parenR);
-      if (this.eat(tt.arrow)) {
-        return this.parseArrowExpression(this.startNodeAt(start), val.expressions || (isDummy(val) ? [] : [val]));
-      }
-      if (this.options.preserveParens) {
-        var par = this.startNodeAt(start);
-        par.expression = val;
-        val = this.finishNode(par, "ParenthesizedExpression");
-      }
-      return val;
-
-    case tt.bracketL:
-      var node = this.startNode();
-      this.pushCx();
-      node.elements = this.parseExprList(tt.bracketR, true);
-      return this.finishNode(node, "ArrayExpression");
-
-    case tt.braceL:
-      return this.parseObj();
-
-    case tt._class:
-      return this.parseClass();
-
-    case tt._function:
-      var node = this.startNode();
-      this.next();
-      return this.parseFunction(node, false);
-
-    case tt._new:
-      return this.parseNew();
-
-    case tt._yield:
-      var node = this.startNode();
-      this.next();
-      if (this.semicolon() || this.canInsertSemicolon() || (this.tok.type != tt.star && !this.tok.type.startsExpr)) {
-        node.delegate = false;
-        node.argument = null;
-      } else {
-        node.delegate = this.eat(tt.star);
-        node.argument = this.parseMaybeAssign();
-      }
-      return this.finishNode(node, "YieldExpression");
-
-    case tt.backQuote:
-      return this.parseTemplate();
-
-    default:
-      return this.dummyIdent();
-    }
-  };
-
-  lp.parseNew = function() {
-    var node = this.startNode(), startIndent = this.curIndent, line = this.curLineStart;
-    this.next();
-    var start = this.storeCurrentPos();
-    node.callee = this.parseSubscripts(this.parseExprAtom(), start, true, startIndent, line);
-    if (this.tok.type == tt.parenL) {
-      this.pushCx();
-      node.arguments = this.parseExprList(tt.parenR);
-    } else {
-      node.arguments = [];
-    }
-    return this.finishNode(node, "NewExpression");
-  };
-
-  lp.parseTemplateElement = function() {
-    var elem = this.startNode();
-    elem.value = {
-      raw: this.input.slice(this.tok.start, this.tok.end),
-      cooked: this.tok.value
-    };
-    this.next();
-    elem.tail = this.tok.type === tt.backQuote;
-    return this.finishNode(elem, "TemplateElement");
-  };
-
-  lp.parseTemplate = function() {
-    var node = this.startNode();
-    this.next();
-    node.expressions = [];
-    var curElt = this.parseTemplateElement();
-    node.quasis = [curElt];
-    while (!curElt.tail) {
-      this.next();
-      node.expressions.push(this.parseExpression());
-      if (this.expect(tt.braceR)) {
-        curElt = this.parseTemplateElement();
-      } else {
-        curElt = this.startNode();
-        curElt.value = {cooked: '', raw: ''};
-        curElt.tail = true;
-      }
-      node.quasis.push(curElt);
-    }
-    this.expect(tt.backQuote);
-    return this.finishNode(node, "TemplateLiteral");
-  };
-
-  lp.parseObj = function() {
-    var node = this.startNode();
-    node.properties = [];
-    this.pushCx();
-    var indent = this.curIndent + 1, line = this.curLineStart;
-    this.eat(tt.braceL);
-    if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart; }
-    while (!this.closes(tt.braceR, indent, line)) {
-      var prop = this.startNode(), isGenerator, start;
-      if (this.options.ecmaVersion >= 6) {
-        start = this.storeCurrentPos();
-        prop.method = false;
-        prop.shorthand = false;
-        isGenerator = this.eat(tt.star);
-      }
-      this.parsePropertyName(prop);
-      if (isDummy(prop.key)) { if (isDummy(this.parseMaybeAssign())) this.next(); this.eat(tt.comma); continue; }
-      if (this.eat(tt.colon)) {
-        prop.kind = "init";
-        prop.value = this.parseMaybeAssign();
-      } else if (this.options.ecmaVersion >= 6 && (this.tok.type === tt.parenL || this.tok.type === tt.braceL)) {
-        prop.kind = "init";
-        prop.method = true;
-        prop.value = this.parseMethod(isGenerator);
-      } else if (this.options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
-                 !prop.computed && (prop.key.name === "get" || prop.key.name === "set") &&
-                 (this.tok.type != tt.comma && this.tok.type != tt.braceR)) {
-        prop.kind = prop.key.name;
-        this.parsePropertyName(prop);
-        prop.value = this.parseMethod(false);
-      } else {
-        prop.kind = "init";
-        if (this.options.ecmaVersion >= 6) {
-          if (this.eat(tt.eq)) {
-            var assign = this.startNodeAt(start);
-            assign.operator = "=";
-            assign.left = prop.key;
-            assign.right = this.parseMaybeAssign();
-            prop.value = this.finishNode(assign, "AssignmentExpression");
-          } else {
-            prop.value = prop.key;
-          }
-        } else {
-          prop.value = this.dummyIdent();
-        }
-        prop.shorthand = true;
-      }
-      node.properties.push(this.finishNode(prop, "Property"));
-      this.eat(tt.comma);
-    }
-    this.popCx();
-    if (!this.eat(tt.braceR)) {
-      // If there is no closing brace, make the node span to the start
-      // of the next token (this is useful for Tern)
-      this.last.end = this.tok.start;
-      if (this.options.locations) this.last.loc.end = this.tok.loc.start;
-    }
-    return this.finishNode(node, "ObjectExpression");
-  };
-
-  lp.parseClass = function(isStatement) {
-    var node = this.startNode();
-    this.next();
-    if (this.tok.type === tt.name) node.id = this.parseIdent();
-    else if (isStatement) node.id = this.dummyIdent();
-    else node.id = null;
-    node.superClass = this.eat(tt._extends) ? this.parseExpression() : null;
-    node.body = this.startNode();
-    node.body.body = [];
-    this.pushCx();
-    var indent = this.curIndent + 1, line = this.curLineStart;
-    this.eat(tt.braceL);
-    if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart; }
-    while (!this.closes(tt.braceR, indent, line)) {
-      if (this.semicolon()) continue;
-      var method = this.startNode(), isGenerator, start;
-      if (this.options.ecmaVersion >= 6) {
-        method['static'] = false;
-        isGenerator = this.eat(tt.star);
-      }
-      this.parsePropertyName(method);
-      if (isDummy(method.key)) { if (isDummy(this.parseMaybeAssign())) this.next(); this.eat(tt.comma); continue; }
-      if (method.key.type === "Identifier" && !method.computed && method.key.name === "static" &&
-          (this.tok.type != tt.parenL && this.tok.type != tt.braceL)) {
-        method['static'] = true;
-        isGenerator = this.eat(tt.star);
-        this.parsePropertyName(method);
-      } else {
-        method['static'] = false;
-      }
-      if (this.options.ecmaVersion >= 5 && method.key.type === "Identifier" &&
-          !method.computed && (method.key.name === "get" || method.key.name === "set") &&
-          this.tok.type !== tt.parenL && this.tok.type !== tt.braceL) {
-        method.kind = method.key.name;
-        this.parsePropertyName(method);
-        method.value = this.parseMethod(false);
-      } else {
-        if (!method.computed && !method['static'] && !isGenerator && (
-          method.key.type === "Identifier" && method.key.name === "constructor" ||
-          method.key.type === "Literal" && method.key.value === "constructor")) {
-          method.kind = "constructor";
-        } else {
-          method.kind =  "method";
-        }
-        method.value = this.parseMethod(isGenerator);
-      }
-      node.body.body.push(this.finishNode(method, "MethodDefinition"));
-    }
-    this.popCx();
-    if (!this.eat(tt.braceR)) {
-      // If there is no closing brace, make the node span to the start
-      // of the next token (this is useful for Tern)
-      this.last.end = this.tok.start;
-      if (this.options.locations) this.last.loc.end = this.tok.loc.start;
-    }
-    this.semicolon();
-    this.finishNode(node.body, "ClassBody");
-    return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
-  };
-
-  lp.parsePropertyName = function(prop) {
-    if (this.options.ecmaVersion >= 6) {
-      if (this.eat(tt.bracketL)) {
-        prop.computed = true;
-        prop.key = this.parseExpression();
-        this.expect(tt.bracketR);
-        return;
-      } else {
-        prop.computed = false;
-      }
-    }
-    var key = (this.tok.type === tt.num || this.tok.type === tt.string) ? this.parseExprAtom() : this.parseIdent();
-    prop.key = key || this.dummyIdent();
-  };
-
-  lp.parsePropertyAccessor = function() {
-    if (this.tok.type === tt.name || this.tok.type.keyword) return this.parseIdent();
-  };
-
-  lp.parseIdent = function() {
-    var node = this.startNode();
-    node.name = this.tok.type === tt.name ? this.tok.value : this.tok.type.keyword;
-    this.next();
-    return this.finishNode(node, "Identifier");
-  };
-
-  lp.initFunction = function(node) {
-    node.id = null;
-    node.params = [];
-    if (this.options.ecmaVersion >= 6) {
-      node.generator = false;
-      node.expression = false;
-    }
-  };
-
-  // Convert existing expression atom to assignable pattern
-  // if possible.
-
-  lp.toAssignable = function(node) {
-    if (this.options.ecmaVersion >= 6 && node) {
-      switch (node.type) {
-        case "ObjectExpression":
-          node.type = "ObjectPattern";
-          var props = node.properties;
-          for (var i = 0; i < props.length; i++)
-            this.toAssignable(props[i].value);
-          break;
-
-        case "ArrayExpression":
-          node.type = "ArrayPattern";
-          this.toAssignableList(node.elements);
-          break;
-
-        case "SpreadElement":
-          node.type = "RestElement";
-          node.argument = this.toAssignable(node.argument);
-          break;
-
-        case "AssignmentExpression":
-          node.type = "AssignmentPattern";
-          break;
-      }
-    }
-    return this.checkLVal(node);
-  };
-
-  lp.toAssignableList = function(exprList) {
-    for (var i = 0; i < exprList.length; i++)
-      this.toAssignable(exprList[i]);
-    return exprList;
-  };
-
-  lp.parseFunctionParams = function(params) {
-    this.pushCx();
-    params = this.parseExprList(tt.parenR);
-    return this.toAssignableList(params);
-  };
-
-  lp.parseFunction = function(node, isStatement) {
-    this.initFunction(node);
-    if (this.options.ecmaVersion >= 6) {
-      node.generator = this.eat(tt.star);
-    }
-    if (this.tok.type === tt.name) node.id = this.parseIdent();
-    else if (isStatement) node.id = this.dummyIdent();
-    node.params = this.parseFunctionParams();
-    node.body = this.parseBlock();
-    return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  };
-
-  lp.parseMethod = function(isGenerator) {
-    var node = this.startNode();
-    this.initFunction(node);
-    node.params = this.parseFunctionParams();
-    node.generator = isGenerator || false;
-    node.expression = this.options.ecmaVersion >= 6 && this.tok.type !== tt.braceL;
-    node.body = node.expression ? this.parseMaybeAssign() : this.parseBlock();
-    return this.finishNode(node, "FunctionExpression");
-  };
-
-  lp.parseArrowExpression = function(node, params) {
-    this.initFunction(node);
-    node.params = this.toAssignableList(params);
-    node.expression = this.tok.type !== tt.braceL;
-    node.body = node.expression ? this.parseMaybeAssign() : this.parseBlock();
-    return this.finishNode(node, "ArrowFunctionExpression");
-  };
-
-  lp.parseExport = function() {
-    var node = this.startNode();
-    this.next();
-    if (this.eat(tt.star)) {
-      node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
-      return this.finishNode(node, "ExportAllDeclaration");
-    }
-    if (this.eat(tt._default)) {
-      var expr = this.parseMaybeAssign();
-      if (expr.id) {
-        switch (expr.type) {
-          case "FunctionExpression": expr.type = "FunctionDeclaration"; break;
-          case "ClassExpression": expr.type = "ClassDeclaration"; break;
-        }
-      }
-      node.declaration = expr;
-      this.semicolon();
-      return this.finishNode(node, "ExportDefaultDeclaration");
-    }
-    if (this.tok.type.keyword) {
-      node.declaration = this.parseStatement();
-      node.specifiers = [];
-      node.source = null;
-    } else {
-      node.declaration = null;
-      node.specifiers = this.parseExportSpecifierList();
-      node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
-      this.semicolon();
-    }
-    return this.finishNode(node, "ExportNamedDeclaration");
-  };
-
-  lp.parseImport = function() {
-    var node = this.startNode();
-    this.next();
-    if (this.tok.type === tt.string) {
-      node.specifiers = [];
-      node.source = this.parseExprAtom();
-      node.kind = '';
-    } else {
-      if (this.tok.type === tt.name && this.tok.value !== "from") {
-        var elt = this.startNode();
-        elt.local = this.parseIdent();
-        this.finishNode(elt, "ImportDefaultSpecifier");
-        this.eat(tt.comma);
-      }
-      node.specifiers = this.parseImportSpecifierList();
-      node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
-      if (elt) node.specifiers.unshift(elt);
-    }
-    this.semicolon();
-    return this.finishNode(node, "ImportDeclaration");
-  };
-
-  lp.parseImportSpecifierList = function() {
-    var elts = [];
-    if (this.tok.type === tt.star) {
-      var elt = this.startNode();
-      this.next();
-      if (this.eatContextual("as")) elt.local = this.parseIdent();
-      elts.push(this.finishNode(elt, "ImportNamespaceSpecifier"));
-    } else {
-      var indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart;
-      this.pushCx();
-      this.eat(tt.braceL);
-      if (this.curLineStart > continuedLine) continuedLine = this.curLineStart;
-      while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
-        var elt = this.startNode();
-        if (this.eat(tt.star)) {
-          if (this.eatContextual("as")) elt.local = this.parseIdent();
-          this.finishNode(elt, "ImportNamespaceSpecifier");
-        } else {
-          if (this.isContextual("from")) break;
-          elt.imported = this.parseIdent();
-          elt.local = this.eatContextual("as") ? this.parseIdent() : elt.imported;
-          this.finishNode(elt, "ImportSpecifier");
-        }
-        elts.push(elt);
-        this.eat(tt.comma);
-      }
-      this.eat(tt.braceR);
-      this.popCx();
-    }
-    return elts;
-  };
-
-  lp.parseExportSpecifierList = function() {
-    var elts = [];
-    var indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart;
-    this.pushCx();
-    this.eat(tt.braceL);
-    if (this.curLineStart > continuedLine) continuedLine = this.curLineStart;
-    while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
-      if (this.isContextual("from")) break;
-      var elt = this.startNode();
-      elt.local = this.parseIdent();
-      elt.exported = this.eatContextual("as") ? this.parseIdent() : elt.local;
-      this.finishNode(elt, "ExportSpecifier");
-      elts.push(elt);
-      this.eat(tt.comma);
-    }
-    this.eat(tt.braceR);
-    this.popCx();
-    return elts;
-  };
-
-  lp.parseExprList = function(close, allowEmpty) {
-    var indent = this.curIndent, line = this.curLineStart, elts = [];
-    this.next(); // Opening bracket
-    while (!this.closes(close, indent + 1, line)) {
-      if (this.eat(tt.comma)) {
-        elts.push(allowEmpty ? null : this.dummyIdent());
-        continue;
-      }
-      var elt = this.parseMaybeAssign();
-      if (isDummy(elt)) {
-        if (this.closes(close, indent, line)) break;
-        this.next();
-      } else {
-        elts.push(elt);
-      }
-      this.eat(tt.comma);
-    }
-    this.popCx();
-    if (!this.eat(close)) {
-      // If there is no closing brace, make the node span to the start
-      // of the next token (this is useful for Tern)
-      this.last.end = this.tok.start;
-      if (this.options.locations) this.last.loc.end = this.tok.loc.start;
-    }
-    return elts;
-  };
-});
diff --git a/tools/build-acorn.js b/bin/build-acorn.js
similarity index 79%
rename from tools/build-acorn.js
rename to bin/build-acorn.js
index 01a3ef11c8..aa7a9fe00f 100644
--- a/tools/build-acorn.js
+++ b/bin/build-acorn.js
@@ -31,10 +31,18 @@ function acornShim(file) {
   return tr
 }
 
-browserify()
+browserify({standalone: "acorn.loose"})
   .transform(acornShim)
   .transform(babelify)
   .require("./src/loose/index.js", {entry: true})
   .bundle()
   .on("error", function (err) { console.log("Error: " + err.message) })
   .pipe(fs.createWriteStream("dist/acorn_loose.js"))
+
+browserify({standalone: "acorn.walk"})
+  .transform(acornShim)
+  .transform(babelify)
+  .require("./src/walk/index.js", {entry: true})
+  .bundle()
+  .on("error", function (err) { console.log("Error: " + err.message) })
+  .pipe(fs.createWriteStream("dist/walk.js"))
diff --git a/tools/generate-identifier-regex.js b/bin/generate-identifier-regex.js
similarity index 100%
rename from tools/generate-identifier-regex.js
rename to bin/generate-identifier-regex.js
diff --git a/bin/prepublish.sh b/bin/prepublish.sh
new file mode 100755
index 0000000000..879834da67
--- /dev/null
+++ b/bin/prepublish.sh
@@ -0,0 +1,2 @@
+node bin/build-acorn.js
+node bin/without_eval > dist/acorn_csp.js
diff --git a/bin/without_eval b/bin/without_eval
index e9ef18f380..4331e7070c 100755
--- a/bin/without_eval
+++ b/bin/without_eval
@@ -1,45 +1,48 @@
 #!/usr/bin/env node
 
-var fs = require("fs");
+var fs = require("fs")
 
-var acornSrc = fs.readFileSync(require.resolve("../acorn"), "utf8");
-var acorn = require("../acorn"), walk = require("../util/walk");
+var acornSrc = fs.readFileSync(require.resolve("../dist/acorn"), "utf8")
+var acorn = require("../dist/acorn"), walk = require("../dist/walk")
 
-var ast = acorn.parse(acornSrc);
-var touchups = [], uses = [];
+var ast = acorn.parse(acornSrc)
+var touchups = [], uses = []
+
+var makePred
 
 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});
+    if (node.id.name == "makePredicate") {
+      makePred = node
+      touchups.push({text: "// Removed to create an eval-free library", from: node.start, to: node.end})
+    }
   },
-  VariableDeclaration: function(node) {
-    node.declarations.forEach(function(decl) {
-      if (decl.init && decl.init.type == "CallExpression" &&
-          decl.init.callee.name == "makePredicate")
-        uses.push(decl);
-    });
+  ObjectExpression: function(node) {
+    node.properties.forEach(function(prop) {
+      if (prop.value.type == "CallExpression" &&
+          prop.value.callee.name == "makePredicate")
+        uses.push(prop.value)
+    })
   }
-});
+})
 
-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);
+var results = []
+var dryRun = acornSrc.slice(0, makePred.end) + "; makePredicate = (function(mp) {" +
+    "return function(words) { var r = mp(words); predicates.push(r); return r }})(makePredicate);" +
+    acornSrc.slice(makePred.end)
+;(new Function("predicates", dryRun))(results)
 
-uses.forEach(function(decl) {
-  touchups.push({text: results[decl.id.name].toString(),
-                 from: decl.init.start, to: decl.init.end});
-});
+uses.forEach(function (node, i) {
+  touchups.push({text: results[i].toString(), from: node.start, to: node.end})
+})
 
-var result = "", pos = 0;
-touchups.sort(function(a, b) { return a.from - b.from; });
+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);
+  result += acornSrc.slice(pos, touchup.from)
+  result += touchup.text
+  pos = touchup.to
+})
+result += acornSrc.slice(pos)
 
-process.stdout.write(result);
+process.stdout.write(result)
diff --git a/package.json b/package.json
index 3cda09c316..7073d2a9e9 100644
--- a/package.json
+++ b/package.json
@@ -1,22 +1,40 @@
 {
-    "name": "acorn",
-    "description": "ECMAScript parser",
-    "homepage": "http://marijnhaverbeke.nl/acorn/",
-    "main": "acorn.js",
-    "version": "0.12.1",
-    "engines": {"node": ">=0.4.0"},
-    "maintainers": [{"name": "Marijn Haverbeke",
-                     "email": "marijnh@gmail.com",
-                     "web": "http://marijnhaverbeke.nl"}],
-    "repository": {"type": "git",
-                   "url": "http://marijnhaverbeke.nl/git/acorn"},
-    "licenses": [{"type": "MIT",
-                  "url": "http://marijnhaverbeke.nl/acorn/LICENSE"}],
-    "scripts": {
-      "test": "node test/run.js",
-      "prepublish": "node bin/without_eval > acorn_csp.js"
-    },
-    "bin": {"acorn": "./bin/acorn"},
-    "devDependencies": {"regenerate": "~0.6.2",
-                        "unicode-7.0.0": "~0.1.5"}
+  "name": "acorn",
+  "description": "ECMAScript parser",
+  "homepage": "http://marijnhaverbeke.nl/acorn/",
+  "main": "dist/acorn.js",
+  "version": "0.12.1",
+  "engines": {
+    "node": ">=0.4.0"
+  },
+  "maintainers": [
+    {
+      "name": "Marijn Haverbeke",
+      "email": "marijnh@gmail.com",
+      "web": "http://marijnhaverbeke.nl"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "http://marijnhaverbeke.nl/git/acorn"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://marijnhaverbeke.nl/acorn/LICENSE"
+    }
+  ],
+  "scripts": {
+    "test": "node test/run.js",
+    "prepublish": "node bin/prepublish.sh"
+  },
+  "bin": {
+    "acorn": "./bin/acorn"
+  },
+  "devDependencies": {
+    "babelify": "^5.0.4",
+    "browserify": "^9.0.3",
+    "regenerate": "~0.6.2",
+    "unicode-7.0.0": "~0.1.5"
+  }
 }
diff --git a/src/loose/statement.js b/src/loose/statement.js
index ad7257da21..714d104b08 100644
--- a/src/loose/statement.js
+++ b/src/loose/statement.js
@@ -5,7 +5,7 @@ import {getLineInfo, tokTypes as tt} from ".."
 const lp = LooseParser.prototype
 
 lp.parseTopLevel = function() {
-  var node = this.startNodeAt(this.options.locations ? [0, acorn.getLineInfo(this.input, 0)] : 0);
+  var node = this.startNodeAt(this.options.locations ? [0, getLineInfo(this.input, 0)] : 0);
   node.body = [];
   while (this.tok.type !== tt.eof) node.body.push(this.parseStatement());
   this.last = this.tok;
diff --git a/src/walk/index.js b/src/walk/index.js
new file mode 100644
index 0000000000..36d4e3ed12
--- /dev/null
+++ b/src/walk/index.js
@@ -0,0 +1,291 @@
+// AST walker module for Mozilla Parser API compatible trees
+
+// A simple walk is one where you simply specify callbacks to be
+// called on specific nodes. The last two arguments are optional. A
+// simple use would be
+//
+//     walk.simple(myTree, {
+//         Expression: function(node) { ... }
+//     });
+//
+// to do something with all expressions. All Parser API node types
+// can be used to identify node types, as well as Expression,
+// Statement, and ScopeBody, which denote categories of nodes.
+//
+// The base argument can be used to pass a custom (recursive)
+// walker, and state can be used to give this walked an initial
+// state.
+
+export function simple(node, visitors, base, state) {
+  if (!base) base = exports.base
+  ;(function c(node, st, override) {
+    let type = override || node.type, found = visitors[type]
+    base[type](node, st, c)
+    if (found) found(node, st)
+  })(node, state)
+}
+
+// An ancestor walk builds up an array of ancestor nodes (including
+// the current node) and passes them to the callback as the state parameter.
+export function ancestor(node, visitors, base, state) {
+  if (!base) base = exports.base
+  if (!state) state = []
+  ;(function c(node, st, override) {
+    let type = override || node.type, found = visitors[type]
+    if (node != st[st.length - 1]) {
+      st = st.slice()
+      st.push(node)
+    }
+    base[type](node, st, c)
+    if (found) found(node, st)
+  })(node, state)
+}
+
+// A recursive walk is one where your functions override the default
+// walkers. They can modify and replace the state parameter that's
+// threaded through the walk, and can opt how and whether to walk
+// their child nodes (by calling their third argument on these
+// nodes).
+export function recursive(node, state, funcs, base) {
+  let visitor = funcs ? exports.make(funcs, base) : base
+  ;(function c(node, st, override) {
+    visitor[override || node.type](node, st, c)
+  })(node, state)
+}
+
+function makeTest(test) {
+  if (typeof test == "string")
+    return type => type == test
+  else if (!test)
+    return () => true
+  else
+    return test
+}
+
+class Found {
+  constructor(node, state) { this.node = node; this.state = state }
+}
+
+// Find a node with a given start, end, and type (all are optional,
+// null can be used as wildcard). Returns a {node, state} object, or
+// undefined when it doesn't find a matching node.
+export function findNodeAt(node, start, end, test, base, state) {
+  test = makeTest(test)
+  if (!base) base = exports.base
+  try {
+    ;(function c(node, st, override) {
+      let type = override || node.type
+      if ((start == null || node.start <= start) &&
+          (end == null || node.end >= end))
+        base[type](node, st, c)
+      if (test(type, node) &&
+          (start == null || node.start == start) &&
+          (end == null || node.end == end))
+        throw new Found(node, st)
+    })(node, state)
+  } catch (e) {
+    if (e instanceof Found) return e
+    throw e
+  }
+}
+
+// Find the innermost node of a given type that contains the given
+// position. Interface similar to findNodeAt.
+export function findNodeAround(node, pos, test, base, state) {
+  test = makeTest(test)
+  if (!base) base = exports.base
+  try {
+    ;(function c(node, st, override) {
+      let type = override || node.type
+      if (node.start > pos || node.end < pos) return
+      base[type](node, st, c)
+      if (test(type, node)) throw new Found(node, st)
+    })(node, state)
+  } catch (e) {
+    if (e instanceof Found) return e
+    throw e
+  }
+}
+
+// Find the outermost matching node after a given position.
+export function findNodeAfter(node, pos, test, base, state) {
+  test = makeTest(test)
+  if (!base) base = exports.base
+  try {
+    ;(function c(node, st, override) {
+      if (node.end < pos) return
+      let type = override || node.type
+      if (node.start >= pos && test(type, node)) throw new Found(node, st)
+      base[type](node, st, c)
+    })(node, state)
+  } catch (e) {
+    if (e instanceof Found) return e
+    throw e
+  }
+}
+
+// Find the outermost matching node before a given position.
+export function findNodeBefore(node, pos, test, base, state) {
+  test = makeTest(test)
+  if (!base) base = exports.base
+  let max
+  ;(function c(node, st, override) {
+    if (node.start > pos) return
+    let type = override || node.type
+    if (node.end <= pos && (!max || max.node.end < node.end) && test(type, node))
+      max = new Found(node, st)
+    base[type](node, st, c)
+  })(node, state)
+  return max
+}
+
+// Used to create a custom walker. Will fill in all missing node
+// type properties with the defaults.
+export function make(funcs, base) {
+  if (!base) base = exports.base
+  let visitor = {}
+  for (var type in base) visitor[type] = base[type]
+  for (var type in funcs) visitor[type] = funcs[type]
+  return visitor
+}
+
+function skipThrough(node, st, c) { c(node, st) }
+function ignore(_node, _st, _c) {}
+
+// Node walkers.
+
+export const base = {}
+
+base.Program = base.BlockStatement = (node, st, c) => {
+  for (let i = 0; i < node.body.length; ++i)
+    c(node.body[i], st, "Statement")
+}
+base.Statement = skipThrough
+base.EmptyStatement = ignore
+base.ExpressionStatement = base.ParenthesizedExpression =
+  (node, st, c) => c(node.expression, st, "Expression")
+base.IfStatement = (node, st, c) => {
+  c(node.test, st, "Expression")
+  c(node.consequent, st, "Statement")
+  if (node.alternate) c(node.alternate, st, "Statement")
+}
+base.LabeledStatement = (node, st, c) => c(node.body, st, "Statement")
+base.BreakStatement = base.ContinueStatement = ignore
+base.WithStatement = (node, st, c) => {
+  c(node.object, st, "Expression")
+  c(node.body, st, "Statement")
+}
+base.SwitchStatement = (node, st, c) => {
+  c(node.discriminant, st, "Expression")
+  for (let i = 0; i < node.cases.length; ++i) {
+    let cs = node.cases[i]
+    if (cs.test) c(cs.test, st, "Expression")
+    for (let j = 0; j < cs.consequent.length; ++j)
+      c(cs.consequent[j], st, "Statement")
+  }
+}
+base.ReturnStatement = base.YieldExpression = (node, st, c) => {
+  if (node.argument) c(node.argument, st, "Expression")
+}
+base.ThrowStatement = base.SpreadElement = base.RestElement =
+  (node, st, c) => c(node.argument, st, "Expression")
+base.TryStatement = (node, st, c) => {
+  c(node.block, st, "Statement")
+  if (node.handler) c(node.handler.body, st, "ScopeBody")
+  if (node.finalizer) c(node.finalizer, st, "Statement")
+}
+base.WhileStatement = base.DoWhileStatement = (node, st, c) => {
+  c(node.test, st, "Expression")
+  c(node.body, st, "Statement")
+}
+base.ForStatement = (node, st, c) => {
+  if (node.init) c(node.init, st, "ForInit")
+  if (node.test) c(node.test, st, "Expression")
+  if (node.update) c(node.update, st, "Expression")
+  c(node.body, st, "Statement")
+}
+base.ForInStatement = base.ForOfStatement = (node, st, c) => {
+  c(node.left, st, "ForInit")
+  c(node.right, st, "Expression")
+  c(node.body, st, "Statement")
+}
+base.ForInit = (node, st, c) => {
+  if (node.type == "VariableDeclaration") c(node, st)
+  else c(node, st, "Expression")
+}
+base.DebuggerStatement = ignore
+
+base.FunctionDeclaration = (node, st, c) => c(node, st, "Function")
+base.VariableDeclaration = (node, st, c) => {
+  for (let i = 0; i < node.declarations.length; ++i) {
+    let decl = node.declarations[i]
+    if (decl.init) c(decl.init, st, "Expression")
+  }
+}
+
+base.Function = (node, st, c) => c(node.body, st, "ScopeBody")
+base.ScopeBody = (node, st, c) => c(node, st, "Statement")
+
+base.Expression = skipThrough
+base.ThisExpression = ignore
+base.ArrayExpression = base.ArrayPattern =  (node, st, c) => {
+  for (let i = 0; i < node.elements.length; ++i) {
+    let elt = node.elements[i]
+    if (elt) c(elt, st, "Expression")
+  }
+}
+base.ObjectExpression = base.ObjectPattern = (node, st, c) => {
+  for (let i = 0; i < node.properties.length; ++i)
+    c(node.properties[i], st)
+}
+base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration
+base.SequenceExpression = base.TemplateLiteral = (node, st, c) => {
+  for (let i = 0; i < node.expressions.length; ++i)
+    c(node.expressions[i], st, "Expression")
+}
+base.UnaryExpression = base.UpdateExpression = (node, st, c) => {
+  c(node.argument, st, "Expression")
+}
+base.BinaryExpression = base.AssignmentExpression = base.AssignmentPattern = base.LogicalExpression = (node, st, c) => {
+  c(node.left, st, "Expression")
+  c(node.right, st, "Expression")
+}
+base.ConditionalExpression = (node, st, c) => {
+  c(node.test, st, "Expression")
+  c(node.consequent, st, "Expression")
+  c(node.alternate, st, "Expression")
+}
+base.NewExpression = base.CallExpression = (node, st, c) => {
+  c(node.callee, st, "Expression")
+  if (node.arguments) for (let i = 0; i < node.arguments.length; ++i)
+    c(node.arguments[i], st, "Expression")
+}
+base.MemberExpression = (node, st, c) => {
+  c(node.object, st, "Expression")
+  if (node.computed) c(node.property, st, "Expression")
+}
+base.ExportDeclaration = (node, st, c) => c(node.declaration, st)
+base.ImportDeclaration = (node, st, c) => {
+  for (let i = 0; i < node.specifiers.length; i++)
+    c(node.specifiers[i], st)
+}
+base.ImportSpecifier = base.ImportBatchSpecifier = base.Identifier = base.Literal = ignore
+
+base.TaggedTemplateExpression = (node, st, c) => {
+  c(node.tag, st, "Expression")
+  c(node.quasi, st)
+}
+base.ClassDeclaration = base.ClassExpression = (node, st, c) => {
+  if (node.superClass) c(node.superClass, st, "Expression")
+  for (let i = 0; i < node.body.body.length; i++)
+    c(node.body.body[i], st)
+}
+base.MethodDefinition = base.Property = (node, st, c) => {
+  if (node.computed) c(node.key, st, "Expression")
+  c(node.value, st, "Expression")
+}
+base.ComprehensionExpression = (node, st, c) => {
+  for (let i = 0; i < node.blocks.length; i++)
+    c(node.blocks[i].right, st, "Expression")
+  c(node.body, st, "Expression")
+}
diff --git a/test/index.html b/test/index.html
index ef80eb7b15..f729fd1c58 100644
--- a/test/index.html
+++ b/test/index.html
@@ -2,8 +2,8 @@
 <head>
   <meta charset="utf-8">
   <title>Acorn test suite</title>
-  <script src="../acorn.js"></script>
-  <script src="../acorn_loose.js"></script>
+  <script src="../dist/acorn.js"></script>
+  <script src="../dist/acorn_loose.js"></script>
   <script src="driver.js"></script>
   <script src="tests.js" charset="utf-8"></script>
   <script src="tests-harmony.js" charset="utf-8"></script>
diff --git a/test/run.js b/test/run.js
index 04f752dc3b..865eed5cd3 100644
--- a/test/run.js
+++ b/test/run.js
@@ -1,12 +1,16 @@
 (function() {
-  var driver;
+  var driver, acorn;
 
   if (typeof require !== "undefined") {
     driver = require("./driver.js");
     require("./tests.js");
     require("./tests-harmony.js");
+    require("babelify/node_modules/babel-core/register")
+    acorn = require("../src")
+    require("../src/loose")
   } else {
     driver = window;
+    acorn = window.acorn;
   }
 
   var htmlLog = typeof document === "object" && document.getElementById('log');
@@ -47,12 +51,12 @@
   var stats, modes = {
     Normal: {
       config: {
-        parse: (typeof require === "undefined" ? window.acorn : require("../acorn.js")).parse
+        parse: (typeof require === "undefined" ? window.acorn : require("../dist/acorn")).parse
       }
     },
     Loose: {
       config: {
-        parse: (typeof require === "undefined" ? window.acorn : require("../acorn_loose")).parse_dammit,
+        parse: (typeof require === "undefined" ? window.acorn : require("../dist/acorn_loose")).parse_dammit,
         loose: true,
         filter: function (test) {
           var opts = test.options || {};
diff --git a/util/walk.js b/util/walk.js
deleted file mode 100644
index 9dcddaa3e9..0000000000
--- a/util/walk.js
+++ /dev/null
@@ -1,359 +0,0 @@
-// AST walker module for Mozilla Parser API compatible trees
-
-(function(mod) {
-  if (typeof exports == "object" && typeof module == "object") return mod(exports); // CommonJS
-  if (typeof define == "function" && define.amd) return define(["exports"], mod); // AMD
-  mod((this.acorn || (this.acorn = {})).walk = {}); // Plain browser env
-})(function(exports) {
-  "use strict";
-
-  // A simple walk is one where you simply specify callbacks to be
-  // called on specific nodes. The last two arguments are optional. A
-  // simple use would be
-  //
-  //     walk.simple(myTree, {
-  //         Expression: function(node) { ... }
-  //     });
-  //
-  // to do something with all expressions. All Parser API node types
-  // can be used to identify node types, as well as Expression,
-  // Statement, and ScopeBody, which denote categories of nodes.
-  //
-  // The base argument can be used to pass a custom (recursive)
-  // walker, and state can be used to give this walked an initial
-  // state.
-  exports.simple = function(node, visitors, base, state) {
-    if (!base) base = exports.base;
-    function c(node, st, override) {
-      var type = override || node.type, found = visitors[type];
-      base[type](node, st, c);
-      if (found) found(node, st);
-    }
-    c(node, state);
-  };
-
-  // An ancestor walk builds up an array of ancestor nodes (including
-  // the current node) and passes them to the callback as the state parameter.
-  exports.ancestor = function(node, visitors, base, state) {
-    if (!base) base = exports.base;
-    if (!state) state = [];
-    function c(node, st, override) {
-      var type = override || node.type, found = visitors[type];
-      if (node != st[st.length - 1]) {
-        st = st.slice();
-        st.push(node);
-      }
-      base[type](node, st, c);
-      if (found) found(node, st);
-    }
-    c(node, state);
-  };
-
-  // A recursive walk is one where your functions override the default
-  // walkers. They can modify and replace the state parameter that's
-  // threaded through the walk, and can opt how and whether to walk
-  // their child nodes (by calling their third argument on these
-  // nodes).
-  exports.recursive = function(node, state, funcs, base) {
-    var visitor = funcs ? exports.make(funcs, base) : base;
-    function c(node, st, override) {
-      visitor[override || node.type](node, st, c);
-    }
-    c(node, state);
-  };
-
-  function makeTest(test) {
-    if (typeof test == "string")
-      return function(type) { return type == test; };
-    else if (!test)
-      return function() { return true; };
-    else
-      return test;
-  }
-
-  function Found(node, state) { this.node = node; this.state = state; }
-
-  // Find a node with a given start, end, and type (all are optional,
-  // null can be used as wildcard). Returns a {node, state} object, or
-  // undefined when it doesn't find a matching node.
-  exports.findNodeAt = function(node, start, end, test, base, state) {
-    test = makeTest(test);
-    try {
-      if (!base) base = exports.base;
-      var c = function(node, st, override) {
-        var type = override || node.type;
-        if ((start == null || node.start <= start) &&
-            (end == null || node.end >= end))
-          base[type](node, st, c);
-        if (test(type, node) &&
-            (start == null || node.start == start) &&
-            (end == null || node.end == end))
-          throw new Found(node, st);
-      };
-      c(node, state);
-    } catch (e) {
-      if (e instanceof Found) return e;
-      throw e;
-    }
-  };
-
-  // Find the innermost node of a given type that contains the given
-  // position. Interface similar to findNodeAt.
-  exports.findNodeAround = function(node, pos, test, base, state) {
-    test = makeTest(test);
-    try {
-      if (!base) base = exports.base;
-      var c = function(node, st, override) {
-        var type = override || node.type;
-        if (node.start > pos || node.end < pos) return;
-        base[type](node, st, c);
-        if (test(type, node)) throw new Found(node, st);
-      };
-      c(node, state);
-    } catch (e) {
-      if (e instanceof Found) return e;
-      throw e;
-    }
-  };
-
-  // Find the outermost matching node after a given position.
-  exports.findNodeAfter = function(node, pos, test, base, state) {
-    test = makeTest(test);
-    try {
-      if (!base) base = exports.base;
-      var c = function(node, st, override) {
-        if (node.end < pos) return;
-        var type = override || node.type;
-        if (node.start >= pos && test(type, node)) throw new Found(node, st);
-        base[type](node, st, c);
-      };
-      c(node, state);
-    } catch (e) {
-      if (e instanceof Found) return e;
-      throw e;
-    }
-  };
-
-  // Find the outermost matching node before a given position.
-  exports.findNodeBefore = function(node, pos, test, base, state) {
-    test = makeTest(test);
-    if (!base) base = exports.base;
-    var max;
-    var c = function(node, st, override) {
-      if (node.start > pos) return;
-      var type = override || node.type;
-      if (node.end <= pos && (!max || max.node.end < node.end) && test(type, node))
-        max = new Found(node, st);
-      base[type](node, st, c);
-    };
-    c(node, state);
-    return max;
-  };
-
-  // Used to create a custom walker. Will fill in all missing node
-  // type properties with the defaults.
-  exports.make = function(funcs, base) {
-    if (!base) base = exports.base;
-    var visitor = {};
-    for (var type in base) visitor[type] = base[type];
-    for (var type in funcs) visitor[type] = funcs[type];
-    return visitor;
-  };
-
-  function skipThrough(node, st, c) { c(node, st); }
-  function ignore(_node, _st, _c) {}
-
-  // Node walkers.
-
-  var base = exports.base = {};
-  base.Program = base.BlockStatement = function(node, st, c) {
-    for (var i = 0; i < node.body.length; ++i)
-      c(node.body[i], st, "Statement");
-  };
-  base.Statement = skipThrough;
-  base.EmptyStatement = ignore;
-  base.ExpressionStatement = base.ParenthesizedExpression = function(node, st, c) {
-    c(node.expression, st, "Expression");
-  };
-  base.IfStatement = function(node, st, c) {
-    c(node.test, st, "Expression");
-    c(node.consequent, st, "Statement");
-    if (node.alternate) c(node.alternate, st, "Statement");
-  };
-  base.LabeledStatement = function(node, st, c) {
-    c(node.body, st, "Statement");
-  };
-  base.BreakStatement = base.ContinueStatement = ignore;
-  base.WithStatement = function(node, st, c) {
-    c(node.object, st, "Expression");
-    c(node.body, st, "Statement");
-  };
-  base.SwitchStatement = function(node, st, c) {
-    c(node.discriminant, st, "Expression");
-    for (var i = 0; i < node.cases.length; ++i) {
-      var cs = node.cases[i];
-      if (cs.test) c(cs.test, st, "Expression");
-      for (var j = 0; j < cs.consequent.length; ++j)
-        c(cs.consequent[j], st, "Statement");
-    }
-  };
-  base.ReturnStatement = base.YieldExpression = function(node, st, c) {
-    if (node.argument) c(node.argument, st, "Expression");
-  };
-  base.ThrowStatement = base.SpreadElement = base.RestElement = function(node, st, c) {
-    c(node.argument, st, "Expression");
-  };
-  base.TryStatement = function(node, st, c) {
-    c(node.block, st, "Statement");
-    if (node.handler) c(node.handler.body, st, "ScopeBody");
-    if (node.finalizer) c(node.finalizer, st, "Statement");
-  };
-  base.WhileStatement = function(node, st, c) {
-    c(node.test, st, "Expression");
-    c(node.body, st, "Statement");
-  };
-  base.DoWhileStatement = base.WhileStatement;
-  base.ForStatement = function(node, st, c) {
-    if (node.init) c(node.init, st, "ForInit");
-    if (node.test) c(node.test, st, "Expression");
-    if (node.update) c(node.update, st, "Expression");
-    c(node.body, st, "Statement");
-  };
-  base.ForInStatement = base.ForOfStatement = function(node, st, c) {
-    c(node.left, st, "ForInit");
-    c(node.right, st, "Expression");
-    c(node.body, st, "Statement");
-  };
-  base.ForInit = function(node, st, c) {
-    if (node.type == "VariableDeclaration") c(node, st);
-    else c(node, st, "Expression");
-  };
-  base.DebuggerStatement = ignore;
-
-  base.FunctionDeclaration = function(node, st, c) {
-    c(node, st, "Function");
-  };
-  base.VariableDeclaration = function(node, st, c) {
-    for (var i = 0; i < node.declarations.length; ++i) {
-      var decl = node.declarations[i];
-      if (decl.init) c(decl.init, st, "Expression");
-    }
-  };
-
-  base.Function = function(node, st, c) {
-    c(node.body, st, "ScopeBody");
-  };
-  base.ScopeBody = function(node, st, c) {
-    c(node, st, "Statement");
-  };
-
-  base.Expression = skipThrough;
-  base.ThisExpression = ignore;
-  base.ArrayExpression = base.ArrayPattern =  function(node, st, c) {
-    for (var i = 0; i < node.elements.length; ++i) {
-      var elt = node.elements[i];
-      if (elt) c(elt, st, "Expression");
-    }
-  };
-  base.ObjectExpression = base.ObjectPattern = function(node, st, c) {
-    for (var i = 0; i < node.properties.length; ++i)
-      c(node.properties[i], st);
-  };
-  base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration;
-  base.SequenceExpression = base.TemplateLiteral = function(node, st, c) {
-    for (var i = 0; i < node.expressions.length; ++i)
-      c(node.expressions[i], st, "Expression");
-  };
-  base.UnaryExpression = base.UpdateExpression = function(node, st, c) {
-    c(node.argument, st, "Expression");
-  };
-  base.BinaryExpression = base.AssignmentExpression = base.AssignmentPattern = base.LogicalExpression = function(node, st, c) {
-    c(node.left, st, "Expression");
-    c(node.right, st, "Expression");
-  };
-  base.ConditionalExpression = function(node, st, c) {
-    c(node.test, st, "Expression");
-    c(node.consequent, st, "Expression");
-    c(node.alternate, st, "Expression");
-  };
-  base.NewExpression = base.CallExpression = function(node, st, c) {
-    c(node.callee, st, "Expression");
-    if (node.arguments) for (var i = 0; i < node.arguments.length; ++i)
-      c(node.arguments[i], st, "Expression");
-  };
-  base.MemberExpression = function(node, st, c) {
-    c(node.object, st, "Expression");
-    if (node.computed) c(node.property, st, "Expression");
-  };
-  base.ExportDeclaration = function (node, st, c) {
-    c(node.declaration, st);
-  };
-  base.ImportDeclaration = function (node, st, c) {
-    node.specifiers.forEach(function (specifier) {
-      c(specifier, st);
-    });
-  };
-  base.ImportSpecifier = base.ImportBatchSpecifier = base.Identifier = base.Literal = ignore;
-
-  base.TaggedTemplateExpression = function(node, st, c) {
-    c(node.tag, st, "Expression");
-    c(node.quasi, st);
-  };
-  base.ClassDeclaration = base.ClassExpression = function(node, st, c) {
-    if (node.superClass) c(node.superClass, st, "Expression");
-    for (var i = 0; i < node.body.body.length; i++)
-      c(node.body.body[i], st);
-  };
-  base.MethodDefinition = base.Property = function(node, st, c) {
-    if (node.computed) c(node.key, st, "Expression");
-    c(node.value, st, "Expression");
-  };
-  base.ComprehensionExpression = function(node, st, c) {
-    for (var i = 0; i < node.blocks.length; i++)
-      c(node.blocks[i].right, st, "Expression");
-    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) {
-    return {vars: Object.create(null), prev: prev, isCatch: isCatch};
-  }
-  function normalScope(scope) {
-    while (scope.isCatch) scope = scope.prev;
-    return scope;
-  }
-  exports.scopeVisitor = exports.make({
-    Function: function(node, scope, c) {
-      var inner = makeScope(scope);
-      for (var i = 0; i < node.params.length; ++i)
-        inner.vars[node.params[i].name] = {type: "argument", node: node.params[i]};
-      if (node.id) {
-        var decl = node.type == "FunctionDeclaration";
-        (decl ? normalScope(scope) : inner).vars[node.id.name] =
-          {type: decl ? "function" : "function name", node: node.id};
-      }
-      c(node.body, inner, "ScopeBody");
-    },
-    TryStatement: function(node, scope, c) {
-      c(node.block, scope, "Statement");
-      if (node.handler) {
-        var inner = makeScope(scope, true);
-        inner.vars[node.handler.param.name] = {type: "catch clause", node: node.handler.param};
-        c(node.handler.body, inner, "ScopeBody");
-      }
-      if (node.finalizer) c(node.finalizer, scope, "Statement");
-    },
-    VariableDeclaration: function(node, scope, c) {
-      var target = normalScope(scope);
-      for (var i = 0; i < node.declarations.length; ++i) {
-        var decl = node.declarations[i];
-        target.vars[decl.id.name] = {type: "var", node: decl.id};
-        if (decl.init) c(decl.init, scope, "Expression");
-      }
-    }
-  });
-
-});

From f538706db39f20cb0d8140d334578c4a46557a65 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 16:59:11 +0100
Subject: [PATCH 29/43] Code style -- less semicolons, more let variables

---
 src/expression.js       | 777 +++++++++++++++++-----------------------
 src/identifier.js       |  90 ++---
 src/location.js         |  20 +-
 src/loose/expression.js | 701 +++++++++++++++---------------------
 src/loose/parseutil.js  | 134 +++----
 src/loose/state.js      |  16 +-
 src/loose/statement.js  | 502 ++++++++++++++++----------
 src/loose/tokenize.js   |  88 ++---
 src/lval.js             | 176 ++++-----
 src/node.js             |  54 +--
 src/options.js          |   6 +-
 src/parseutil.js        |  50 +--
 src/statement.js        | 628 +++++++++++++++++++-------------
 src/tokencontext.js     |  72 ++--
 src/tokenize.js         | 615 +++++++++++++++----------------
 15 files changed, 1966 insertions(+), 1963 deletions(-)

diff --git a/src/expression.js b/src/expression.js
index af0f229859..82eda65434 100644
--- a/src/expression.js
+++ b/src/expression.js
@@ -1,5 +1,3 @@
-// ## 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
@@ -31,28 +29,28 @@ const pp = Parser.prototype
 // strict mode, init properties are also not allowed to be repeated.
 
 pp.checkPropClash = function(prop, propHash) {
-  if (this.options.ecmaVersion >= 6) return;
-  var key = prop.key, name;
+  if (this.options.ecmaVersion >= 6) return
+  let key = prop.key, name
   switch (key.type) {
-  case "Identifier": name = key.name; break;
-  case "Literal": name = String(key.value); break;
-  default: return;
+  case "Identifier": name = key.name; break
+  case "Literal": name = String(key.value); break
+  default: return
   }
-  var kind = prop.kind || "init", other;
+  let kind = prop.kind || "init", other
   if (has(propHash, name)) {
-    other = propHash[name];
-    var isGetSet = kind !== "init";
+    other = propHash[name]
+    let isGetSet = kind !== "init"
     if ((this.strict || isGetSet) && other[kind] || !(isGetSet ^ other.init))
-      this.raise(key.start, "Redefinition of property");
+      this.raise(key.start, "Redefinition of property")
   } else {
     other = propHash[name] = {
       init: false,
       get: false,
       set: false
-    };
+    }
   }
-  other[kind] = true;
-};
+  other[kind] = true
+}
 
 // ### Expression parsing
 
@@ -70,72 +68,72 @@ pp.checkPropClash = function(prop, propHash) {
 // delayed syntax error at correct position).
 
 pp.parseExpression = function(noIn, refShorthandDefaultPos) {
-  var start = this.markPosition();
-  var expr = this.parseMaybeAssign(noIn, refShorthandDefaultPos);
+  let start = this.markPosition()
+  let expr = this.parseMaybeAssign(noIn, refShorthandDefaultPos)
   if (this.type === tt.comma) {
-    var node = this.startNodeAt(start);
-    node.expressions = [expr];
-    while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn, refShorthandDefaultPos));
-    return this.finishNode(node, "SequenceExpression");
+    let node = this.startNodeAt(start)
+    node.expressions = [expr]
+    while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn, refShorthandDefaultPos))
+    return this.finishNode(node, "SequenceExpression")
   }
-  return expr;
-};
+  return expr
+}
 
 // Parse an assignment expression. This includes applications of
 // operators like `+=`.
 
 pp.parseMaybeAssign = function(noIn, refShorthandDefaultPos) {
-  if (this.type == tt._yield && this.inGenerator) return this.parseYield();
+  if (this.type == tt._yield && this.inGenerator) return this.parseYield()
 
-  var failOnShorthandAssign;
+  let failOnShorthandAssign
   if (!refShorthandDefaultPos) {
-    refShorthandDefaultPos = {start: 0};
-    failOnShorthandAssign = true;
+    refShorthandDefaultPos = {start: 0}
+    failOnShorthandAssign = true
   } else {
-    failOnShorthandAssign = false;
+    failOnShorthandAssign = false
   }
-  var start = this.markPosition();
-  var left = this.parseMaybeConditional(noIn, refShorthandDefaultPos);
+  let start = this.markPosition()
+  let left = this.parseMaybeConditional(noIn, refShorthandDefaultPos)
   if (this.type.isAssign) {
-    var node = this.startNodeAt(start);
-    node.operator = this.value;
-    node.left = this.type === tt.eq ? this.toAssignable(left) : left;
+    let node = this.startNodeAt(start)
+    node.operator = this.value
+    node.left = this.type === tt.eq ? this.toAssignable(left) : left
     refShorthandDefaultPos.start = 0; // reset because shorthand default was used correctly
-    this.checkLVal(left);
-    this.next();
-    node.right = this.parseMaybeAssign(noIn);
-    return this.finishNode(node, "AssignmentExpression");
+    this.checkLVal(left)
+    this.next()
+    node.right = this.parseMaybeAssign(noIn)
+    return this.finishNode(node, "AssignmentExpression")
   } else if (failOnShorthandAssign && refShorthandDefaultPos.start) {
-    this.unexpected(refShorthandDefaultPos.start);
+    this.unexpected(refShorthandDefaultPos.start)
   }
-  return left;
-};
+  return left
+}
 
 // Parse a ternary conditional (`?:`) operator.
 
 pp.parseMaybeConditional = function(noIn, refShorthandDefaultPos) {
-  var start = this.markPosition();
-  var expr = this.parseExprOps(noIn, refShorthandDefaultPos);
-  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
+  let start = this.markPosition()
+  let expr = this.parseExprOps(noIn, refShorthandDefaultPos)
+  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr
   if (this.eat(tt.question)) {
-    var node = this.startNodeAt(start);
-    node.test = expr;
-    node.consequent = this.parseMaybeAssign();
-    this.expect(tt.colon);
-    node.alternate = this.parseMaybeAssign(noIn);
-    return this.finishNode(node, "ConditionalExpression");
+    let node = this.startNodeAt(start)
+    node.test = expr
+    node.consequent = this.parseMaybeAssign()
+    this.expect(tt.colon)
+    node.alternate = this.parseMaybeAssign(noIn)
+    return this.finishNode(node, "ConditionalExpression")
   }
-  return expr;
-};
+  return expr
+}
 
 // Start the precedence parser.
 
 pp.parseExprOps = function(noIn, refShorthandDefaultPos) {
-  var start = this.markPosition();
-  var expr = this.parseMaybeUnary(refShorthandDefaultPos);
-  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-  return this.parseExprOp(expr, start, -1, noIn);
-};
+  let start = this.markPosition()
+  let expr = this.parseMaybeUnary(refShorthandDefaultPos)
+  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr
+  return this.parseExprOp(expr, start, -1, noIn)
+}
 
 // Parse binary operators with the operator precedence parsing
 // algorithm. `left` is the left-hand side of the operator.
@@ -144,89 +142,89 @@ pp.parseExprOps = function(noIn, refShorthandDefaultPos) {
 // operator that has a lower precedence than the set it is parsing.
 
 pp.parseExprOp = function(left, leftStart, minPrec, noIn) {
-  var prec = this.type.binop;
+  let prec = this.type.binop
   if (prec != null && (!noIn || this.type !== tt._in)) {
     if (prec > minPrec) {
-      var node = this.startNodeAt(leftStart);
-      node.left = left;
-      node.operator = this.value;
-      var op = this.type;
-      this.next();
-      var start = this.markPosition();
-      node.right = this.parseExprOp(this.parseMaybeUnary(), start, prec, noIn);
-      this.finishNode(node, (op === tt.logicalOR || op === tt.logicalAND) ? "LogicalExpression" : "BinaryExpression");
-      return this.parseExprOp(node, leftStart, minPrec, noIn);
+      let node = this.startNodeAt(leftStart)
+      node.left = left
+      node.operator = this.value
+      let op = this.type
+      this.next()
+      let start = this.markPosition()
+      node.right = this.parseExprOp(this.parseMaybeUnary(), start, prec, noIn)
+      this.finishNode(node, (op === tt.logicalOR || op === tt.logicalAND) ? "LogicalExpression" : "BinaryExpression")
+      return this.parseExprOp(node, leftStart, minPrec, noIn)
     }
   }
-  return left;
-};
+  return left
+}
 
 // Parse unary operators, both prefix and postfix.
 
 pp.parseMaybeUnary = function(refShorthandDefaultPos) {
   if (this.type.prefix) {
-    var node = this.startNode(), update = this.type === tt.incDec;
-    node.operator = this.value;
-    node.prefix = true;
-    this.next();
-    node.argument = this.parseMaybeUnary();
-    if (refShorthandDefaultPos && refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
-    if (update) this.checkLVal(node.argument);
+    let node = this.startNode(), update = this.type === tt.incDec
+    node.operator = this.value
+    node.prefix = true
+    this.next()
+    node.argument = this.parseMaybeUnary()
+    if (refShorthandDefaultPos && refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start)
+    if (update) this.checkLVal(node.argument)
     else if (this.strict && node.operator === "delete" &&
              node.argument.type === "Identifier")
-      this.raise(node.start, "Deleting local variable in strict mode");
-    return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+      this.raise(node.start, "Deleting local variable in strict mode")
+    return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression")
   }
-  var start = this.markPosition();
-  var expr = this.parseExprSubscripts(refShorthandDefaultPos);
-  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
+  let start = this.markPosition()
+  let expr = this.parseExprSubscripts(refShorthandDefaultPos)
+  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr
   while (this.type.postfix && !this.canInsertSemicolon()) {
-    var node = this.startNodeAt(start);
-    node.operator = this.value;
-    node.prefix = false;
-    node.argument = expr;
-    this.checkLVal(expr);
-    this.next();
-    expr = this.finishNode(node, "UpdateExpression");
+    let node = this.startNodeAt(start)
+    node.operator = this.value
+    node.prefix = false
+    node.argument = expr
+    this.checkLVal(expr)
+    this.next()
+    expr = this.finishNode(node, "UpdateExpression")
   }
-  return expr;
-};
+  return expr
+}
 
 // Parse call, dot, and `[]`-subscript expressions.
 
 pp.parseExprSubscripts = function(refShorthandDefaultPos) {
-  var start = this.markPosition();
-  var expr = this.parseExprAtom(refShorthandDefaultPos);
-  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-  return this.parseSubscripts(expr, start);
-};
+  let start = this.markPosition()
+  let expr = this.parseExprAtom(refShorthandDefaultPos)
+  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr
+  return this.parseSubscripts(expr, start)
+}
 
 pp.parseSubscripts = function(base, start, noCalls) {
   if (this.eat(tt.dot)) {
-    var node = this.startNodeAt(start);
-    node.object = base;
-    node.property = this.parseIdent(true);
-    node.computed = false;
-    return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls);
+    let node = this.startNodeAt(start)
+    node.object = base
+    node.property = this.parseIdent(true)
+    node.computed = false
+    return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls)
   } else if (this.eat(tt.bracketL)) {
-    var node = this.startNodeAt(start);
-    node.object = base;
-    node.property = this.parseExpression();
-    node.computed = true;
-    this.expect(tt.bracketR);
-    return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls);
+    let node = this.startNodeAt(start)
+    node.object = base
+    node.property = this.parseExpression()
+    node.computed = true
+    this.expect(tt.bracketR)
+    return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls)
   } else if (!noCalls && this.eat(tt.parenL)) {
-    var node = this.startNodeAt(start);
-    node.callee = base;
-    node.arguments = this.parseExprList(tt.parenR, false);
-    return this.parseSubscripts(this.finishNode(node, "CallExpression"), start, noCalls);
+    let node = this.startNodeAt(start)
+    node.callee = base
+    node.arguments = this.parseExprList(tt.parenR, false)
+    return this.parseSubscripts(this.finishNode(node, "CallExpression"), start, noCalls)
   } else if (this.type === tt.backQuote) {
-    var node = this.startNodeAt(start);
-    node.tag = base;
-    node.quasi = this.parseTemplate();
-    return this.parseSubscripts(this.finishNode(node, "TaggedTemplateExpression"), start, noCalls);
-  } return base;
-};
+    let node = this.startNodeAt(start)
+    node.tag = base
+    node.quasi = this.parseTemplate()
+    return this.parseSubscripts(this.finishNode(node, "TaggedTemplateExpression"), start, noCalls)
+  } return base
+}
 
 // Parse an atomic expression — either a single token that is an
 // expression, an expression started by a keyword like `function` or
@@ -234,146 +232,147 @@ pp.parseSubscripts = function(base, start, noCalls) {
 // or `{}`.
 
 pp.parseExprAtom = function(refShorthandDefaultPos) {
+  let node
   switch (this.type) {
   case tt._this:
   case tt._super:
-    var type = this.type === tt._this ? "ThisExpression" : "SuperExpression";
-    var node = this.startNode();
-    this.next();
-    return this.finishNode(node, type);
+    let type = this.type === tt._this ? "ThisExpression" : "SuperExpression"
+    node = this.startNode()
+    this.next()
+    return this.finishNode(node, type)
 
   case tt._yield:
-    if (this.inGenerator) unexpected();
+    if (this.inGenerator) unexpected()
 
   case tt.name:
-    var start = this.markPosition();
-    var id = this.parseIdent(this.type !== tt.name);
+    let start = this.markPosition()
+    let id = this.parseIdent(this.type !== tt.name)
     if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
-      return this.parseArrowExpression(this.startNodeAt(start), [id]);
+      return this.parseArrowExpression(this.startNodeAt(start), [id])
     }
-    return id;
+    return id
 
   case tt.regexp:
-    var value = this.value;
-    var node = this.parseLiteral(value.value);
-    node.regex = {pattern: value.pattern, flags: value.flags};
-    return node;
+    let value = this.value
+    node = this.parseLiteral(value.value)
+    node.regex = {pattern: value.pattern, flags: value.flags}
+    return node
 
   case tt.num: case tt.string:
-    return this.parseLiteral(this.value);
+    return this.parseLiteral(this.value)
 
   case tt._null: case tt._true: case tt._false:
-    var node = this.startNode();
-    node.value = this.type === tt._null ? null : this.type === tt._true;
-    node.raw = this.type.keyword;
-    this.next();
-    return this.finishNode(node, "Literal");
+    node = this.startNode()
+    node.value = this.type === tt._null ? null : this.type === tt._true
+    node.raw = this.type.keyword
+    this.next()
+    return this.finishNode(node, "Literal")
 
   case tt.parenL:
-    return this.parseParenAndDistinguishExpression();
+    return this.parseParenAndDistinguishExpression()
 
   case tt.bracketL:
-    var node = this.startNode();
-    this.next();
+    node = this.startNode()
+    this.next()
     // check whether this is array comprehension or regular array
     if (this.options.ecmaVersion >= 7 && this.type === tt._for) {
-      return this.parseComprehension(node, false);
+      return this.parseComprehension(node, false)
     }
-    node.elements = this.parseExprList(tt.bracketR, true, true, refShorthandDefaultPos);
-    return this.finishNode(node, "ArrayExpression");
+    node.elements = this.parseExprList(tt.bracketR, true, true, refShorthandDefaultPos)
+    return this.finishNode(node, "ArrayExpression")
 
   case tt.braceL:
-    return this.parseObj(false, refShorthandDefaultPos);
+    return this.parseObj(false, refShorthandDefaultPos)
 
   case tt._function:
-    var node = this.startNode();
-    this.next();
-    return this.parseFunction(node, false);
+    node = this.startNode()
+    this.next()
+    return this.parseFunction(node, false)
 
   case tt._class:
-    return this.parseClass(this.startNode(), false);
+    return this.parseClass(this.startNode(), false)
 
   case tt._new:
-    return this.parseNew();
+    return this.parseNew()
 
   case tt.backQuote:
-    return this.parseTemplate();
+    return this.parseTemplate()
 
   default:
-    this.unexpected();
+    this.unexpected()
   }
-};
+}
 
 pp.parseLiteral = function(value) {
-  var node = this.startNode();
-  node.value = value;
-  node.raw = this.input.slice(this.start, this.end);
-  this.next();
-  return this.finishNode(node, "Literal");
-};
+  let node = this.startNode()
+  node.value = value
+  node.raw = this.input.slice(this.start, this.end)
+  this.next()
+  return this.finishNode(node, "Literal")
+}
 
 pp.parseParenExpression = function() {
-  this.expect(tt.parenL);
-  var val = this.parseExpression();
-  this.expect(tt.parenR);
-  return val;
-};
+  this.expect(tt.parenL)
+  let val = this.parseExpression()
+  this.expect(tt.parenR)
+  return val
+}
 
 pp.parseParenAndDistinguishExpression = function() {
-  var start = this.markPosition(), val;
+  let start = this.markPosition(), val
   if (this.options.ecmaVersion >= 6) {
-    this.next();
+    this.next()
 
     if (this.options.ecmaVersion >= 7 && this.type === tt._for) {
-      return this.parseComprehension(this.startNodeAt(start), true);
+      return this.parseComprehension(this.startNodeAt(start), true)
     }
 
-    var innerStart = this.markPosition(), exprList = [], first = true;
-    var refShorthandDefaultPos = {start: 0}, spreadStart, innerParenStart;
+    let innerStart = this.markPosition(), exprList = [], first = true
+    let refShorthandDefaultPos = {start: 0}, spreadStart, innerParenStart
     while (this.type !== tt.parenR) {
-      first ? first = false : this.expect(tt.comma);
+      first ? first = false : this.expect(tt.comma)
       if (this.type === tt.ellipsis) {
-        spreadStart = this.start;
-        exprList.push(this.parseRest());
-        break;
+        spreadStart = this.start
+        exprList.push(this.parseRest())
+        break
       } else {
         if (this.type === tt.parenL && !innerParenStart) {
-          innerParenStart = this.start;
+          innerParenStart = this.start
         }
-        exprList.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
+        exprList.push(this.parseMaybeAssign(false, refShorthandDefaultPos))
       }
     }
-    var innerEnd = this.markPosition();
-    this.expect(tt.parenR);
+    let innerEnd = this.markPosition()
+    this.expect(tt.parenR)
 
     if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
-      if (innerParenStart) this.unexpected(innerParenStart);
-      return this.parseArrowExpression(this.startNodeAt(start), exprList);
+      if (innerParenStart) this.unexpected(innerParenStart)
+      return this.parseArrowExpression(this.startNodeAt(start), exprList)
     }
 
-    if (!exprList.length) this.unexpected(this.lastTokStart);
-    if (spreadStart) this.unexpected(spreadStart);
-    if (refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
+    if (!exprList.length) this.unexpected(this.lastTokStart)
+    if (spreadStart) this.unexpected(spreadStart)
+    if (refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start)
 
     if (exprList.length > 1) {
-      val = this.startNodeAt(innerStart);
-      val.expressions = exprList;
-      this.finishNodeAt(val, "SequenceExpression", innerEnd);
+      val = this.startNodeAt(innerStart)
+      val.expressions = exprList
+      this.finishNodeAt(val, "SequenceExpression", innerEnd)
     } else {
-      val = exprList[0];
+      val = exprList[0]
     }
   } else {
-    val = this.parseParenExpression();
+    val = this.parseParenExpression()
   }
 
   if (this.options.preserveParens) {
-    var par = this.startNodeAt(start);
-    par.expression = val;
-    return this.finishNode(par, "ParenthesizedExpression");
+    let par = this.startNodeAt(start)
+    par.expression = val
+    return this.finishNode(par, "ParenthesizedExpression")
   } else {
-    return val;
+    return val
   }
-};
+}
 
 // New's precedence is slightly tricky. It must allow its argument
 // to be a `[]` or dot subscript expression, but not a call — at
@@ -382,187 +381,187 @@ pp.parseParenAndDistinguishExpression = function() {
 const empty = []
 
 pp.parseNew = function() {
-  var node = this.startNode();
-  this.next();
-  var start = this.markPosition();
-  node.callee = this.parseSubscripts(this.parseExprAtom(), start, true);
-  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false);
-  else node.arguments = empty;
-  return this.finishNode(node, "NewExpression");
-};
+  let node = this.startNode()
+  this.next()
+  let start = this.markPosition()
+  node.callee = this.parseSubscripts(this.parseExprAtom(), start, true)
+  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false)
+  else node.arguments = empty
+  return this.finishNode(node, "NewExpression")
+}
 
 // Parse template expression.
 
 pp.parseTemplateElement = function() {
-  var elem = this.startNode();
+  let elem = this.startNode()
   elem.value = {
     raw: this.input.slice(this.start, this.end),
     cooked: this.value
-  };
-  this.next();
-  elem.tail = this.type === tt.backQuote;
-  return this.finishNode(elem, "TemplateElement");
-};
+  }
+  this.next()
+  elem.tail = this.type === tt.backQuote
+  return this.finishNode(elem, "TemplateElement")
+}
 
 pp.parseTemplate = function() {
-  var node = this.startNode();
-  this.next();
-  node.expressions = [];
-  var curElt = this.parseTemplateElement();
-  node.quasis = [curElt];
+  let node = this.startNode()
+  this.next()
+  node.expressions = []
+  let curElt = this.parseTemplateElement()
+  node.quasis = [curElt]
   while (!curElt.tail) {
-    this.expect(tt.dollarBraceL);
-    node.expressions.push(this.parseExpression());
-    this.expect(tt.braceR);
-    node.quasis.push(curElt = this.parseTemplateElement());
+    this.expect(tt.dollarBraceL)
+    node.expressions.push(this.parseExpression())
+    this.expect(tt.braceR)
+    node.quasis.push(curElt = this.parseTemplateElement())
   }
-  this.next();
-  return this.finishNode(node, "TemplateLiteral");
-};
+  this.next()
+  return this.finishNode(node, "TemplateLiteral")
+}
 
 // Parse an object literal or binding pattern.
 
 pp.parseObj = function(isPattern, refShorthandDefaultPos) {
-  var node = this.startNode(), first = true, propHash = {};
-  node.properties = [];
-  this.next();
+  let node = this.startNode(), first = true, propHash = {}
+  node.properties = []
+  this.next()
   while (!this.eat(tt.braceR)) {
     if (!first) {
-      this.expect(tt.comma);
-      if (this.afterTrailingComma(tt.braceR)) break;
-    } else first = false;
+      this.expect(tt.comma)
+      if (this.afterTrailingComma(tt.braceR)) break
+    } else first = false
 
-    var prop = this.startNode(), isGenerator, start;
+    let prop = this.startNode(), isGenerator, start
     if (this.options.ecmaVersion >= 6) {
-      prop.method = false;
-      prop.shorthand = false;
+      prop.method = false
+      prop.shorthand = false
       if (isPattern || refShorthandDefaultPos)
-        start = this.markPosition();
+        start = this.markPosition()
       if (!isPattern)
-        isGenerator = this.eat(tt.star);
+        isGenerator = this.eat(tt.star)
     }
-    this.parsePropertyName(prop);
+    this.parsePropertyName(prop)
     if (this.eat(tt.colon)) {
-      prop.value = isPattern ? this.parseMaybeDefault() : this.parseMaybeAssign(false, refShorthandDefaultPos);
-      prop.kind = "init";
+      prop.value = isPattern ? this.parseMaybeDefault() : this.parseMaybeAssign(false, refShorthandDefaultPos)
+      prop.kind = "init"
     } else if (this.options.ecmaVersion >= 6 && this.type === tt.parenL) {
-      if (isPattern) this.unexpected();
-      prop.kind = "init";
-      prop.method = true;
-      prop.value = this.parseMethod(isGenerator);
+      if (isPattern) this.unexpected()
+      prop.kind = "init"
+      prop.method = true
+      prop.value = this.parseMethod(isGenerator)
     } else if (this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
                (prop.key.name === "get" || prop.key.name === "set") &&
                (this.type != tt.comma && this.type != tt.braceR)) {
-      if (isGenerator || isPattern) this.unexpected();
-      prop.kind = prop.key.name;
-      this.parsePropertyName(prop);
-      prop.value = this.parseMethod(false);
+      if (isGenerator || isPattern) this.unexpected()
+      prop.kind = prop.key.name
+      this.parsePropertyName(prop)
+      prop.value = this.parseMethod(false)
     } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
-      prop.kind = "init";
+      prop.kind = "init"
       if (isPattern) {
         if (this.isKeyword(prop.key.name) ||
             (this.strict && (reservedWords.strictBind(prop.key.name) || reservedWords.strict(prop.key.name))) ||
             (!this.options.allowReserved && this.isReservedWord(prop.key.name)))
-          this.raise(prop.key.start, "Binding " + prop.key.name);
-        prop.value = this.parseMaybeDefault(start, prop.key);
+          this.raise(prop.key.start, "Binding " + prop.key.name)
+        prop.value = this.parseMaybeDefault(start, prop.key)
       } else if (this.type === tt.eq && refShorthandDefaultPos) {
         if (!refShorthandDefaultPos.start)
-          refShorthandDefaultPos.start = this.start;
-        prop.value = this.parseMaybeDefault(start, prop.key);
+          refShorthandDefaultPos.start = this.start
+        prop.value = this.parseMaybeDefault(start, prop.key)
       } else {
-        prop.value = prop.key;
+        prop.value = prop.key
       }
-      prop.shorthand = true;
-    } else this.unexpected();
+      prop.shorthand = true
+    } else this.unexpected()
 
-    this.checkPropClash(prop, propHash);
-    node.properties.push(this.finishNode(prop, "Property"));
+    this.checkPropClash(prop, propHash)
+    node.properties.push(this.finishNode(prop, "Property"))
   }
-  return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");
-};
+  return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression")
+}
 
 pp.parsePropertyName = function(prop) {
   if (this.options.ecmaVersion >= 6) {
     if (this.eat(tt.bracketL)) {
-      prop.computed = true;
-      prop.key = this.parseExpression();
-      this.expect(tt.bracketR);
-      return;
+      prop.computed = true
+      prop.key = this.parseExpression()
+      this.expect(tt.bracketR)
+      return
     } else {
-      prop.computed = false;
+      prop.computed = false
     }
   }
-  prop.key = (this.type === tt.num || this.type === tt.string) ? this.parseExprAtom() : this.parseIdent(true);
-};
+  prop.key = (this.type === tt.num || this.type === tt.string) ? this.parseExprAtom() : this.parseIdent(true)
+}
 
 // Initialize empty function node.
 
 pp.initFunction = function(node) {
-  node.id = null;
+  node.id = null
   if (this.options.ecmaVersion >= 6) {
-    node.generator = false;
-    node.expression = false;
+    node.generator = false
+    node.expression = false
   }
-};
+}
 
 // Parse object or class method.
 
 pp.parseMethod = function(isGenerator) {
-  var node = this.startNode();
-  this.initFunction(node);
-  this.expect(tt.parenL);
-  node.params = this.parseBindingList(tt.parenR, false, false);
-  var allowExpressionBody;
+  let node = this.startNode()
+  this.initFunction(node)
+  this.expect(tt.parenL)
+  node.params = this.parseBindingList(tt.parenR, false, false)
+  let allowExpressionBody
   if (this.options.ecmaVersion >= 6) {
-    node.generator = isGenerator;
-    allowExpressionBody = true;
+    node.generator = isGenerator
+    allowExpressionBody = true
   } else {
-    allowExpressionBody = false;
+    allowExpressionBody = false
   }
-  this.parseFunctionBody(node, allowExpressionBody);
-  return this.finishNode(node, "FunctionExpression");
-};
+  this.parseFunctionBody(node, allowExpressionBody)
+  return this.finishNode(node, "FunctionExpression")
+}
 
 // Parse arrow function expression with given parameters.
 
 pp.parseArrowExpression = function(node, params) {
-  this.initFunction(node);
-  node.params = this.toAssignableList(params, true);
-  this.parseFunctionBody(node, true);
-  return this.finishNode(node, "ArrowFunctionExpression");
-};
+  this.initFunction(node)
+  node.params = this.toAssignableList(params, true)
+  this.parseFunctionBody(node, true)
+  return this.finishNode(node, "ArrowFunctionExpression")
+}
 
 // Parse function body and check parameters.
 
 pp.parseFunctionBody = function(node, allowExpression) {
-  var isExpression = allowExpression && this.type !== tt.braceL;
+  let isExpression = allowExpression && this.type !== tt.braceL
 
   if (isExpression) {
-    node.body = this.parseMaybeAssign();
-    node.expression = true;
+    node.body = this.parseMaybeAssign()
+    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 = this.inFunction, oldInGen = this.inGenerator, oldLabels = this.labels;
-    this.inFunction = true; this.inGenerator = node.generator; this.labels = [];
-    node.body = this.parseBlock(true);
-    node.expression = false;
-    this.inFunction = oldInFunc; this.inGenerator = oldInGen; this.labels = oldLabels;
+    let oldInFunc = this.inFunction, oldInGen = this.inGenerator, oldLabels = this.labels
+    this.inFunction = true; this.inGenerator = node.generator; this.labels = []
+    node.body = this.parseBlock(true)
+    node.expression = false
+    this.inFunction = oldInFunc; this.inGenerator = oldInGen; this.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 (this.strict || !isExpression && node.body.body.length && this.isUseStrict(node.body.body[0])) {
-    var nameHash = {}, oldStrict = this.strict;
-    this.strict = true;
+    let nameHash = {}, oldStrict = this.strict
+    this.strict = true
     if (node.id)
-      this.checkLVal(node.id, true);
-    for (var i = 0; i < node.params.length; i++)
-      this.checkLVal(node.params[i], true, nameHash);
-    this.strict = oldStrict;
+      this.checkLVal(node.id, true)
+    for (let i = 0; i < node.params.length; i++)
+      this.checkLVal(node.params[i], true, nameHash)
+    this.strict = oldStrict
   }
-};
+}
 
 // Parses a comma-separated list of expressions, and returns them as
 // an array. `close` is the token type that ends the list, and
@@ -571,198 +570,82 @@ pp.parseFunctionBody = function(node, allowExpression) {
 // for array literals).
 
 pp.parseExprList = function(close, allowTrailingComma, allowEmpty, refShorthandDefaultPos) {
-  var elts = [], first = true;
+  let elts = [], first = true
   while (!this.eat(close)) {
     if (!first) {
-      this.expect(tt.comma);
-      if (allowTrailingComma && this.afterTrailingComma(close)) break;
-    } else first = false;
+      this.expect(tt.comma)
+      if (allowTrailingComma && this.afterTrailingComma(close)) break
+    } else first = false
 
     if (allowEmpty && this.type === tt.comma) {
-      elts.push(null);
+      elts.push(null)
     } else {
       if (this.type === tt.ellipsis)
-        elts.push(this.parseSpread(refShorthandDefaultPos));
+        elts.push(this.parseSpread(refShorthandDefaultPos))
       else
-        elts.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
+        elts.push(this.parseMaybeAssign(false, refShorthandDefaultPos))
     }
   }
-  return elts;
-};
+  return elts
+}
 
 // Parse the next token as an identifier. If `liberal` is true (used
 // when parsing properties), it will also convert keywords into
 // identifiers.
 
 pp.parseIdent = function(liberal) {
-  var node = this.startNode();
-  if (liberal && this.options.allowReserved == "never") liberal = false;
+  let node = this.startNode()
+  if (liberal && this.options.allowReserved == "never") liberal = false
   if (this.type === tt.name) {
     if (!liberal &&
         ((!this.options.allowReserved && this.isReservedWord(this.value)) ||
          (this.strict && reservedWords.strict(this.value)) &&
          (this.options.ecmaVersion >= 6 || 
           this.input.slice(this.start, this.end).indexOf("\\") == -1)))
-      this.raise(this.start, "The keyword '" + this.value + "' is reserved");
-    node.name = this.value;
+      this.raise(this.start, "The keyword '" + this.value + "' is reserved")
+    node.name = this.value
   } else if (liberal && this.type.keyword) {
-    node.name = this.type.keyword;
+    node.name = this.type.keyword
   } else {
-    this.unexpected();
+    this.unexpected()
   }
-  this.next();
-  return this.finishNode(node, "Identifier");
-};
-
-// Parses module export declaration.
-
-pp.parseExport = function(node) {
-  this.next();
-  // export * from '...';
-  if (this.eat(tt.star)) {
-    this.expectContextual("from");
-    node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
-    this.semicolon();
-    return this.finishNode(node, "ExportAllDeclaration");
-  }
-  if (this.eat(tt._default)) { // export default ...;
-    var expr = this.parseMaybeAssign();
-    if (expr.id) {
-      switch (expr.type) {
-      case "FunctionExpression": expr.type = "FunctionDeclaration"; break;
-      case "ClassExpression": expr.type = "ClassDeclaration"; break;
-      }
-    }
-    node.declaration = expr;
-    this.semicolon();
-    return this.finishNode(node, "ExportDefaultDeclaration");
-  }
-  // export var|const|let|function|class ...;
-  if (this.type.keyword) {
-    node.declaration = this.parseStatement(true);
-    node.specifiers = [];
-    node.source = null;
-  } else { // export { x, y as z } [from '...'];
-    node.declaration = null;
-    node.specifiers = this.parseExportSpecifiers();
-    if (this.eatContextual("from")) {
-      node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
-    } else {
-      node.source = null;
-    }
-    this.semicolon();
-  }
-  return this.finishNode(node, "ExportNamedDeclaration");
-};
-
-// Parses a comma-separated list of module exports.
-
-pp.parseExportSpecifiers = function() {
-  var nodes = [], first = true;
-  // export { x, y as z } [from '...']
-  this.expect(tt.braceL);
-  while (!this.eat(tt.braceR)) {
-    if (!first) {
-      this.expect(tt.comma);
-      if (this.afterTrailingComma(tt.braceR)) break;
-    } else first = false;
-
-    var node = this.startNode();
-    node.local = this.parseIdent(this.type === tt._default);
-    node.exported = this.eatContextual("as") ? this.parseIdent(true) : node.local;
-    nodes.push(this.finishNode(node, "ExportSpecifier"));
-  }
-  return nodes;
-};
-
-// Parses import declaration.
-
-pp.parseImport = function(node) {
-  this.next();
-  // import '...';
-  if (this.type === tt.string) {
-    node.specifiers = empty;
-    node.source = this.parseExprAtom();
-    node.kind = "";
-  } else {
-    node.specifiers = this.parseImportSpecifiers();
-    this.expectContextual("from");
-    node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
-  }
-  this.semicolon();
-  return this.finishNode(node, "ImportDeclaration");
-};
-
-// Parses a comma-separated list of module imports.
-
-pp.parseImportSpecifiers = function() {
-  var nodes = [], first = true;
-  if (this.type === tt.name) {
-    // import defaultObj, { x, y as z } from '...'
-    var node = this.startNode();
-    node.local = this.parseIdent();
-    this.checkLVal(node.local, true);
-    nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
-    if (!this.eat(tt.comma)) return nodes;
-  }
-  if (this.type === tt.star) {
-    var node = this.startNode();
-    this.next();
-    this.expectContextual("as");
-    node.local = this.parseIdent();
-    this.checkLVal(node.local, true);
-    nodes.push(this.finishNode(node, "ImportNamespaceSpecifier"));
-    return nodes;
-  }
-  this.expect(tt.braceL);
-  while (!this.eat(tt.braceR)) {
-    if (!first) {
-      this.expect(tt.comma);
-      if (this.afterTrailingComma(tt.braceR)) break;
-    } else first = false;
-
-    var node = this.startNode();
-    node.imported = this.parseIdent(true);
-    node.local = this.eatContextual("as") ? this.parseIdent() : node.imported;
-    this.checkLVal(node.local, true);
-    nodes.push(this.finishNode(node, "ImportSpecifier"));
-  }
-  return nodes;
-};
+  this.next()
+  return this.finishNode(node, "Identifier")
+}
 
 // Parses yield expression inside generator.
 
 pp.parseYield = function() {
-  var node = this.startNode();
-  this.next();
+  let node = this.startNode()
+  this.next()
   if (this.type == tt.semi || this.canInsertSemicolon() || (this.type != tt.star && !this.type.startsExpr)) {
-    node.delegate = false;
-    node.argument = null;
+    node.delegate = false
+    node.argument = null
   } else {
-    node.delegate = this.eat(tt.star);
-    node.argument = this.parseMaybeAssign();
+    node.delegate = this.eat(tt.star)
+    node.argument = this.parseMaybeAssign()
   }
-  return this.finishNode(node, "YieldExpression");
-};
+  return this.finishNode(node, "YieldExpression")
+}
 
 // Parses array and generator comprehensions.
 
 pp.parseComprehension = function(node, isGenerator) {
-  node.blocks = [];
+  node.blocks = []
   while (this.type === tt._for) {
-    var block = this.startNode();
-    this.next();
-    this.expect(tt.parenL);
-    block.left = this.parseBindingAtom();
-    this.checkLVal(block.left, true);
-    this.expectContextual("of");
-    block.right = this.parseExpression();
-    this.expect(tt.parenR);
-    node.blocks.push(this.finishNode(block, "ComprehensionBlock"));
+    let block = this.startNode()
+    this.next()
+    this.expect(tt.parenL)
+    block.left = this.parseBindingAtom()
+    this.checkLVal(block.left, true)
+    this.expectContextual("of")
+    block.right = this.parseExpression()
+    this.expect(tt.parenR)
+    node.blocks.push(this.finishNode(block, "ComprehensionBlock"))
   }
-  node.filter = this.eat(tt._if) ? this.parseParenExpression() : null;
-  node.body = this.parseExpression();
-  this.expect(isGenerator ? tt.parenR : tt.bracketR);
-  node.generator = isGenerator;
-  return this.finishNode(node, "ComprehensionExpression");
-};
+  node.filter = this.eat(tt._if) ? this.parseParenExpression() : null
+  node.body = this.parseExpression()
+  this.expect(isGenerator ? tt.parenR : tt.bracketR)
+  node.generator = isGenerator
+  return this.finishNode(node, "ComprehensionExpression")
+}
diff --git a/src/identifier.js b/src/identifier.js
index fd2794c27a..ad2fe03935 100644
--- a/src/identifier.js
+++ b/src/identifier.js
@@ -8,42 +8,42 @@
 // 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)
+  words = words.split(" ")
+  let f = "", cats = []
+  out: for (let i = 0; i < words.length; ++i) {
+    for (let j = 0; j < cats.length; ++j)
       if (cats[j][0].length == words[i].length) {
-        cats[j].push(words[i]);
-        continue out;
+        cats[j].push(words[i])
+        continue out
       }
-    cats.push([words[i]]);
+    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;";
+    if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";"
+    f += "switch(str){"
+    for (let 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);
+    cats.sort((a, b) => b.length - a.length)
+    f += "switch(str.length){"
+    for (let i = 0; i < cats.length; ++i) {
+      let cat = cats[i]
+      f += "case " + cat[0].length + ":"
+      compareTo(cat)
     }
-    f += "}";
+    f += "}"
 
     // Otherwise, simply generate a flat `switch` statement.
 
   } else {
-    compareTo(words);
+    compareTo(words)
   }
-  return new Function("str", f);
+  return new Function("str", f)
 }
 
 // Reserved word lists for various dialects of the language
@@ -58,7 +58,7 @@ export const reservedWords = {
 
 // 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 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"
 
 export const keywords = {
   5: makePredicate(ecma5AndLessKeywords),
@@ -86,44 +86,44 @@ nonASCIIidentifierStartChars = nonASCIIidentifierChars = null
 // offset starts at 0x10000, and each pair of numbers represents an
 // offset to the next range, and then a size of the range. They were
 // generated by tools/generate-identifier-regex.js
-var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,17,26,6,37,11,29,3,35,5,7,2,4,43,157,99,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,98,21,11,25,71,55,7,1,65,0,16,3,2,2,2,26,45,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,955,52,76,44,33,24,27,35,42,34,4,0,13,47,15,3,22,0,38,17,2,24,133,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,32,4,287,47,21,1,2,0,185,46,82,47,21,0,60,42,502,63,32,0,449,56,1288,920,104,110,2962,1070,13266,568,8,30,114,29,19,47,17,3,32,20,6,18,881,68,12,0,67,12,16481,1,3071,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,1340,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,16355,541];
-var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,1306,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,52,0,13,2,49,13,16,9,83,11,168,11,6,9,8,2,57,0,2,6,3,1,3,2,10,0,11,1,3,6,4,4,316,19,13,9,214,6,3,8,112,16,16,9,82,12,9,9,535,9,20855,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,4305,6,792618,239];
+var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,17,26,6,37,11,29,3,35,5,7,2,4,43,157,99,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,98,21,11,25,71,55,7,1,65,0,16,3,2,2,2,26,45,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,955,52,76,44,33,24,27,35,42,34,4,0,13,47,15,3,22,0,38,17,2,24,133,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,32,4,287,47,21,1,2,0,185,46,82,47,21,0,60,42,502,63,32,0,449,56,1288,920,104,110,2962,1070,13266,568,8,30,114,29,19,47,17,3,32,20,6,18,881,68,12,0,67,12,16481,1,3071,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,1340,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,16355,541]
+var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,1306,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,52,0,13,2,49,13,16,9,83,11,168,11,6,9,8,2,57,0,2,6,3,1,3,2,10,0,11,1,3,6,4,4,316,19,13,9,214,6,3,8,112,16,16,9,82,12,9,9,535,9,20855,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,4305,6,792618,239]
 
 // This has a complexity linear to the value of the code. The
 // assumption is that looking up astral identifier characters is
 // rare.
 function isInAstralSet(code, set) {
-  var pos = 0x10000;
-  for (var i = 0; i < set.length; i += 2) {
-    pos += set[i];
-    if (pos > code) return false;
-    pos += set[i + 1];
-    if (pos >= code) return true;
+  let pos = 0x10000
+  for (let i = 0; i < set.length; i += 2) {
+    pos += set[i]
+    if (pos > code) return false
+    pos += set[i + 1]
+    if (pos >= code) return true
   }
 }
 
 // Test whether a given character code starts an identifier.
 
 export function isIdentifierStart(code, astral) {
-  if (code < 65) return code === 36;
-  if (code < 91) return true;
-  if (code < 97) return code === 95;
-  if (code < 123) return true;
-  if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  if (astral === false) return false;
-  return isInAstralSet(code, astralIdentifierStartCodes);
+  if (code < 65) return code === 36
+  if (code < 91) return true
+  if (code < 97) return code === 95
+  if (code < 123) return true
+  if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code))
+  if (astral === false) return false
+  return isInAstralSet(code, astralIdentifierStartCodes)
 }
 
 // Test whether a given character is part of an identifier.
 
 export function isIdentifierChar(code, astral) {
-  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;
-  if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  if (astral === false) return false;
-  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+  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
+  if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code))
+  if (astral === false) return false
+  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes)
 }
diff --git a/src/location.js b/src/location.js
index 83bae82121..31d40a3501 100644
--- a/src/location.js
+++ b/src/location.js
@@ -51,17 +51,17 @@ const pp = Parser.prototype
 // message.
 
 pp.raise = function(pos, message) {
-  var loc = getLineInfo(this.input, pos);
-  message += " (" + loc.line + ":" + loc.column + ")";
-  var err = new SyntaxError(message);
-  err.pos = pos; err.loc = loc; err.raisedAt = this.pos;
-  throw err;
-};
+  let loc = getLineInfo(this.input, pos)
+  message += " (" + loc.line + ":" + loc.column + ")"
+  let err = new SyntaxError(message)
+  err.pos = pos; err.loc = loc; err.raisedAt = this.pos
+  throw err
+}
 
 pp.curPosition = function() {
-  return new Position(this.curLine, this.pos - this.lineStart);
-};
+  return new Position(this.curLine, this.pos - this.lineStart)
+}
 
 pp.markPosition = function() {
-  return this.options.locations ? [this.start, this.startLoc] : this.start;
-};
+  return this.options.locations ? [this.start, this.startLoc] : this.start
+}
diff --git a/src/loose/expression.js b/src/loose/expression.js
index ff38374b94..4269f2f234 100644
--- a/src/loose/expression.js
+++ b/src/loose/expression.js
@@ -5,7 +5,7 @@ import {tokTypes as tt} from ".."
 const lp = LooseParser.prototype
 
 lp.checkLVal = function(expr) {
-  if (!expr) return expr;
+  if (!expr) return expr
   switch (expr.type) {
   case "Identifier":
   case "MemberExpression":
@@ -13,400 +13,401 @@ lp.checkLVal = function(expr) {
   case "ArrayPattern":
   case "RestElement":
   case "AssignmentPattern":
-    return expr;
+    return expr
 
   default:
-    return this.dummyIdent();
+    return this.dummyIdent()
   }
-};
+}
 
 lp.parseExpression = function(noIn) {
-  var start = this.storeCurrentPos();
-  var expr = this.parseMaybeAssign(noIn);
+  let start = this.storeCurrentPos()
+  let expr = this.parseMaybeAssign(noIn)
   if (this.tok.type === tt.comma) {
-    var node = this.startNodeAt(start);
-    node.expressions = [expr];
-    while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn));
-    return this.finishNode(node, "SequenceExpression");
+    let node = this.startNodeAt(start)
+    node.expressions = [expr]
+    while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn))
+    return this.finishNode(node, "SequenceExpression")
   }
-  return expr;
-};
+  return expr
+}
 
 lp.parseParenExpression = function() {
-  this.pushCx();
-  this.expect(tt.parenL);
-  var val = this.parseExpression();
-  this.popCx();
-  this.expect(tt.parenR);
-  return val;
-};
+  this.pushCx()
+  this.expect(tt.parenL)
+  let val = this.parseExpression()
+  this.popCx()
+  this.expect(tt.parenR)
+  return val
+}
 
 lp.parseMaybeAssign = function(noIn) {
-  var start = this.storeCurrentPos();
-  var left = this.parseMaybeConditional(noIn);
+  let start = this.storeCurrentPos()
+  let left = this.parseMaybeConditional(noIn)
   if (this.tok.type.isAssign) {
-    var node = this.startNodeAt(start);
-    node.operator = this.tok.value;
-    node.left = this.tok.type === tt.eq ? this.toAssignable(left) : this.checkLVal(left);
-    this.next();
-    node.right = this.parseMaybeAssign(noIn);
-    return this.finishNode(node, "AssignmentExpression");
+    let node = this.startNodeAt(start)
+    node.operator = this.tok.value
+    node.left = this.tok.type === tt.eq ? this.toAssignable(left) : this.checkLVal(left)
+    this.next()
+    node.right = this.parseMaybeAssign(noIn)
+    return this.finishNode(node, "AssignmentExpression")
   }
-  return left;
-};
+  return left
+}
 
 lp.parseMaybeConditional = function(noIn) {
-  var start = this.storeCurrentPos();
-  var expr = this.parseExprOps(noIn);
+  let start = this.storeCurrentPos()
+  let expr = this.parseExprOps(noIn)
   if (this.eat(tt.question)) {
-    var node = this.startNodeAt(start);
-    node.test = expr;
-    node.consequent = this.parseMaybeAssign();
-    node.alternate = this.expect(tt.colon) ? this.parseMaybeAssign(noIn) : this.dummyIdent();
-    return this.finishNode(node, "ConditionalExpression");
+    let node = this.startNodeAt(start)
+    node.test = expr
+    node.consequent = this.parseMaybeAssign()
+    node.alternate = this.expect(tt.colon) ? this.parseMaybeAssign(noIn) : this.dummyIdent()
+    return this.finishNode(node, "ConditionalExpression")
   }
-  return expr;
-};
+  return expr
+}
 
 lp.parseExprOps = function(noIn) {
-  var start = this.storeCurrentPos();
-  var indent = this.curIndent, line = this.curLineStart;
-  return this.parseExprOp(this.parseMaybeUnary(noIn), start, -1, noIn, indent, line);
-};
+  let start = this.storeCurrentPos()
+  let indent = this.curIndent, line = this.curLineStart
+  return this.parseExprOp(this.parseMaybeUnary(noIn), start, -1, noIn, indent, line)
+}
 
 lp.parseExprOp = function(left, start, minPrec, noIn, indent, line) {
-  if (this.curLineStart != line && this.curIndent < indent && this.tokenStartsLine()) return left;
-  var prec = this.tok.type.binop;
+  if (this.curLineStart != line && this.curIndent < indent && this.tokenStartsLine()) return left
+  let prec = this.tok.type.binop
   if (prec != null && (!noIn || this.tok.type !== tt._in)) {
     if (prec > minPrec) {
-      var node = this.startNodeAt(start);
-      node.left = left;
-      node.operator = this.tok.value;
-      this.next();
+      let node = this.startNodeAt(start)
+      node.left = left
+      node.operator = this.tok.value
+      this.next()
       if (this.curLineStart != line && this.curIndent < indent && this.tokenStartsLine()) {
-        node.right = this.dummyIdent();
+        node.right = this.dummyIdent()
       } else {
-        var rightStart = this.storeCurrentPos();
-        node.right = this.parseExprOp(this.parseMaybeUnary(noIn), rightStart, prec, noIn, indent, line);
+        let rightStart = this.storeCurrentPos()
+        node.right = this.parseExprOp(this.parseMaybeUnary(noIn), rightStart, prec, noIn, indent, line)
       }
-      this.finishNode(node, /&&|\|\|/.test(node.operator) ? "LogicalExpression" : "BinaryExpression");
-      return this.parseExprOp(node, start, minPrec, noIn, indent, line);
+      this.finishNode(node, /&&|\|\|/.test(node.operator) ? "LogicalExpression" : "BinaryExpression")
+      return this.parseExprOp(node, start, minPrec, noIn, indent, line)
     }
   }
-  return left;
-};
+  return left
+}
 
 lp.parseMaybeUnary = function(noIn) {
   if (this.tok.type.prefix) {
-    var node = this.startNode(), update = this.tok.type === tt.incDec;
-    node.operator = this.tok.value;
-    node.prefix = true;
-    this.next();
-    node.argument = this.parseMaybeUnary(noIn);
-    if (update) node.argument = this.checkLVal(node.argument);
-    return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+    let node = this.startNode(), update = this.tok.type === tt.incDec
+    node.operator = this.tok.value
+    node.prefix = true
+    this.next()
+    node.argument = this.parseMaybeUnary(noIn)
+    if (update) node.argument = this.checkLVal(node.argument)
+    return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression")
   } else if (this.tok.type === tt.ellipsis) {
-    var node = this.startNode();
-    this.next();
-    node.argument = this.parseMaybeUnary(noIn);
-    return this.finishNode(node, "SpreadElement");
+    let node = this.startNode()
+    this.next()
+    node.argument = this.parseMaybeUnary(noIn)
+    return this.finishNode(node, "SpreadElement")
   }
-  var start = this.storeCurrentPos();
-  var expr = this.parseExprSubscripts();
+  let start = this.storeCurrentPos()
+  let expr = this.parseExprSubscripts()
   while (this.tok.type.postfix && !this.canInsertSemicolon()) {
-    var node = this.startNodeAt(start);
-    node.operator = this.tok.value;
-    node.prefix = false;
-    node.argument = this.checkLVal(expr);
-    this.next();
-    expr = this.finishNode(node, "UpdateExpression");
+    let node = this.startNodeAt(start)
+    node.operator = this.tok.value
+    node.prefix = false
+    node.argument = this.checkLVal(expr)
+    this.next()
+    expr = this.finishNode(node, "UpdateExpression")
   }
-  return expr;
-};
+  return expr
+}
 
 lp.parseExprSubscripts = function() {
-  var start = this.storeCurrentPos();
-  return this.parseSubscripts(this.parseExprAtom(), start, false, this.curIndent, this.curLineStart);
-};
+  let start = this.storeCurrentPos()
+  return this.parseSubscripts(this.parseExprAtom(), start, false, this.curIndent, this.curLineStart)
+}
 
 lp.parseSubscripts = function(base, start, noCalls, startIndent, line) {
   for (;;) {
     if (this.curLineStart != line && this.curIndent <= startIndent && this.tokenStartsLine()) {
       if (this.tok.type == tt.dot && this.curIndent == startIndent)
-        --startIndent;
+        --startIndent
       else
-        return base;
+        return base
     }
 
     if (this.eat(tt.dot)) {
-      var node = this.startNodeAt(start);
-      node.object = base;
+      let node = this.startNodeAt(start)
+      node.object = base
       if (this.curLineStart != line && this.curIndent <= startIndent && this.tokenStartsLine())
-        node.property = this.dummyIdent();
+        node.property = this.dummyIdent()
       else
-        node.property = this.parsePropertyAccessor() || this.dummyIdent();
-      node.computed = false;
-      base = this.finishNode(node, "MemberExpression");
+        node.property = this.parsePropertyAccessor() || this.dummyIdent()
+      node.computed = false
+      base = this.finishNode(node, "MemberExpression")
     } else if (this.tok.type == tt.bracketL) {
-      this.pushCx();
-      this.next();
-      var node = this.startNodeAt(start);
-      node.object = base;
-      node.property = this.parseExpression();
-      node.computed = true;
-      this.popCx();
-      this.expect(tt.bracketR);
-      base = this.finishNode(node, "MemberExpression");
+      this.pushCx()
+      this.next()
+      let node = this.startNodeAt(start)
+      node.object = base
+      node.property = this.parseExpression()
+      node.computed = true
+      this.popCx()
+      this.expect(tt.bracketR)
+      base = this.finishNode(node, "MemberExpression")
     } else if (!noCalls && this.tok.type == tt.parenL) {
-      this.pushCx();
-      var node = this.startNodeAt(start);
-      node.callee = base;
-      node.arguments = this.parseExprList(tt.parenR);
-      base = this.finishNode(node, "CallExpression");
+      this.pushCx()
+      let node = this.startNodeAt(start)
+      node.callee = base
+      node.arguments = this.parseExprList(tt.parenR)
+      base = this.finishNode(node, "CallExpression")
     } else if (this.tok.type == tt.backQuote) {
-      var node = this.startNodeAt(start);
-      node.tag = base;
-      node.quasi = this.parseTemplate();
-      base = this.finishNode(node, "TaggedTemplateExpression");
+      let node = this.startNodeAt(start)
+      node.tag = base
+      node.quasi = this.parseTemplate()
+      base = this.finishNode(node, "TaggedTemplateExpression")
     } else {
-      return base;
+      return base
     }
   }
-};
+}
 
 lp.parseExprAtom = function() {
+  let node
   switch (this.tok.type) {
   case tt._this:
   case tt._super:
-    var type = this.tok.type === tt._this ? "ThisExpression" : "SuperExpression";
-    var node = this.startNode();
-    this.next();
-    return this.finishNode(node, type);
+    let type = this.tok.type === tt._this ? "ThisExpression" : "SuperExpression"
+    node = this.startNode()
+    this.next()
+    return this.finishNode(node, type)
 
   case tt.name:
-    var start = this.storeCurrentPos();
-    var id = this.parseIdent();
-    return this.eat(tt.arrow) ? this.parseArrowExpression(this.startNodeAt(start), [id]) : id;
+    let start = this.storeCurrentPos()
+    let id = this.parseIdent()
+    return this.eat(tt.arrow) ? this.parseArrowExpression(this.startNodeAt(start), [id]) : id
 
   case tt.regexp:
-    var node = this.startNode();
-    var val = this.tok.value;
-    node.regex = {pattern: val.pattern, flags: val.flags};
-    node.value = val.value;
-    node.raw = this.input.slice(this.tok.start, this.tok.end);
-    this.next();
-    return this.finishNode(node, "Literal");
+    node = this.startNode()
+    let val = this.tok.value
+    node.regex = {pattern: val.pattern, flags: val.flags}
+    node.value = val.value
+    node.raw = this.input.slice(this.tok.start, this.tok.end)
+    this.next()
+    return this.finishNode(node, "Literal")
 
   case tt.num: case tt.string:
-    var node = this.startNode();
-    node.value = this.tok.value;
-    node.raw = this.input.slice(this.tok.start, this.tok.end);
-    this.next();
-    return this.finishNode(node, "Literal");
+    node = this.startNode()
+    node.value = this.tok.value
+    node.raw = this.input.slice(this.tok.start, this.tok.end)
+    this.next()
+    return this.finishNode(node, "Literal")
 
   case tt._null: case tt._true: case tt._false:
-    var node = this.startNode();
-    node.value = this.tok.type === tt._null ? null : this.tok.type === tt._true;
-    node.raw = this.tok.type.keyword;
-    this.next();
-    return this.finishNode(node, "Literal");
+    node = this.startNode()
+    node.value = this.tok.type === tt._null ? null : this.tok.type === tt._true
+    node.raw = this.tok.type.keyword
+    this.next()
+    return this.finishNode(node, "Literal")
 
   case tt.parenL:
-    var start = this.storeCurrentPos();
-    this.next();
-    var val = this.parseExpression();
-    this.expect(tt.parenR);
+    let parenStart = this.storeCurrentPos()
+    this.next()
+    let inner = this.parseExpression()
+    this.expect(tt.parenR)
     if (this.eat(tt.arrow)) {
-      return this.parseArrowExpression(this.startNodeAt(start), val.expressions || (isDummy(val) ? [] : [val]));
+      return this.parseArrowExpression(this.startNodeAt(parenStart), inner.expressions || (isDummy(inner) ? [] : [inner]))
     }
     if (this.options.preserveParens) {
-      var par = this.startNodeAt(start);
-      par.expression = val;
-      val = this.finishNode(par, "ParenthesizedExpression");
+      let par = this.startNodeAt(parenStart)
+      par.expression = inner
+      inner = this.finishNode(par, "ParenthesizedExpression")
     }
-    return val;
+    return inner
 
   case tt.bracketL:
-    var node = this.startNode();
-    this.pushCx();
-    node.elements = this.parseExprList(tt.bracketR, true);
-    return this.finishNode(node, "ArrayExpression");
+    node = this.startNode()
+    this.pushCx()
+    node.elements = this.parseExprList(tt.bracketR, true)
+    return this.finishNode(node, "ArrayExpression")
 
   case tt.braceL:
-    return this.parseObj();
+    return this.parseObj()
 
   case tt._class:
-    return this.parseClass();
+    return this.parseClass()
 
   case tt._function:
-    var node = this.startNode();
-    this.next();
-    return this.parseFunction(node, false);
+    node = this.startNode()
+    this.next()
+    return this.parseFunction(node, false)
 
   case tt._new:
-    return this.parseNew();
+    return this.parseNew()
 
   case tt._yield:
-    var node = this.startNode();
-    this.next();
+    node = this.startNode()
+    this.next()
     if (this.semicolon() || this.canInsertSemicolon() || (this.tok.type != tt.star && !this.tok.type.startsExpr)) {
-      node.delegate = false;
-      node.argument = null;
+      node.delegate = false
+      node.argument = null
     } else {
-      node.delegate = this.eat(tt.star);
-      node.argument = this.parseMaybeAssign();
+      node.delegate = this.eat(tt.star)
+      node.argument = this.parseMaybeAssign()
     }
-    return this.finishNode(node, "YieldExpression");
+    return this.finishNode(node, "YieldExpression")
 
   case tt.backQuote:
-    return this.parseTemplate();
+    return this.parseTemplate()
 
   default:
-    return this.dummyIdent();
+    return this.dummyIdent()
   }
-};
+}
 
 lp.parseNew = function() {
-  var node = this.startNode(), startIndent = this.curIndent, line = this.curLineStart;
-  this.next();
-  var start = this.storeCurrentPos();
-  node.callee = this.parseSubscripts(this.parseExprAtom(), start, true, startIndent, line);
+  let node = this.startNode(), startIndent = this.curIndent, line = this.curLineStart
+  this.next()
+  let start = this.storeCurrentPos()
+  node.callee = this.parseSubscripts(this.parseExprAtom(), start, true, startIndent, line)
   if (this.tok.type == tt.parenL) {
-    this.pushCx();
-    node.arguments = this.parseExprList(tt.parenR);
+    this.pushCx()
+    node.arguments = this.parseExprList(tt.parenR)
   } else {
-    node.arguments = [];
+    node.arguments = []
   }
-  return this.finishNode(node, "NewExpression");
-};
+  return this.finishNode(node, "NewExpression")
+}
 
 lp.parseTemplateElement = function() {
-  var elem = this.startNode();
+  let elem = this.startNode()
   elem.value = {
     raw: this.input.slice(this.tok.start, this.tok.end),
     cooked: this.tok.value
-  };
-  this.next();
-  elem.tail = this.tok.type === tt.backQuote;
-  return this.finishNode(elem, "TemplateElement");
-};
+  }
+  this.next()
+  elem.tail = this.tok.type === tt.backQuote
+  return this.finishNode(elem, "TemplateElement")
+}
 
 lp.parseTemplate = function() {
-  var node = this.startNode();
-  this.next();
-  node.expressions = [];
-  var curElt = this.parseTemplateElement();
-  node.quasis = [curElt];
+  let node = this.startNode()
+  this.next()
+  node.expressions = []
+  let curElt = this.parseTemplateElement()
+  node.quasis = [curElt]
   while (!curElt.tail) {
-    this.next();
-    node.expressions.push(this.parseExpression());
+    this.next()
+    node.expressions.push(this.parseExpression())
     if (this.expect(tt.braceR)) {
-      curElt = this.parseTemplateElement();
+      curElt = this.parseTemplateElement()
     } else {
-      curElt = this.startNode();
-      curElt.value = {cooked: '', raw: ''};
-      curElt.tail = true;
+      curElt = this.startNode()
+      curElt.value = {cooked: '', raw: ''}
+      curElt.tail = true
     }
-    node.quasis.push(curElt);
+    node.quasis.push(curElt)
   }
-  this.expect(tt.backQuote);
-  return this.finishNode(node, "TemplateLiteral");
-};
+  this.expect(tt.backQuote)
+  return this.finishNode(node, "TemplateLiteral")
+}
 
 lp.parseObj = function() {
-  var node = this.startNode();
-  node.properties = [];
-  this.pushCx();
-  var indent = this.curIndent + 1, line = this.curLineStart;
-  this.eat(tt.braceL);
-  if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart; }
+  let node = this.startNode()
+  node.properties = []
+  this.pushCx()
+  let indent = this.curIndent + 1, line = this.curLineStart
+  this.eat(tt.braceL)
+  if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart }
   while (!this.closes(tt.braceR, indent, line)) {
-    var prop = this.startNode(), isGenerator, start;
+    let prop = this.startNode(), isGenerator, start
     if (this.options.ecmaVersion >= 6) {
-      start = this.storeCurrentPos();
-      prop.method = false;
-      prop.shorthand = false;
-      isGenerator = this.eat(tt.star);
+      start = this.storeCurrentPos()
+      prop.method = false
+      prop.shorthand = false
+      isGenerator = this.eat(tt.star)
     }
-    this.parsePropertyName(prop);
-    if (isDummy(prop.key)) { if (isDummy(this.parseMaybeAssign())) this.next(); this.eat(tt.comma); continue; }
+    this.parsePropertyName(prop)
+    if (isDummy(prop.key)) { if (isDummy(this.parseMaybeAssign())) this.next(); this.eat(tt.comma); continue }
     if (this.eat(tt.colon)) {
-      prop.kind = "init";
-      prop.value = this.parseMaybeAssign();
+      prop.kind = "init"
+      prop.value = this.parseMaybeAssign()
     } else if (this.options.ecmaVersion >= 6 && (this.tok.type === tt.parenL || this.tok.type === tt.braceL)) {
-      prop.kind = "init";
-      prop.method = true;
-      prop.value = this.parseMethod(isGenerator);
+      prop.kind = "init"
+      prop.method = true
+      prop.value = this.parseMethod(isGenerator)
     } else if (this.options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
                !prop.computed && (prop.key.name === "get" || prop.key.name === "set") &&
                (this.tok.type != tt.comma && this.tok.type != tt.braceR)) {
-      prop.kind = prop.key.name;
-      this.parsePropertyName(prop);
-      prop.value = this.parseMethod(false);
+      prop.kind = prop.key.name
+      this.parsePropertyName(prop)
+      prop.value = this.parseMethod(false)
     } else {
-      prop.kind = "init";
+      prop.kind = "init"
       if (this.options.ecmaVersion >= 6) {
         if (this.eat(tt.eq)) {
-          var assign = this.startNodeAt(start);
-          assign.operator = "=";
-          assign.left = prop.key;
-          assign.right = this.parseMaybeAssign();
-          prop.value = this.finishNode(assign, "AssignmentExpression");
+          let assign = this.startNodeAt(start)
+          assign.operator = "="
+          assign.left = prop.key
+          assign.right = this.parseMaybeAssign()
+          prop.value = this.finishNode(assign, "AssignmentExpression")
         } else {
-          prop.value = prop.key;
+          prop.value = prop.key
         }
       } else {
-        prop.value = this.dummyIdent();
+        prop.value = this.dummyIdent()
       }
-      prop.shorthand = true;
+      prop.shorthand = true
     }
-    node.properties.push(this.finishNode(prop, "Property"));
-    this.eat(tt.comma);
+    node.properties.push(this.finishNode(prop, "Property"))
+    this.eat(tt.comma)
   }
-  this.popCx();
+  this.popCx()
   if (!this.eat(tt.braceR)) {
     // If there is no closing brace, make the node span to the start
     // of the next token (this is useful for Tern)
-    this.last.end = this.tok.start;
-    if (this.options.locations) this.last.loc.end = this.tok.loc.start;
+    this.last.end = this.tok.start
+    if (this.options.locations) this.last.loc.end = this.tok.loc.start
   }
-  return this.finishNode(node, "ObjectExpression");
-};
+  return this.finishNode(node, "ObjectExpression")
+}
 
 lp.parsePropertyName = function(prop) {
   if (this.options.ecmaVersion >= 6) {
     if (this.eat(tt.bracketL)) {
-      prop.computed = true;
-      prop.key = this.parseExpression();
-      this.expect(tt.bracketR);
-      return;
+      prop.computed = true
+      prop.key = this.parseExpression()
+      this.expect(tt.bracketR)
+      return
     } else {
-      prop.computed = false;
+      prop.computed = false
     }
   }
-  var key = (this.tok.type === tt.num || this.tok.type === tt.string) ? this.parseExprAtom() : this.parseIdent();
-  prop.key = key || this.dummyIdent();
-};
+  let key = (this.tok.type === tt.num || this.tok.type === tt.string) ? this.parseExprAtom() : this.parseIdent()
+  prop.key = key || this.dummyIdent()
+}
 
 lp.parsePropertyAccessor = function() {
-  if (this.tok.type === tt.name || this.tok.type.keyword) return this.parseIdent();
-};
+  if (this.tok.type === tt.name || this.tok.type.keyword) return this.parseIdent()
+}
 
 lp.parseIdent = function() {
-  var node = this.startNode();
-  node.name = this.tok.type === tt.name ? this.tok.value : this.tok.type.keyword;
-  this.next();
-  return this.finishNode(node, "Identifier");
-};
+  let node = this.startNode()
+  node.name = this.tok.type === tt.name ? this.tok.value : this.tok.type.keyword
+  this.next()
+  return this.finishNode(node, "Identifier")
+}
 
 lp.initFunction = function(node) {
-  node.id = null;
-  node.params = [];
+  node.id = null
+  node.params = []
   if (this.options.ecmaVersion >= 6) {
-    node.generator = false;
-    node.expression = false;
+    node.generator = false
+    node.expression = false
   }
-};
+}
 
 // Convert existing expression atom to assignable pattern
 // if possible.
@@ -415,189 +416,83 @@ lp.toAssignable = function(node) {
   if (this.options.ecmaVersion >= 6 && node) {
     switch (node.type) {
     case "ObjectExpression":
-      node.type = "ObjectPattern";
-      var props = node.properties;
-      for (var i = 0; i < props.length; i++)
-        this.toAssignable(props[i].value);
-      break;
+      node.type = "ObjectPattern"
+      let props = node.properties
+      for (let i = 0; i < props.length; i++)
+        this.toAssignable(props[i].value)
+      break
 
     case "ArrayExpression":
-      node.type = "ArrayPattern";
-      this.toAssignableList(node.elements);
-      break;
+      node.type = "ArrayPattern"
+      this.toAssignableList(node.elements)
+      break
 
     case "SpreadElement":
-      node.type = "RestElement";
-      node.argument = this.toAssignable(node.argument);
-      break;
+      node.type = "RestElement"
+      node.argument = this.toAssignable(node.argument)
+      break
 
     case "AssignmentExpression":
-      node.type = "AssignmentPattern";
-      break;
+      node.type = "AssignmentPattern"
+      break
     }
   }
-  return this.checkLVal(node);
-};
+  return this.checkLVal(node)
+}
 
 lp.toAssignableList = function(exprList) {
-  for (var i = 0; i < exprList.length; i++)
-    this.toAssignable(exprList[i]);
-  return exprList;
-};
+  for (let i = 0; i < exprList.length; i++)
+    this.toAssignable(exprList[i])
+  return exprList
+}
 
 lp.parseFunctionParams = function(params) {
-  this.pushCx();
-  params = this.parseExprList(tt.parenR);
-  return this.toAssignableList(params);
-};
+  this.pushCx()
+  params = this.parseExprList(tt.parenR)
+  return this.toAssignableList(params)
+}
 
 lp.parseMethod = function(isGenerator) {
-  var node = this.startNode();
-  this.initFunction(node);
-  node.params = this.parseFunctionParams();
-  node.generator = isGenerator || false;
-  node.expression = this.options.ecmaVersion >= 6 && this.tok.type !== tt.braceL;
-  node.body = node.expression ? this.parseMaybeAssign() : this.parseBlock();
-  return this.finishNode(node, "FunctionExpression");
-};
+  let node = this.startNode()
+  this.initFunction(node)
+  node.params = this.parseFunctionParams()
+  node.generator = isGenerator || false
+  node.expression = this.options.ecmaVersion >= 6 && this.tok.type !== tt.braceL
+  node.body = node.expression ? this.parseMaybeAssign() : this.parseBlock()
+  return this.finishNode(node, "FunctionExpression")
+}
 
 lp.parseArrowExpression = function(node, params) {
-  this.initFunction(node);
-  node.params = this.toAssignableList(params);
-  node.expression = this.tok.type !== tt.braceL;
-  node.body = node.expression ? this.parseMaybeAssign() : this.parseBlock();
-  return this.finishNode(node, "ArrowFunctionExpression");
-};
-
-lp.parseExport = function() {
-  var node = this.startNode();
-  this.next();
-  if (this.eat(tt.star)) {
-    node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
-    return this.finishNode(node, "ExportAllDeclaration");
-  }
-  if (this.eat(tt._default)) {
-    var expr = this.parseMaybeAssign();
-    if (expr.id) {
-      switch (expr.type) {
-      case "FunctionExpression": expr.type = "FunctionDeclaration"; break;
-      case "ClassExpression": expr.type = "ClassDeclaration"; break;
-      }
-    }
-    node.declaration = expr;
-    this.semicolon();
-    return this.finishNode(node, "ExportDefaultDeclaration");
-  }
-  if (this.tok.type.keyword) {
-    node.declaration = this.parseStatement();
-    node.specifiers = [];
-    node.source = null;
-  } else {
-    node.declaration = null;
-    node.specifiers = this.parseExportSpecifierList();
-    node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
-    this.semicolon();
-  }
-  return this.finishNode(node, "ExportNamedDeclaration");
-};
-
-lp.parseImport = function() {
-  var node = this.startNode();
-  this.next();
-  if (this.tok.type === tt.string) {
-    node.specifiers = [];
-    node.source = this.parseExprAtom();
-    node.kind = '';
-  } else {
-    if (this.tok.type === tt.name && this.tok.value !== "from") {
-      var elt = this.startNode();
-      elt.local = this.parseIdent();
-      this.finishNode(elt, "ImportDefaultSpecifier");
-      this.eat(tt.comma);
-    }
-    node.specifiers = this.parseImportSpecifierList();
-    node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
-    if (elt) node.specifiers.unshift(elt);
-  }
-  this.semicolon();
-  return this.finishNode(node, "ImportDeclaration");
-};
-
-lp.parseImportSpecifierList = function() {
-  var elts = [];
-  if (this.tok.type === tt.star) {
-    var elt = this.startNode();
-    this.next();
-    if (this.eatContextual("as")) elt.local = this.parseIdent();
-    elts.push(this.finishNode(elt, "ImportNamespaceSpecifier"));
-  } else {
-    var indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart;
-    this.pushCx();
-    this.eat(tt.braceL);
-    if (this.curLineStart > continuedLine) continuedLine = this.curLineStart;
-    while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
-      var elt = this.startNode();
-      if (this.eat(tt.star)) {
-        if (this.eatContextual("as")) elt.local = this.parseIdent();
-        this.finishNode(elt, "ImportNamespaceSpecifier");
-      } else {
-        if (this.isContextual("from")) break;
-        elt.imported = this.parseIdent();
-        elt.local = this.eatContextual("as") ? this.parseIdent() : elt.imported;
-        this.finishNode(elt, "ImportSpecifier");
-      }
-      elts.push(elt);
-      this.eat(tt.comma);
-    }
-    this.eat(tt.braceR);
-    this.popCx();
-  }
-  return elts;
-};
-
-lp.parseExportSpecifierList = function() {
-  var elts = [];
-  var indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart;
-  this.pushCx();
-  this.eat(tt.braceL);
-  if (this.curLineStart > continuedLine) continuedLine = this.curLineStart;
-  while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
-    if (this.isContextual("from")) break;
-    var elt = this.startNode();
-    elt.local = this.parseIdent();
-    elt.exported = this.eatContextual("as") ? this.parseIdent() : elt.local;
-    this.finishNode(elt, "ExportSpecifier");
-    elts.push(elt);
-    this.eat(tt.comma);
-  }
-  this.eat(tt.braceR);
-  this.popCx();
-  return elts;
-};
+  this.initFunction(node)
+  node.params = this.toAssignableList(params)
+  node.expression = this.tok.type !== tt.braceL
+  node.body = node.expression ? this.parseMaybeAssign() : this.parseBlock()
+  return this.finishNode(node, "ArrowFunctionExpression")
+}
 
 lp.parseExprList = function(close, allowEmpty) {
-  var indent = this.curIndent, line = this.curLineStart, elts = [];
+  let indent = this.curIndent, line = this.curLineStart, elts = []
   this.next(); // Opening bracket
   while (!this.closes(close, indent + 1, line)) {
     if (this.eat(tt.comma)) {
-      elts.push(allowEmpty ? null : this.dummyIdent());
-      continue;
+      elts.push(allowEmpty ? null : this.dummyIdent())
+      continue
     }
-    var elt = this.parseMaybeAssign();
+    let elt = this.parseMaybeAssign()
     if (isDummy(elt)) {
-      if (this.closes(close, indent, line)) break;
-      this.next();
+      if (this.closes(close, indent, line)) break
+      this.next()
     } else {
-      elts.push(elt);
+      elts.push(elt)
     }
-    this.eat(tt.comma);
+    this.eat(tt.comma)
   }
-  this.popCx();
+  this.popCx()
   if (!this.eat(close)) {
     // If there is no closing brace, make the node span to the start
     // of the next token (this is useful for Tern)
-    this.last.end = this.tok.start;
-    if (this.options.locations) this.last.loc.end = this.tok.loc.start;
+    this.last.end = this.tok.start
+    if (this.options.locations) this.last.loc.end = this.tok.loc.start
   }
-  return elts;
-};
+  return elts
+}
diff --git a/src/loose/parseutil.js b/src/loose/parseutil.js
index 5f656ec282..3e2c80418f 100644
--- a/src/loose/parseutil.js
+++ b/src/loose/parseutil.js
@@ -4,123 +4,123 @@ import {Node, SourceLocation, lineBreak, isNewLine, tokTypes as tt} from ".."
 const lp = LooseParser.prototype
 
 lp.startNode = function() {
-  var node = new Node;
-  node.start = this.tok.start;
+  let node = new Node
+  node.start = this.tok.start
   if (this.options.locations)
-    node.loc = new SourceLocation(this.toks, this.tok.loc.start);
+    node.loc = new SourceLocation(this.toks, this.tok.loc.start)
   if (this.options.directSourceFile)
-    node.sourceFile = this.options.directSourceFile;
+    node.sourceFile = this.options.directSourceFile
   if (this.options.ranges)
-    node.range = [this.tok.start, 0];
-  return node;
-};
+    node.range = [this.tok.start, 0]
+  return node
+}
 
 lp.storeCurrentPos = function() {
-  return this.options.locations ? [this.tok.start, this.tok.loc.start] : this.tok.start;
-};
+  return this.options.locations ? [this.tok.start, this.tok.loc.start] : this.tok.start
+}
 
 lp.startNodeAt = function(pos) {
-  var node = new Node;
+  let node = new Node
   if (this.options.locations) {
-    node.start = pos[0];
-    node.loc = new SourceLocation(this.toks, pos[1]);
-    pos = pos[0];
+    node.start = pos[0]
+    node.loc = new SourceLocation(this.toks, pos[1])
+    pos = pos[0]
   } else {
-    node.start = pos;
+    node.start = pos
   }
   if (this.options.directSourceFile)
-    node.sourceFile = this.options.directSourceFile;
+    node.sourceFile = this.options.directSourceFile
   if (this.options.ranges)
-    node.range = [pos, 0];
-  return node;
-};
+    node.range = [pos, 0]
+  return node
+}
 
 lp.finishNode = function(node, type) {
-  node.type = type;
-  node.end = this.last.end;
+  node.type = type
+  node.end = this.last.end
   if (this.options.locations)
-    node.loc.end = this.last.loc.end;
+    node.loc.end = this.last.loc.end
   if (this.options.ranges)
-    node.range[1] = this.last.end;
-  return node;
-};
+    node.range[1] = this.last.end
+  return node
+}
 
 lp.dummyIdent = function() {
-  var dummy = this.startNode();
-  dummy.name = "✖";
-  return this.finishNode(dummy, "Identifier");
-};
+  let dummy = this.startNode()
+  dummy.name = "✖"
+  return this.finishNode(dummy, "Identifier")
+}
 
-export function isDummy(node) { return node.name == "✖"; }
+export function isDummy(node) { return node.name == "✖" }
 
 lp.eat = function(type) {
   if (this.tok.type === type) {
-    this.next();
-    return true;
+    this.next()
+    return true
   } else {
-    return false;
+    return false
   }
-};
+}
 
 lp.isContextual = function(name) {
-  return this.tok.type === tt.name && this.tok.value === name;
-};
+  return this.tok.type === tt.name && this.tok.value === name
+}
 
 lp.eatContextual = function(name) {
-  return this.tok.value === name && this.eat(tt.name);
-};
+  return this.tok.value === name && this.eat(tt.name)
+}
 
 lp.canInsertSemicolon = function() {
   return this.tok.type === tt.eof || this.tok.type === tt.braceR ||
-    lineBreak.test(this.input.slice(this.last.end, this.tok.start));
-};
+    lineBreak.test(this.input.slice(this.last.end, this.tok.start))
+}
 
 lp.semicolon = function() {
-  return this.eat(tt.semi);
-};
+  return this.eat(tt.semi)
+}
 
 lp.expect = function(type) {
-  if (this.eat(type)) return true;
-  for (var i = 1; i <= 2; i++) {
+  if (this.eat(type)) return true
+  for (let i = 1; i <= 2; i++) {
     if (this.lookAhead(i).type == type) {
-      for (var j = 0; j < i; j++) this.next();
-      return true;
+      for (let j = 0; j < i; j++) this.next()
+      return true
     }
   }
-};
+}
 
 lp.pushCx = function() {
-  this.context.push(this.curIndent);
-};
+  this.context.push(this.curIndent)
+}
 lp.popCx = function() {
-  this.curIndent = this.context.pop();
-};
+  this.curIndent = this.context.pop()
+}
 
 lp.lineEnd = function(pos) {
-  while (pos < this.input.length && !isNewLine(this.input.charCodeAt(pos))) ++pos;
-  return pos;
-};
+  while (pos < this.input.length && !isNewLine(this.input.charCodeAt(pos))) ++pos
+  return pos
+}
 
 lp.indentationAfter = function(pos) {
-  for (var count = 0;; ++pos) {
-    var ch = this.input.charCodeAt(pos);
-    if (ch === 32) ++count;
-    else if (ch === 9) count += this.options.tabSize;
-    else return count;
+  for (let count = 0;; ++pos) {
+    let ch = this.input.charCodeAt(pos)
+    if (ch === 32) ++count
+    else if (ch === 9) count += this.options.tabSize
+    else return count
   }
-};
+}
 
 lp.closes = function(closeTok, indent, line, blockHeuristic) {
-  if (this.tok.type === closeTok || this.tok.type === tt.eof) return true;
+  if (this.tok.type === closeTok || this.tok.type === tt.eof) return true
   return line != this.curLineStart && this.curIndent < indent && this.tokenStartsLine() &&
     (!blockHeuristic || this.nextLineStart >= this.input.length ||
-     this.indentationAfter(this.nextLineStart) < indent);
-};
+     this.indentationAfter(this.nextLineStart) < indent)
+}
 
 lp.tokenStartsLine = function() {
-  for (var p = this.tok.start - 1; p >= this.curLineStart; --p) {
-    var ch = this.input.charCodeAt(p);
-    if (ch !== 9 && ch !== 32) return false;
+  for (let p = this.tok.start - 1; p >= this.curLineStart; --p) {
+    let ch = this.input.charCodeAt(p)
+    if (ch !== 9 && ch !== 32) return false
   }
-  return true;
-};
+  return true
+}
diff --git a/src/loose/state.js b/src/loose/state.js
index 3854da2261..fbf1227ab3 100644
--- a/src/loose/state.js
+++ b/src/loose/state.js
@@ -2,16 +2,16 @@ import {tokenizer, SourceLocation, tokTypes as tt} from ".."
 
 export function LooseParser(input, options) {
   this.toks = tokenizer(input, options)
-  this.options = this.toks.options;
-  this.input = this.toks.input;
-  this.tok = this.last = {type: tt.eof, start: 0, end: 0};
+  this.options = this.toks.options
+  this.input = this.toks.input
+  this.tok = this.last = {type: tt.eof, start: 0, end: 0}
   if (this.options.locations) {
-    var here = this.toks.curPosition();
-    this.tok.loc = new SourceLocation(this.toks, here, here);
+    let here = this.toks.curPosition()
+    this.tok.loc = new SourceLocation(this.toks, here, here)
   }
   this.ahead = []; // Tokens ahead
   this.context = []; // Indentation contexted
-  this.curIndent = 0;
-  this.curLineStart = 0;
-  this.nextLineStart = this.lineEnd(this.curLineStart) + 1;
+  this.curIndent = 0
+  this.curLineStart = 0
+  this.nextLineStart = this.lineEnd(this.curLineStart) + 1
 }
diff --git a/src/loose/statement.js b/src/loose/statement.js
index 714d104b08..eddfe4f05e 100644
--- a/src/loose/statement.js
+++ b/src/loose/statement.js
@@ -5,307 +5,415 @@ import {getLineInfo, tokTypes as tt} from ".."
 const lp = LooseParser.prototype
 
 lp.parseTopLevel = function() {
-  var node = this.startNodeAt(this.options.locations ? [0, getLineInfo(this.input, 0)] : 0);
-  node.body = [];
-  while (this.tok.type !== tt.eof) node.body.push(this.parseStatement());
-  this.last = this.tok;
+  let node = this.startNodeAt(this.options.locations ? [0, getLineInfo(this.input, 0)] : 0)
+  node.body = []
+  while (this.tok.type !== tt.eof) node.body.push(this.parseStatement())
+  this.last = this.tok
   if (this.options.ecmaVersion >= 6) {
-    node.sourceType = this.options.sourceType;
+    node.sourceType = this.options.sourceType
   }
-  return this.finishNode(node, "Program");
-};
+  return this.finishNode(node, "Program")
+}
 
 lp.parseStatement = function() {
-  var starttype = this.tok.type, node = this.startNode();
+  let starttype = this.tok.type, node = this.startNode()
 
   switch (starttype) {
   case tt._break: case tt._continue:
-    this.next();
-    var isBreak = starttype === tt._break;
+    this.next()
+    let isBreak = starttype === tt._break
     if (this.semicolon() || this.canInsertSemicolon()) {
-      node.label = null;
+      node.label = null
     } else {
-      node.label = this.tok.type === tt.name ? this.parseIdent() : null;
-      this.semicolon();
+      node.label = this.tok.type === tt.name ? this.parseIdent() : null
+      this.semicolon()
     }
-    return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+    return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement")
 
   case tt._debugger:
-    this.next();
-    this.semicolon();
-    return this.finishNode(node, "DebuggerStatement");
+    this.next()
+    this.semicolon()
+    return this.finishNode(node, "DebuggerStatement")
 
   case tt._do:
-    this.next();
-    node.body = this.parseStatement();
-    node.test = this.eat(tt._while) ? this.parseParenExpression() : this.dummyIdent();
-    this.semicolon();
-    return this.finishNode(node, "DoWhileStatement");
+    this.next()
+    node.body = this.parseStatement()
+    node.test = this.eat(tt._while) ? this.parseParenExpression() : this.dummyIdent()
+    this.semicolon()
+    return this.finishNode(node, "DoWhileStatement")
 
   case tt._for:
-    this.next();
-    this.pushCx();
-    this.expect(tt.parenL);
-    if (this.tok.type === tt.semi) return this.parseFor(node, null);
+    this.next()
+    this.pushCx()
+    this.expect(tt.parenL)
+    if (this.tok.type === tt.semi) return this.parseFor(node, null)
     if (this.tok.type === tt._var || this.tok.type === tt._let || this.tok.type === tt._const) {
-      var init = this.parseVar(true);
+      let init = this.parseVar(true)
       if (init.declarations.length === 1 && (this.tok.type === tt._in || this.isContextual("of"))) {
-        return this.parseForIn(node, init);
+        return this.parseForIn(node, init)
       }
-      return this.parseFor(node, init);
+      return this.parseFor(node, init)
     }
-    var init = this.parseExpression(true);
+    let init = this.parseExpression(true)
     if (this.tok.type === tt._in || this.isContextual("of"))
-      return this.parseForIn(node, this.toAssignable(init));
-    return this.parseFor(node, init);
+      return this.parseForIn(node, this.toAssignable(init))
+    return this.parseFor(node, init)
 
   case tt._function:
-    this.next();
-    return this.parseFunction(node, true);
+    this.next()
+    return this.parseFunction(node, true)
 
   case tt._if:
-    this.next();
-    node.test = this.parseParenExpression();
-    node.consequent = this.parseStatement();
-    node.alternate = this.eat(tt._else) ? this.parseStatement() : null;
-    return this.finishNode(node, "IfStatement");
+    this.next()
+    node.test = this.parseParenExpression()
+    node.consequent = this.parseStatement()
+    node.alternate = this.eat(tt._else) ? this.parseStatement() : null
+    return this.finishNode(node, "IfStatement")
 
   case tt._return:
-    this.next();
-    if (this.eat(tt.semi) || this.canInsertSemicolon()) node.argument = null;
-    else { node.argument = this.parseExpression(); this.semicolon(); }
-    return this.finishNode(node, "ReturnStatement");
+    this.next()
+    if (this.eat(tt.semi) || this.canInsertSemicolon()) node.argument = null
+    else { node.argument = this.parseExpression(); this.semicolon() }
+    return this.finishNode(node, "ReturnStatement")
 
   case tt._switch:
-    var blockIndent = this.curIndent, line = this.curLineStart;
-    this.next();
-    node.discriminant = this.parseParenExpression();
-    node.cases = [];
-    this.pushCx();
-    this.expect(tt.braceL);
+    let blockIndent = this.curIndent, line = this.curLineStart
+    this.next()
+    node.discriminant = this.parseParenExpression()
+    node.cases = []
+    this.pushCx()
+    this.expect(tt.braceL)
 
-    for (var cur; !this.closes(tt.braceR, blockIndent, line, true);) {
+    let cur
+    while (!this.closes(tt.braceR, blockIndent, line, true)) {
       if (this.tok.type === tt._case || this.tok.type === tt._default) {
-        var isCase = this.tok.type === tt._case;
-        if (cur) this.finishNode(cur, "SwitchCase");
-        node.cases.push(cur = this.startNode());
-        cur.consequent = [];
-        this.next();
-        if (isCase) cur.test = this.parseExpression();
-        else cur.test = null;
-        this.expect(tt.colon);
+        let isCase = this.tok.type === tt._case
+        if (cur) this.finishNode(cur, "SwitchCase")
+        node.cases.push(cur = this.startNode())
+        cur.consequent = []
+        this.next()
+        if (isCase) cur.test = this.parseExpression()
+        else cur.test = null
+        this.expect(tt.colon)
       } else {
         if (!cur) {
-          node.cases.push(cur = this.startNode());
-          cur.consequent = [];
-          cur.test = null;
+          node.cases.push(cur = this.startNode())
+          cur.consequent = []
+          cur.test = null
         }
-        cur.consequent.push(this.parseStatement());
+        cur.consequent.push(this.parseStatement())
       }
     }
-    if (cur) this.finishNode(cur, "SwitchCase");
-    this.popCx();
-    this.eat(tt.braceR);
-    return this.finishNode(node, "SwitchStatement");
+    if (cur) this.finishNode(cur, "SwitchCase")
+    this.popCx()
+    this.eat(tt.braceR)
+    return this.finishNode(node, "SwitchStatement")
 
   case tt._throw:
-    this.next();
-    node.argument = this.parseExpression();
-    this.semicolon();
-    return this.finishNode(node, "ThrowStatement");
+    this.next()
+    node.argument = this.parseExpression()
+    this.semicolon()
+    return this.finishNode(node, "ThrowStatement")
 
   case tt._try:
-    this.next();
-    node.block = this.parseBlock();
-    node.handler = null;
+    this.next()
+    node.block = this.parseBlock()
+    node.handler = null
     if (this.tok.type === tt._catch) {
-      var clause = this.startNode();
-      this.next();
-      this.expect(tt.parenL);
-      clause.param = this.toAssignable(this.parseExprAtom());
-      this.expect(tt.parenR);
-      clause.guard = null;
-      clause.body = this.parseBlock();
-      node.handler = this.finishNode(clause, "CatchClause");
+      let clause = this.startNode()
+      this.next()
+      this.expect(tt.parenL)
+      clause.param = this.toAssignable(this.parseExprAtom())
+      this.expect(tt.parenR)
+      clause.guard = null
+      clause.body = this.parseBlock()
+      node.handler = this.finishNode(clause, "CatchClause")
     }
-    node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;
-    if (!node.handler && !node.finalizer) return node.block;
-    return this.finishNode(node, "TryStatement");
+    node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null
+    if (!node.handler && !node.finalizer) return node.block
+    return this.finishNode(node, "TryStatement")
 
   case tt._var:
   case tt._let:
   case tt._const:
-    return this.parseVar();
+    return this.parseVar()
 
   case tt._while:
-    this.next();
-    node.test = this.parseParenExpression();
-    node.body = this.parseStatement();
-    return this.finishNode(node, "WhileStatement");
+    this.next()
+    node.test = this.parseParenExpression()
+    node.body = this.parseStatement()
+    return this.finishNode(node, "WhileStatement")
 
   case tt._with:
-    this.next();
-    node.object = this.parseParenExpression();
-    node.body = this.parseStatement();
-    return this.finishNode(node, "WithStatement");
+    this.next()
+    node.object = this.parseParenExpression()
+    node.body = this.parseStatement()
+    return this.finishNode(node, "WithStatement")
 
   case tt.braceL:
-    return this.parseBlock();
+    return this.parseBlock()
 
   case tt.semi:
-    this.next();
-    return this.finishNode(node, "EmptyStatement");
+    this.next()
+    return this.finishNode(node, "EmptyStatement")
 
   case tt._class:
-    return this.parseClass(true);
+    return this.parseClass(true)
 
   case tt._import:
-    return this.parseImport();
+    return this.parseImport()
 
   case tt._export:
-    return this.parseExport();
+    return this.parseExport()
 
   default:
-    var expr = this.parseExpression();
+    let expr = this.parseExpression()
     if (isDummy(expr)) {
-      this.next();
-      if (this.tok.type === tt.eof) return this.finishNode(node, "EmptyStatement");
-      return this.parseStatement();
+      this.next()
+      if (this.tok.type === tt.eof) return this.finishNode(node, "EmptyStatement")
+      return this.parseStatement()
     } else if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon)) {
-      node.body = this.parseStatement();
-      node.label = expr;
-      return this.finishNode(node, "LabeledStatement");
+      node.body = this.parseStatement()
+      node.label = expr
+      return this.finishNode(node, "LabeledStatement")
     } else {
-      node.expression = expr;
-      this.semicolon();
-      return this.finishNode(node, "ExpressionStatement");
+      node.expression = expr
+      this.semicolon()
+      return this.finishNode(node, "ExpressionStatement")
     }
   }
-};
+}
 
 lp.parseBlock = function() {
-  var node = this.startNode();
-  this.pushCx();
-  this.expect(tt.braceL);
-  var blockIndent = this.curIndent, line = this.curLineStart;
-  node.body = [];
+  let node = this.startNode()
+  this.pushCx()
+  this.expect(tt.braceL)
+  let blockIndent = this.curIndent, line = this.curLineStart
+  node.body = []
   while (!this.closes(tt.braceR, blockIndent, line, true))
-    node.body.push(this.parseStatement());
-  this.popCx();
-  this.eat(tt.braceR);
-  return this.finishNode(node, "BlockStatement");
-};
+    node.body.push(this.parseStatement())
+  this.popCx()
+  this.eat(tt.braceR)
+  return this.finishNode(node, "BlockStatement")
+}
 
 lp.parseFor = function(node, init) {
-  node.init = init;
-  node.test = node.update = null;
-  if (this.eat(tt.semi) && this.tok.type !== tt.semi) node.test = this.parseExpression();
-  if (this.eat(tt.semi) && this.tok.type !== tt.parenR) node.update = this.parseExpression();
-  this.popCx();
-  this.expect(tt.parenR);
-  node.body = this.parseStatement();
-  return this.finishNode(node, "ForStatement");
-};
+  node.init = init
+  node.test = node.update = null
+  if (this.eat(tt.semi) && this.tok.type !== tt.semi) node.test = this.parseExpression()
+  if (this.eat(tt.semi) && this.tok.type !== tt.parenR) node.update = this.parseExpression()
+  this.popCx()
+  this.expect(tt.parenR)
+  node.body = this.parseStatement()
+  return this.finishNode(node, "ForStatement")
+}
 
 lp.parseForIn = function(node, init) {
-  var type = this.tok.type === tt._in ? "ForInStatement" : "ForOfStatement";
-  this.next();
-  node.left = init;
-  node.right = this.parseExpression();
-  this.popCx();
-  this.expect(tt.parenR);
-  node.body = this.parseStatement();
-  return this.finishNode(node, type);
-};
+  let type = this.tok.type === tt._in ? "ForInStatement" : "ForOfStatement"
+  this.next()
+  node.left = init
+  node.right = this.parseExpression()
+  this.popCx()
+  this.expect(tt.parenR)
+  node.body = this.parseStatement()
+  return this.finishNode(node, type)
+}
 
 lp.parseVar = function(noIn) {
-  var node = this.startNode();
-  node.kind = this.tok.type.keyword;
-  this.next();
-  node.declarations = [];
+  let node = this.startNode()
+  node.kind = this.tok.type.keyword
+  this.next()
+  node.declarations = []
   do {
-    var decl = this.startNode();
-    decl.id = this.options.ecmaVersion >= 6 ? this.toAssignable(this.parseExprAtom()) : this.parseIdent();
-    decl.init = this.eat(tt.eq) ? this.parseMaybeAssign(noIn) : null;
-    node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
-  } while (this.eat(tt.comma));
+    let decl = this.startNode()
+    decl.id = this.options.ecmaVersion >= 6 ? this.toAssignable(this.parseExprAtom()) : this.parseIdent()
+    decl.init = this.eat(tt.eq) ? this.parseMaybeAssign(noIn) : null
+    node.declarations.push(this.finishNode(decl, "VariableDeclarator"))
+  } while (this.eat(tt.comma))
   if (!node.declarations.length) {
-    var decl = this.startNode();
-    decl.id = this.dummyIdent();
-    node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
+    let decl = this.startNode()
+    decl.id = this.dummyIdent()
+    node.declarations.push(this.finishNode(decl, "VariableDeclarator"))
   }
-  if (!noIn) this.semicolon();
-  return this.finishNode(node, "VariableDeclaration");
-};
+  if (!noIn) this.semicolon()
+  return this.finishNode(node, "VariableDeclaration")
+}
 
 lp.parseClass = function(isStatement) {
-  var node = this.startNode();
-  this.next();
-  if (this.tok.type === tt.name) node.id = this.parseIdent();
-  else if (isStatement) node.id = this.dummyIdent();
-  else node.id = null;
-  node.superClass = this.eat(tt._extends) ? this.parseExpression() : null;
-  node.body = this.startNode();
-  node.body.body = [];
-  this.pushCx();
-  var indent = this.curIndent + 1, line = this.curLineStart;
-  this.eat(tt.braceL);
-  if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart; }
+  let node = this.startNode()
+  this.next()
+  if (this.tok.type === tt.name) node.id = this.parseIdent()
+  else if (isStatement) node.id = this.dummyIdent()
+  else node.id = null
+  node.superClass = this.eat(tt._extends) ? this.parseExpression() : null
+  node.body = this.startNode()
+  node.body.body = []
+  this.pushCx()
+  let indent = this.curIndent + 1, line = this.curLineStart
+  this.eat(tt.braceL)
+  if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart }
   while (!this.closes(tt.braceR, indent, line)) {
-    if (this.semicolon()) continue;
-    var method = this.startNode(), isGenerator, start;
+    if (this.semicolon()) continue
+    let method = this.startNode(), isGenerator, start
     if (this.options.ecmaVersion >= 6) {
-      method['static'] = false;
-      isGenerator = this.eat(tt.star);
+      method['static'] = false
+      isGenerator = this.eat(tt.star)
     }
-    this.parsePropertyName(method);
-    if (isDummy(method.key)) { if (isDummy(this.parseMaybeAssign())) this.next(); this.eat(tt.comma); continue; }
+    this.parsePropertyName(method)
+    if (isDummy(method.key)) { if (isDummy(this.parseMaybeAssign())) this.next(); this.eat(tt.comma); continue }
     if (method.key.type === "Identifier" && !method.computed && method.key.name === "static" &&
         (this.tok.type != tt.parenL && this.tok.type != tt.braceL)) {
-      method['static'] = true;
-      isGenerator = this.eat(tt.star);
-      this.parsePropertyName(method);
+      method['static'] = true
+      isGenerator = this.eat(tt.star)
+      this.parsePropertyName(method)
     } else {
-      method['static'] = false;
+      method['static'] = false
     }
     if (this.options.ecmaVersion >= 5 && method.key.type === "Identifier" &&
         !method.computed && (method.key.name === "get" || method.key.name === "set") &&
         this.tok.type !== tt.parenL && this.tok.type !== tt.braceL) {
-      method.kind = method.key.name;
-      this.parsePropertyName(method);
-      method.value = this.parseMethod(false);
+      method.kind = method.key.name
+      this.parsePropertyName(method)
+      method.value = this.parseMethod(false)
     } else {
       if (!method.computed && !method['static'] && !isGenerator && (
         method.key.type === "Identifier" && method.key.name === "constructor" ||
           method.key.type === "Literal" && method.key.value === "constructor")) {
-        method.kind = "constructor";
+        method.kind = "constructor"
       } else {
-        method.kind =  "method";
+        method.kind =  "method"
       }
-      method.value = this.parseMethod(isGenerator);
+      method.value = this.parseMethod(isGenerator)
     }
-    node.body.body.push(this.finishNode(method, "MethodDefinition"));
+    node.body.body.push(this.finishNode(method, "MethodDefinition"))
   }
-  this.popCx();
+  this.popCx()
   if (!this.eat(tt.braceR)) {
     // If there is no closing brace, make the node span to the start
     // of the next token (this is useful for Tern)
-    this.last.end = this.tok.start;
-    if (this.options.locations) this.last.loc.end = this.tok.loc.start;
+    this.last.end = this.tok.start
+    if (this.options.locations) this.last.loc.end = this.tok.loc.start
   }
-  this.semicolon();
-  this.finishNode(node.body, "ClassBody");
-  return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
-};
+  this.semicolon()
+  this.finishNode(node.body, "ClassBody")
+  return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
+}
 
 lp.parseFunction = function(node, isStatement) {
-  this.initFunction(node);
+  this.initFunction(node)
   if (this.options.ecmaVersion >= 6) {
-    node.generator = this.eat(tt.star);
+    node.generator = this.eat(tt.star)
   }
-  if (this.tok.type === tt.name) node.id = this.parseIdent();
-  else if (isStatement) node.id = this.dummyIdent();
-  node.params = this.parseFunctionParams();
-  node.body = this.parseBlock();
-  return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-};
+  if (this.tok.type === tt.name) node.id = this.parseIdent()
+  else if (isStatement) node.id = this.dummyIdent()
+  node.params = this.parseFunctionParams()
+  node.body = this.parseBlock()
+  return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression")
+}
+
+lp.parseExport = function() {
+  let node = this.startNode()
+  this.next()
+  if (this.eat(tt.star)) {
+    node.source = this.eatContextual("from") ? this.parseExprAtom() : null
+    return this.finishNode(node, "ExportAllDeclaration")
+  }
+  if (this.eat(tt._default)) {
+    let expr = this.parseMaybeAssign()
+    if (expr.id) {
+      switch (expr.type) {
+      case "FunctionExpression": expr.type = "FunctionDeclaration"; break
+      case "ClassExpression": expr.type = "ClassDeclaration"; break
+      }
+    }
+    node.declaration = expr
+    this.semicolon()
+    return this.finishNode(node, "ExportDefaultDeclaration")
+  }
+  if (this.tok.type.keyword) {
+    node.declaration = this.parseStatement()
+    node.specifiers = []
+    node.source = null
+  } else {
+    node.declaration = null
+    node.specifiers = this.parseExportSpecifierList()
+    node.source = this.eatContextual("from") ? this.parseExprAtom() : null
+    this.semicolon()
+  }
+  return this.finishNode(node, "ExportNamedDeclaration")
+}
+
+lp.parseImport = function() {
+  let node = this.startNode()
+  this.next()
+  if (this.tok.type === tt.string) {
+    node.specifiers = []
+    node.source = this.parseExprAtom()
+    node.kind = ''
+  } else {
+    let elt
+    if (this.tok.type === tt.name && this.tok.value !== "from") {
+      elt = this.startNode()
+      elt.local = this.parseIdent()
+      this.finishNode(elt, "ImportDefaultSpecifier")
+      this.eat(tt.comma)
+    }
+    node.specifiers = this.parseImportSpecifierList()
+    node.source = this.eatContextual("from") ? this.parseExprAtom() : null
+    if (elt) node.specifiers.unshift(elt)
+  }
+  this.semicolon()
+  return this.finishNode(node, "ImportDeclaration")
+}
+
+lp.parseImportSpecifierList = function() {
+  let elts = []
+  if (this.tok.type === tt.star) {
+    let elt = this.startNode()
+    this.next()
+    if (this.eatContextual("as")) elt.local = this.parseIdent()
+    elts.push(this.finishNode(elt, "ImportNamespaceSpecifier"))
+  } else {
+    let indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart
+    this.pushCx()
+    this.eat(tt.braceL)
+    if (this.curLineStart > continuedLine) continuedLine = this.curLineStart
+    while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
+      let elt = this.startNode()
+      if (this.eat(tt.star)) {
+        if (this.eatContextual("as")) elt.local = this.parseIdent()
+        this.finishNode(elt, "ImportNamespaceSpecifier")
+      } else {
+        if (this.isContextual("from")) break
+        elt.imported = this.parseIdent()
+        elt.local = this.eatContextual("as") ? this.parseIdent() : elt.imported
+        this.finishNode(elt, "ImportSpecifier")
+      }
+      elts.push(elt)
+      this.eat(tt.comma)
+    }
+    this.eat(tt.braceR)
+    this.popCx()
+  }
+  return elts
+}
+
+lp.parseExportSpecifierList = function() {
+  let elts = []
+  let indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart
+  this.pushCx()
+  this.eat(tt.braceL)
+  if (this.curLineStart > continuedLine) continuedLine = this.curLineStart
+  while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
+    if (this.isContextual("from")) break
+    let elt = this.startNode()
+    elt.local = this.parseIdent()
+    elt.exported = this.eatContextual("as") ? this.parseIdent() : elt.local
+    this.finishNode(elt, "ExportSpecifier")
+    elts.push(elt)
+    this.eat(tt.comma)
+  }
+  this.eat(tt.braceR)
+  this.popCx()
+  return elts
+}
diff --git a/src/loose/tokenize.js b/src/loose/tokenize.js
index ba3d14a8df..edecc17b5b 100644
--- a/src/loose/tokenize.js
+++ b/src/loose/tokenize.js
@@ -8,101 +8,101 @@ function isSpace(ch) {
 }
 
 lp.next = function() {
-  this.last = this.tok;
+  this.last = this.tok
   if (this.ahead.length)
-    this.tok = this.ahead.shift();
+    this.tok = this.ahead.shift()
   else
-    this.tok = this.readToken();
+    this.tok = this.readToken()
 
   if (this.tok.start >= this.nextLineStart) {
     while (this.tok.start >= this.nextLineStart) {
-      this.curLineStart = this.nextLineStart;
-      this.nextLineStart = this.lineEnd(this.curLineStart) + 1;
+      this.curLineStart = this.nextLineStart
+      this.nextLineStart = this.lineEnd(this.curLineStart) + 1
     }
-    this.curIndent = this.indentationAfter(this.curLineStart);
+    this.curIndent = this.indentationAfter(this.curLineStart)
   }
-};
+}
 
 lp.readToken = function() {
   for (;;) {
     try {
-      this.toks.next();
+      this.toks.next()
       if (this.toks.type === tt.dot &&
           this.input.substr(this.toks.end, 1) === "." &&
           this.options.ecmaVersion >= 6) {
-        this.toks.end++;
-        this.toks.type = tt.ellipsis;
+        this.toks.end++
+        this.toks.type = tt.ellipsis
       }
-      return new Token(this.toks);
+      return new Token(this.toks)
     } catch(e) {
-      if (!(e instanceof SyntaxError)) throw e;
+      if (!(e instanceof SyntaxError)) throw e
 
       // Try to skip some text, based on the error message, and then continue
-      var msg = e.message, pos = e.raisedAt, replace = true;
+      let msg = e.message, pos = e.raisedAt, replace = true
       if (/unterminated/i.test(msg)) {
-        pos = this.lineEnd(e.pos + 1);
+        pos = this.lineEnd(e.pos + 1)
         if (/string/.test(msg)) {
-          replace = {start: e.pos, end: pos, type: tt.string, value: this.input.slice(e.pos + 1, pos)};
+          replace = {start: e.pos, end: pos, type: tt.string, value: this.input.slice(e.pos + 1, pos)}
         } else if (/regular expr/i.test(msg)) {
-          var re = this.input.slice(e.pos, pos);
-          try { re = new RegExp(re); } catch(e) {}
-          replace = {start: e.pos, end: pos, type: tt.regexp, value: re};
+          let re = this.input.slice(e.pos, pos)
+          try { re = new RegExp(re) } catch(e) {}
+          replace = {start: e.pos, end: pos, type: tt.regexp, value: re}
         } else if (/template/.test(msg)) {
           replace = {start: e.pos, end: pos,
                      type: tt.template,
-                     value: this.input.slice(e.pos, pos)};
+                     value: this.input.slice(e.pos, pos)}
         } else {
-          replace = false;
+          replace = false
         }
       } else if (/invalid (unicode|regexp|number)|expecting unicode|octal literal|is reserved|directly after number/i.test(msg)) {
-        while (pos < this.input.length && !isSpace(this.input.charCodeAt(pos))) ++pos;
+        while (pos < this.input.length && !isSpace(this.input.charCodeAt(pos))) ++pos
       } else if (/character escape|expected hexadecimal/i.test(msg)) {
         while (pos < this.input.length) {
-          var ch = this.input.charCodeAt(pos++);
-          if (ch === 34 || ch === 39 || isNewLine(ch)) break;
+          let ch = this.input.charCodeAt(pos++)
+          if (ch === 34 || ch === 39 || isNewLine(ch)) break
         }
       } else if (/unexpected character/i.test(msg)) {
-        pos++;
-        replace = false;
+        pos++
+        replace = false
       } else if (/regular expression/i.test(msg)) {
-        replace = true;
+        replace = true
       } else {
-        throw e;
+        throw e
       }
-      this.resetTo(pos);
-      if (replace === true) replace = {start: pos, end: pos, type: tt.name, value: "✖"};
+      this.resetTo(pos)
+      if (replace === true) replace = {start: pos, end: pos, type: tt.name, value: "✖"}
       if (replace) {
         if (this.options.locations)
           replace.loc = new SourceLocation(
             this.toks,
             getLineInfo(this.input, replace.start),
-            getLineInfo(this.input, replace.end));
-        return replace;
+            getLineInfo(this.input, replace.end))
+        return replace
       }
     }
   }
-};
+}
 
 lp.resetTo = function(pos) {
-  this.toks.pos = pos;
-  var ch = this.input.charAt(pos - 1);
+  this.toks.pos = pos
+  let ch = this.input.charAt(pos - 1)
   this.toks.exprAllowed = !ch || /[\[\{\(,;:?\/*=+\-~!|&%^<>]/.test(ch) ||
     /[enwfd]/.test(ch) &&
-    /\b(keywords|case|else|return|throw|new|in|(instance|type)of|delete|void)$/.test(this.input.slice(pos - 10, pos));
+    /\b(keywords|case|else|return|throw|new|in|(instance|type)of|delete|void)$/.test(this.input.slice(pos - 10, pos))
 
   if (this.options.locations) {
-    this.toks.curLine = 1;
-    this.toks.lineStart = lineBreakG.lastIndex = 0;
-    var match;
+    this.toks.curLine = 1
+    this.toks.lineStart = lineBreakG.lastIndex = 0
+    let match
     while ((match = lineBreakG.exec(this.input)) && match.index < pos) {
-      ++this.toks.curLine;
-      this.toks.lineStart = match.index + match[0].length;
+      ++this.toks.curLine
+      this.toks.lineStart = match.index + match[0].length
     }
   }
-};
+}
 
 lp.lookAhead = function(n) {
   while (n > this.ahead.length)
-    this.ahead.push(this.readToken());
-  return this.ahead[n - 1];
-};
+    this.ahead.push(this.readToken())
+  return this.ahead[n - 1]
+}
diff --git a/src/lval.js b/src/lval.js
index 75ef38147c..660f1c7c74 100644
--- a/src/lval.js
+++ b/src/lval.js
@@ -15,134 +15,134 @@ pp.toAssignable = function(node, isBinding) {
     case "ObjectPattern":
     case "ArrayPattern":
     case "AssignmentPattern":
-      break;
+      break
 
     case "ObjectExpression":
-      node.type = "ObjectPattern";
-      for (var i = 0; i < node.properties.length; i++) {
-        var prop = node.properties[i];
-        if (prop.kind !== "init") this.raise(prop.key.start, "Object pattern can't contain getter or setter");
-        this.toAssignable(prop.value, isBinding);
+      node.type = "ObjectPattern"
+      for (let i = 0; i < node.properties.length; i++) {
+        let prop = node.properties[i]
+        if (prop.kind !== "init") this.raise(prop.key.start, "Object pattern can't contain getter or setter")
+        this.toAssignable(prop.value, isBinding)
       }
-      break;
+      break
 
     case "ArrayExpression":
-      node.type = "ArrayPattern";
-      this.toAssignableList(node.elements, isBinding);
-      break;
+      node.type = "ArrayPattern"
+      this.toAssignableList(node.elements, isBinding)
+      break
 
     case "AssignmentExpression":
       if (node.operator === "=") {
-        node.type = "AssignmentPattern";
+        node.type = "AssignmentPattern"
       } else {
-        this.raise(node.left.end, "Only '=' operator can be used for specifying default value.");
+        this.raise(node.left.end, "Only '=' operator can be used for specifying default value.")
       }
-      break;
+      break
 
     case "MemberExpression":
-      if (!isBinding) break;
+      if (!isBinding) break
 
     default:
-      this.raise(node.start, "Assigning to rvalue");
+      this.raise(node.start, "Assigning to rvalue")
     }
   }
-  return node;
-};
+  return node
+}
 
 // Convert list of expression atoms to binding list.
 
 pp.toAssignableList = function(exprList, isBinding) {
-  var end = exprList.length;
+  let end = exprList.length
   if (end) {
-    var last = exprList[end - 1];
+    let last = exprList[end - 1]
     if (last && last.type == "RestElement") {
-      --end;
+      --end
     } else if (last && last.type == "SpreadElement") {
-      last.type = "RestElement";
-      var arg = last.argument;
-      this.toAssignable(arg, isBinding);
+      last.type = "RestElement"
+      let arg = last.argument
+      this.toAssignable(arg, isBinding)
       if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern")
-        this.unexpected(arg.start);
-      --end;
+        this.unexpected(arg.start)
+      --end
     }
   }
-  for (var i = 0; i < end; i++) {
-    var elt = exprList[i];
-    if (elt) this.toAssignable(elt, isBinding);
+  for (let i = 0; i < end; i++) {
+    let elt = exprList[i]
+    if (elt) this.toAssignable(elt, isBinding)
   }
-  return exprList;
-};
+  return exprList
+}
 
 // Parses spread element.
 
 pp.parseSpread = function(refShorthandDefaultPos) {
-  var node = this.startNode();
-  this.next();
-  node.argument = this.parseMaybeAssign(refShorthandDefaultPos);
-  return this.finishNode(node, "SpreadElement");
-};
+  let node = this.startNode()
+  this.next()
+  node.argument = this.parseMaybeAssign(refShorthandDefaultPos)
+  return this.finishNode(node, "SpreadElement")
+}
 
 pp.parseRest = function() {
-  var node = this.startNode();
-  this.next();
-  node.argument = this.type === tt.name || this.type === tt.bracketL ? this.parseBindingAtom() : this.unexpected();
-  return this.finishNode(node, "RestElement");
-};
+  let node = this.startNode()
+  this.next()
+  node.argument = this.type === tt.name || this.type === tt.bracketL ? this.parseBindingAtom() : this.unexpected()
+  return this.finishNode(node, "RestElement")
+}
 
 // Parses lvalue (assignable) atom.
 
 pp.parseBindingAtom = function() {
-  if (this.options.ecmaVersion < 6) return this.parseIdent();
+  if (this.options.ecmaVersion < 6) return this.parseIdent()
   switch (this.type) {
   case tt.name:
-    return this.parseIdent();
+    return this.parseIdent()
 
   case tt.bracketL:
-    var node = this.startNode();
-    this.next();
-    node.elements = this.parseBindingList(tt.bracketR, true, true);
-    return this.finishNode(node, "ArrayPattern");
+    let node = this.startNode()
+    this.next()
+    node.elements = this.parseBindingList(tt.bracketR, true, true)
+    return this.finishNode(node, "ArrayPattern")
 
   case tt.braceL:
-    return this.parseObj(true);
+    return this.parseObj(true)
 
   default:
-    this.unexpected();
+    this.unexpected()
   }
-};
+}
 
 pp.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
-  var elts = [], first = true;
+  let elts = [], first = true
   while (!this.eat(close)) {
-    if (first) first = false;
-    else this.expect(tt.comma);
+    if (first) first = false
+    else this.expect(tt.comma)
     if (allowEmpty && this.type === tt.comma) {
-      elts.push(null);
+      elts.push(null)
     } else if (allowTrailingComma && this.afterTrailingComma(close)) {
-      break;
+      break
     } else if (this.type === tt.ellipsis) {
-      elts.push(this.parseRest());
-      this.expect(close);
-      break;
+      elts.push(this.parseRest())
+      this.expect(close)
+      break
     } else {
-      elts.push(this.parseMaybeDefault());
+      elts.push(this.parseMaybeDefault())
     }
   }
-  return elts;
-};
+  return elts
+}
 
 // Parses assignment pattern around given atom if possible.
 
 pp.parseMaybeDefault = function(startPos, left) {
-  startPos = startPos || this.markPosition();
-  left = left || this.parseBindingAtom();
-  if (!this.eat(tt.eq)) return left;
-  var node = this.startNodeAt(startPos);
-  node.operator = "=";
-  node.left = left;
-  node.right = this.parseMaybeAssign();
-  return this.finishNode(node, "AssignmentPattern");
-};
+  startPos = startPos || this.markPosition()
+  left = left || this.parseBindingAtom()
+  if (!this.eat(tt.eq)) return left
+  let node = this.startNodeAt(startPos)
+  node.operator = "="
+  node.left = left
+  node.right = this.parseMaybeAssign()
+  return this.finishNode(node, "AssignmentPattern")
+}
 
 // Verify that a node is an lval — something that can be assigned
 // to.
@@ -151,39 +151,39 @@ pp.checkLVal = function(expr, isBinding, checkClashes) {
   switch (expr.type) {
   case "Identifier":
     if (this.strict && (reservedWords.strictBind(expr.name) || reservedWords.strict(expr.name)))
-      this.raise(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode");
+      this.raise(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode")
     if (checkClashes) {
       if (has(checkClashes, expr.name))
-        this.raise(expr.start, "Argument name clash in strict mode");
-      checkClashes[expr.name] = true;
+        this.raise(expr.start, "Argument name clash in strict mode")
+      checkClashes[expr.name] = true
     }
-    break;
+    break
 
   case "MemberExpression":
-    if (isBinding) this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " member expression");
-    break;
+    if (isBinding) this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " member expression")
+    break
 
   case "ObjectPattern":
-    for (var i = 0; i < expr.properties.length; i++)
-      this.checkLVal(expr.properties[i].value, isBinding, checkClashes);
-    break;
+    for (let i = 0; i < expr.properties.length; i++)
+      this.checkLVal(expr.properties[i].value, isBinding, checkClashes)
+    break
 
   case "ArrayPattern":
-    for (var i = 0; i < expr.elements.length; i++) {
-      var elem = expr.elements[i];
-      if (elem) this.checkLVal(elem, isBinding, checkClashes);
+    for (let i = 0; i < expr.elements.length; i++) {
+      let elem = expr.elements[i]
+      if (elem) this.checkLVal(elem, isBinding, checkClashes)
     }
-    break;
+    break
 
   case "AssignmentPattern":
-    this.checkLVal(expr.left, isBinding, checkClashes);
-    break;
+    this.checkLVal(expr.left, isBinding, checkClashes)
+    break
 
   case "RestElement":
-    this.checkLVal(expr.argument, isBinding, checkClashes);
-    break;
+    this.checkLVal(expr.argument, isBinding, checkClashes)
+    break
 
   default:
-    this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " rvalue");
+    this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " rvalue")
   }
-};
+}
diff --git a/src/node.js b/src/node.js
index e756a9df0f..250f2dde0a 100644
--- a/src/node.js
+++ b/src/node.js
@@ -8,50 +8,50 @@ const pp = Parser.prototype
 export class Node {}
 
 pp.startNode = function() {
-  var node = new Node;
-  node.start = this.start;
+  let node = new Node
+  node.start = this.start
   if (this.options.locations)
-    node.loc = new SourceLocation(this, this.startLoc);
+    node.loc = new SourceLocation(this, this.startLoc)
   if (this.options.directSourceFile)
-    node.sourceFile = this.options.directSourceFile;
+    node.sourceFile = this.options.directSourceFile
   if (this.options.ranges)
-    node.range = [this.start, 0];
-  return node;
-};
+    node.range = [this.start, 0]
+  return node
+}
 
 pp.startNodeAt = function(pos) {
-  var node = new Node, start = pos;
+  let node = new Node, start = pos
   if (this.options.locations) {
-    node.loc = new SourceLocation(this, start[1]);
-    start = pos[0];
+    node.loc = new SourceLocation(this, start[1])
+    start = pos[0]
   }
-  node.start = start;
+  node.start = start
   if (this.options.directSourceFile)
-    node.sourceFile = this.options.directSourceFile;
+    node.sourceFile = this.options.directSourceFile
   if (this.options.ranges)
-    node.range = [start, 0];
-  return node;
-};
+    node.range = [start, 0]
+  return node
+}
 
 // Finish an AST node, adding `type` and `end` properties.
 
 pp.finishNode = function(node, type) {
-  node.type = type;
-  node.end = this.lastTokEnd;
+  node.type = type
+  node.end = this.lastTokEnd
   if (this.options.locations)
-    node.loc.end = this.lastTokEndLoc;
+    node.loc.end = this.lastTokEndLoc
   if (this.options.ranges)
-    node.range[1] = this.lastTokEnd;
-  return node;
-};
+    node.range[1] = this.lastTokEnd
+  return node
+}
 
 // Finish node at given position
 
 pp.finishNodeAt = function(node, type, pos) {
-  if (this.options.locations) { node.loc.end = pos[1]; pos = pos[0]; }
-  node.type = type;
-  node.end = pos;
+  if (this.options.locations) { node.loc.end = pos[1]; pos = pos[0] }
+  node.type = type
+  node.end = pos
   if (this.options.ranges)
-    node.range[1] = pos;
-  return node;
-};
+    node.range[1] = pos
+  return node
+}
diff --git a/src/options.js b/src/options.js
index 713345a6b3..cc0967e3d3 100644
--- a/src/options.js
+++ b/src/options.js
@@ -92,13 +92,13 @@ export function getOptions(opts) {
     options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]
 
   if (isArray(options.onToken)) {
-    var tokens = options.onToken;
+    let tokens = options.onToken
     options.onToken = (token) => tokens.push(token)
   }
   if (isArray(options.onComment))
-    options.onComment = pushComment(options, options.onComment);
+    options.onComment = pushComment(options, options.onComment)
 
-  return options;
+  return options
 }
 
 function pushComment(options, array) {
diff --git a/src/parseutil.js b/src/parseutil.js
index 24461fabd3..3d464a22dc 100644
--- a/src/parseutil.js
+++ b/src/parseutil.js
@@ -10,38 +10,38 @@ const pp = Parser.prototype
 
 pp.isUseStrict = function(stmt) {
   return this.options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
-    stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
-};
+    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.
 
 pp.eat = function(type) {
   if (this.type === type) {
-    this.next();
-    return true;
+    this.next()
+    return true
   } else {
-    return false;
+    return false
   }
-};
+}
 
 // Tests whether parsed token is a contextual keyword.
 
 pp.isContextual = function(name) {
-  return this.type === tt.name && this.value === name;
-};
+  return this.type === tt.name && this.value === name
+}
 
 // Consumes contextual keyword if possible.
 
 pp.eatContextual = function(name) {
-  return this.value === name && this.eat(tt.name);
-};
+  return this.value === name && this.eat(tt.name)
+}
 
 // Asserts that following token is given contextual keyword.
 
 pp.expectContextual = function(name) {
-  if (!this.eatContextual(name)) this.unexpected();
-};
+  if (!this.eatContextual(name)) this.unexpected()
+}
 
 // Test whether a semicolon can be inserted at the current position.
 
@@ -49,41 +49,41 @@ pp.canInsertSemicolon = function() {
   return this.type === tt.eof ||
     this.type === tt.braceR ||
     lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
-};
+}
 
 pp.insertSemicolon = function() {
   if (this.canInsertSemicolon()) {
     if (this.options.onInsertedSemicolon)
       this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc)
-    return true;
+    return true
   }
-};
+}
 
 // Consume a semicolon, or, failing that, see if we are allowed to
 // pretend that there is a semicolon at this position.
 
 pp.semicolon = function() {
-  if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected();
-};
+  if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected()
+}
 
 pp.afterTrailingComma = function(tokType) {
   if (this.type == tokType) {
     if (this.options.onTrailingComma)
-      this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc);
-    this.next();
-    return true;
+      this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc)
+    this.next()
+    return true
   }
-};
+}
 
 // Expect a token of a given type. If found, consume it, otherwise,
 // raise an unexpected token error.
 
 pp.expect = function(type) {
-  this.eat(type) || this.unexpected();
-};
+  this.eat(type) || this.unexpected()
+}
 
 // Raise an unexpected token error.
 
 pp.unexpected = function(pos) {
-  this.raise(pos != null ? pos : this.start, "Unexpected token");
-};
+  this.raise(pos != null ? pos : this.start, "Unexpected token")
+}
diff --git a/src/statement.js b/src/statement.js
index 9014d062ea..d6b94bea24 100644
--- a/src/statement.js
+++ b/src/statement.js
@@ -12,68 +12,68 @@ const pp = Parser.prototype
 // to its body instead of creating a new node.
 
 pp.parseTopLevel = function(node) {
-  var first = true;
-  if (!node.body) node.body = [];
+  let first = true
+  if (!node.body) node.body = []
   while (this.type !== tt.eof) {
-    var stmt = this.parseStatement(true, true);
-    node.body.push(stmt);
-    if (first && this.isUseStrict(stmt)) this.setStrict(true);
-    first = false;
+    let stmt = this.parseStatement(true, true)
+    node.body.push(stmt)
+    if (first && this.isUseStrict(stmt)) this.setStrict(true)
+    first = false
   }
-  this.next();
+  this.next()
   if (this.options.ecmaVersion >= 6) {
-    node.sourceType = this.options.sourceType;
+    node.sourceType = this.options.sourceType
   }
-  return this.finishNode(node, "Program");
-};
+  return this.finishNode(node, "Program")
+}
 
-var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
+const 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
+// `if (foo) /blah/.exec(foo)`, where looking at the previous token
 // does not help.
 
 pp.parseStatement = function(declaration, topLevel) {
-  var starttype = this.type, node = this.startNode();
+  let starttype = this.type, node = this.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 tt._break: case tt._continue: return this.parseBreakContinueStatement(node, starttype.keyword);
-  case tt._debugger: return this.parseDebuggerStatement(node);
-  case tt._do: return this.parseDoStatement(node);
-  case tt._for: return this.parseForStatement(node);
+  case tt._break: case tt._continue: return this.parseBreakContinueStatement(node, starttype.keyword)
+  case tt._debugger: return this.parseDebuggerStatement(node)
+  case tt._do: return this.parseDoStatement(node)
+  case tt._for: return this.parseForStatement(node)
   case tt._function:
-    if (!declaration && this.options.ecmaVersion >= 6) this.unexpected();
-    return this.parseFunctionStatement(node);
+    if (!declaration && this.options.ecmaVersion >= 6) this.unexpected()
+    return this.parseFunctionStatement(node)
   case tt._class:
-    if (!declaration) this.unexpected();
-    return this.parseClass(node, true);
-  case tt._if: return this.parseIfStatement(node);
-  case tt._return: return this.parseReturnStatement(node);
-  case tt._switch: return this.parseSwitchStatement(node);
-  case tt._throw: return this.parseThrowStatement(node);
-  case tt._try: return this.parseTryStatement(node);
-  case tt._let: case tt._const: if (!declaration) this.unexpected(); // NOTE: falls through to _var
-  case tt._var: return this.parseVarStatement(node, starttype);
-  case tt._while: return this.parseWhileStatement(node);
-  case tt._with: return this.parseWithStatement(node);
-  case tt.braceL: return this.parseBlock(); // no point creating a function for this
-  case tt.semi: return this.parseEmptyStatement(node);
+    if (!declaration) this.unexpected()
+    return this.parseClass(node, true)
+  case tt._if: return this.parseIfStatement(node)
+  case tt._return: return this.parseReturnStatement(node)
+  case tt._switch: return this.parseSwitchStatement(node)
+  case tt._throw: return this.parseThrowStatement(node)
+  case tt._try: return this.parseTryStatement(node)
+  case tt._let: case tt._const: if (!declaration) this.unexpected() // NOTE: falls through to _var
+  case tt._var: return this.parseVarStatement(node, starttype)
+  case tt._while: return this.parseWhileStatement(node)
+  case tt._with: return this.parseWithStatement(node)
+  case tt.braceL: return this.parseBlock()
+  case tt.semi: return this.parseEmptyStatement(node)
   case tt._export:
   case tt._import:
     if (!this.options.allowImportExportEverywhere) {
       if (!topLevel)
-        this.raise(this.start, "'import' and 'export' may only appear at the top level");
+        this.raise(this.start, "'import' and 'export' may only appear at the top level")
       if (!this.inModule)
-        this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
+        this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'")
     }
-    return starttype === tt._import ? this.parseImport(node) : this.parseExport(node);
+    return starttype === tt._import ? this.parseImport(node) : this.parseExport(node)
 
     // If the statement does not start with a statement keyword or a
     // brace, it's an ExpressionStatement or LabeledStatement. We
@@ -81,55 +81,55 @@ pp.parseStatement = function(declaration, topLevel) {
     // next token is a colon and the expression was a simple
     // Identifier node, we switch to interpreting it as a label.
   default:
-    var maybeName = this.value, expr = this.parseExpression();
+    let maybeName = this.value, expr = this.parseExpression()
     if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon))
-      return this.parseLabeledStatement(node, maybeName, expr);
-    else return this.parseExpressionStatement(node, expr);
+      return this.parseLabeledStatement(node, maybeName, expr)
+    else return this.parseExpressionStatement(node, expr)
   }
-};
+}
 
 pp.parseBreakContinueStatement = function(node, keyword) {
-  var isBreak = keyword == "break";
-  this.next();
-  if (this.eat(tt.semi) || this.insertSemicolon()) node.label = null;
-  else if (this.type !== tt.name) this.unexpected();
+  let isBreak = keyword == "break"
+  this.next()
+  if (this.eat(tt.semi) || this.insertSemicolon()) node.label = null
+  else if (this.type !== tt.name) this.unexpected()
   else {
-    node.label = this.parseIdent();
-    this.semicolon();
+    node.label = this.parseIdent()
+    this.semicolon()
   }
 
   // Verify that there is an actual destination to break or
   // continue to.
   for (var i = 0; i < this.labels.length; ++i) {
-    var lab = this.labels[i];
+    let lab = this.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 (lab.kind != null && (isBreak || lab.kind === "loop")) break
+      if (node.label && isBreak) break
     }
   }
-  if (i === this.labels.length) this.raise(node.start, "Unsyntactic " + keyword);
-  return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-};
+  if (i === this.labels.length) this.raise(node.start, "Unsyntactic " + keyword)
+  return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement")
+}
 
 pp.parseDebuggerStatement = function(node) {
-  this.next();
-  this.semicolon();
-  return this.finishNode(node, "DebuggerStatement");
-};
+  this.next()
+  this.semicolon()
+  return this.finishNode(node, "DebuggerStatement")
+}
 
 pp.parseDoStatement = function(node) {
-  this.next();
-  this.labels.push(loopLabel);
-  node.body = this.parseStatement(false);
-  this.labels.pop();
-  this.expect(tt._while);
-  node.test = this.parseParenExpression();
+  this.next()
+  this.labels.push(loopLabel)
+  node.body = this.parseStatement(false)
+  this.labels.pop()
+  this.expect(tt._while)
+  node.test = this.parseParenExpression()
   if (this.options.ecmaVersion >= 6)
-    this.eat(tt.semi);
+    this.eat(tt.semi)
   else
-    this.semicolon();
-  return this.finishNode(node, "DoWhileStatement");
-};
+    this.semicolon()
+  return this.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`
@@ -140,65 +140,65 @@ pp.parseDoStatement = function(node) {
 // is a regular `for` loop.
 
 pp.parseForStatement = function(node) {
-  this.next();
-  this.labels.push(loopLabel);
-  this.expect(tt.parenL);
-  if (this.type === tt.semi) return this.parseFor(node, null);
+  this.next()
+  this.labels.push(loopLabel)
+  this.expect(tt.parenL)
+  if (this.type === tt.semi) return this.parseFor(node, null)
   if (this.type === tt._var || this.type === tt._let || this.type === tt._const) {
-    var init = this.startNode(), varKind = this.type;
-    this.next();
-    this.parseVar(init, true, varKind);
-    this.finishNode(init, "VariableDeclaration");
+    let init = this.startNode(), varKind = this.type
+    this.next()
+    this.parseVar(init, true, varKind)
+    this.finishNode(init, "VariableDeclaration")
     if ((this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init.declarations.length === 1 &&
         !(varKind !== tt._var && init.declarations[0].init))
-      return this.parseForIn(node, init);
-    return this.parseFor(node, init);
+      return this.parseForIn(node, init)
+    return this.parseFor(node, init)
   }
-  var refShorthandDefaultPos = {start: 0};
-  var init = this.parseExpression(true, refShorthandDefaultPos);
+  let refShorthandDefaultPos = {start: 0}
+  let init = this.parseExpression(true, refShorthandDefaultPos)
   if (this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
-    this.toAssignable(init);
-    this.checkLVal(init);
-    return this.parseForIn(node, init);
+    this.toAssignable(init)
+    this.checkLVal(init)
+    return this.parseForIn(node, init)
   } else if (refShorthandDefaultPos.start) {
-    this.unexpected(refShorthandDefaultPos.start);
+    this.unexpected(refShorthandDefaultPos.start)
   }
-  return this.parseFor(node, init);
-};
+  return this.parseFor(node, init)
+}
 
 pp.parseFunctionStatement = function(node) {
-  this.next();
-  return this.parseFunction(node, true);
-};
+  this.next()
+  return this.parseFunction(node, true)
+}
 
 pp.parseIfStatement = function(node) {
-  this.next();
-  node.test = this.parseParenExpression();
-  node.consequent = this.parseStatement(false);
-  node.alternate = this.eat(tt._else) ? this.parseStatement(false) : null;
-  return this.finishNode(node, "IfStatement");
-};
+  this.next()
+  node.test = this.parseParenExpression()
+  node.consequent = this.parseStatement(false)
+  node.alternate = this.eat(tt._else) ? this.parseStatement(false) : null
+  return this.finishNode(node, "IfStatement")
+}
 
 pp.parseReturnStatement = function(node) {
   if (!this.inFunction && !this.options.allowReturnOutsideFunction)
-    this.raise(this.start, "'return' outside of function");
-  this.next();
+    this.raise(this.start, "'return' outside of function")
+  this.next()
 
   // In `return` (and `break`/`continue`), the keywords with
   // optional arguments, we eagerly look for a semicolon or the
   // possibility to insert one.
 
-  if (this.eat(tt.semi) || this.insertSemicolon()) node.argument = null;
-  else { node.argument = this.parseExpression(); this.semicolon(); }
-  return this.finishNode(node, "ReturnStatement");
-};
+  if (this.eat(tt.semi) || this.insertSemicolon()) node.argument = null
+  else { node.argument = this.parseExpression(); this.semicolon() }
+  return this.finishNode(node, "ReturnStatement")
+}
 
 pp.parseSwitchStatement = function(node) {
-  this.next();
-  node.discriminant = this.parseParenExpression();
-  node.cases = [];
-  this.expect(tt.braceL);
-  this.labels.push(switchLabel);
+  this.next()
+  node.discriminant = this.parseParenExpression()
+  node.cases = []
+  this.expect(tt.braceL)
+  this.labels.push(switchLabel)
 
   // Statements under must be grouped (by label) in SwitchCase
   // nodes. `cur` is used to keep the node that we are currently
@@ -206,241 +206,357 @@ pp.parseSwitchStatement = function(node) {
 
   for (var cur, sawDefault; this.type != tt.braceR;) {
     if (this.type === tt._case || this.type === tt._default) {
-      var isCase = this.type === tt._case;
-      if (cur) this.finishNode(cur, "SwitchCase");
-      node.cases.push(cur = this.startNode());
-      cur.consequent = [];
-      this.next();
-      if (isCase) cur.test = this.parseExpression();
-      else {
-        if (sawDefault) this.raise(this.lastTokStart, "Multiple default clauses"); sawDefault = true;
-        cur.test = null;
+      let isCase = this.type === tt._case
+      if (cur) this.finishNode(cur, "SwitchCase")
+      node.cases.push(cur = this.startNode())
+      cur.consequent = []
+      this.next()
+      if (isCase) {
+        cur.test = this.parseExpression()
+      } else {
+        if (sawDefault) this.raise(this.lastTokStart, "Multiple default clauses")
+        sawDefault = true
+        cur.test = null
       }
-      this.expect(tt.colon);
+      this.expect(tt.colon)
     } else {
-      if (!cur) this.unexpected();
-      cur.consequent.push(this.parseStatement(true));
+      if (!cur) this.unexpected()
+      cur.consequent.push(this.parseStatement(true))
     }
   }
-  if (cur) this.finishNode(cur, "SwitchCase");
-  this.next(); // Closing brace
-  this.labels.pop();
-  return this.finishNode(node, "SwitchStatement");
-};
+  if (cur) this.finishNode(cur, "SwitchCase")
+  this.next() // Closing brace
+  this.labels.pop()
+  return this.finishNode(node, "SwitchStatement")
+}
 
 pp.parseThrowStatement = function(node) {
-  this.next();
+  this.next()
   if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))
-    this.raise(this.lastTokEnd, "Illegal newline after throw");
-  node.argument = this.parseExpression();
-  this.semicolon();
-  return this.finishNode(node, "ThrowStatement");
-};
+    this.raise(this.lastTokEnd, "Illegal newline after throw")
+  node.argument = this.parseExpression()
+  this.semicolon()
+  return this.finishNode(node, "ThrowStatement")
+}
 
 // Reused empty array added for node fields that are always empty.
 
 const empty = []
 
 pp.parseTryStatement = function(node) {
-  this.next();
-  node.block = this.parseBlock();
-  node.handler = null;
+  this.next()
+  node.block = this.parseBlock()
+  node.handler = null
   if (this.type === tt._catch) {
-    var clause = this.startNode();
-    this.next();
-    this.expect(tt.parenL);
-    clause.param = this.parseBindingAtom();
-    this.checkLVal(clause.param, true);
-    this.expect(tt.parenR);
-    clause.guard = null;
-    clause.body = this.parseBlock();
-    node.handler = this.finishNode(clause, "CatchClause");
+    let clause = this.startNode()
+    this.next()
+    this.expect(tt.parenL)
+    clause.param = this.parseBindingAtom()
+    this.checkLVal(clause.param, true)
+    this.expect(tt.parenR)
+    clause.guard = null
+    clause.body = this.parseBlock()
+    node.handler = this.finishNode(clause, "CatchClause")
   }
-  node.guardedHandlers = empty;
-  node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;
+  node.guardedHandlers = empty
+  node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null
   if (!node.handler && !node.finalizer)
-    this.raise(node.start, "Missing catch or finally clause");
-  return this.finishNode(node, "TryStatement");
-};
+    this.raise(node.start, "Missing catch or finally clause")
+  return this.finishNode(node, "TryStatement")
+}
 
 pp.parseVarStatement = function(node, kind) {
-  this.next();
-  this.parseVar(node, false, kind);
-  this.semicolon();
-  return this.finishNode(node, "VariableDeclaration");
-};
+  this.next()
+  this.parseVar(node, false, kind)
+  this.semicolon()
+  return this.finishNode(node, "VariableDeclaration")
+}
 
 pp.parseWhileStatement = function(node) {
-  this.next();
-  node.test = this.parseParenExpression();
-  this.labels.push(loopLabel);
-  node.body = this.parseStatement(false);
-  this.labels.pop();
-  return this.finishNode(node, "WhileStatement");
-};
+  this.next()
+  node.test = this.parseParenExpression()
+  this.labels.push(loopLabel)
+  node.body = this.parseStatement(false)
+  this.labels.pop()
+  return this.finishNode(node, "WhileStatement")
+}
 
 pp.parseWithStatement = function(node) {
-  if (this.strict) this.raise(this.start, "'with' in strict mode");
-  this.next();
-  node.object = this.parseParenExpression();
-  node.body = this.parseStatement(false);
-  return this.finishNode(node, "WithStatement");
-};
+  if (this.strict) this.raise(this.start, "'with' in strict mode")
+  this.next()
+  node.object = this.parseParenExpression()
+  node.body = this.parseStatement(false)
+  return this.finishNode(node, "WithStatement")
+}
 
 pp.parseEmptyStatement = function(node) {
-  this.next();
-  return this.finishNode(node, "EmptyStatement");
-};
+  this.next()
+  return this.finishNode(node, "EmptyStatement")
+}
 
 pp.parseLabeledStatement = function(node, maybeName, expr) {
-  for (var i = 0; i < this.labels.length; ++i)
-    if (this.labels[i].name === maybeName) this.raise(expr.start, "Label '" + maybeName + "' is already declared");
-  var kind = this.type.isLoop ? "loop" : this.type === tt._switch ? "switch" : null;
-  this.labels.push({name: maybeName, kind: kind});
-  node.body = this.parseStatement(true);
-  this.labels.pop();
-  node.label = expr;
-  return this.finishNode(node, "LabeledStatement");
-};
+  for (let i = 0; i < this.labels.length; ++i)
+    if (this.labels[i].name === maybeName) this.raise(expr.start, "Label '" + maybeName + "' is already declared")
+  let kind = this.type.isLoop ? "loop" : this.type === tt._switch ? "switch" : null
+  this.labels.push({name: maybeName, kind: kind})
+  node.body = this.parseStatement(true)
+  this.labels.pop()
+  node.label = expr
+  return this.finishNode(node, "LabeledStatement")
+}
 
 pp.parseExpressionStatement = function(node, expr) {
-  node.expression = expr;
-  this.semicolon();
-  return this.finishNode(node, "ExpressionStatement");
-};
+  node.expression = expr
+  this.semicolon()
+  return this.finishNode(node, "ExpressionStatement")
+}
 
 // Parse a semicolon-enclosed block of statements, handling `"use
 // strict"` declarations when `allowStrict` is true (used for
 // function bodies).
 
 pp.parseBlock = function(allowStrict) {
-  var node = this.startNode(), first = true, oldStrict;
-  node.body = [];
-  this.expect(tt.braceL);
+  let node = this.startNode(), first = true, oldStrict
+  node.body = []
+  this.expect(tt.braceL)
   while (!this.eat(tt.braceR)) {
-    var stmt = this.parseStatement(true);
-    node.body.push(stmt);
+    let stmt = this.parseStatement(true)
+    node.body.push(stmt)
     if (first && allowStrict && this.isUseStrict(stmt)) {
-      oldStrict = this.strict;
-      this.setStrict(this.strict = true);
+      oldStrict = this.strict
+      this.setStrict(this.strict = true)
     }
-    first = false;
+    first = false
   }
-  if (oldStrict === false) this.setStrict(false);
-  return this.finishNode(node, "BlockStatement");
-};
+  if (oldStrict === false) this.setStrict(false)
+  return this.finishNode(node, "BlockStatement")
+}
 
 // Parse a regular `for` loop. The disambiguation code in
 // `parseStatement` will already have parsed the init statement or
 // expression.
 
 pp.parseFor = function(node, init) {
-  node.init = init;
-  this.expect(tt.semi);
-  node.test = this.type === tt.semi ? null : this.parseExpression();
-  this.expect(tt.semi);
-  node.update = this.type === tt.parenR ? null : this.parseExpression();
-  this.expect(tt.parenR);
-  node.body = this.parseStatement(false);
-  this.labels.pop();
-  return this.finishNode(node, "ForStatement");
-};
+  node.init = init
+  this.expect(tt.semi)
+  node.test = this.type === tt.semi ? null : this.parseExpression()
+  this.expect(tt.semi)
+  node.update = this.type === tt.parenR ? null : this.parseExpression()
+  this.expect(tt.parenR)
+  node.body = this.parseStatement(false)
+  this.labels.pop()
+  return this.finishNode(node, "ForStatement")
+}
 
 // Parse a `for`/`in` and `for`/`of` loop, which are almost
 // same from parser's perspective.
 
 pp.parseForIn = function(node, init) {
-  var type = this.type === tt._in ? "ForInStatement" : "ForOfStatement";
-  this.next();
-  node.left = init;
-  node.right = this.parseExpression();
-  this.expect(tt.parenR);
-  node.body = this.parseStatement(false);
-  this.labels.pop();
-  return this.finishNode(node, type);
-};
+  let type = this.type === tt._in ? "ForInStatement" : "ForOfStatement"
+  this.next()
+  node.left = init
+  node.right = this.parseExpression()
+  this.expect(tt.parenR)
+  node.body = this.parseStatement(false)
+  this.labels.pop()
+  return this.finishNode(node, type)
+}
 
 // Parse a list of variable declarations.
 
 pp.parseVar = function(node, noIn, kind) {
-  node.declarations = [];
-  node.kind = kind.keyword;
+  node.declarations = []
+  node.kind = kind.keyword
   for (;;) {
-    var decl = this.startNode();
-    decl.id = this.parseBindingAtom();
-    this.checkLVal(decl.id, true);
+    let decl = this.startNode()
+    decl.id = this.parseBindingAtom()
+    this.checkLVal(decl.id, true)
     if (this.eat(tt.eq)) {
-      decl.init = this.parseMaybeAssign(noIn);
+      decl.init = this.parseMaybeAssign(noIn)
     } else if (kind === tt._const && !(this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
-      this.unexpected();
+      this.unexpected()
     } else if (decl.id.type != "Identifier") {
       this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value")
     } else {
-      decl.init = null;
+      decl.init = null
     }
-    node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
-    if (!this.eat(tt.comma)) break;
+    node.declarations.push(this.finishNode(decl, "VariableDeclarator"))
+    if (!this.eat(tt.comma)) break
   }
-  return node;
-};
+  return node
+}
 
 // Parse a function declaration or literal (depending on the
 // `isStatement` parameter).
 
 pp.parseFunction = function(node, isStatement, allowExpressionBody) {
-  this.initFunction(node);
-  if (this.options.ecmaVersion >= 6) {
-    node.generator = this.eat(tt.star);
-  }
-  if (isStatement || this.type === tt.name) {
-    node.id = this.parseIdent();
-  }
-  this.expect(tt.parenL);
-  node.params = this.parseBindingList(tt.parenR, false, false);
-  this.parseFunctionBody(node, allowExpressionBody);
-  return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-};
+  this.initFunction(node)
+  if (this.options.ecmaVersion >= 6)
+    node.generator = this.eat(tt.star)
+  if (isStatement || this.type === tt.name)
+    node.id = this.parseIdent()
+  this.expect(tt.parenL)
+  node.params = this.parseBindingList(tt.parenR, false, false)
+  this.parseFunctionBody(node, allowExpressionBody)
+  return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression")
+}
 
 // Parse a class declaration or literal (depending on the
 // `isStatement` parameter).
 
 pp.parseClass = function(node, isStatement) {
-  this.next();
-  node.id = this.type === tt.name ? this.parseIdent() : isStatement ? this.unexpected() : null;
-  node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null;
-  var classBody = this.startNode();
-  classBody.body = [];
-  this.expect(tt.braceL);
+  this.next()
+  node.id = this.type === tt.name ? this.parseIdent() : isStatement ? this.unexpected() : null
+  node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null
+  let classBody = this.startNode()
+  classBody.body = []
+  this.expect(tt.braceL)
   while (!this.eat(tt.braceR)) {
-    if (this.eat(tt.semi)) continue;
-    var method = this.startNode();
-    var isGenerator = this.eat(tt.star);
-    this.parsePropertyName(method);
+    if (this.eat(tt.semi)) continue
+    let method = this.startNode()
+    let isGenerator = this.eat(tt.star)
+    this.parsePropertyName(method)
     if (this.type !== tt.parenL && !method.computed && method.key.type === "Identifier" &&
         method.key.name === "static") {
-      if (isGenerator) this.unexpected();
-      method['static'] = true;
-      isGenerator = this.eat(tt.star);
-      this.parsePropertyName(method);
+      if (isGenerator) this.unexpected()
+      method['static'] = true
+      isGenerator = this.eat(tt.star)
+      this.parsePropertyName(method)
     } else {
-      method['static'] = false;
+      method['static'] = false
     }
-    method.kind = "method";
+    method.kind = "method"
     if (!method.computed && !isGenerator) {
       if (method.key.type === "Identifier") {
         if (this.type !== tt.parenL && (method.key.name === "get" || method.key.name === "set")) {
-          method.kind = method.key.name;
-          this.parsePropertyName(method);
+          method.kind = method.key.name
+          this.parsePropertyName(method)
         } else if (!method['static'] && method.key.name === "constructor") {
-          method.kind = "constructor";
+          method.kind = "constructor"
         }
       } else if (!method['static'] && method.key.type === "Literal" && method.key.value === "constructor") {
-        method.kind = "constructor";
+        method.kind = "constructor"
       }
     }
-    method.value = this.parseMethod(isGenerator);
-    classBody.body.push(this.finishNode(method, "MethodDefinition"));
+    method.value = this.parseMethod(isGenerator)
+    classBody.body.push(this.finishNode(method, "MethodDefinition"))
   }
-  node.body = this.finishNode(classBody, "ClassBody");
-  return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
-};
+  node.body = this.finishNode(classBody, "ClassBody")
+  return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
+}
+
+// Parses module export declaration.
+
+pp.parseExport = function(node) {
+  this.next()
+  // export * from '...'
+  if (this.eat(tt.star)) {
+    this.expectContextual("from")
+    node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected()
+    this.semicolon()
+    return this.finishNode(node, "ExportAllDeclaration")
+  }
+  if (this.eat(tt._default)) { // export default ...
+    let expr = this.parseMaybeAssign()
+    if (expr.id) {
+      switch (expr.type) {
+      case "FunctionExpression": expr.type = "FunctionDeclaration"; break
+      case "ClassExpression": expr.type = "ClassDeclaration"; break
+      }
+    }
+    node.declaration = expr
+    this.semicolon()
+    return this.finishNode(node, "ExportDefaultDeclaration")
+  }
+  // export var|const|let|function|class ...
+  if (this.type.keyword) {
+    node.declaration = this.parseStatement(true)
+    node.specifiers = []
+    node.source = null
+  } else { // export { x, y as z } [from '...']
+    node.declaration = null
+    node.specifiers = this.parseExportSpecifiers()
+    if (this.eatContextual("from")) {
+      node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected()
+    } else {
+      node.source = null
+    }
+    this.semicolon()
+  }
+  return this.finishNode(node, "ExportNamedDeclaration")
+}
+
+// Parses a comma-separated list of module exports.
+
+pp.parseExportSpecifiers = function() {
+  let nodes = [], first = true
+  // export { x, y as z } [from '...']
+  this.expect(tt.braceL)
+  while (!this.eat(tt.braceR)) {
+    if (!first) {
+      this.expect(tt.comma)
+      if (this.afterTrailingComma(tt.braceR)) break
+    } else first = false
+
+    let node = this.startNode()
+    node.local = this.parseIdent(this.type === tt._default)
+    node.exported = this.eatContextual("as") ? this.parseIdent(true) : node.local
+    nodes.push(this.finishNode(node, "ExportSpecifier"))
+  }
+  return nodes
+}
+
+// Parses import declaration.
+
+pp.parseImport = function(node) {
+  this.next()
+  // import '...'
+  if (this.type === tt.string) {
+    node.specifiers = empty
+    node.source = this.parseExprAtom()
+    node.kind = ""
+  } else {
+    node.specifiers = this.parseImportSpecifiers()
+    this.expectContextual("from")
+    node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected()
+  }
+  this.semicolon()
+  return this.finishNode(node, "ImportDeclaration")
+}
+
+// Parses a comma-separated list of module imports.
+
+pp.parseImportSpecifiers = function() {
+  let nodes = [], first = true
+  if (this.type === tt.name) {
+    // import defaultObj, { x, y as z } from '...'
+    let node = this.startNode()
+    node.local = this.parseIdent()
+    this.checkLVal(node.local, true)
+    nodes.push(this.finishNode(node, "ImportDefaultSpecifier"))
+    if (!this.eat(tt.comma)) return nodes
+  }
+  if (this.type === tt.star) {
+    let node = this.startNode()
+    this.next()
+    this.expectContextual("as")
+    node.local = this.parseIdent()
+    this.checkLVal(node.local, true)
+    nodes.push(this.finishNode(node, "ImportNamespaceSpecifier"))
+    return nodes
+  }
+  this.expect(tt.braceL)
+  while (!this.eat(tt.braceR)) {
+    if (!first) {
+      this.expect(tt.comma)
+      if (this.afterTrailingComma(tt.braceR)) break
+    } else first = false
+
+    let node = this.startNode()
+    node.imported = this.parseIdent(true)
+    node.local = this.eatContextual("as") ? this.parseIdent() : node.imported
+    this.checkLVal(node.local, true)
+    nodes.push(this.finishNode(node, "ImportSpecifier"))
+  }
+  return nodes
+}
diff --git a/src/tokencontext.js b/src/tokencontext.js
index a23b5fab16..a3cabb58e2 100644
--- a/src/tokencontext.js
+++ b/src/tokencontext.js
@@ -32,72 +32,72 @@ pp.initialContext = function() {
 }
 
 pp.braceIsBlock = function(prevType) {
-  var parent;
+  let parent
   if (prevType === tt.colon && (parent = this.curContext()).token == "{")
-    return !parent.isExpr;
+    return !parent.isExpr
   if (prevType === tt._return)
-    return lineBreak.test(this.input.slice(this.lastTokEnd, this.start));
+    return lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
   if (prevType === tt._else || prevType === tt.semi || prevType === tt.eof)
-    return true;
+    return true
   if (prevType == tt.braceL)
-    return this.curContext() === types.b_stat;
-  return !this.exprAllowed;
-};
+    return this.curContext() === types.b_stat
+  return !this.exprAllowed
+}
 
 pp.updateContext = function(prevType) {
-  var update, type = this.type;
+  let update, type = this.type
   if (type.keyword && prevType == tt.dot)
-    this.exprAllowed = false;
+    this.exprAllowed = false
   else if (update = type.updateContext)
-    update.call(this, prevType);
+    update.call(this, prevType)
   else
-    this.exprAllowed = type.beforeExpr;
-};
+    this.exprAllowed = type.beforeExpr
+}
 
 // Token-specific context update code
 
 tt.parenR.updateContext = tt.braceR.updateContext = function() {
-  var out = this.context.pop();
+  let out = this.context.pop()
   if (out === types.b_stat && this.curContext() === types.f_expr) {
-    this.context.pop();
-    this.exprAllowed = false;
+    this.context.pop()
+    this.exprAllowed = false
   } else if (out === types.b_tmpl) {
-    this.exprAllowed = true;
+    this.exprAllowed = true
   } else {
-    this.exprAllowed = !(out && out.isExpr);
+    this.exprAllowed = !(out && out.isExpr)
   }
-};
+}
 
 tt.braceL.updateContext = function(prevType) {
-  this.context.push(this.braceIsBlock(prevType) ? types.b_stat : types.b_expr);
-  this.exprAllowed = true;
-};
+  this.context.push(this.braceIsBlock(prevType) ? types.b_stat : types.b_expr)
+  this.exprAllowed = true
+}
 
 tt.dollarBraceL.updateContext = function() {
-  this.context.push(types.b_tmpl);
-  this.exprAllowed = true;
-};
+  this.context.push(types.b_tmpl)
+  this.exprAllowed = true
+}
 
 tt.parenL.updateContext = function(prevType) {
-  var statementParens = prevType === tt._if || prevType === tt._for || prevType === tt._with || prevType === tt._while;
-  this.context.push(statementParens ? types.p_stat : types.p_expr);
-  this.exprAllowed = true;
-};
+  let statementParens = prevType === tt._if || prevType === tt._for || prevType === tt._with || prevType === tt._while
+  this.context.push(statementParens ? types.p_stat : types.p_expr)
+  this.exprAllowed = true
+}
 
 tt.incDec.updateContext = function() {
   // tokExprAllowed stays unchanged
-};
+}
 
 tt._function.updateContext = function() {
   if (this.curContext() !== types.b_stat)
-    this.context.push(types.f_expr);
-  this.exprAllowed = false;
-};
+    this.context.push(types.f_expr)
+  this.exprAllowed = false
+}
 
 tt.backQuote.updateContext = function() {
   if (this.curContext() === types.q_tmpl)
-    this.context.pop();
+    this.context.pop()
   else
-    this.context.push(types.q_tmpl);
-  this.exprAllowed = false;
-};
+    this.context.push(types.q_tmpl)
+  this.exprAllowed = false
+}
diff --git a/src/tokenize.js b/src/tokenize.js
index 470a9b49b6..16eb0f93be 100644
--- a/src/tokenize.js
+++ b/src/tokenize.js
@@ -10,14 +10,14 @@ import {lineBreak, lineBreakG, isNewLine, nonASCIIwhitespace} from "./whitespace
 
 export class Token {
   constructor(p) {
-    this.type = p.type;
-    this.value = p.value;
-    this.start = p.start;
-    this.end = p.end;
+    this.type = p.type
+    this.value = p.value
+    this.start = p.start
+    this.end = p.end
     if (p.options.locations)
-      this.loc = new SourceLocation(p, p.startLoc, p.endLoc);
+      this.loc = new SourceLocation(p, p.startLoc, p.endLoc)
     if (p.options.ranges)
-      this.range = [p.start, p.end];
+      this.range = [p.start, p.end]
   }
 }
 
@@ -29,52 +29,52 @@ const pp = Parser.prototype
 
 pp.next = function() {
   if (this.options.onToken)
-    this.options.onToken(new Token(this));
+    this.options.onToken(new Token(this))
 
-  this.lastTokEnd = this.end;
-  this.lastTokStart = this.start;
-  this.lastTokEndLoc = this.endLoc;
-  this.lastTokStartLoc = this.startLoc;
-  this.nextToken();
-};
+  this.lastTokEnd = this.end
+  this.lastTokStart = this.start
+  this.lastTokEndLoc = this.endLoc
+  this.lastTokStartLoc = this.startLoc
+  this.nextToken()
+}
 
 pp.getToken = function() {
-  this.next();
-  return new Token(this);
-};
+  this.next()
+  return new Token(this)
+}
 
 // If we're in an ES6 environment, make parsers iterable
 if (typeof Symbol !== "undefined")
   pp[Symbol.iterator] = function () {
-    var self = this;
+    let self = this
     return {next: function () {
-      var token = self.getToken();
+      let token = self.getToken()
       return {
         done: token.type === tt.eof,
         value: token
-      };
-    }};
-  };
+      }
+    }}
+  }
 
 // Toggle strict mode. Re-reads the next number or string to please
 // pedantic tests (`"use strict"; 010;` should fail).
 
 pp.setStrict = function(strict) {
-  this.strict = strict;
-  if (this.type !== tt.num && this.type !== tt.string) return;
-  this.pos = this.start;
+  this.strict = strict
+  if (this.type !== tt.num && this.type !== tt.string) return
+  this.pos = this.start
   if (this.options.locations) {
     while (this.pos < this.lineStart) {
-      this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1;
-      --this.curLine;
+      this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1
+      --this.curLine
     }
   }
-  this.nextToken();
-};
+  this.nextToken()
+}
 
 pp.curContext = function() {
-  return this.context[this.context.length - 1];
-};
+  return this.context[this.context.length - 1]
+}
 
 // Read a single token, updating the parser object's token-related
 // properties.
@@ -95,91 +95,91 @@ pp.readToken = function(code) {
   // Identifier or keyword. '\uXXXX' sequences are allowed in
   // identifiers, so '\' also dispatches to that.
   if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */)
-    return this.readWord();
+    return this.readWord()
 
-  return this.getTokenFromCode(code);
-};
+  return this.getTokenFromCode(code)
+}
 
 pp.fullCharCodeAtPos = function() {
-  var code = this.input.charCodeAt(this.pos);
-  if (code <= 0xd7ff || code >= 0xe000) return code;
-  var next = this.input.charCodeAt(this.pos + 1);
-  return (code << 10) + next - 0x35fdc00;
-};
+  let code = this.input.charCodeAt(this.pos)
+  if (code <= 0xd7ff || code >= 0xe000) return code
+  let next = this.input.charCodeAt(this.pos + 1)
+  return (code << 10) + next - 0x35fdc00
+}
 
 pp.skipBlockComment = function() {
-  var startLoc = this.options.onComment && this.options.locations && this.curPosition();
-  var start = this.pos, end = this.input.indexOf("*/", this.pos += 2);
-  if (end === -1) this.raise(this.pos - 2, "Unterminated comment");
-  this.pos = end + 2;
+  let startLoc = this.options.onComment && this.options.locations && this.curPosition()
+  let start = this.pos, end = this.input.indexOf("*/", this.pos += 2)
+  if (end === -1) this.raise(this.pos - 2, "Unterminated comment")
+  this.pos = end + 2
   if (this.options.locations) {
-    lineBreakG.lastIndex = start;
-    var match;
+    lineBreakG.lastIndex = start
+    let match
     while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {
-      ++this.curLine;
-      this.lineStart = match.index + match[0].length;
+      ++this.curLine
+      this.lineStart = match.index + match[0].length
     }
   }
   if (this.options.onComment)
     this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,
-                           startLoc, this.options.locations && this.curPosition());
-};
+                           startLoc, this.options.locations && this.curPosition())
+}
 
 pp.skipLineComment = function(startSkip) {
-  var start = this.pos;
-  var startLoc = this.options.onComment && this.options.locations && this.curPosition();
-  var ch = this.input.charCodeAt(this.pos+=startSkip);
+  let start = this.pos
+  let startLoc = this.options.onComment && this.options.locations && this.curPosition()
+  let ch = this.input.charCodeAt(this.pos+=startSkip)
   while (this.pos < this.input.length && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
-    ++this.pos;
-    ch = this.input.charCodeAt(this.pos);
+    ++this.pos
+    ch = this.input.charCodeAt(this.pos)
   }
   if (this.options.onComment)
     this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,
-                           startLoc, this.options.locations && this.curPosition());
-};
+                           startLoc, this.options.locations && this.curPosition())
+}
 
 // Called at the start of the parse and after every token. Skips
 // whitespace and comments, and.
 
 pp.skipSpace = function() {
   while (this.pos < this.input.length) {
-    var ch = this.input.charCodeAt(this.pos);
+    let ch = this.input.charCodeAt(this.pos)
     if (ch === 32) { // ' '
-      ++this.pos;
+      ++this.pos
     } else if (ch === 13) {
-      ++this.pos;
-      var next = this.input.charCodeAt(this.pos);
+      ++this.pos
+      let next = this.input.charCodeAt(this.pos)
       if (next === 10) {
-        ++this.pos;
+        ++this.pos
       }
       if (this.options.locations) {
-        ++this.curLine;
-        this.lineStart = this.pos;
+        ++this.curLine
+        this.lineStart = this.pos
       }
     } else if (ch === 10 || ch === 8232 || ch === 8233) {
-      ++this.pos;
+      ++this.pos
       if (this.options.locations) {
-        ++this.curLine;
-        this.lineStart = this.pos;
+        ++this.curLine
+        this.lineStart = this.pos
       }
     } else if (ch > 8 && ch < 14) {
-      ++this.pos;
+      ++this.pos
     } else if (ch === 47) { // '/'
-      var next = this.input.charCodeAt(this.pos + 1);
+      let next = this.input.charCodeAt(this.pos + 1)
       if (next === 42) { // '*'
-        this.skipBlockComment();
+        this.skipBlockComment()
       } else if (next === 47) { // '/'
-        this.skipLineComment(2);
-      } else break;
+        this.skipLineComment(2)
+      } else break
     } else if (ch === 160) { // '\xa0'
-      ++this.pos;
+      ++this.pos
     } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
-      ++this.pos;
+      ++this.pos
     } else {
-      break;
+      break
     }
   }
-};
+}
 
 // Called at the end of every token. Sets `end`, `val`, and
 // maintains `context` and `exprAllowed`, and skips the space after
@@ -187,14 +187,14 @@ pp.skipSpace = function() {
 // right position.
 
 pp.finishToken = function(type, val) {
-  this.end = this.pos;
-  if (this.options.locations) this.endLoc = this.curPosition();
-  var prevType = this.type;
-  this.type = type;
-  this.value = val;
+  this.end = this.pos
+  if (this.options.locations) this.endLoc = this.curPosition()
+  let prevType = this.type
+  this.type = type
+  this.value = val
 
-  this.updateContext(prevType);
-};
+  this.updateContext(prevType)
+}
 
 // ### Token reading
 
@@ -206,117 +206,117 @@ pp.finishToken = function(type, val) {
 // All in the name of speed.
 //
 pp.readToken_dot = function() {
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next >= 48 && next <= 57) return this.readNumber(true);
-  var next2 = this.input.charCodeAt(this.pos + 2);
+  let next = this.input.charCodeAt(this.pos + 1)
+  if (next >= 48 && next <= 57) return this.readNumber(true)
+  let next2 = this.input.charCodeAt(this.pos + 2)
   if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
-    this.pos += 3;
-    return this.finishToken(tt.ellipsis);
+    this.pos += 3
+    return this.finishToken(tt.ellipsis)
   } else {
-    ++this.pos;
-    return this.finishToken(tt.dot);
+    ++this.pos
+    return this.finishToken(tt.dot)
   }
-};
+}
 
 pp.readToken_slash = function() { // '/'
-  var next = this.input.charCodeAt(this.pos + 1);
+  let next = this.input.charCodeAt(this.pos + 1)
   if (this.exprAllowed) {++this.pos; return this.readRegexp();}
-  if (next === 61) return this.finishOp(tt.assign, 2);
-  return this.finishOp(tt.slash, 1);
-};
+  if (next === 61) return this.finishOp(tt.assign, 2)
+  return this.finishOp(tt.slash, 1)
+}
 
 pp.readToken_mult_modulo = function(code) { // '%*'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next === 61) return this.finishOp(tt.assign, 2);
-  return this.finishOp(code === 42 ? tt.star : tt.modulo, 1);
-};
+  let next = this.input.charCodeAt(this.pos + 1)
+  if (next === 61) return this.finishOp(tt.assign, 2)
+  return this.finishOp(code === 42 ? tt.star : tt.modulo, 1)
+}
 
 pp.readToken_pipe_amp = function(code) { // '|&'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next === code) return this.finishOp(code === 124 ? tt.logicalOR : tt.logicalAND, 2);
-  if (next === 61) return this.finishOp(tt.assign, 2);
-  return this.finishOp(code === 124 ? tt.bitwiseOR : tt.bitwiseAND, 1);
-};
+  let next = this.input.charCodeAt(this.pos + 1)
+  if (next === code) return this.finishOp(code === 124 ? tt.logicalOR : tt.logicalAND, 2)
+  if (next === 61) return this.finishOp(tt.assign, 2)
+  return this.finishOp(code === 124 ? tt.bitwiseOR : tt.bitwiseAND, 1)
+}
 
 pp.readToken_caret = function() { // '^'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next === 61) return this.finishOp(tt.assign, 2);
-  return this.finishOp(tt.bitwiseXOR, 1);
-};
+  let next = this.input.charCodeAt(this.pos + 1)
+  if (next === 61) return this.finishOp(tt.assign, 2)
+  return this.finishOp(tt.bitwiseXOR, 1)
+}
 
 pp.readToken_plus_min = function(code) { // '+-'
-  var next = this.input.charCodeAt(this.pos + 1);
+  let next = this.input.charCodeAt(this.pos + 1)
   if (next === code) {
     if (next == 45 && this.input.charCodeAt(this.pos + 2) == 62 &&
         lineBreak.test(this.input.slice(this.lastTokEnd, this.pos))) {
       // A `-->` line comment
-      this.skipLineComment(3);
-      this.skipSpace();
-      return this.nextToken();
+      this.skipLineComment(3)
+      this.skipSpace()
+      return this.nextToken()
     }
-    return this.finishOp(tt.incDec, 2);
+    return this.finishOp(tt.incDec, 2)
   }
-  if (next === 61) return this.finishOp(tt.assign, 2);
-  return this.finishOp(tt.plusMin, 1);
-};
+  if (next === 61) return this.finishOp(tt.assign, 2)
+  return this.finishOp(tt.plusMin, 1)
+}
 
 pp.readToken_lt_gt = function(code) { // '<>'
-  var next = this.input.charCodeAt(this.pos + 1);
-  var size = 1;
+  let next = this.input.charCodeAt(this.pos + 1)
+  let size = 1
   if (next === code) {
-    size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
-    if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1);
-    return this.finishOp(tt.bitShift, size);
+    size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2
+    if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1)
+    return this.finishOp(tt.bitShift, size)
   }
   if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 &&
       this.input.charCodeAt(this.pos + 3) == 45) {
-    if (this.inModule) unexpected();
+    if (this.inModule) unexpected()
     // `<!--`, an XML-style comment that should be interpreted as a line comment
-    this.skipLineComment(4);
-    this.skipSpace();
-    return this.nextToken();
+    this.skipLineComment(4)
+    this.skipSpace()
+    return this.nextToken()
   }
   if (next === 61)
-    size = this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2;
-  return this.finishOp(tt.relational, size);
-};
+    size = this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2
+  return this.finishOp(tt.relational, size)
+}
 
 pp.readToken_eq_excl = function(code) { // '=!'
-  var next = this.input.charCodeAt(this.pos + 1);
-  if (next === 61) return this.finishOp(tt.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2);
+  let next = this.input.charCodeAt(this.pos + 1)
+  if (next === 61) return this.finishOp(tt.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2)
   if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'
-    this.pos += 2;
-    return this.finishToken(tt.arrow);
+    this.pos += 2
+    return this.finishToken(tt.arrow)
   }
-  return this.finishOp(code === 61 ? tt.eq : tt.prefix, 1);
-};
+  return this.finishOp(code === 61 ? tt.eq : tt.prefix, 1)
+}
 
 pp.getTokenFromCode = function(code) {
   switch (code) {
     // The interpretation of a dot depends on whether it is followed
     // by a digit or another two dots.
   case 46: // '.'
-    return this.readToken_dot();
+    return this.readToken_dot()
 
     // Punctuation tokens.
-  case 40: ++this.pos; return this.finishToken(tt.parenL);
-  case 41: ++this.pos; return this.finishToken(tt.parenR);
-  case 59: ++this.pos; return this.finishToken(tt.semi);
-  case 44: ++this.pos; return this.finishToken(tt.comma);
-  case 91: ++this.pos; return this.finishToken(tt.bracketL);
-  case 93: ++this.pos; return this.finishToken(tt.bracketR);
-  case 123: ++this.pos; return this.finishToken(tt.braceL);
-  case 125: ++this.pos; return this.finishToken(tt.braceR);
-  case 58: ++this.pos; return this.finishToken(tt.colon);
-  case 63: ++this.pos; return this.finishToken(tt.question);
+  case 40: ++this.pos; return this.finishToken(tt.parenL)
+  case 41: ++this.pos; return this.finishToken(tt.parenR)
+  case 59: ++this.pos; return this.finishToken(tt.semi)
+  case 44: ++this.pos; return this.finishToken(tt.comma)
+  case 91: ++this.pos; return this.finishToken(tt.bracketL)
+  case 93: ++this.pos; return this.finishToken(tt.bracketR)
+  case 123: ++this.pos; return this.finishToken(tt.braceL)
+  case 125: ++this.pos; return this.finishToken(tt.braceR)
+  case 58: ++this.pos; return this.finishToken(tt.colon)
+  case 63: ++this.pos; return this.finishToken(tt.question)
 
   case 96: // '`'
-    if (this.options.ecmaVersion < 6) break;
-    ++this.pos;
-    return this.finishToken(tt.backQuote);
+    if (this.options.ecmaVersion < 6) break
+    ++this.pos
+    return this.finishToken(tt.backQuote)
 
   case 48: // '0'
-    var next = this.input.charCodeAt(this.pos + 1);
+    let next = this.input.charCodeAt(this.pos + 1)
     if (next === 120 || next === 88) return this.readRadixNumber(16); // '0x', '0X' - hex number
     if (this.options.ecmaVersion >= 6) {
       if (next === 111 || next === 79) return this.readRadixNumber(8); // '0o', '0O' - octal number
@@ -325,11 +325,11 @@ pp.getTokenFromCode = function(code) {
     // 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 this.readNumber(false);
+    return this.readNumber(false)
 
     // Quotes produce strings.
   case 34: case 39: // '"', "'"
-    return this.readString(code);
+    return this.readString(code)
 
     // Operators are parsed inline in tiny state machines. '=' (61) is
     // often referred to. `finishOp` simply skips the amount of
@@ -337,70 +337,70 @@ pp.getTokenFromCode = function(code) {
     // of the type given by its first argument.
 
   case 47: // '/'
-    return this.readToken_slash();
+    return this.readToken_slash()
 
   case 37: case 42: // '%*'
-    return this.readToken_mult_modulo(code);
+    return this.readToken_mult_modulo(code)
 
   case 124: case 38: // '|&'
-    return this.readToken_pipe_amp(code);
+    return this.readToken_pipe_amp(code)
 
   case 94: // '^'
-    return this.readToken_caret();
+    return this.readToken_caret()
 
   case 43: case 45: // '+-'
-    return this.readToken_plus_min(code);
+    return this.readToken_plus_min(code)
 
   case 60: case 62: // '<>'
-    return this.readToken_lt_gt(code);
+    return this.readToken_lt_gt(code)
 
   case 61: case 33: // '=!'
-    return this.readToken_eq_excl(code);
+    return this.readToken_eq_excl(code)
 
   case 126: // '~'
-    return this.finishOp(tt.prefix, 1);
+    return this.finishOp(tt.prefix, 1)
   }
 
-  this.raise(this.pos, "Unexpected character '" + codePointToString(code) + "'");
-};
+  this.raise(this.pos, "Unexpected character '" + codePointToString(code) + "'")
+}
 
 pp.finishOp = function(type, size) {
-  var str = this.input.slice(this.pos, this.pos + size);
-  this.pos += size;
-  return this.finishToken(type, str);
-};
+  let str = this.input.slice(this.pos, this.pos + size)
+  this.pos += size
+  return this.finishToken(type, str)
+}
 
-var regexpUnicodeSupport = false;
-try { new RegExp("\uffff", "u"); regexpUnicodeSupport = true; }
+var regexpUnicodeSupport = false
+try { new RegExp("\uffff", "u"); regexpUnicodeSupport = true }
 catch(e) {}
 
 // Parse a regular expression. Some context-awareness is necessary,
 // since a '/' inside a '[]' set does not end the expression.
 
 pp.readRegexp = function() {
-  var content = "", escaped, inClass, start = this.pos;
+  let escaped, inClass, start = this.pos
   for (;;) {
-    if (this.pos >= this.input.length) this.raise(start, "Unterminated regular expression");
-    var ch = this.input.charAt(this.pos);
-    if (lineBreak.test(ch)) this.raise(start, "Unterminated regular expression");
+    if (this.pos >= this.input.length) this.raise(start, "Unterminated regular expression")
+    let ch = this.input.charAt(this.pos)
+    if (lineBreak.test(ch)) this.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;
-    ++this.pos;
+      if (ch === "[") inClass = true
+      else if (ch === "]" && inClass) inClass = false
+      else if (ch === "/" && !inClass) break
+      escaped = ch === "\\"
+    } else escaped = false
+    ++this.pos
   }
-  var content = this.input.slice(start, this.pos);
-  ++this.pos;
+  let content = this.input.slice(start, this.pos)
+  ++this.pos
   // Need to use `readWord1` because '\uXXXX' sequences are allowed
   // here (don't ask).
-  var mods = this.readWord1();
-  var tmp = content;
+  let mods = this.readWord1()
+  let tmp = content
   if (mods) {
-    var validFlags = /^[gmsiy]*$/;
-    if (this.options.ecmaVersion >= 6) validFlags = /^[gmsiyu]*$/;
-    if (!validFlags.test(mods)) this.raise(start, "Invalid regular expression flag");
+    let validFlags = /^[gmsiy]*$/
+    if (this.options.ecmaVersion >= 6) validFlags = /^[gmsiyu]*$/
+    if (!validFlags.test(mods)) this.raise(start, "Invalid regular expression flag")
     if (mods.indexOf('u') >= 0 && !regexpUnicodeSupport) {
       // Replace each astral symbol and every Unicode escape sequence that
       // possibly represents an astral symbol or a paired surrogate with a
@@ -415,177 +415,178 @@ pp.readRegexp = function() {
   }
   // Detect invalid regular expressions.
   try {
-    new RegExp(tmp);
+    new RegExp(tmp)
   } catch (e) {
-    if (e instanceof SyntaxError) this.raise(start, "Error parsing regular expression: " + e.message);
-    this.raise(e);
+    if (e instanceof SyntaxError) this.raise(start, "Error parsing regular expression: " + e.message)
+    this.raise(e)
   }
   // Get a regular expression object for this pattern-flag pair, or `null` in
   // case the current environment doesn't support the flags it uses.
+  let value
   try {
-    var value = new RegExp(content, mods);
+    value = new RegExp(content, mods)
   } catch (err) {
-    value = null;
+    value = null
   }
-  return this.finishToken(tt.regexp, {pattern: content, flags: mods, value: value});
-};
+  return this.finishToken(tt.regexp, {pattern: content, flags: mods, value: 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.
 
 pp.readInt = function(radix, len) {
-  var start = this.pos, total = 0;
-  for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-    var code = this.input.charCodeAt(this.pos), val;
+  let start = this.pos, total = 0
+  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+    let code = this.input.charCodeAt(this.pos), 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;
-    ++this.pos;
-    total = total * radix + val;
+    else val = Infinity
+    if (val >= radix) break
+    ++this.pos
+    total = total * radix + val
   }
-  if (this.pos === start || len != null && this.pos - start !== len) return null;
+  if (this.pos === start || len != null && this.pos - start !== len) return null
 
-  return total;
-};
+  return total
+}
 
 pp.readRadixNumber = function(radix) {
   this.pos += 2; // 0x
-  var val = this.readInt(radix);
-  if (val == null) this.raise(this.start + 2, "Expected number in radix " + radix);
-  if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
-  return this.finishToken(tt.num, val);
-};
+  let val = this.readInt(radix)
+  if (val == null) this.raise(this.start + 2, "Expected number in radix " + radix)
+  if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number")
+  return this.finishToken(tt.num, val)
+}
 
 // Read an integer, octal integer, or floating-point number.
 
 pp.readNumber = function(startsWithDot) {
-  var start = this.pos, isFloat = false, octal = this.input.charCodeAt(this.pos) === 48;
-  if (!startsWithDot && this.readInt(10) === null) this.raise(start, "Invalid number");
+  let start = this.pos, isFloat = false, octal = this.input.charCodeAt(this.pos) === 48
+  if (!startsWithDot && this.readInt(10) === null) this.raise(start, "Invalid number")
   if (this.input.charCodeAt(this.pos) === 46) {
-    ++this.pos;
-    this.readInt(10);
-    isFloat = true;
+    ++this.pos
+    this.readInt(10)
+    isFloat = true
   }
-  var next = this.input.charCodeAt(this.pos);
+  let next = this.input.charCodeAt(this.pos)
   if (next === 69 || next === 101) { // 'eE'
-    next = this.input.charCodeAt(++this.pos);
+    next = this.input.charCodeAt(++this.pos)
     if (next === 43 || next === 45) ++this.pos; // '+-'
-    if (this.readInt(10) === null) this.raise(start, "Invalid number");
-    isFloat = true;
+    if (this.readInt(10) === null) this.raise(start, "Invalid number")
+    isFloat = true
   }
-  if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
+  if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number")
 
-  var str = this.input.slice(start, this.pos), val;
-  if (isFloat) val = parseFloat(str);
-  else if (!octal || str.length === 1) val = parseInt(str, 10);
-  else if (/[89]/.test(str) || this.strict) this.raise(start, "Invalid number");
-  else val = parseInt(str, 8);
-  return this.finishToken(tt.num, val);
-};
+  let str = this.input.slice(start, this.pos), val
+  if (isFloat) val = parseFloat(str)
+  else if (!octal || str.length === 1) val = parseInt(str, 10)
+  else if (/[89]/.test(str) || this.strict) this.raise(start, "Invalid number")
+  else val = parseInt(str, 8)
+  return this.finishToken(tt.num, val)
+}
 
 // Read a string value, interpreting backslash-escapes.
 
 pp.readCodePoint = function() {
-  var ch = this.input.charCodeAt(this.pos), code;
+  let ch = this.input.charCodeAt(this.pos), code
 
   if (ch === 123) {
-    if (this.options.ecmaVersion < 6) this.unexpected();
-    ++this.pos;
-    code = this.readHexChar(this.input.indexOf('}', this.pos) - this.pos);
-    ++this.pos;
-    if (code > 0x10FFFF) this.unexpected();
+    if (this.options.ecmaVersion < 6) this.unexpected()
+    ++this.pos
+    code = this.readHexChar(this.input.indexOf('}', this.pos) - this.pos)
+    ++this.pos
+    if (code > 0x10FFFF) this.unexpected()
   } else {
-    code = this.readHexChar(4);
+    code = this.readHexChar(4)
   }
-  return code;
-};
+  return code
+}
 
 function codePointToString(code) {
   // UTF-16 Decoding
-  if (code <= 0xFFFF) return String.fromCharCode(code);
+  if (code <= 0xFFFF) return String.fromCharCode(code)
   return String.fromCharCode(((code - 0x10000) >> 10) + 0xD800,
-                             ((code - 0x10000) & 1023) + 0xDC00);
+                             ((code - 0x10000) & 1023) + 0xDC00)
 }
 
 pp.readString = function(quote) {
-  var out = "", chunkStart = ++this.pos;
+  let out = "", chunkStart = ++this.pos
   for (;;) {
-    if (this.pos >= this.input.length) this.raise(this.start, "Unterminated string constant");
-    var ch = this.input.charCodeAt(this.pos);
-    if (ch === quote) break;
+    if (this.pos >= this.input.length) this.raise(this.start, "Unterminated string constant")
+    let ch = this.input.charCodeAt(this.pos)
+    if (ch === quote) break
     if (ch === 92) { // '\'
-      out += this.input.slice(chunkStart, this.pos);
-      out += this.readEscapedChar();
-      chunkStart = this.pos;
+      out += this.input.slice(chunkStart, this.pos)
+      out += this.readEscapedChar()
+      chunkStart = this.pos
     } else {
-      if (isNewLine(ch)) this.raise(this.start, "Unterminated string constant");
-      ++this.pos;
+      if (isNewLine(ch)) this.raise(this.start, "Unterminated string constant")
+      ++this.pos
     }
   }
-  out += this.input.slice(chunkStart, this.pos++);
-  return this.finishToken(tt.string, out);
-};
+  out += this.input.slice(chunkStart, this.pos++)
+  return this.finishToken(tt.string, out)
+}
 
 // Reads template string tokens.
 
 pp.readTmplToken = function() {
-  var out = "", chunkStart = this.pos;
+  let out = "", chunkStart = this.pos
   for (;;) {
-    if (this.pos >= this.input.length) this.raise(this.start, "Unterminated template");
-    var ch = this.input.charCodeAt(this.pos);
+    if (this.pos >= this.input.length) this.raise(this.start, "Unterminated template")
+    let ch = this.input.charCodeAt(this.pos)
     if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) { // '`', '${'
       if (this.pos === this.start && this.type === tt.template) {
         if (ch === 36) {
-          this.pos += 2;
-          return this.finishToken(tt.dollarBraceL);
+          this.pos += 2
+          return this.finishToken(tt.dollarBraceL)
         } else {
-          ++this.pos;
-          return this.finishToken(tt.backQuote);
+          ++this.pos
+          return this.finishToken(tt.backQuote)
         }
       }
-      out += this.input.slice(chunkStart, this.pos);
-      return this.finishToken(tt.template, out);
+      out += this.input.slice(chunkStart, this.pos)
+      return this.finishToken(tt.template, out)
     }
     if (ch === 92) { // '\'
-      out += this.input.slice(chunkStart, this.pos);
-      out += this.readEscapedChar();
-      chunkStart = this.pos;
+      out += this.input.slice(chunkStart, this.pos)
+      out += this.readEscapedChar()
+      chunkStart = this.pos
     } else if (isNewLine(ch)) {
-      out += this.input.slice(chunkStart, this.pos);
-      ++this.pos;
+      out += this.input.slice(chunkStart, this.pos)
+      ++this.pos
       if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
-        ++this.pos;
-        out += "\n";
+        ++this.pos
+        out += "\n"
       } else {
-        out += String.fromCharCode(ch);
+        out += String.fromCharCode(ch)
       }
       if (this.options.locations) {
-        ++this.curLine;
-        this.lineStart = this.pos;
+        ++this.curLine
+        this.lineStart = this.pos
       }
-      chunkStart = this.pos;
+      chunkStart = this.pos
     } else {
-      ++this.pos;
+      ++this.pos
     }
   }
-};
+}
 
 // Used to read escaped characters
 
 pp.readEscapedChar = function() {
-  var ch = this.input.charCodeAt(++this.pos);
-  var octal = /^[0-7]+/.exec(this.input.slice(this.pos, this.pos + 3));
-  if (octal) octal = octal[0];
-  while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
-  if (octal === "0") octal = null;
-  ++this.pos;
+  let ch = this.input.charCodeAt(++this.pos)
+  let octal = /^[0-7]+/.exec(this.input.slice(this.pos, this.pos + 3))
+  if (octal) octal = octal[0]
+  while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1)
+  if (octal === "0") octal = null
+  ++this.pos
   if (octal) {
-    if (this.strict) this.raise(this.pos - 2, "Octal literal in strict mode");
-    this.pos += octal.length - 1;
-    return String.fromCharCode(parseInt(octal, 8));
+    if (this.strict) this.raise(this.pos - 2, "Octal literal in strict mode")
+    this.pos += octal.length - 1
+    return String.fromCharCode(parseInt(octal, 8))
   } else {
     switch (ch) {
     case 110: return "\n"; // 'n' -> '\n'
@@ -599,26 +600,26 @@ pp.readEscapedChar = function() {
     case 48: return "\0"; // 0 -> '\0'
     case 13: if (this.input.charCodeAt(this.pos) === 10) ++this.pos; // '\r\n'
     case 10: // ' \n'
-      if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }
-      return "";
-    default: return String.fromCharCode(ch);
+      if (this.options.locations) { this.lineStart = this.pos; ++this.curLine }
+      return ""
+    default: return String.fromCharCode(ch)
     }
   }
-};
+}
 
 // Used to read character escape sequences ('\x', '\u', '\U').
 
 pp.readHexChar = function(len) {
-  var n = this.readInt(16, len);
-  if (n === null) this.raise(this.start, "Bad character escape sequence");
-  return n;
-};
+  let n = this.readInt(16, len)
+  if (n === null) this.raise(this.start, "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;
+var containsEsc
 
 // Read an identifier, and return it as a string. Sets `containsEsc`
 // to whether the word contained a '\u' escape.
@@ -627,40 +628,40 @@ var containsEsc;
 // as a micro-optimization.
 
 pp.readWord1 = function() {
-  containsEsc = false;
-  var word = "", first = true, chunkStart = this.pos;
-  var astral = this.options.ecmaVersion >= 6;
+  containsEsc = false
+  let word = "", first = true, chunkStart = this.pos
+  let astral = this.options.ecmaVersion >= 6
   while (this.pos < this.input.length) {
-    var ch = this.fullCharCodeAtPos();
+    let ch = this.fullCharCodeAtPos()
     if (isIdentifierChar(ch, astral)) {
-      this.pos += ch <= 0xffff ? 1 : 2;
+      this.pos += ch <= 0xffff ? 1 : 2
     } else if (ch === 92) { // "\"
-      containsEsc = true;
-      word += this.input.slice(chunkStart, this.pos);
-      var escStart = this.pos;
+      containsEsc = true
+      word += this.input.slice(chunkStart, this.pos)
+      let escStart = this.pos
       if (this.input.charCodeAt(++this.pos) != 117) // "u"
-        this.raise(this.pos, "Expecting Unicode escape sequence \\uXXXX");
-      ++this.pos;
-      var esc = this.readCodePoint();
+        this.raise(this.pos, "Expecting Unicode escape sequence \\uXXXX")
+      ++this.pos
+      let esc = this.readCodePoint()
       if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))
-        this.raise(escStart, "Invalid Unicode escape");
-      word += codePointToString(esc);
-      chunkStart = this.pos;
+        this.raise(escStart, "Invalid Unicode escape")
+      word += codePointToString(esc)
+      chunkStart = this.pos
     } else {
-      break;
+      break
     }
-    first = false;
+    first = false
   }
-  return word + this.input.slice(chunkStart, this.pos);
-};
+  return word + this.input.slice(chunkStart, this.pos)
+}
 
 // Read an identifier or keyword token. Will check for reserved
 // words when necessary.
 
 pp.readWord = function() {
-  var word = this.readWord1();
-  var type = tt.name;
+  let word = this.readWord1()
+  let type = tt.name
   if ((this.options.ecmaVersion >= 6 || !containsEsc) && this.isKeyword(word))
-    type = keywordTypes[word];
-  return this.finishToken(type, word);
-};
+    type = keywordTypes[word]
+  return this.finishToken(type, word)
+}

From 35c417d02b1ddd53943e0637bbd873c03b731f6a Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 17:05:23 +0100
Subject: [PATCH 30/43] Remove remnants of docco-based homepage

---
 docco.css    | 192 ---------------------------------------------------
 package.json |  14 ++--
 src/index.js |   2 +-
 3 files changed, 10 insertions(+), 198 deletions(-)
 delete mode 100644 docco.css

diff --git a/docco.css b/docco.css
deleted file mode 100644
index 04cc7ecb8a..0000000000
--- a/docco.css
+++ /dev/null
@@ -1,192 +0,0 @@
-/*--------------------- Layout and Typography ----------------------------*/
-body {
-  font-family: 'Palatino Linotype', 'Book Antiqua', Palatino, FreeSerif, serif;
-  font-size: 15px;
-  line-height: 22px;
-  color: #252519;
-  margin: 0; padding: 0;
-}
-a {
-  color: #261a3b;
-}
-  a:visited {
-    color: #261a3b;
-  }
-p {
-  margin: 0 0 15px 0;
-}
-h1, h2, h3, h4, h5, h6 {
-  margin: 0px 0 15px 0;
-}
-  h1 {
-    margin-top: 40px;
-  }
-hr {
-    border: 0 none;
-    border-top: 1px solid #e5e5ee;
-    height: 1px;
-    margin: 20px 0;
-}
-#container {
-  position: relative;
-}
-#background {
-  position: fixed;
-  top: 0; left: 525px; right: 0; bottom: 0;
-  background: #f5f5ff;
-  border-left: 1px solid #e5e5ee;
-  z-index: -1;
-}
-#jump_to, #jump_page {
-  background: white;
-  -webkit-box-shadow: 0 0 25px #777; -moz-box-shadow: 0 0 25px #777;
-  -webkit-border-bottom-left-radius: 5px; -moz-border-radius-bottomleft: 5px;
-  font: 10px Arial;
-  text-transform: uppercase;
-  cursor: pointer;
-  text-align: right;
-}
-#jump_to, #jump_wrapper {
-  position: fixed;
-  right: 0; top: 0;
-  padding: 5px 10px;
-}
-  #jump_wrapper {
-    padding: 0;
-    display: none;
-  }
-    #jump_to:hover #jump_wrapper {
-      display: block;
-    }
-    #jump_page {
-      padding: 5px 0 3px;
-      margin: 0 0 25px 25px;
-    }
-      #jump_page .source {
-        display: block;
-        padding: 5px 10px;
-        text-decoration: none;
-        border-top: 1px solid #eee;
-      }
-        #jump_page .source:hover {
-          background: #f5f5ff;
-        }
-        #jump_page .source:first-child {
-        }
-table td {
-  border: 0;
-  outline: 0;
-}
-  td.docs, th.docs {
-    max-width: 450px;
-    min-width: 450px;
-    min-height: 5px;
-    padding: 10px 25px 1px 50px;
-    overflow-x: hidden;
-    vertical-align: top;
-    text-align: left;
-  }
-    .docs pre {
-      margin: 15px 0 15px;
-      padding-left: 15px;
-    }
-    .docs p tt, .docs p code {
-      background: #f8f8ff;
-      border: 1px solid #dedede;
-      font-size: 12px;
-      padding: 0 0.2em;
-    }
-    .pilwrap {
-      position: relative;
-    }
-      .pilcrow {
-        font: 12px Arial;
-        text-decoration: none;
-        color: #454545;
-        position: absolute;
-        top: 3px; left: -20px;
-        padding: 1px 2px;
-        opacity: 0;
-        -webkit-transition: opacity 0.2s linear;
-      }
-        td.docs:hover .pilcrow {
-          opacity: 1;
-        }
-  td.code, th.code {
-    padding: 14px 15px 16px 25px;
-    width: 100%;
-    vertical-align: top;
-    background: #f5f5ff;
-    border-left: 1px solid #e5e5ee;
-  }
-    pre, tt, code {
-      font-size: 12px; line-height: 18px;
-      font-family: Menlo, Monaco, Consolas, "Lucida Console", monospace;
-      margin: 0; padding: 0;
-    }
-
-
-/*---------------------- Syntax Highlighting -----------------------------*/
-td.linenos { background-color: #f0f0f0; padding-right: 10px; }
-span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }
-body .hll { background-color: #ffffcc }
-body .c { color: #408080; font-style: italic }  /* Comment */
-body .err { border: 1px solid #FF0000 }         /* Error */
-body .k { color: #954121 }                      /* Keyword */
-body .o { color: #666666 }                      /* Operator */
-body .cm { color: #408080; font-style: italic } /* Comment.Multiline */
-body .cp { color: #BC7A00 }                     /* Comment.Preproc */
-body .c1 { color: #408080; font-style: italic } /* Comment.Single */
-body .cs { color: #408080; font-style: italic } /* Comment.Special */
-body .gd { color: #A00000 }                     /* Generic.Deleted */
-body .ge { font-style: italic }                 /* Generic.Emph */
-body .gr { color: #FF0000 }                     /* Generic.Error */
-body .gh { color: #000080; font-weight: bold }  /* Generic.Heading */
-body .gi { color: #00A000 }                     /* Generic.Inserted */
-body .go { color: #808080 }                     /* Generic.Output */
-body .gp { color: #000080; font-weight: bold }  /* Generic.Prompt */
-body .gs { font-weight: bold }                  /* Generic.Strong */
-body .gu { color: #800080; font-weight: bold }  /* Generic.Subheading */
-body .gt { color: #0040D0 }                     /* Generic.Traceback */
-body .kc { color: #954121 }                     /* Keyword.Constant */
-body .kd { color: #954121; font-weight: bold }  /* Keyword.Declaration */
-body .kn { color: #954121; font-weight: bold }  /* Keyword.Namespace */
-body .kp { color: #954121 }                     /* Keyword.Pseudo */
-body .kr { color: #954121; font-weight: bold }  /* Keyword.Reserved */
-body .kt { color: #B00040 }                     /* Keyword.Type */
-body .m { color: #666666 }                      /* Literal.Number */
-body .s { color: #219161 }                      /* Literal.String */
-body .na { color: #7D9029 }                     /* Name.Attribute */
-body .nb { color: #954121 }                     /* Name.Builtin */
-body .nc { color: #0000FF; font-weight: bold }  /* Name.Class */
-body .no { color: #880000 }                     /* Name.Constant */
-body .nd { color: #AA22FF }                     /* Name.Decorator */
-body .ni { color: #999999; font-weight: bold }  /* Name.Entity */
-body .ne { color: #D2413A; font-weight: bold }  /* Name.Exception */
-body .nf { color: #0000FF }                     /* Name.Function */
-body .nl { color: #A0A000 }                     /* Name.Label */
-body .nn { color: #0000FF; font-weight: bold }  /* Name.Namespace */
-body .nt { color: #954121; font-weight: bold }  /* Name.Tag */
-body .nv { color: #19469D }                     /* Name.Variable */
-body .ow { color: #AA22FF; font-weight: bold }  /* Operator.Word */
-body .w { color: #bbbbbb }                      /* Text.Whitespace */
-body .mf { color: #666666 }                     /* Literal.Number.Float */
-body .mh { color: #666666 }                     /* Literal.Number.Hex */
-body .mi { color: #666666 }                     /* Literal.Number.Integer */
-body .mo { color: #666666 }                     /* Literal.Number.Oct */
-body .sb { color: #219161 }                     /* Literal.String.Backtick */
-body .sc { color: #219161 }                     /* Literal.String.Char */
-body .sd { color: #219161; font-style: italic } /* Literal.String.Doc */
-body .s2 { color: #219161 }                     /* Literal.String.Double */
-body .se { color: #BB6622; font-weight: bold }  /* Literal.String.Escape */
-body .sh { color: #219161 }                     /* Literal.String.Heredoc */
-body .si { color: #BB6688; font-weight: bold }  /* Literal.String.Interpol */
-body .sx { color: #954121 }                     /* Literal.String.Other */
-body .sr { color: #BB6688 }                     /* Literal.String.Regex */
-body .s1 { color: #219161 }                     /* Literal.String.Single */
-body .ss { color: #19469D }                     /* Literal.String.Symbol */
-body .bp { color: #954121 }                     /* Name.Builtin.Pseudo */
-body .vc { color: #19469D }                     /* Name.Variable.Class */
-body .vg { color: #19469D }                     /* Name.Variable.Global */
-body .vi { color: #19469D }                     /* Name.Variable.Instance */
-body .il { color: #666666 }                     /* Literal.Number.Integer.Long */
\ No newline at end of file
diff --git a/package.json b/package.json
index 7073d2a9e9..07c28135a4 100644
--- a/package.json
+++ b/package.json
@@ -1,9 +1,9 @@
 {
   "name": "acorn",
   "description": "ECMAScript parser",
-  "homepage": "http://marijnhaverbeke.nl/acorn/",
+  "homepage": "https://github.com/marijnh/acorn",
   "main": "dist/acorn.js",
-  "version": "0.12.1",
+  "version": "1.0.0",
   "engines": {
     "node": ">=0.4.0"
   },
@@ -12,16 +12,21 @@
       "name": "Marijn Haverbeke",
       "email": "marijnh@gmail.com",
       "web": "http://marijnhaverbeke.nl"
+    },
+    {
+      "name": "Ingvar Stepanyan",
+      "email": "me@rreverser.com",
+      "web": "http://rreverser.com/"
     }
   ],
   "repository": {
     "type": "git",
-    "url": "http://marijnhaverbeke.nl/git/acorn"
+    "url": "https://github.com/marijnh/acorn.git"
   },
   "licenses": [
     {
       "type": "MIT",
-      "url": "http://marijnhaverbeke.nl/acorn/LICENSE"
+      "url": "https://raw.githubusercontent.com/marijnh/acorn/master/LICENSE"
     }
   ],
   "scripts": {
@@ -34,7 +39,6 @@
   "devDependencies": {
     "babelify": "^5.0.4",
     "browserify": "^9.0.3",
-    "regenerate": "~0.6.2",
     "unicode-7.0.0": "~0.1.5"
   }
 }
diff --git a/src/index.js b/src/index.js
index 055f99b77c..fdc329c1d8 100644
--- a/src/index.js
+++ b/src/index.js
@@ -37,7 +37,7 @@ export {isIdentifierChar, isIdentifierStart} from "./identifier"
 export {Token} from "./tokenize"
 export {isNewLine, lineBreak, lineBreakG} from "./whitespace"
 
-export const version = "0.12.1"
+export const version = "1.0.0"
 
 // The main exported interface (under `self.acorn` when in the
 // browser) is a `parse` function that takes a code string and

From e88a5431db1b7c9d1d1ca9a76c04b27a4ae48011 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 17:19:35 +0100
Subject: [PATCH 31/43] Allow init-less destructing bindings in for/in and
 for/of

---
 src/statement.js      |  6 +++---
 test/tests-harmony.js | 41 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+), 3 deletions(-)

diff --git a/src/statement.js b/src/statement.js
index d6b94bea24..e90e97b489 100644
--- a/src/statement.js
+++ b/src/statement.js
@@ -364,7 +364,7 @@ pp.parseForIn = function(node, init) {
 
 // Parse a list of variable declarations.
 
-pp.parseVar = function(node, noIn, kind) {
+pp.parseVar = function(node, isFor, kind) {
   node.declarations = []
   node.kind = kind.keyword
   for (;;) {
@@ -372,10 +372,10 @@ pp.parseVar = function(node, noIn, kind) {
     decl.id = this.parseBindingAtom()
     this.checkLVal(decl.id, true)
     if (this.eat(tt.eq)) {
-      decl.init = this.parseMaybeAssign(noIn)
+      decl.init = this.parseMaybeAssign(isFor)
     } else if (kind === tt._const && !(this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
       this.unexpected()
-    } else if (decl.id.type != "Identifier") {
+    } else if (decl.id.type != "Identifier" && !(isFor && (this.type === tt._in || this.isContextual("of")))) {
       this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value")
     } else {
       decl.init = null
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index 75019ce3af..bf55f8bfde 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -15522,6 +15522,47 @@ test("[x,,] = 1", {
   ]
 }, {ecmaVersion: 6});
 
+test("for (var [name, value] in obj) {}", {
+  body: [
+    {
+      left: {
+        declarations: [
+          {
+            id: {
+              elements: [
+                {
+                  name: "name",
+                  type: "Identifier"
+                },
+                {
+                  name: "value",
+                  type: "Identifier"
+                }
+              ],
+              type: "ArrayPattern"
+            },
+            init: null,
+            type: "VariableDeclarator"
+          }
+        ],
+        kind: "var",
+        type: "VariableDeclaration"
+      },
+      right: {
+        name: "obj",
+        type: "Identifier"
+      },
+      body: {
+        body: [],
+        type: "BlockStatement"
+      },
+      type: "ForInStatement"
+    }
+  ],
+  sourceType: "script",
+  type: "Program"
+}, {ecmaVersion: 6})
+
 testFail("let [x]", "Complex binding patterns require an initialization value (1:7)", {ecmaVersion: 6})
 testFail("var [x]", "Complex binding patterns require an initialization value (1:7)", {ecmaVersion: 6})
 testFail("var _𖫵 = 11;", "Unexpected character '𖫵' (1:5)", {ecmaVersion: 6});

From 921e45ab2b257439790402a7e7d6aa133270ddf5 Mon Sep 17 00:00:00 2001
From: Ingvar Stepanyan <me@rreverser.com>
Date: Thu, 19 Mar 2015 22:07:12 +0200
Subject: [PATCH 32/43] SuperExpression -> Super

---
 src/expression.js       | 2 +-
 src/loose/expression.js | 2 +-
 test/tests-harmony.js   | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/expression.js b/src/expression.js
index 82eda65434..84bb04a540 100644
--- a/src/expression.js
+++ b/src/expression.js
@@ -236,7 +236,7 @@ pp.parseExprAtom = function(refShorthandDefaultPos) {
   switch (this.type) {
   case tt._this:
   case tt._super:
-    let type = this.type === tt._this ? "ThisExpression" : "SuperExpression"
+    let type = this.type === tt._this ? "ThisExpression" : "Super"
     node = this.startNode()
     this.next()
     return this.finishNode(node, type)
diff --git a/src/loose/expression.js b/src/loose/expression.js
index 4269f2f234..b0286fb58d 100644
--- a/src/loose/expression.js
+++ b/src/loose/expression.js
@@ -179,7 +179,7 @@ lp.parseExprAtom = function() {
   switch (this.tok.type) {
   case tt._this:
   case tt._super:
-    let type = this.tok.type === tt._this ? "ThisExpression" : "SuperExpression"
+    let type = this.tok.type === tt._this ? "ThisExpression" : "Super"
     node = this.startNode()
     this.next()
     return this.finishNode(node, type)
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index bf55f8bfde..5eec5cbf5e 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -7463,7 +7463,7 @@ test("\"use strict\"; (class A {constructor() { super() }})", {
                   expression: {
                     type: "CallExpression",
                     callee: {
-                      type: "SuperExpression",
+                      type: "Super",
                       loc: {
                         start: {line: 1, column: 40},
                         end: {line: 1, column: 45}
@@ -7794,7 +7794,7 @@ test("\"use strict\"; (class A { static constructor() { super() }})", {
                   expression: {
                     type: "CallExpression",
                     callee: {
-                      type: "SuperExpression",
+                      type: "Super",
                       loc: {
                         start: {line: 1, column: 48},
                         end: {line: 1, column: 53}

From 864268abb6f84e381a9bab1fa0f273c0005c7891 Mon Sep 17 00:00:00 2001
From: Ingvar Stepanyan <me@rreverser.com>
Date: Fri, 20 Mar 2015 13:01:30 +0200
Subject: [PATCH 33/43] Add support for meta-properties.

estree/estree#32
---
 src/expression.js       |  9 ++++++++-
 src/loose/expression.js |  7 ++++++-
 test/tests-harmony.js   | 15 +++++++++++++++
 3 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/src/expression.js b/src/expression.js
index 84bb04a540..fe186f68b1 100644
--- a/src/expression.js
+++ b/src/expression.js
@@ -382,7 +382,14 @@ const empty = []
 
 pp.parseNew = function() {
   let node = this.startNode()
-  this.next()
+  let meta = this.parseIdent(true)
+  if (this.options.ecmaVersion >= 6 && this.eat(tt.dot)) {
+    node.meta = meta
+    node.property = this.parseIdent(true)
+    if (node.property.name !== "target")
+      this.raise(node.property.start, "The only valid meta property for new is new.target")
+    return this.finishNode(node, "MetaProperty")
+  }
   let start = this.markPosition()
   node.callee = this.parseSubscripts(this.parseExprAtom(), start, true)
   if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false)
diff --git a/src/loose/expression.js b/src/loose/expression.js
index b0286fb58d..80aac911eb 100644
--- a/src/loose/expression.js
+++ b/src/loose/expression.js
@@ -269,7 +269,12 @@ lp.parseExprAtom = function() {
 
 lp.parseNew = function() {
   let node = this.startNode(), startIndent = this.curIndent, line = this.curLineStart
-  this.next()
+  let meta = this.parseIdent(true)
+  if (this.options.ecmaVersion >= 6 && this.eat(tt.dot)) {
+    node.meta = meta
+    node.property = this.parseIdent(true)
+    return this.finishNode(node, "MetaProperty")
+  }
   let start = this.storeCurrentPos()
   node.callee = this.parseSubscripts(this.parseExprAtom(), start, true, startIndent, line)
   if (this.tok.type == tt.parenL) {
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index 5eec5cbf5e..e536094291 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -15579,3 +15579,18 @@ testFail("'use strict'; ({eval = defValue} = obj)", "Assigning to eval in strict
 testFail("[...eval] = arr", "Assigning to eval in strict mode (1:4)", {ecmaVersion: 6, sourceType: "module"});
 
 testFail("function* y({yield}) {}", "Binding yield (1:13)", {ecmaVersion: 6});
+
+test("new.target", {
+  type: "Program",
+  body: [{
+    type: "ExpressionStatement",
+    expression: {
+      type: "MetaProperty",
+      meta: {type: "Identifier", name: "new"},
+      property: {type: "Identifier", name: "target"}
+    }
+  }],
+  sourceType: "script"
+}, {ecmaVersion: 6});
+
+testFail("new.prop", "The only valid meta property for new is new.target (1:4)", {ecmaVersion: 6});

From 0fee7a395ec2e8aa93e9050e7f185276c7c7964f Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 17:35:51 +0100
Subject: [PATCH 34/43] Fix the way 'npm test' loads the library

---
 test/driver.js | 3 ++-
 test/run.js    | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/test/driver.js b/test/driver.js
index 46e29e547c..ed48ace821 100644
--- a/test/driver.js
+++ b/test/driver.js
@@ -69,7 +69,8 @@
 
   var misMatch = exports.misMatch = function(exp, act) {
     if (!exp || !act || (typeof exp != "object") || (typeof act != "object")) {
-      if (exp !== act) return ppJSON(exp) + " !== " + ppJSON(act);
+      if (exp !== act && typeof exp != "function")
+        return ppJSON(exp) + " !== " + ppJSON(act);
     } else if (exp instanceof RegExp || act instanceof RegExp) {
       var left = ppJSON(exp), right = ppJSON(act);
       if (left !== right) return left + " !== " + right;
diff --git a/test/run.js b/test/run.js
index 865eed5cd3..43dc21d76a 100644
--- a/test/run.js
+++ b/test/run.js
@@ -51,12 +51,12 @@
   var stats, modes = {
     Normal: {
       config: {
-        parse: (typeof require === "undefined" ? window.acorn : require("../dist/acorn")).parse
+        parse: acorn.parse
       }
     },
     Loose: {
       config: {
-        parse: (typeof require === "undefined" ? window.acorn : require("../dist/acorn_loose")).parse_dammit,
+        parse: acorn.parse_dammit,
         loose: true,
         filter: function (test) {
           var opts = test.options || {};

From 685b51e0ae1eabc9b629fd7d664ffe613b1bba54 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 17:36:47 +0100
Subject: [PATCH 35/43] Make the loose parser's parseIdent actually returns an
 identifier with a name

---
 src/loose/expression.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/loose/expression.js b/src/loose/expression.js
index 80aac911eb..96d4f3a818 100644
--- a/src/loose/expression.js
+++ b/src/loose/expression.js
@@ -399,9 +399,10 @@ lp.parsePropertyAccessor = function() {
 }
 
 lp.parseIdent = function() {
+  let name = this.tok.type === tt.name ? this.tok.value : this.tok.type.keyword
+  if (!name) return this.dummyIdent()
   let node = this.startNode()
-  node.name = this.tok.type === tt.name ? this.tok.value : this.tok.type.keyword
-  this.next()
+  node.name = name
   return this.finishNode(node, "Identifier")
 }
 

From 013e48439fab0c14e4a4286e5f2b78258237ac6f Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Thu, 5 Mar 2015 11:15:04 +0100
Subject: [PATCH 36/43] Update tools/generate-identifier-regex.js

So that it can also spit out the astral maps.
---
 src/expression.js     | 2 +-
 test/tests-harmony.js | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/expression.js b/src/expression.js
index fe186f68b1..8419d9ebb2 100644
--- a/src/expression.js
+++ b/src/expression.js
@@ -491,7 +491,7 @@ pp.parsePropertyName = function(prop) {
   if (this.options.ecmaVersion >= 6) {
     if (this.eat(tt.bracketL)) {
       prop.computed = true
-      prop.key = this.parseExpression()
+      prop.key = this.parseMaybeAssign()
       this.expect(tt.bracketR)
       return
     } else {
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index e536094291..71b9be9c08 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -14051,6 +14051,8 @@ testFail("yield v", "Unexpected token (1:6)", {ecmaVersion: 6});
 
 testFail("yield 10", "Unexpected token (1:6)", {ecmaVersion: 6});
 
+testFail("void { [1, 2]: 3 };", "Unexpected token (1:9)", {ecmaVersion: 6});
+
 test("yield* 10", {
   type: "Program",
   body: [{

From 2ed8f8f2b8730e00039603d0fd630a5aa2106502 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 17:49:19 +0100
Subject: [PATCH 37/43] Fix infinite loop introduced by 685b51e

---
 src/loose/expression.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/loose/expression.js b/src/loose/expression.js
index 96d4f3a818..e1161a632f 100644
--- a/src/loose/expression.js
+++ b/src/loose/expression.js
@@ -402,6 +402,7 @@ lp.parseIdent = function() {
   let name = this.tok.type === tt.name ? this.tok.value : this.tok.type.keyword
   if (!name) return this.dummyIdent()
   let node = this.startNode()
+  this.next()
   node.name = name
   return this.finishNode(node, "Identifier")
 }

From 659f2c909124b7e4cf5f460a85a644e08c906897 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 17:51:50 +0100
Subject: [PATCH 38/43] Teach the walker about Super and MetaProperty

---
 src/walk/index.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/walk/index.js b/src/walk/index.js
index 36d4e3ed12..7adc53e24e 100644
--- a/src/walk/index.js
+++ b/src/walk/index.js
@@ -227,7 +227,7 @@ base.Function = (node, st, c) => c(node.body, st, "ScopeBody")
 base.ScopeBody = (node, st, c) => c(node, st, "Statement")
 
 base.Expression = skipThrough
-base.ThisExpression = ignore
+base.ThisExpression = base.Super = base.MetaProperty = ignore
 base.ArrayExpression = base.ArrayPattern =  (node, st, c) => {
   for (let i = 0; i < node.elements.length; ++i) {
     let elt = node.elements[i]

From 5d7f4d7a237660cb350baa0d5f7e6b474d003e8d Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 21:01:05 +0100
Subject: [PATCH 39/43] Update README

---
 README.md    | 58 +++++++++++++++++++++++++++++++++++-----------------
 src/index.js |  3 ---
 2 files changed, 39 insertions(+), 22 deletions(-)

diff --git a/README.md b/README.md
index 3ab7882203..a2f2a45b47 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 [![Build Status](https://travis-ci.org/marijnh/acorn.svg?branch=master)](https://travis-ci.org/marijnh/acorn)
 [![NPM version](https://img.shields.io/npm/v/acorn.svg)](https://www.npmjs.org/package/acorn)  
-[Author funding status: ![maintainer happiness](https://marijnhaverbeke.nl/fund/status_s.png)](https://marijnhaverbeke.nl/fund/)
+[Author funding status: ![maintainer happiness](https://marijnhaverbeke.nl/fund/status_s.png?force)](https://marijnhaverbeke.nl/fund/)
 
 A tiny, fast JavaScript parser, written completely in JavaScript.
 
@@ -31,10 +31,10 @@ recent than IE5) without any kind of module management, a single
 global object `acorn` will be defined, and all the exported properties
 will be added to that.
 
-### acorn.js
+### Main parser
 
-This file contains the actual parser (and is what you get when you
-`require("acorn")` in node.js).
+This is implemented in `dist/acorn.js`, and is what you get when you
+`require("acorn")` in node.js.
 
 **parse**`(input, options)` is used to parse a JavaScript program.
 The `input` parameter is a string, `options` can be undefined or an
@@ -161,15 +161,16 @@ 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.
 
-**tokenize**`(input, options)` exports a primitive interface to
-Acorn's tokenizer. The function takes an input string and options
-similar to `parse` (though only some options are meaningful here), and
-returns a function that can be called repeatedly to read a single
-token, and returns a `{start, end, type, value}` object (with added
-`loc` property when the `locations` option is enabled and `range`
-property when the `ranges` option is enabled).
+**tokenizer**`(input, options)` returns an object with a `getToken`
+method that can be called repeatedly to get the next token, a `{start,
+end, type, value}` object (with added `loc` property when the
+`locations` option is enabled and `range` property when the `ranges`
+option is enabled). When the token's type is `tokTypes.eof`, you
+should stop calling the method, since it will keep returning that same
+token forever.
 
-In ES6 environment, returned result can be used as any other protocol-compliant iterable:
+In ES6 environment, returned result can be used as any other
+protocol-compliant iterable:
 
 ```javascript
 for (let token of acorn.tokenize(str)) {
@@ -221,12 +222,11 @@ in a context with such a
 (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. In versions of this library downloaded
-from NPM, this script will be available as `acorn_csp.js`.
+The `dist/acorn_csp.js` file in the distribution (which is built
+by the `bin/without_eval` script) has the generated code inlined, and
+can thus run without evaluating anything.
 
-### acorn_loose.js ###
+### dist/acorn_loose.js ###
 
 This file implements an error-tolerant parser. It exposes a single
 function.
@@ -239,10 +239,10 @@ nodes with name `"✖"` as placeholders in places where it can't make
 sense of the input. Depends on `acorn.js`, because it uses the same
 tokenizer.
 
-### util/walk.js ###
+### dist/walk.js ###
 
 Implements an abstract syntax tree walker. Will store its interface in
-`acorn.walk` when used without a module system.
+`acorn.walk` when loaded without a module system.
 
 **simple**`(node, visitors, base, state)` does a 'simple' walk over
 a tree. `node` should be the AST node to walk, and `visitors` an
@@ -316,3 +316,23 @@ options:
 - `--help`: Print the usage information and quit.
 
 The utility spits out the syntax tree as JSON data.
+
+## Build system
+
+Acorn is written in ECMAScript 6, as a set of small modules, in the
+project's `src` directory, and compiled down to bigger ECMAScript 3
+files in `dist` using [Browserify](http://browserify.org) and
+[Babel](http://babeljs.io/). If you are already using Babel, you can
+consider including the modules directly.
+
+The command-line test runner (`npm test`) uses the ES6 modules. The
+browser-based test page (`test/index.html`) uses the compiled modules.
+The `bin/build-acorn.js` script builds the latter from the former.
+
+If you are working on Acorn, you'll probably want to try the code out
+directly, without an intermediate build step. In your scripts, you can
+register the Babel require shim like this:
+
+    require("babelify/node_modules/babel-core/register")
+
+That will allow you to directly `require` the ES6 modules.
diff --git a/src/index.js b/src/index.js
index fdc329c1d8..dcd5855539 100644
--- a/src/index.js
+++ b/src/index.js
@@ -65,9 +65,6 @@ export function parseExpressionAt(input, pos, options) {
 
 // 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.
 
 export function tokenizer(input, options) {
   return parser(options, input)

From a1022f38e1db23e0264b23d7b7b21dd456d97975 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 21:05:14 +0100
Subject: [PATCH 40/43] Fix trying to run .sh file with node in prepublish
 script

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 07c28135a4..333daa1951 100644
--- a/package.json
+++ b/package.json
@@ -31,7 +31,7 @@
   ],
   "scripts": {
     "test": "node test/run.js",
-    "prepublish": "node bin/prepublish.sh"
+    "prepublish": "bin/prepublish.sh"
   },
   "bin": {
     "acorn": "./bin/acorn"

From 35d0b80976082e8583f21195819ee29c64412a5c Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 21:11:52 +0100
Subject: [PATCH 41/43] Properly export acorn.plugins

---
 src/index.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/index.js b/src/index.js
index dcd5855539..7862f5f75c 100644
--- a/src/index.js
+++ b/src/index.js
@@ -19,14 +19,14 @@
 // [dammit]: acorn_loose.js
 // [walk]: util/walk.js
 
-import {Parser, plugins} from "./state"
+import {Parser} from "./state"
 import {getOptions} from "./options"
 import "./parseutil"
 import "./statement"
 import "./lval"
 import "./expression"
 
-export {Parser} from "./state"
+export {Parser, plugins} from "./state"
 export {defaultOptions} from "./options"
 export {SourceLocation} from "./location"
 export {getLineInfo} from "./location"

From 1fc1d32e1fe533070910a3a85a70bbf5b824e945 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 21:29:29 +0100
Subject: [PATCH 42/43] Add some notes on plugins to the README

---
 README.md | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/README.md b/README.md
index a2f2a45b47..4d2fc260ae 100644
--- a/README.md
+++ b/README.md
@@ -336,3 +336,44 @@ register the Babel require shim like this:
     require("babelify/node_modules/babel-core/register")
 
 That will allow you to directly `require` the ES6 modules.
+
+## Plugins
+
+Acorn is designed support allow plugins which, within reasonable
+bounds, redefine the way the parser works. Plugins can add new token
+types and new tokenizer contexts (if necessary), and extend methods in
+the parser object. This is not a clean, elegant API—using it requires
+an understanding of Acorn's internals, and plugins are likely to break
+whenever those internals are significantly changed. But still, it is
+_possible_, in this way, to create parsers for JavaScript dialects
+without forking all of Acorn. And in principle it is even possible to
+combine such plugins, so that if you have, for example, a plugin for
+parsing types and a plugin for parsing JSX-style XML literals, you
+could load them both and parse code with both JSX tags and types.
+
+A plugin should register itself by adding a property to
+`acorn.plugins`, which holds a function. Calling `acorn.parse`, a
+`plugin` option can be passed, holding an object mapping plugin names
+to configuration values (or just `true` for plugins that don't take
+options). After the parser object has been created, the initialization
+functions for the chosen plugins are called with `(parser,
+configValue)` arguments. They are expected to use the `parser.extend`
+method to extend parser methods. For example, the `readToken` method
+could be extended like this:
+
+```javascript
+parser.extend("readToken", function(nextMethod) {
+  return function(code) {
+    console.log("Reading a token!")
+    return nextMethod.call(this, code)
+  }
+})
+```
+
+The `nextMethod` argument passed to `extend`'s second argument is the
+previous value of this method, and should usually be called through to
+whenever the extended method does not handle the call itself.
+
+There is a proof-of-concept JSX plugin in the [`jsx`
+branch](https://github.com/marijnh/acorn/tree/jsx) branch of the
+Github repository.

From 44c0231c09b6093abe70fc68c854fc80e3205590 Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Fri, 20 Mar 2015 22:40:51 +0100
Subject: [PATCH 43/43] Don't require a semicolon after 'export default
 [function|class] ...'

Issue #225
---
 src/statement.js      |  8 ++++----
 test/tests-harmony.js | 29 +++++++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 4 deletions(-)

diff --git a/src/statement.js b/src/statement.js
index e90e97b489..7ac5484ec4 100644
--- a/src/statement.js
+++ b/src/statement.js
@@ -458,14 +458,14 @@ pp.parseExport = function(node) {
   }
   if (this.eat(tt._default)) { // export default ...
     let expr = this.parseMaybeAssign()
-    if (expr.id) {
-      switch (expr.type) {
+    let needsSemi = false
+    if (expr.id) switch (expr.type) {
       case "FunctionExpression": expr.type = "FunctionDeclaration"; break
       case "ClassExpression": expr.type = "ClassDeclaration"; break
-      }
+      default: needsSemi = true
     }
     node.declaration = expr
-    this.semicolon()
+    if (needsSemi) this.semicolon()
     return this.finishNode(node, "ExportDefaultDeclaration")
   }
   // export var|const|let|function|class ...
diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index 71b9be9c08..03a4a54c25 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -15596,3 +15596,32 @@ test("new.target", {
 }, {ecmaVersion: 6});
 
 testFail("new.prop", "The only valid meta property for new is new.target (1:4)", {ecmaVersion: 6});
+
+test("export default function () {} false", {
+  body: [
+    {
+      declaration: {
+        id: null,
+        generator: false,
+        expression: false,
+        params: [],
+        body: {
+          body: [],
+          type: "BlockStatement"
+        },
+        type: "FunctionExpression"
+      },
+      type: "ExportDefaultDeclaration"
+    },
+    {
+      expression: {
+        value: false,
+        raw: "false",
+        type: "Literal"
+      },
+      type: "ExpressionStatement"
+    }
+  ],
+  sourceType: "module",
+  type: "Program"
+}, {ecmaVersion: 6, sourceType: "module"})