diff --git a/js/lib/beautify.js b/js/lib/beautify.js index 18061353d..1cbedb042 100644 --- a/js/lib/beautify.js +++ b/js/lib/beautify.js @@ -248,10 +248,10 @@ module.exports = js_beautify; SOFTWARE. */ -var mergeOpts = __webpack_require__ (2).mergeOpts; -var acorn = __webpack_require__ (3); -var Output = __webpack_require__ (4).Output; -var Tokenizer = __webpack_require__ (5).Tokenizer; +var mergeOpts = __webpack_require__(2).mergeOpts; +var acorn = __webpack_require__(3); +var Output = __webpack_require__(4).Output; +var Tokenizer = __webpack_require__(5).Tokenizer; function remove_redundant_indentation(output, frame) { // This implementation is effective but has some issues: @@ -305,7 +305,7 @@ function generateMapFromStrings(list) { function sanitizeOperatorPosition(opPosition) { opPosition = opPosition || OPERATOR_POSITION.before_newline; - if (!in_array (opPosition, validPositionValues)) { + if (!in_array(opPosition, validPositionValues)) { throw new Error("Invalid Option Value: The option 'operator_position' must be one of the following values\n" + validPositionValues + "\nYou passed in: '" + opPosition + "'"); @@ -317,7 +317,7 @@ function sanitizeOperatorPosition(opPosition) { var validPositionValues = ['before-newline', 'after-newline', 'preserve-newline']; // Generate map from array -var OPERATOR_POSITION = generateMapFromStrings (validPositionValues); +var OPERATOR_POSITION = generateMapFromStrings(validPositionValues); var OPERATOR_POSITION_BEFORE_OR_PRESERVE = [OPERATOR_POSITION.before_newline, OPERATOR_POSITION.preserve_newline]; @@ -404,7 +404,7 @@ function Beautifier(js_source_text, options) { // Allow the setting of language/file-type specific options // with inheritance of overall settings - options = mergeOpts (options, 'js'); + options = mergeOpts(options, 'js'); opt = {}; @@ -432,13 +432,13 @@ function Beautifier(js_source_text, options) { } } - opt.indent_size = options.indent_size ? parseInt (options.indent_size, 10) : 4; + opt.indent_size = options.indent_size ? parseInt(options.indent_size, 10) : 4; opt.indent_char = options.indent_char ? options.indent_char : ' '; opt.eol = options.eol ? options.eol : 'auto'; opt.preserve_newlines = (options.preserve_newlines === undefined) ? true : options.preserve_newlines; opt.unindent_chained_methods = (options.unindent_chained_methods === undefined) ? false : options.unindent_chained_methods; opt.break_chained_methods = (options.break_chained_methods === undefined) ? false : options.break_chained_methods; - opt.max_preserve_newlines = (options.max_preserve_newlines === undefined) ? 0 : parseInt (options.max_preserve_newlines, 10); + opt.max_preserve_newlines = (options.max_preserve_newlines === undefined) ? 0 : parseInt(options.max_preserve_newlines, 10); opt.space_in_paren = (options.space_in_paren === undefined) ? false : options.space_in_paren; opt.space_in_empty_paren = (options.space_in_empty_paren === undefined) ? false : options.space_in_empty_paren; opt.jslint_happy = (options.jslint_happy === undefined) ? false : options.jslint_happy; @@ -447,11 +447,11 @@ function Beautifier(js_source_text, options) { opt.keep_array_indentation = (options.keep_array_indentation === undefined) ? false : options.keep_array_indentation; opt.space_before_conditional = (options.space_before_conditional === undefined) ? true : options.space_before_conditional; opt.unescape_strings = (options.unescape_strings === undefined) ? false : options.unescape_strings; - opt.wrap_line_length = (options.wrap_line_length === undefined) ? 0 : parseInt (options.wrap_line_length, 10); + opt.wrap_line_length = (options.wrap_line_length === undefined) ? 0 : parseInt(options.wrap_line_length, 10); opt.e4x = (options.e4x === undefined) ? false : options.e4x; opt.end_with_newline = (options.end_with_newline === undefined) ? false : options.end_with_newline; opt.comma_first = (options.comma_first === undefined) ? false : options.comma_first; - opt.operator_position = sanitizeOperatorPosition (options.operator_position); + opt.operator_position = sanitizeOperatorPosition(options.operator_position); // For testing of beautify ignore:start directive opt.test_output_raw = (options.test_output_raw === undefined) ? false : options.test_output_raw; @@ -511,7 +511,7 @@ function Beautifier(js_source_text, options) { // most full parsers would die, but the beautifier gracefully falls back to // MODE.BlockStatement and continues on. flag_store = []; - set_mode (MODE.BlockStatement); + set_mode(MODE.BlockStatement); this.beautify = function() { @@ -521,7 +521,7 @@ function Beautifier(js_source_text, options) { tokens = tokenizer.tokenize(); token_pos = 0; - current_token = get_token (); + current_token = get_token(); while (current_token) { handlers[current_token.type](); @@ -530,7 +530,7 @@ function Beautifier(js_source_text, options) { flags.last_text = current_token.text; token_pos += 1; - current_token = get_token (); + current_token = get_token(); } sweet_code = output.get_code(opt.end_with_newline, opt.eol); @@ -540,7 +540,7 @@ function Beautifier(js_source_text, options) { function handle_whitespace_and_comments(local_token, preserve_statement_flags) { var newlines = local_token.newlines; - var keep_whitespace = opt.keep_array_indentation && is_array (flags.mode); + var keep_whitespace = opt.keep_array_indentation && is_array(flags.mode); var temp_token = current_token; for (var h = 0; h < local_token.comments_before.length; h++) { @@ -548,14 +548,14 @@ function Beautifier(js_source_text, options) { // Just continue formatting and the behavior should be logical. // Also ignore unknown tokens. Again, this should result in better behavior. current_token = local_token.comments_before[h]; - handle_whitespace_and_comments (current_token, preserve_statement_flags); + handle_whitespace_and_comments(current_token, preserve_statement_flags); handlers[current_token.type](preserve_statement_flags); } current_token = temp_token; if (keep_whitespace) { for (var i = 0; i < newlines; i += 1) { - print_newline (i > 0, preserve_statement_flags); + print_newline(i > 0, preserve_statement_flags); } } else { if (opt.max_preserve_newlines && newlines > opt.max_preserve_newlines) { @@ -564,9 +564,9 @@ function Beautifier(js_source_text, options) { if (opt.preserve_newlines) { if (local_token.newlines > 1) { - print_newline (false, preserve_statement_flags); + print_newline(false, preserve_statement_flags); for (var j = 1; j < newlines; j += 1) { - print_newline (true, preserve_statement_flags); + print_newline(true, preserve_statement_flags); } } } @@ -604,21 +604,21 @@ function Beautifier(js_source_text, options) { } var shouldPreserveOrForce = (opt.preserve_newlines && current_token.wanted_newline) || force_linewrap; - var operatorLogicApplies = in_array (flags.last_text, tokenizer.positionable_operators) || in_array (current_token.text, tokenizer.positionable_operators); + var operatorLogicApplies = in_array(flags.last_text, tokenizer.positionable_operators) || in_array(current_token.text, tokenizer.positionable_operators); if (operatorLogicApplies) { var shouldPrintOperatorNewline = ( - in_array (flags.last_text, tokenizer.positionable_operators) && - in_array (opt.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE) + in_array(flags.last_text, tokenizer.positionable_operators) && + in_array(opt.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE) ) || - in_array (current_token.text, tokenizer.positionable_operators); + in_array(current_token.text, tokenizer.positionable_operators); shouldPreserveOrForce = shouldPreserveOrForce && shouldPrintOperatorNewline; } if (shouldPreserveOrForce) { - print_newline (false, true); + print_newline(false, true); } else if (opt.wrap_line_length) { - if (last_type === 'TK_RESERVED' && in_array (flags.last_text, newline_restricted_tokens)) { + if (last_type === 'TK_RESERVED' && in_array(flags.last_text, newline_restricted_tokens)) { // These tokens should never have a newline inserted // between them and the following expression. return; @@ -626,7 +626,7 @@ function Beautifier(js_source_text, options) { var proposed_line_length = output.current_line.get_character_count() + current_token.text.length + (output.space_before_token ? 1 : 0); if (proposed_line_length >= opt.wrap_line_length) { - print_newline (false, true); + print_newline(false, true); } } } @@ -634,11 +634,11 @@ function Beautifier(js_source_text, options) { function print_newline(force_newline, preserve_statement_flags) { if (!preserve_statement_flags) { if (flags.last_text !== ';' && flags.last_text !== ',' && flags.last_text !== '=' && (last_type !== 'TK_OPERATOR' || flags.last_text === '--' || flags.last_text === '++')) { - var next_token = get_token (1); + var next_token = get_token(1); while (flags.mode === MODE.Statement && !(flags.if_block && next_token && next_token.type === 'TK_RESERVED' && next_token.text === 'else') && !flags.do_block) { - restore_mode (); + restore_mode(); } } } @@ -650,7 +650,7 @@ function Beautifier(js_source_text, options) { function print_token_line_indentation() { if (output.just_added_newline()) { - if (opt.keep_array_indentation && is_array (flags.mode) && current_token.wanted_newline) { + if (opt.keep_array_indentation && is_array(flags.mode) && current_token.wanted_newline) { output.current_line.push(current_token.whitespace_before); output.space_before_token = false; } else if (output.set_indent(flags.indentation_level)) { @@ -679,14 +679,14 @@ function Beautifier(js_source_text, options) { } // add the comma in front of the next token - print_token_line_indentation (); + print_token_line_indentation(); output.add_token(','); output.space_before_token = true; } } printable_token = printable_token || current_token.text; - print_token_line_indentation (); + print_token_line_indentation(); output.add_token(printable_token); } @@ -707,10 +707,10 @@ function Beautifier(js_source_text, options) { flag_store.push(flags); previous_flags = flags; } else { - previous_flags = create_flags (null, mode); + previous_flags = create_flags(null, mode); } - flags = create_flags (previous_flags, mode); + flags = create_flags(previous_flags, mode); } function is_array(mode) { @@ -726,21 +726,21 @@ function Beautifier(js_source_text, options) { previous_flags = flags; flags = flag_store.pop(); if (previous_flags.mode === MODE.Statement) { - remove_redundant_indentation (output, previous_flags); + remove_redundant_indentation(output, previous_flags); } } } function start_of_object_property() { return flags.parent.mode === MODE.ObjectLiteral && flags.mode === MODE.Statement && ( - (flags.last_text === ':' && flags.ternary_depth === 0) || (last_type === 'TK_RESERVED' && in_array (flags.last_text, ['get', 'set']))); + (flags.last_text === ':' && flags.ternary_depth === 0) || (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['get', 'set']))); } function start_of_statement() { if ( - (last_type === 'TK_RESERVED' && in_array (flags.last_text, ['var', 'let', 'const']) && current_token.type === 'TK_WORD') || + (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['var', 'let', 'const']) && current_token.type === 'TK_WORD') || (last_type === 'TK_RESERVED' && flags.last_text === 'do') || - (last_type === 'TK_RESERVED' && in_array (flags.last_text, newline_restricted_tokens) && !current_token.wanted_newline) || + (last_type === 'TK_RESERVED' && in_array(flags.last_text, newline_restricted_tokens) && !current_token.wanted_newline) || (last_type === 'TK_RESERVED' && flags.last_text === 'else' && !(current_token.type === 'TK_RESERVED' && current_token.text === 'if' && !current_token.comments_before.length)) || (last_type === 'TK_END_EXPR' && (previous_flags.mode === MODE.ForInitializer || previous_flags.mode === MODE.Conditional)) || @@ -748,22 +748,24 @@ function Beautifier(js_source_text, options) { !flags.in_case && !(current_token.text === '--' || current_token.text === '++') && last_last_text !== 'function' && - current_token.type !== 'TK_WORD' && current_token.type !== 'TK_RESERVED') || + current_token.type !== 'TK_WORD' && + current_token.type !== 'TK_RESERVED' && + current_token.type !== 'TK_START_EXPR') || (flags.mode === MODE.ObjectLiteral && ( - (flags.last_text === ':' && flags.ternary_depth === 0) || (last_type === 'TK_RESERVED' && in_array (flags.last_text, ['get', 'set'])))) + (flags.last_text === ':' && flags.ternary_depth === 0) || (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['get', 'set'])))) ) { - set_mode (MODE.Statement); - indent (); + set_mode(MODE.Statement); + indent(); - handle_whitespace_and_comments (current_token, true); + handle_whitespace_and_comments(current_token, true); // Issue #276: // If starting a new statement with [if, for, while, do], push to a new line. // if (a) if (b) if(c) d(); else e(); else f(); - if (!start_of_object_property ()) { - allow_wrap_or_preserved_newline ( - current_token.type === 'TK_RESERVED' && in_array (current_token.text, ['do', 'for', 'if', 'while'])); + if (!start_of_object_property()) { + allow_wrap_or_preserved_newline( + current_token.type === 'TK_RESERVED' && in_array(current_token.text, ['do', 'for', 'if', 'while'])); } return true; @@ -773,7 +775,7 @@ function Beautifier(js_source_text, options) { function all_lines_start_with(lines, c) { for (var i = 0; i < lines.length; i++) { - var line = trim (lines[i]); + var line = trim(lines[i]); if (line.charAt(0) !== c) { return false; } @@ -806,8 +808,8 @@ function Beautifier(js_source_text, options) { function handle_start_expr() { // The conditional starts the statement if appropriate. - if (!start_of_statement ()) { - handle_whitespace_and_comments (current_token); + if (!start_of_statement()) { + handle_whitespace_and_comments(current_token); } var next_mode = MODE.Expression; @@ -816,12 +818,12 @@ function Beautifier(js_source_text, options) { if (last_type === 'TK_WORD' || flags.last_text === ')') { // this is array index specifier, break immediately // a[x], fn()[x] - if (last_type === 'TK_RESERVED' && in_array (flags.last_text, tokenizer.line_starters)) { + if (last_type === 'TK_RESERVED' && in_array(flags.last_text, tokenizer.line_starters)) { output.space_before_token = true; } - set_mode (next_mode); - print_token (); - indent (); + set_mode(next_mode); + print_token(); + indent(); if (opt.space_in_paren) { output.space_before_token = true; } @@ -829,18 +831,18 @@ function Beautifier(js_source_text, options) { } next_mode = MODE.ArrayLiteral; - if (is_array (flags.mode)) { + if (is_array(flags.mode)) { if (flags.last_text === '[' || (flags.last_text === ',' && (last_last_text === ']' || last_last_text === '}'))) { // ], [ goes to new line // }, [ goes to new line if (!opt.keep_array_indentation) { - print_newline (); + print_newline(); } } } - if (!in_array (last_type, ['TK_START_EXPR', 'TK_END_EXPR', 'TK_WORD', 'TK_OPERATOR'])) { + if (!in_array(last_type, ['TK_START_EXPR', 'TK_END_EXPR', 'TK_WORD', 'TK_OPERATOR'])) { output.space_before_token = true; } } else { @@ -848,23 +850,23 @@ function Beautifier(js_source_text, options) { if (flags.last_text === 'for') { output.space_before_token = opt.space_before_conditional; next_mode = MODE.ForInitializer; - } else if (in_array (flags.last_text, ['if', 'while'])) { + } else if (in_array(flags.last_text, ['if', 'while'])) { output.space_before_token = opt.space_before_conditional; next_mode = MODE.Conditional; - } else if (in_array (flags.last_word, ['await', 'async'])) { + } else if (in_array(flags.last_word, ['await', 'async'])) { // Should be a space between await and an IIFE, or async and an arrow function output.space_before_token = true; } else if (flags.last_text === 'import' && current_token.whitespace_before === '') { output.space_before_token = false; - } else if (in_array (flags.last_text, tokenizer.line_starters) || flags.last_text === 'catch') { + } else if (in_array(flags.last_text, tokenizer.line_starters) || flags.last_text === 'catch') { output.space_before_token = true; } } else if (last_type === 'TK_EQUALS' || last_type === 'TK_OPERATOR') { // Support of this kind of newline preservation. // a = (b && // (c || d)); - if (!start_of_object_property ()) { - allow_wrap_or_preserved_newline (); + if (!start_of_object_property()) { + allow_wrap_or_preserved_newline(); } } else if (last_type === 'TK_WORD') { output.space_before_token = false; @@ -873,7 +875,7 @@ function Beautifier(js_source_text, options) { // a.b('c', // () => d.e // ) - allow_wrap_or_preserved_newline (); + allow_wrap_or_preserved_newline(); } // function() vs function () @@ -896,12 +898,13 @@ function Beautifier(js_source_text, options) { // data () {} // } if (current_token.text === '(') { - if (last_type === 'TK_RESERVED' && in_array (flags.last_word, ['get', 'set'])) { + if (last_type === 'TK_RESERVED' && in_array(flags.last_word, ['get', 'set'])) { output.space_before_token = opt.space_after_function; } if (last_type === 'TK_WORD' && tokens[token_pos - 2] && - !in_array (tokens[token_pos - 2].type, ['TK_DOT', 'TK_RESERVED'])) { + !in_array(tokens[token_pos - 2].type, ['TK_DOT', 'TK_RESERVED']) && + (previous_flags.parent.mode !== 'Statement' || previous_flags.parent.mode !== 'Expression')) { output.space_before_token = opt.space_after_function; } } @@ -909,34 +912,34 @@ function Beautifier(js_source_text, options) { } if (flags.last_text === ';' || last_type === 'TK_START_BLOCK') { - print_newline (); + print_newline(); } else if (last_type === 'TK_END_EXPR' || last_type === 'TK_START_EXPR' || last_type === 'TK_END_BLOCK' || flags.last_text === '.') { // do nothing on (( and )( and ][ and ]( and .( // TODO: Consider whether forcing this is required. Review failing tests when removed. - allow_wrap_or_preserved_newline (current_token.wanted_newline); + allow_wrap_or_preserved_newline(current_token.wanted_newline); } - set_mode (next_mode); - print_token (); + set_mode(next_mode); + print_token(); if (opt.space_in_paren) { output.space_before_token = true; } // In all cases, if we newline while inside an expression it should be indented. - indent (); + indent(); } function handle_end_expr() { // statements inside expressions are not valid syntax, but... // statements must all be closed when their container closes while (flags.mode === MODE.Statement) { - restore_mode (); + restore_mode(); } - handle_whitespace_and_comments (current_token); + handle_whitespace_and_comments(current_token); if (flags.multiline_frame) { - allow_wrap_or_preserved_newline (current_token.text === ']' && is_array (flags.mode) && !opt.keep_array_indentation); + allow_wrap_or_preserved_newline(current_token.text === ']' && is_array(flags.mode) && !opt.keep_array_indentation); } if (opt.space_in_paren) { @@ -949,13 +952,13 @@ function Beautifier(js_source_text, options) { } } if (current_token.text === ']' && opt.keep_array_indentation) { - print_token (); - restore_mode (); + print_token(); + restore_mode(); } else { - restore_mode (); - print_token (); + restore_mode(); + print_token(); } - remove_redundant_indentation (output, previous_flags); + remove_redundant_indentation(output, previous_flags); // do {} while () // no statement required after if (flags.do_while && previous_flags.mode === MODE.Conditional) { @@ -967,35 +970,35 @@ function Beautifier(js_source_text, options) { } function handle_start_block() { - handle_whitespace_and_comments (current_token); + handle_whitespace_and_comments(current_token); // Check if this is should be treated as a ObjectLiteral - var next_token = get_token (1); - var second_token = get_token (2); + var next_token = get_token(1); + var second_token = get_token(2); if (second_token && ( - (in_array (second_token.text, [':', ',']) && in_array (next_token.type, ['TK_STRING', 'TK_WORD', 'TK_RESERVED'])) || - (in_array (next_token.text, ['get', 'set', '...']) && in_array (second_token.type, ['TK_WORD', 'TK_RESERVED'])) + (in_array(second_token.text, [':', ',']) && in_array(next_token.type, ['TK_STRING', 'TK_WORD', 'TK_RESERVED'])) || + (in_array(next_token.text, ['get', 'set', '...']) && in_array(second_token.type, ['TK_WORD', 'TK_RESERVED'])) )) { // We don't support TypeScript,but we didn't break it for a very long time. // We'll try to keep not breaking it. - if (!in_array (last_last_text, ['class', 'interface'])) { - set_mode (MODE.ObjectLiteral); + if (!in_array(last_last_text, ['class', 'interface'])) { + set_mode(MODE.ObjectLiteral); } else { - set_mode (MODE.BlockStatement); + set_mode(MODE.BlockStatement); } } else if (last_type === 'TK_OPERATOR' && flags.last_text === '=>') { // arrow function: (param1, paramN) => { statements } - set_mode (MODE.BlockStatement); - } else if (in_array (last_type, ['TK_EQUALS', 'TK_START_EXPR', 'TK_COMMA', 'TK_OPERATOR']) || - (last_type === 'TK_RESERVED' && in_array (flags.last_text, ['return', 'throw', 'import', 'default'])) + set_mode(MODE.BlockStatement); + } else if (in_array(last_type, ['TK_EQUALS', 'TK_START_EXPR', 'TK_COMMA', 'TK_OPERATOR']) || + (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['return', 'throw', 'import', 'default'])) ) { // Detecting shorthand function syntax is difficult by scanning forward, // so check the surrounding context. // If the block is being returned, imported, export default, passed as arg, // assigned with = or assigned in a nested object, treat as an ObjectLiteral. - set_mode (MODE.ObjectLiteral); + set_mode(MODE.ObjectLiteral); } else { - set_mode (MODE.BlockStatement); + set_mode(MODE.BlockStatement); } var empty_braces = !next_token.comments_before.length && next_token.text === '}'; @@ -1010,7 +1013,7 @@ function Beautifier(js_source_text, options) { flags.inline_frame = true; do { index += 1; - check_token = get_token (index); + check_token = get_token(index); if (check_token.wanted_newline) { flags.inline_frame = false; break; @@ -1025,41 +1028,41 @@ function Beautifier(js_source_text, options) { if (last_type !== 'TK_OPERATOR' && (empty_anonymous_function || last_type === 'TK_EQUALS' || - (last_type === 'TK_RESERVED' && is_special_word (flags.last_text) && flags.last_text !== 'else'))) { + (last_type === 'TK_RESERVED' && is_special_word(flags.last_text) && flags.last_text !== 'else'))) { output.space_before_token = true; } else { - print_newline (false, true); + print_newline(false, true); } } else { // collapse || inline_frame - if (is_array (previous_flags.mode) && (last_type === 'TK_START_EXPR' || last_type === 'TK_COMMA')) { + if (is_array(previous_flags.mode) && (last_type === 'TK_START_EXPR' || last_type === 'TK_COMMA')) { if (last_type === 'TK_COMMA' || opt.space_in_paren) { output.space_before_token = true; } if (last_type === 'TK_COMMA' || (last_type === 'TK_START_EXPR' && flags.inline_frame)) { - allow_wrap_or_preserved_newline (); + allow_wrap_or_preserved_newline(); previous_flags.multiline_frame = previous_flags.multiline_frame || flags.multiline_frame; flags.multiline_frame = false; } } if (last_type !== 'TK_OPERATOR' && last_type !== 'TK_START_EXPR') { if (last_type === 'TK_START_BLOCK' && !flags.inline_frame) { - print_newline (); + print_newline(); } else { output.space_before_token = true; } } } - print_token (); - indent (); + print_token(); + indent(); } function handle_end_block() { // statements must all be closed when their container closes - handle_whitespace_and_comments (current_token); + handle_whitespace_and_comments(current_token); while (flags.mode === MODE.Statement) { - restore_mode (); + restore_mode(); } var empty_braces = last_type === 'TK_START_BLOCK'; @@ -1068,67 +1071,67 @@ function Beautifier(js_source_text, options) { output.space_before_token = true; } else if (opt.brace_style === "expand") { if (!empty_braces) { - print_newline (); + print_newline(); } } else { // skip {} if (!empty_braces) { - if (is_array (flags.mode) && opt.keep_array_indentation) { + if (is_array(flags.mode) && opt.keep_array_indentation) { // we REALLY need a newline here, but newliner would skip that opt.keep_array_indentation = false; - print_newline (); + print_newline(); opt.keep_array_indentation = true; } else { - print_newline (); + print_newline(); } } } - restore_mode (); - print_token (); + restore_mode(); + print_token(); } function handle_word() { if (current_token.type === 'TK_RESERVED') { - if (in_array (current_token.text, ['set', 'get']) && flags.mode !== MODE.ObjectLiteral) { + if (in_array(current_token.text, ['set', 'get']) && flags.mode !== MODE.ObjectLiteral) { current_token.type = 'TK_WORD'; - } else if (in_array (current_token.text, ['as', 'from']) && !flags.import_block) { + } else if (in_array(current_token.text, ['as', 'from']) && !flags.import_block) { current_token.type = 'TK_WORD'; } else if (flags.mode === MODE.ObjectLiteral) { - var next_token = get_token (1); + var next_token = get_token(1); if (next_token.text === ':') { current_token.type = 'TK_WORD'; } } } - if (start_of_statement ()) { + if (start_of_statement()) { // The conditional starts the statement if appropriate. - if (last_type === 'TK_RESERVED' && in_array (flags.last_text, ['var', 'let', 'const']) && current_token.type === 'TK_WORD') { + if (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['var', 'let', 'const']) && current_token.type === 'TK_WORD') { flags.declaration_statement = true; } - } else if (current_token.wanted_newline && !is_expression (flags.mode) && + } else if (current_token.wanted_newline && !is_expression(flags.mode) && (last_type !== 'TK_OPERATOR' || (flags.last_text === '--' || flags.last_text === '++')) && last_type !== 'TK_EQUALS' && - (opt.preserve_newlines || !(last_type === 'TK_RESERVED' && in_array (flags.last_text, ['var', 'let', 'const', 'set', 'get'])))) { - handle_whitespace_and_comments (current_token); - print_newline (); + (opt.preserve_newlines || !(last_type === 'TK_RESERVED' && in_array(flags.last_text, ['var', 'let', 'const', 'set', 'get'])))) { + handle_whitespace_and_comments(current_token); + print_newline(); } else { - handle_whitespace_and_comments (current_token); + handle_whitespace_and_comments(current_token); } if (flags.do_block && !flags.do_while) { if (current_token.type === 'TK_RESERVED' && current_token.text === 'while') { // do {} ## while () output.space_before_token = true; - print_token (); + print_token(); output.space_before_token = true; flags.do_while = true; return; } else { // do {} should always have while as the next word. // if we don't see the expected while, recover - print_newline (); + print_newline(); flags.do_block = false; } } @@ -1141,7 +1144,7 @@ function Beautifier(js_source_text, options) { flags.else_block = true; } else { while (flags.mode === MODE.Statement) { - restore_mode (); + restore_mode(); } flags.if_block = false; flags.else_block = false; @@ -1149,54 +1152,54 @@ function Beautifier(js_source_text, options) { } if (current_token.type === 'TK_RESERVED' && (current_token.text === 'case' || (current_token.text === 'default' && flags.in_case_statement))) { - print_newline (); + print_newline(); if (flags.case_body || opt.jslint_happy) { // switch cases following one another - deindent (); + deindent(); flags.case_body = false; } - print_token (); + print_token(); flags.in_case = true; flags.in_case_statement = true; return; } if (last_type === 'TK_COMMA' || last_type === 'TK_START_EXPR' || last_type === 'TK_EQUALS' || last_type === 'TK_OPERATOR') { - if (!start_of_object_property ()) { - allow_wrap_or_preserved_newline (); + if (!start_of_object_property()) { + allow_wrap_or_preserved_newline(); } } if (current_token.type === 'TK_RESERVED' && current_token.text === 'function') { - if (in_array (flags.last_text, ['}', ';']) || - (output.just_added_newline() && !(in_array (flags.last_text, ['(', '[', '{', ':', '=', ',']) || last_type === 'TK_OPERATOR'))) { + if (in_array(flags.last_text, ['}', ';']) || + (output.just_added_newline() && !(in_array(flags.last_text, ['(', '[', '{', ':', '=', ',']) || last_type === 'TK_OPERATOR'))) { // make sure there is a nice clean space of at least one blank line // before a new function definition if (!output.just_added_blankline() && !current_token.comments_before.length) { - print_newline (); - print_newline (true); + print_newline(); + print_newline(true); } } if (last_type === 'TK_RESERVED' || last_type === 'TK_WORD') { if (last_type === 'TK_RESERVED' && ( - in_array (flags.last_text, ['get', 'set', 'new', 'export']) || - in_array (flags.last_text, newline_restricted_tokens))) { + in_array(flags.last_text, ['get', 'set', 'new', 'export']) || + in_array(flags.last_text, newline_restricted_tokens))) { output.space_before_token = true; } else if (last_type === 'TK_RESERVED' && flags.last_text === 'default' && last_last_text === 'export') { output.space_before_token = true; } else { - print_newline (); + print_newline(); } } else if (last_type === 'TK_OPERATOR' || flags.last_text === '=') { // foo = function output.space_before_token = true; - } else if (!flags.multiline_frame && (is_expression (flags.mode) || is_array (flags.mode))) { + } else if (!flags.multiline_frame && (is_expression(flags.mode) || is_array(flags.mode))) { // (function } else { - print_newline (); + print_newline(); } - print_token (); + print_token(); flags.last_word = current_token.text; return; } @@ -1207,7 +1210,7 @@ function Beautifier(js_source_text, options) { if (previous_flags.inline_frame) { prefix = 'SPACE'; - } else if (!(current_token.type === 'TK_RESERVED' && in_array (current_token.text, ['else', 'catch', 'finally', 'from']))) { + } else if (!(current_token.type === 'TK_RESERVED' && in_array(current_token.text, ['else', 'catch', 'finally', 'from']))) { prefix = 'NEWLINE'; } else { if (opt.brace_style === "expand" || @@ -1222,14 +1225,14 @@ function Beautifier(js_source_text, options) { } else if (last_type === 'TK_SEMICOLON' && flags.mode === MODE.BlockStatement) { // TODO: Should this be for STATEMENT as well? prefix = 'NEWLINE'; - } else if (last_type === 'TK_SEMICOLON' && is_expression (flags.mode)) { + } else if (last_type === 'TK_SEMICOLON' && is_expression(flags.mode)) { prefix = 'SPACE'; } else if (last_type === 'TK_STRING') { prefix = 'NEWLINE'; } else if (last_type === 'TK_RESERVED' || last_type === 'TK_WORD' || (flags.last_text === '*' && - (in_array (last_last_text, ['function', 'yield']) || - (flags.mode === MODE.ObjectLiteral && in_array (last_last_text, ['{', ',']))))) { + (in_array(last_last_text, ['function', 'yield']) || + (flags.mode === MODE.ObjectLiteral && in_array(last_last_text, ['{', ',']))))) { prefix = 'SPACE'; } else if (last_type === 'TK_START_BLOCK') { if (flags.inline_frame) { @@ -1242,7 +1245,7 @@ function Beautifier(js_source_text, options) { prefix = 'NEWLINE'; } - if (current_token.type === 'TK_RESERVED' && in_array (current_token.text, tokenizer.line_starters) && flags.last_text !== ')') { + if (current_token.type === 'TK_RESERVED' && in_array(current_token.text, tokenizer.line_starters) && flags.last_text !== ')') { if (flags.inline_frame || flags.last_text === 'else' || flags.last_text === 'export') { prefix = 'SPACE'; } else { @@ -1251,46 +1254,46 @@ function Beautifier(js_source_text, options) { } - if (current_token.type === 'TK_RESERVED' && in_array (current_token.text, ['else', 'catch', 'finally'])) { + if (current_token.type === 'TK_RESERVED' && in_array(current_token.text, ['else', 'catch', 'finally'])) { if ((!(last_type === 'TK_END_BLOCK' && previous_flags.mode === MODE.BlockStatement) || opt.brace_style === "expand" || opt.brace_style === "end-expand" || (opt.brace_style === "none" && current_token.wanted_newline)) && !flags.inline_frame) { - print_newline (); + print_newline(); } else { output.trim(true); var line = output.current_line; // If we trimmed and there's something other than a close block before us // put a newline back in. Handles '} // comment' scenario. if (line.last() !== '}') { - print_newline (); + print_newline(); } output.space_before_token = true; } } else if (prefix === 'NEWLINE') { - if (last_type === 'TK_RESERVED' && is_special_word (flags.last_text)) { + if (last_type === 'TK_RESERVED' && is_special_word(flags.last_text)) { // no newline between 'return nnn' output.space_before_token = true; } else if (last_type !== 'TK_END_EXPR') { - if ((last_type !== 'TK_START_EXPR' || !(current_token.type === 'TK_RESERVED' && in_array (current_token.text, ['var', 'let', 'const']))) && flags.last_text !== ':') { + if ((last_type !== 'TK_START_EXPR' || !(current_token.type === 'TK_RESERVED' && in_array(current_token.text, ['var', 'let', 'const']))) && flags.last_text !== ':') { // no need to force newline on 'var': for (var x = 0...) if (current_token.type === 'TK_RESERVED' && current_token.text === 'if' && flags.last_text === 'else') { // no newline for } else if { output.space_before_token = true; } else { - print_newline (); + print_newline(); } } - } else if (current_token.type === 'TK_RESERVED' && in_array (current_token.text, tokenizer.line_starters) && flags.last_text !== ')') { - print_newline (); + } else if (current_token.type === 'TK_RESERVED' && in_array(current_token.text, tokenizer.line_starters) && flags.last_text !== ')') { + print_newline(); } - } else if (flags.multiline_frame && is_array (flags.mode) && flags.last_text === ',' && last_last_text === '}') { - print_newline (); // }, in lists get a newline treatment + } else if (flags.multiline_frame && is_array(flags.mode) && flags.last_text === ',' && last_last_text === '}') { + print_newline(); // }, in lists get a newline treatment } else if (prefix === 'SPACE') { output.space_before_token = true; } - print_token (); + print_token(); flags.last_word = current_token.text; if (current_token.type === 'TK_RESERVED') { @@ -1307,53 +1310,53 @@ function Beautifier(js_source_text, options) { } function handle_semicolon() { - if (start_of_statement ()) { + if (start_of_statement()) { // The conditional starts the statement if appropriate. // Semicolon can be the start (and end) of a statement output.space_before_token = false; } else { - handle_whitespace_and_comments (current_token); + handle_whitespace_and_comments(current_token); } - var next_token = get_token (1); + var next_token = get_token(1); while (flags.mode === MODE.Statement && !(flags.if_block && next_token && next_token.type === 'TK_RESERVED' && next_token.text === 'else') && !flags.do_block) { - restore_mode (); + restore_mode(); } // hacky but effective for the moment if (flags.import_block) { flags.import_block = false; } - print_token (); + print_token(); } function handle_string() { - if (start_of_statement ()) { + if (start_of_statement()) { // The conditional starts the statement if appropriate. // One difference - strings want at least a space before output.space_before_token = true; } else { - handle_whitespace_and_comments (current_token); + handle_whitespace_and_comments(current_token); if (last_type === 'TK_RESERVED' || last_type === 'TK_WORD' || flags.inline_frame) { output.space_before_token = true; } else if (last_type === 'TK_COMMA' || last_type === 'TK_START_EXPR' || last_type === 'TK_EQUALS' || last_type === 'TK_OPERATOR') { - if (!start_of_object_property ()) { - allow_wrap_or_preserved_newline (); + if (!start_of_object_property()) { + allow_wrap_or_preserved_newline(); } } else { - print_newline (); + print_newline(); } } - print_token (); + print_token(); } function handle_equals() { - if (start_of_statement ()) { + if(start_of_statement()) { // The conditional starts the statement if appropriate. } else { - handle_whitespace_and_comments (current_token); + handle_whitespace_and_comments(current_token); } if (flags.declaration_statement) { @@ -1361,94 +1364,94 @@ function Beautifier(js_source_text, options) { flags.declaration_assignment = true; } output.space_before_token = true; - print_token (); + print_token(); output.space_before_token = true; } function handle_comma() { - handle_whitespace_and_comments (current_token, true); + handle_whitespace_and_comments(current_token, true); - print_token (); + print_token(); output.space_before_token = true; if (flags.declaration_statement) { - if (is_expression (flags.parent.mode)) { + if (is_expression(flags.parent.mode)) { // do not break on comma, for(var a = 1, b = 2) flags.declaration_assignment = false; } if (flags.declaration_assignment) { flags.declaration_assignment = false; - print_newline (false, true); + print_newline(false, true); } else if (opt.comma_first) { // for comma-first, we want to allow a newline before the comma // to turn into a newline after the comma, which we will fixup later - allow_wrap_or_preserved_newline (); + allow_wrap_or_preserved_newline(); } } else if (flags.mode === MODE.ObjectLiteral || (flags.mode === MODE.Statement && flags.parent.mode === MODE.ObjectLiteral)) { if (flags.mode === MODE.Statement) { - restore_mode (); + restore_mode(); } if (!flags.inline_frame) { - print_newline (); + print_newline(); } } else if (opt.comma_first) { // EXPR or DO_BLOCK // for comma-first, we want to allow a newline before the comma // to turn into a newline after the comma, which we will fixup later - allow_wrap_or_preserved_newline (); + allow_wrap_or_preserved_newline(); } } function handle_operator() { var isGeneratorAsterisk = current_token.text === '*' && - ((last_type === 'TK_RESERVED' && in_array (flags.last_text, ['function', 'yield'])) || - (in_array (last_type, ['TK_START_BLOCK', 'TK_COMMA', 'TK_END_BLOCK', 'TK_SEMICOLON'])) + ((last_type === 'TK_RESERVED' && in_array(flags.last_text, ['function', 'yield'])) || + (in_array(last_type, ['TK_START_BLOCK', 'TK_COMMA', 'TK_END_BLOCK', 'TK_SEMICOLON'])) ); - var isUnary = in_array (current_token.text, ['-', '+']) && ( - in_array (last_type, ['TK_START_BLOCK', 'TK_START_EXPR', 'TK_EQUALS', 'TK_OPERATOR']) || - in_array (flags.last_text, tokenizer.line_starters) || + var isUnary = in_array(current_token.text, ['-', '+']) && ( + in_array(last_type, ['TK_START_BLOCK', 'TK_START_EXPR', 'TK_EQUALS', 'TK_OPERATOR']) || + in_array(flags.last_text, tokenizer.line_starters) || flags.last_text === ',' ); - if (start_of_statement ()) { + if (start_of_statement()) { // The conditional starts the statement if appropriate. } else { var preserve_statement_flags = !isGeneratorAsterisk; - handle_whitespace_and_comments (current_token, preserve_statement_flags); + handle_whitespace_and_comments(current_token, preserve_statement_flags); } - if (last_type === 'TK_RESERVED' && is_special_word (flags.last_text)) { + if (last_type === 'TK_RESERVED' && is_special_word(flags.last_text)) { // "return" had a special handling in TK_WORD. Now we need to return the favor output.space_before_token = true; - print_token (); + print_token(); return; } // hack for actionscript's import .*; if (current_token.text === '*' && last_type === 'TK_DOT') { - print_token (); + print_token(); return; } if (current_token.text === '::') { // no spaces around exotic namespacing syntax operator - print_token (); + print_token(); return; } // Allow line wrapping between operators when operator_position is // set to before or preserve - if (last_type === 'TK_OPERATOR' && in_array (opt.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)) { - allow_wrap_or_preserved_newline (); + if (last_type === 'TK_OPERATOR' && in_array(opt.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)) { + allow_wrap_or_preserved_newline(); } if (current_token.text === ':' && flags.in_case) { flags.case_body = true; - indent (); - print_token (); - print_newline (); + indent(); + print_token(); + print_newline(); flags.in_case = false; return; } @@ -1457,6 +1460,11 @@ function Beautifier(js_source_text, options) { var space_after = true; var in_ternary = false; if (current_token.text === ':') { + if ((flags.mode === 'Expression' || flags.mode === 'Statement') && flags.last_text === '?') { + output.space_before_token = false; + space_before = false; + } + if (flags.ternary_depth === 0) { // Colon is invalid javascript outside of ternary and object, but do our best to guess what was meant. space_before = false; @@ -1465,11 +1473,15 @@ function Beautifier(js_source_text, options) { in_ternary = true; } } else if (current_token.text === '?') { + if (tokens[token_pos + 1].text === ':' && (flags.mode === 'Expression' || flags.mode === 'Statement')) { + output.space_before_token = false; + space_before = false; + } flags.ternary_depth += 1; } // let's handle the operator_position option prior to any conflicting logic - if (!isUnary && !isGeneratorAsterisk && opt.preserve_newlines && in_array (current_token.text, tokenizer.positionable_operators)) { + if (!isUnary && !isGeneratorAsterisk && opt.preserve_newlines && in_array(current_token.text, tokenizer.positionable_operators)) { var isColon = current_token.text === ':'; var isTernaryColon = (isColon && in_ternary); var isOtherColon = (isColon && !in_ternary); @@ -1479,10 +1491,10 @@ function Beautifier(js_source_text, options) { // if the current token is : and it's not a ternary statement then we set space_before to false output.space_before_token = !isOtherColon; - print_token (); + print_token(); if (!isColon || isTernaryColon) { - allow_wrap_or_preserved_newline (); + allow_wrap_or_preserved_newline(); } output.space_before_token = true; @@ -1495,23 +1507,23 @@ function Beautifier(js_source_text, options) { output.space_before_token = true; if (!isColon || isTernaryColon) { - if (get_token (1).wanted_newline) { - print_newline (false, true); + if (get_token(1).wanted_newline) { + print_newline(false, true); } else { - allow_wrap_or_preserved_newline (); + allow_wrap_or_preserved_newline(); } } else { output.space_before_token = false; } - print_token (); + print_token(); output.space_before_token = true; return; case OPERATOR_POSITION.preserve_newline: if (!isOtherColon) { - allow_wrap_or_preserved_newline (); + allow_wrap_or_preserved_newline(); } // if we just added a newline, or the current token is : and it's not a ternary statement, @@ -1519,22 +1531,22 @@ function Beautifier(js_source_text, options) { space_before = !(output.just_added_newline() || isOtherColon); output.space_before_token = space_before; - print_token (); + print_token(); output.space_before_token = true; return; } } if (isGeneratorAsterisk) { - allow_wrap_or_preserved_newline (); + allow_wrap_or_preserved_newline(); space_before = false; - var next_token = get_token (1); - space_after = next_token && in_array (next_token.type, ['TK_WORD', 'TK_RESERVED']); + var next_token = get_token(1); + space_after = next_token && in_array(next_token.type, ['TK_WORD', 'TK_RESERVED']); } else if (current_token.text === '...') { - allow_wrap_or_preserved_newline (); + allow_wrap_or_preserved_newline(); space_before = last_type === 'TK_START_BLOCK'; space_after = false; - } else if (in_array (current_token.text, ['--', '++', '!', '~']) || isUnary) { + } else if (in_array(current_token.text, ['--', '++', '!', '~']) || isUnary) { // unary operators (and binary +/- pretending to be unary) special cases space_before = false; @@ -1543,10 +1555,10 @@ function Beautifier(js_source_text, options) { // http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1 // if there is a newline between -- or ++ and anything else we should preserve it. if (current_token.wanted_newline && (current_token.text === '--' || current_token.text === '++')) { - print_newline (false, true); + print_newline(false, true); } - if (flags.last_text === ';' && is_expression (flags.mode)) { + if (flags.last_text === ';' && is_expression(flags.mode)) { // for (;; ++i) // ^^^ space_before = true; @@ -1559,12 +1571,12 @@ function Beautifier(js_source_text, options) { } else if (last_type === 'TK_OPERATOR') { // a++ + ++b; // a - -b - space_before = in_array (current_token.text, ['--', '-', '++', '+']) && in_array (flags.last_text, ['--', '-', '++', '+']); + space_before = in_array(current_token.text, ['--', '-', '++', '+']) && in_array(flags.last_text, ['--', '-', '++', '+']); // + and - are not unary when preceeded by -- or ++ operator // a-- + b // a * +b // a - -b - if (in_array (current_token.text, ['+', '-']) && in_array (flags.last_text, ['--', '++'])) { + if (in_array(current_token.text, ['+', '-']) && in_array(flags.last_text, ['--', '++'])) { space_after = true; } } @@ -1574,12 +1586,12 @@ function Beautifier(js_source_text, options) { (flags.last_text === '{' || flags.last_text === ';')) { // { foo; --i } // foo(); --bar; - print_newline (); + print_newline(); } } output.space_before_token = output.space_before_token || space_before; - print_token (); + print_token(); output.space_before_token = space_after; } @@ -1594,24 +1606,24 @@ function Beautifier(js_source_text, options) { } if (current_token.directives) { - print_newline (false, preserve_statement_flags); - print_token (); + print_newline(false, preserve_statement_flags); + print_token(); if (current_token.directives.preserve === 'start') { output.raw = true; } - print_newline (false, true); + print_newline(false, true); return; } // inline block if (!acorn.newline.test(current_token.text) && !current_token.wanted_newline) { output.space_before_token = true; - print_token (); + print_token(); output.space_before_token = true; return; } - var lines = split_linebreaks (current_token.text); + var lines = split_linebreaks(current_token.text); var j; // iterator for this case var javadoc = false; var starless = false; @@ -1619,22 +1631,22 @@ function Beautifier(js_source_text, options) { var lastIndentLength = lastIndent.length; // block comment starts with a new line - print_newline (false, preserve_statement_flags); + print_newline(false, preserve_statement_flags); if (lines.length > 1) { - javadoc = all_lines_start_with (lines.slice(1), '*'); - starless = each_line_matches_indent (lines.slice(1), lastIndent); + javadoc = all_lines_start_with(lines.slice(1), '*'); + starless = each_line_matches_indent(lines.slice(1), lastIndent); } // first line always indented - print_token (lines[0]); + print_token(lines[0]); for (j = 1; j < lines.length; j++) { - print_newline (false, true); + print_newline(false, true); if (javadoc) { // javadoc: reformat and re-indent - print_token (' ' + ltrim (lines[j])); + print_token(' ' + ltrim(lines[j])); } else if (starless && lines[j].length > lastIndentLength) { // starless: re-indent non-empty content, avoiding trim - print_token (lines[j].substring(lastIndentLength)); + print_token(lines[j].substring(lastIndentLength)); } else { // normal comments output raw output.add_token(lines[j]); @@ -1642,57 +1654,57 @@ function Beautifier(js_source_text, options) { } // for comments of more than one line, make sure there's a new line after - print_newline (false, preserve_statement_flags); + print_newline(false, preserve_statement_flags); } function handle_comment(preserve_statement_flags) { if (current_token.wanted_newline) { - print_newline (false, preserve_statement_flags); + print_newline(false, preserve_statement_flags); } else { output.trim(true); } output.space_before_token = true; - print_token (); - print_newline (false, preserve_statement_flags); + print_token(); + print_newline(false, preserve_statement_flags); } function handle_dot() { - if (start_of_statement ()) { + if (start_of_statement()) { // The conditional starts the statement if appropriate. } else { - handle_whitespace_and_comments (current_token, true); + handle_whitespace_and_comments(current_token, true); } if (opt.unindent_chained_methods) { - deindent (); + deindent(); } - if (last_type === 'TK_RESERVED' && is_special_word (flags.last_text)) { + if (last_type === 'TK_RESERVED' && is_special_word(flags.last_text)) { output.space_before_token = false; } else { // allow preserved newlines before dots in general // force newlines on dots after close paren when break_chained - for bar().baz() - allow_wrap_or_preserved_newline (flags.last_text === ')' && opt.break_chained_methods); + allow_wrap_or_preserved_newline(flags.last_text === ')' && opt.break_chained_methods); } - print_token (); + print_token(); } function handle_unknown(preserve_statement_flags) { - print_token (); + print_token(); if (current_token.text[current_token.text.length - 1] === '\n') { - print_newline (false, preserve_statement_flags); + print_newline(false, preserve_statement_flags); } } function handle_eof() { // Unwind any open statements while (flags.mode === MODE.Statement) { - restore_mode (); + restore_mode(); } - handle_whitespace_and_comments (current_token); + handle_whitespace_and_comments(current_token); } }