Buckets:
| /*********************************************************************** | |
| A JavaScript tokenizer / parser / beautifier / compressor. | |
| https://github.com/mishoo/UglifyJS2 | |
| -------------------------------- (C) --------------------------------- | |
| Author: Mihai Bazon | |
| <mihai.bazon@gmail.com> | |
| http://mihai.bazon.net/blog | |
| Distributed under the BSD license: | |
| Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com> | |
| Parser based on parse-js (http://marijn.haverbeke.nl/parse-js/). | |
| Redistribution and use in source and binary forms, with or without | |
| modification, are permitted provided that the following conditions | |
| are met: | |
| * Redistributions of source code must retain the above | |
| copyright notice, this list of conditions and the following | |
| disclaimer. | |
| * Redistributions in binary form must reproduce the above | |
| copyright notice, this list of conditions and the following | |
| disclaimer in the documentation and/or other materials | |
| provided with the distribution. | |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY | |
| EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
| PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE | |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, | |
| OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
| PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | |
| PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR | |
| TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF | |
| THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
| SUCH DAMAGE. | |
| ***********************************************************************/ | |
| ; | |
| import { | |
| characters, | |
| defaults, | |
| makePredicate, | |
| set_annotation, | |
| } from "./utils/index.js"; | |
| import { | |
| AST_Accessor, | |
| AST_Array, | |
| AST_Arrow, | |
| AST_Assign, | |
| AST_Await, | |
| AST_BigInt, | |
| AST_Binary, | |
| AST_BlockStatement, | |
| AST_Break, | |
| AST_Call, | |
| AST_Case, | |
| AST_Catch, | |
| AST_Chain, | |
| AST_ClassExpression, | |
| AST_ClassPrivateProperty, | |
| AST_ClassProperty, | |
| AST_ClassStaticBlock, | |
| AST_ConciseMethod, | |
| AST_PrivateIn, | |
| AST_PrivateGetter, | |
| AST_PrivateMethod, | |
| AST_PrivateSetter, | |
| AST_Conditional, | |
| AST_Const, | |
| AST_Continue, | |
| AST_Debugger, | |
| AST_Default, | |
| AST_DefaultAssign, | |
| AST_DefClass, | |
| AST_Definitions, | |
| AST_Defun, | |
| AST_Destructuring, | |
| AST_Directive, | |
| AST_Do, | |
| AST_Dot, | |
| AST_DotHash, | |
| AST_EmptyStatement, | |
| AST_Expansion, | |
| AST_Export, | |
| AST_False, | |
| AST_Finally, | |
| AST_For, | |
| AST_ForIn, | |
| AST_ForOf, | |
| AST_Function, | |
| AST_Hole, | |
| AST_If, | |
| AST_Import, | |
| AST_ImportMeta, | |
| AST_IterationStatement, | |
| AST_Label, | |
| AST_LabeledStatement, | |
| AST_LabelRef, | |
| AST_Let, | |
| AST_NameMapping, | |
| AST_New, | |
| AST_NewTarget, | |
| AST_Node, | |
| AST_Null, | |
| AST_Number, | |
| AST_Object, | |
| AST_ObjectGetter, | |
| AST_ObjectKeyVal, | |
| AST_ObjectProperty, | |
| AST_ObjectSetter, | |
| AST_PrefixedTemplateString, | |
| AST_PropAccess, | |
| AST_RegExp, | |
| AST_Return, | |
| AST_Sequence, | |
| AST_SimpleStatement, | |
| AST_String, | |
| AST_Sub, | |
| AST_Super, | |
| AST_Switch, | |
| AST_SymbolCatch, | |
| AST_SymbolClass, | |
| AST_SymbolClassProperty, | |
| AST_SymbolConst, | |
| AST_SymbolDeclaration, | |
| AST_SymbolDefClass, | |
| AST_SymbolDefun, | |
| AST_SymbolExport, | |
| AST_SymbolExportForeign, | |
| AST_SymbolFunarg, | |
| AST_SymbolImport, | |
| AST_SymbolImportForeign, | |
| AST_SymbolLambda, | |
| AST_SymbolLet, | |
| AST_SymbolMethod, | |
| AST_SymbolRef, | |
| AST_SymbolVar, | |
| AST_TemplateSegment, | |
| AST_TemplateString, | |
| AST_This, | |
| AST_SymbolPrivateProperty, | |
| AST_Throw, | |
| AST_Token, | |
| AST_Toplevel, | |
| AST_True, | |
| AST_Try, | |
| AST_TryBlock, | |
| AST_UnaryPostfix, | |
| AST_UnaryPrefix, | |
| AST_Var, | |
| AST_VarDef, | |
| AST_While, | |
| AST_With, | |
| AST_Yield, | |
| _INLINE, | |
| _NOINLINE, | |
| _PURE, | |
| _KEY, | |
| _MANGLEPROP, | |
| } from "./ast.js"; | |
| var LATEST_RAW = ""; // Only used for numbers and template strings | |
| var TEMPLATE_RAWS = new Map(); // Raw template strings | |
| var KEYWORDS = "break case catch class const continue debugger default delete do else export 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 = "enum import super this " + KEYWORDS_ATOM + " " + KEYWORDS; | |
| var ALL_RESERVED_WORDS = "implements interface package private protected public static " + RESERVED_WORDS; | |
| var KEYWORDS_BEFORE_EXPRESSION = "return new delete throw else case yield await"; | |
| KEYWORDS = makePredicate(KEYWORDS); | |
| RESERVED_WORDS = makePredicate(RESERVED_WORDS); | |
| KEYWORDS_BEFORE_EXPRESSION = makePredicate(KEYWORDS_BEFORE_EXPRESSION); | |
| KEYWORDS_ATOM = makePredicate(KEYWORDS_ATOM); | |
| ALL_RESERVED_WORDS = makePredicate(ALL_RESERVED_WORDS); | |
| var OPERATOR_CHARS = makePredicate(characters("+-*&%=<>!?|~^")); | |
| var RE_NUM_LITERAL = /[0-9a-f]/i; | |
| var RE_HEX_NUMBER = /^0x[0-9a-f]+$/i; | |
| var RE_OCT_NUMBER = /^0[0-7]+$/; | |
| var RE_ES6_OCT_NUMBER = /^0o[0-7]+$/i; | |
| var RE_BIN_NUMBER = /^0b[01]+$/i; | |
| var RE_DEC_NUMBER = /^\d*\.?\d*(?:e[+-]?\d*(?:\d\.?|\.?\d)\d*)?$/i; | |
| var RE_BIG_INT = /^(0[xob])?[0-9a-f]+n$/i; | |
| var OPERATORS = makePredicate([ | |
| "in", | |
| "instanceof", | |
| "typeof", | |
| "new", | |
| "void", | |
| "delete", | |
| "++", | |
| "--", | |
| "+", | |
| "-", | |
| "!", | |
| "~", | |
| "&", | |
| "|", | |
| "^", | |
| "*", | |
| "**", | |
| "/", | |
| "%", | |
| ">>", | |
| "<<", | |
| ">>>", | |
| "<", | |
| ">", | |
| "<=", | |
| ">=", | |
| "==", | |
| "===", | |
| "!=", | |
| "!==", | |
| "?", | |
| "=", | |
| "+=", | |
| "-=", | |
| "||=", | |
| "&&=", | |
| "??=", | |
| "/=", | |
| "*=", | |
| "**=", | |
| "%=", | |
| ">>=", | |
| "<<=", | |
| ">>>=", | |
| "|=", | |
| "^=", | |
| "&=", | |
| "&&", | |
| "??", | |
| "||", | |
| ]); | |
| 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_AFTER_EXPRESSION = makePredicate(characters(";]),:")); | |
| var PUNC_BEFORE_EXPRESSION = makePredicate(characters("[{(,;:")); | |
| var PUNC_CHARS = makePredicate(characters("[]{}(),;:")); | |
| /* -----[ Tokenizer ]----- */ | |
| // surrogate safe regexps adapted from https://github.com/mathiasbynens/unicode-8.0.0/tree/89b412d8a71ecca9ed593d9e9fa073ab64acfebe/Binary_Property | |
| var UNICODE = { | |
| ID_Start: /[$A-Z_a-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\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-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\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-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]/, | |
| ID_Continue: /(?:[$0-9A-Z_a-z\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF])+/, | |
| }; | |
| function get_full_char(str, pos) { | |
| if (is_surrogate_pair_head(str.charCodeAt(pos))) { | |
| if (is_surrogate_pair_tail(str.charCodeAt(pos + 1))) { | |
| return str.charAt(pos) + str.charAt(pos + 1); | |
| } | |
| } else if (is_surrogate_pair_tail(str.charCodeAt(pos))) { | |
| if (is_surrogate_pair_head(str.charCodeAt(pos - 1))) { | |
| return str.charAt(pos - 1) + str.charAt(pos); | |
| } | |
| } | |
| return str.charAt(pos); | |
| } | |
| function get_full_char_code(str, pos) { | |
| // https://en.wikipedia.org/wiki/Universal_Character_Set_characters#Surrogates | |
| if (is_surrogate_pair_head(str.charCodeAt(pos))) { | |
| return 0x10000 + (str.charCodeAt(pos) - 0xd800 << 10) + str.charCodeAt(pos + 1) - 0xdc00; | |
| } | |
| return str.charCodeAt(pos); | |
| } | |
| function get_full_char_length(str) { | |
| var surrogates = 0; | |
| for (var i = 0; i < str.length; i++) { | |
| if (is_surrogate_pair_head(str.charCodeAt(i)) && is_surrogate_pair_tail(str.charCodeAt(i + 1))) { | |
| surrogates++; | |
| i++; | |
| } | |
| } | |
| return str.length - surrogates; | |
| } | |
| function from_char_code(code) { | |
| // Based on https://github.com/mathiasbynens/String.fromCodePoint/blob/master/fromcodepoint.js | |
| if (code > 0xFFFF) { | |
| code -= 0x10000; | |
| return (String.fromCharCode((code >> 10) + 0xD800) + | |
| String.fromCharCode((code % 0x400) + 0xDC00)); | |
| } | |
| return String.fromCharCode(code); | |
| } | |
| function is_surrogate_pair_head(code) { | |
| return code >= 0xd800 && code <= 0xdbff; | |
| } | |
| function is_surrogate_pair_tail(code) { | |
| return code >= 0xdc00 && code <= 0xdfff; | |
| } | |
| function is_digit(code) { | |
| return code >= 48 && code <= 57; | |
| } | |
| function is_identifier_start(ch) { | |
| return UNICODE.ID_Start.test(ch); | |
| } | |
| function is_identifier_char(ch) { | |
| return UNICODE.ID_Continue.test(ch); | |
| } | |
| const BASIC_IDENT = /^[a-z_$][a-z0-9_$]*$/i; | |
| function is_basic_identifier_string(str) { | |
| return BASIC_IDENT.test(str); | |
| } | |
| function is_identifier_string(str, allow_surrogates) { | |
| if (BASIC_IDENT.test(str)) { | |
| return true; | |
| } | |
| if (!allow_surrogates && /[\ud800-\udfff]/.test(str)) { | |
| return false; | |
| } | |
| var match = UNICODE.ID_Start.exec(str); | |
| if (!match || match.index !== 0) { | |
| return false; | |
| } | |
| str = str.slice(match[0].length); | |
| if (!str) { | |
| return true; | |
| } | |
| match = UNICODE.ID_Continue.exec(str); | |
| return !!match && match[0].length === str.length; | |
| } | |
| function parse_js_number(num, allow_e = true) { | |
| if (!allow_e && num.includes("e")) { | |
| return NaN; | |
| } | |
| 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 if (RE_ES6_OCT_NUMBER.test(num)) { | |
| return parseInt(num.substr(2), 8); | |
| } else if (RE_BIN_NUMBER.test(num)) { | |
| return parseInt(num.substr(2), 2); | |
| } else if (RE_DEC_NUMBER.test(num)) { | |
| return parseFloat(num); | |
| } else { | |
| var val = parseFloat(num); | |
| if (val == num) return val; | |
| } | |
| } | |
| class JS_Parse_Error extends Error { | |
| constructor(message, filename, line, col, pos) { | |
| super(); | |
| this.name = "SyntaxError"; | |
| this.message = message; | |
| this.filename = filename; | |
| this.line = line; | |
| this.col = col; | |
| this.pos = pos; | |
| } | |
| } | |
| function js_error(message, filename, line, col, pos) { | |
| throw new JS_Parse_Error(message, filename, line, col, pos); | |
| } | |
| function is_token(token, type, val) { | |
| return token.type == type && (val == null || token.value == val); | |
| } | |
| var EX_EOF = {}; | |
| function tokenizer($TEXT, filename, html5_comments, shebang) { | |
| var S = { | |
| text : $TEXT, | |
| filename : filename, | |
| pos : 0, | |
| tokpos : 0, | |
| line : 1, | |
| tokline : 0, | |
| col : 0, | |
| tokcol : 0, | |
| newline_before : false, | |
| regex_allowed : false, | |
| brace_counter : 0, | |
| template_braces : [], | |
| comments_before : [], | |
| directives : {}, | |
| directive_stack : [] | |
| }; | |
| function peek() { return get_full_char(S.text, S.pos); } | |
| // Used because parsing ?. involves a lookahead for a digit | |
| function is_option_chain_op() { | |
| const must_be_dot = S.text.charCodeAt(S.pos + 1) === 46; | |
| if (!must_be_dot) return false; | |
| const cannot_be_digit = S.text.charCodeAt(S.pos + 2); | |
| return cannot_be_digit < 48 || cannot_be_digit > 57; | |
| } | |
| function next(signal_eof, in_string) { | |
| var ch = get_full_char(S.text, S.pos++); | |
| if (signal_eof && !ch) | |
| throw EX_EOF; | |
| if (NEWLINE_CHARS.has(ch)) { | |
| S.newline_before = S.newline_before || !in_string; | |
| ++S.line; | |
| S.col = 0; | |
| if (ch == "\r" && peek() == "\n") { | |
| // treat a \r\n sequence as a single \n | |
| ++S.pos; | |
| ch = "\n"; | |
| } | |
| } else { | |
| if (ch.length > 1) { | |
| ++S.pos; | |
| ++S.col; | |
| } | |
| ++S.col; | |
| } | |
| return ch; | |
| } | |
| function forward(i) { | |
| while (i--) next(); | |
| } | |
| function looking_at(str) { | |
| return S.text.substr(S.pos, str.length) == str; | |
| } | |
| function find_eol() { | |
| var text = S.text; | |
| for (var i = S.pos, n = S.text.length; i < n; ++i) { | |
| var ch = text[i]; | |
| if (NEWLINE_CHARS.has(ch)) | |
| return i; | |
| } | |
| return -1; | |
| } | |
| function find(what, signal_eof) { | |
| var pos = S.text.indexOf(what, S.pos); | |
| if (signal_eof && pos == -1) throw EX_EOF; | |
| return pos; | |
| } | |
| function start_token() { | |
| S.tokline = S.line; | |
| S.tokcol = S.col; | |
| S.tokpos = S.pos; | |
| } | |
| var prev_was_dot = false; | |
| var previous_token = null; | |
| function token(type, value, is_comment) { | |
| S.regex_allowed = ((type == "operator" && !UNARY_POSTFIX.has(value)) || | |
| (type == "keyword" && KEYWORDS_BEFORE_EXPRESSION.has(value)) || | |
| (type == "punc" && PUNC_BEFORE_EXPRESSION.has(value))) || | |
| (type == "arrow"); | |
| if (type == "punc" && (value == "." || value == "?.")) { | |
| prev_was_dot = true; | |
| } else if (!is_comment) { | |
| prev_was_dot = false; | |
| } | |
| const line = S.tokline; | |
| const col = S.tokcol; | |
| const pos = S.tokpos; | |
| const nlb = S.newline_before; | |
| const file = filename; | |
| let comments_before = []; | |
| let comments_after = []; | |
| if (!is_comment) { | |
| comments_before = S.comments_before; | |
| comments_after = S.comments_before = []; | |
| } | |
| S.newline_before = false; | |
| const tok = new AST_Token(type, value, line, col, pos, nlb, comments_before, comments_after, file); | |
| if (!is_comment) previous_token = tok; | |
| return tok; | |
| } | |
| function skip_whitespace() { | |
| while (WHITESPACE_CHARS.has(peek())) | |
| next(); | |
| } | |
| function read_while(pred) { | |
| var ret = "", ch, i = 0; | |
| while ((ch = peek()) && pred(ch, i++)) | |
| ret += next(); | |
| return ret; | |
| } | |
| function parse_error(err) { | |
| js_error(err, filename, S.tokline, S.tokcol, S.tokpos); | |
| } | |
| function read_num(prefix) { | |
| var has_e = false, after_e = false, has_x = false, has_dot = prefix == ".", is_big_int = false, numeric_separator = false; | |
| var num = read_while(function(ch, i) { | |
| if (is_big_int) return false; | |
| var code = ch.charCodeAt(0); | |
| switch (code) { | |
| case 95: // _ | |
| return (numeric_separator = true); | |
| case 98: case 66: // bB | |
| return (has_x = true); // Can occur in hex sequence, don't return false yet | |
| case 111: case 79: // oO | |
| 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 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; | |
| } | |
| if (ch === "n") { | |
| is_big_int = true; | |
| return true; | |
| } | |
| return RE_NUM_LITERAL.test(ch); | |
| }); | |
| if (prefix) num = prefix + num; | |
| LATEST_RAW = num; | |
| if (RE_OCT_NUMBER.test(num) && next_token.has_directive("use strict")) { | |
| parse_error("Legacy octal literals are not allowed in strict mode"); | |
| } | |
| if (numeric_separator) { | |
| if (num.endsWith("_")) { | |
| parse_error("Numeric separators are not allowed at the end of numeric literals"); | |
| } else if (num.includes("__")) { | |
| parse_error("Only one underscore is allowed as numeric separator"); | |
| } | |
| num = num.replace(/_/g, ""); | |
| } | |
| if (num.endsWith("n")) { | |
| const without_n = num.slice(0, -1); | |
| const allow_e = RE_HEX_NUMBER.test(without_n); | |
| const valid = parse_js_number(without_n, allow_e); | |
| if (!has_dot && RE_BIG_INT.test(num) && !isNaN(valid)) | |
| return token("big_int", without_n); | |
| parse_error("Invalid or unexpected token"); | |
| } | |
| var valid = parse_js_number(num); | |
| if (!isNaN(valid)) { | |
| return token("num", valid); | |
| } else { | |
| parse_error("Invalid syntax: " + num); | |
| } | |
| } | |
| function is_octal(ch) { | |
| return ch >= "0" && ch <= "7"; | |
| } | |
| function read_escaped_char(in_string, strict_hex, template_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, strict_hex)); // \x | |
| case 117 : // \u | |
| if (peek() == "{") { | |
| next(true); | |
| if (peek() === "}") | |
| parse_error("Expecting hex-character between {}"); | |
| while (peek() == "0") next(true); // No significance | |
| var result, length = find("}", true) - S.pos; | |
| // Avoid 32 bit integer overflow (1 << 32 === 1) | |
| // We know first character isn't 0 and thus out of range anyway | |
| if (length > 6 || (result = hex_bytes(length, strict_hex)) > 0x10FFFF) { | |
| parse_error("Unicode reference out of bounds"); | |
| } | |
| next(true); | |
| return from_char_code(result); | |
| } | |
| return String.fromCharCode(hex_bytes(4, strict_hex)); | |
| case 10 : return ""; // newline | |
| case 13 : // \r | |
| if (peek() == "\n") { // DOS newline | |
| next(true, in_string); | |
| return ""; | |
| } | |
| } | |
| if (is_octal(ch)) { | |
| if (template_string && strict_hex) { | |
| const represents_null_character = ch === "0" && !is_octal(peek()); | |
| if (!represents_null_character) { | |
| parse_error("Octal escape sequences are not allowed in template strings"); | |
| } | |
| } | |
| return read_octal_escape_sequence(ch, strict_hex); | |
| } | |
| return ch; | |
| } | |
| function read_octal_escape_sequence(ch, strict_octal) { | |
| // Read | |
| var p = peek(); | |
| if (p >= "0" && p <= "7") { | |
| ch += next(true); | |
| if (ch[0] <= "3" && (p = peek()) >= "0" && p <= "7") | |
| ch += next(true); | |
| } | |
| // Parse | |
| if (ch === "0") return "\0"; | |
| if (ch.length > 0 && next_token.has_directive("use strict") && strict_octal) | |
| parse_error("Legacy octal escape sequences are not allowed in strict mode"); | |
| return String.fromCharCode(parseInt(ch, 8)); | |
| } | |
| function hex_bytes(n, strict_hex) { | |
| var num = 0; | |
| for (; n > 0; --n) { | |
| if (!strict_hex && isNaN(parseInt(peek(), 16))) { | |
| return parseInt(num, 16) || ""; | |
| } | |
| var digit = next(true); | |
| if (isNaN(parseInt(digit, 16))) | |
| parse_error("Invalid hex-character pattern in string"); | |
| num += digit; | |
| } | |
| return parseInt(num, 16); | |
| } | |
| var read_string = with_eof_error("Unterminated string constant", function() { | |
| const start_pos = S.pos; | |
| var quote = next(), ret = []; | |
| for (;;) { | |
| var ch = next(true, true); | |
| if (ch == "\\") ch = read_escaped_char(true, true); | |
| else if (ch == "\r" || ch == "\n") parse_error("Unterminated string constant"); | |
| else if (ch == quote) break; | |
| ret.push(ch); | |
| } | |
| var tok = token("string", ret.join("")); | |
| LATEST_RAW = S.text.slice(start_pos, S.pos); | |
| tok.quote = quote; | |
| return tok; | |
| }); | |
| var read_template_characters = with_eof_error("Unterminated template", function(begin) { | |
| if (begin) { | |
| S.template_braces.push(S.brace_counter); | |
| } | |
| var content = "", raw = "", ch, tok; | |
| next(true, true); | |
| while ((ch = next(true, true)) != "`") { | |
| if (ch == "\r") { | |
| if (peek() == "\n") ++S.pos; | |
| ch = "\n"; | |
| } else if (ch == "$" && peek() == "{") { | |
| next(true, true); | |
| S.brace_counter++; | |
| tok = token(begin ? "template_head" : "template_substitution", content); | |
| TEMPLATE_RAWS.set(tok, raw); | |
| tok.template_end = false; | |
| return tok; | |
| } | |
| raw += ch; | |
| if (ch == "\\") { | |
| var tmp = S.pos; | |
| var prev_is_tag = previous_token && (previous_token.type === "name" || previous_token.type === "punc" && (previous_token.value === ")" || previous_token.value === "]")); | |
| ch = read_escaped_char(true, !prev_is_tag, true); | |
| raw += S.text.substr(tmp, S.pos - tmp); | |
| } | |
| content += ch; | |
| } | |
| S.template_braces.pop(); | |
| tok = token(begin ? "template_head" : "template_substitution", content); | |
| TEMPLATE_RAWS.set(tok, raw); | |
| tok.template_end = true; | |
| return tok; | |
| }); | |
| function skip_line_comment(type) { | |
| var regex_allowed = S.regex_allowed; | |
| var i = find_eol(), ret; | |
| if (i == -1) { | |
| ret = S.text.substr(S.pos); | |
| S.pos = S.text.length; | |
| } else { | |
| ret = S.text.substring(S.pos, i); | |
| S.pos = i; | |
| } | |
| S.col = S.tokcol + (S.pos - S.tokpos); | |
| S.comments_before.push(token(type, ret, true)); | |
| S.regex_allowed = regex_allowed; | |
| return next_token; | |
| } | |
| 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"); | |
| // update stream position | |
| forward(get_full_char_length(text) /* text length doesn't count \r\n as 2 char while S.pos - i does */ + 2); | |
| S.comments_before.push(token("comment2", text, true)); | |
| S.newline_before = S.newline_before || text.includes("\n"); | |
| S.regex_allowed = regex_allowed; | |
| return next_token; | |
| }); | |
| var read_name = with_eof_error("Unterminated identifier name", function() { | |
| var name = [], ch, escaped = false; | |
| var read_escaped_identifier_char = function() { | |
| escaped = true; | |
| next(); | |
| if (peek() !== "u") { | |
| parse_error("Expecting UnicodeEscapeSequence -- uXXXX or u{XXXX}"); | |
| } | |
| return read_escaped_char(false, true); | |
| }; | |
| // Read first character (ID_Start) | |
| if ((ch = peek()) === "\\") { | |
| ch = read_escaped_identifier_char(); | |
| if (!is_identifier_start(ch)) { | |
| parse_error("First identifier char is an invalid identifier char"); | |
| } | |
| } else if (is_identifier_start(ch)) { | |
| next(); | |
| } else { | |
| return ""; | |
| } | |
| name.push(ch); | |
| // Read ID_Continue | |
| while ((ch = peek()) != null) { | |
| if ((ch = peek()) === "\\") { | |
| ch = read_escaped_identifier_char(); | |
| if (!is_identifier_char(ch)) { | |
| parse_error("Invalid escaped identifier char"); | |
| } | |
| } else { | |
| if (!is_identifier_char(ch)) { | |
| break; | |
| } | |
| next(); | |
| } | |
| name.push(ch); | |
| } | |
| const name_str = name.join(""); | |
| if (RESERVED_WORDS.has(name_str) && escaped) { | |
| parse_error("Escaped characters are not allowed in keywords"); | |
| } | |
| return name_str; | |
| }); | |
| var read_regexp = with_eof_error("Unterminated regular expression", function(source) { | |
| var prev_backslash = false, ch, in_class = false; | |
| while ((ch = next(true))) if (NEWLINE_CHARS.has(ch)) { | |
| parse_error("Unexpected line terminator"); | |
| } else if (prev_backslash) { | |
| if (/^[\u0000-\u007F]$/.test(ch)) { | |
| source += "\\" + ch; | |
| } else { | |
| // Remove the useless slash before the escape, but only for characters that won't be added to regexp syntax | |
| source += ch; | |
| } | |
| prev_backslash = false; | |
| } else if (ch == "[") { | |
| in_class = true; | |
| source += ch; | |
| } else if (ch == "]" && in_class) { | |
| in_class = false; | |
| source += ch; | |
| } else if (ch == "/" && !in_class) { | |
| break; | |
| } else if (ch == "\\") { | |
| prev_backslash = true; | |
| } else { | |
| source += ch; | |
| } | |
| const flags = read_name(); | |
| return token("regexp", "/" + source + "/" + flags); | |
| }); | |
| function read_operator(prefix) { | |
| function grow(op) { | |
| if (!peek()) return op; | |
| var bigger = op + peek(); | |
| if (OPERATORS.has(bigger)) { | |
| next(); | |
| return grow(bigger); | |
| } else { | |
| return op; | |
| } | |
| } | |
| return token("operator", grow(prefix || next())); | |
| } | |
| function handle_slash() { | |
| next(); | |
| switch (peek()) { | |
| case "/": | |
| next(); | |
| return skip_line_comment("comment1"); | |
| case "*": | |
| next(); | |
| return skip_multiline_comment(); | |
| } | |
| return S.regex_allowed ? read_regexp("") : read_operator("/"); | |
| } | |
| function handle_eq_sign() { | |
| next(); | |
| if (peek() === ">") { | |
| next(); | |
| return token("arrow", "=>"); | |
| } else { | |
| return read_operator("="); | |
| } | |
| } | |
| function handle_dot() { | |
| next(); | |
| if (is_digit(peek().charCodeAt(0))) { | |
| return read_num("."); | |
| } | |
| if (peek() === ".") { | |
| next(); // Consume second dot | |
| next(); // Consume third dot | |
| return token("expand", "..."); | |
| } | |
| return token("punc", "."); | |
| } | |
| function read_word() { | |
| var word = read_name(); | |
| if (prev_was_dot) return token("name", word); | |
| return KEYWORDS_ATOM.has(word) ? token("atom", word) | |
| : !KEYWORDS.has(word) ? token("name", word) | |
| : OPERATORS.has(word) ? token("operator", word) | |
| : token("keyword", word); | |
| } | |
| function read_private_word() { | |
| next(); | |
| return token("privatename", read_name()); | |
| } | |
| function with_eof_error(eof_error, cont) { | |
| return function(x) { | |
| try { | |
| return cont(x); | |
| } catch(ex) { | |
| if (ex === EX_EOF) parse_error(eof_error); | |
| else throw ex; | |
| } | |
| }; | |
| } | |
| function next_token(force_regexp) { | |
| if (force_regexp != null) | |
| return read_regexp(force_regexp); | |
| if (shebang && S.pos == 0 && looking_at("#!")) { | |
| start_token(); | |
| forward(2); | |
| skip_line_comment("comment5"); | |
| } | |
| for (;;) { | |
| skip_whitespace(); | |
| start_token(); | |
| if (html5_comments) { | |
| if (looking_at("<!--")) { | |
| forward(4); | |
| skip_line_comment("comment3"); | |
| continue; | |
| } | |
| if (looking_at("-->") && S.newline_before) { | |
| forward(3); | |
| skip_line_comment("comment4"); | |
| continue; | |
| } | |
| } | |
| var ch = peek(); | |
| if (!ch) return token("eof"); | |
| var code = ch.charCodeAt(0); | |
| switch (code) { | |
| case 34: case 39: return read_string(); | |
| case 46: return handle_dot(); | |
| case 47: { | |
| var tok = handle_slash(); | |
| if (tok === next_token) continue; | |
| return tok; | |
| } | |
| case 61: return handle_eq_sign(); | |
| case 63: { | |
| if (!is_option_chain_op()) break; // Handled below | |
| next(); // ? | |
| next(); // . | |
| return token("punc", "?."); | |
| } | |
| case 96: return read_template_characters(true); | |
| case 123: | |
| S.brace_counter++; | |
| break; | |
| case 125: | |
| S.brace_counter--; | |
| if (S.template_braces.length > 0 | |
| && S.template_braces[S.template_braces.length - 1] === S.brace_counter) | |
| return read_template_characters(false); | |
| break; | |
| } | |
| if (is_digit(code)) return read_num(); | |
| if (PUNC_CHARS.has(ch)) return token("punc", next()); | |
| if (OPERATOR_CHARS.has(ch)) return read_operator(); | |
| if (code == 92 || is_identifier_start(ch)) return read_word(); | |
| if (code == 35) return read_private_word(); | |
| break; | |
| } | |
| parse_error("Unexpected character '" + ch + "'"); | |
| } | |
| next_token.next = next; | |
| next_token.peek = peek; | |
| next_token.context = function(nc) { | |
| if (nc) S = nc; | |
| return S; | |
| }; | |
| next_token.add_directive = function(directive) { | |
| S.directive_stack[S.directive_stack.length - 1].push(directive); | |
| if (S.directives[directive] === undefined) { | |
| S.directives[directive] = 1; | |
| } else { | |
| S.directives[directive]++; | |
| } | |
| }; | |
| next_token.push_directives_stack = function() { | |
| S.directive_stack.push([]); | |
| }; | |
| next_token.pop_directives_stack = function() { | |
| var directives = S.directive_stack[S.directive_stack.length - 1]; | |
| for (var i = 0; i < directives.length; i++) { | |
| S.directives[directives[i]]--; | |
| } | |
| S.directive_stack.pop(); | |
| }; | |
| next_token.has_directive = function(directive) { | |
| return S.directives[directive] > 0; | |
| }; | |
| return next_token; | |
| } | |
| /* -----[ Parser (constants) ]----- */ | |
| var UNARY_PREFIX = makePredicate([ | |
| "typeof", | |
| "void", | |
| "delete", | |
| "--", | |
| "++", | |
| "!", | |
| "~", | |
| "-", | |
| "+" | |
| ]); | |
| var UNARY_POSTFIX = makePredicate([ "--", "++" ]); | |
| var ASSIGNMENT = makePredicate([ "=", "+=", "-=", "??=", "&&=", "||=", "/=", "*=", "**=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&=" ]); | |
| var LOGICAL_ASSIGNMENT = makePredicate([ "??=", "&&=", "||=" ]); | |
| var PRECEDENCE = (function(a, ret) { | |
| for (var i = 0; i < a.length; ++i) { | |
| for (const op of a[i]) { | |
| ret[op] = i + 1; | |
| } | |
| } | |
| return ret; | |
| })( | |
| [ | |
| ["||"], | |
| ["??"], | |
| ["&&"], | |
| ["|"], | |
| ["^"], | |
| ["&"], | |
| ["==", "===", "!=", "!=="], | |
| ["<", ">", "<=", ">=", "in", "instanceof"], | |
| [">>", "<<", ">>>"], | |
| ["+", "-"], | |
| ["*", "/", "%"], | |
| ["**"] | |
| ], | |
| {} | |
| ); | |
| var ATOMIC_START_TOKEN = makePredicate([ "atom", "num", "big_int", "string", "regexp", "name"]); | |
| /* -----[ Parser ]----- */ | |
| function parse($TEXT, options) { | |
| // maps start tokens to count of comments found outside of their parens | |
| // Example: /* I count */ ( /* I don't */ foo() ) | |
| // Useful because comments_before property of call with parens outside | |
| // contains both comments inside and outside these parens. Used to find the | |
| // right #__PURE__ comments for an expression | |
| const outer_comments_before_counts = new WeakMap(); | |
| options = defaults(options, { | |
| bare_returns : false, | |
| ecma : null, // Legacy | |
| expression : false, | |
| filename : null, | |
| html5_comments : true, | |
| module : false, | |
| shebang : true, | |
| strict : false, | |
| toplevel : null, | |
| }, true); | |
| var S = { | |
| input : (typeof $TEXT == "string" | |
| ? tokenizer($TEXT, options.filename, | |
| options.html5_comments, options.shebang) | |
| : $TEXT), | |
| token : null, | |
| prev : null, | |
| peeked : null, | |
| in_function : 0, | |
| in_async : -1, | |
| in_generator : -1, | |
| in_directives : true, | |
| in_loop : 0, | |
| labels : [] | |
| }; | |
| S.token = next(); | |
| function is(type, value) { | |
| return is_token(S.token, type, value); | |
| } | |
| function peek() { return S.peeked || (S.peeked = S.input()); } | |
| function next() { | |
| S.prev = S.token; | |
| if (!S.peeked) peek(); | |
| S.token = S.peeked; | |
| S.peeked = null; | |
| S.in_directives = S.in_directives && ( | |
| S.token.type == "string" || is("punc", ";") | |
| ); | |
| return S.token; | |
| } | |
| function prev() { | |
| return S.prev; | |
| } | |
| function croak(msg, line, col, pos) { | |
| var ctx = S.input.context(); | |
| js_error(msg, | |
| ctx.filename, | |
| line != null ? line : ctx.tokline, | |
| col != null ? col : ctx.tokcol, | |
| pos != null ? pos : ctx.tokpos); | |
| } | |
| function token_error(token, msg) { | |
| croak(msg, token.line, token.col); | |
| } | |
| function unexpected(token) { | |
| if (token == null) | |
| token = S.token; | |
| token_error(token, "Unexpected token: " + token.type + " (" + token.value + ")"); | |
| } | |
| function expect_token(type, val) { | |
| if (is(type, val)) { | |
| return next(); | |
| } | |
| token_error(S.token, "Unexpected token " + S.token.type + " «" + S.token.value + "»" + ", expected " + type + " «" + val + "»"); | |
| } | |
| function expect(punc) { return expect_token("punc", punc); } | |
| function has_newline_before(token) { | |
| return token.nlb || !token.comments_before.every((comment) => !comment.nlb); | |
| } | |
| function can_insert_semicolon() { | |
| return !options.strict | |
| && (is("eof") || is("punc", "}") || has_newline_before(S.token)); | |
| } | |
| function is_in_generator() { | |
| return S.in_generator === S.in_function; | |
| } | |
| function is_in_async() { | |
| return S.in_async === S.in_function; | |
| } | |
| function can_await() { | |
| return ( | |
| S.in_async === S.in_function | |
| || S.in_function === 0 && S.input.has_directive("use strict") | |
| ); | |
| } | |
| function semicolon(optional) { | |
| if (is("punc", ";")) next(); | |
| else if (!optional && !can_insert_semicolon()) unexpected(); | |
| } | |
| function parenthesised() { | |
| expect("("); | |
| var exp = expression(true); | |
| expect(")"); | |
| return exp; | |
| } | |
| function embed_tokens(parser) { | |
| return function _embed_tokens_wrapper(...args) { | |
| const start = S.token; | |
| const expr = parser(...args); | |
| expr.start = start; | |
| expr.end = prev(); | |
| return expr; | |
| }; | |
| } | |
| function handle_regexp() { | |
| if (is("operator", "/") || is("operator", "/=")) { | |
| S.peeked = null; | |
| S.token = S.input(S.token.value.substr(1)); // force regexp | |
| } | |
| } | |
| var statement = embed_tokens(function statement(is_export_default, is_for_body, is_if_body) { | |
| handle_regexp(); | |
| switch (S.token.type) { | |
| case "string": | |
| if (S.in_directives) { | |
| var token = peek(); | |
| if (!LATEST_RAW.includes("\\") | |
| && (is_token(token, "punc", ";") | |
| || is_token(token, "punc", "}") | |
| || has_newline_before(token) | |
| || is_token(token, "eof"))) { | |
| S.input.add_directive(S.token.value); | |
| } else { | |
| S.in_directives = false; | |
| } | |
| } | |
| var dir = S.in_directives, stat = simple_statement(); | |
| return dir && stat.body instanceof AST_String ? new AST_Directive(stat.body) : stat; | |
| case "template_head": | |
| case "num": | |
| case "big_int": | |
| case "regexp": | |
| case "operator": | |
| case "atom": | |
| return simple_statement(); | |
| case "name": | |
| case "privatename": | |
| if(is("privatename") && !S.in_class) | |
| croak("Private field must be used in an enclosing class"); | |
| if (S.token.value == "async" && is_token(peek(), "keyword", "function")) { | |
| next(); | |
| next(); | |
| if (is_for_body) { | |
| croak("functions are not allowed as the body of a loop"); | |
| } | |
| return function_(AST_Defun, false, true, is_export_default); | |
| } | |
| if (S.token.value == "import" && !is_token(peek(), "punc", "(") && !is_token(peek(), "punc", ".")) { | |
| next(); | |
| var node = import_statement(); | |
| semicolon(); | |
| return node; | |
| } | |
| return is_token(peek(), "punc", ":") | |
| ? labeled_statement() | |
| : simple_statement(); | |
| case "punc": | |
| switch (S.token.value) { | |
| case "{": | |
| return new AST_BlockStatement({ | |
| start : S.token, | |
| body : block_(), | |
| end : prev() | |
| }); | |
| case "[": | |
| case "(": | |
| return simple_statement(); | |
| case ";": | |
| S.in_directives = false; | |
| next(); | |
| return new AST_EmptyStatement(); | |
| default: | |
| unexpected(); | |
| } | |
| case "keyword": | |
| switch (S.token.value) { | |
| case "break": | |
| next(); | |
| return break_cont(AST_Break); | |
| case "continue": | |
| next(); | |
| return break_cont(AST_Continue); | |
| case "debugger": | |
| next(); | |
| semicolon(); | |
| return new AST_Debugger(); | |
| case "do": | |
| next(); | |
| var body = in_loop(statement); | |
| expect_token("keyword", "while"); | |
| var condition = parenthesised(); | |
| semicolon(true); | |
| return new AST_Do({ | |
| body : body, | |
| condition : condition | |
| }); | |
| case "while": | |
| next(); | |
| return new AST_While({ | |
| condition : parenthesised(), | |
| body : in_loop(function() { return statement(false, true); }) | |
| }); | |
| case "for": | |
| next(); | |
| return for_(); | |
| case "class": | |
| next(); | |
| if (is_for_body) { | |
| croak("classes are not allowed as the body of a loop"); | |
| } | |
| if (is_if_body) { | |
| croak("classes are not allowed as the body of an if"); | |
| } | |
| return class_(AST_DefClass, is_export_default); | |
| case "function": | |
| next(); | |
| if (is_for_body) { | |
| croak("functions are not allowed as the body of a loop"); | |
| } | |
| return function_(AST_Defun, false, false, is_export_default); | |
| case "if": | |
| next(); | |
| return if_(); | |
| case "return": | |
| if (S.in_function == 0 && !options.bare_returns) | |
| croak("'return' outside of function"); | |
| next(); | |
| var value = null; | |
| if (is("punc", ";")) { | |
| next(); | |
| } else if (!can_insert_semicolon()) { | |
| value = expression(true); | |
| semicolon(); | |
| } | |
| return new AST_Return({ | |
| value: value | |
| }); | |
| case "switch": | |
| next(); | |
| return new AST_Switch({ | |
| expression : parenthesised(), | |
| body : in_loop(switch_body_) | |
| }); | |
| case "throw": | |
| next(); | |
| if (has_newline_before(S.token)) | |
| croak("Illegal newline after 'throw'"); | |
| var value = expression(true); | |
| semicolon(); | |
| return new AST_Throw({ | |
| value: value | |
| }); | |
| case "try": | |
| next(); | |
| return try_(); | |
| case "var": | |
| next(); | |
| var node = var_(); | |
| semicolon(); | |
| return node; | |
| case "let": | |
| next(); | |
| var node = let_(); | |
| semicolon(); | |
| return node; | |
| case "const": | |
| next(); | |
| var node = const_(); | |
| semicolon(); | |
| return node; | |
| case "with": | |
| if (S.input.has_directive("use strict")) { | |
| croak("Strict mode may not include a with statement"); | |
| } | |
| next(); | |
| return new AST_With({ | |
| expression : parenthesised(), | |
| body : statement() | |
| }); | |
| case "export": | |
| if (!is_token(peek(), "punc", "(")) { | |
| next(); | |
| var node = export_statement(); | |
| if (is("punc", ";")) semicolon(); | |
| return node; | |
| } | |
| } | |
| } | |
| unexpected(); | |
| }); | |
| function labeled_statement() { | |
| var label = as_symbol(AST_Label); | |
| if (label.name === "await" && is_in_async()) { | |
| token_error(S.prev, "await cannot be used as label inside async function"); | |
| } | |
| if (S.labels.some((l) => l.name === label.name)) { | |
| // ECMA-262, 12.12: An ECMAScript program is considered | |
| // syntactically incorrect if it contains a | |
| // LabelledStatement that is enclosed by a | |
| // LabelledStatement with the same Identifier as label. | |
| croak("Label " + label.name + " defined twice"); | |
| } | |
| expect(":"); | |
| S.labels.push(label); | |
| var stat = statement(); | |
| S.labels.pop(); | |
| if (!(stat instanceof AST_IterationStatement)) { | |
| // check for `continue` that refers to this label. | |
| // those should be reported as syntax errors. | |
| // https://github.com/mishoo/UglifyJS2/issues/287 | |
| label.references.forEach(function(ref) { | |
| if (ref instanceof AST_Continue) { | |
| ref = ref.label.start; | |
| croak("Continue label `" + label.name + "` refers to non-IterationStatement.", | |
| ref.line, ref.col, ref.pos); | |
| } | |
| }); | |
| } | |
| return new AST_LabeledStatement({ body: stat, label: label }); | |
| } | |
| function simple_statement(tmp) { | |
| return new AST_SimpleStatement({ body: (tmp = expression(true), semicolon(), tmp) }); | |
| } | |
| function break_cont(type) { | |
| var label = null, ldef; | |
| if (!can_insert_semicolon()) { | |
| label = as_symbol(AST_LabelRef, true); | |
| } | |
| if (label != null) { | |
| ldef = S.labels.find((l) => l.name === 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(); | |
| var stat = new type({ label: label }); | |
| if (ldef) ldef.references.push(stat); | |
| return stat; | |
| } | |
| function for_() { | |
| var for_await_error = "`for await` invalid in this context"; | |
| var await_tok = S.token; | |
| if (await_tok.type == "name" && await_tok.value == "await") { | |
| if (!can_await()) { | |
| token_error(await_tok, for_await_error); | |
| } | |
| next(); | |
| } else { | |
| await_tok = false; | |
| } | |
| expect("("); | |
| var init = null; | |
| if (!is("punc", ";")) { | |
| init = | |
| is("keyword", "var") ? (next(), var_(true)) : | |
| is("keyword", "let") ? (next(), let_(true)) : | |
| is("keyword", "const") ? (next(), const_(true)) : | |
| expression(true, true); | |
| var is_in = is("operator", "in"); | |
| var is_of = is("name", "of"); | |
| if (await_tok && !is_of) { | |
| token_error(await_tok, for_await_error); | |
| } | |
| if (is_in || is_of) { | |
| if (init instanceof AST_Definitions) { | |
| if (init.definitions.length > 1) | |
| token_error(init.start, "Only one variable declaration allowed in for..in loop"); | |
| } else if (!(is_assignable(init) || (init = to_destructuring(init)) instanceof AST_Destructuring)) { | |
| token_error(init.start, "Invalid left-hand side in for..in loop"); | |
| } | |
| next(); | |
| if (is_in) { | |
| return for_in(init); | |
| } else { | |
| return for_of(init, !!await_tok); | |
| } | |
| } | |
| } else if (await_tok) { | |
| token_error(await_tok, for_await_error); | |
| } | |
| return regular_for(init); | |
| } | |
| function regular_for(init) { | |
| expect(";"); | |
| var test = is("punc", ";") ? null : expression(true); | |
| expect(";"); | |
| var step = is("punc", ")") ? null : expression(true); | |
| expect(")"); | |
| return new AST_For({ | |
| init : init, | |
| condition : test, | |
| step : step, | |
| body : in_loop(function() { return statement(false, true); }) | |
| }); | |
| } | |
| function for_of(init, is_await) { | |
| var lhs = init instanceof AST_Definitions ? init.definitions[0].name : null; | |
| var obj = expression(true); | |
| expect(")"); | |
| return new AST_ForOf({ | |
| await : is_await, | |
| init : init, | |
| name : lhs, | |
| object : obj, | |
| body : in_loop(function() { return statement(false, true); }) | |
| }); | |
| } | |
| function for_in(init) { | |
| var obj = expression(true); | |
| expect(")"); | |
| return new AST_ForIn({ | |
| init : init, | |
| object : obj, | |
| body : in_loop(function() { return statement(false, true); }) | |
| }); | |
| } | |
| var arrow_function = function(start, argnames, is_async) { | |
| if (has_newline_before(S.token)) { | |
| croak("Unexpected newline before arrow (=>)"); | |
| } | |
| expect_token("arrow", "=>"); | |
| var body = _function_body(is("punc", "{"), false, is_async); | |
| var end = | |
| body instanceof Array && body.length ? body[body.length - 1].end : | |
| body instanceof Array ? start : | |
| body.end; | |
| return new AST_Arrow({ | |
| start : start, | |
| end : end, | |
| async : is_async, | |
| argnames : argnames, | |
| body : body | |
| }); | |
| }; | |
| var function_ = function(ctor, is_generator_property, is_async, is_export_default) { | |
| var in_statement = ctor === AST_Defun; | |
| var is_generator = is("operator", "*"); | |
| if (is_generator) { | |
| next(); | |
| } | |
| var name = is("name") ? as_symbol(in_statement ? AST_SymbolDefun : AST_SymbolLambda) : null; | |
| if (in_statement && !name) { | |
| if (is_export_default) { | |
| ctor = AST_Function; | |
| } else { | |
| unexpected(); | |
| } | |
| } | |
| if (name && ctor !== AST_Accessor && !(name instanceof AST_SymbolDeclaration)) | |
| unexpected(prev()); | |
| var args = []; | |
| var body = _function_body(true, is_generator || is_generator_property, is_async, name, args); | |
| return new ctor({ | |
| start : args.start, | |
| end : body.end, | |
| is_generator: is_generator, | |
| async : is_async, | |
| name : name, | |
| argnames: args, | |
| body : body | |
| }); | |
| }; | |
| class UsedParametersTracker { | |
| constructor(is_parameter, strict, duplicates_ok = false) { | |
| this.is_parameter = is_parameter; | |
| this.duplicates_ok = duplicates_ok; | |
| this.parameters = new Set(); | |
| this.duplicate = null; | |
| this.default_assignment = false; | |
| this.spread = false; | |
| this.strict_mode = !!strict; | |
| } | |
| add_parameter(token) { | |
| if (this.parameters.has(token.value)) { | |
| if (this.duplicate === null) { | |
| this.duplicate = token; | |
| } | |
| this.check_strict(); | |
| } else { | |
| this.parameters.add(token.value); | |
| if (this.is_parameter) { | |
| switch (token.value) { | |
| case "arguments": | |
| case "eval": | |
| case "yield": | |
| if (this.strict_mode) { | |
| token_error(token, "Unexpected " + token.value + " identifier as parameter inside strict mode"); | |
| } | |
| break; | |
| default: | |
| if (RESERVED_WORDS.has(token.value)) { | |
| unexpected(); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| mark_default_assignment(token) { | |
| if (this.default_assignment === false) { | |
| this.default_assignment = token; | |
| } | |
| } | |
| mark_spread(token) { | |
| if (this.spread === false) { | |
| this.spread = token; | |
| } | |
| } | |
| mark_strict_mode() { | |
| this.strict_mode = true; | |
| } | |
| is_strict() { | |
| return this.default_assignment !== false || this.spread !== false || this.strict_mode; | |
| } | |
| check_strict() { | |
| if (this.is_strict() && this.duplicate !== null && !this.duplicates_ok) { | |
| token_error(this.duplicate, "Parameter " + this.duplicate.value + " was used already"); | |
| } | |
| } | |
| } | |
| function parameters(params) { | |
| var used_parameters = new UsedParametersTracker(true, S.input.has_directive("use strict")); | |
| expect("("); | |
| while (!is("punc", ")")) { | |
| var param = parameter(used_parameters); | |
| params.push(param); | |
| if (!is("punc", ")")) { | |
| expect(","); | |
| } | |
| if (param instanceof AST_Expansion) { | |
| break; | |
| } | |
| } | |
| next(); | |
| } | |
| function parameter(used_parameters, symbol_type) { | |
| var param; | |
| var expand = false; | |
| if (used_parameters === undefined) { | |
| used_parameters = new UsedParametersTracker(true, S.input.has_directive("use strict")); | |
| } | |
| if (is("expand", "...")) { | |
| expand = S.token; | |
| used_parameters.mark_spread(S.token); | |
| next(); | |
| } | |
| param = binding_element(used_parameters, symbol_type); | |
| if (is("operator", "=") && expand === false) { | |
| used_parameters.mark_default_assignment(S.token); | |
| next(); | |
| param = new AST_DefaultAssign({ | |
| start: param.start, | |
| left: param, | |
| operator: "=", | |
| right: expression(false), | |
| end: S.token | |
| }); | |
| } | |
| if (expand !== false) { | |
| if (!is("punc", ")")) { | |
| unexpected(); | |
| } | |
| param = new AST_Expansion({ | |
| start: expand, | |
| expression: param, | |
| end: expand | |
| }); | |
| } | |
| used_parameters.check_strict(); | |
| return param; | |
| } | |
| function binding_element(used_parameters, symbol_type) { | |
| var elements = []; | |
| var first = true; | |
| var is_expand = false; | |
| var expand_token; | |
| var first_token = S.token; | |
| if (used_parameters === undefined) { | |
| const strict = S.input.has_directive("use strict"); | |
| const duplicates_ok = symbol_type === AST_SymbolVar; | |
| used_parameters = new UsedParametersTracker(false, strict, duplicates_ok); | |
| } | |
| symbol_type = symbol_type === undefined ? AST_SymbolFunarg : symbol_type; | |
| if (is("punc", "[")) { | |
| next(); | |
| while (!is("punc", "]")) { | |
| if (first) { | |
| first = false; | |
| } else { | |
| expect(","); | |
| } | |
| if (is("expand", "...")) { | |
| is_expand = true; | |
| expand_token = S.token; | |
| used_parameters.mark_spread(S.token); | |
| next(); | |
| } | |
| if (is("punc")) { | |
| switch (S.token.value) { | |
| case ",": | |
| elements.push(new AST_Hole({ | |
| start: S.token, | |
| end: S.token | |
| })); | |
| continue; | |
| case "]": // Trailing comma after last element | |
| break; | |
| case "[": | |
| case "{": | |
| elements.push(binding_element(used_parameters, symbol_type)); | |
| break; | |
| default: | |
| unexpected(); | |
| } | |
| } else if (is("name")) { | |
| used_parameters.add_parameter(S.token); | |
| elements.push(as_symbol(symbol_type)); | |
| } else { | |
| croak("Invalid function parameter"); | |
| } | |
| if (is("operator", "=") && is_expand === false) { | |
| used_parameters.mark_default_assignment(S.token); | |
| next(); | |
| elements[elements.length - 1] = new AST_DefaultAssign({ | |
| start: elements[elements.length - 1].start, | |
| left: elements[elements.length - 1], | |
| operator: "=", | |
| right: expression(false), | |
| end: S.token | |
| }); | |
| } | |
| if (is_expand) { | |
| if (!is("punc", "]")) { | |
| croak("Rest element must be last element"); | |
| } | |
| elements[elements.length - 1] = new AST_Expansion({ | |
| start: expand_token, | |
| expression: elements[elements.length - 1], | |
| end: expand_token | |
| }); | |
| } | |
| } | |
| expect("]"); | |
| used_parameters.check_strict(); | |
| return new AST_Destructuring({ | |
| start: first_token, | |
| names: elements, | |
| is_array: true, | |
| end: prev() | |
| }); | |
| } else if (is("punc", "{")) { | |
| next(); | |
| while (!is("punc", "}")) { | |
| if (first) { | |
| first = false; | |
| } else { | |
| expect(","); | |
| } | |
| if (is("expand", "...")) { | |
| is_expand = true; | |
| expand_token = S.token; | |
| used_parameters.mark_spread(S.token); | |
| next(); | |
| } | |
| if (is("name") && (is_token(peek(), "punc") || is_token(peek(), "operator")) && [",", "}", "="].includes(peek().value)) { | |
| used_parameters.add_parameter(S.token); | |
| var start = prev(); | |
| var value = as_symbol(symbol_type); | |
| if (is_expand) { | |
| elements.push(new AST_Expansion({ | |
| start: expand_token, | |
| expression: value, | |
| end: value.end, | |
| })); | |
| } else { | |
| elements.push(new AST_ObjectKeyVal({ | |
| start: start, | |
| key: value.name, | |
| value: value, | |
| end: value.end, | |
| })); | |
| } | |
| } else if (is("punc", "}")) { | |
| continue; // Allow trailing hole | |
| } else { | |
| var property_token = S.token; | |
| var property = as_property_name(); | |
| if (property === null) { | |
| unexpected(prev()); | |
| } else if (prev().type === "name" && !is("punc", ":")) { | |
| elements.push(new AST_ObjectKeyVal({ | |
| start: prev(), | |
| key: property, | |
| value: new symbol_type({ | |
| start: prev(), | |
| name: property, | |
| end: prev() | |
| }), | |
| end: prev() | |
| })); | |
| } else { | |
| expect(":"); | |
| elements.push(new AST_ObjectKeyVal({ | |
| start: property_token, | |
| quote: property_token.quote, | |
| key: property, | |
| value: binding_element(used_parameters, symbol_type), | |
| end: prev() | |
| })); | |
| } | |
| } | |
| if (is_expand) { | |
| if (!is("punc", "}")) { | |
| croak("Rest element must be last element"); | |
| } | |
| } else if (is("operator", "=")) { | |
| used_parameters.mark_default_assignment(S.token); | |
| next(); | |
| elements[elements.length - 1].value = new AST_DefaultAssign({ | |
| start: elements[elements.length - 1].value.start, | |
| left: elements[elements.length - 1].value, | |
| operator: "=", | |
| right: expression(false), | |
| end: S.token | |
| }); | |
| } | |
| } | |
| expect("}"); | |
| used_parameters.check_strict(); | |
| return new AST_Destructuring({ | |
| start: first_token, | |
| names: elements, | |
| is_array: false, | |
| end: prev() | |
| }); | |
| } else if (is("name")) { | |
| used_parameters.add_parameter(S.token); | |
| return as_symbol(symbol_type); | |
| } else { | |
| croak("Invalid function parameter"); | |
| } | |
| } | |
| function params_or_seq_(allow_arrows, maybe_sequence) { | |
| var spread_token; | |
| var invalid_sequence; | |
| var trailing_comma; | |
| var a = []; | |
| expect("("); | |
| while (!is("punc", ")")) { | |
| if (spread_token) unexpected(spread_token); | |
| if (is("expand", "...")) { | |
| spread_token = S.token; | |
| if (maybe_sequence) invalid_sequence = S.token; | |
| next(); | |
| a.push(new AST_Expansion({ | |
| start: prev(), | |
| expression: expression(), | |
| end: S.token, | |
| })); | |
| } else { | |
| a.push(expression()); | |
| } | |
| if (!is("punc", ")")) { | |
| expect(","); | |
| if (is("punc", ")")) { | |
| trailing_comma = prev(); | |
| if (maybe_sequence) invalid_sequence = trailing_comma; | |
| } | |
| } | |
| } | |
| expect(")"); | |
| if (allow_arrows && is("arrow", "=>")) { | |
| if (spread_token && trailing_comma) unexpected(trailing_comma); | |
| } else if (invalid_sequence) { | |
| unexpected(invalid_sequence); | |
| } | |
| return a; | |
| } | |
| function _function_body(block, generator, is_async, name, args) { | |
| var loop = S.in_loop; | |
| var labels = S.labels; | |
| var current_generator = S.in_generator; | |
| var current_async = S.in_async; | |
| ++S.in_function; | |
| if (generator) | |
| S.in_generator = S.in_function; | |
| if (is_async) | |
| S.in_async = S.in_function; | |
| if (args) parameters(args); | |
| if (block) | |
| S.in_directives = true; | |
| S.in_loop = 0; | |
| S.labels = []; | |
| if (block) { | |
| S.input.push_directives_stack(); | |
| var a = block_(); | |
| if (name) _verify_symbol(name); | |
| if (args) args.forEach(_verify_symbol); | |
| S.input.pop_directives_stack(); | |
| } else { | |
| var a = [new AST_Return({ | |
| start: S.token, | |
| value: expression(false), | |
| end: S.token | |
| })]; | |
| } | |
| --S.in_function; | |
| S.in_loop = loop; | |
| S.labels = labels; | |
| S.in_generator = current_generator; | |
| S.in_async = current_async; | |
| return a; | |
| } | |
| function _await_expression() { | |
| // Previous token must be "await" and not be interpreted as an identifier | |
| if (!can_await()) { | |
| croak("Unexpected await expression outside async function", | |
| S.prev.line, S.prev.col, S.prev.pos); | |
| } | |
| // the await expression is parsed as a unary expression in Babel | |
| return new AST_Await({ | |
| start: prev(), | |
| end: S.token, | |
| expression : maybe_unary(true), | |
| }); | |
| } | |
| function _yield_expression() { | |
| // Previous token must be keyword yield and not be interpret as an identifier | |
| if (!is_in_generator()) { | |
| croak("Unexpected yield expression outside generator function", | |
| S.prev.line, S.prev.col, S.prev.pos); | |
| } | |
| var start = S.token; | |
| var star = false; | |
| var has_expression = true; | |
| // Attempt to get expression or star (and then the mandatory expression) | |
| // behind yield on the same line. | |
| // | |
| // If nothing follows on the same line of the yieldExpression, | |
| // it should default to the value `undefined` for yield to return. | |
| // In that case, the `undefined` stored as `null` in ast. | |
| // | |
| // Note 1: It isn't allowed for yield* to close without an expression | |
| // Note 2: If there is a nlb between yield and star, it is interpret as | |
| // yield <explicit undefined> <inserted automatic semicolon> * | |
| if (can_insert_semicolon() || | |
| (is("punc") && PUNC_AFTER_EXPRESSION.has(S.token.value))) { | |
| has_expression = false; | |
| } else if (is("operator", "*")) { | |
| star = true; | |
| next(); | |
| } | |
| return new AST_Yield({ | |
| start : start, | |
| is_star : star, | |
| expression : has_expression ? expression() : null, | |
| end : prev() | |
| }); | |
| } | |
| function if_() { | |
| var cond = parenthesised(), body = statement(false, false, true), belse = null; | |
| if (is("keyword", "else")) { | |
| next(); | |
| belse = statement(false, false, true); | |
| } | |
| return new AST_If({ | |
| condition : cond, | |
| body : body, | |
| alternative : belse | |
| }); | |
| } | |
| function block_() { | |
| expect("{"); | |
| var a = []; | |
| while (!is("punc", "}")) { | |
| if (is("eof")) unexpected(); | |
| a.push(statement()); | |
| } | |
| next(); | |
| return a; | |
| } | |
| function switch_body_() { | |
| expect("{"); | |
| var a = [], cur = null, branch = null, tmp; | |
| while (!is("punc", "}")) { | |
| if (is("eof")) unexpected(); | |
| if (is("keyword", "case")) { | |
| if (branch) branch.end = prev(); | |
| cur = []; | |
| branch = new AST_Case({ | |
| start : (tmp = S.token, next(), tmp), | |
| expression : expression(true), | |
| body : cur | |
| }); | |
| a.push(branch); | |
| expect(":"); | |
| } else if (is("keyword", "default")) { | |
| if (branch) branch.end = prev(); | |
| cur = []; | |
| branch = new AST_Default({ | |
| start : (tmp = S.token, next(), expect(":"), tmp), | |
| body : cur | |
| }); | |
| a.push(branch); | |
| } else { | |
| if (!cur) unexpected(); | |
| cur.push(statement()); | |
| } | |
| } | |
| if (branch) branch.end = prev(); | |
| next(); | |
| return a; | |
| } | |
| function try_() { | |
| var body, bcatch = null, bfinally = null; | |
| body = new AST_TryBlock({ | |
| start : S.token, | |
| body : block_(), | |
| end : prev(), | |
| }); | |
| if (is("keyword", "catch")) { | |
| var start = S.token; | |
| next(); | |
| if (is("punc", "{")) { | |
| var name = null; | |
| } else { | |
| expect("("); | |
| var name = parameter(undefined, AST_SymbolCatch); | |
| expect(")"); | |
| } | |
| bcatch = new AST_Catch({ | |
| start : start, | |
| argname : name, | |
| body : block_(), | |
| end : prev() | |
| }); | |
| } | |
| if (is("keyword", "finally")) { | |
| var start = S.token; | |
| next(); | |
| bfinally = new AST_Finally({ | |
| start : start, | |
| body : block_(), | |
| end : prev() | |
| }); | |
| } | |
| if (!bcatch && !bfinally) | |
| croak("Missing catch/finally blocks"); | |
| return new AST_Try({ | |
| body : body, | |
| bcatch : bcatch, | |
| bfinally : bfinally | |
| }); | |
| } | |
| /** | |
| * var | |
| * vardef1 = 2, | |
| * vardef2 = 3; | |
| */ | |
| function vardefs(no_in, kind) { | |
| var var_defs = []; | |
| var def; | |
| for (;;) { | |
| var sym_type = | |
| kind === "var" ? AST_SymbolVar : | |
| kind === "const" ? AST_SymbolConst : | |
| kind === "let" ? AST_SymbolLet : null; | |
| // var { a } = b | |
| if (is("punc", "{") || is("punc", "[")) { | |
| def = new AST_VarDef({ | |
| start: S.token, | |
| name: binding_element(undefined, sym_type), | |
| value: is("operator", "=") ? (expect_token("operator", "="), expression(false, no_in)) : null, | |
| end: prev() | |
| }); | |
| } else { | |
| def = new AST_VarDef({ | |
| start : S.token, | |
| name : as_symbol(sym_type), | |
| value : is("operator", "=") | |
| ? (next(), expression(false, no_in)) | |
| : !no_in && kind === "const" | |
| ? croak("Missing initializer in const declaration") : null, | |
| end : prev() | |
| }); | |
| if (def.name.name == "import") croak("Unexpected token: import"); | |
| } | |
| var_defs.push(def); | |
| if (!is("punc", ",")) | |
| break; | |
| next(); | |
| } | |
| return var_defs; | |
| } | |
| var var_ = function(no_in) { | |
| return new AST_Var({ | |
| start : prev(), | |
| definitions : vardefs(no_in, "var"), | |
| end : prev() | |
| }); | |
| }; | |
| var let_ = function(no_in) { | |
| return new AST_Let({ | |
| start : prev(), | |
| definitions : vardefs(no_in, "let"), | |
| end : prev() | |
| }); | |
| }; | |
| var const_ = function(no_in) { | |
| return new AST_Const({ | |
| start : prev(), | |
| definitions : vardefs(no_in, "const"), | |
| end : prev() | |
| }); | |
| }; | |
| var new_ = function(allow_calls) { | |
| var start = S.token; | |
| expect_token("operator", "new"); | |
| if (is("punc", ".")) { | |
| next(); | |
| expect_token("name", "target"); | |
| return subscripts(new AST_NewTarget({ | |
| start : start, | |
| end : prev() | |
| }), allow_calls); | |
| } | |
| var newexp = expr_atom(false), args; | |
| if (is("punc", "(")) { | |
| next(); | |
| args = expr_list(")", true); | |
| } else { | |
| args = []; | |
| } | |
| var call = new AST_New({ | |
| start : start, | |
| expression : newexp, | |
| args : args, | |
| end : prev() | |
| }); | |
| annotate(call); | |
| return subscripts(call, allow_calls); | |
| }; | |
| 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, | |
| raw: LATEST_RAW | |
| }); | |
| break; | |
| case "big_int": | |
| ret = new AST_BigInt({ start: tok, end: tok, value: tok.value }); | |
| break; | |
| case "string": | |
| ret = new AST_String({ | |
| start : tok, | |
| end : tok, | |
| value : tok.value, | |
| quote : tok.quote | |
| }); | |
| annotate(ret); | |
| break; | |
| case "regexp": | |
| const [_, source, flags] = tok.value.match(/^\/(.*)\/(\w*)$/); | |
| ret = new AST_RegExp({ start: tok, end: tok, value: { source, flags } }); | |
| break; | |
| case "atom": | |
| switch (tok.value) { | |
| case "false": | |
| ret = new AST_False({ start: tok, end: tok }); | |
| break; | |
| case "true": | |
| ret = new AST_True({ start: tok, end: tok }); | |
| break; | |
| case "null": | |
| ret = new AST_Null({ start: tok, end: tok }); | |
| break; | |
| } | |
| break; | |
| } | |
| next(); | |
| return ret; | |
| } | |
| function to_fun_args(ex, default_seen_above) { | |
| var insert_default = function(ex, default_value) { | |
| if (default_value) { | |
| return new AST_DefaultAssign({ | |
| start: ex.start, | |
| left: ex, | |
| operator: "=", | |
| right: default_value, | |
| end: default_value.end | |
| }); | |
| } | |
| return ex; | |
| }; | |
| if (ex instanceof AST_Object) { | |
| return insert_default(new AST_Destructuring({ | |
| start: ex.start, | |
| end: ex.end, | |
| is_array: false, | |
| names: ex.properties.map(prop => to_fun_args(prop)) | |
| }), default_seen_above); | |
| } else if (ex instanceof AST_ObjectKeyVal) { | |
| ex.value = to_fun_args(ex.value); | |
| return insert_default(ex, default_seen_above); | |
| } else if (ex instanceof AST_Hole) { | |
| return ex; | |
| } else if (ex instanceof AST_Destructuring) { | |
| ex.names = ex.names.map(name => to_fun_args(name)); | |
| return insert_default(ex, default_seen_above); | |
| } else if (ex instanceof AST_SymbolRef) { | |
| return insert_default(new AST_SymbolFunarg({ | |
| name: ex.name, | |
| start: ex.start, | |
| end: ex.end | |
| }), default_seen_above); | |
| } else if (ex instanceof AST_Expansion) { | |
| ex.expression = to_fun_args(ex.expression); | |
| return insert_default(ex, default_seen_above); | |
| } else if (ex instanceof AST_Array) { | |
| return insert_default(new AST_Destructuring({ | |
| start: ex.start, | |
| end: ex.end, | |
| is_array: true, | |
| names: ex.elements.map(elm => to_fun_args(elm)) | |
| }), default_seen_above); | |
| } else if (ex instanceof AST_Assign) { | |
| return insert_default(to_fun_args(ex.left, ex.right), default_seen_above); | |
| } else if (ex instanceof AST_DefaultAssign) { | |
| ex.left = to_fun_args(ex.left); | |
| return ex; | |
| } else { | |
| croak("Invalid function parameter", ex.start.line, ex.start.col); | |
| } | |
| } | |
| var expr_atom = function(allow_calls, allow_arrows) { | |
| if (is("operator", "new")) { | |
| return new_(allow_calls); | |
| } | |
| if (is("name", "import") && is_token(peek(), "punc", ".")) { | |
| return import_meta(allow_calls); | |
| } | |
| var start = S.token; | |
| var peeked; | |
| var async = is("name", "async") | |
| && (peeked = peek()).value != "[" | |
| && peeked.type != "arrow" | |
| && as_atom_node(); | |
| if (is("punc")) { | |
| switch (S.token.value) { | |
| case "(": | |
| if (async && !allow_calls) break; | |
| var exprs = params_or_seq_(allow_arrows, !async); | |
| if (allow_arrows && is("arrow", "=>")) { | |
| return arrow_function(start, exprs.map(e => to_fun_args(e)), !!async); | |
| } | |
| var ex = async ? new AST_Call({ | |
| expression: async, | |
| args: exprs | |
| }) : to_expr_or_sequence(start, exprs); | |
| if (ex.start) { | |
| const outer_comments_before = start.comments_before.length; | |
| outer_comments_before_counts.set(start, outer_comments_before); | |
| ex.start.comments_before.unshift(...start.comments_before); | |
| start.comments_before = ex.start.comments_before; | |
| if (outer_comments_before == 0 && start.comments_before.length > 0) { | |
| var comment = start.comments_before[0]; | |
| if (!comment.nlb) { | |
| comment.nlb = start.nlb; | |
| start.nlb = false; | |
| } | |
| } | |
| start.comments_after = ex.start.comments_after; | |
| } | |
| ex.start = start; | |
| var end = prev(); | |
| if (ex.end) { | |
| end.comments_before = ex.end.comments_before; | |
| ex.end.comments_after.push(...end.comments_after); | |
| end.comments_after = ex.end.comments_after; | |
| } | |
| ex.end = end; | |
| if (ex instanceof AST_Call) annotate(ex); | |
| return subscripts(ex, allow_calls); | |
| case "[": | |
| return subscripts(array_(), allow_calls); | |
| case "{": | |
| return subscripts(object_or_destructuring_(), allow_calls); | |
| } | |
| if (!async) unexpected(); | |
| } | |
| if (allow_arrows && is("name") && is_token(peek(), "arrow")) { | |
| var param = new AST_SymbolFunarg({ | |
| name: S.token.value, | |
| start: start, | |
| end: start, | |
| }); | |
| next(); | |
| return arrow_function(start, [param], !!async); | |
| } | |
| if (is("keyword", "function")) { | |
| next(); | |
| var func = function_(AST_Function, false, !!async); | |
| func.start = start; | |
| func.end = prev(); | |
| return subscripts(func, allow_calls); | |
| } | |
| if (async) return subscripts(async, allow_calls); | |
| if (is("keyword", "class")) { | |
| next(); | |
| var cls = class_(AST_ClassExpression); | |
| cls.start = start; | |
| cls.end = prev(); | |
| return subscripts(cls, allow_calls); | |
| } | |
| if (is("template_head")) { | |
| return subscripts(template_string(), allow_calls); | |
| } | |
| if (ATOMIC_START_TOKEN.has(S.token.type)) { | |
| return subscripts(as_atom_node(), allow_calls); | |
| } | |
| unexpected(); | |
| }; | |
| function template_string() { | |
| var segments = [], start = S.token; | |
| segments.push(new AST_TemplateSegment({ | |
| start: S.token, | |
| raw: TEMPLATE_RAWS.get(S.token), | |
| value: S.token.value, | |
| end: S.token | |
| })); | |
| while (!S.token.template_end) { | |
| next(); | |
| handle_regexp(); | |
| segments.push(expression(true)); | |
| segments.push(new AST_TemplateSegment({ | |
| start: S.token, | |
| raw: TEMPLATE_RAWS.get(S.token), | |
| value: S.token.value, | |
| end: S.token | |
| })); | |
| } | |
| next(); | |
| return new AST_TemplateString({ | |
| start: start, | |
| segments: segments, | |
| end: S.token | |
| }); | |
| } | |
| 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 (is("punc", ",") && allow_empty) { | |
| a.push(new AST_Hole({ start: S.token, end: S.token })); | |
| } else if (is("expand", "...")) { | |
| next(); | |
| a.push(new AST_Expansion({start: prev(), expression: expression(),end: S.token})); | |
| } else { | |
| a.push(expression(false)); | |
| } | |
| } | |
| next(); | |
| return a; | |
| } | |
| var array_ = embed_tokens(function() { | |
| expect("["); | |
| return new AST_Array({ | |
| elements: expr_list("]", !options.strict, true) | |
| }); | |
| }); | |
| var create_accessor = embed_tokens((is_generator, is_async) => { | |
| return function_(AST_Accessor, is_generator, is_async); | |
| }); | |
| var object_or_destructuring_ = embed_tokens(function object_or_destructuring_() { | |
| var start = S.token, first = true, a = []; | |
| expect("{"); | |
| while (!is("punc", "}")) { | |
| if (first) first = false; else expect(","); | |
| if (!options.strict && is("punc", "}")) | |
| // allow trailing comma | |
| break; | |
| start = S.token; | |
| if (start.type == "expand") { | |
| next(); | |
| a.push(new AST_Expansion({ | |
| start: start, | |
| expression: expression(false), | |
| end: prev(), | |
| })); | |
| continue; | |
| } | |
| if(is("privatename")) { | |
| croak("private fields are not allowed in an object"); | |
| } | |
| var name = as_property_name(); | |
| var value; | |
| // Check property and fetch value | |
| if (!is("punc", ":")) { | |
| var concise = concise_method_or_getset(name, start); | |
| if (concise) { | |
| a.push(concise); | |
| continue; | |
| } | |
| value = new AST_SymbolRef({ | |
| start: prev(), | |
| name: name, | |
| end: prev() | |
| }); | |
| } else if (name === null) { | |
| unexpected(prev()); | |
| } else { | |
| next(); // `:` - see first condition | |
| value = expression(false); | |
| } | |
| // Check for default value and alter value accordingly if necessary | |
| if (is("operator", "=")) { | |
| next(); | |
| value = new AST_Assign({ | |
| start: start, | |
| left: value, | |
| operator: "=", | |
| right: expression(false), | |
| logical: false, | |
| end: prev() | |
| }); | |
| } | |
| // Create property | |
| const kv = new AST_ObjectKeyVal({ | |
| start: start, | |
| quote: start.quote, | |
| key: name instanceof AST_Node ? name : "" + name, | |
| value: value, | |
| end: prev() | |
| }); | |
| a.push(annotate(kv)); | |
| } | |
| next(); | |
| return new AST_Object({ properties: a }); | |
| }); | |
| function class_(KindOfClass, is_export_default) { | |
| var start, method, class_name, extends_, a = []; | |
| S.input.push_directives_stack(); // Push directive stack, but not scope stack | |
| S.input.add_directive("use strict"); | |
| if (S.token.type == "name" && S.token.value != "extends") { | |
| class_name = as_symbol(KindOfClass === AST_DefClass ? AST_SymbolDefClass : AST_SymbolClass); | |
| } | |
| if (KindOfClass === AST_DefClass && !class_name) { | |
| if (is_export_default) { | |
| KindOfClass = AST_ClassExpression; | |
| } else { | |
| unexpected(); | |
| } | |
| } | |
| if (S.token.value == "extends") { | |
| next(); | |
| extends_ = expression(true); | |
| } | |
| expect("{"); | |
| // mark in class feild, | |
| const save_in_class = S.in_class; | |
| S.in_class = true; | |
| while (is("punc", ";")) { next(); } // Leading semicolons are okay in class bodies. | |
| while (!is("punc", "}")) { | |
| start = S.token; | |
| method = concise_method_or_getset(as_property_name(), start, true); | |
| if (!method) { unexpected(); } | |
| a.push(method); | |
| while (is("punc", ";")) { next(); } | |
| } | |
| // mark in class feild, | |
| S.in_class = save_in_class; | |
| S.input.pop_directives_stack(); | |
| next(); | |
| return new KindOfClass({ | |
| start: start, | |
| name: class_name, | |
| extends: extends_, | |
| properties: a, | |
| end: prev(), | |
| }); | |
| } | |
| function concise_method_or_getset(name, start, is_class) { | |
| const get_symbol_ast = (name, SymbolClass = AST_SymbolMethod) => { | |
| if (typeof name === "string" || typeof name === "number") { | |
| return new SymbolClass({ | |
| start, | |
| name: "" + name, | |
| end: prev() | |
| }); | |
| } else if (name === null) { | |
| unexpected(); | |
| } | |
| return name; | |
| }; | |
| const is_not_method_start = () => | |
| !is("punc", "(") && !is("punc", ",") && !is("punc", "}") && !is("punc", ";") && !is("operator", "="); | |
| var is_async = false; | |
| var is_static = false; | |
| var is_generator = false; | |
| var is_private = false; | |
| var accessor_type = null; | |
| if (is_class && name === "static" && is_not_method_start()) { | |
| const static_block = class_static_block(); | |
| if (static_block != null) { | |
| return static_block; | |
| } | |
| is_static = true; | |
| name = as_property_name(); | |
| } | |
| if (name === "async" && is_not_method_start()) { | |
| is_async = true; | |
| name = as_property_name(); | |
| } | |
| if (prev().type === "operator" && prev().value === "*") { | |
| is_generator = true; | |
| name = as_property_name(); | |
| } | |
| if ((name === "get" || name === "set") && is_not_method_start()) { | |
| accessor_type = name; | |
| name = as_property_name(); | |
| } | |
| if (prev().type === "privatename") { | |
| is_private = true; | |
| } | |
| const property_token = prev(); | |
| if (accessor_type != null) { | |
| if (!is_private) { | |
| const AccessorClass = accessor_type === "get" | |
| ? AST_ObjectGetter | |
| : AST_ObjectSetter; | |
| name = get_symbol_ast(name); | |
| return annotate(new AccessorClass({ | |
| start, | |
| static: is_static, | |
| key: name, | |
| quote: name instanceof AST_SymbolMethod ? property_token.quote : undefined, | |
| value: create_accessor(), | |
| end: prev() | |
| })); | |
| } else { | |
| const AccessorClass = accessor_type === "get" | |
| ? AST_PrivateGetter | |
| : AST_PrivateSetter; | |
| return annotate(new AccessorClass({ | |
| start, | |
| static: is_static, | |
| key: get_symbol_ast(name), | |
| value: create_accessor(), | |
| end: prev(), | |
| })); | |
| } | |
| } | |
| if (is("punc", "(")) { | |
| name = get_symbol_ast(name); | |
| const AST_MethodVariant = is_private | |
| ? AST_PrivateMethod | |
| : AST_ConciseMethod; | |
| var node = new AST_MethodVariant({ | |
| start : start, | |
| static : is_static, | |
| is_generator: is_generator, | |
| async : is_async, | |
| key : name, | |
| quote : name instanceof AST_SymbolMethod ? | |
| property_token.quote : undefined, | |
| value : create_accessor(is_generator, is_async), | |
| end : prev() | |
| }); | |
| return annotate(node); | |
| } | |
| if (is_class) { | |
| const key = get_symbol_ast(name, AST_SymbolClassProperty); | |
| const quote = key instanceof AST_SymbolClassProperty | |
| ? property_token.quote | |
| : undefined; | |
| const AST_ClassPropertyVariant = is_private | |
| ? AST_ClassPrivateProperty | |
| : AST_ClassProperty; | |
| if (is("operator", "=")) { | |
| next(); | |
| return annotate( | |
| new AST_ClassPropertyVariant({ | |
| start, | |
| static: is_static, | |
| quote, | |
| key, | |
| value: expression(false), | |
| end: prev() | |
| }) | |
| ); | |
| } else if ( | |
| is("name") | |
| || is("privatename") | |
| || is("punc", "[") | |
| || is("operator", "*") | |
| || is("punc", ";") | |
| || is("punc", "}") | |
| ) { | |
| return annotate( | |
| new AST_ClassPropertyVariant({ | |
| start, | |
| static: is_static, | |
| quote, | |
| key, | |
| end: prev() | |
| }) | |
| ); | |
| } | |
| } | |
| } | |
| function class_static_block() { | |
| if (!is("punc", "{")) { | |
| return null; | |
| } | |
| const start = S.token; | |
| const body = []; | |
| next(); | |
| while (!is("punc", "}")) { | |
| body.push(statement()); | |
| } | |
| next(); | |
| return new AST_ClassStaticBlock({ start, body, end: prev() }); | |
| } | |
| function maybe_import_attributes() { | |
| if ( | |
| (is("keyword", "with") || is("name", "assert")) | |
| && !has_newline_before(S.token) | |
| ) { | |
| next(); | |
| return object_or_destructuring_(); | |
| } | |
| return null; | |
| } | |
| function import_statement() { | |
| var start = prev(); | |
| var imported_name; | |
| var imported_names; | |
| if (is("name")) { | |
| imported_name = as_symbol(AST_SymbolImport); | |
| } | |
| if (is("punc", ",")) { | |
| next(); | |
| } | |
| imported_names = map_names(true); | |
| if (imported_names || imported_name) { | |
| expect_token("name", "from"); | |
| } | |
| var mod_str = S.token; | |
| if (mod_str.type !== "string") { | |
| unexpected(); | |
| } | |
| next(); | |
| const attributes = maybe_import_attributes(); | |
| return new AST_Import({ | |
| start, | |
| imported_name, | |
| imported_names, | |
| module_name: new AST_String({ | |
| start: mod_str, | |
| value: mod_str.value, | |
| quote: mod_str.quote, | |
| end: mod_str, | |
| }), | |
| attributes, | |
| end: S.token, | |
| }); | |
| } | |
| function import_meta(allow_calls) { | |
| var start = S.token; | |
| expect_token("name", "import"); | |
| expect_token("punc", "."); | |
| expect_token("name", "meta"); | |
| return subscripts(new AST_ImportMeta({ | |
| start: start, | |
| end: prev() | |
| }), allow_calls); | |
| } | |
| function map_name(is_import) { | |
| function make_symbol(type, quote) { | |
| return new type({ | |
| name: as_property_name(), | |
| quote: quote || undefined, | |
| start: prev(), | |
| end: prev() | |
| }); | |
| } | |
| var foreign_type = is_import ? AST_SymbolImportForeign : AST_SymbolExportForeign; | |
| var type = is_import ? AST_SymbolImport : AST_SymbolExport; | |
| var start = S.token; | |
| var foreign_name; | |
| var name; | |
| if (is_import) { | |
| foreign_name = make_symbol(foreign_type, start.quote); | |
| } else { | |
| name = make_symbol(type, start.quote); | |
| } | |
| if (is("name", "as")) { | |
| next(); // The "as" word | |
| if (is_import) { | |
| name = make_symbol(type); | |
| } else { | |
| foreign_name = make_symbol(foreign_type, S.token.quote); | |
| } | |
| } else if (is_import) { | |
| name = new type(foreign_name); | |
| } else { | |
| foreign_name = new foreign_type(name); | |
| } | |
| return new AST_NameMapping({ | |
| start: start, | |
| foreign_name: foreign_name, | |
| name: name, | |
| end: prev(), | |
| }); | |
| } | |
| function map_nameAsterisk(is_import, import_or_export_foreign_name) { | |
| var foreign_type = is_import ? AST_SymbolImportForeign : AST_SymbolExportForeign; | |
| var type = is_import ? AST_SymbolImport : AST_SymbolExport; | |
| var start = S.token; | |
| var name, foreign_name; | |
| var end = prev(); | |
| if (is_import) { | |
| name = import_or_export_foreign_name; | |
| } else { | |
| foreign_name = import_or_export_foreign_name; | |
| } | |
| name = name || new type({ | |
| start: start, | |
| name: "*", | |
| end: end, | |
| }); | |
| foreign_name = foreign_name || new foreign_type({ | |
| start: start, | |
| name: "*", | |
| end: end, | |
| }); | |
| return new AST_NameMapping({ | |
| start: start, | |
| foreign_name: foreign_name, | |
| name: name, | |
| end: end, | |
| }); | |
| } | |
| function map_names(is_import) { | |
| var names; | |
| if (is("punc", "{")) { | |
| next(); | |
| names = []; | |
| while (!is("punc", "}")) { | |
| names.push(map_name(is_import)); | |
| if (is("punc", ",")) { | |
| next(); | |
| } | |
| } | |
| next(); | |
| } else if (is("operator", "*")) { | |
| var name; | |
| next(); | |
| if (is("name", "as")) { | |
| next(); // The "as" word | |
| name = is_import ? as_symbol(AST_SymbolImport) : as_symbol_or_string(AST_SymbolExportForeign); | |
| } | |
| names = [map_nameAsterisk(is_import, name)]; | |
| } | |
| return names; | |
| } | |
| function export_statement() { | |
| var start = S.token; | |
| var is_default; | |
| var exported_names; | |
| if (is("keyword", "default")) { | |
| is_default = true; | |
| next(); | |
| } else if (exported_names = map_names(false)) { | |
| if (is("name", "from")) { | |
| next(); | |
| var mod_str = S.token; | |
| if (mod_str.type !== "string") { | |
| unexpected(); | |
| } | |
| next(); | |
| const attributes = maybe_import_attributes(); | |
| return new AST_Export({ | |
| start: start, | |
| is_default: is_default, | |
| exported_names: exported_names, | |
| module_name: new AST_String({ | |
| start: mod_str, | |
| value: mod_str.value, | |
| quote: mod_str.quote, | |
| end: mod_str, | |
| }), | |
| end: prev(), | |
| attributes | |
| }); | |
| } else { | |
| return new AST_Export({ | |
| start: start, | |
| is_default: is_default, | |
| exported_names: exported_names, | |
| end: prev(), | |
| }); | |
| } | |
| } | |
| var node; | |
| var exported_value; | |
| var exported_definition; | |
| if (is("punc", "{") | |
| || is_default | |
| && (is("keyword", "class") || is("keyword", "function")) | |
| && is_token(peek(), "punc")) { | |
| exported_value = expression(false); | |
| semicolon(); | |
| } else if ((node = statement(is_default)) instanceof AST_Definitions && is_default) { | |
| unexpected(node.start); | |
| } else if ( | |
| node instanceof AST_Definitions | |
| || node instanceof AST_Defun | |
| || node instanceof AST_DefClass | |
| ) { | |
| exported_definition = node; | |
| } else if ( | |
| node instanceof AST_ClassExpression | |
| || node instanceof AST_Function | |
| ) { | |
| exported_value = node; | |
| } else if (node instanceof AST_SimpleStatement) { | |
| exported_value = node.body; | |
| } else { | |
| unexpected(node.start); | |
| } | |
| return new AST_Export({ | |
| start: start, | |
| is_default: is_default, | |
| exported_value: exported_value, | |
| exported_definition: exported_definition, | |
| end: prev(), | |
| attributes: null | |
| }); | |
| } | |
| function as_property_name() { | |
| var tmp = S.token; | |
| switch (tmp.type) { | |
| case "punc": | |
| if (tmp.value === "[") { | |
| next(); | |
| var ex = expression(false); | |
| expect("]"); | |
| return ex; | |
| } else unexpected(tmp); | |
| case "operator": | |
| if (tmp.value === "*") { | |
| next(); | |
| return null; | |
| } | |
| if (!["delete", "in", "instanceof", "new", "typeof", "void"].includes(tmp.value)) { | |
| unexpected(tmp); | |
| } | |
| /* falls through */ | |
| case "name": | |
| case "privatename": | |
| case "string": | |
| case "num": | |
| case "big_int": | |
| case "keyword": | |
| case "atom": | |
| next(); | |
| return tmp.value; | |
| default: | |
| unexpected(tmp); | |
| } | |
| } | |
| function as_name() { | |
| var tmp = S.token; | |
| if (tmp.type != "name" && tmp.type != "privatename") unexpected(); | |
| next(); | |
| return tmp.value; | |
| } | |
| function _make_symbol(type) { | |
| var name = S.token.value; | |
| return new (name == "this" ? AST_This : | |
| name == "super" ? AST_Super : | |
| type)({ | |
| name : String(name), | |
| start : S.token, | |
| end : S.token | |
| }); | |
| } | |
| function _verify_symbol(sym) { | |
| var name = sym.name; | |
| if (is_in_generator() && name == "yield") { | |
| token_error(sym.start, "Yield cannot be used as identifier inside generators"); | |
| } | |
| if (S.input.has_directive("use strict")) { | |
| if (name == "yield") { | |
| token_error(sym.start, "Unexpected yield identifier inside strict mode"); | |
| } | |
| if (sym instanceof AST_SymbolDeclaration && (name == "arguments" || name == "eval")) { | |
| token_error(sym.start, "Unexpected " + name + " in strict mode"); | |
| } | |
| } | |
| } | |
| function as_symbol(type, noerror) { | |
| if (!is("name")) { | |
| if (!noerror) croak("Name expected"); | |
| return null; | |
| } | |
| var sym = _make_symbol(type); | |
| _verify_symbol(sym); | |
| next(); | |
| return sym; | |
| } | |
| function as_symbol_or_string(type) { | |
| if (!is("name")) { | |
| if (!is("string")) { | |
| croak("Name or string expected"); | |
| } | |
| var tok = S.token; | |
| var ret = new type({ | |
| start : tok, | |
| end : tok, | |
| name : tok.value, | |
| quote : tok.quote | |
| }); | |
| next(); | |
| return ret; | |
| } | |
| var sym = _make_symbol(type); | |
| _verify_symbol(sym); | |
| next(); | |
| return sym; | |
| } | |
| // Annotate AST_Call, AST_Lambda or AST_New with the special comments | |
| function annotate(node, before_token = node.start) { | |
| var comments = before_token.comments_before; | |
| const comments_outside_parens = outer_comments_before_counts.get(before_token); | |
| var i = comments_outside_parens != null ? comments_outside_parens : comments.length; | |
| while (--i >= 0) { | |
| var comment = comments[i]; | |
| if (/[@#]__/.test(comment.value)) { | |
| if (/[@#]__PURE__/.test(comment.value)) { | |
| set_annotation(node, _PURE); | |
| break; | |
| } | |
| if (/[@#]__INLINE__/.test(comment.value)) { | |
| set_annotation(node, _INLINE); | |
| break; | |
| } | |
| if (/[@#]__NOINLINE__/.test(comment.value)) { | |
| set_annotation(node, _NOINLINE); | |
| break; | |
| } | |
| if (/[@#]__KEY__/.test(comment.value)) { | |
| set_annotation(node, _KEY); | |
| break; | |
| } | |
| if (/[@#]__MANGLE_PROP__/.test(comment.value)) { | |
| set_annotation(node, _MANGLEPROP); | |
| break; | |
| } | |
| } | |
| } | |
| return node; | |
| } | |
| var subscripts = function(expr, allow_calls, is_chain) { | |
| var start = expr.start; | |
| if (is("punc", ".")) { | |
| next(); | |
| if(is("privatename") && !S.in_class) | |
| croak("Private field must be used in an enclosing class"); | |
| const AST_DotVariant = is("privatename") ? AST_DotHash : AST_Dot; | |
| return annotate(subscripts(new AST_DotVariant({ | |
| start : start, | |
| expression : expr, | |
| optional : false, | |
| property : as_name(), | |
| end : prev() | |
| }), allow_calls, is_chain)); | |
| } | |
| if (is("punc", "[")) { | |
| next(); | |
| var prop = expression(true); | |
| expect("]"); | |
| return annotate(subscripts(new AST_Sub({ | |
| start : start, | |
| expression : expr, | |
| optional : false, | |
| property : prop, | |
| end : prev() | |
| }), allow_calls, is_chain)); | |
| } | |
| if (allow_calls && is("punc", "(")) { | |
| next(); | |
| var call = new AST_Call({ | |
| start : start, | |
| expression : expr, | |
| optional : false, | |
| args : call_args(), | |
| end : prev() | |
| }); | |
| annotate(call); | |
| return subscripts(call, true, is_chain); | |
| } | |
| // Optional chain | |
| if (is("punc", "?.")) { | |
| next(); | |
| let chain_contents; | |
| if (allow_calls && is("punc", "(")) { | |
| next(); | |
| const call = new AST_Call({ | |
| start, | |
| optional: true, | |
| expression: expr, | |
| args: call_args(), | |
| end: prev() | |
| }); | |
| annotate(call); | |
| chain_contents = subscripts(call, true, true); | |
| } else if (is("name") || is("privatename")) { | |
| if(is("privatename") && !S.in_class) | |
| croak("Private field must be used in an enclosing class"); | |
| const AST_DotVariant = is("privatename") ? AST_DotHash : AST_Dot; | |
| chain_contents = annotate(subscripts(new AST_DotVariant({ | |
| start, | |
| expression: expr, | |
| optional: true, | |
| property: as_name(), | |
| end: prev() | |
| }), allow_calls, true)); | |
| } else if (is("punc", "[")) { | |
| next(); | |
| const property = expression(true); | |
| expect("]"); | |
| chain_contents = annotate(subscripts(new AST_Sub({ | |
| start, | |
| expression: expr, | |
| optional: true, | |
| property, | |
| end: prev() | |
| }), allow_calls, true)); | |
| } | |
| if (!chain_contents) unexpected(); | |
| if (chain_contents instanceof AST_Chain) return chain_contents; | |
| return new AST_Chain({ | |
| start, | |
| expression: chain_contents, | |
| end: prev() | |
| }); | |
| } | |
| if (is("template_head")) { | |
| if (is_chain) { | |
| // a?.b`c` is a syntax error | |
| unexpected(); | |
| } | |
| return subscripts(new AST_PrefixedTemplateString({ | |
| start: start, | |
| prefix: expr, | |
| template_string: template_string(), | |
| end: prev() | |
| }), allow_calls); | |
| } | |
| return expr; | |
| }; | |
| function call_args() { | |
| var args = []; | |
| while (!is("punc", ")")) { | |
| if (is("expand", "...")) { | |
| next(); | |
| args.push(new AST_Expansion({ | |
| start: prev(), | |
| expression: expression(false), | |
| end: prev() | |
| })); | |
| } else { | |
| args.push(expression(false)); | |
| } | |
| if (!is("punc", ")")) { | |
| expect(","); | |
| } | |
| } | |
| next(); | |
| return args; | |
| } | |
| var maybe_unary = function(allow_calls, allow_arrows) { | |
| var start = S.token; | |
| if (start.type == "name" && start.value == "await" && can_await()) { | |
| next(); | |
| return _await_expression(); | |
| } | |
| if (is("operator") && UNARY_PREFIX.has(start.value)) { | |
| next(); | |
| handle_regexp(); | |
| var ex = make_unary(AST_UnaryPrefix, start, maybe_unary(allow_calls)); | |
| ex.start = start; | |
| ex.end = prev(); | |
| return ex; | |
| } | |
| var val = expr_atom(allow_calls, allow_arrows); | |
| while (is("operator") && UNARY_POSTFIX.has(S.token.value) && !has_newline_before(S.token)) { | |
| if (val instanceof AST_Arrow) unexpected(); | |
| val = make_unary(AST_UnaryPostfix, S.token, val); | |
| val.start = start; | |
| val.end = S.token; | |
| next(); | |
| } | |
| return val; | |
| }; | |
| function make_unary(ctor, token, expr) { | |
| var op = token.value; | |
| switch (op) { | |
| case "++": | |
| case "--": | |
| if (!is_assignable(expr)) | |
| 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")) | |
| 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 }); | |
| } | |
| var expr_op = function(left, min_prec, no_in) { | |
| var op = is("operator") ? S.token.value : null; | |
| if (op == "in" && no_in) op = null; | |
| if (op == "**" && left instanceof AST_UnaryPrefix | |
| /* unary token in front not allowed - parenthesis required */ | |
| && !is_token(left.start, "punc", "(") | |
| && left.operator !== "--" && left.operator !== "++") | |
| unexpected(left.start); | |
| var prec = op != null ? PRECEDENCE[op] : null; | |
| if (prec != null && (prec > min_prec || (op === "**" && min_prec === prec))) { | |
| next(); | |
| var right = expr_ops(no_in, prec, true); | |
| return expr_op(new AST_Binary({ | |
| start : left.start, | |
| left : left, | |
| operator : op, | |
| right : right, | |
| end : right.end | |
| }), min_prec, no_in); | |
| } | |
| return left; | |
| }; | |
| function expr_ops(no_in, min_prec, allow_calls, allow_arrows) { | |
| // maybe_unary won't return us a AST_SymbolPrivateProperty | |
| if (!no_in && min_prec < PRECEDENCE["in"] && is("privatename")) { | |
| if(!S.in_class) { | |
| croak("Private field must be used in an enclosing class"); | |
| } | |
| const start = S.token; | |
| const key = new AST_SymbolPrivateProperty({ | |
| start, | |
| name: start.value, | |
| end: start | |
| }); | |
| next(); | |
| expect_token("operator", "in"); | |
| const private_in = new AST_PrivateIn({ | |
| start, | |
| key, | |
| value: expr_ops(no_in, PRECEDENCE["in"], true), | |
| end: prev() | |
| }); | |
| return expr_op(private_in, 0, no_in); | |
| } else { | |
| return expr_op(maybe_unary(allow_calls, allow_arrows), min_prec, no_in); | |
| } | |
| } | |
| var maybe_conditional = function(no_in) { | |
| var start = S.token; | |
| var expr = expr_ops(no_in, 0, true, true); | |
| if (is("operator", "?")) { | |
| next(); | |
| var yes = expression(false); | |
| expect(":"); | |
| return new AST_Conditional({ | |
| start : start, | |
| condition : expr, | |
| consequent : yes, | |
| alternative : expression(false, no_in), | |
| end : prev() | |
| }); | |
| } | |
| return expr; | |
| }; | |
| function is_assignable(expr) { | |
| return expr instanceof AST_PropAccess || expr instanceof AST_SymbolRef; | |
| } | |
| function to_destructuring(node) { | |
| if (node instanceof AST_Object) { | |
| node = new AST_Destructuring({ | |
| start: node.start, | |
| names: node.properties.map(to_destructuring), | |
| is_array: false, | |
| end: node.end | |
| }); | |
| } else if (node instanceof AST_Array) { | |
| var names = []; | |
| for (var i = 0; i < node.elements.length; i++) { | |
| // Only allow expansion as last element | |
| if (node.elements[i] instanceof AST_Expansion) { | |
| if (i + 1 !== node.elements.length) { | |
| token_error(node.elements[i].start, "Spread must the be last element in destructuring array"); | |
| } | |
| node.elements[i].expression = to_destructuring(node.elements[i].expression); | |
| } | |
| names.push(to_destructuring(node.elements[i])); | |
| } | |
| node = new AST_Destructuring({ | |
| start: node.start, | |
| names: names, | |
| is_array: true, | |
| end: node.end | |
| }); | |
| } else if (node instanceof AST_ObjectProperty) { | |
| node.value = to_destructuring(node.value); | |
| } else if (node instanceof AST_Assign) { | |
| node = new AST_DefaultAssign({ | |
| start: node.start, | |
| left: node.left, | |
| operator: "=", | |
| right: node.right, | |
| end: node.end | |
| }); | |
| } | |
| return node; | |
| } | |
| // In ES6, AssignmentExpression can also be an ArrowFunction | |
| var maybe_assign = function(no_in) { | |
| handle_regexp(); | |
| var start = S.token; | |
| if (start.type == "name" && start.value == "yield") { | |
| if (is_in_generator()) { | |
| next(); | |
| return _yield_expression(); | |
| } else if (S.input.has_directive("use strict")) { | |
| token_error(S.token, "Unexpected yield identifier inside strict mode"); | |
| } | |
| } | |
| var left = maybe_conditional(no_in); | |
| var val = S.token.value; | |
| if (is("operator") && ASSIGNMENT.has(val)) { | |
| if (is_assignable(left) || (left = to_destructuring(left)) instanceof AST_Destructuring) { | |
| next(); | |
| return new AST_Assign({ | |
| start : start, | |
| left : left, | |
| operator : val, | |
| right : maybe_assign(no_in), | |
| logical : LOGICAL_ASSIGNMENT.has(val), | |
| end : prev() | |
| }); | |
| } | |
| croak("Invalid assignment"); | |
| } | |
| return left; | |
| }; | |
| var to_expr_or_sequence = function(start, exprs) { | |
| if (exprs.length === 1) { | |
| return exprs[0]; | |
| } else if (exprs.length > 1) { | |
| return new AST_Sequence({ start, expressions: exprs, end: peek() }); | |
| } else { | |
| croak("Invalid parenthesized expression"); | |
| } | |
| }; | |
| var expression = function(commas, no_in) { | |
| var start = S.token; | |
| var exprs = []; | |
| while (true) { | |
| exprs.push(maybe_assign(no_in)); | |
| if (!commas || !is("punc", ",")) break; | |
| next(); | |
| commas = true; | |
| } | |
| return to_expr_or_sequence(start, exprs); | |
| }; | |
| function in_loop(cont) { | |
| ++S.in_loop; | |
| var ret = cont(); | |
| --S.in_loop; | |
| return ret; | |
| } | |
| if (options.expression) { | |
| return expression(true); | |
| } | |
| return (function parse_toplevel() { | |
| var start = S.token; | |
| var body = []; | |
| S.input.push_directives_stack(); | |
| if (options.module) S.input.add_directive("use strict"); | |
| while (!is("eof")) { | |
| body.push(statement()); | |
| } | |
| S.input.pop_directives_stack(); | |
| var end = prev(); | |
| var toplevel = options.toplevel; | |
| if (toplevel) { | |
| toplevel.body = toplevel.body.concat(body); | |
| toplevel.end = end; | |
| } else { | |
| toplevel = new AST_Toplevel({ start: start, body: body, end: end }); | |
| } | |
| TEMPLATE_RAWS = new Map(); | |
| return toplevel; | |
| })(); | |
| } | |
| export { | |
| get_full_char_code, | |
| get_full_char, | |
| is_identifier_char, | |
| is_basic_identifier_string, | |
| is_identifier_string, | |
| is_surrogate_pair_head, | |
| is_surrogate_pair_tail, | |
| js_error, | |
| JS_Parse_Error, | |
| parse, | |
| PRECEDENCE, | |
| ALL_RESERVED_WORDS, | |
| tokenizer, | |
| }; | |
Xet Storage Details
- Size:
- 126 kB
- Xet hash:
- e30462dfecfbe86d56550a5e5f5934eeae7da722819e3a28db83e7d45940dbd9
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.