pdf-creator-node 2.2.1 → 2.3.4

package/example/node_modules/uglify-js/lib/parse.js

@@ -1,7 +1,7 @@
 /***********************************************************************
 
   A JavaScript tokenizer / parser / beautifier / compressor.
-  https://github.com/mishoo/UglifyJS
+  https://github.com/mishoo/UglifyJS2
 
   -------------------------------- (C) ---------------------------------
 
@@ -44,23 +44,21 @@
 
 "use strict";
 
-var KEYWORDS = "break case catch class const continue debugger default delete do else extends finally for function if in instanceof let new return switch throw try typeof var void while with";
-var KEYWORDS_ATOM = "false null true";
-var RESERVED_WORDS = [
-    "abstract async await boolean byte char double enum export final float goto implements import int interface long native package private protected public short static super synchronized this throws transient volatile yield",
-    KEYWORDS_ATOM,
-    KEYWORDS,
-].join(" ");
-var KEYWORDS_BEFORE_EXPRESSION = "return new delete throw else case";
+var KEYWORDS = 'break case catch const continue debugger default delete do else finally for function if in instanceof new return switch throw try typeof var void while with';
+var KEYWORDS_ATOM = 'false null true';
+var RESERVED_WORDS = 'abstract boolean byte char class double enum export extends final float goto implements import int interface let long native package private protected public short static super synchronized this throws transient volatile yield'
+    + " " + KEYWORDS_ATOM + " " + KEYWORDS;
+var KEYWORDS_BEFORE_EXPRESSION = 'return new delete throw else case';
 
 KEYWORDS = makePredicate(KEYWORDS);
 RESERVED_WORDS = makePredicate(RESERVED_WORDS);
 KEYWORDS_BEFORE_EXPRESSION = makePredicate(KEYWORDS_BEFORE_EXPRESSION);
 KEYWORDS_ATOM = makePredicate(KEYWORDS_ATOM);
 
-var RE_BIN_NUMBER = /^0b([01]+)$/i;
-var RE_HEX_NUMBER = /^0x([0-9a-f]+)$/i;
-var RE_OCT_NUMBER = /^0o?([0-7]+)$/i;
+var OPERATOR_CHARS = makePredicate(characters("+-*&%=<>!?|~^"));
+
+var RE_HEX_NUMBER = /^0x[0-9a-f]+$/i;
+var RE_OCT_NUMBER = /^0[0-7]+$/;
 
 var OPERATORS = makePredicate([
     "in",
@@ -81,7 +79,6 @@ var OPERATORS = makePredicate([
     "*",
     "/",
     "%",
-    "**",
     ">>",
     "<<",
     ">>>",
@@ -107,30 +104,34 @@ var OPERATORS = makePredicate([
     "^=",
     "&=",
     "&&",
-    "||",
-    "??",
+    "||"
 ]);
 
-var NEWLINE_CHARS = "\n\r\u2028\u2029";
-var OPERATOR_CHARS = "+-*&%=<>!?|~^";
-var PUNC_OPENERS = "[{(";
-var PUNC_SEPARATORS = ",;:";
-var PUNC_CLOSERS = ")}]";
-var PUNC_AFTER_EXPRESSION = PUNC_SEPARATORS + PUNC_CLOSERS;
-var PUNC_BEFORE_EXPRESSION = PUNC_OPENERS + PUNC_SEPARATORS;
-var PUNC_CHARS = PUNC_BEFORE_EXPRESSION + "`" + PUNC_CLOSERS;
-var WHITESPACE_CHARS = NEWLINE_CHARS + " \u00a0\t\f\u000b\u200b\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\uFEFF";
-var NON_IDENTIFIER_CHARS = makePredicate(characters("./'\"" + OPERATOR_CHARS + PUNC_CHARS + WHITESPACE_CHARS));
-
-NEWLINE_CHARS = makePredicate(characters(NEWLINE_CHARS));
-OPERATOR_CHARS = makePredicate(characters(OPERATOR_CHARS));
-PUNC_AFTER_EXPRESSION = makePredicate(characters(PUNC_AFTER_EXPRESSION));
-PUNC_BEFORE_EXPRESSION = makePredicate(characters(PUNC_BEFORE_EXPRESSION));
-PUNC_CHARS = makePredicate(characters(PUNC_CHARS));
-WHITESPACE_CHARS = makePredicate(characters(WHITESPACE_CHARS));
+var WHITESPACE_CHARS = makePredicate(characters(" \u00a0\n\r\t\f\u000b\u200b\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000\uFEFF"));
+
+var NEWLINE_CHARS = makePredicate(characters("\n\r\u2028\u2029"));
+
+var PUNC_BEFORE_EXPRESSION = makePredicate(characters("[{(,;:"));
+
+var PUNC_CHARS = makePredicate(characters("[]{}(),;:"));
 
 /* -----[ Tokenizer ]----- */
 
+// regexps adapted from http://xregexp.com/plugins/#unicode
+var UNICODE = {
+    letter: new RegExp("[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B2\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FCC\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA78E\\uA790-\\uA7AD\\uA7B0\\uA7B1\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB5F\\uAB64\\uAB65\\uABC0-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]"),
+    digit: new RegExp("[\\u0030-\\u0039\\u0660-\\u0669\\u06F0-\\u06F9\\u07C0-\\u07C9\\u0966-\\u096F\\u09E6-\\u09EF\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0BE6-\\u0BEF\\u0C66-\\u0C6F\\u0CE6-\\u0CEF\\u0D66-\\u0D6F\\u0DE6-\\u0DEF\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F29\\u1040-\\u1049\\u1090-\\u1099\\u17E0-\\u17E9\\u1810-\\u1819\\u1946-\\u194F\\u19D0-\\u19D9\\u1A80-\\u1A89\\u1A90-\\u1A99\\u1B50-\\u1B59\\u1BB0-\\u1BB9\\u1C40-\\u1C49\\u1C50-\\u1C59\\uA620-\\uA629\\uA8D0-\\uA8D9\\uA900-\\uA909\\uA9D0-\\uA9D9\\uA9F0-\\uA9F9\\uAA50-\\uAA59\\uABF0-\\uABF9\\uFF10-\\uFF19]"),
+    non_spacing_mark: new RegExp("[\\u0300-\\u036F\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065E\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0900-\\u0902\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0955\\u0962\\u0963\\u0981\\u09BC\\u09C1-\\u09C4\\u09CD\\u09E2\\u09E3\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0B01\\u0B3C\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B56\\u0B62\\u0B63\\u0B82\\u0BC0\\u0BCD\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0CBC\\u0CBF\\u0CC6\\u0CCC\\u0CCD\\u0CE2\\u0CE3\\u0D41-\\u0D44\\u0D4D\\u0D62\\u0D63\\u0DCA\\u0DD2-\\u0DD4\\u0DD6\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F90-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1B00-\\u1B03\\u1B34\\u1B36-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1DC0-\\u1DE6\\u1DFD-\\u1DFF\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F\\uA67C\\uA67D\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA8C4\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE26]"),
+    space_combining_mark: new RegExp("[\\u0903\\u093E-\\u0940\\u0949-\\u094C\\u094E\\u0982\\u0983\\u09BE-\\u09C0\\u09C7\\u09C8\\u09CB\\u09CC\\u09D7\\u0A03\\u0A3E-\\u0A40\\u0A83\\u0ABE-\\u0AC0\\u0AC9\\u0ACB\\u0ACC\\u0B02\\u0B03\\u0B3E\\u0B40\\u0B47\\u0B48\\u0B4B\\u0B4C\\u0B57\\u0BBE\\u0BBF\\u0BC1\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCC\\u0BD7\\u0C01-\\u0C03\\u0C41-\\u0C44\\u0C82\\u0C83\\u0CBE\\u0CC0-\\u0CC4\\u0CC7\\u0CC8\\u0CCA\\u0CCB\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D40\\u0D46-\\u0D48\\u0D4A-\\u0D4C\\u0D57\\u0D82\\u0D83\\u0DCF-\\u0DD1\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0F3E\\u0F3F\\u0F7F\\u102B\\u102C\\u1031\\u1038\\u103B\\u103C\\u1056\\u1057\\u1062-\\u1064\\u1067-\\u106D\\u1083\\u1084\\u1087-\\u108C\\u108F\\u109A-\\u109C\\u17B6\\u17BE-\\u17C5\\u17C7\\u17C8\\u1923-\\u1926\\u1929-\\u192B\\u1930\\u1931\\u1933-\\u1938\\u19B0-\\u19C0\\u19C8\\u19C9\\u1A19-\\u1A1B\\u1A55\\u1A57\\u1A61\\u1A63\\u1A64\\u1A6D-\\u1A72\\u1B04\\u1B35\\u1B3B\\u1B3D-\\u1B41\\u1B43\\u1B44\\u1B82\\u1BA1\\u1BA6\\u1BA7\\u1BAA\\u1C24-\\u1C2B\\u1C34\\u1C35\\u1CE1\\u1CF2\\uA823\\uA824\\uA827\\uA880\\uA881\\uA8B4-\\uA8C3\\uA952\\uA953\\uA983\\uA9B4\\uA9B5\\uA9BA\\uA9BB\\uA9BD-\\uA9C0\\uAA2F\\uAA30\\uAA33\\uAA34\\uAA4D\\uAA7B\\uABE3\\uABE4\\uABE6\\uABE7\\uABE9\\uABEA\\uABEC]"),
+    connector_punctuation: new RegExp("[\\u005F\\u203F\\u2040\\u2054\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF3F]")
+};
+
+function is_letter(code) {
+    return (code >= 97 && code <= 122)
+        || (code >= 65 && code <= 90)
+        || (code >= 0xaa && UNICODE.letter.test(String.fromCharCode(code)));
+}
+
 function is_surrogate_pair_head(code) {
     return code >= 0xd800 && code <= 0xdbff;
 }
@@ -143,58 +144,51 @@ function is_digit(code) {
     return code >= 48 && code <= 57;
 }
 
+function is_alphanumeric_char(code) {
+    return is_digit(code) || is_letter(code);
+}
+
+function is_unicode_digit(code) {
+    return UNICODE.digit.test(String.fromCharCode(code));
+}
+
+function is_unicode_combining_mark(ch) {
+    return UNICODE.non_spacing_mark.test(ch) || UNICODE.space_combining_mark.test(ch);
+}
+
+function is_unicode_connector_punctuation(ch) {
+    return UNICODE.connector_punctuation.test(ch);
+}
+
+function is_identifier_start(code) {
+    return code == 36 || code == 95 || is_letter(code);
+}
+
 function is_identifier_char(ch) {
-    return !NON_IDENTIFIER_CHARS[ch];
+    var code = ch.charCodeAt(0);
+    return is_identifier_start(code)
+        || is_digit(code)
+        || code == 8204 // \u200c: zero-width non-joiner <ZWNJ>
+        || code == 8205 // \u200d: zero-width joiner <ZWJ> (in my ECMA-262 PDF, this is also 200c)
+        || is_unicode_combining_mark(ch)
+        || is_unicode_connector_punctuation(ch)
+        || is_unicode_digit(code)
+    ;
 }
 
 function is_identifier_string(str) {
     return /^[a-z_$][a-z0-9_$]*$/i.test(str);
 }
 
-function decode_escape_sequence(seq) {
-    switch (seq[0]) {
-      case "b": return "\b";
-      case "f": return "\f";
-      case "n": return "\n";
-      case "r": return "\r";
-      case "t": return "\t";
-      case "u":
-        var code;
-        if (seq.length == 5) {
-            code = seq.slice(1);
-        } else if (seq[1] == "{" && seq.slice(-1) == "}") {
-            code = seq.slice(2, -1);
-        } else {
-            return;
-        }
-        var num = parseInt(code, 16);
-        if (num < 0 || isNaN(num)) return;
-        if (num < 0x10000) return String.fromCharCode(num);
-        if (num > 0x10ffff) return;
-        return String.fromCharCode((num >> 10) + 0xd7c0) + String.fromCharCode((num & 0x03ff) + 0xdc00);
-      case "v": return "\u000b";
-      case "x":
-        if (seq.length != 3) return;
-        var num = parseInt(seq.slice(1), 16);
-        if (num < 0 || isNaN(num)) return;
-        return String.fromCharCode(num);
-      case "\r":
-      case "\n":
-        return "";
-      default:
-        if (seq == "0") return "\0";
-        if (seq[0] >= "0" && seq[0] <= "9") return;
-        return seq;
-    }
-}
-
 function parse_js_number(num) {
-    var match;
-    if (match = RE_BIN_NUMBER.exec(num)) return parseInt(match[1], 2);
-    if (match = RE_HEX_NUMBER.exec(num)) return parseInt(match[1], 16);
-    if (match = RE_OCT_NUMBER.exec(num)) return parseInt(match[1], 8);
-    var val = parseFloat(num);
-    if (val == num) return val;
+    if (RE_HEX_NUMBER.test(num)) {
+        return parseInt(num.substr(2), 16);
+    } else if (RE_OCT_NUMBER.test(num)) {
+        return parseInt(num.substr(1), 8);
+    } else {
+        var val = parseFloat(num);
+        if (val == num) return val;
+    }
 }
 
 function JS_Parse_Error(message, filename, line, col, pos) {
@@ -234,29 +228,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         regex_allowed   : false,
         comments_before : [],
         directives      : {},
-        directive_stack : [],
-        read_template   : with_eof_error("Unterminated template literal", function(strings) {
-            var s = "";
-            for (;;) {
-                var ch = next(true, true);
-                switch (ch) {
-                  case "\\":
-                    ch += next(true, true);
-                    break;
-                  case "`":
-                    strings.push(s);
-                    return;
-                  case "$":
-                    if (peek() == "{") {
-                        next();
-                        strings.push(s);
-                        S.regex_allowed = true;
-                        return true;
-                    }
-                }
-                s += ch;
-            }
-        }),
+        directive_stack : []
     };
     var prev_was_dot = false;
 
@@ -346,8 +318,9 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
     }
 
     function read_while(pred) {
-        var ret = "", ch;
-        while ((ch = peek()) && pred(ch)) ret += next();
+        var ret = "", ch, i = 0;
+        while ((ch = peek()) && pred(ch, i++))
+            ret += next();
         return ret;
     }
 
@@ -357,50 +330,52 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
 
     function read_num(prefix) {
         var has_e = false, after_e = false, has_x = false, has_dot = prefix == ".";
-        var num = read_while(function(ch) {
+        var num = read_while(function(ch, i) {
             var code = ch.charCodeAt(0);
             switch (code) {
               case 120: case 88: // xX
                 return has_x ? false : (has_x = true);
               case 101: case 69: // eE
                 return has_x ? true : has_e ? false : (has_e = after_e = true);
-              case 43: case 45: // +-
+              case 45: // -
+                return after_e || (i == 0 && !prefix);
+              case 43: // +
                 return after_e;
               case (after_e = false, 46): // .
                 return (!has_dot && !has_x && !has_e) ? (has_dot = true) : false;
             }
-            return is_digit(code) || /[_0-9a-fo]/i.test(ch);
+            return is_alphanumeric_char(code);
         });
         if (prefix) num = prefix + num;
-        if (/^0[0-7_]+$/.test(num)) {
-            if (next_token.has_directive("use strict")) parse_error("Legacy octal literals are not allowed in strict mode");
-        } else {
-            num = num.replace(has_x ? /([1-9a-f]|.0)_(?=[0-9a-f])/gi : /([1-9]|.0)_(?=[0-9])/gi, "$1");
+        if (RE_OCT_NUMBER.test(num) && next_token.has_directive("use strict")) {
+            parse_error("Legacy octal literals are not allowed in strict mode");
         }
         var valid = parse_js_number(num);
-        if (isNaN(valid)) parse_error("Invalid syntax: " + num);
-        if (has_dot || has_e || peek() != "n") return token("num", valid);
-        return token("bigint", num.toLowerCase() + next());
+        if (!isNaN(valid)) return token("num", valid);
+        parse_error("Invalid syntax: " + num);
     }
 
     function read_escaped_char(in_string) {
-        var seq = next(true, in_string);
-        if (seq >= "0" && seq <= "7") return read_octal_escape_sequence(seq);
-        if (seq == "u") {
-            var ch = next(true, in_string);
-            seq += ch;
-            if (ch != "{") {
-                seq += next(true, in_string) + next(true, in_string) + next(true, in_string);
-            } else do {
-                ch = next(true, in_string);
-                seq += ch;
-            } while (ch != "}");
-        } else if (seq == "x") {
-            seq += next(true, in_string) + next(true, in_string);
+        var ch = next(true, in_string);
+        switch (ch.charCodeAt(0)) {
+          case 110 : return "\n";
+          case 114 : return "\r";
+          case 116 : return "\t";
+          case 98  : return "\b";
+          case 118 : return "\u000b"; // \v
+          case 102 : return "\f";
+          case 120 : return String.fromCharCode(hex_bytes(2)); // \x
+          case 117 : return String.fromCharCode(hex_bytes(4)); // \u
+          case 10  : return ""; // newline
+          case 13  :            // \r
+            if (peek() == "\n") { // DOS newline
+                next(true, in_string);
+                return "";
+            }
         }
-        var str = decode_escape_sequence(seq);
-        if (typeof str != "string") parse_error("Invalid escape sequence: \\" + seq);
-        return str;
+        if (ch >= "0" && ch <= "7")
+            return read_octal_escape_sequence(ch);
+        return ch;
     }
 
     function read_octal_escape_sequence(ch) {
@@ -419,6 +394,17 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         return String.fromCharCode(parseInt(ch, 8));
     }
 
+    function hex_bytes(n) {
+        var num = 0;
+        for (; n > 0; --n) {
+            var digit = parseInt(next(true), 16);
+            if (isNaN(digit))
+                parse_error("Invalid hex-character pattern in string");
+            num = (num << 4) | digit;
+        }
+        return num;
+    }
+
     var read_string = with_eof_error("Unterminated string constant", function(quote_char) {
         var quote = next(), ret = "";
         for (;;) {
@@ -452,7 +438,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
     var skip_multiline_comment = with_eof_error("Unterminated multiline comment", function() {
         var regex_allowed = S.regex_allowed;
         var i = find("*/", true);
-        var text = S.text.substring(S.pos, i).replace(/\r\n|\r|\u2028|\u2029/g, "\n");
+        var text = S.text.substring(S.pos, i).replace(/\r\n|\r|\u2028|\u2029/g, '\n');
         // update stream position
         forward(text.length /* doesn't count \r\n as 2 char while S.pos - i does */ + 2);
         S.comments_before.push(token("comment2", text, true));
@@ -462,7 +448,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
 
     function read_name() {
         var backslash = false, name = "", ch, escaped = false, hex;
-        while (ch = peek()) {
+        while ((ch = peek()) != null) {
             if (!backslash) {
                 if (ch == "\\") escaped = backslash = true, next();
                 else if (is_identifier_char(ch)) name += next();
@@ -541,16 +527,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
 
     function handle_dot() {
         next();
-        var ch = peek();
-        if (ch == ".") {
-            var op = ".";
-            do {
-                op += ".";
-                next();
-            } while (peek() == ".");
-            return token("operator", op);
-        }
-        return is_digit(ch.charCodeAt(0)) ? read_num(".") : token("punc", ".");
+        return is_digit(peek().charCodeAt(0)) ? read_num(".") : token("punc", ".");
     }
 
     function read_word() {
@@ -609,9 +586,8 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
             }
             if (is_digit(code)) return read_num();
             if (PUNC_CHARS[ch]) return token("punc", next());
-            if (looking_at("=>")) return token("punc", next() + next());
             if (OPERATOR_CHARS[ch]) return read_operator();
-            if (code == 92 || !NON_IDENTIFIER_CHARS[ch]) return read_word();
+            if (code == 92 || is_identifier_start(code)) return read_word();
             break;
         }
         parse_error("Unexpected character '" + ch + "'");
@@ -663,7 +639,6 @@ var PRECEDENCE = function(a, ret) {
     }
     return ret;
 }([
-    ["??"],
     ["||"],
     ["&&"],
     ["|"],
@@ -673,11 +648,10 @@ var PRECEDENCE = function(a, ret) {
     ["<", ">", "<=", ">=", "in", "instanceof"],
     [">>", "<<", ">>>"],
     ["+", "-"],
-    ["*", "/", "%"],
-    ["**"],
+    ["*", "/", "%"]
 ], {});
 
-var ATOMIC_START_TOKEN = makePredicate("atom bigint num regexp string");
+var ATOMIC_START_TOKEN = makePredicate("atom num string regexp name");
 
 /* -----[ Parser ]----- */
 
@@ -696,16 +670,13 @@ function parse($TEXT, options) {
         input         : typeof $TEXT == "string"
                         ? tokenizer($TEXT, options.filename, options.html5_comments, options.shebang)
                         : $TEXT,
-        in_async      : false,
-        in_directives : true,
-        in_funarg     : -1,
+        token         : null,
+        prev          : null,
+        peeked        : null,
         in_function   : 0,
-        in_generator  : false,
+        in_directives : true,
         in_loop       : 0,
-        labels        : [],
-        peeked        : null,
-        prev          : null,
-        token         : null,
+        labels        : []
     };
 
     S.token = next();
@@ -780,12 +751,12 @@ function parse($TEXT, options) {
 
     function semicolon(optional) {
         if (is("punc", ";")) next();
-        else if (!optional && !can_insert_semicolon()) expect(";");
+        else if (!optional && !can_insert_semicolon()) expect_token("punc", ";");
     }
 
     function parenthesised() {
         expect("(");
-        var exp = expression();
+        var exp = expression(true);
         expect(")");
         return exp;
     }
@@ -808,12 +779,12 @@ function parse($TEXT, options) {
         }
     }
 
-    var statement = embed_tokens(function() {
+    var statement = embed_tokens(function(strict_defun) {
         handle_regexp();
         switch (S.token.type) {
           case "string":
             var dir = S.in_directives;
-            var body = expression();
+            var body = expression(true);
             if (dir) {
                 if (body instanceof AST_String) {
                     var value = body.start.raw.slice(1, -1);
@@ -826,38 +797,12 @@ function parse($TEXT, options) {
             semicolon();
             return dir ? new AST_Directive(body) : new AST_SimpleStatement({ body: body });
           case "num":
-          case "bigint":
           case "regexp":
           case "operator":
           case "atom":
             return simple_statement();
 
           case "name":
-            switch (S.token.value) {
-              case "async":
-                if (is_token(peek(), "keyword", "function")) {
-                    next();
-                    next();
-                    if (!is("operator", "*")) return function_(AST_AsyncDefun);
-                    next();
-                    return function_(AST_AsyncGeneratorDefun);
-                }
-                break;
-              case "await":
-                if (S.in_async) return simple_statement();
-                break;
-              case "export":
-                next();
-                return export_();
-              case "import":
-                if (!is_token(peek(), "punc", "(")) {
-                    next();
-                    return import_();
-                }
-              case "yield":
-                if (S.in_generator) return simple_statement();
-                break;
-            }
             return is_token(peek(), "punc", ":")
                 ? labeled_statement()
                 : simple_statement();
@@ -872,7 +817,6 @@ function parse($TEXT, options) {
                 });
               case "[":
               case "(":
-              case "`":
                 return simple_statement();
               case ";":
                 S.in_directives = false;
@@ -888,16 +832,6 @@ function parse($TEXT, options) {
                 next();
                 return break_cont(AST_Break);
 
-              case "class":
-                next();
-                return class_(AST_DefClass);
-
-              case "const":
-                next();
-                var node = const_();
-                semicolon();
-                return node;
-
               case "continue":
                 next();
                 return break_cont(AST_Continue);
@@ -930,21 +864,16 @@ function parse($TEXT, options) {
                 return for_();
 
               case "function":
+                if (!strict_defun && S.input.has_directive("use strict")) {
+                    croak("In strict mode code, functions can only be declared at top level or immediately within another function.");
+                }
                 next();
-                if (!is("operator", "*")) return function_(AST_Defun);
-                next();
-                return function_(AST_GeneratorDefun);
+                return function_(AST_Defun);
 
               case "if":
                 next();
                 return if_();
 
-              case "let":
-                next();
-                var node = let_();
-                semicolon();
-                return node;
-
               case "return":
                 if (S.in_function == 0 && !options.bare_returns)
                     croak("'return' outside of function");
@@ -953,7 +882,7 @@ function parse($TEXT, options) {
                 if (is("punc", ";")) {
                     next();
                 } else if (!can_insert_semicolon()) {
-                    value = expression();
+                    value = expression(true);
                     semicolon();
                 }
                 return new AST_Return({
@@ -971,7 +900,7 @@ function parse($TEXT, options) {
                 next();
                 if (has_newline_before(S.token))
                     croak("Illegal newline after 'throw'");
-                var value = expression();
+                var value = expression(true);
                 semicolon();
                 return new AST_Throw({
                     value: value
@@ -1019,10 +948,12 @@ function parse($TEXT, options) {
         if (!(stat instanceof AST_IterationStatement)) {
             // check for `continue` that refers to this label.
             // those should be reported as syntax errors.
-            // https://github.com/mishoo/UglifyJS/issues/287
+            // https://github.com/mishoo/UglifyJS2/issues/287
             label.references.forEach(function(ref) {
                 if (ref instanceof AST_Continue) {
-                    token_error(ref.label.start, "Continue label `" + label.name + "` must refer to IterationStatement");
+                    ref = ref.label.start;
+                    croak("Continue label `" + label.name + "` refers to non-IterationStatement.",
+                          ref.line, ref.col, ref.pos);
                 }
             });
         }
@@ -1030,7 +961,7 @@ function parse($TEXT, options) {
     }
 
     function simple_statement() {
-        var body = expression();
+        var body = expression(true);
         semicolon();
         return new AST_SimpleStatement({ body: body });
     }
@@ -1044,7 +975,7 @@ function parse($TEXT, options) {
             ldef = find_if(function(l) {
                 return l.name == label.name;
             }, S.labels);
-            if (!ldef) token_error(label.start, "Undefined label " + label.name);
+            if (!ldef) croak("Undefined label " + label.name);
             label.thedef = ldef;
         } else if (S.in_loop == 0) croak(type.TYPE + " not inside a loop or switch");
         semicolon();
@@ -1053,163 +984,22 @@ function parse($TEXT, options) {
         return stat;
     }
 
-    function class_(ctor) {
-        var was_async = S.in_async;
-        var was_gen = S.in_generator;
-        S.input.push_directives_stack();
-        S.input.add_directive("use strict");
-        var name;
-        if (ctor === AST_DefClass) {
-            name = as_symbol(AST_SymbolDefClass);
-        } else {
-            name = as_symbol(AST_SymbolClass, true);
-        }
-        var parent = null;
-        if (is("keyword", "extends")) {
-            next();
-            handle_regexp();
-            parent = expr_atom(true);
-        }
-        expect("{");
-        var props = [];
-        while (!is("punc", "}")) {
-            if (is("punc", ";")) {
-                next();
-                continue;
-            }
-            var start = S.token;
-            var fixed = is("name", "static");
-            if (fixed) next();
-            var async = is("name", "async") && peek();
-            if (async) {
-                if (async.type == "punc" && /^[(=;}]$/.test(async.value) || has_newline_before(async)) {
-                    async = false;
-                } else {
-                    async = next();
-                }
-            }
-            if (is("operator", "*")) {
-                next();
-                var internal = is("name") && /^#/.test(S.token.value);
-                var key = as_property_key();
-                var gen_start = S.token;
-                var gen = function_(async ? AST_AsyncGeneratorFunction : AST_GeneratorFunction);
-                gen.start = gen_start;
-                gen.end = prev();
-                props.push(new AST_ClassMethod({
-                    start: start,
-                    static: fixed,
-                    private: internal,
-                    key: key,
-                    value: gen,
-                    end: prev(),
-                }));
-                continue;
-            }
-            var internal = is("name") && /^#/.test(S.token.value);
-            var key = as_property_key();
-            if (is("punc", "(")) {
-                var func_start = S.token;
-                var func = function_(async ? AST_AsyncFunction : AST_Function);
-                func.start = func_start;
-                func.end = prev();
-                props.push(new AST_ClassMethod({
-                    start: start,
-                    static: fixed,
-                    private: internal,
-                    key: key,
-                    value: func,
-                    end: prev(),
-                }));
-                continue;
-            }
-            if (async) unexpected(async);
-            var value = null;
-            if (is("operator", "=")) {
-                next();
-                S.in_async = false;
-                S.in_generator = false;
-                value = maybe_assign();
-                S.in_generator = was_gen;
-                S.in_async = was_async;
-            } else if (!(is("punc", ";") || is("punc", "}"))) {
-                var type = null;
-                switch (key) {
-                  case "get":
-                    type = AST_ClassGetter;
-                    break;
-                  case "set":
-                    type = AST_ClassSetter;
-                    break;
-                }
-                if (type) {
-                    props.push(new type({
-                        start: start,
-                        static: fixed,
-                        private: is("name") && /^#/.test(S.token.value),
-                        key: as_property_key(),
-                        value: create_accessor(),
-                        end: prev(),
-                    }));
-                    continue;
-                }
-            }
-            semicolon();
-            props.push(new AST_ClassField({
-                start: start,
-                static: fixed,
-                private: internal,
-                key: key,
-                value: value,
-                end: prev(),
-            }));
-        }
-        next();
-        S.input.pop_directives_stack();
-        S.in_generator = was_gen;
-        S.in_async = was_async;
-        return new ctor({
-            extends: parent,
-            name: name,
-            properties: props,
-        });
-    }
-
     function for_() {
-        var await = is("name", "await") && next();
         expect("(");
         var init = null;
         if (!is("punc", ";")) {
-            init = is("keyword", "const")
-                ? (next(), const_(true))
-                : is("keyword", "let")
-                ? (next(), let_(true))
-                : is("keyword", "var")
+            init = is("keyword", "var")
                 ? (next(), var_(true))
-                : expression(true);
-            var ctor;
-            if (await) {
-                expect_token("name", "of");
-                ctor = AST_ForAwaitOf;
-            } else if (is("operator", "in")) {
-                next();
-                ctor = AST_ForIn;
-            } else if (is("name", "of")) {
-                next();
-                ctor = AST_ForOf;
-            }
-            if (ctor) {
-                if (init instanceof AST_Definitions) {
-                    if (init.definitions.length > 1) {
-                        token_error(init.start, "Only one variable declaration allowed in for..in/of loop");
-                    }
-                    if (ctor !== AST_ForIn && init.definitions[0].value) {
-                        token_error(init.definitions[0].value.start, "No initializers allowed in for..of loop");
-                    }
-                } else if (!(is_assignable(init) || (init = to_destructured(init)) instanceof AST_Destructured)) {
-                    token_error(init.start, "Invalid left-hand side in for..in/of loop");
+                : expression(true, true);
+            if (is("operator", "in")) {
+                if (init instanceof AST_Var) {
+                    if (init.definitions.length > 1)
+                        croak("Only one variable declaration allowed in for..in loop", init.start.line, init.start.col, init.start.pos);
+                } else if (!is_assignable(init)) {
+                    croak("Invalid left-hand side in for..in loop", init.start.line, init.start.col, init.start.pos);
                 }
-                return for_enum(ctor, init);
+                next();
+                return for_in(init);
             }
         }
         return regular_for(init);
@@ -1217,9 +1007,9 @@ function parse($TEXT, options) {
 
     function regular_for(init) {
         expect(";");
-        var test = is("punc", ";") ? null : expression();
+        var test = is("punc", ";") ? null : expression(true);
         expect(";");
-        var step = is("punc", ")") ? null : expression();
+        var step = is("punc", ")") ? null : expression(true);
         expect(")");
         return new AST_For({
             init      : init,
@@ -1229,146 +1019,30 @@ function parse($TEXT, options) {
         });
     }
 
-    function for_enum(ctor, init) {
-        var obj = expression();
+    function for_in(init) {
+        var obj = expression(true);
         expect(")");
-        return new ctor({
+        return new AST_ForIn({
             init   : init,
             object : obj,
             body   : in_loop(statement)
         });
     }
 
-    function to_funarg(node) {
-        if (node instanceof AST_Array) {
-            var rest = null;
-            if (node.elements[node.elements.length - 1] instanceof AST_Spread) {
-                rest = to_funarg(node.elements.pop().expression);
-            }
-            return new AST_DestructuredArray({
-                start: node.start,
-                elements: node.elements.map(to_funarg),
-                rest: rest,
-                end: node.end,
-            });
-        }
-        if (node instanceof AST_Assign) return new AST_DefaultValue({
-            start: node.start,
-            name: to_funarg(node.left),
-            value: node.right,
-            end: node.end,
-        });
-        if (node instanceof AST_DefaultValue) {
-            node.name = to_funarg(node.name);
-            return node;
-        }
-        if (node instanceof AST_DestructuredArray) {
-            node.elements = node.elements.map(to_funarg);
-            if (node.rest) node.rest = to_funarg(node.rest);
-            return node;
-        }
-        if (node instanceof AST_DestructuredObject) {
-            node.properties.forEach(function(prop) {
-                prop.value = to_funarg(prop.value);
-            });
-            if (node.rest) node.rest = to_funarg(node.rest);
-            return node;
-        }
-        if (node instanceof AST_Hole) return node;
-        if (node instanceof AST_Object) {
-            var rest = null;
-            if (node.properties[node.properties.length - 1] instanceof AST_Spread) {
-                rest = to_funarg(node.properties.pop().expression);
-            }
-            return new AST_DestructuredObject({
-                start: node.start,
-                properties: node.properties.map(function(prop) {
-                    if (!(prop instanceof AST_ObjectKeyVal)) token_error(prop.start, "Invalid destructuring assignment");
-                    return new AST_DestructuredKeyVal({
-                        start: prop.start,
-                        key: prop.key,
-                        value: to_funarg(prop.value),
-                        end: prop.end,
-                    });
-                }),
-                rest: rest,
-                end: node.end,
-            });
-        }
-        if (node instanceof AST_SymbolFunarg) return node;
-        if (node instanceof AST_SymbolRef) return new AST_SymbolFunarg(node);
-        token_error(node.start, "Invalid arrow parameter");
-    }
-
-    function arrow(exprs, start, async) {
-        var was_async = S.in_async;
-        var was_gen = S.in_generator;
-        S.in_async = async;
-        S.in_generator = false;
-        var was_funarg = S.in_funarg;
-        S.in_funarg = S.in_function;
-        var argnames = exprs.map(to_funarg);
-        var rest = exprs.rest || null;
-        if (rest) rest = to_funarg(rest);
-        S.in_funarg = was_funarg;
-        expect("=>");
-        var body, value;
-        var loop = S.in_loop;
-        var labels = S.labels;
-        ++S.in_function;
-        S.in_directives = true;
-        S.input.push_directives_stack();
-        S.in_loop = 0;
-        S.labels = [];
-        if (is("punc", "{")) {
-            body = block_();
-            value = null;
-            if (S.input.has_directive("use strict")) {
-                argnames.forEach(strict_verify_symbol);
-            }
-        } else {
-            body = [];
-            handle_regexp();
-            value = maybe_assign();
-        }
-        S.input.pop_directives_stack();
-        --S.in_function;
-        S.in_loop = loop;
-        S.labels = labels;
-        S.in_generator = was_gen;
-        S.in_async = was_async;
-        return new (async ? AST_AsyncArrow : AST_Arrow)({
-            start: start,
-            argnames: argnames,
-            rest: rest,
-            body: body,
-            value: value,
-            end: prev(),
-        });
-    }
-
     var function_ = function(ctor) {
-        var was_async = S.in_async;
-        var was_gen = S.in_generator;
-        var name;
-        if (/Defun$/.test(ctor.TYPE)) {
-            name = as_symbol(AST_SymbolDefun);
-            S.in_async = /^Async/.test(ctor.TYPE);
-            S.in_generator = /Generator/.test(ctor.TYPE);
-        } else {
-            S.in_async = /^Async/.test(ctor.TYPE);
-            S.in_generator = /Generator/.test(ctor.TYPE);
-            name = as_symbol(AST_SymbolLambda, true);
-        }
+        var in_statement = ctor === AST_Defun;
+        var name = is("name") ? as_symbol(in_statement ? AST_SymbolDefun : AST_SymbolLambda) : null;
+        if (in_statement && !name)
+            expect_token("name");
         if (name && ctor !== AST_Accessor && !(name instanceof AST_SymbolDeclaration))
             unexpected(prev());
         expect("(");
-        var was_funarg = S.in_funarg;
-        S.in_funarg = S.in_function;
-        var argnames = expr_list(")", !options.strict, false, function() {
-            return maybe_default(AST_SymbolFunarg);
-        });
-        S.in_funarg = was_funarg;
+        var argnames = [];
+        for (var first = true; !is("punc", ")");) {
+            if (first) first = false; else expect(",");
+            argnames.push(as_symbol(AST_SymbolFunarg));
+        }
+        next();
         var loop = S.in_loop;
         var labels = S.labels;
         ++S.in_function;
@@ -1376,22 +1050,18 @@ function parse($TEXT, options) {
         S.input.push_directives_stack();
         S.in_loop = 0;
         S.labels = [];
-        var body = block_();
+        var body = block_(true);
         if (S.input.has_directive("use strict")) {
             if (name) strict_verify_symbol(name);
             argnames.forEach(strict_verify_symbol);
-            if (argnames.rest) strict_verify_symbol(argnames.rest);
         }
         S.input.pop_directives_stack();
         --S.in_function;
         S.in_loop = loop;
         S.labels = labels;
-        S.in_generator = was_gen;
-        S.in_async = was_async;
         return new ctor({
             name: name,
             argnames: argnames,
-            rest: argnames.rest || null,
             body: body
         });
     };
@@ -1409,203 +1079,12 @@ function parse($TEXT, options) {
         });
     }
 
-    function is_alias() {
-        return is("name") || is_identifier_string(S.token.value);
-    }
-
-    function export_() {
-        if (is("operator", "*")) {
-            next();
-            var alias = "*";
-            if (is("name", "as")) {
-                next();
-                if (!is_alias()) expect_token("name");
-                alias = S.token.value;
-                next();
-            }
-            expect_token("name", "from");
-            var path = S.token;
-            expect_token("string");
-            semicolon();
-            return new AST_ExportForeign({
-                aliases: [ alias ],
-                keys: [ "*" ],
-                path: path.value,
-                quote: path.quote,
-            });
-        }
-        if (is("punc", "{")) {
-            next();
-            var aliases = [];
-            var keys = [];
-            while (is_alias()) {
-                var key = S.token;
-                next();
-                keys.push(key);
-                if (is("name", "as")) {
-                    next();
-                    if (!is_alias()) expect_token("name");
-                    aliases.push(S.token.value);
-                    next();
-                } else {
-                    aliases.push(key.value);
-                }
-                if (!is("punc", "}")) expect(",");
-            }
-            expect("}");
-            if (is("name", "from")) {
-                next();
-                var path = S.token;
-                expect_token("string");
-                semicolon();
-                return new AST_ExportForeign({
-                    aliases: aliases,
-                    keys: keys.map(function(token) {
-                        return token.value;
-                    }),
-                    path: path.value,
-                    quote: path.quote,
-                });
-            }
-            semicolon();
-            return new AST_ExportReferences({
-                properties: keys.map(function(token, index) {
-                    if (!is_token(token, "name")) token_error(token, "Name expected");
-                    var sym = _make_symbol(AST_SymbolExport, token);
-                    sym.alias = aliases[index];
-                    return sym;
-                }),
-            });
-        }
-        if (is("keyword", "default")) {
-            next();
-            var start = S.token;
-            var body = export_default_decl();
-            if (body) {
-                body.start = start;
-                body.end = prev();
-            } else {
-                body = expression();
-                semicolon();
-            }
-            return new AST_ExportDefault({ body: body });
-        }
-        return new AST_ExportDeclaration({ body: export_decl() });
-    }
-
-    function maybe_named(def, expr) {
-        if (expr.name) {
-            expr = new def(expr);
-            expr.name = new (def === AST_DefClass ? AST_SymbolDefClass : AST_SymbolDefun)(expr.name);
-        }
-        return expr;
-    }
-
-    function export_default_decl() {
-        switch (S.token.value) {
-          case "async":
-            if (!is_token(peek(), "keyword", "function")) return;
-            next();
-            next();
-            if (!is("operator", "*")) return maybe_named(AST_AsyncDefun, function_(AST_AsyncFunction));
-            next();
-            return maybe_named(AST_AsyncGeneratorDefun, function_(AST_AsyncGeneratorFunction));
-          case "class":
-            next();
-            return maybe_named(AST_DefClass, class_(AST_ClassExpression));
-          case "function":
-            next();
-            if (!is("operator", "*")) return maybe_named(AST_Defun, function_(AST_Function));
-            next();
-            return maybe_named(AST_GeneratorDefun, function_(AST_GeneratorFunction));
-        }
-    }
-
-    var export_decl = embed_tokens(function() {
-        switch (S.token.value) {
-          case "async":
-            next();
-            expect_token("keyword", "function");
-            if (!is("operator", "*")) return function_(AST_AsyncDefun);
-            next();
-            return function_(AST_AsyncGeneratorDefun);
-          case "class":
-            next();
-            return class_(AST_DefClass);
-          case "const":
-            next();
-            var node = const_();
-            semicolon();
-            return node;
-          case "function":
-            next();
-            if (!is("operator", "*")) return function_(AST_Defun);
-            next();
-            return function_(AST_GeneratorDefun);
-          case "let":
-            next();
-            var node = let_();
-            semicolon();
-            return node;
-          case "var":
-            next();
-            var node = var_();
-            semicolon();
-            return node;
-        }
-        unexpected();
-    });
-
-    function import_() {
-        var all = null;
-        var def = as_symbol(AST_SymbolImport, true);
-        var props = null;
-        if (def ? (def.key = "", is("punc", ",") && next()) : !is("string")) {
-            if (is("operator", "*")) {
-                next();
-                expect_token("name", "as");
-                all = as_symbol(AST_SymbolImport);
-                all.key = "*";
-            } else {
-                expect("{");
-                props = [];
-                while (is_alias()) {
-                    var alias;
-                    if (is_token(peek(), "name", "as")) {
-                        var key = S.token.value;
-                        next();
-                        next();
-                        alias = as_symbol(AST_SymbolImport);
-                        alias.key = key;
-                    } else {
-                        alias = as_symbol(AST_SymbolImport);
-                        alias.key = alias.name;
-                    }
-                    props.push(alias);
-                    if (!is("punc", "}")) expect(",");
-                }
-                expect("}");
-            }
-        }
-        if (all || def || props) expect_token("name", "from");
-        var path = S.token;
-        expect_token("string");
-        semicolon();
-        return new AST_Import({
-            all: all,
-            default: def,
-            path: path.value,
-            properties: props,
-            quote: path.quote,
-        });
-    }
-
-    function block_() {
+    function block_(strict_defun) {
         expect("{");
         var a = [];
         while (!is("punc", "}")) {
-            if (is("eof")) expect("}");
-            a.push(statement());
+            if (is("eof")) expect_token("punc", "}");
+            a.push(statement(strict_defun));
         }
         next();
         return a;
@@ -1613,29 +1092,27 @@ function parse($TEXT, options) {
 
     function switch_body_() {
         expect("{");
-        var a = [], branch, cur, default_branch, tmp;
+        var a = [], cur = null, branch = null, tmp;
         while (!is("punc", "}")) {
-            if (is("eof")) expect("}");
+            if (is("eof")) expect_token("punc", "}");
             if (is("keyword", "case")) {
                 if (branch) branch.end = prev();
                 cur = [];
                 branch = new AST_Case({
                     start      : (tmp = S.token, next(), tmp),
-                    expression : expression(),
+                    expression : expression(true),
                     body       : cur
                 });
                 a.push(branch);
                 expect(":");
             } else if (is("keyword", "default")) {
                 if (branch) branch.end = prev();
-                if (default_branch) croak("More than one default clause in switch statement");
                 cur = [];
                 branch = new AST_Default({
                     start : (tmp = S.token, next(), expect(":"), tmp),
                     body  : cur
                 });
                 a.push(branch);
-                default_branch = branch;
             } else {
                 if (!cur) unexpected();
                 cur.push(statement());
@@ -1651,12 +1128,9 @@ function parse($TEXT, options) {
         if (is("keyword", "catch")) {
             var start = S.token;
             next();
-            var name = null;
-            if (is("punc", "(")) {
-                next();
-                name = maybe_destructured(AST_SymbolCatch);
-                expect(")");
-            }
+            expect("(");
+            var name = as_symbol(AST_SymbolCatch);
+            expect(")");
             bcatch = new AST_Catch({
                 start   : start,
                 argname : name,
@@ -1682,22 +1156,13 @@ function parse($TEXT, options) {
         });
     }
 
-    function vardefs(type, no_in) {
+    function vardefs(no_in) {
         var a = [];
         for (;;) {
-            var start = S.token;
-            var name = maybe_destructured(type);
-            var value = null;
-            if (is("operator", "=")) {
-                next();
-                value = maybe_assign(no_in);
-            } else if (!no_in && (type === AST_SymbolConst || name instanceof AST_Destructured)) {
-                croak("Missing initializer in declaration");
-            }
             a.push(new AST_VarDef({
-                start : start,
-                name  : name,
-                value : value,
+                start : S.token,
+                name  : as_symbol(AST_SymbolVar),
+                value : is("operator", "=") ? (next(), expression(false, no_in)) : null,
                 end   : prev()
             }));
             if (!is("punc", ","))
@@ -1707,26 +1172,10 @@ function parse($TEXT, options) {
         return a;
     }
 
-    var const_ = function(no_in) {
-        return new AST_Const({
-            start       : prev(),
-            definitions : vardefs(AST_SymbolConst, no_in),
-            end         : prev()
-        });
-    };
-
-    var let_ = function(no_in) {
-        return new AST_Let({
-            start       : prev(),
-            definitions : vardefs(AST_SymbolLet, no_in),
-            end         : prev()
-        });
-    };
-
     var var_ = function(no_in) {
         return new AST_Var({
             start       : prev(),
-            definitions : vardefs(AST_SymbolVar, no_in),
+            definitions : vardefs(no_in),
             end         : prev()
         });
     };
@@ -1737,7 +1186,7 @@ function parse($TEXT, options) {
         var newexp = expr_atom(false), args;
         if (is("punc", "(")) {
             next();
-            args = expr_list(")", !options.strict);
+            args = expr_list(")");
         } else {
             args = [];
         }
@@ -1754,12 +1203,12 @@ function parse($TEXT, options) {
     function as_atom_node() {
         var tok = S.token, ret;
         switch (tok.type) {
+          case "name":
+            ret = _make_symbol(AST_SymbolRef);
+            break;
           case "num":
             ret = new AST_Number({ start: tok, end: tok, value: tok.value });
             break;
-          case "bigint":
-            ret = new AST_BigInt({ start: tok, end: tok, value: tok.value });
-            break;
           case "string":
             ret = new AST_String({
                 start : tok,
@@ -1796,18 +1245,9 @@ function parse($TEXT, options) {
         var start = S.token;
         if (is("punc")) {
             switch (start.value) {
-              case "`":
-                var tmpl = template(null);
-                tmpl.start = start;
-                tmpl.end = prev();
-                return subscripts(tmpl, allow_calls);
               case "(":
                 next();
-                if (is("punc", ")")) {
-                    next();
-                    return arrow([], start);
-                }
-                var ex = expression(false, true);
+                var ex = expression(true);
                 var len = start.comments_before.length;
                 [].unshift.apply(ex.start.comments_before, start.comments_before);
                 start.comments_before.length = 0;
@@ -1830,7 +1270,6 @@ function parse($TEXT, options) {
                 end.comments_after = ex.end.comments_after;
                 ex.end = end;
                 if (ex instanceof AST_Call) mark_pure(ex);
-                if (is("punc", "=>")) return arrow(ex instanceof AST_Sequence ? ex.expressions : [ ex ], start);
                 return subscripts(ex, allow_calls);
               case "[":
                 return subscripts(array_(), allow_calls);
@@ -1839,91 +1278,31 @@ function parse($TEXT, options) {
             }
             unexpected();
         }
-        if (is("keyword")) switch (start.value) {
-          case "class":
-            next();
-            var clazz = class_(AST_ClassExpression);
-            clazz.start = start;
-            clazz.end = prev();
-            return subscripts(clazz, allow_calls);
-          case "function":
+        if (is("keyword", "function")) {
             next();
-            var func;
-            if (is("operator", "*")) {
-                next();
-                func = function_(AST_GeneratorFunction);
-            } else {
-                func = function_(AST_Function);
-            }
+            var func = function_(AST_Function);
             func.start = start;
             func.end = prev();
             return subscripts(func, allow_calls);
         }
-        if (is("name")) {
-            var sym = _make_symbol(AST_SymbolRef, start);
-            next();
-            if (sym.name == "async") {
-                if (is("keyword", "function")) {
-                    next();
-                    var func;
-                    if (is("operator", "*")) {
-                        next();
-                        func = function_(AST_AsyncGeneratorFunction);
-                    } else {
-                        func = function_(AST_AsyncFunction);
-                    }
-                    func.start = start;
-                    func.end = prev();
-                    return subscripts(func, allow_calls);
-                }
-                if (is("name") && is_token(peek(), "punc", "=>")) {
-                    start = S.token;
-                    sym = _make_symbol(AST_SymbolRef, start);
-                    next();
-                    return arrow([ sym ], start, true);
-                }
-                if (is("punc", "(")) {
-                    var call = subscripts(sym, allow_calls);
-                    if (!is("punc", "=>")) return call;
-                    var args = call.args;
-                    if (args[args.length - 1] instanceof AST_Spread) {
-                        args.rest = args.pop().expression;
-                    }
-                    return arrow(args, start, true);
-                }
-            }
-            return is("punc", "=>") ? arrow([ sym ], start) : subscripts(sym, allow_calls);
-        }
         if (ATOMIC_START_TOKEN[S.token.type]) {
             return subscripts(as_atom_node(), allow_calls);
         }
         unexpected();
     };
 
-    function expr_list(closing, allow_trailing_comma, allow_empty, parser) {
-        if (!parser) parser = maybe_assign;
+    function expr_list(closing, allow_trailing_comma, allow_empty) {
         var first = true, a = [];
         while (!is("punc", closing)) {
             if (first) first = false; else expect(",");
             if (allow_trailing_comma && is("punc", closing)) break;
-            if (allow_empty && is("punc", ",")) {
+            if (is("punc", ",") && allow_empty) {
                 a.push(new AST_Hole({ start: S.token, end: S.token }));
-            } else if (!is("operator", "...")) {
-                a.push(parser());
-            } else if (parser === maybe_assign) {
-                a.push(new AST_Spread({
-                    start: S.token,
-                    expression: (next(), parser()),
-                    end: prev(),
-                }));
             } else {
-                next();
-                a.rest = parser();
-                if (a.rest instanceof AST_DefaultValue) token_error(a.rest.start, "Invalid rest parameter");
-                break;
+                a.push(expression(false));
             }
         }
-        expect(closing);
+        next();
         return a;
     }
 
@@ -1943,122 +1322,51 @@ function parse($TEXT, options) {
         var first = true, a = [];
         while (!is("punc", "}")) {
             if (first) first = false; else expect(",");
-            // allow trailing comma
-            if (!options.strict && is("punc", "}")) break;
+            if (!options.strict && is("punc", "}"))
+                // allow trailing comma
+                break;
             var start = S.token;
-            if (is("operator", "*")) {
-                next();
-                var key = as_property_key();
-                var gen_start = S.token;
-                var gen = function_(AST_GeneratorFunction);
-                gen.start = gen_start;
-                gen.end = prev();
-                a.push(new AST_ObjectMethod({
-                    start: start,
-                    key: key,
-                    value: gen,
-                    end: prev(),
-                }));
-                continue;
-            }
-            if (is("operator", "...")) {
-                next();
-                a.push(new AST_Spread({
-                    start: start,
-                    expression: maybe_assign(),
-                    end: prev(),
-                }));
-                continue;
-            }
-            if (is_token(peek(), "operator", "=")) {
-                var name = as_symbol(AST_SymbolRef);
-                next();
-                a.push(new AST_ObjectKeyVal({
-                    start: start,
-                    key: start.value,
-                    value: new AST_Assign({
-                        start: start,
-                        left: name,
-                        operator: "=",
-                        right: maybe_assign(),
-                        end: prev(),
-                    }),
-                    end: prev(),
-                }));
-                continue;
-            }
-            if (is_token(peek(), "punc", ",") || is_token(peek(), "punc", "}")) {
-                a.push(new AST_ObjectKeyVal({
-                    start: start,
-                    key: start.value,
-                    value: as_symbol(AST_SymbolRef),
-                    end: prev(),
-                }));
-                continue;
-            }
-            var key = as_property_key();
-            if (is("punc", "(")) {
-                var func_start = S.token;
-                var func = function_(AST_Function);
-                func.start = func_start;
-                func.end = prev();
-                a.push(new AST_ObjectMethod({
-                    start: start,
-                    key: key,
-                    value: func,
-                    end: prev(),
-                }));
-                continue;
-            }
-            if (is("punc", ":")) {
-                next();
-                a.push(new AST_ObjectKeyVal({
-                    start: start,
-                    key: key,
-                    value: maybe_assign(),
-                    end: prev(),
-                }));
-                continue;
-            }
-            if (start.type == "name") switch (key) {
-              case "async":
-                var is_gen = is("operator", "*") && next();
-                key = as_property_key();
-                var func_start = S.token;
-                var func = function_(is_gen ? AST_AsyncGeneratorFunction : AST_AsyncFunction);
-                func.start = func_start;
-                func.end = prev();
-                a.push(new AST_ObjectMethod({
-                    start: start,
-                    key: key,
-                    value: func,
-                    end: prev(),
-                }));
-                continue;
-              case "get":
-                a.push(new AST_ObjectGetter({
-                    start: start,
-                    key: as_property_key(),
-                    value: create_accessor(),
-                    end: prev(),
-                }));
-                continue;
-              case "set":
-                a.push(new AST_ObjectSetter({
-                    start: start,
-                    key: as_property_key(),
-                    value: create_accessor(),
-                    end: prev(),
-                }));
-                continue;
+            var type = start.type;
+            var name = as_property_name();
+            if (type == "name" && !is("punc", ":")) {
+                var key = new AST_SymbolAccessor({
+                    start: S.token,
+                    name: "" + as_property_name(),
+                    end: prev()
+                });
+                if (name == "get") {
+                    a.push(new AST_ObjectGetter({
+                        start : start,
+                        key   : key,
+                        value : create_accessor(),
+                        end   : prev()
+                    }));
+                    continue;
+                }
+                if (name == "set") {
+                    a.push(new AST_ObjectSetter({
+                        start : start,
+                        key   : key,
+                        value : create_accessor(),
+                        end   : prev()
+                    }));
+                    continue;
+                }
             }
-            unexpected();
+            expect(":");
+            a.push(new AST_ObjectKeyVal({
+                start : start,
+                quote : start.quote,
+                key   : "" + name,
+                value : expression(false),
+                end   : prev()
+            }));
         }
         next();
         return new AST_Object({ properties: a });
     });
 
-    function as_property_key() {
+    function as_property_name() {
         var tmp = S.token;
         switch (tmp.type) {
           case "operator":
@@ -2069,49 +1377,31 @@ function parse($TEXT, options) {
           case "keyword":
           case "atom":
             next();
-            return "" + tmp.value;
-          case "punc":
-            expect("[");
-            var key = maybe_assign();
-            expect("]");
-            return key;
+            return tmp.value;
           default:
             unexpected();
         }
     }
 
     function as_name() {
+        if (!is("name")) expect_token("name");
         var name = S.token.value;
-        expect_token("name");
+        next();
         return name;
     }
 
-    function _make_symbol(type, token) {
-        var name = token.value;
-        switch (name) {
-          case "await":
-            if (S.in_async) unexpected(token);
-            break;
-          case "super":
-            type = AST_Super;
-            break;
-          case "this":
-            type = AST_This;
-            break;
-          case "yield":
-            if (S.in_generator) unexpected(token);
-            break;
-        }
-        return new type({
-            name: "" + name,
-            start: token,
-            end: token,
+    function _make_symbol(type) {
+        var name = S.token.value;
+        return new (name == "this" ? AST_This : type)({
+            name  : String(name),
+            start : S.token,
+            end   : S.token
         });
     }
 
     function strict_verify_symbol(sym) {
         if (sym.name == "arguments" || sym.name == "eval")
-            token_error(sym.start, "Unexpected " + sym.name + " in strict mode");
+            croak("Unexpected " + sym.name + " in strict mode", sym.start.line, sym.start.col, sym.start.pos);
     }
 
     function as_symbol(type, noerror) {
@@ -2119,7 +1409,7 @@ function parse($TEXT, options) {
             if (!noerror) croak("Name expected");
             return null;
         }
-        var sym = _make_symbol(type, S.token);
+        var sym = _make_symbol(type);
         if (S.input.has_directive("use strict") && sym instanceof AST_SymbolDeclaration) {
             strict_verify_symbol(sym);
         }
@@ -2127,85 +1417,6 @@ function parse($TEXT, options) {
         return sym;
     }
 
-    function maybe_destructured(type) {
-        var start = S.token;
-        if (is("punc", "[")) {
-            next();
-            var elements = expr_list("]", !options.strict, true, function() {
-                return maybe_default(type);
-            });
-            return new AST_DestructuredArray({
-                start: start,
-                elements: elements,
-                rest: elements.rest || null,
-                end: prev(),
-            });
-        }
-        if (is("punc", "{")) {
-            next();
-            var first = true, a = [], rest = null;
-            while (!is("punc", "}")) {
-                if (first) first = false; else expect(",");
-                // allow trailing comma
-                if (!options.strict && is("punc", "}")) break;
-                var key_start = S.token;
-                if (is("punc", "[") || is_token(peek(), "punc", ":")) {
-                    var key = as_property_key();
-                    expect(":");
-                    a.push(new AST_DestructuredKeyVal({
-                        start: key_start,
-                        key: key,
-                        value: maybe_default(type),
-                        end: prev(),
-                    }));
-                    continue;
-                }
-                if (is("operator", "...")) {
-                    next();
-                    rest = maybe_destructured(type);
-                    break;
-                }
-                var name = as_symbol(type);
-                if (is("operator", "=")) {
-                    next();
-                    name = new AST_DefaultValue({
-                        start: name.start,
-                        name: name,
-                        value: maybe_assign(),
-                        end: prev(),
-                    });
-                }
-                a.push(new AST_DestructuredKeyVal({
-                    start: key_start,
-                    key: key_start.value,
-                    value: name,
-                    end: prev(),
-                }));
-            }
-            expect("}");
-            return new AST_DestructuredObject({
-                start: start,
-                properties: a,
-                rest: rest,
-                end: prev(),
-            });
-        }
-        return as_symbol(type);
-    }
-
-    function maybe_default(type) {
-        var start = S.token;
-        var name = maybe_destructured(type);
-        if (!is("operator", "=")) return name;
-        next();
-        return new AST_DefaultValue({
-            start: start,
-            name: name,
-            value: maybe_assign(),
-            end: prev(),
-        });
-    }
-
     function mark_pure(call) {
         var start = call.start;
         var comments = start.comments_before;
@@ -2219,23 +1430,6 @@ function parse($TEXT, options) {
         }
     }
 
-    function template(tag) {
-        var read = S.input.context().read_template;
-        var strings = [];
-        var expressions = [];
-        while (read(strings)) {
-            next();
-            expressions.push(expression());
-            if (!is("punc", "}")) unexpected();
-        }
-        next();
-        return new AST_Template({
-            expressions: expressions,
-            strings: strings,
-            tag: tag,
-        });
-    }
-
     var subscripts = function(expr, allow_calls) {
         var start = expr.start;
         if (is("punc", ".")) {
@@ -2249,7 +1443,7 @@ function parse($TEXT, options) {
         }
         if (is("punc", "[")) {
             next();
-            var prop = expression();
+            var prop = expression(true);
             expect("]");
             return subscripts(new AST_Sub({
                 start      : start,
@@ -2263,62 +1457,26 @@ function parse($TEXT, options) {
             var call = new AST_Call({
                 start      : start,
                 expression : expr,
-                args       : expr_list(")", !options.strict),
+                args       : expr_list(")"),
                 end        : prev()
             });
             mark_pure(call);
             return subscripts(call, true);
         }
-        if (is("punc", "`")) {
-            var tmpl = template(expr);
-            tmpl.start = expr.start;
-            tmpl.end = prev();
-            return subscripts(tmpl, allow_calls);
-        }
         return expr;
     };
 
-    function maybe_unary(no_in) {
+    var maybe_unary = function(allow_calls) {
         var start = S.token;
-        if (S.in_async && is("name", "await")) {
-            if (S.in_funarg === S.in_function) croak("Invalid use of await in function argument");
-            S.input.context().regex_allowed = true;
-            next();
-            return new AST_Await({
-                start: start,
-                expression: maybe_unary(no_in),
-                end: prev(),
-            });
-        }
-        if (S.in_generator && is("name", "yield")) {
-            if (S.in_funarg === S.in_function) croak("Invalid use of yield in function argument");
-            S.input.context().regex_allowed = true;
-            next();
-            var exp = null;
-            var nested = false;
-            if (is("operator", "*")) {
-                next();
-                exp = maybe_assign(no_in);
-                nested = true;
-            } else if (is("punc") ? !PUNC_AFTER_EXPRESSION[S.token.value] : !can_insert_semicolon()) {
-                exp = maybe_assign(no_in);
-            }
-            return new AST_Yield({
-                start: start,
-                expression: exp,
-                nested: nested,
-                end: prev(),
-            });
-        }
         if (is("operator") && UNARY_PREFIX[start.value]) {
             next();
             handle_regexp();
-            var ex = make_unary(AST_UnaryPrefix, start, maybe_unary(no_in));
+            var ex = make_unary(AST_UnaryPrefix, start, maybe_unary(allow_calls));
             ex.start = start;
             ex.end = prev();
             return ex;
         }
-        var val = expr_atom(true);
+        var val = expr_atom(allow_calls);
         while (is("operator") && UNARY_POSTFIX[S.token.value] && !has_newline_before(S.token)) {
             val = make_unary(AST_UnaryPostfix, S.token, val);
             val.start = start;
@@ -2326,7 +1484,7 @@ function parse($TEXT, options) {
             next();
         }
         return val;
-    }
+    };
 
     function make_unary(ctor, token, expr) {
         var op = token.value;
@@ -2334,11 +1492,11 @@ function parse($TEXT, options) {
           case "++":
           case "--":
             if (!is_assignable(expr))
-                token_error(token, "Invalid use of " + op + " operator");
+                croak("Invalid use of " + op + " operator", token.line, token.col, token.pos);
             break;
           case "delete":
             if (expr instanceof AST_SymbolRef && S.input.has_directive("use strict"))
-                token_error(expr.start, "Calling delete on expression not allowed in strict mode");
+                croak("Calling delete on expression not allowed in strict mode", expr.start.line, expr.start.col, expr.start.pos);
             break;
         }
         return new ctor({ operator: op, expression: expr });
@@ -2350,7 +1508,7 @@ function parse($TEXT, options) {
         var prec = op != null ? PRECEDENCE[op] : null;
         if (prec != null && prec > min_prec) {
             next();
-            var right = expr_op(maybe_unary(no_in), op == "**" ? prec - 1 : prec, no_in);
+            var right = expr_op(maybe_unary(true), prec, no_in);
             return expr_op(new AST_Binary({
                 start    : left.start,
                 left     : left,
@@ -2363,7 +1521,7 @@ function parse($TEXT, options) {
     };
 
     function expr_ops(no_in) {
-        return expr_op(maybe_unary(no_in), 0, no_in);
+        return expr_op(maybe_unary(true), 0, no_in);
     }
 
     var maybe_conditional = function(no_in) {
@@ -2371,13 +1529,13 @@ function parse($TEXT, options) {
         var expr = expr_ops(no_in);
         if (is("operator", "?")) {
             next();
-            var yes = maybe_assign();
+            var yes = expression(false);
             expect(":");
             return new AST_Conditional({
                 start       : start,
                 condition   : expr,
                 consequent  : yes,
-                alternative : maybe_assign(no_in),
+                alternative : expression(false, no_in),
                 end         : prev()
             });
         }
@@ -2388,69 +1546,11 @@ function parse($TEXT, options) {
         return expr instanceof AST_PropAccess || expr instanceof AST_SymbolRef;
     }
 
-    function to_destructured(node) {
-        if (node instanceof AST_Array) {
-            var rest = null;
-            if (node.elements[node.elements.length - 1] instanceof AST_Spread) {
-                rest = to_destructured(node.elements.pop().expression);
-                if (!(rest instanceof AST_Destructured || is_assignable(rest))) return node;
-            }
-            var elements = node.elements.map(to_destructured);
-            return all(elements, function(node) {
-                return node instanceof AST_DefaultValue
-                    || node instanceof AST_Destructured
-                    || node instanceof AST_Hole
-                    || is_assignable(node);
-            }) ? new AST_DestructuredArray({
-                start: node.start,
-                elements: elements,
-                rest: rest,
-                end: node.end,
-            }) : node;
-        }
-        if (node instanceof AST_Assign) {
-            var name = to_destructured(node.left);
-            return name instanceof AST_Destructured || is_assignable(name) ? new AST_DefaultValue({
-                start: node.start,
-                name: name,
-                value: node.right,
-                end: node.end,
-            }) : node;
-        }
-        if (!(node instanceof AST_Object)) return node;
-        var rest = null;
-        if (node.properties[node.properties.length - 1] instanceof AST_Spread) {
-            rest = to_destructured(node.properties.pop().expression);
-            if (!(rest instanceof AST_Destructured || is_assignable(rest))) return node;
-        }
-        var props = [];
-        for (var i = 0; i < node.properties.length; i++) {
-            var prop = node.properties[i];
-            if (!(prop instanceof AST_ObjectKeyVal)) return node;
-            var value = to_destructured(prop.value);
-            if (!(value instanceof AST_DefaultValue || value instanceof AST_Destructured || is_assignable(value))) {
-                return node;
-            }
-            props.push(new AST_DestructuredKeyVal({
-                start: prop.start,
-                key: prop.key,
-                value: value,
-                end: prop.end,
-            }));
-        }
-        return new AST_DestructuredObject({
-            start: node.start,
-            properties: props,
-            rest: rest,
-            end: node.end,
-        });
-    }
-
-    function maybe_assign(no_in) {
+    var maybe_assign = function(no_in) {
         var start = S.token;
         var left = maybe_conditional(no_in), val = S.token.value;
         if (is("operator") && ASSIGNMENT[val]) {
-            if (is_assignable(left) || val == "=" && (left = to_destructured(left)) instanceof AST_Destructured) {
+            if (is_assignable(left)) {
                 next();
                 return new AST_Assign({
                     start    : start,
@@ -2463,28 +1563,23 @@ function parse($TEXT, options) {
             croak("Invalid assignment");
         }
         return left;
-    }
+    };
 
-    function expression(no_in, maybe_arrow) {
+    var expression = function(commas, no_in) {
         var start = S.token;
         var exprs = [];
         while (true) {
-            if (maybe_arrow && is("operator", "...")) {
-                next();
-                exprs.rest = maybe_destructured(AST_SymbolFunarg);
-                break;
-            }
             exprs.push(maybe_assign(no_in));
-            if (!is("punc", ",")) break;
+            if (!commas || !is("punc", ",")) break;
             next();
-            if (maybe_arrow && is("punc", ")") && is_token(peek(), "punc", "=>")) break;
+            commas = true;
         }
-        return exprs.length == 1 && !exprs.rest ? exprs[0] : new AST_Sequence({
-            start: start,
-            expressions: exprs,
-            end: prev(),
+        return exprs.length == 1 ? exprs[0] : new AST_Sequence({
+            start       : start,
+            expressions : exprs,
+            end         : peek()
         });
-    }
+    };
 
     function in_loop(cont) {
         ++S.in_loop;
@@ -2495,9 +1590,7 @@ function parse($TEXT, options) {
 
     if (options.expression) {
         handle_regexp();
-        var exp = expression();
-        expect_token("eof");
-        return exp;
+        return expression(true);
     }
 
     return function() {
@@ -2505,7 +1598,7 @@ function parse($TEXT, options) {
         var body = [];
         S.input.push_directives_stack();
         while (!is("eof"))
-            body.push(statement());
+            body.push(statement(true));
         S.input.pop_directives_stack();
         var end = prev();
         var toplevel = options.toplevel;