3935 lines
111 KiB
JavaScript
3935 lines
111 KiB
JavaScript
/***********************************************************************
|
|
|
|
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.
|
|
|
|
***********************************************************************/
|
|
|
|
'use strict';
|
|
|
|
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,
|
|
};
|