2586 lines
81 KiB
JavaScript
2586 lines
81 KiB
JavaScript
// -------------------------------------------------------------
|
|
// WARNING: this file is used by both the client and the server.
|
|
// Do not use any browser or node-specific API!
|
|
// -------------------------------------------------------------
|
|
|
|
/*
|
|
Copyright (C) 2014 Ivan Nikulin <ifaaan@gmail.com>
|
|
Copyright (C) 2012-2014 Yusuke Suzuki <utatane.tea@gmail.com>
|
|
Copyright (C) 2012-2013 Michael Ficarra <escodegen.copyright@michael.ficarra.me>
|
|
Copyright (C) 2012-2013 Mathias Bynens <mathias@qiwi.be>
|
|
Copyright (C) 2013 Irakli Gozalishvili <rfobic@gmail.com>
|
|
Copyright (C) 2012 Robert Gust-Bardon <donate@robert.gust-bardon.org>
|
|
Copyright (C) 2012 John Freeman <jfreeman08@gmail.com>
|
|
Copyright (C) 2011-2012 Ariya Hidayat <ariya.hidayat@gmail.com>
|
|
Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>
|
|
Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>
|
|
Copyright (C) 2012 Arpad Borsos <arpad.borsos@googlemail.com>
|
|
|
|
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 HOLDERS AND CONTRIBUTORS "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 <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';
|
|
|
|
var isArray,
|
|
json,
|
|
renumber,
|
|
hexadecimal,
|
|
quotes,
|
|
escapeless,
|
|
parentheses,
|
|
semicolons,
|
|
safeConcatenation,
|
|
directive,
|
|
extra,
|
|
parse;
|
|
|
|
var Syntax = {
|
|
AssignmentExpression: 'AssignmentExpression',
|
|
AssignmentPattern: 'AssignmentPattern',
|
|
ArrayExpression: 'ArrayExpression',
|
|
ArrayPattern: 'ArrayPattern',
|
|
ArrowFunctionExpression: 'ArrowFunctionExpression',
|
|
AwaitExpression: 'AwaitExpression',
|
|
BlockStatement: 'BlockStatement',
|
|
BinaryExpression: 'BinaryExpression',
|
|
BreakStatement: 'BreakStatement',
|
|
CallExpression: 'CallExpression',
|
|
CatchClause: 'CatchClause',
|
|
ClassBody: 'ClassBody',
|
|
ClassDeclaration: 'ClassDeclaration',
|
|
ClassExpression: 'ClassExpression',
|
|
ComprehensionBlock: 'ComprehensionBlock',
|
|
ComprehensionExpression: 'ComprehensionExpression',
|
|
ConditionalExpression: 'ConditionalExpression',
|
|
ContinueStatement: 'ContinueStatement',
|
|
DirectiveStatement: 'DirectiveStatement',
|
|
DoWhileStatement: 'DoWhileStatement',
|
|
DebuggerStatement: 'DebuggerStatement',
|
|
EmptyStatement: 'EmptyStatement',
|
|
ExportAllDeclaration: 'ExportAllDeclaration',
|
|
ExportBatchSpecifier: 'ExportBatchSpecifier',
|
|
ExportDeclaration: 'ExportDeclaration',
|
|
ExportNamedDeclaration: 'ExportNamedDeclaration',
|
|
ExportSpecifier: 'ExportSpecifier',
|
|
ExpressionStatement: 'ExpressionStatement',
|
|
ForStatement: 'ForStatement',
|
|
ForInStatement: 'ForInStatement',
|
|
ForOfStatement: 'ForOfStatement',
|
|
FunctionDeclaration: 'FunctionDeclaration',
|
|
FunctionExpression: 'FunctionExpression',
|
|
GeneratorExpression: 'GeneratorExpression',
|
|
Identifier: 'Identifier',
|
|
IfStatement: 'IfStatement',
|
|
ImportExpression: 'ImportExpression',
|
|
ImportSpecifier: 'ImportSpecifier',
|
|
ImportDeclaration: 'ImportDeclaration',
|
|
ChainExpression: 'ChainExpression',
|
|
Literal: 'Literal',
|
|
LabeledStatement: 'LabeledStatement',
|
|
LogicalExpression: 'LogicalExpression',
|
|
MemberExpression: 'MemberExpression',
|
|
MetaProperty: 'MetaProperty',
|
|
MethodDefinition: 'MethodDefinition',
|
|
ModuleDeclaration: 'ModuleDeclaration',
|
|
NewExpression: 'NewExpression',
|
|
ObjectExpression: 'ObjectExpression',
|
|
ObjectPattern: 'ObjectPattern',
|
|
Program: 'Program',
|
|
Property: 'Property',
|
|
RestElement: 'RestElement',
|
|
ReturnStatement: 'ReturnStatement',
|
|
SequenceExpression: 'SequenceExpression',
|
|
SpreadElement: 'SpreadElement',
|
|
Super: 'Super',
|
|
SwitchStatement: 'SwitchStatement',
|
|
SwitchCase: 'SwitchCase',
|
|
TaggedTemplateExpression: 'TaggedTemplateExpression',
|
|
TemplateElement: 'TemplateElement',
|
|
TemplateLiteral: 'TemplateLiteral',
|
|
ThisExpression: 'ThisExpression',
|
|
ThrowStatement: 'ThrowStatement',
|
|
TryStatement: 'TryStatement',
|
|
UnaryExpression: 'UnaryExpression',
|
|
UpdateExpression: 'UpdateExpression',
|
|
VariableDeclaration: 'VariableDeclaration',
|
|
VariableDeclarator: 'VariableDeclarator',
|
|
WhileStatement: 'WhileStatement',
|
|
WithStatement: 'WithStatement',
|
|
YieldExpression: 'YieldExpression'
|
|
};
|
|
|
|
exports.Syntax = Syntax;
|
|
|
|
var Precedence = {
|
|
Sequence: 0,
|
|
Yield: 1,
|
|
Assignment: 1,
|
|
Conditional: 2,
|
|
ArrowFunction: 2,
|
|
Coalesce: 3,
|
|
LogicalOR: 3,
|
|
LogicalAND: 4,
|
|
BitwiseOR: 5,
|
|
BitwiseXOR: 6,
|
|
BitwiseAND: 7,
|
|
Equality: 8,
|
|
Relational: 9,
|
|
BitwiseSHIFT: 10,
|
|
Additive: 11,
|
|
Multiplicative: 12,
|
|
Unary: 13,
|
|
Exponentiation: 14,
|
|
Postfix: 14,
|
|
Await: 14,
|
|
Call: 15,
|
|
New: 16,
|
|
TaggedTemplate: 17,
|
|
OptionalChaining: 17,
|
|
Member: 18,
|
|
Primary: 19
|
|
};
|
|
|
|
var BinaryPrecedence = {
|
|
'||': Precedence.LogicalOR,
|
|
'&&': Precedence.LogicalAND,
|
|
'|': Precedence.BitwiseOR,
|
|
'^': Precedence.BitwiseXOR,
|
|
'&': Precedence.BitwiseAND,
|
|
'==': Precedence.Equality,
|
|
'!=': Precedence.Equality,
|
|
'===': Precedence.Equality,
|
|
'!==': Precedence.Equality,
|
|
'is': Precedence.Equality,
|
|
'isnt': Precedence.Equality,
|
|
'<': Precedence.Relational,
|
|
'>': Precedence.Relational,
|
|
'<=': Precedence.Relational,
|
|
'>=': Precedence.Relational,
|
|
'in': Precedence.Relational,
|
|
'instanceof': Precedence.Relational,
|
|
'<<': Precedence.BitwiseSHIFT,
|
|
'>>': Precedence.BitwiseSHIFT,
|
|
'>>>': Precedence.BitwiseSHIFT,
|
|
'+': Precedence.Additive,
|
|
'-': Precedence.Additive,
|
|
'*': Precedence.Multiplicative,
|
|
'%': Precedence.Multiplicative,
|
|
'/': Precedence.Multiplicative,
|
|
'??': Precedence.Coalesce,
|
|
'**': Precedence.Exponentiation
|
|
};
|
|
|
|
function getDefaultOptions () {
|
|
// default options
|
|
return {
|
|
indent: null,
|
|
base: null,
|
|
parse: null,
|
|
format: {
|
|
indent: {
|
|
style: ' ',
|
|
base: 0
|
|
},
|
|
newline: '\n',
|
|
space: ' ',
|
|
json: false,
|
|
renumber: false,
|
|
hexadecimal: false,
|
|
quotes: 'single',
|
|
escapeless: false,
|
|
compact: false,
|
|
parentheses: true,
|
|
semicolons: true,
|
|
safeConcatenation: false
|
|
},
|
|
directive: false,
|
|
raw: true,
|
|
verbatim: null
|
|
};
|
|
}
|
|
|
|
//-------------------------------------------------===------------------------------------------------------
|
|
// Lexical utils
|
|
//-------------------------------------------------===------------------------------------------------------
|
|
|
|
//Const
|
|
var NON_ASCII_WHITESPACES = [
|
|
0x1680, 0x180E, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005,
|
|
0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000,
|
|
0xFEFF
|
|
];
|
|
|
|
//Regular expressions
|
|
var NON_ASCII_IDENTIFIER_CHARACTERS_REGEXP = new RegExp(
|
|
'[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376' +
|
|
'\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-' +
|
|
'\u0527\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\u08A2-\u08AC\u08E4-\u08FE\u0900-' +
|
|
'\u0963\u0966-\u096F\u0971-\u0977\u0979-\u097F\u0981-\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\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\u0C01-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D-\u0C44\u0C46-' +
|
|
'\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C82\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\u0D02\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44' +
|
|
'\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-' +
|
|
'\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\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\u1380-' +
|
|
'\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F0\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-\u191C\u1920-\u192B' +
|
|
'\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E' +
|
|
'\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-' +
|
|
'\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1D00-\u1DE6\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' +
|
|
'\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\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\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A' +
|
|
'\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5' +
|
|
'\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA697' +
|
|
'\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA827\uA840-\uA873' +
|
|
'\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-' +
|
|
'\uA9D9\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A\uAA7B\uAA80-\uAAC2\uAADB-\uAADD\uAAE0-' +
|
|
'\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\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-\uFE26\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]'
|
|
);
|
|
|
|
|
|
//Methods
|
|
function isIdentifierCh (cp) {
|
|
if (cp < 0x80) {
|
|
return cp >= 97 && cp <= 122 || // a..z
|
|
cp >= 65 && cp <= 90 || // A..Z
|
|
cp >= 48 && cp <= 57 || // 0..9
|
|
cp === 36 || cp === 95 || // $ (dollar) and _ (underscore)
|
|
cp === 92; // \ (backslash)
|
|
}
|
|
|
|
var ch = String.fromCharCode(cp);
|
|
|
|
return NON_ASCII_IDENTIFIER_CHARACTERS_REGEXP.test(ch);
|
|
}
|
|
|
|
function isLineTerminator (cp) {
|
|
return cp === 0x0A || cp === 0x0D || cp === 0x2028 || cp === 0x2029;
|
|
}
|
|
|
|
function isWhitespace (cp) {
|
|
return cp === 0x20 || cp === 0x09 || isLineTerminator(cp) || cp === 0x0B || cp === 0x0C || cp === 0xA0 ||
|
|
(cp >= 0x1680 && NON_ASCII_WHITESPACES.indexOf(cp) >= 0);
|
|
}
|
|
|
|
function isDecimalDigit (cp) {
|
|
return cp >= 48 && cp <= 57;
|
|
}
|
|
|
|
function stringRepeat (str, num) {
|
|
var result = '';
|
|
|
|
for (num |= 0; num > 0; num >>>= 1, str += str) {
|
|
if (num & 1) {
|
|
result += str;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
isArray = Array.isArray;
|
|
if (!isArray) {
|
|
isArray = function isArray (array) {
|
|
return Object.prototype.toString.call(array) === '[object Array]';
|
|
};
|
|
}
|
|
|
|
|
|
function updateDeeply (target, override) {
|
|
var key, val;
|
|
|
|
function isHashObject (target) {
|
|
return typeof target === 'object' && target instanceof Object && !(target instanceof RegExp);
|
|
}
|
|
|
|
for (key in override) {
|
|
if (override.hasOwnProperty(key)) {
|
|
val = override[key];
|
|
if (isHashObject(val)) {
|
|
if (isHashObject(target[key])) {
|
|
updateDeeply(target[key], val);
|
|
}
|
|
else {
|
|
target[key] = updateDeeply({}, val);
|
|
}
|
|
}
|
|
else {
|
|
target[key] = val;
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
|
|
function generateNumber (value) {
|
|
var result, point, temp, exponent, pos;
|
|
|
|
if (value === 1 / 0) {
|
|
return json ? 'null' : renumber ? '1e400' : '1e+400';
|
|
}
|
|
|
|
result = '' + value;
|
|
if (!renumber || result.length < 3) {
|
|
return result;
|
|
}
|
|
|
|
point = result.indexOf('.');
|
|
//NOTE: 0x30 == '0'
|
|
if (!json && result.charCodeAt(0) === 0x30 && point === 1) {
|
|
point = 0;
|
|
result = result.slice(1);
|
|
}
|
|
temp = result;
|
|
result = result.replace('e+', 'e');
|
|
exponent = 0;
|
|
if ((pos = temp.indexOf('e')) > 0) {
|
|
exponent = +temp.slice(pos + 1);
|
|
temp = temp.slice(0, pos);
|
|
}
|
|
if (point >= 0) {
|
|
exponent -= temp.length - point - 1;
|
|
temp = +(temp.slice(0, point) + temp.slice(point + 1)) + '';
|
|
}
|
|
pos = 0;
|
|
|
|
//NOTE: 0x30 == '0'
|
|
while (temp.charCodeAt(temp.length + pos - 1) === 0x30) {
|
|
--pos;
|
|
}
|
|
if (pos !== 0) {
|
|
exponent -= pos;
|
|
temp = temp.slice(0, pos);
|
|
}
|
|
if (exponent !== 0) {
|
|
temp += 'e' + exponent;
|
|
}
|
|
if ((temp.length < result.length ||
|
|
(hexadecimal && value > 1e12 && Math.floor(value) === value &&
|
|
(temp = '0x' + value.toString(16)).length
|
|
< result.length)) &&
|
|
+temp === value) {
|
|
result = temp;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// Generate valid RegExp expression.
|
|
// This function is based on https://github.com/Constellation/iv Engine
|
|
|
|
function escapeRegExpCharacter (ch, previousIsBackslash) {
|
|
// not handling '\' and handling \u2028 or \u2029 to unicode escape sequence
|
|
if ((ch & ~1) === 0x2028) {
|
|
return (previousIsBackslash ? 'u' : '\\u') + ((ch === 0x2028) ? '2028' : '2029');
|
|
}
|
|
else if (ch === 10 || ch === 13) { // \n, \r
|
|
return (previousIsBackslash ? '' : '\\') + ((ch === 10) ? 'n' : 'r');
|
|
}
|
|
return String.fromCharCode(ch);
|
|
}
|
|
|
|
function generateRegExp (reg) {
|
|
var match, result, flags, i, iz, ch, characterInBrack, previousIsBackslash;
|
|
|
|
result = reg.toString();
|
|
|
|
if (reg.source) {
|
|
// extract flag from toString result
|
|
match = result.match(/\/([^/]*)$/);
|
|
if (!match) {
|
|
return result;
|
|
}
|
|
|
|
flags = match[1];
|
|
result = '';
|
|
|
|
characterInBrack = false;
|
|
previousIsBackslash = false;
|
|
for (i = 0, iz = reg.source.length; i < iz; ++i) {
|
|
ch = reg.source.charCodeAt(i);
|
|
|
|
if (!previousIsBackslash) {
|
|
if (characterInBrack) {
|
|
if (ch === 93) { // ]
|
|
characterInBrack = false;
|
|
}
|
|
}
|
|
else {
|
|
if (ch === 47) { // /
|
|
result += '\\';
|
|
}
|
|
else if (ch === 91) { // [
|
|
characterInBrack = true;
|
|
}
|
|
}
|
|
result += escapeRegExpCharacter(ch, previousIsBackslash);
|
|
previousIsBackslash = ch === 92; // \
|
|
}
|
|
else {
|
|
// if new RegExp("\\\n') is provided, create /\n/
|
|
result += escapeRegExpCharacter(ch, previousIsBackslash);
|
|
// prevent like /\\[/]/
|
|
previousIsBackslash = false;
|
|
}
|
|
}
|
|
|
|
return '/' + result + '/' + flags;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function escapeAllowedCharacter (code, next) {
|
|
var hex, result = '\\';
|
|
|
|
switch (code) {
|
|
case 0x08: // \b
|
|
result += 'b';
|
|
break;
|
|
case 0x0C: // \f
|
|
result += 'f';
|
|
break;
|
|
case 0x09: // \t
|
|
result += 't';
|
|
break;
|
|
default:
|
|
hex = code.toString(16).toUpperCase();
|
|
if (json || code > 0xFF) {
|
|
result += 'u' + '0000'.slice(hex.length) + hex;
|
|
}
|
|
|
|
else if (code === 0x0000 && !isDecimalDigit(next)) {
|
|
result += '0';
|
|
}
|
|
|
|
else if (code === 0x000B) { // \v
|
|
result += 'x0B';
|
|
}
|
|
|
|
else {
|
|
result += 'x' + '00'.slice(hex.length) + hex;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function escapeDisallowedCharacter (code) {
|
|
var result = '\\';
|
|
switch (code) {
|
|
case 0x5C // \
|
|
:
|
|
result += '\\';
|
|
break;
|
|
case 0x0A // \n
|
|
:
|
|
result += 'n';
|
|
break;
|
|
case 0x0D // \r
|
|
:
|
|
result += 'r';
|
|
break;
|
|
case 0x2028:
|
|
result += 'u2028';
|
|
break;
|
|
case 0x2029:
|
|
result += 'u2029';
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function escapeDirective (str) {
|
|
var i, iz, code, quote;
|
|
|
|
quote = quotes === 'double' ? '"' : '\'';
|
|
for (i = 0, iz = str.length; i < iz; ++i) {
|
|
code = str.charCodeAt(i);
|
|
if (code === 0x27) { // '
|
|
quote = '"';
|
|
break;
|
|
}
|
|
else if (code === 0x22) { // "
|
|
quote = '\'';
|
|
break;
|
|
}
|
|
else if (code === 0x5C) { // \
|
|
++i;
|
|
}
|
|
}
|
|
|
|
return quote + str + quote;
|
|
}
|
|
|
|
function escapeString (str) {
|
|
var result = '', i, len, code, singleQuotes = 0, doubleQuotes = 0, single, quote;
|
|
//TODO http://jsperf.com/character-counting/8
|
|
for (i = 0, len = str.length; i < len; ++i) {
|
|
code = str.charCodeAt(i);
|
|
if (code === 0x27) { // '
|
|
++singleQuotes;
|
|
}
|
|
else if (code === 0x22) { // "
|
|
++doubleQuotes;
|
|
}
|
|
else if (code === 0x2F && json) { // /
|
|
result += '\\';
|
|
}
|
|
else if (isLineTerminator(code) || code === 0x5C) { // \
|
|
result += escapeDisallowedCharacter(code);
|
|
continue;
|
|
}
|
|
else if ((json && code < 0x20) || // SP
|
|
!(json || escapeless || (code >= 0x20 && code <= 0x7E))) { // SP, ~
|
|
result += escapeAllowedCharacter(code, str.charCodeAt(i + 1));
|
|
continue;
|
|
}
|
|
result += String.fromCharCode(code);
|
|
}
|
|
|
|
single = !(quotes === 'double' || (quotes === 'auto' && doubleQuotes < singleQuotes));
|
|
quote = single ? '\'' : '"';
|
|
|
|
if (!(single ? singleQuotes : doubleQuotes)) {
|
|
return quote + result + quote;
|
|
}
|
|
|
|
str = result;
|
|
result = quote;
|
|
|
|
for (i = 0, len = str.length; i < len; ++i) {
|
|
code = str.charCodeAt(i);
|
|
if ((code === 0x27 && single) || (code === 0x22 && !single)) { // ', "
|
|
result += '\\';
|
|
}
|
|
result += String.fromCharCode(code);
|
|
}
|
|
|
|
return result + quote;
|
|
}
|
|
|
|
|
|
function join (l, r) {
|
|
if (!l.length)
|
|
return r;
|
|
|
|
if (!r.length)
|
|
return l;
|
|
|
|
var lCp = l.charCodeAt(l.length - 1),
|
|
rCp = r.charCodeAt(0);
|
|
|
|
if (isIdentifierCh(lCp) && isIdentifierCh(rCp) ||
|
|
lCp === rCp && (lCp === 0x2B || lCp === 0x2D) || // + +, - -
|
|
lCp === 0x2F && rCp === 0x69) { // /re/ instanceof foo
|
|
return l + _.space + r;
|
|
}
|
|
|
|
else if (isWhitespace(lCp) || isWhitespace(rCp))
|
|
return l + r;
|
|
|
|
return l + _.optSpace + r;
|
|
}
|
|
|
|
function shiftIndent () {
|
|
var prevIndent = _.indent;
|
|
|
|
_.indent += _.indentUnit;
|
|
return prevIndent;
|
|
}
|
|
|
|
function adoptionPrefix ($stmt) {
|
|
if ($stmt.type === Syntax.BlockStatement)
|
|
return _.optSpace;
|
|
|
|
if ($stmt.type === Syntax.EmptyStatement)
|
|
return '';
|
|
|
|
return _.newline + _.indent + _.indentUnit;
|
|
}
|
|
|
|
function adoptionSuffix ($stmt) {
|
|
if ($stmt.type === Syntax.BlockStatement)
|
|
return _.optSpace;
|
|
|
|
return _.newline + _.indent;
|
|
}
|
|
|
|
//Subentities generators
|
|
function generateVerbatim ($expr, settings) {
|
|
var verbatim = $expr[extra.verbatim],
|
|
strVerbatim = typeof verbatim === 'string',
|
|
precedence = !strVerbatim &&
|
|
verbatim.precedence !== void 0 ? verbatim.precedence : Precedence.Sequence,
|
|
parenthesize = precedence < settings.precedence,
|
|
content = strVerbatim ? verbatim : verbatim.content,
|
|
chunks = content.split(/\r\n|\n/),
|
|
chunkCount = chunks.length;
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
_.js += chunks[0];
|
|
|
|
for (var i = 1; i < chunkCount; i++)
|
|
_.js += _.newline + _.indent + chunks[i];
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
}
|
|
|
|
function generateFunctionParams ($node) {
|
|
var $params = $node.params,
|
|
paramCount = $params.length,
|
|
lastParamIdx = paramCount - 1,
|
|
arrowFuncWithoutParentheses = $node.type === Syntax.ArrowFunctionExpression && paramCount === 1 &&
|
|
$params[0].type === Syntax.Identifier;
|
|
|
|
//NOTE: arg => { } case
|
|
if (arrowFuncWithoutParentheses)
|
|
_.js += $params[0].name;
|
|
|
|
else {
|
|
_.js += '(';
|
|
|
|
for (var i = 0; i < paramCount; ++i) {
|
|
var $param = $params[i];
|
|
|
|
if ($params[i].type === Syntax.Identifier)
|
|
_.js += $param.name;
|
|
|
|
else
|
|
ExprGen[$param.type]($param, Preset.e4);
|
|
|
|
if (i !== lastParamIdx)
|
|
_.js += ',' + _.optSpace;
|
|
}
|
|
|
|
_.js += ')';
|
|
}
|
|
}
|
|
|
|
function generateFunctionBody ($node) {
|
|
var $body = $node.body;
|
|
|
|
generateFunctionParams($node);
|
|
|
|
if ($node.type === Syntax.ArrowFunctionExpression)
|
|
_.js += _.optSpace + '=>';
|
|
|
|
if ($node.expression) {
|
|
_.js += _.optSpace;
|
|
|
|
var exprJs = exprToJs($body, Preset.e4);
|
|
|
|
if (exprJs.charAt(0) === '{')
|
|
exprJs = '(' + exprJs + ')';
|
|
|
|
_.js += exprJs;
|
|
}
|
|
|
|
else {
|
|
_.js += adoptionPrefix($body);
|
|
StmtGen[$body.type]($body, Preset.s8);
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------===------------------------------------------------------
|
|
// Syntactic entities generation presets
|
|
//-------------------------------------------------===------------------------------------------------------
|
|
|
|
var Preset = {
|
|
e1: function (allowIn) {
|
|
return {
|
|
precedence: Precedence.Assignment,
|
|
allowIn: allowIn,
|
|
allowCall: true,
|
|
allowUnparenthesizedNew: true
|
|
};
|
|
},
|
|
|
|
e2: function (allowIn) {
|
|
return {
|
|
precedence: Precedence.LogicalOR,
|
|
allowIn: allowIn,
|
|
allowCall: true,
|
|
allowUnparenthesizedNew: true
|
|
};
|
|
},
|
|
|
|
e3: {
|
|
precedence: Precedence.Call,
|
|
allowIn: true,
|
|
allowCall: true,
|
|
allowUnparenthesizedNew: false
|
|
},
|
|
|
|
e4: {
|
|
precedence: Precedence.Assignment,
|
|
allowIn: true,
|
|
allowCall: true,
|
|
allowUnparenthesizedNew: true
|
|
},
|
|
|
|
e5: {
|
|
precedence: Precedence.Sequence,
|
|
allowIn: true,
|
|
allowCall: true,
|
|
allowUnparenthesizedNew: true
|
|
},
|
|
|
|
e6: function (allowUnparenthesizedNew) {
|
|
return {
|
|
precedence: Precedence.New,
|
|
allowIn: true,
|
|
allowCall: false,
|
|
allowUnparenthesizedNew: allowUnparenthesizedNew
|
|
};
|
|
},
|
|
|
|
e7: {
|
|
precedence: Precedence.Unary,
|
|
allowIn: true,
|
|
allowCall: true,
|
|
allowUnparenthesizedNew: true
|
|
},
|
|
|
|
e8: {
|
|
precedence: Precedence.Postfix,
|
|
allowIn: true,
|
|
allowCall: true,
|
|
allowUnparenthesizedNew: true
|
|
},
|
|
|
|
e9: {
|
|
precedence: void 0,
|
|
allowIn: true,
|
|
allowCall: true,
|
|
allowUnparenthesizedNew: true
|
|
},
|
|
|
|
e10: {
|
|
precedence: Precedence.Call,
|
|
allowIn: true,
|
|
allowCall: true,
|
|
allowUnparenthesizedNew: true
|
|
},
|
|
|
|
e11: function (allowCall) {
|
|
return {
|
|
precedence: Precedence.Call,
|
|
allowIn: true,
|
|
allowCall: allowCall,
|
|
allowUnparenthesizedNew: false
|
|
};
|
|
},
|
|
|
|
e12: {
|
|
precedence: Precedence.Primary,
|
|
allowIn: false,
|
|
allowCall: false,
|
|
allowUnparenthesizedNew: true
|
|
},
|
|
|
|
e13: {
|
|
precedence: Precedence.Primary,
|
|
allowIn: true,
|
|
allowCall: true,
|
|
allowUnparenthesizedNew: true
|
|
},
|
|
|
|
|
|
e14: {
|
|
precedence: Precedence.Sequence,
|
|
allowIn: false,
|
|
allowCall: true,
|
|
allowUnparenthesizedNew: true
|
|
},
|
|
|
|
|
|
e15: function (allowCall) {
|
|
return {
|
|
precedence: Precedence.Sequence,
|
|
allowIn: true,
|
|
allowCall: allowCall,
|
|
allowUnparenthesizedNew: true
|
|
};
|
|
},
|
|
|
|
e16: function (precedence, allowIn) {
|
|
return {
|
|
precedence: precedence,
|
|
allowIn: allowIn,
|
|
allowCall: true,
|
|
allowUnparenthesizedNew: true
|
|
};
|
|
},
|
|
|
|
e17: function (allowIn) {
|
|
return {
|
|
precedence: Precedence.Call,
|
|
allowIn: allowIn,
|
|
allowCall: true,
|
|
allowUnparenthesizedNew: true
|
|
}
|
|
},
|
|
|
|
e18: function (allowIn) {
|
|
return {
|
|
precedence: Precedence.Assignment,
|
|
allowIn: allowIn,
|
|
allowCall: true,
|
|
allowUnparenthesizedNew: true
|
|
}
|
|
},
|
|
|
|
e19: {
|
|
precedence: Precedence.Sequence,
|
|
allowIn: true,
|
|
allowCall: true,
|
|
semicolonOptional: false
|
|
},
|
|
|
|
e20: {
|
|
precedence: Precedence.Await,
|
|
allowCall: true
|
|
},
|
|
|
|
s1: function (functionBody, semicolonOptional) {
|
|
return {
|
|
allowIn: true,
|
|
functionBody: false,
|
|
directiveContext: functionBody,
|
|
semicolonOptional: semicolonOptional
|
|
};
|
|
},
|
|
|
|
s2: {
|
|
allowIn: true,
|
|
functionBody: false,
|
|
directiveContext: false,
|
|
semicolonOptional: true
|
|
},
|
|
|
|
s3: function (allowIn) {
|
|
return {
|
|
allowIn: allowIn,
|
|
functionBody: false,
|
|
directiveContext: false,
|
|
semicolonOptional: false
|
|
};
|
|
},
|
|
|
|
s4: function (semicolonOptional) {
|
|
return {
|
|
allowIn: true,
|
|
functionBody: false,
|
|
directiveContext: false,
|
|
semicolonOptional: semicolonOptional
|
|
};
|
|
},
|
|
|
|
s5: function (semicolonOptional) {
|
|
return {
|
|
allowIn: true,
|
|
functionBody: false,
|
|
directiveContext: true,
|
|
semicolonOptional: semicolonOptional,
|
|
};
|
|
},
|
|
|
|
s6: {
|
|
allowIn: false,
|
|
functionBody: false,
|
|
directiveContext: false,
|
|
semicolonOptional: false
|
|
},
|
|
|
|
s7: {
|
|
allowIn: true,
|
|
functionBody: false,
|
|
directiveContext: false,
|
|
semicolonOptional: false
|
|
},
|
|
|
|
s8: {
|
|
allowIn: true,
|
|
functionBody: true,
|
|
directiveContext: false,
|
|
semicolonOptional: false
|
|
}
|
|
};
|
|
|
|
|
|
//-------------------------------------------------===-------------------------------------------------------
|
|
// Expressions
|
|
//-------------------------------------------------===-------------------------------------------------------
|
|
|
|
//Regular expressions
|
|
var FLOATING_OR_OCTAL_REGEXP = /[.eExX]|^0[0-9]+/,
|
|
LAST_DECIMAL_DIGIT_REGEXP = /[0-9]$/;
|
|
|
|
|
|
//Common expression generators
|
|
function isLogicalExpression(node) {
|
|
if (!node)
|
|
return false;
|
|
|
|
return node.type === Syntax.LogicalExpression;
|
|
}
|
|
|
|
function needParensForLogicalExpression (node, parent) {
|
|
switch (node.operator) {
|
|
case "||":
|
|
if (!isLogicalExpression(parent)) return false;
|
|
return parent.operator === "??" || parent.operator === "&&";
|
|
|
|
case "&&":
|
|
return isLogicalExpression(parent, {
|
|
operator: "??"
|
|
});
|
|
|
|
case "??":
|
|
return isLogicalExpression(parent) && parent.operator !== "??";
|
|
}
|
|
}
|
|
|
|
function generateLogicalOrBinaryExpression ($expr, settings, $parent) {
|
|
var op = $expr.operator,
|
|
precedence = BinaryPrecedence[$expr.operator],
|
|
parenthesize = precedence < settings.precedence,
|
|
allowIn = settings.allowIn || parenthesize,
|
|
operandGenSettings = Preset.e16(precedence, allowIn),
|
|
exprJs = exprToJs($expr.left, operandGenSettings, $expr);
|
|
|
|
parenthesize |= op === 'in' && !allowIn;
|
|
|
|
var needParens = needParensForLogicalExpression($expr, $parent);
|
|
|
|
if (parenthesize || needParens)
|
|
_.js += '(';
|
|
|
|
// 0x2F = '/'
|
|
if (exprJs.charCodeAt(exprJs.length - 1) === 0x2F && isIdentifierCh(op.charCodeAt(0)))
|
|
exprJs = exprJs + _.space + op;
|
|
|
|
else
|
|
exprJs = join(exprJs, op);
|
|
|
|
operandGenSettings.precedence++;
|
|
|
|
var rightJs = exprToJs($expr.right, operandGenSettings, $expr);
|
|
|
|
//NOTE: If '/' concats with '/' or `<` concats with `!--`, it is interpreted as comment start
|
|
if (op === '/' && rightJs.charAt(0) === '/' || op.slice(-1) === '<' && rightJs.slice(0, 3) === '!--')
|
|
exprJs += _.space + rightJs;
|
|
|
|
else
|
|
exprJs = join(exprJs, rightJs);
|
|
|
|
_.js += exprJs;
|
|
|
|
if (parenthesize || needParens)
|
|
_.js += ')';
|
|
}
|
|
|
|
function generateArrayPatternOrExpression ($expr) {
|
|
var $elems = $expr.elements,
|
|
elemCount = $elems.length;
|
|
|
|
if (elemCount) {
|
|
var lastElemIdx = elemCount - 1,
|
|
multiline = elemCount > 1,
|
|
prevIndent = shiftIndent(),
|
|
itemPrefix = _.newline + _.indent;
|
|
|
|
_.js += '[';
|
|
|
|
for (var i = 0; i < elemCount; i++) {
|
|
var $elem = $elems[i];
|
|
|
|
if (multiline)
|
|
_.js += itemPrefix;
|
|
|
|
if ($elem)
|
|
ExprGen[$elem.type]($elem, Preset.e4);
|
|
|
|
if (i !== lastElemIdx || !$elem)
|
|
_.js += ',';
|
|
}
|
|
|
|
_.indent = prevIndent;
|
|
|
|
if (multiline)
|
|
_.js += _.newline + _.indent;
|
|
|
|
_.js += ']';
|
|
}
|
|
|
|
else
|
|
_.js += '[]';
|
|
}
|
|
|
|
function generateGeneratorOrComprehensionExpression ($expr) {
|
|
//NOTE: GeneratorExpression should be parenthesized with (...), ComprehensionExpression with [...]
|
|
var $blocks = $expr.blocks,
|
|
$filter = $expr.filter,
|
|
isGenerator = $expr.type === Syntax.GeneratorExpression,
|
|
exprJs = isGenerator ? '(' : '[',
|
|
bodyJs = exprToJs($expr.body, Preset.e4);
|
|
|
|
if ($blocks) {
|
|
var prevIndent = shiftIndent(),
|
|
blockCount = $blocks.length;
|
|
|
|
for (var i = 0; i < blockCount; ++i) {
|
|
var blockJs = exprToJs($blocks[i], Preset.e5);
|
|
|
|
exprJs = i > 0 ? join(exprJs, blockJs) : (exprJs + blockJs);
|
|
}
|
|
|
|
_.indent = prevIndent;
|
|
}
|
|
|
|
if ($filter) {
|
|
var filterJs = exprToJs($filter, Preset.e5);
|
|
|
|
exprJs = join(exprJs, 'if' + _.optSpace);
|
|
exprJs = join(exprJs, '(' + filterJs + ')');
|
|
}
|
|
|
|
exprJs = join(exprJs, bodyJs);
|
|
exprJs += isGenerator ? ')' : ']';
|
|
|
|
_.js += exprJs;
|
|
}
|
|
|
|
|
|
//Expression raw generator dictionary
|
|
var ExprRawGen = {
|
|
SequenceExpression: function generateSequenceExpression ($expr, settings) {
|
|
var $children = $expr.expressions,
|
|
childrenCount = $children.length,
|
|
lastChildIdx = childrenCount - 1,
|
|
parenthesize = Precedence.Sequence < settings.precedence,
|
|
exprGenSettings = Preset.e1(settings.allowIn || parenthesize);
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
for (var i = 0; i < childrenCount; i++) {
|
|
var $child = $children[i];
|
|
|
|
ExprGen[$child.type]($child, exprGenSettings);
|
|
|
|
if (i !== lastChildIdx)
|
|
_.js += ',' + _.optSpace;
|
|
}
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
AssignmentExpression: function generateAssignmentExpression ($expr, settings) {
|
|
var $left = $expr.left,
|
|
$right = $expr.right,
|
|
parenthesize = Precedence.Assignment < settings.precedence,
|
|
allowIn = settings.allowIn || parenthesize;
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
ExprGen[$left.type]($left, Preset.e17(allowIn));
|
|
_.js += _.optSpace + $expr.operator + _.optSpace;
|
|
ExprGen[$right.type]($right, Preset.e18(allowIn));
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
AssignmentPattern: function generateAssignmentPattern ($node) {
|
|
var $fakeAssign = {
|
|
left: $node.left,
|
|
right: $node.right,
|
|
operator: '='
|
|
};
|
|
|
|
ExprGen.AssignmentExpression($fakeAssign, Preset.e4);
|
|
},
|
|
|
|
ArrowFunctionExpression: function generateArrowFunctionExpression ($expr, settings) {
|
|
var parenthesize = Precedence.ArrowFunction < settings.precedence;
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
if ($expr.async)
|
|
_.js += 'async ';
|
|
|
|
generateFunctionBody($expr);
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
AwaitExpression: function generateAwaitExpression ($expr, settings) {
|
|
var parenthesize = Precedence.Await < settings.precedence;
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
_.js += $expr.all ? 'await* ' : 'await ';
|
|
|
|
ExprGen[$expr.argument.type]($expr.argument, Preset.e20);
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
ConditionalExpression: function generateConditionalExpression ($expr, settings) {
|
|
var $test = $expr.test,
|
|
$conseq = $expr.consequent,
|
|
$alt = $expr.alternate,
|
|
parenthesize = Precedence.Conditional < settings.precedence,
|
|
allowIn = settings.allowIn || parenthesize,
|
|
testGenSettings = Preset.e2(allowIn),
|
|
branchGenSettings = Preset.e1(allowIn);
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
ExprGen[$test.type]($test, testGenSettings);
|
|
_.js += _.optSpace + '?' + _.optSpace;
|
|
ExprGen[$conseq.type]($conseq, branchGenSettings);
|
|
_.js += _.optSpace + ':' + _.optSpace;
|
|
ExprGen[$alt.type]($alt, branchGenSettings);
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
LogicalExpression: generateLogicalOrBinaryExpression,
|
|
|
|
BinaryExpression: generateLogicalOrBinaryExpression,
|
|
|
|
CallExpression: function generateCallExpression ($expr, settings) {
|
|
var $callee = $expr.callee,
|
|
$args = $expr['arguments'],
|
|
argCount = $args.length,
|
|
lastArgIdx = argCount - 1,
|
|
parenthesize = !settings.allowCall || Precedence.Call < settings.precedence;
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
ExprGen[$callee.type]($callee, Preset.e3);
|
|
|
|
if ($expr.optional)
|
|
_.js += '?.';
|
|
|
|
_.js += '(';
|
|
|
|
for (var i = 0; i < argCount; ++i) {
|
|
var $arg = $args[i];
|
|
|
|
ExprGen[$arg.type]($arg, Preset.e4);
|
|
|
|
if (i !== lastArgIdx)
|
|
_.js += ',' + _.optSpace;
|
|
}
|
|
|
|
_.js += ')';
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
NewExpression: function generateNewExpression ($expr, settings) {
|
|
var $args = $expr['arguments'],
|
|
parenthesize = Precedence.New < settings.precedence,
|
|
argCount = $args.length,
|
|
lastArgIdx = argCount - 1,
|
|
withCall = !settings.allowUnparenthesizedNew || parentheses || argCount > 0,
|
|
calleeJs = exprToJs($expr.callee, Preset.e6(!withCall));
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
_.js += join('new', calleeJs);
|
|
|
|
if (withCall) {
|
|
_.js += '(';
|
|
|
|
for (var i = 0; i < argCount; ++i) {
|
|
var $arg = $args[i];
|
|
|
|
ExprGen[$arg.type]($arg, Preset.e4);
|
|
|
|
if (i !== lastArgIdx)
|
|
_.js += ',' + _.optSpace;
|
|
}
|
|
|
|
_.js += ')';
|
|
}
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
MemberExpression: function generateMemberExpression ($expr, settings) {
|
|
var $obj = $expr.object,
|
|
$prop = $expr.property,
|
|
parenthesize = Precedence.Member < settings.precedence,
|
|
isNumObj = !$expr.computed && $obj.type === Syntax.Literal && typeof $obj.value === 'number';
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
if (isNumObj) {
|
|
|
|
//NOTE: When the following conditions are all true:
|
|
// 1. No floating point
|
|
// 2. Don't have exponents
|
|
// 3. The last character is a decimal digit
|
|
// 4. Not hexadecimal OR octal number literal
|
|
// then we should add a floating point.
|
|
|
|
var numJs = exprToJs($obj, Preset.e11(settings.allowCall)),
|
|
withPoint = LAST_DECIMAL_DIGIT_REGEXP.test(numJs) && !FLOATING_OR_OCTAL_REGEXP.test(numJs);
|
|
|
|
_.js += withPoint ? (numJs + '.') : numJs;
|
|
}
|
|
|
|
else
|
|
ExprGen[$obj.type]($obj, Preset.e11(settings.allowCall));
|
|
|
|
if ($expr.computed) {
|
|
if ($expr.optional)
|
|
_.js += '?.';
|
|
|
|
_.js += '[';
|
|
ExprGen[$prop.type]($prop, Preset.e15(settings.allowCall));
|
|
_.js += ']';
|
|
}
|
|
|
|
else
|
|
_.js += ($expr.optional ? '?.' : '.') + $prop.name;
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
UnaryExpression: function generateUnaryExpression ($expr, settings) {
|
|
var parenthesize = Precedence.Unary < settings.precedence,
|
|
op = $expr.operator,
|
|
argJs = exprToJs($expr.argument, Preset.e7);
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
//NOTE: delete, void, typeof
|
|
// get `typeof []`, not `typeof[]`
|
|
if (_.optSpace === '' || op.length > 2)
|
|
_.js += join(op, argJs);
|
|
|
|
else {
|
|
_.js += op;
|
|
|
|
//NOTE: Prevent inserting spaces between operator and argument if it is unnecessary
|
|
// like, `!cond`
|
|
var leftCp = op.charCodeAt(op.length - 1),
|
|
rightCp = argJs.charCodeAt(0);
|
|
|
|
// 0x2B = '+', 0x2D = '-'
|
|
if (leftCp === rightCp && (leftCp === 0x2B || leftCp === 0x2D) ||
|
|
isIdentifierCh(leftCp) && isIdentifierCh(rightCp)) {
|
|
_.js += _.space;
|
|
}
|
|
|
|
_.js += argJs;
|
|
}
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
YieldExpression: function generateYieldExpression ($expr, settings) {
|
|
var $arg = $expr.argument,
|
|
js = $expr.delegate ? 'yield*' : 'yield',
|
|
parenthesize = Precedence.Yield < settings.precedence;
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
if ($arg) {
|
|
var argJs = exprToJs($arg, Preset.e4);
|
|
|
|
js = join(js, argJs);
|
|
}
|
|
|
|
_.js += js;
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
UpdateExpression: function generateUpdateExpression ($expr, settings) {
|
|
var $arg = $expr.argument,
|
|
$op = $expr.operator,
|
|
prefix = $expr.prefix,
|
|
precedence = prefix ? Precedence.Unary : Precedence.Postfix,
|
|
parenthesize = precedence < settings.precedence;
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
if (prefix) {
|
|
_.js += $op;
|
|
ExprGen[$arg.type]($arg, Preset.e8);
|
|
|
|
}
|
|
|
|
else {
|
|
ExprGen[$arg.type]($arg, Preset.e8);
|
|
_.js += $op;
|
|
}
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
FunctionExpression: function generateFunctionExpression ($expr) {
|
|
var isGenerator = !!$expr.generator;
|
|
|
|
if ($expr.async)
|
|
_.js += 'async ';
|
|
|
|
_.js += isGenerator ? 'function*' : 'function';
|
|
|
|
if ($expr.id) {
|
|
_.js += isGenerator ? _.optSpace : _.space;
|
|
_.js += $expr.id.name;
|
|
}
|
|
else
|
|
_.js += _.optSpace;
|
|
|
|
generateFunctionBody($expr);
|
|
},
|
|
|
|
ExportBatchSpecifier: function generateExportBatchSpecifier () {
|
|
_.js += '*';
|
|
},
|
|
|
|
ArrayPattern: generateArrayPatternOrExpression,
|
|
|
|
ArrayExpression: generateArrayPatternOrExpression,
|
|
|
|
ClassExpression: function generateClassExpression ($expr) {
|
|
var $id = $expr.id,
|
|
$super = $expr.superClass,
|
|
$body = $expr.body,
|
|
exprJs = 'class';
|
|
|
|
if ($id) {
|
|
var idJs = exprToJs($id, Preset.e9);
|
|
|
|
exprJs = join(exprJs, idJs);
|
|
}
|
|
|
|
if ($super) {
|
|
var superJs = exprToJs($super, Preset.e4);
|
|
|
|
superJs = join('extends', superJs);
|
|
exprJs = join(exprJs, superJs);
|
|
}
|
|
|
|
_.js += exprJs + _.optSpace;
|
|
StmtGen[$body.type]($body, Preset.s2);
|
|
},
|
|
|
|
MetaProperty: function generateMetaProperty ($expr, settings) {
|
|
var $meta = $expr.meta,
|
|
$property = $expr.property,
|
|
parenthesize = Precedence.Member < settings.precedence;
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
_.js += (typeof $meta === "string" ? $meta : $meta.name) +
|
|
'.' + (typeof $property === "string" ? $property : $property.name);
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
MethodDefinition: function generateMethodDefinition ($expr) {
|
|
var exprJs = $expr['static'] ? 'static' + _.optSpace : '',
|
|
keyJs = exprToJs($expr.key, Preset.e5);
|
|
|
|
if ($expr.computed)
|
|
keyJs = '[' + keyJs + ']';
|
|
|
|
if ($expr.kind === 'get' || $expr.kind === 'set') {
|
|
keyJs = join($expr.kind, keyJs);
|
|
_.js += join(exprJs, keyJs);
|
|
}
|
|
|
|
else {
|
|
if ($expr.value.generator)
|
|
_.js += exprJs + '*' + keyJs;
|
|
else if ($expr.value.async)
|
|
_.js += exprJs + 'async ' + keyJs;
|
|
else
|
|
_.js += join(exprJs, keyJs);
|
|
}
|
|
|
|
generateFunctionBody($expr.value);
|
|
},
|
|
|
|
Property: function generateProperty ($expr) {
|
|
var $val = $expr.value,
|
|
$kind = $expr.kind,
|
|
keyJs = exprToJs($expr.key, Preset.e4);
|
|
|
|
if ($expr.computed)
|
|
keyJs = '[' + keyJs + ']';
|
|
|
|
if ($kind === 'get' || $kind === 'set') {
|
|
_.js += $kind + _.space + keyJs;
|
|
generateFunctionBody($val);
|
|
}
|
|
|
|
else {
|
|
if ($expr.shorthand)
|
|
_.js += keyJs;
|
|
|
|
else if ($expr.method) {
|
|
if ($val.generator)
|
|
keyJs = '*' + keyJs;
|
|
else if ($val.async)
|
|
keyJs = 'async ' + keyJs;
|
|
|
|
_.js += keyJs;
|
|
generateFunctionBody($val)
|
|
}
|
|
|
|
else {
|
|
_.js += keyJs + ':' + _.optSpace;
|
|
ExprGen[$val.type]($val, Preset.e4);
|
|
}
|
|
}
|
|
},
|
|
|
|
ObjectExpression: function generateObjectExpression ($expr) {
|
|
var $props = $expr.properties,
|
|
propCount = $props.length;
|
|
|
|
if (propCount) {
|
|
var lastPropIdx = propCount - 1,
|
|
prevIndent = shiftIndent();
|
|
|
|
_.js += '{';
|
|
|
|
for (var i = 0; i < propCount; i++) {
|
|
var $prop = $props[i],
|
|
propType = $prop.type || Syntax.Property;
|
|
|
|
_.js += _.newline + _.indent;
|
|
ExprGen[propType]($prop, Preset.e5);
|
|
|
|
if (i !== lastPropIdx)
|
|
_.js += ',';
|
|
}
|
|
|
|
_.indent = prevIndent;
|
|
_.js += _.newline + _.indent + '}';
|
|
}
|
|
|
|
else
|
|
_.js += '{}';
|
|
},
|
|
|
|
ObjectPattern: function generateObjectPattern ($expr) {
|
|
var $props = $expr.properties,
|
|
propCount = $props.length;
|
|
|
|
if (propCount) {
|
|
var lastPropIdx = propCount - 1,
|
|
multiline = false;
|
|
|
|
if (propCount === 1)
|
|
multiline = $props[0].value.type !== Syntax.Identifier;
|
|
|
|
else {
|
|
for (var i = 0; i < propCount; i++) {
|
|
if (!$props[i].shorthand) {
|
|
multiline = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
_.js += multiline ? ('{' + _.newline) : '{';
|
|
|
|
var prevIndent = shiftIndent(),
|
|
propSuffix = ',' + (multiline ? _.newline : _.optSpace);
|
|
|
|
for (var i = 0; i < propCount; i++) {
|
|
var $prop = $props[i];
|
|
|
|
if (multiline)
|
|
_.js += _.indent;
|
|
|
|
ExprGen[$prop.type]($prop, Preset.e5);
|
|
|
|
if (i !== lastPropIdx)
|
|
_.js += propSuffix;
|
|
}
|
|
|
|
_.indent = prevIndent;
|
|
_.js += multiline ? (_.newline + _.indent + '}') : '}';
|
|
}
|
|
else
|
|
_.js += '{}';
|
|
},
|
|
|
|
ThisExpression: function generateThisExpression () {
|
|
_.js += 'this';
|
|
},
|
|
|
|
Identifier: function generateIdentifier ($expr, precedence, flag) {
|
|
_.js += $expr.name;
|
|
},
|
|
|
|
ImportExpression: function generateImportExpression ($expr, settings) {
|
|
var parenthesize = Precedence.Call < settings.precedence;
|
|
var $source = $expr.source;
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
_.js += 'import(';
|
|
|
|
ExprGen[$source.type]($source, Preset.e4);
|
|
|
|
_.js += ')';
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
ImportSpecifier: function generateImportSpecifier ($expr) {
|
|
_.js += $expr.imported.name;
|
|
|
|
if ($expr.local)
|
|
_.js += _.space + 'as' + _.space + $expr.local.name;
|
|
},
|
|
|
|
ExportSpecifier: function generateImportOrExportSpecifier ($expr) {
|
|
_.js += $expr.local.name;
|
|
|
|
if ($expr.exported)
|
|
_.js += _.space + 'as' + _.space + $expr.exported.name;
|
|
},
|
|
|
|
ChainExpression: function generateChainExpression ($expr, settings) {
|
|
var parenthesize = Precedence.OptionalChaining < settings.precedence;
|
|
var $expression = $expr.expression;
|
|
|
|
settings = settings || {};
|
|
|
|
var newSettings = {
|
|
precedence: Precedence.OptionalChaining,
|
|
allowIn: settings.allowIn ,
|
|
allowCall: settings.allowCall,
|
|
|
|
allowUnparenthesizedNew: settings.allowUnparenthesizedNew
|
|
}
|
|
|
|
if (parenthesize) {
|
|
newSettings.allowCall = true;
|
|
_.js += '(';
|
|
}
|
|
|
|
ExprGen[$expression.type]($expression, newSettings);
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
Literal: function generateLiteral ($expr) {
|
|
if (extra.raw && $expr.raw !== void 0)
|
|
_.js += $expr.raw;
|
|
|
|
else if ($expr.value === null)
|
|
_.js += 'null';
|
|
|
|
else {
|
|
var valueType = typeof $expr.value;
|
|
|
|
if (valueType === 'string')
|
|
_.js += escapeString($expr.value);
|
|
|
|
else if (valueType === 'number')
|
|
_.js += generateNumber($expr.value);
|
|
|
|
else if (valueType === 'boolean')
|
|
_.js += $expr.value ? 'true' : 'false';
|
|
|
|
else
|
|
_.js += generateRegExp($expr.value);
|
|
}
|
|
},
|
|
|
|
GeneratorExpression: generateGeneratorOrComprehensionExpression,
|
|
|
|
ComprehensionExpression: generateGeneratorOrComprehensionExpression,
|
|
|
|
ComprehensionBlock: function generateComprehensionBlock ($expr) {
|
|
var $left = $expr.left,
|
|
leftJs = void 0,
|
|
rightJs = exprToJs($expr.right, Preset.e5);
|
|
|
|
if ($left.type === Syntax.VariableDeclaration)
|
|
leftJs = $left.kind + _.space + stmtToJs($left.declarations[0], Preset.s6);
|
|
|
|
else
|
|
leftJs = exprToJs($left, Preset.e10);
|
|
|
|
leftJs = join(leftJs, $expr.of ? 'of' : 'in');
|
|
|
|
_.js += 'for' + _.optSpace + '(' + join(leftJs, rightJs) + ')';
|
|
},
|
|
|
|
RestElement: function generateRestElement ($node) {
|
|
_.js += '...' + $node.argument.name;
|
|
},
|
|
|
|
SpreadElement: function generateSpreadElement ($expr) {
|
|
var $arg = $expr.argument;
|
|
|
|
_.js += '...';
|
|
ExprGen[$arg.type]($arg, Preset.e4);
|
|
},
|
|
|
|
TaggedTemplateExpression: function generateTaggedTemplateExpression ($expr, settings) {
|
|
var $tag = $expr.tag,
|
|
$quasi = $expr.quasi,
|
|
parenthesize = Precedence.TaggedTemplate < settings.precedence;
|
|
|
|
if (parenthesize)
|
|
_.js += '(';
|
|
|
|
ExprGen[$tag.type]($tag, Preset.e11(settings.allowCall));
|
|
ExprGen[$quasi.type]($quasi, Preset.e12);
|
|
|
|
if (parenthesize)
|
|
_.js += ')';
|
|
},
|
|
|
|
TemplateElement: function generateTemplateElement ($expr) {
|
|
//NOTE: Don't use "cooked". Since tagged template can use raw template
|
|
// representation. So if we do so, it breaks the script semantics.
|
|
_.js += $expr.value.raw;
|
|
},
|
|
|
|
TemplateLiteral: function generateTemplateLiteral ($expr) {
|
|
var $quasis = $expr.quasis,
|
|
$childExprs = $expr.expressions,
|
|
quasiCount = $quasis.length,
|
|
lastQuasiIdx = quasiCount - 1;
|
|
|
|
_.js += '`';
|
|
|
|
for (var i = 0; i < quasiCount; ++i) {
|
|
var $quasi = $quasis[i];
|
|
|
|
ExprGen[$quasi.type]($quasi, Preset.e13);
|
|
|
|
if (i !== lastQuasiIdx) {
|
|
var $childExpr = $childExprs[i];
|
|
|
|
_.js += '${' + _.optSpace;
|
|
ExprGen[$childExpr.type]($childExpr, Preset.e5);
|
|
_.js += _.optSpace + '}';
|
|
}
|
|
}
|
|
|
|
_.js += '`';
|
|
},
|
|
|
|
Super: function generateSuper () {
|
|
_.js += 'super';
|
|
}
|
|
};
|
|
|
|
|
|
//-------------------------------------------------===------------------------------------------------------
|
|
// Statements
|
|
//-------------------------------------------------===------------------------------------------------------
|
|
|
|
|
|
//Regular expressions
|
|
var EXPR_STMT_UNALLOWED_EXPR_REGEXP = /^{|^class(?:\s|{)|^(async )?function(?:\s|\*|\()/;
|
|
|
|
|
|
//Common statement generators
|
|
function generateTryStatementHandlers (stmtJs, $finalizer, handlers) {
|
|
var handlerCount = handlers.length,
|
|
lastHandlerIdx = handlerCount - 1;
|
|
|
|
for (var i = 0; i < handlerCount; ++i) {
|
|
var handlerJs = stmtToJs(handlers[i], Preset.s7);
|
|
|
|
stmtJs = join(stmtJs, handlerJs);
|
|
|
|
if ($finalizer || i !== lastHandlerIdx)
|
|
stmtJs += adoptionSuffix(handlers[i].body);
|
|
}
|
|
|
|
return stmtJs;
|
|
}
|
|
|
|
function generateForStatementIterator ($op, $stmt, settings) {
|
|
var $body = $stmt.body,
|
|
$left = $stmt.left,
|
|
bodySemicolonOptional = !semicolons && settings.semicolonOptional,
|
|
prevIndent1 = shiftIndent(),
|
|
awaitStr = $stmt.await ? ' await' : '',
|
|
stmtJs = 'for' + awaitStr + _.optSpace + '(';
|
|
|
|
if ($left.type === Syntax.VariableDeclaration) {
|
|
var prevIndent2 = shiftIndent();
|
|
|
|
stmtJs += $left.kind + _.space + stmtToJs($left.declarations[0], Preset.s6);
|
|
_.indent = prevIndent2;
|
|
}
|
|
|
|
else
|
|
stmtJs += exprToJs($left, Preset.e10);
|
|
|
|
stmtJs = join(stmtJs, $op);
|
|
|
|
var rightJs = exprToJs($stmt.right, Preset.e4);
|
|
|
|
stmtJs = join(stmtJs, rightJs) + ')';
|
|
|
|
_.indent = prevIndent1;
|
|
|
|
_.js += stmtJs + adoptionPrefix($body);
|
|
StmtGen[$body.type]($body, Preset.s4(bodySemicolonOptional));
|
|
}
|
|
|
|
|
|
//Statement generator dictionary
|
|
var StmtRawGen = {
|
|
BlockStatement: function generateBlockStatement ($stmt, settings) {
|
|
var $body = $stmt.body,
|
|
len = $body.length,
|
|
lastIdx = len - 1,
|
|
prevIndent = shiftIndent();
|
|
|
|
_.js += '{' + _.newline;
|
|
|
|
for (var i = 0; i < len; i++) {
|
|
var $item = $body[i];
|
|
|
|
_.js += _.indent;
|
|
StmtGen[$item.type]($item, Preset.s1(settings.functionBody, i === lastIdx));
|
|
_.js += _.newline;
|
|
}
|
|
|
|
_.indent = prevIndent;
|
|
_.js += _.indent + '}';
|
|
},
|
|
|
|
BreakStatement: function generateBreakStatement ($stmt, settings) {
|
|
if ($stmt.label)
|
|
_.js += 'break ' + $stmt.label.name;
|
|
|
|
else
|
|
_.js += 'break';
|
|
|
|
if (semicolons || !settings.semicolonOptional)
|
|
_.js += ';';
|
|
},
|
|
|
|
ContinueStatement: function generateContinueStatement ($stmt, settings) {
|
|
if ($stmt.label)
|
|
_.js += 'continue ' + $stmt.label.name;
|
|
|
|
else
|
|
_.js += 'continue';
|
|
|
|
if (semicolons || !settings.semicolonOptional)
|
|
_.js += ';';
|
|
},
|
|
|
|
ClassBody: function generateClassBody ($stmt) {
|
|
var $body = $stmt.body,
|
|
itemCount = $body.length,
|
|
lastItemIdx = itemCount - 1,
|
|
prevIndent = shiftIndent();
|
|
|
|
_.js += '{' + _.newline;
|
|
|
|
for (var i = 0; i < itemCount; i++) {
|
|
var $item = $body[i],
|
|
itemType = $item.type || Syntax.Property;
|
|
|
|
_.js += _.indent;
|
|
ExprGen[itemType]($item, Preset.e5);
|
|
|
|
if (i !== lastItemIdx)
|
|
_.js += _.newline;
|
|
}
|
|
|
|
_.indent = prevIndent;
|
|
_.js += _.newline + _.indent + '}';
|
|
},
|
|
|
|
ClassDeclaration: function generateClassDeclaration ($stmt) {
|
|
var $body = $stmt.body,
|
|
$super = $stmt.superClass,
|
|
js = 'class ' + $stmt.id.name;
|
|
|
|
if ($super) {
|
|
var superJs = exprToJs($super, Preset.e4);
|
|
|
|
js += _.space + join('extends', superJs);
|
|
}
|
|
|
|
_.js += js + _.optSpace;
|
|
StmtGen[$body.type]($body, Preset.s2);
|
|
},
|
|
|
|
DirectiveStatement: function generateDirectiveStatement ($stmt, settings) {
|
|
if (extra.raw && $stmt.raw)
|
|
_.js += $stmt.raw;
|
|
|
|
else
|
|
_.js += escapeDirective($stmt.directive);
|
|
|
|
if (semicolons || !settings.semicolonOptional)
|
|
_.js += ';';
|
|
},
|
|
|
|
DoWhileStatement: function generateDoWhileStatement ($stmt, settings) {
|
|
var $body = $stmt.body,
|
|
$test = $stmt.test,
|
|
bodyJs = adoptionPrefix($body) +
|
|
stmtToJs($body, Preset.s7) +
|
|
adoptionSuffix($body);
|
|
|
|
//NOTE: Because `do 42 while (cond)` is Syntax Error. We need semicolon.
|
|
var stmtJs = join('do', bodyJs);
|
|
|
|
_.js += join(stmtJs, 'while' + _.optSpace + '(');
|
|
ExprGen[$test.type]($test, Preset.e5);
|
|
_.js += ')';
|
|
|
|
if (semicolons || !settings.semicolonOptional)
|
|
_.js += ';';
|
|
},
|
|
|
|
CatchClause: function generateCatchClause ($stmt) {
|
|
var $param = $stmt.param,
|
|
$guard = $stmt.guard,
|
|
$body = $stmt.body,
|
|
prevIndent = shiftIndent();
|
|
|
|
_.js += 'catch' + _.optSpace;
|
|
|
|
if ($param) {
|
|
_.js += '(';
|
|
ExprGen[$param.type]($param, Preset.e5);
|
|
}
|
|
|
|
if ($guard) {
|
|
_.js += ' if ';
|
|
ExprGen[$guard.type]($guard, Preset.e5);
|
|
}
|
|
|
|
_.indent = prevIndent;
|
|
if ($param) {
|
|
_.js += ')';
|
|
}
|
|
|
|
_.js += adoptionPrefix($body);
|
|
StmtGen[$body.type]($body, Preset.s7);
|
|
},
|
|
|
|
DebuggerStatement: function generateDebuggerStatement ($stmt, settings) {
|
|
_.js += 'debugger';
|
|
|
|
if (semicolons || !settings.semicolonOptional)
|
|
_.js += ';';
|
|
},
|
|
|
|
EmptyStatement: function generateEmptyStatement () {
|
|
_.js += ';';
|
|
},
|
|
|
|
ExportAllDeclaration: function ($stmt, settings) {
|
|
StmtRawGen.ExportDeclaration($stmt, settings, true);
|
|
},
|
|
|
|
ExportDeclaration: function generateExportDeclaration ($stmt, settings, exportAll) {
|
|
var $specs = $stmt.specifiers,
|
|
$decl = $stmt.declaration,
|
|
withSemicolon = semicolons || !settings.semicolonOptional;
|
|
|
|
// export default AssignmentExpression[In] ;
|
|
if ($stmt['default']) {
|
|
var declJs = exprToJs($decl, Preset.e4);
|
|
|
|
_.js += join('export default', declJs);
|
|
|
|
if (withSemicolon)
|
|
_.js += ';';
|
|
}
|
|
|
|
// export * FromClause ;
|
|
// export ExportClause[NoReference] FromClause ;
|
|
// export ExportClause ;
|
|
else if ($specs || exportAll) {
|
|
var stmtJs = 'export';
|
|
|
|
if (exportAll)
|
|
stmtJs += _.optSpace + '*';
|
|
|
|
else if ($specs.length === 0)
|
|
stmtJs += _.optSpace + '{' + _.optSpace + '}';
|
|
|
|
else if ($specs[0].type === Syntax.ExportBatchSpecifier) {
|
|
var specJs = exprToJs($specs[0], Preset.e5);
|
|
|
|
stmtJs = join(stmtJs, specJs);
|
|
}
|
|
|
|
else {
|
|
var prevIndent = shiftIndent(),
|
|
specCount = $specs.length,
|
|
lastSpecIdx = specCount - 1;
|
|
|
|
stmtJs += _.optSpace + '{';
|
|
|
|
for (var i = 0; i < specCount; ++i) {
|
|
stmtJs += _.newline + _.indent;
|
|
stmtJs += exprToJs($specs[i], Preset.e5);
|
|
|
|
if (i !== lastSpecIdx)
|
|
stmtJs += ',';
|
|
}
|
|
|
|
_.indent = prevIndent;
|
|
stmtJs += _.newline + _.indent + '}';
|
|
}
|
|
|
|
if ($stmt.source) {
|
|
_.js += join(stmtJs, 'from' + _.optSpace);
|
|
ExprGen.Literal($stmt.source);
|
|
}
|
|
|
|
else
|
|
_.js += stmtJs;
|
|
|
|
if (withSemicolon)
|
|
_.js += ';';
|
|
}
|
|
|
|
// export VariableStatement
|
|
// export Declaration[Default]
|
|
else if ($decl) {
|
|
var declJs = stmtToJs($decl, Preset.s4(!withSemicolon));
|
|
|
|
_.js += join('export', declJs);
|
|
}
|
|
},
|
|
|
|
ExportNamedDeclaration: function ($stmt, settings) {
|
|
StmtRawGen.ExportDeclaration($stmt, settings);
|
|
},
|
|
|
|
ExpressionStatement: function generateExpressionStatement ($stmt, settings) {
|
|
var exprJs = exprToJs($stmt.expression, Preset.e5),
|
|
parenthesize = EXPR_STMT_UNALLOWED_EXPR_REGEXP.test(exprJs) ||
|
|
(directive &&
|
|
settings.directiveContext &&
|
|
$stmt.expression.type === Syntax.Literal &&
|
|
typeof $stmt.expression.value === 'string');
|
|
|
|
//NOTE: '{', 'function', 'class' are not allowed in expression statement.
|
|
// Therefore, they should be parenthesized.
|
|
if (parenthesize)
|
|
_.js += '(' + exprJs + ')';
|
|
|
|
else
|
|
_.js += exprJs;
|
|
|
|
if (semicolons || !settings.semicolonOptional)
|
|
_.js += ';';
|
|
},
|
|
|
|
ImportDeclaration: function generateImportDeclaration ($stmt, settings) {
|
|
var $specs = $stmt.specifiers,
|
|
stmtJs = 'import',
|
|
specCount = $specs.length;
|
|
|
|
//NOTE: If no ImportClause is present,
|
|
// this should be `import ModuleSpecifier` so skip `from`
|
|
// ModuleSpecifier is StringLiteral.
|
|
if (specCount) {
|
|
var hasBinding = !!$specs[0]['default'],
|
|
firstNamedIdx = hasBinding ? 1 : 0,
|
|
lastSpecIdx = specCount - 1;
|
|
|
|
// ImportedBinding
|
|
if (hasBinding)
|
|
stmtJs = join(stmtJs, $specs[0].id.name);
|
|
|
|
// NamedImports
|
|
if (firstNamedIdx < specCount) {
|
|
if (hasBinding)
|
|
stmtJs += ',';
|
|
|
|
stmtJs += _.optSpace + '{';
|
|
|
|
// import { ... } from "...";
|
|
if (firstNamedIdx === lastSpecIdx)
|
|
stmtJs += _.optSpace + exprToJs($specs[firstNamedIdx], Preset.e5) + _.optSpace;
|
|
|
|
else {
|
|
var prevIndent = shiftIndent();
|
|
|
|
// import {
|
|
// ...,
|
|
// ...,
|
|
// } from "...";
|
|
for (var i = firstNamedIdx; i < specCount; i++) {
|
|
stmtJs += _.newline + _.indent + exprToJs($specs[i], Preset.e5);
|
|
|
|
if (i !== lastSpecIdx)
|
|
stmtJs += ',';
|
|
}
|
|
|
|
_.indent = prevIndent;
|
|
stmtJs += _.newline + _.indent;
|
|
}
|
|
|
|
stmtJs += '}' + _.optSpace;
|
|
}
|
|
|
|
stmtJs = join(stmtJs, 'from')
|
|
}
|
|
|
|
_.js += stmtJs + _.optSpace;
|
|
ExprGen.Literal($stmt.source);
|
|
|
|
if (semicolons || !settings.semicolonOptional)
|
|
_.js += ';';
|
|
},
|
|
|
|
VariableDeclarator: function generateVariableDeclarator ($stmt, settings) {
|
|
var $id = $stmt.id,
|
|
$init = $stmt.init,
|
|
genSettings = Preset.e1(settings.allowIn);
|
|
|
|
if ($init) {
|
|
ExprGen[$id.type]($id, genSettings);
|
|
_.js += _.optSpace + '=' + _.optSpace;
|
|
ExprGen[$init.type]($init, genSettings, $stmt);
|
|
}
|
|
|
|
else {
|
|
if ($id.type === Syntax.Identifier)
|
|
_.js += $id.name;
|
|
|
|
else
|
|
ExprGen[$id.type]($id, genSettings);
|
|
}
|
|
},
|
|
|
|
VariableDeclaration: function generateVariableDeclaration ($stmt, settings) {
|
|
var $decls = $stmt.declarations,
|
|
len = $decls.length,
|
|
prevIndent = len > 1 ? shiftIndent() : _.indent,
|
|
declGenSettings = Preset.s3(settings.allowIn);
|
|
|
|
_.js += $stmt.kind;
|
|
|
|
for (var i = 0; i < len; i++) {
|
|
var $decl = $decls[i];
|
|
|
|
_.js += i === 0 ? _.space : (',' + _.optSpace);
|
|
StmtGen[$decl.type]($decl, declGenSettings);
|
|
}
|
|
|
|
if (semicolons || !settings.semicolonOptional)
|
|
_.js += ';';
|
|
|
|
_.indent = prevIndent;
|
|
},
|
|
|
|
ThrowStatement: function generateThrowStatement ($stmt, settings) {
|
|
var argJs = exprToJs($stmt.argument, Preset.e5);
|
|
|
|
_.js += join('throw', argJs);
|
|
|
|
if (semicolons || !settings.semicolonOptional)
|
|
_.js += ';';
|
|
},
|
|
|
|
TryStatement: function generateTryStatement ($stmt) {
|
|
var $block = $stmt.block,
|
|
$finalizer = $stmt.finalizer,
|
|
stmtJs = 'try' +
|
|
adoptionPrefix($block) +
|
|
stmtToJs($block, Preset.s7) +
|
|
adoptionSuffix($block);
|
|
|
|
var $handlers = $stmt.handlers || $stmt.guardedHandlers;
|
|
|
|
if ($handlers)
|
|
stmtJs = generateTryStatementHandlers(stmtJs, $finalizer, $handlers);
|
|
|
|
if ($stmt.handler) {
|
|
$handlers = isArray($stmt.handler) ? $stmt.handler : [$stmt.handler];
|
|
stmtJs = generateTryStatementHandlers(stmtJs, $finalizer, $handlers);
|
|
}
|
|
|
|
if ($finalizer) {
|
|
stmtJs = join(stmtJs, 'finally' + adoptionPrefix($finalizer));
|
|
stmtJs += stmtToJs($finalizer, Preset.s7);
|
|
}
|
|
|
|
_.js += stmtJs;
|
|
},
|
|
|
|
SwitchStatement: function generateSwitchStatement ($stmt) {
|
|
var $cases = $stmt.cases,
|
|
$discr = $stmt.discriminant,
|
|
prevIndent = shiftIndent();
|
|
|
|
_.js += 'switch' + _.optSpace + '(';
|
|
ExprGen[$discr.type]($discr, Preset.e5);
|
|
_.js += ')' + _.optSpace + '{' + _.newline;
|
|
_.indent = prevIndent;
|
|
|
|
if ($cases) {
|
|
var caseCount = $cases.length,
|
|
lastCaseIdx = caseCount - 1;
|
|
|
|
for (var i = 0; i < caseCount; i++) {
|
|
var $case = $cases[i];
|
|
|
|
_.js += _.indent;
|
|
StmtGen[$case.type]($case, Preset.s4(i === lastCaseIdx));
|
|
_.js += _.newline;
|
|
}
|
|
}
|
|
|
|
_.js += _.indent + '}';
|
|
},
|
|
|
|
SwitchCase: function generateSwitchCase ($stmt, settings) {
|
|
var $conseqs = $stmt.consequent,
|
|
$firstConseq = $conseqs[0],
|
|
$test = $stmt.test,
|
|
i = 0,
|
|
conseqSemicolonOptional = !semicolons && settings.semicolonOptional,
|
|
conseqCount = $conseqs.length,
|
|
lastConseqIdx = conseqCount - 1,
|
|
prevIndent = shiftIndent();
|
|
|
|
if ($test) {
|
|
var testJs = exprToJs($test, Preset.e5);
|
|
|
|
_.js += join('case', testJs) + ':';
|
|
}
|
|
|
|
else
|
|
_.js += 'default:';
|
|
|
|
|
|
if (conseqCount && $firstConseq.type === Syntax.BlockStatement) {
|
|
i++;
|
|
_.js += adoptionPrefix($firstConseq);
|
|
StmtGen[$firstConseq.type]($firstConseq, Preset.s7);
|
|
}
|
|
|
|
for (; i < conseqCount; i++) {
|
|
var $conseq = $conseqs[i],
|
|
semicolonOptional = i === lastConseqIdx && conseqSemicolonOptional;
|
|
|
|
_.js += _.newline + _.indent;
|
|
StmtGen[$conseq.type]($conseq, Preset.s4(semicolonOptional));
|
|
}
|
|
|
|
_.indent = prevIndent;
|
|
},
|
|
|
|
IfStatement: function generateIfStatement ($stmt, settings) {
|
|
var $conseq = $stmt.consequent,
|
|
$test = $stmt.test,
|
|
prevIndent = shiftIndent(),
|
|
semicolonOptional = !semicolons && settings.semicolonOptional;
|
|
|
|
_.js += 'if' + _.optSpace + '(';
|
|
ExprGen[$test.type]($test, Preset.e5);
|
|
_.js += ')';
|
|
_.indent = prevIndent;
|
|
_.js += adoptionPrefix($conseq);
|
|
|
|
if ($stmt.alternate) {
|
|
var conseq = stmtToJs($conseq, Preset.s7) + adoptionSuffix($conseq),
|
|
alt = stmtToJs($stmt.alternate, Preset.s4(semicolonOptional));
|
|
|
|
if ($stmt.alternate.type === Syntax.IfStatement)
|
|
alt = 'else ' + alt;
|
|
|
|
else
|
|
alt = join('else', adoptionPrefix($stmt.alternate) + alt);
|
|
|
|
_.js += join(conseq, alt);
|
|
}
|
|
|
|
else
|
|
StmtGen[$conseq.type]($conseq, Preset.s4(semicolonOptional));
|
|
},
|
|
|
|
ForStatement: function generateForStatement ($stmt, settings) {
|
|
var $init = $stmt.init,
|
|
$test = $stmt.test,
|
|
$body = $stmt.body,
|
|
$update = $stmt.update,
|
|
bodySemicolonOptional = !semicolons && settings.semicolonOptional,
|
|
prevIndent = shiftIndent();
|
|
|
|
_.js += 'for' + _.optSpace + '(';
|
|
|
|
if ($init) {
|
|
if ($init.type === Syntax.VariableDeclaration)
|
|
StmtGen[$init.type]($init, Preset.s6);
|
|
|
|
else {
|
|
ExprGen[$init.type]($init, Preset.e14);
|
|
_.js += ';';
|
|
}
|
|
}
|
|
|
|
else
|
|
_.js += ';';
|
|
|
|
if ($test) {
|
|
_.js += _.optSpace;
|
|
ExprGen[$test.type]($test, Preset.e5);
|
|
}
|
|
|
|
_.js += ';';
|
|
|
|
if ($update) {
|
|
_.js += _.optSpace;
|
|
ExprGen[$update.type]($update, Preset.e5);
|
|
}
|
|
|
|
_.js += ')';
|
|
_.indent = prevIndent;
|
|
_.js += adoptionPrefix($body);
|
|
StmtGen[$body.type]($body, Preset.s4(bodySemicolonOptional));
|
|
},
|
|
|
|
ForInStatement: function generateForInStatement ($stmt, settings) {
|
|
generateForStatementIterator('in', $stmt, settings);
|
|
},
|
|
|
|
ForOfStatement: function generateForOfStatement ($stmt, settings) {
|
|
generateForStatementIterator('of', $stmt, settings);
|
|
},
|
|
|
|
LabeledStatement: function generateLabeledStatement ($stmt, settings) {
|
|
var $body = $stmt.body,
|
|
bodySemicolonOptional = !semicolons && settings.semicolonOptional,
|
|
prevIndent = _.indent;
|
|
|
|
_.js += $stmt.label.name + ':' + adoptionPrefix($body);
|
|
|
|
if ($body.type !== Syntax.BlockStatement)
|
|
prevIndent = shiftIndent();
|
|
|
|
StmtGen[$body.type]($body, Preset.s4(bodySemicolonOptional));
|
|
_.indent = prevIndent;
|
|
},
|
|
|
|
ModuleDeclaration: function generateModuleDeclaration ($stmt, settings) {
|
|
_.js += 'module' + _.space + $stmt.id.name + _.space + 'from' + _.optSpace;
|
|
|
|
ExprGen.Literal($stmt.source);
|
|
|
|
if (semicolons || !settings.semicolonOptional)
|
|
_.js += ';';
|
|
},
|
|
|
|
Program: function generateProgram ($stmt) {
|
|
var $body = $stmt.body,
|
|
len = $body.length,
|
|
lastIdx = len - 1;
|
|
|
|
if (safeConcatenation && len > 0)
|
|
_.js += '\n';
|
|
|
|
for (var i = 0; i < len; i++) {
|
|
var $item = $body[i];
|
|
|
|
_.js += _.indent;
|
|
StmtGen[$item.type]($item, Preset.s5(!safeConcatenation && i === lastIdx));
|
|
|
|
if (i !== lastIdx)
|
|
_.js += _.newline;
|
|
}
|
|
},
|
|
|
|
FunctionDeclaration: function generateFunctionDeclaration ($stmt) {
|
|
var isGenerator = !!$stmt.generator;
|
|
|
|
if ($stmt.async)
|
|
_.js += 'async ';
|
|
|
|
_.js += isGenerator ? ('function*' + _.optSpace) : ('function' + _.space );
|
|
_.js += $stmt.id.name;
|
|
generateFunctionBody($stmt);
|
|
},
|
|
|
|
ReturnStatement: function generateReturnStatement ($stmt, settings) {
|
|
var $arg = $stmt.argument;
|
|
|
|
if ($arg) {
|
|
var argJs = exprToJs($arg, Preset.e5);
|
|
|
|
_.js += join('return', argJs);
|
|
}
|
|
|
|
else
|
|
_.js += 'return';
|
|
|
|
if (semicolons || !settings.semicolonOptional)
|
|
_.js += ';';
|
|
},
|
|
|
|
WhileStatement: function generateWhileStatement ($stmt, settings) {
|
|
var $body = $stmt.body,
|
|
$test = $stmt.test,
|
|
bodySemicolonOptional = !semicolons && settings.semicolonOptional,
|
|
prevIndent = shiftIndent();
|
|
|
|
_.js += 'while' + _.optSpace + '(';
|
|
ExprGen[$test.type]($test, Preset.e5);
|
|
_.js += ')';
|
|
_.indent = prevIndent;
|
|
|
|
_.js += adoptionPrefix($body);
|
|
StmtGen[$body.type]($body, Preset.s4(bodySemicolonOptional));
|
|
},
|
|
|
|
WithStatement: function generateWithStatement ($stmt, settings) {
|
|
var $body = $stmt.body,
|
|
$obj = $stmt.object,
|
|
bodySemicolonOptional = !semicolons && settings.semicolonOptional,
|
|
prevIndent = shiftIndent();
|
|
|
|
_.js += 'with' + _.optSpace + '(';
|
|
ExprGen[$obj.type]($obj, Preset.e5);
|
|
_.js += ')';
|
|
_.indent = prevIndent;
|
|
_.js += adoptionPrefix($body);
|
|
StmtGen[$body.type]($body, Preset.s4(bodySemicolonOptional));
|
|
}
|
|
};
|
|
|
|
function generateStatement ($stmt, option) {
|
|
StmtGen[$stmt.type]($stmt, option);
|
|
}
|
|
|
|
//CodeGen
|
|
//-----------------------------------------------------------------------------------
|
|
function exprToJs ($expr, settings, $parent) {
|
|
var savedJs = _.js;
|
|
_.js = '';
|
|
|
|
ExprGen[$expr.type]($expr, settings, $parent);
|
|
|
|
var src = _.js;
|
|
_.js = savedJs;
|
|
|
|
return src;
|
|
}
|
|
|
|
function stmtToJs ($stmt, settings) {
|
|
var savedJs = _.js;
|
|
_.js = '';
|
|
|
|
StmtGen[$stmt.type]($stmt, settings);
|
|
|
|
var src = _.js;
|
|
_.js = savedJs;
|
|
|
|
return src;
|
|
}
|
|
|
|
function run ($node) {
|
|
_.js = '';
|
|
|
|
if (StmtGen[$node.type])
|
|
StmtGen[$node.type]($node, Preset.s7);
|
|
|
|
else
|
|
ExprGen[$node.type]($node, Preset.e19);
|
|
|
|
return _.js;
|
|
}
|
|
|
|
function wrapExprGen (gen) {
|
|
return function ($expr, settings) {
|
|
if (extra.verbatim && $expr.hasOwnProperty(extra.verbatim))
|
|
generateVerbatim($expr, settings);
|
|
|
|
else
|
|
gen($expr, settings);
|
|
}
|
|
}
|
|
|
|
function createExprGenWithExtras () {
|
|
var gens = {};
|
|
|
|
for (var key in ExprRawGen) {
|
|
if (ExprRawGen.hasOwnProperty(key))
|
|
gens[key] = wrapExprGen(ExprRawGen[key]);
|
|
}
|
|
|
|
return gens;
|
|
}
|
|
|
|
|
|
//Strings
|
|
var _ = {
|
|
js: '',
|
|
newline: '\n',
|
|
optSpace: ' ',
|
|
space: ' ',
|
|
indentUnit: ' ',
|
|
indent: ''
|
|
};
|
|
|
|
|
|
//Generators
|
|
var ExprGen = void 0,
|
|
StmtGen = StmtRawGen;
|
|
|
|
|
|
exports.generate = function ($node, options) {
|
|
var defaultOptions = getDefaultOptions(), result, pair;
|
|
|
|
if (options != null) {
|
|
//NOTE: Obsolete options
|
|
//
|
|
// `options.indent`
|
|
// `options.base`
|
|
//
|
|
// Instead of them, we can use `option.format.indent`.
|
|
if (typeof options.indent === 'string') {
|
|
defaultOptions.format.indent.style = options.indent;
|
|
}
|
|
if (typeof options.base === 'number') {
|
|
defaultOptions.format.indent.base = options.base;
|
|
}
|
|
options = updateDeeply(defaultOptions, options);
|
|
_.indentUnit = options.format.indent.style;
|
|
if (typeof options.base === 'string') {
|
|
_.indent = options.base;
|
|
}
|
|
else {
|
|
_.indent = stringRepeat(_.indentUnit, options.format.indent.base);
|
|
}
|
|
}
|
|
else {
|
|
options = defaultOptions;
|
|
_.indentUnit = options.format.indent.style;
|
|
_.indent = stringRepeat(_.indentUnit, options.format.indent.base);
|
|
}
|
|
json = options.format.json;
|
|
renumber = options.format.renumber;
|
|
hexadecimal = json ? false : options.format.hexadecimal;
|
|
quotes = json ? 'double' : options.format.quotes;
|
|
escapeless = options.format.escapeless;
|
|
|
|
_.newline = options.format.newline;
|
|
_.optSpace = options.format.space;
|
|
|
|
if (options.format.compact)
|
|
_.newline = _.optSpace = _.indentUnit = _.indent = '';
|
|
|
|
_.space = _.optSpace ? _.optSpace : ' ';
|
|
parentheses = options.format.parentheses;
|
|
semicolons = options.format.semicolons;
|
|
safeConcatenation = options.format.safeConcatenation;
|
|
directive = options.directive;
|
|
parse = json ? null : options.parse;
|
|
extra = options;
|
|
|
|
if (extra.verbatim)
|
|
ExprGen = createExprGenWithExtras();
|
|
|
|
else
|
|
ExprGen = ExprRawGen;
|
|
|
|
return run($node);
|
|
};
|