From 58528fe5cae2157f6bb0193362bb59b8145806fc Mon Sep 17 00:00:00 2001 From: Michael Ratcliffe Date: Mon, 14 Jul 2014 01:00:35 +0100 Subject: [PATCH] Backed out changeset e2360d41bd66 (bug 1033387) for loader test failures --- .../commandline/test/browser_cmd_jsb.js | 2 +- browser/devtools/shared/Jsbeautify.jsm | 1313 ++++++++++- toolkit/devtools/Loader.jsm | 2 - toolkit/devtools/gcli/commands/jsb.js | 6 +- toolkit/devtools/jsbeautify/UPGRADING.md | 37 - toolkit/devtools/jsbeautify/beautify.js | 7 - toolkit/devtools/jsbeautify/lib/sanitytest.js | 137 -- .../jsbeautify/lib/urlencode_unpacker.js | 73 - toolkit/devtools/jsbeautify/moz.build | 19 - .../devtools/jsbeautify/src/beautify-css.js | 367 --- .../devtools/jsbeautify/src/beautify-html.js | 822 ------- .../devtools/jsbeautify/src/beautify-js.js | 1662 ------------- .../devtools/jsbeautify/src/beautify-tests.js | 2096 ----------------- .../jsbeautify/tests/unit/head_jsbeautify.js | 18 - .../devtools/jsbeautify/tests/unit/test.js | 23 - .../jsbeautify/tests/unit/xpcshell.ini | 5 - toolkit/devtools/moz.build | 1 - 17 files changed, 1303 insertions(+), 5287 deletions(-) delete mode 100644 toolkit/devtools/jsbeautify/UPGRADING.md delete mode 100644 toolkit/devtools/jsbeautify/beautify.js delete mode 100644 toolkit/devtools/jsbeautify/lib/sanitytest.js delete mode 100644 toolkit/devtools/jsbeautify/lib/urlencode_unpacker.js delete mode 100644 toolkit/devtools/jsbeautify/moz.build delete mode 100644 toolkit/devtools/jsbeautify/src/beautify-css.js delete mode 100644 toolkit/devtools/jsbeautify/src/beautify-html.js delete mode 100644 toolkit/devtools/jsbeautify/src/beautify-js.js delete mode 100644 toolkit/devtools/jsbeautify/src/beautify-tests.js delete mode 100644 toolkit/devtools/jsbeautify/tests/unit/head_jsbeautify.js delete mode 100644 toolkit/devtools/jsbeautify/tests/unit/test.js delete mode 100644 toolkit/devtools/jsbeautify/tests/unit/xpcshell.ini diff --git a/browser/devtools/commandline/test/browser_cmd_jsb.js b/browser/devtools/commandline/test/browser_cmd_jsb.js index cf2a9da13f85..3cfae700befe 100644 --- a/browser/devtools/commandline/test/browser_cmd_jsb.js +++ b/browser/devtools/commandline/test/browser_cmd_jsb.js @@ -45,7 +45,7 @@ function testTask() { result = result.replace(/[\r\n]]*/g, "\n"); let correct = "function somefunc() {\n" + " if (true) // Some comment\n" + - " doSomething();\n" + + " doSomething();\n" + " for (let n = 0; n < 500; n++) {\n" + " if (n % 2 == 1) {\n" + " console.log(n);\n" + diff --git a/browser/devtools/shared/Jsbeautify.jsm b/browser/devtools/shared/Jsbeautify.jsm index 438fa6e2ee95..4171d57468f4 100644 --- a/browser/devtools/shared/Jsbeautify.jsm +++ b/browser/devtools/shared/Jsbeautify.jsm @@ -1,16 +1,1303 @@ -/* This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ - -"use strict"; - +/*jslint onevar: false, plusplus: false */ +/*jshint curly:true, eqeqeq:true, laxbreak:true, noempty:false */ /* - * JS Beautifier. Please use devtools.require("devtools/jsbeautify") instead of - * this JSM. - */ -this.EXPORTED_SYMBOLS = [ "jsBeautify" ]; + JS Beautifier +--------------- -const { devtools } = Components.utils.import("resource://gre/modules/devtools/Loader.jsm", {}); -const { beautify } = devtools.require("devtools/jsbeautify"); -const jsBeautify = beautify.js; + + Written by Einar Lielmanis, + http://jsbeautifier.org/ + + Originally converted to javascript by Vital, + "End braces on own line" added by Chris J. Shull, + + You are free to use this in any way you want, in case you find this useful or working for you. + + Usage: + js_beautify(js_source_text); + js_beautify(js_source_text, options); + + The options are: + indent_size (default 4) - indentation size, + indent_char (default space) - character to indent with, + preserve_newlines (default true) - whether existing line breaks should be preserved, + max_preserve_newlines (default unlimited) - maximum number of line breaks to be preserved in one chunk, + + jslint_happy (default false) - if true, then jslint-stricter mode is enforced. + + jslint_happy !jslint_happy + --------------------------------- + function () function() + + brace_style (default "collapse") - "collapse" | "expand" | "end-expand" | "expand-strict" + put braces on the same line as control statements (default), or put braces on own line (Allman / ANSI style), or just put end braces on own line. + + expand-strict: put brace on own line even in such cases: + + var a = + { + a: 5, + b: 6 + } + This mode may break your scripts - e.g "return { a: 1 }" will be broken into two lines, so beware. + + space_before_conditional (default true) - should the space before conditional statement be added, "if(true)" vs "if (true)", + + unescape_strings (default false) - should printable characters in strings encoded in \xNN notation be unescaped, "example" vs "\x65\x78\x61\x6d\x70\x6c\x65" + + e.g + + js_beautify(js_source_text, { + 'indent_size': 1, + 'indent_char': '\t' + }); + + +*/ + +this.EXPORTED_SYMBOLS = ["js_beautify"]; + +this.js_beautify = function js_beautify(js_source_text, options) { + + var input, output, token_text, last_type, last_text, last_last_text, last_word, flags, flag_store, indent_string; + var whitespace, wordchar, punct, parser_pos, line_starters, digits; + var prefix, token_type, do_block_just_closed; + var wanted_newline, just_added_newline, n_newlines; + var preindent_string = ''; + + + // Some interpreters have unexpected results with foo = baz || bar; + options = options ? options : {}; + + var opt_brace_style; + + // compatibility + if (options.space_after_anon_function !== undefined && options.jslint_happy === undefined) { + options.jslint_happy = options.space_after_anon_function; + } + if (options.braces_on_own_line !== undefined) { //graceful handling of deprecated option + opt_brace_style = options.braces_on_own_line ? "expand" : "collapse"; + } + opt_brace_style = options.brace_style ? options.brace_style : (opt_brace_style ? opt_brace_style : "collapse"); + + + var opt_indent_size = options.indent_size ? options.indent_size : 4; + var opt_indent_char = options.indent_char ? options.indent_char : ' '; + var opt_preserve_newlines = typeof options.preserve_newlines === 'undefined' ? true : options.preserve_newlines; + var opt_max_preserve_newlines = typeof options.max_preserve_newlines === 'undefined' ? false : options.max_preserve_newlines; + var opt_jslint_happy = options.jslint_happy === 'undefined' ? false : options.jslint_happy; + var opt_keep_array_indentation = typeof options.keep_array_indentation === 'undefined' ? false : options.keep_array_indentation; + var opt_space_before_conditional = typeof options.space_before_conditional === 'undefined' ? true : options.space_before_conditional; + var opt_indent_case = typeof options.indent_case === 'undefined' ? false : options.indent_case; + var opt_unescape_strings = typeof options.unescape_strings === 'undefined' ? false : options.unescape_strings; + + just_added_newline = false; + + // cache the source's length. + var input_length = js_source_text.length; + + function trim_output(eat_newlines) { + eat_newlines = typeof eat_newlines === 'undefined' ? false : eat_newlines; + while (output.length && (output[output.length - 1] === ' ' + || output[output.length - 1] === indent_string + || output[output.length - 1] === preindent_string + || (eat_newlines && (output[output.length - 1] === '\n' || output[output.length - 1] === '\r')))) { + output.pop(); + } + } + + function trim(s) { + return s.replace(/^\s\s*|\s\s*$/, ''); + } + + // we could use just string.split, but + // IE doesn't like returning empty strings + function split_newlines(s) { + return s.split(/\x0d\x0a|\x0a/); + } + + function force_newline() { + var old_keep_array_indentation = opt_keep_array_indentation; + opt_keep_array_indentation = false; + print_newline(); + opt_keep_array_indentation = old_keep_array_indentation; + } + + function print_newline(ignore_repeated) { + + flags.eat_next_space = false; + if (opt_keep_array_indentation && is_array(flags.mode)) { + return; + } + + ignore_repeated = typeof ignore_repeated === 'undefined' ? true : ignore_repeated; + + flags.if_line = false; + trim_output(); + + if (!output.length) { + return; // no newline on start of file + } + + if (output[output.length - 1] !== "\n" || !ignore_repeated) { + just_added_newline = true; + output.push("\n"); + } + if (preindent_string) { + output.push(preindent_string); + } + for (var i = 0; i < flags.indentation_level; i += 1) { + output.push(indent_string); + } + if (flags.var_line && flags.var_line_reindented) { + output.push(indent_string); // skip space-stuffing, if indenting with a tab + } + if (flags.case_body) { + output.push(indent_string); + } + } + + + + function print_single_space() { + + if (last_type === 'TK_COMMENT') { + return print_newline(); + } + if (flags.eat_next_space) { + flags.eat_next_space = false; + return; + } + var last_output = ' '; + if (output.length) { + last_output = output[output.length - 1]; + } + if (last_output !== ' ' && last_output !== '\n' && last_output !== indent_string) { // prevent occassional duplicate space + output.push(' '); + } + } + + + function print_token() { + just_added_newline = false; + flags.eat_next_space = false; + output.push(token_text); + } + + function indent() { + flags.indentation_level += 1; + } + + + function remove_indent() { + if (output.length && output[output.length - 1] === indent_string) { + output.pop(); + } + } + + function set_mode(mode) { + if (flags) { + flag_store.push(flags); + } + flags = { + previous_mode: flags ? flags.mode : 'BLOCK', + mode: mode, + var_line: false, + var_line_tainted: false, + var_line_reindented: false, + in_html_comment: false, + if_line: false, + in_case_statement: false, // switch(..){ INSIDE HERE } + in_case: false, // we're on the exact line with "case 0:" + case_body: false, // the indented case-action block + eat_next_space: false, + indentation_baseline: -1, + indentation_level: (flags ? flags.indentation_level + (flags.case_body ? 1 : 0) + ((flags.var_line && flags.var_line_reindented) ? 1 : 0) : 0), + ternary_depth: 0 + }; + } + + function is_array(mode) { + return mode === '[EXPRESSION]' || mode === '[INDENTED-EXPRESSION]'; + } + + function is_expression(mode) { + return in_array(mode, ['[EXPRESSION]', '(EXPRESSION)', '(FOR-EXPRESSION)', '(COND-EXPRESSION)']); + } + + function restore_mode() { + do_block_just_closed = flags.mode === 'DO_BLOCK'; + if (flag_store.length > 0) { + var mode = flags.mode; + flags = flag_store.pop(); + flags.previous_mode = mode; + } + } + + function all_lines_start_with(lines, c) { + for (var i = 0; i < lines.length; i++) { + var line = trim(lines[i]); + if (line.charAt(0) !== c) { + return false; + } + } + return true; + } + + function is_special_word(word) { + return in_array(word, ['case', 'return', 'do', 'if', 'throw', 'else']); + } + + function in_array(what, arr) { + for (var i = 0; i < arr.length; i += 1) { + if (arr[i] === what) { + return true; + } + } + return false; + } + + function look_up(exclude) { + var local_pos = parser_pos; + var c = input.charAt(local_pos); + while (in_array(c, whitespace) && c !== exclude) { + local_pos++; + if (local_pos >= input_length) { + return 0; + } + c = input.charAt(local_pos); + } + return c; + } + + function get_next_token() { + var i; + var resulting_string; + + n_newlines = 0; + + if (parser_pos >= input_length) { + return ['', 'TK_EOF']; + } + + wanted_newline = false; + + var c = input.charAt(parser_pos); + parser_pos += 1; + + + var keep_whitespace = opt_keep_array_indentation && is_array(flags.mode); + + if (keep_whitespace) { + + // + // slight mess to allow nice preservation of array indentation and reindent that correctly + // first time when we get to the arrays: + // var a = [ + // ....'something' + // we make note of whitespace_count = 4 into flags.indentation_baseline + // so we know that 4 whitespaces in original source match indent_level of reindented source + // + // and afterwards, when we get to + // 'something, + // .......'something else' + // we know that this should be indented to indent_level + (7 - indentation_baseline) spaces + // + var whitespace_count = 0; + + while (in_array(c, whitespace)) { + + if (c === "\n") { + trim_output(); + output.push("\n"); + just_added_newline = true; + whitespace_count = 0; + } else { + if (c === '\t') { + whitespace_count += 4; + } else if (c === '\r') { + // nothing + } else { + whitespace_count += 1; + } + } + + if (parser_pos >= input_length) { + return ['', 'TK_EOF']; + } + + c = input.charAt(parser_pos); + parser_pos += 1; + + } + if (flags.indentation_baseline === -1) { + flags.indentation_baseline = whitespace_count; + } + + if (just_added_newline) { + for (i = 0; i < flags.indentation_level + 1; i += 1) { + output.push(indent_string); + } + if (flags.indentation_baseline !== -1) { + for (i = 0; i < whitespace_count - flags.indentation_baseline; i++) { + output.push(' '); + } + } + } + + } else { + while (in_array(c, whitespace)) { + + if (c === "\n") { + n_newlines += ((opt_max_preserve_newlines) ? (n_newlines <= opt_max_preserve_newlines) ? 1 : 0 : 1); + } + + + if (parser_pos >= input_length) { + return ['', 'TK_EOF']; + } + + c = input.charAt(parser_pos); + parser_pos += 1; + + } + + if (opt_preserve_newlines) { + if (n_newlines > 1) { + for (i = 0; i < n_newlines; i += 1) { + print_newline(i === 0); + just_added_newline = true; + } + } + } + wanted_newline = n_newlines > 0; + } + + + if (in_array(c, wordchar)) { + if (parser_pos < input_length) { + while (in_array(input.charAt(parser_pos), wordchar)) { + c += input.charAt(parser_pos); + parser_pos += 1; + if (parser_pos === input_length) { + break; + } + } + } + + // small and surprisingly unugly hack for 1E-10 representation + if (parser_pos !== input_length && c.match(/^[0-9]+[Ee]$/) && (input.charAt(parser_pos) === '-' || input.charAt(parser_pos) === '+')) { + + var sign = input.charAt(parser_pos); + parser_pos += 1; + + var t = get_next_token(); + c += sign + t[0]; + return [c, 'TK_WORD']; + } + + if (c === 'in') { // hack for 'in' operator + return [c, 'TK_OPERATOR']; + } + if (wanted_newline && last_type !== 'TK_OPERATOR' + && last_type !== 'TK_EQUALS' + && !flags.if_line && (opt_preserve_newlines || last_text !== 'var')) { + print_newline(); + } + return [c, 'TK_WORD']; + } + + if (c === '(' || c === '[') { + return [c, 'TK_START_EXPR']; + } + + if (c === ')' || c === ']') { + return [c, 'TK_END_EXPR']; + } + + if (c === '{') { + return [c, 'TK_START_BLOCK']; + } + + if (c === '}') { + return [c, 'TK_END_BLOCK']; + } + + if (c === ';') { + return [c, 'TK_SEMICOLON']; + } + + if (c === '/') { + var comment = ''; + // peek for comment /* ... */ + var inline_comment = true; + if (input.charAt(parser_pos) === '*') { + parser_pos += 1; + if (parser_pos < input_length) { + while (parser_pos < input_length && + ! (input.charAt(parser_pos) === '*' && input.charAt(parser_pos + 1) && input.charAt(parser_pos + 1) === '/')) { + c = input.charAt(parser_pos); + comment += c; + if (c === "\n" || c === "\r") { + inline_comment = false; + } + parser_pos += 1; + if (parser_pos >= input_length) { + break; + } + } + } + parser_pos += 2; + if (inline_comment && n_newlines === 0) { + return ['/*' + comment + '*/', 'TK_INLINE_COMMENT']; + } else { + return ['/*' + comment + '*/', 'TK_BLOCK_COMMENT']; + } + } + // peek for comment // ... + if (input.charAt(parser_pos) === '/') { + comment = c; + while (input.charAt(parser_pos) !== '\r' && input.charAt(parser_pos) !== '\n') { + comment += input.charAt(parser_pos); + parser_pos += 1; + if (parser_pos >= input_length) { + break; + } + } + if (wanted_newline) { + print_newline(); + } + return [comment, 'TK_COMMENT']; + } + + } + + if (c === "'" || // string + c === '"' || // string + (c === '/' && + ((last_type === 'TK_WORD' && is_special_word(last_text)) || + (last_text === ')' && in_array(flags.previous_mode, ['(COND-EXPRESSION)', '(FOR-EXPRESSION)'])) || + (last_type === 'TK_COMMA' || last_type === 'TK_COMMENT' || last_type === 'TK_START_EXPR' || last_type === 'TK_START_BLOCK' || last_type === 'TK_END_BLOCK' || last_type === 'TK_OPERATOR' || last_type === 'TK_EQUALS' || last_type === 'TK_EOF' || last_type === 'TK_SEMICOLON')))) { // regexp + var sep = c; + var esc = false; + var esc1 = 0; + var esc2 = 0; + resulting_string = c; + + if (parser_pos < input_length) { + if (sep === '/') { + // + // handle regexp separately... + // + var in_char_class = false; + while (esc || in_char_class || input.charAt(parser_pos) !== sep) { + resulting_string += input.charAt(parser_pos); + if (!esc) { + esc = input.charAt(parser_pos) === '\\'; + if (input.charAt(parser_pos) === '[') { + in_char_class = true; + } else if (input.charAt(parser_pos) === ']') { + in_char_class = false; + } + } else { + esc = false; + } + parser_pos += 1; + if (parser_pos >= input_length) { + // incomplete string/rexp when end-of-file reached. + // bail out with what had been received so far. + return [resulting_string, 'TK_STRING']; + } + } + + } else { + // + // and handle string also separately + // + while (esc || input.charAt(parser_pos) !== sep) { + resulting_string += input.charAt(parser_pos); + if (esc1 && esc1 >= esc2) { + esc1 = parseInt(resulting_string.substr(-esc2), 16); + if (esc1 && esc1 >= 0x20 && esc1 <= 0x7e) { + esc1 = String.fromCharCode(esc1); + resulting_string = resulting_string.substr(0, resulting_string.length - esc2 - 2) + (((esc1 === sep) || (esc1 === '\\')) ? '\\' : '') + esc1; + } + esc1 = 0; + } + if (esc1) { + esc1++; + } else if (!esc) { + esc = input.charAt(parser_pos) === '\\'; + } else { + esc = false; + if (opt_unescape_strings) { + if (input.charAt(parser_pos) === 'x') { + esc1++; + esc2 = 2; + } else if (input.charAt(parser_pos) === 'u') { + esc1++; + esc2 = 4; + } + } + } + parser_pos += 1; + if (parser_pos >= input_length) { + // incomplete string/rexp when end-of-file reached. + // bail out with what had been received so far. + return [resulting_string, 'TK_STRING']; + } + } + } + + + + } + + parser_pos += 1; + + resulting_string += sep; + + if (sep === '/') { + // regexps may have modifiers /regexp/MOD , so fetch those, too + while (parser_pos < input_length && in_array(input.charAt(parser_pos), wordchar)) { + resulting_string += input.charAt(parser_pos); + parser_pos += 1; + } + } + return [resulting_string, 'TK_STRING']; + } + + if (c === '#') { + + + if (output.length === 0 && input.charAt(parser_pos) === '!') { + // shebang + resulting_string = c; + while (parser_pos < input_length && c !== '\n') { + c = input.charAt(parser_pos); + resulting_string += c; + parser_pos += 1; + } + output.push(trim(resulting_string) + '\n'); + print_newline(); + return get_next_token(); + } + + + + // Spidermonkey-specific sharp variables for circular references + // https://developer.mozilla.org/En/Sharp_variables_in_JavaScript + // http://mxr.mozilla.org/mozilla-central/source/js/src/jsscan.cpp around line 1935 + var sharp = '#'; + if (parser_pos < input_length && in_array(input.charAt(parser_pos), digits)) { + do { + c = input.charAt(parser_pos); + sharp += c; + parser_pos += 1; + } while (parser_pos < input_length && c !== '#' && c !== '='); + if (c === '#') { + // + } else if (input.charAt(parser_pos) === '[' && input.charAt(parser_pos + 1) === ']') { + sharp += '[]'; + parser_pos += 2; + } else if (input.charAt(parser_pos) === '{' && input.charAt(parser_pos + 1) === '}') { + sharp += '{}'; + parser_pos += 2; + } + return [sharp, 'TK_WORD']; + } + } + + if (c === '<' && input.substring(parser_pos - 1, parser_pos + 3) === '') { + flags.in_html_comment = false; + parser_pos += 2; + if (wanted_newline) { + print_newline(); + } + return ['-->', 'TK_COMMENT']; + } + + if (in_array(c, punct)) { + while (parser_pos < input_length && in_array(c + input.charAt(parser_pos), punct)) { + c += input.charAt(parser_pos); + parser_pos += 1; + if (parser_pos >= input_length) { + break; + } + } + + if (c === ',') { + return [c, 'TK_COMMA']; + } else if (c === '=') { + return [c, 'TK_EQUALS']; + } else { + return [c, 'TK_OPERATOR']; + } + } + + return [c, 'TK_UNKNOWN']; + } + + //---------------------------------- + indent_string = ''; + while (opt_indent_size > 0) { + indent_string += opt_indent_char; + opt_indent_size -= 1; + } + + while (js_source_text && (js_source_text.charAt(0) === ' ' || js_source_text.charAt(0) === '\t')) { + preindent_string += js_source_text.charAt(0); + js_source_text = js_source_text.substring(1); + } + input = js_source_text; + + last_word = ''; // last 'TK_WORD' passed + last_type = 'TK_START_EXPR'; // last token type + last_text = ''; // last token text + last_last_text = ''; // pre-last token text + output = []; + + do_block_just_closed = false; + + whitespace = "\n\r\t ".split(''); + wordchar = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$'.split(''); + digits = '0123456789'.split(''); + + punct = '+ - * / % & ++ -- = += -= *= /= %= == === != !== > < >= <= >> << >>> >>>= >>= <<= && &= | || ! !! , : ? ^ ^= |= ::'; + punct += ' <%= <% %> '; // try to be a good boy and try not to break the markup language identifiers + punct = punct.split(' '); + + // words which should always start on new line. + line_starters = 'continue,try,throw,return,var,if,switch,case,default,for,while,break,function'.split(','); + + // states showing if we are currently in expression (i.e. "if" case) - 'EXPRESSION', or in usual block (like, procedure), 'BLOCK'. + // some formatting depends on that. + flag_store = []; + set_mode('BLOCK'); + + parser_pos = 0; + while (true) { + var t = get_next_token(); + token_text = t[0]; + token_type = t[1]; + if (token_type === 'TK_EOF') { + break; + } + + switch (token_type) { + + case 'TK_START_EXPR': + + if (token_text === '[') { + + if (last_type === 'TK_WORD' || last_text === ')') { + // this is array index specifier, break immediately + // a[x], fn()[x] + if (in_array(last_text, line_starters)) { + print_single_space(); + } + set_mode('(EXPRESSION)'); + print_token(); + break; + } + + if (flags.mode === '[EXPRESSION]' || flags.mode === '[INDENTED-EXPRESSION]') { + if (last_last_text === ']' && last_text === ',') { + // ], [ goes to new line + if (flags.mode === '[EXPRESSION]') { + flags.mode = '[INDENTED-EXPRESSION]'; + if (!opt_keep_array_indentation) { + indent(); + } + } + set_mode('[EXPRESSION]'); + if (!opt_keep_array_indentation) { + print_newline(); + } + } else if (last_text === '[') { + if (flags.mode === '[EXPRESSION]') { + flags.mode = '[INDENTED-EXPRESSION]'; + if (!opt_keep_array_indentation) { + indent(); + } + } + set_mode('[EXPRESSION]'); + + if (!opt_keep_array_indentation) { + print_newline(); + } + } else { + set_mode('[EXPRESSION]'); + } + } else { + set_mode('[EXPRESSION]'); + } + + + + } else { + if (last_word === 'for') { + set_mode('(FOR-EXPRESSION)'); + } else if (in_array(last_word, ['if', 'while'])) { + set_mode('(COND-EXPRESSION)'); + } else { + set_mode('(EXPRESSION)'); + } + } + + if (last_text === ';' || last_type === 'TK_START_BLOCK') { + print_newline(); + } else if (last_type === 'TK_END_EXPR' || last_type === 'TK_START_EXPR' || last_type === 'TK_END_BLOCK' || last_text === '.') { + if (wanted_newline) { + print_newline(); + } + // do nothing on (( and )( and ][ and ]( and .( + } else if (last_type !== 'TK_WORD' && last_type !== 'TK_OPERATOR') { + print_single_space(); + } else if (last_word === 'function' || last_word === 'typeof') { + // function() vs function () + if (opt_jslint_happy) { + print_single_space(); + } + } else if (in_array(last_text, line_starters) || last_text === 'catch') { + if (opt_space_before_conditional) { + print_single_space(); + } + } + print_token(); + + break; + + case 'TK_END_EXPR': + if (token_text === ']') { + if (opt_keep_array_indentation) { + if (last_text === '}') { + // trim_output(); + // print_newline(true); + remove_indent(); + print_token(); + restore_mode(); + break; + } + } else { + if (flags.mode === '[INDENTED-EXPRESSION]') { + if (last_text === ']') { + restore_mode(); + print_newline(); + print_token(); + break; + } + } + } + } + restore_mode(); + print_token(); + break; + + case 'TK_START_BLOCK': + + if (last_word === 'do') { + set_mode('DO_BLOCK'); + } else { + set_mode('BLOCK'); + } + if (opt_brace_style === "expand" || opt_brace_style === "expand-strict") { + var empty_braces = false; + if (opt_brace_style === "expand-strict") { + empty_braces = (look_up() === '}'); + if (!empty_braces) { + print_newline(true); + } + } else { + if (last_type !== 'TK_OPERATOR') { + if (last_text === '=' || (is_special_word(last_text) && last_text !== 'else')) { + print_single_space(); + } else { + print_newline(true); + } + } + } + print_token(); + if (!empty_braces) { + indent(); + } + } else { + if (last_type !== 'TK_OPERATOR' && last_type !== 'TK_START_EXPR') { + if (last_type === 'TK_START_BLOCK') { + print_newline(); + } else { + print_single_space(); + } + } else { + // if TK_OPERATOR or TK_START_EXPR + if (is_array(flags.previous_mode) && last_text === ',') { + if (last_last_text === '}') { + // }, { in array context + print_single_space(); + } else { + print_newline(); // [a, b, c, { + } + } + } + indent(); + print_token(); + } + + break; + + case 'TK_END_BLOCK': + restore_mode(); + if (opt_brace_style === "expand" || opt_brace_style === "expand-strict") { + if (last_text !== '{') { + print_newline(); + } + print_token(); + } else { + if (last_type === 'TK_START_BLOCK') { + // nothing + if (just_added_newline) { + remove_indent(); + } else { + // {} + trim_output(); + } + } else { + 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(); + opt_keep_array_indentation = true; + + } else { + print_newline(); + } + } + print_token(); + } + break; + + case 'TK_WORD': + + // no, it's not you. even I have problems understanding how this works + // and what does what. + if (do_block_just_closed) { + // do {} ## while () + print_single_space(); + print_token(); + print_single_space(); + do_block_just_closed = false; + break; + } + + prefix = 'NONE'; + + if (token_text === 'function') { + if (flags.var_line && last_type !== 'TK_EQUALS' ) { + flags.var_line_reindented = true; + } + if ((just_added_newline || last_text === ';') && last_text !== '{' + && last_type !== 'TK_BLOCK_COMMENT' && last_type !== 'TK_COMMENT') { + // make sure there is a nice clean space of at least one blank line + // before a new function definition + n_newlines = just_added_newline ? n_newlines : 0; + if (!opt_preserve_newlines) { + n_newlines = 1; + } + + for (var i = 0; i < 2 - n_newlines; i++) { + print_newline(false); + } + } + if (last_type === 'TK_WORD') { + if (last_text === 'get' || last_text === 'set' || last_text === 'new' || last_text === 'return') { + print_single_space(); + } else { + print_newline(); + } + } else if (last_type === 'TK_OPERATOR' || last_text === '=') { + // foo = function + print_single_space(); + } else if (is_expression(flags.mode)) { + //ää print nothing + } else { + print_newline(); + } + + print_token(); + last_word = token_text; + break; + } + + if (token_text === 'case' || (token_text === 'default' && flags.in_case_statement)) { + if (last_text === ':' || flags.case_body) { + // switch cases following one another + remove_indent(); + } else { + // case statement starts in the same line where switch + if (!opt_indent_case) { + flags.indentation_level--; + } + print_newline(); + if (!opt_indent_case) { + flags.indentation_level++; + } + } + print_token(); + flags.in_case = true; + flags.in_case_statement = true; + flags.case_body = false; + break; + } + + if (last_type === 'TK_END_BLOCK') { + + if (!in_array(token_text.toLowerCase(), ['else', 'catch', 'finally'])) { + prefix = 'NEWLINE'; + } else { + if (opt_brace_style === "expand" || opt_brace_style === "end-expand" || opt_brace_style === "expand-strict") { + prefix = 'NEWLINE'; + } else { + prefix = 'SPACE'; + print_single_space(); + } + } + } else if (last_type === 'TK_SEMICOLON' && (flags.mode === 'BLOCK' || flags.mode === 'DO_BLOCK')) { + prefix = 'NEWLINE'; + } 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_WORD') { + if (last_text === 'else') { + // eat newlines between ...else *** some_op... + // won't preserve extra newlines in this place (if any), but don't care that much + trim_output(true); + } + prefix = 'SPACE'; + } else if (last_type === 'TK_START_BLOCK') { + prefix = 'NEWLINE'; + } else if (last_type === 'TK_END_EXPR') { + print_single_space(); + prefix = 'NEWLINE'; + } + + if (in_array(token_text, line_starters) && last_text !== ')') { + if (last_text === 'else') { + prefix = 'SPACE'; + } else { + prefix = 'NEWLINE'; + } + + } + + if (flags.if_line && last_type === 'TK_END_EXPR') { + flags.if_line = false; + } + if (in_array(token_text.toLowerCase(), ['else', 'catch', 'finally'])) { + if (last_type !== 'TK_END_BLOCK' || opt_brace_style === "expand" || opt_brace_style === "end-expand" || opt_brace_style === "expand-strict") { + print_newline(); + } else { + trim_output(true); + print_single_space(); + } + } else if (prefix === 'NEWLINE') { + if (is_special_word(last_text)) { + // no newline between 'return nnn' + print_single_space(); + } else if (last_type !== 'TK_END_EXPR') { + if ((last_type !== 'TK_START_EXPR' || token_text !== 'var') && last_text !== ':') { + // no need to force newline on 'var': for (var x = 0...) + if (token_text === 'if' && last_word === 'else' && last_text !== '{') { + // no newline for } else if { + print_single_space(); + } else { + flags.var_line = false; + flags.var_line_reindented = false; + print_newline(); + } + } + } else if (in_array(token_text, line_starters) && last_text !== ')') { + flags.var_line = false; + flags.var_line_reindented = false; + print_newline(); + } + } else if (is_array(flags.mode) && last_text === ',' && last_last_text === '}') { + print_newline(); // }, in lists get a newline treatment + } else if (prefix === 'SPACE') { + print_single_space(); + } + print_token(); + last_word = token_text; + + if (token_text === 'var') { + flags.var_line = true; + flags.var_line_reindented = false; + flags.var_line_tainted = false; + } + + if (token_text === 'if') { + flags.if_line = true; + } + if (token_text === 'else') { + flags.if_line = false; + } + + break; + + case 'TK_SEMICOLON': + + print_token(); + flags.var_line = false; + flags.var_line_reindented = false; + if (flags.mode === 'OBJECT') { + // OBJECT mode is weird and doesn't get reset too well. + flags.mode = 'BLOCK'; + } + break; + + case 'TK_STRING': + + if (last_type === 'TK_END_EXPR' && in_array(flags.previous_mode, ['(COND-EXPRESSION)', '(FOR-EXPRESSION)'])) { + print_single_space(); + } else if (last_type === 'TK_COMMENT' || last_type === 'TK_STRING' || last_type === 'TK_START_BLOCK' || last_type === 'TK_END_BLOCK' || last_type === 'TK_SEMICOLON') { + print_newline(); + } else if (last_type === 'TK_WORD') { + print_single_space(); + } + print_token(); + break; + + case 'TK_EQUALS': + if (flags.var_line) { + // just got an '=' in a var-line, different formatting/line-breaking, etc will now be done + flags.var_line_tainted = true; + } + print_single_space(); + print_token(); + print_single_space(); + break; + + case 'TK_COMMA': + if (flags.var_line) { + if (is_expression(flags.mode) || last_type === 'TK_END_BLOCK' ) { + // do not break on comma, for(var a = 1, b = 2) + flags.var_line_tainted = false; + } + if (flags.var_line_tainted) { + print_token(); + flags.var_line_reindented = true; + flags.var_line_tainted = false; + print_newline(); + break; + } else { + flags.var_line_tainted = false; + } + + print_token(); + print_single_space(); + break; + } + + if (last_type === 'TK_COMMENT') { + print_newline(); + } + + if (last_type === 'TK_END_BLOCK' && flags.mode !== "(EXPRESSION)") { + print_token(); + if (flags.mode === 'OBJECT' && last_text === '}') { + print_newline(); + } else { + print_single_space(); + } + } else { + if (flags.mode === 'OBJECT') { + print_token(); + print_newline(); + } else { + // EXPR or DO_BLOCK + print_token(); + print_single_space(); + } + } + break; + + + case 'TK_OPERATOR': + + var space_before = true; + var space_after = true; + + if (is_special_word(last_text)) { + // "return" had a special handling in TK_WORD. Now we need to return the favor + print_single_space(); + print_token(); + break; + } + + // hack for actionscript's import .*; + if (token_text === '*' && last_type === 'TK_UNKNOWN' && !last_last_text.match(/^\d+$/)) { + print_token(); + break; + } + + if (token_text === ':' && flags.in_case) { + if (opt_indent_case) { + flags.case_body = true; + } + print_token(); // colon really asks for separate treatment + print_newline(); + flags.in_case = false; + break; + } + + if (token_text === '::') { + // no spaces around exotic namespacing syntax operator + print_token(); + break; + } + + if (in_array(token_text, ['--', '++', '!']) || (in_array(token_text, ['-', '+']) && (in_array(last_type, ['TK_START_BLOCK', 'TK_START_EXPR', 'TK_EQUALS', 'TK_OPERATOR']) || in_array(last_text, line_starters)))) { + // unary operators (and binary +/- pretending to be unary) special cases + + space_before = false; + space_after = false; + + if (last_text === ';' && is_expression(flags.mode)) { + // for (;; ++i) + // ^^^ + space_before = true; + } + if (last_type === 'TK_WORD' && in_array(last_text, line_starters)) { + space_before = true; + } + + if (flags.mode === 'BLOCK' && (last_text === '{' || last_text === ';')) { + // { foo; --i } + // foo(); --bar; + print_newline(); + } + } else if (token_text === '.') { + // decimal digits or object.property + space_before = false; + + } else if (token_text === ':') { + if (flags.ternary_depth === 0) { + if (flags.mode === 'BLOCK') { + flags.mode = 'OBJECT'; + } + space_before = false; + } else { + flags.ternary_depth -= 1; + } + } else if (token_text === '?') { + flags.ternary_depth += 1; + } + if (space_before) { + print_single_space(); + } + + print_token(); + + if (space_after) { + print_single_space(); + } + + break; + + case 'TK_BLOCK_COMMENT': + + var lines = split_newlines(token_text); + var j; // iterator for this case + + if (all_lines_start_with(lines.slice(1), '*')) { + // javadoc: reformat and reindent + print_newline(); + output.push(lines[0]); + for (j = 1; j < lines.length; j++) { + print_newline(); + output.push(' '); + output.push(trim(lines[j])); + } + + } else { + + // simple block comment: leave intact + if (lines.length > 1) { + // multiline comment block starts with a new line + print_newline(); + } else { + // single-line /* comment */ stays where it is + if (last_type === 'TK_END_BLOCK') { + print_newline(); + } else { + print_single_space(); + } + + } + + for (j = 0; j < lines.length; j++) { + output.push(lines[j]); + output.push("\n"); + } + + } + if (look_up('\n') !== '\n') { + print_newline(); + } + break; + + case 'TK_INLINE_COMMENT': + print_single_space(); + print_token(); + if (is_expression(flags.mode)) { + print_single_space(); + } else { + force_newline(); + } + break; + + case 'TK_COMMENT': + + if (last_text === ',' && !wanted_newline) { + trim_output(true); + } + if (last_type !== 'TK_COMMENT') { + if (wanted_newline) { + print_newline(); + } else { + print_single_space(); + } + } + print_token(); + print_newline(); + break; + + case 'TK_UNKNOWN': + if (is_special_word(last_text)) { + print_single_space(); + } + print_token(); + break; + } + + last_last_text = last_text; + last_type = token_type; + last_text = token_text; + } + + var sweet_code = preindent_string + output.join('').replace(/[\r\n ]+$/, ''); + return sweet_code; + +} diff --git a/toolkit/devtools/Loader.jsm b/toolkit/devtools/Loader.jsm index 4f7b4cd9144a..933d3d24c933 100644 --- a/toolkit/devtools/Loader.jsm +++ b/toolkit/devtools/Loader.jsm @@ -96,8 +96,6 @@ BuiltinProvider.prototype = { "devtools/touch-events": "resource://gre/modules/devtools/touch-events", "devtools/client": "resource://gre/modules/devtools/client", "devtools/pretty-fast": "resource://gre/modules/devtools/pretty-fast.js", - "devtools/jsbeautify/": "resource://gre/modules/devtools/jsbeautify/", - "devtools/jsbeautify": "resource://gre/modules/devtools/jsbeautify/beautify.js", "devtools/async-utils": "resource://gre/modules/devtools/async-utils", "devtools/content-observer": "resource://gre/modules/devtools/content-observer", "gcli": "resource://gre/modules/devtools/gcli", diff --git a/toolkit/devtools/gcli/commands/jsb.js b/toolkit/devtools/gcli/commands/jsb.js index f5409a088400..b110aa35a662 100644 --- a/toolkit/devtools/gcli/commands/jsb.js +++ b/toolkit/devtools/gcli/commands/jsb.js @@ -7,11 +7,9 @@ const { Cc, Ci, Cu } = require("chrome"); const gcli = require("gcli/index"); const XMLHttpRequest = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"]; -const { devtools } = Cu.import("resource://gre/modules/devtools/Loader.jsm", {}); loader.lazyImporter(this, "Preferences", "resource://gre/modules/Preferences.jsm"); - -devtools.lazyRequireGetter(this, "beautify", "devtools/jsbeautify"); +loader.lazyImporter(this, "js_beautify", "resource:///modules/devtools/Jsbeautify.jsm"); exports.items = [ { @@ -118,7 +116,7 @@ exports.items = [ let browserDoc = context.environment.chromeDocument; let browserWindow = browserDoc.defaultView; let gBrowser = browserWindow.gBrowser; - let result = beautify.js(xhr.responseText, opts); + let result = js_beautify(xhr.responseText, opts); browserWindow.Scratchpad.ScratchpadManager.openScratchpad({text: result}); diff --git a/toolkit/devtools/jsbeautify/UPGRADING.md b/toolkit/devtools/jsbeautify/UPGRADING.md deleted file mode 100644 index 45bef067ea40..000000000000 --- a/toolkit/devtools/jsbeautify/UPGRADING.md +++ /dev/null @@ -1,37 +0,0 @@ -# UPGRADING - -1. `git clone https://github.com/beautify-web/js-beautify.git` - -2. Copy `js/lib/beautify.js` to `toolkit/devtools/jsbeautify/src/beautify-js.js` - -3. Remove the acorn section from the file and add the following to the top: - - ``` - const acorn = require("acorn/acorn"); - ``` - -4. Just above `function Beautifier(js_source_text, options) {` add: - - ``` - exports.jsBeautify = js_beautify; - ``` - -5. Copy `beautify-html.js` to `toolkit/devtools/jsbeautify/src/beautify-html.js` - -6. Replace the require blocks at the bottom of the file with: - - ``` - var beautify = require('devtools/jsbeautify'); - - exports.htmlBeautify = function(html_source, options) { - return style_html(html_source, options, beautify.js, beautify.css); - }; - ``` - -7. Copy `beautify-css.js` to `toolkit/devtools/jsbeautify/src/beautify-css.js` - -8. Replace the global define block at the bottom of the file with: - ``` - exports.cssBeautify = css_beautify; - ``` -9. Copy `js/test/beautify-tests.js` to `toolkit/devtools/jsbeautify/src/beautify-tests.js` diff --git a/toolkit/devtools/jsbeautify/beautify.js b/toolkit/devtools/jsbeautify/beautify.js deleted file mode 100644 index 3d300bec7748..000000000000 --- a/toolkit/devtools/jsbeautify/beautify.js +++ /dev/null @@ -1,7 +0,0 @@ -var { cssBeautify } = require("devtools/jsbeautify/beautify-css"); -var { htmlBeautify } = require("devtools/jsbeautify/beautify-html"); -var { jsBeautify } = require("devtools/jsbeautify/beautify-js"); - -exports.css = cssBeautify; -exports.html = htmlBeautify; -exports.js = jsBeautify; diff --git a/toolkit/devtools/jsbeautify/lib/sanitytest.js b/toolkit/devtools/jsbeautify/lib/sanitytest.js deleted file mode 100644 index f072a74b119c..000000000000 --- a/toolkit/devtools/jsbeautify/lib/sanitytest.js +++ /dev/null @@ -1,137 +0,0 @@ -// -// simple testing interface -// written by Einar Lielmanis, einar@jsbeautifier.org -// -// usage: -// -// var t = new SanityTest(function (x) { return x; }, 'my function'); -// t.expect('input', 'output'); -// t.expect('a', 'a'); -// output_somewhere(t.results()); // good for 
, html safe-ish
-// alert(t.results_raw());        // html unescaped
-
-
-function SanityTest (func, name_of_test) {
-
-    var test_func = func || function (x) {
-        return x;
-    };
-
-    var test_name = name_of_test || '';
-
-    var n_failed = 0;
-    var n_succeeded = 0;
-
-    this.failures = [];
-    this.successes = [];
-
-    this.test_function = function(func, name) {
-        test_func = func;
-        test_name = name || '';
-    };
-
-    this.get_exitcode = function() {
-        return n_succeeded === 0 || n_failed !== 0 ? 1 : 0;
-    };
-
-    this.expect = function(parameters, expected_value) {
-        // multi-parameter calls not supported (I don't need them now).
-        var result = test_func(parameters);
-        // proper array checking is a pain. i'll maybe do it later, compare strings representations instead
-        if ((result === expected_value) || (expected_value instanceof Array && result.join(', ') == expected_value.join(', '))) {
-            n_succeeded += 1;
-            this.successes.push([test_name, parameters, expected_value, result]);
-        } else {
-            n_failed += 1;
-            this.failures.push([test_name, parameters, expected_value, result]);
-        }
-    };
-
-
-    this.results_raw = function() {
-        var results = '';
-        if (n_failed === 0) {
-            if (n_succeeded === 0) {
-                results = 'No tests run.';
-            } else {
-                results = 'All ' + n_succeeded + ' tests passed.';
-            }
-        } else {
-            for (var i = 0 ; i < this.failures.length; i++) {
-                var f = this.failures[i];
-                if (f[0]) {
-                    f[0] = f[0] + ' ';
-                }
-                results += '---- ' + f[0] + 'input -------\n' + this.prettyprint(f[1]) + '\n';
-                results += '---- ' + f[0] + 'expected ----\n' + this.prettyprint(f[2]) + '\n';
-                results += '---- ' + f[0] + 'output ------\n' + this.prettyprint(f[3]) + '\n\n';
-
-            }
-            results += n_failed + ' tests failed.\n';
-        }
-        return results;
-    };
-
-
-    this.results = function() {
-        return this.lazy_escape(this.results_raw());
-    };
-
-
-    this.prettyprint = function(something, quote_strings) {
-        var type = typeof something;
-        switch(type.toLowerCase()) {
-        case 'string':
-            if (quote_strings) {
-                return "'" + something.replace("'", "\\'") + "'";
-            } else {
-                return something;
-            }
-        case 'number':
-            return '' + something;
-        case 'boolean':
-            return something ? 'true' : 'false';
-        case 'undefined':
-            return 'undefined';
-        case 'object':
-            if (something instanceof Array) {
-                var x = [];
-                var expected_index = 0;
-                for (var k in something) {
-                    if (k == expected_index) {
-                        x.push(this.prettyprint(something[k], true));
-                        expected_index += 1;
-                    } else {
-                        x.push('\n' + k + ': ' + this.prettyprint(something[k], true));
-                    }
-                }
-                return '[' + x.join(', ') + ']';
-            } else {
-                return 'object: ' + something;
-            }
-        default:
-            return type + ': ' + something;
-        }
-    };
-
-
-    this.lazy_escape = function (str) {
-        return str.replace(//g, '>').replace(/\n/g, '
');
-    };
-
-
-    this.log = function () {
-        if (window.console) {
-            if (console.firebug) {
-                console.log.apply(console, Array.prototype.slice.call(arguments));
-            } else {
-                console.log.call(console, Array.prototype.slice.call(arguments));
-            }
-        }
-    };
-
-}
-
-if (typeof module !== 'undefined' && module.exports) {
-    module.exports = SanityTest;
-}
diff --git a/toolkit/devtools/jsbeautify/lib/urlencode_unpacker.js b/toolkit/devtools/jsbeautify/lib/urlencode_unpacker.js
deleted file mode 100644
index 56971cdc3081..000000000000
--- a/toolkit/devtools/jsbeautify/lib/urlencode_unpacker.js
+++ /dev/null
@@ -1,73 +0,0 @@
-/*global unescape */
-/*jshint curly: false, scripturl: true */
-//
-// trivial bookmarklet/escaped script detector for the javascript beautifier
-// written by Einar Lielmanis 
-//
-// usage:
-//
-// if (Urlencoded.detect(some_string)) {
-//     var unpacked = Urlencoded.unpack(some_string);
-// }
-//
-//
-
-var isNode = (typeof module !== 'undefined' && module.exports);
-if (isNode) {
-    var SanityTest = require("devtools/jsbeautify/sanitytest");
-}
-
-var Urlencoded = {
-    detect: function (str) {
-        // the fact that script doesn't contain any space, but has %20 instead
-        // should be sufficient check for now.
-        if (str.indexOf(' ') == -1) {
-            if (str.indexOf('%2') != -1) return true;
-            if (str.replace(/[^%]+/g, '').length > 3) return true;
-        }
-        return false;
-    },
-
-    unpack: function (str) {
-        if (Urlencoded.detect(str)) {
-            if (str.indexOf('%2B') != -1 || str.indexOf('%2b') != -1) {
-                // "+" escaped as "%2B"
-                return unescape(str.replace(/\+/g, '%20'));
-            } else {
-                return unescape(str);
-            }
-        }
-        return str;
-    },
-
-
-
-    run_tests: function (sanity_test) {
-        var t = sanity_test || new SanityTest();
-        t.test_function(Urlencoded.detect, "Urlencoded.detect");
-        t.expect('', false);
-        t.expect('var a = b', false);
-        t.expect('var%20a+=+b', true);
-        t.expect('var%20a=b', true);
-        t.expect('var%20%21%22', true);
-        t.expect('javascript:(function(){var%20whatever={init:function(){alert(%22a%22+%22b%22)}};whatever.init()})();', true);
-        t.test_function(Urlencoded.unpack, 'Urlencoded.unpack');
-
-        t.expect('javascript:(function(){var%20whatever={init:function(){alert(%22a%22+%22b%22)}};whatever.init()})();',
-            'javascript:(function(){var whatever={init:function(){alert("a"+"b")}};whatever.init()})();'
-        );
-        t.expect('', '');
-        t.expect('abcd', 'abcd');
-        t.expect('var a = b', 'var a = b');
-        t.expect('var%20a=b', 'var a=b');
-        t.expect('var%20a=b+1', 'var a=b+1');
-        t.expect('var%20a=b%2b1', 'var a=b+1');
-        return t;
-    }
-
-
-};
-
-if (isNode) {
-    module.exports = Urlencoded;
-}
diff --git a/toolkit/devtools/jsbeautify/moz.build b/toolkit/devtools/jsbeautify/moz.build
deleted file mode 100644
index 23cf8c785cb6..000000000000
--- a/toolkit/devtools/jsbeautify/moz.build
+++ /dev/null
@@ -1,19 +0,0 @@
-# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
-# vim: set filetype=python:
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-XPCSHELL_TESTS_MANIFESTS += ['tests/unit/xpcshell.ini']
-
-JS_MODULES_PATH = 'modules/devtools/jsbeautify'
-
-EXTRA_JS_MODULES += [
-    'beautify.js',
-    'lib/sanitytest.js',
-    'lib/urlencode_unpacker.js',
-    'src/beautify-css.js',
-    'src/beautify-html.js',
-    'src/beautify-js.js',
-    'src/beautify-tests.js'
-]
diff --git a/toolkit/devtools/jsbeautify/src/beautify-css.js b/toolkit/devtools/jsbeautify/src/beautify-css.js
deleted file mode 100644
index faf9ac0f2e41..000000000000
--- a/toolkit/devtools/jsbeautify/src/beautify-css.js
+++ /dev/null
@@ -1,367 +0,0 @@
-/*jshint curly:true, eqeqeq:true, laxbreak:true, noempty:false */
-/*
-
-  The MIT License (MIT)
-
-  Copyright (c) 2007-2013 Einar Lielmanis and contributors.
-
-  Permission is hereby granted, free of charge, to any person
-  obtaining a copy of this software and associated documentation files
-  (the "Software"), to deal in the Software without restriction,
-  including without limitation the rights to use, copy, modify, merge,
-  publish, distribute, sublicense, and/or sell copies of the Software,
-  and to permit persons to whom the Software is furnished to do so,
-  subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be
-  included in all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.
-
-
- CSS Beautifier
----------------
-
-    Written by Harutyun Amirjanyan, (amirjanyan@gmail.com)
-
-    Based on code initially developed by: Einar Lielmanis, 
-        http://jsbeautifier.org/
-
-    Usage:
-        css_beautify(source_text);
-        css_beautify(source_text, options);
-
-    The options are (default in brackets):
-        indent_size (4)                   — indentation size,
-        indent_char (space)               — character to indent with,
-        selector_separator_newline (true) - separate selectors with newline or
-                                            not (e.g. "a,\nbr" or "a, br")
-        end_with_newline (false)          - end with a newline
-
-    e.g
-
-    css_beautify(css_source_text, {
-      'indent_size': 1,
-      'indent_char': '\t',
-      'selector_separator': ' ',
-      'end_with_newline': false,
-    });
-*/
-
-// http://www.w3.org/TR/CSS21/syndata.html#tokenization
-// http://www.w3.org/TR/css3-syntax/
-
-(function () {
-    function css_beautify(source_text, options) {
-        options = options || {};
-        var indentSize = options.indent_size || 4;
-        var indentCharacter = options.indent_char || ' ';
-        var selectorSeparatorNewline = (options.selector_separator_newline === undefined) ? true : options.selector_separator_newline;
-        var endWithNewline = (options.end_with_newline === undefined) ? false : options.end_with_newline;
-
-        // compatibility
-        if (typeof indentSize === "string") {
-            indentSize = parseInt(indentSize, 10);
-        }
-
-
-        // tokenizer
-        var whiteRe = /^\s+$/;
-        var wordRe = /[\w$\-_]/;
-
-        var pos = -1,
-            ch;
-
-        function next() {
-            ch = source_text.charAt(++pos);
-            return ch;
-        }
-
-        function peek() {
-            return source_text.charAt(pos + 1);
-        }
-
-        function eatString(endChar) {
-            var start = pos;
-            while (next()) {
-                if (ch === "\\") {
-                    next();
-                    next();
-                } else if (ch === endChar) {
-                    break;
-                } else if (ch === "\n") {
-                    break;
-                }
-            }
-            return source_text.substring(start, pos + 1);
-        }
-
-        function eatWhitespace() {
-            var start = pos;
-            while (whiteRe.test(peek())) {
-                pos++;
-            }
-            return pos !== start;
-        }
-
-        function skipWhitespace() {
-            var start = pos;
-            do {} while (whiteRe.test(next()));
-            return pos !== start + 1;
-        }
-
-        function eatComment(singleLine) {
-            var start = pos;
-            next();
-            while (next()) {
-                if (ch === "*" && peek() === "/") {
-                    pos++;
-                    break;
-                } else if (singleLine && ch === "\n") {
-                    break;
-                }
-            }
-
-            return source_text.substring(start, pos + 1);
-        }
-
-
-        function lookBack(str) {
-            return source_text.substring(pos - str.length, pos).toLowerCase() ===
-                str;
-        }
-
-        function isCommentOnLine() {
-            var endOfLine = source_text.indexOf('\n', pos);
-            if (endOfLine === -1) {
-                return false;
-            }
-            var restOfLine = source_text.substring(pos, endOfLine);
-            return restOfLine.indexOf('//') !== -1;
-        }
-
-        // printer
-        var indentString = source_text.match(/^[\r\n]*[\t ]*/)[0];
-        var singleIndent = new Array(indentSize + 1).join(indentCharacter);
-        var indentLevel = 0;
-        var nestedLevel = 0;
-
-        function indent() {
-            indentLevel++;
-            indentString += singleIndent;
-        }
-
-        function outdent() {
-            indentLevel--;
-            indentString = indentString.slice(0, -indentSize);
-        }
-
-        var print = {};
-        print["{"] = function (ch) {
-            print.singleSpace();
-            output.push(ch);
-            print.newLine();
-        };
-        print["}"] = function (ch) {
-            print.newLine();
-            output.push(ch);
-            print.newLine();
-        };
-
-        print._lastCharWhitespace = function () {
-            return whiteRe.test(output[output.length - 1]);
-        };
-
-        print.newLine = function (keepWhitespace) {
-            if (!keepWhitespace) {
-                while (print._lastCharWhitespace()) {
-                    output.pop();
-                }
-            }
-
-            if (output.length) {
-                output.push('\n');
-            }
-            if (indentString) {
-                output.push(indentString);
-            }
-        };
-        print.singleSpace = function () {
-            if (output.length && !print._lastCharWhitespace()) {
-                output.push(' ');
-            }
-        };
-        var output = [];
-        if (indentString) {
-            output.push(indentString);
-        }
-        /*_____________________--------------------_____________________*/
-
-        var insideRule = false;
-        var enteringConditionalGroup = false;
-
-        while (true) {
-            var isAfterSpace = skipWhitespace();
-
-            if (!ch) {
-                break;
-            } else if (ch === '/' && peek() === '*') { /* css comment */
-                print.newLine();
-                output.push(eatComment(), "\n", indentString);
-                var header = lookBack("");
-                if (header) {
-                    print.newLine();
-                }
-            } else if (ch === '/' && peek() === '/') { // single line comment
-                output.push(eatComment(true), indentString);
-            } else if (ch === '@') {
-                // strip trailing space, if present, for hash property checks
-                var atRule = eatString(" ").replace(/ $/, '');
-
-                // pass along the space we found as a separate item
-                output.push(atRule, ch);
-
-                // might be a nesting at-rule
-                if (atRule in css_beautify.NESTED_AT_RULE) {
-                    nestedLevel += 1;
-                    if (atRule in css_beautify.CONDITIONAL_GROUP_RULE) {
-                        enteringConditionalGroup = true;
-                    }
-                }
-            } else if (ch === '{') {
-                eatWhitespace();
-                if (peek() === '}') {
-                    next();
-                    output.push(" {}");
-                } else {
-                    indent();
-                    print["{"](ch);
-                    // when entering conditional groups, only rulesets are allowed
-                    if (enteringConditionalGroup) {
-                        enteringConditionalGroup = false;
-                        insideRule = (indentLevel > nestedLevel);
-                    } else {
-                        // otherwise, declarations are also allowed
-                        insideRule = (indentLevel >= nestedLevel);
-                    }
-                }
-            } else if (ch === '}') {
-                outdent();
-                print["}"](ch);
-                insideRule = false;
-                if (nestedLevel) {
-                    nestedLevel--;
-                }
-            } else if (ch === ":") {
-                eatWhitespace();
-                if (insideRule || enteringConditionalGroup) {
-                    // 'property: value' delimiter
-                    // which could be in a conditional group query
-                    output.push(ch, " ");
-                } else {
-                    if (peek() === ":") {
-                        // pseudo-element
-                        next();
-                        output.push("::");
-                    } else {
-                        // pseudo-class
-                        output.push(ch);
-                    }
-                }
-            } else if (ch === '"' || ch === '\'') {
-                output.push(eatString(ch));
-            } else if (ch === ';') {
-                if (isCommentOnLine()) {
-                    var beforeComment = eatString('/');
-                    var comment = eatComment(true);
-                    output.push(beforeComment, comment.substring(1, comment.length - 1), '\n', indentString);
-                } else {
-                    output.push(ch, '\n', indentString);
-                }
-            } else if (ch === '(') { // may be a url
-                if (lookBack("url")) {
-                    output.push(ch);
-                    eatWhitespace();
-                    if (next()) {
-                        if (ch !== ')' && ch !== '"' && ch !== '\'') {
-                            output.push(eatString(')'));
-                        } else {
-                            pos--;
-                        }
-                    }
-                } else {
-                    if (isAfterSpace) {
-                        print.singleSpace();
-                    }
-                    output.push(ch);
-                    eatWhitespace();
-                }
-            } else if (ch === ')') {
-                output.push(ch);
-            } else if (ch === ',') {
-                eatWhitespace();
-                output.push(ch);
-                if (!insideRule && selectorSeparatorNewline) {
-                    print.newLine();
-                } else {
-                    print.singleSpace();
-                }
-            } else if (ch === ']') {
-                output.push(ch);
-            } else if (ch === '[') {
-                if (isAfterSpace) {
-                    print.singleSpace();
-                }
-                output.push(ch);
-            } else if (ch === '=') { // no whitespace before or after
-                eatWhitespace();
-                output.push(ch);
-            } else {
-                if (isAfterSpace) {
-                    print.singleSpace();
-                }
-
-                output.push(ch);
-            }
-        }
-
-
-        var sweetCode = output.join('').replace(/[\n ]+$/, '');
-
-        // establish end_with_newline
-        var should = endWithNewline;
-        var actually = /\n$/.test(sweetCode);
-        if (should && !actually) {
-            sweetCode += "\n";
-        } else if (!should && actually) {
-            sweetCode = sweetCode.slice(0, -1);
-        }
-
-        return sweetCode;
-    }
-
-    // https://developer.mozilla.org/en-US/docs/Web/CSS/At-rule
-    css_beautify.NESTED_AT_RULE = {
-        "@page": true,
-        "@font-face": true,
-        "@keyframes": true,
-        // also in CONDITIONAL_GROUP_RULE below
-        "@media": true,
-        "@supports": true,
-        "@document": true
-    };
-    css_beautify.CONDITIONAL_GROUP_RULE = {
-        "@media": true,
-        "@supports": true,
-        "@document": true
-    };
-
-    exports.cssBeautify = css_beautify;
-}());
diff --git a/toolkit/devtools/jsbeautify/src/beautify-html.js b/toolkit/devtools/jsbeautify/src/beautify-html.js
deleted file mode 100644
index abddf6a327ca..000000000000
--- a/toolkit/devtools/jsbeautify/src/beautify-html.js
+++ /dev/null
@@ -1,822 +0,0 @@
-/*jshint curly:true, eqeqeq:true, laxbreak:true, noempty:false */
-/*
-
-  The MIT License (MIT)
-
-  Copyright (c) 2007-2013 Einar Lielmanis and contributors.
-
-  Permission is hereby granted, free of charge, to any person
-  obtaining a copy of this software and associated documentation files
-  (the "Software"), to deal in the Software without restriction,
-  including without limitation the rights to use, copy, modify, merge,
-  publish, distribute, sublicense, and/or sell copies of the Software,
-  and to permit persons to whom the Software is furnished to do so,
-  subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be
-  included in all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.
-
-
- Style HTML
----------------
-
-  Written by Nochum Sossonko, (nsossonko@hotmail.com)
-
-  Based on code initially developed by: Einar Lielmanis, 
-    http://jsbeautifier.org/
-
-  Usage:
-    style_html(html_source);
-
-    style_html(html_source, options);
-
-  The options are:
-    indent_inner_html (default false)  — indent  and  sections,
-    indent_size (default 4)          — indentation size,
-    indent_char (default space)      — character to indent with,
-    wrap_line_length (default 250)            -  maximum amount of characters per line (0 = disable)
-    brace_style (default "collapse") - "collapse" | "expand" | "end-expand"
-            put braces on the same line as control statements (default), or put braces on own line (Allman / ANSI style), or just put end braces on own line.
-    unformatted (defaults to inline tags) - list of tags, that shouldn't be reformatted
-    indent_scripts (default normal)  - "keep"|"separate"|"normal"
-    preserve_newlines (default true) - whether existing line breaks before elements should be preserved
-                                        Only works before elements, not inside tags or for text.
-    max_preserve_newlines (default unlimited) - maximum number of line breaks to be preserved in one chunk
-    indent_handlebars (default false) - format and indent {{#foo}} and {{/foo}}
-
-    e.g.
-
-    style_html(html_source, {
-      'indent_inner_html': false,
-      'indent_size': 2,
-      'indent_char': ' ',
-      'wrap_line_length': 78,
-      'brace_style': 'expand',
-      'unformatted': ['a', 'sub', 'sup', 'b', 'i', 'u'],
-      'preserve_newlines': true,
-      'max_preserve_newlines': 5,
-      'indent_handlebars': false
-    });
-*/
-
-(function() {
-
-    function trim(s) {
-        return s.replace(/^\s+|\s+$/g, '');
-    }
-
-    function ltrim(s) {
-        return s.replace(/^\s+/g, '');
-    }
-
-    function style_html(html_source, options, js_beautify, css_beautify) {
-        //Wrapper function to invoke all the necessary constructors and deal with the output.
-
-        var multi_parser,
-            indent_inner_html,
-            indent_size,
-            indent_character,
-            wrap_line_length,
-            brace_style,
-            unformatted,
-            preserve_newlines,
-            max_preserve_newlines,
-            indent_handlebars;
-
-        options = options || {};
-
-        // backwards compatibility to 1.3.4
-        if ((options.wrap_line_length === undefined || parseInt(options.wrap_line_length, 10) === 0) &&
-                (options.max_char !== undefined && parseInt(options.max_char, 10) !== 0)) {
-            options.wrap_line_length = options.max_char;
-        }
-
-        indent_inner_html = (options.indent_inner_html === undefined) ? false : options.indent_inner_html;
-        indent_size = (options.indent_size === undefined) ? 4 : parseInt(options.indent_size, 10);
-        indent_character = (options.indent_char === undefined) ? ' ' : options.indent_char;
-        brace_style = (options.brace_style === undefined) ? 'collapse' : options.brace_style;
-        wrap_line_length =  parseInt(options.wrap_line_length, 10) === 0 ? 32786 : parseInt(options.wrap_line_length || 250, 10);
-        unformatted = options.unformatted || ['a', 'span', 'bdo', 'em', 'strong', 'dfn', 'code', 'samp', 'kbd', 'var', 'cite', 'abbr', 'acronym', 'q', 'sub', 'sup', 'tt', 'i', 'b', 'big', 'small', 'u', 's', 'strike', 'font', 'ins', 'del', 'pre', 'address', 'dt', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6'];
-        preserve_newlines = (options.preserve_newlines === undefined) ? true : options.preserve_newlines;
-        max_preserve_newlines = preserve_newlines ?
-            (isNaN(parseInt(options.max_preserve_newlines, 10)) ? 32786 : parseInt(options.max_preserve_newlines, 10))
-            : 0;
-        indent_handlebars = (options.indent_handlebars === undefined) ? false : options.indent_handlebars;
-
-        function Parser() {
-
-            this.pos = 0; //Parser position
-            this.token = '';
-            this.current_mode = 'CONTENT'; //reflects the current Parser mode: TAG/CONTENT
-            this.tags = { //An object to hold tags, their position, and their parent-tags, initiated with default values
-                parent: 'parent1',
-                parentcount: 1,
-                parent1: ''
-            };
-            this.tag_type = '';
-            this.token_text = this.last_token = this.last_text = this.token_type = '';
-            this.newlines = 0;
-            this.indent_content = indent_inner_html;
-
-            this.Utils = { //Uilities made available to the various functions
-                whitespace: "\n\r\t ".split(''),
-                single_token: 'br,input,link,meta,!doctype,basefont,base,area,hr,wbr,param,img,isindex,?xml,embed,?php,?,?='.split(','), //all the single tags for HTML
-                extra_liners: 'head,body,/html'.split(','), //for tags that need a line of whitespace before them
-                in_array: function(what, arr) {
-                    for (var i = 0; i < arr.length; i++) {
-                        if (what === arr[i]) {
-                            return true;
-                        }
-                    }
-                    return false;
-                }
-            };
-
-            this.traverse_whitespace = function() {
-                var input_char = '';
-
-                input_char = this.input.charAt(this.pos);
-                if (this.Utils.in_array(input_char, this.Utils.whitespace)) {
-                    this.newlines = 0;
-                    while (this.Utils.in_array(input_char, this.Utils.whitespace)) {
-                        if (preserve_newlines && input_char === '\n' && this.newlines <= max_preserve_newlines) {
-                            this.newlines += 1;
-                        }
-
-                        this.pos++;
-                        input_char = this.input.charAt(this.pos);
-                    }
-                    return true;
-                }
-                return false;
-            };
-
-            this.get_content = function() { //function to capture regular content between tags
-
-                var input_char = '',
-                    content = [],
-                    space = false; //if a space is needed
-
-                while (this.input.charAt(this.pos) !== '<') {
-                    if (this.pos >= this.input.length) {
-                        return content.length ? content.join('') : ['', 'TK_EOF'];
-                    }
-
-                    if (this.traverse_whitespace()) {
-                        if (content.length) {
-                            space = true;
-                        }
-                        continue; //don't want to insert unnecessary space
-                    }
-
-                    if (indent_handlebars) {
-                        // Handlebars parsing is complicated.
-                        // {{#foo}} and {{/foo}} are formatted tags.
-                        // {{something}} should get treated as content, except:
-                        // {{else}} specifically behaves like {{#if}} and {{/if}}
-                        var peek3 = this.input.substr(this.pos, 3);
-                        if (peek3 === '{{#' || peek3 === '{{/') {
-                            // These are tags and not content.
-                            break;
-                        } else if (this.input.substr(this.pos, 2) === '{{') {
-                            if (this.get_tag(true) === '{{else}}') {
-                                break;
-                            }
-                        }
-                    }
-
-                    input_char = this.input.charAt(this.pos);
-                    this.pos++;
-
-                    if (space) {
-                        if (this.line_char_count >= this.wrap_line_length) { //insert a line when the wrap_line_length is reached
-                            this.print_newline(false, content);
-                            this.print_indentation(content);
-                        } else {
-                            this.line_char_count++;
-                            content.push(' ');
-                        }
-                        space = false;
-                    }
-                    this.line_char_count++;
-                    content.push(input_char); //letter at-a-time (or string) inserted to an array
-                }
-                return content.length ? content.join('') : '';
-            };
-
-            this.get_contents_to = function(name) { //get the full content of a script or style to pass to js_beautify
-                if (this.pos === this.input.length) {
-                    return ['', 'TK_EOF'];
-                }
-                var input_char = '';
-                var content = '';
-                var reg_match = new RegExp('', 'igm');
-                reg_match.lastIndex = this.pos;
-                var reg_array = reg_match.exec(this.input);
-                var end_script = reg_array ? reg_array.index : this.input.length; //absolute end of script
-                if (this.pos < end_script) { //get everything in between the script tags
-                    content = this.input.substring(this.pos, end_script);
-                    this.pos = end_script;
-                }
-                return content;
-            };
-
-            this.record_tag = function(tag) { //function to record a tag and its parent in this.tags Object
-                if (this.tags[tag + 'count']) { //check for the existence of this tag type
-                    this.tags[tag + 'count']++;
-                    this.tags[tag + this.tags[tag + 'count']] = this.indent_level; //and record the present indent level
-                } else { //otherwise initialize this tag type
-                    this.tags[tag + 'count'] = 1;
-                    this.tags[tag + this.tags[tag + 'count']] = this.indent_level; //and record the present indent level
-                }
-                this.tags[tag + this.tags[tag + 'count'] + 'parent'] = this.tags.parent; //set the parent (i.e. in the case of a div this.tags.div1parent)
-                this.tags.parent = tag + this.tags[tag + 'count']; //and make this the current parent (i.e. in the case of a div 'div1')
-            };
-
-            this.retrieve_tag = function(tag) { //function to retrieve the opening tag to the corresponding closer
-                if (this.tags[tag + 'count']) { //if the openener is not in the Object we ignore it
-                    var temp_parent = this.tags.parent; //check to see if it's a closable tag.
-                    while (temp_parent) { //till we reach '' (the initial value);
-                        if (tag + this.tags[tag + 'count'] === temp_parent) { //if this is it use it
-                            break;
-                        }
-                        temp_parent = this.tags[temp_parent + 'parent']; //otherwise keep on climbing up the DOM Tree
-                    }
-                    if (temp_parent) { //if we caught something
-                        this.indent_level = this.tags[tag + this.tags[tag + 'count']]; //set the indent_level accordingly
-                        this.tags.parent = this.tags[temp_parent + 'parent']; //and set the current parent
-                    }
-                    delete this.tags[tag + this.tags[tag + 'count'] + 'parent']; //delete the closed tags parent reference...
-                    delete this.tags[tag + this.tags[tag + 'count']]; //...and the tag itself
-                    if (this.tags[tag + 'count'] === 1) {
-                        delete this.tags[tag + 'count'];
-                    } else {
-                        this.tags[tag + 'count']--;
-                    }
-                }
-            };
-
-            this.indent_to_tag = function(tag) {
-                // Match the indentation level to the last use of this tag, but don't remove it.
-                if (!this.tags[tag + 'count']) {
-                    return;
-                }
-                var temp_parent = this.tags.parent;
-                while (temp_parent) {
-                    if (tag + this.tags[tag + 'count'] === temp_parent) {
-                        break;
-                    }
-                    temp_parent = this.tags[temp_parent + 'parent'];
-                }
-                if (temp_parent) {
-                    this.indent_level = this.tags[tag + this.tags[tag + 'count']];
-                }
-            };
-
-            this.get_tag = function(peek) { //function to get a full tag and parse its type
-                var input_char = '',
-                    content = [],
-                    comment = '',
-                    space = false,
-                    tag_start, tag_end,
-                    tag_start_char,
-                    orig_pos = this.pos,
-                    orig_line_char_count = this.line_char_count;
-
-                peek = peek !== undefined ? peek : false;
-
-                do {
-                    if (this.pos >= this.input.length) {
-                        if (peek) {
-                            this.pos = orig_pos;
-                            this.line_char_count = orig_line_char_count;
-                        }
-                        return content.length ? content.join('') : ['', 'TK_EOF'];
-                    }
-
-                    input_char = this.input.charAt(this.pos);
-                    this.pos++;
-
-                    if (this.Utils.in_array(input_char, this.Utils.whitespace)) { //don't want to insert unnecessary space
-                        space = true;
-                        continue;
-                    }
-
-                    if (input_char === "'" || input_char === '"') {
-                        input_char += this.get_unformatted(input_char);
-                        space = true;
-
-                    }
-
-                    if (input_char === '=') { //no space before =
-                        space = false;
-                    }
-
-                    if (content.length && content[content.length - 1] !== '=' && input_char !== '>' && space) {
-                        //no space after = or before >
-                        if (this.line_char_count >= this.wrap_line_length) {
-                            this.print_newline(false, content);
-                            this.print_indentation(content);
-                        } else {
-                            content.push(' ');
-                            this.line_char_count++;
-                        }
-                        space = false;
-                    }
-
-                    if (indent_handlebars && tag_start_char === '<') {
-                        // When inside an angle-bracket tag, put spaces around
-                        // handlebars not inside of strings.
-                        if ((input_char + this.input.charAt(this.pos)) === '{{') {
-                            input_char += this.get_unformatted('}}');
-                            if (content.length && content[content.length - 1] !== ' ' && content[content.length - 1] !== '<') {
-                                input_char = ' ' + input_char;
-                            }
-                            space = true;
-                        }
-                    }
-
-                    if (input_char === '<' && !tag_start_char) {
-                        tag_start = this.pos - 1;
-                        tag_start_char = '<';
-                    }
-
-                    if (indent_handlebars && !tag_start_char) {
-                        if (content.length >= 2 && content[content.length - 1] === '{' && content[content.length - 2] == '{') {
-                            if (input_char === '#' || input_char === '/') {
-                                tag_start = this.pos - 3;
-                            } else {
-                                tag_start = this.pos - 2;
-                            }
-                            tag_start_char = '{';
-                        }
-                    }
-
-                    this.line_char_count++;
-                    content.push(input_char); //inserts character at-a-time (or string)
-
-                    if (content[1] && content[1] === '!') { //if we're in a comment, do something special
-                        // We treat all comments as literals, even more than preformatted tags
-                        // we just look for the appropriate close tag
-                        content = [this.get_comment(tag_start)];
-                        break;
-                    }
-
-                    if (indent_handlebars && tag_start_char === '{' && content.length > 2 && content[content.length - 2] === '}' && content[content.length - 1] === '}') {
-                        break;
-                    }
-                } while (input_char !== '>');
-
-                var tag_complete = content.join('');
-                var tag_index;
-                var tag_offset;
-
-                if (tag_complete.indexOf(' ') !== -1) { //if there's whitespace, thats where the tag name ends
-                    tag_index = tag_complete.indexOf(' ');
-                } else if (tag_complete[0] === '{') {
-                    tag_index = tag_complete.indexOf('}');
-                } else { //otherwise go with the tag ending
-                    tag_index = tag_complete.indexOf('>');
-                }
-                if (tag_complete[0] === '<' || !indent_handlebars) {
-                    tag_offset = 1;
-                } else {
-                    tag_offset = tag_complete[2] === '#' ? 3 : 2;
-                }
-                var tag_check = tag_complete.substring(tag_offset, tag_index).toLowerCase();
-                if (tag_complete.charAt(tag_complete.length - 2) === '/' ||
-                    this.Utils.in_array(tag_check, this.Utils.single_token)) { //if this tag name is a single tag type (either in the list or has a closing /)
-                    if (!peek) {
-                        this.tag_type = 'SINGLE';
-                    }
-                } else if (indent_handlebars && tag_complete[0] === '{' && tag_check === 'else') {
-                    if (!peek) {
-                        this.indent_to_tag('if');
-                        this.tag_type = 'HANDLEBARS_ELSE';
-                        this.indent_content = true;
-                        this.traverse_whitespace();
-                    }
-                } else if (tag_check === 'script' &&
-                    (tag_complete.search('type') === -1 ||
-                    (tag_complete.search('type') > -1 &&
-                    tag_complete.search(/\b(text|application)\/(x-)?(javascript|ecmascript|jscript|livescript)/) > -1))) {
-                    if (!peek) {
-                        this.record_tag(tag_check);
-                        this.tag_type = 'SCRIPT';
-                    }
-                } else if (tag_check === 'style' &&
-                    (tag_complete.search('type') === -1 ||
-                    (tag_complete.search('type') > -1 && tag_complete.search('text/css') > -1))) {
-                    if (!peek) {
-                        this.record_tag(tag_check);
-                        this.tag_type = 'STYLE';
-                    }
-                } else if (this.is_unformatted(tag_check, unformatted)) { // do not reformat the "unformatted" tags
-                    comment = this.get_unformatted('', tag_complete); //...delegate to get_unformatted function
-                    content.push(comment);
-                    // Preserve collapsed whitespace either before or after this tag.
-                    if (tag_start > 0 && this.Utils.in_array(this.input.charAt(tag_start - 1), this.Utils.whitespace)) {
-                        content.splice(0, 0, this.input.charAt(tag_start - 1));
-                    }
-                    tag_end = this.pos - 1;
-                    if (this.Utils.in_array(this.input.charAt(tag_end + 1), this.Utils.whitespace)) {
-                        content.push(this.input.charAt(tag_end + 1));
-                    }
-                    this.tag_type = 'SINGLE';
-                } else if (tag_check.charAt(0) === '!') { //peek for ',
-                    matched = false;
-
-                this.pos = start_pos;
-                input_char = this.input.charAt(this.pos);
-                this.pos++;
-
-                while (this.pos <= this.input.length) {
-                    comment += input_char;
-
-                    // only need to check for the delimiter if the last chars match
-                    if (comment[comment.length - 1] === delimiter[delimiter.length - 1] &&
-                        comment.indexOf(delimiter) !== -1) {
-                        break;
-                    }
-
-                    // only need to search for custom delimiter for the first few characters
-                    if (!matched && comment.length < 10) {
-                        if (comment.indexOf('';
-                            matched = true;
-                        } else if (comment.indexOf('';
-                            matched = true;
-                        } else if (comment.indexOf('';
-                            matched = true;
-                        } else if (comment.indexOf('';
-                            matched = true;
-                        }
-                    }
-
-                    input_char = this.input.charAt(this.pos);
-                    this.pos++;
-                }
-
-                return comment;
-            };
-
-            this.get_unformatted = function(delimiter, orig_tag) { //function to return unformatted content in its entirety
-
-                if (orig_tag && orig_tag.toLowerCase().indexOf(delimiter) !== -1) {
-                    return '';
-                }
-                var input_char = '';
-                var content = '';
-                var min_index = 0;
-                var space = true;
-                do {
-
-                    if (this.pos >= this.input.length) {
-                        return content;
-                    }
-
-                    input_char = this.input.charAt(this.pos);
-                    this.pos++;
-
-                    if (this.Utils.in_array(input_char, this.Utils.whitespace)) {
-                        if (!space) {
-                            this.line_char_count--;
-                            continue;
-                        }
-                        if (input_char === '\n' || input_char === '\r') {
-                            content += '\n';
-                            /*  Don't change tab indention for unformatted blocks.  If using code for html editing, this will greatly affect 
 tags if they are specified in the 'unformatted array'
-                for (var i=0; i]*>\s*$/);
-
-                // if next_tag comes back but is not an isolated tag, then
-                // let's treat the 'a' tag as having content
-                // and respect the unformatted option
-                if (!tag || this.Utils.in_array(tag, unformatted)) {
-                    return true;
-                } else {
-                    return false;
-                }
-            };
-
-            this.printer = function(js_source, indent_character, indent_size, wrap_line_length, brace_style) { //handles input/output and some other printing functions
-
-                this.input = js_source || ''; //gets the input for the Parser
-                this.output = [];
-                this.indent_character = indent_character;
-                this.indent_string = '';
-                this.indent_size = indent_size;
-                this.brace_style = brace_style;
-                this.indent_level = 0;
-                this.wrap_line_length = wrap_line_length;
-                this.line_char_count = 0; //count to see if wrap_line_length was exceeded
-
-                for (var i = 0; i < this.indent_size; i++) {
-                    this.indent_string += this.indent_character;
-                }
-
-                this.print_newline = function(force, arr) {
-                    this.line_char_count = 0;
-                    if (!arr || !arr.length) {
-                        return;
-                    }
-                    if (force || (arr[arr.length - 1] !== '\n')) { //we might want the extra line
-                        arr.push('\n');
-                    }
-                };
-
-                this.print_indentation = function(arr) {
-                    for (var i = 0; i < this.indent_level; i++) {
-                        arr.push(this.indent_string);
-                        this.line_char_count += this.indent_string.length;
-                    }
-                };
-
-                this.print_token = function(text) {
-                    if (text || text !== '') {
-                        if (this.output.length && this.output[this.output.length - 1] === '\n') {
-                            this.print_indentation(this.output);
-                            text = ltrim(text);
-                        }
-                    }
-                    this.print_token_raw(text);
-                };
-
-                this.print_token_raw = function(text) {
-                    if (text && text !== '') {
-                        if (text.length > 1 && text[text.length - 1] === '\n') {
-                            // unformatted tags can grab newlines as their last character
-                            this.output.push(text.slice(0, -1));
-                            this.print_newline(false, this.output);
-                        } else {
-                            this.output.push(text);
-                        }
-                    }
-
-                    for (var n = 0; n < this.newlines; n++) {
-                        this.print_newline(n > 0, this.output);
-                    }
-                    this.newlines = 0;
-                };
-
-                this.indent = function() {
-                    this.indent_level++;
-                };
-
-                this.unindent = function() {
-                    if (this.indent_level > 0) {
-                        this.indent_level--;
-                    }
-                };
-            };
-            return this;
-        }
-
-        /*_____________________--------------------_____________________*/
-
-        multi_parser = new Parser(); //wrapping functions Parser
-        multi_parser.printer(html_source, indent_character, indent_size, wrap_line_length, brace_style); //initialize starting values
-
-        while (true) {
-            var t = multi_parser.get_token();
-            multi_parser.token_text = t[0];
-            multi_parser.token_type = t[1];
-
-            if (multi_parser.token_type === 'TK_EOF') {
-                break;
-            }
-
-            switch (multi_parser.token_type) {
-                case 'TK_TAG_START':
-                    multi_parser.print_newline(false, multi_parser.output);
-                    multi_parser.print_token(multi_parser.token_text);
-                    if (multi_parser.indent_content) {
-                        multi_parser.indent();
-                        multi_parser.indent_content = false;
-                    }
-                    multi_parser.current_mode = 'CONTENT';
-                    break;
-                case 'TK_TAG_STYLE':
-                case 'TK_TAG_SCRIPT':
-                    multi_parser.print_newline(false, multi_parser.output);
-                    multi_parser.print_token(multi_parser.token_text);
-                    multi_parser.current_mode = 'CONTENT';
-                    break;
-                case 'TK_TAG_END':
-                    //Print new line only if the tag has no content and has child
-                    if (multi_parser.last_token === 'TK_CONTENT' && multi_parser.last_text === '') {
-                        var tag_name = multi_parser.token_text.match(/\w+/)[0];
-                        var tag_extracted_from_last_output = null;
-                        if (multi_parser.output.length) {
-                            tag_extracted_from_last_output = multi_parser.output[multi_parser.output.length - 1].match(/(?:<|{{#)\s*(\w+)/);
-                        }
-                        if (tag_extracted_from_last_output === null ||
-                            tag_extracted_from_last_output[1] !== tag_name) {
-                            multi_parser.print_newline(false, multi_parser.output);
-                        }
-                    }
-                    multi_parser.print_token(multi_parser.token_text);
-                    multi_parser.current_mode = 'CONTENT';
-                    break;
-                case 'TK_TAG_SINGLE':
-                    // Don't add a newline before elements that should remain unformatted.
-                    var tag_check = multi_parser.token_text.match(/^\s*<([a-z]+)/i);
-                    if (!tag_check || !multi_parser.Utils.in_array(tag_check[1], unformatted)) {
-                        multi_parser.print_newline(false, multi_parser.output);
-                    }
-                    multi_parser.print_token(multi_parser.token_text);
-                    multi_parser.current_mode = 'CONTENT';
-                    break;
-                case 'TK_TAG_HANDLEBARS_ELSE':
-                    multi_parser.print_token(multi_parser.token_text);
-                    if (multi_parser.indent_content) {
-                        multi_parser.indent();
-                        multi_parser.indent_content = false;
-                    }
-                    multi_parser.current_mode = 'CONTENT';
-                    break;
-                case 'TK_CONTENT':
-                    multi_parser.print_token(multi_parser.token_text);
-                    multi_parser.current_mode = 'TAG';
-                    break;
-                case 'TK_STYLE':
-                case 'TK_SCRIPT':
-                    if (multi_parser.token_text !== '') {
-                        multi_parser.print_newline(false, multi_parser.output);
-                        var text = multi_parser.token_text,
-                            _beautifier,
-                            script_indent_level = 1;
-                        if (multi_parser.token_type === 'TK_SCRIPT') {
-                            _beautifier = typeof js_beautify === 'function' && js_beautify;
-                        } else if (multi_parser.token_type === 'TK_STYLE') {
-                            _beautifier = typeof css_beautify === 'function' && css_beautify;
-                        }
-
-                        if (options.indent_scripts === "keep") {
-                            script_indent_level = 0;
-                        } else if (options.indent_scripts === "separate") {
-                            script_indent_level = -multi_parser.indent_level;
-                        }
-
-                        var indentation = multi_parser.get_full_indent(script_indent_level);
-                        if (_beautifier) {
-                            // call the Beautifier if avaliable
-                            text = _beautifier(text.replace(/^\s*/, indentation), options);
-                        } else {
-                            // simply indent the string otherwise
-                            var white = text.match(/^\s*/)[0];
-                            var _level = white.match(/[^\n\r]*$/)[0].split(multi_parser.indent_string).length - 1;
-                            var reindent = multi_parser.get_full_indent(script_indent_level - _level);
-                            text = text.replace(/^\s*/, indentation)
-                                .replace(/\r\n|\r|\n/g, '\n' + reindent)
-                                .replace(/\s+$/, '');
-                        }
-                        if (text) {
-                            multi_parser.print_token_raw(indentation + trim(text));
-                            multi_parser.print_newline(false, multi_parser.output);
-                        }
-                    }
-                    multi_parser.current_mode = 'TAG';
-                    break;
-            }
-            multi_parser.last_token = multi_parser.token_type;
-            multi_parser.last_text = multi_parser.token_text;
-        }
-        return multi_parser.output.join('');
-    }
-
-    var beautify = require('devtools/jsbeautify');
-
-    exports.htmlBeautify = function(html_source, options) {
-        return style_html(html_source, options, beautify.js, beautify.css);
-    };
-}());
diff --git a/toolkit/devtools/jsbeautify/src/beautify-js.js b/toolkit/devtools/jsbeautify/src/beautify-js.js
deleted file mode 100644
index a11285f4818d..000000000000
--- a/toolkit/devtools/jsbeautify/src/beautify-js.js
+++ /dev/null
@@ -1,1662 +0,0 @@
-/*jshint curly:true, eqeqeq:true, laxbreak:true, noempty:false */
-
-"use strict";
-
-const acorn = require("acorn/acorn");
-
-/*
-
-  The MIT License (MIT)
-
-  Copyright (c) 2007-2013 Einar Lielmanis and contributors.
-
-  Permission is hereby granted, free of charge, to any person
-  obtaining a copy of this software and associated documentation files
-  (the "Software"), to deal in the Software without restriction,
-  including without limitation the rights to use, copy, modify, merge,
-  publish, distribute, sublicense, and/or sell copies of the Software,
-  and to permit persons to whom the Software is furnished to do so,
-  subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be
-  included in all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.
-
- JS Beautifier
----------------
-
-
-  Written by Einar Lielmanis, 
-      http://jsbeautifier.org/
-
-  Originally converted to javascript by Vital, 
-  "End braces on own line" added by Chris J. Shull, 
-  Parsing improvements for brace-less statements by Liam Newman 
-
-
-  Usage:
-    js_beautify(js_source_text);
-    js_beautify(js_source_text, options);
-
-  The options are:
-    indent_size (default 4)          - indentation size,
-    indent_char (default space)      - character to indent with,
-    preserve_newlines (default true) - whether existing line breaks should be preserved,
-    max_preserve_newlines (default unlimited) - maximum number of line breaks to be preserved in one chunk,
-
-    jslint_happy (default false) - if true, then jslint-stricter mode is enforced.
-
-            jslint_happy       !jslint_happy
-            ---------------------------------
-            function ()        function()
-
-    brace_style (default "collapse") - "collapse" | "expand" | "end-expand"
-            put braces on the same line as control statements (default), or put braces on own line (Allman / ANSI style), or just put end braces on own line.
-
-    space_before_conditional (default true) - should the space before conditional statement be added, "if(true)" vs "if (true)",
-
-    unescape_strings (default false) - should printable characters in strings encoded in \xNN notation be unescaped, "example" vs "\x65\x78\x61\x6d\x70\x6c\x65"
-
-    wrap_line_length (default unlimited) - lines should wrap at next opportunity after this number of characters.
-          NOTE: This is not a hard limit. Lines will continue until a point where a newline would
-                be preserved if it were present.
-
-    e.g
-
-    js_beautify(js_source_text, {
-      'indent_size': 1,
-      'indent_char': '\t'
-    });
-
-*/
-
-let js_beautify = function js_beautify(js_source_text, options) {
-    var beautifier = new Beautifier(js_source_text, options);
-    return beautifier.beautify();
-};
-
-exports.jsBeautify = js_beautify;
-
-function Beautifier(js_source_text, options) {
-    var input, output_lines;
-    var token_text, token_type, last_type, last_last_text, indent_string;
-    var flags, previous_flags, flag_store;
-    var whitespace, wordchar, punct, parser_pos, line_starters, reserved_words, digits;
-    var prefix;
-    var input_wanted_newline;
-    var output_space_before_token;
-    var input_length, n_newlines, whitespace_before_token;
-    var handlers, MODE, opt;
-    var preindent_string = '';
-
-
-
-    whitespace = "\n\r\t ".split('');
-    wordchar = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$'.split('');
-    digits = '0123456789'.split('');
-
-    punct = '+ - * / % & ++ -- = += -= *= /= %= == === != !== > < >= <= >> << >>> >>>= >>= <<= && &= | || ! ~ , : ? ^ ^= |= :: =>';
-    punct += ' <%= <% %> '; // try to be a good boy and try not to break the markup language identifiers
-    punct = punct.split(' ');
-
-    // words which should always start on new line.
-    line_starters = 'continue,try,throw,return,var,let,const,if,switch,case,default,for,while,break,function,yield'.split(',');
-    reserved_words = line_starters.concat(['do', 'in', 'else', 'get', 'set', 'new', 'catch', 'finally', 'typeof']);
-
-
-    MODE = {
-        BlockStatement: 'BlockStatement', // 'BLOCK'
-        Statement: 'Statement', // 'STATEMENT'
-        ObjectLiteral: 'ObjectLiteral', // 'OBJECT',
-        ArrayLiteral: 'ArrayLiteral', //'[EXPRESSION]',
-        ForInitializer: 'ForInitializer', //'(FOR-EXPRESSION)',
-        Conditional: 'Conditional', //'(COND-EXPRESSION)',
-        Expression: 'Expression' //'(EXPRESSION)'
-    };
-
-    handlers = {
-        'TK_START_EXPR': handle_start_expr,
-        'TK_END_EXPR': handle_end_expr,
-        'TK_START_BLOCK': handle_start_block,
-        'TK_END_BLOCK': handle_end_block,
-        'TK_WORD': handle_word,
-        'TK_RESERVED': handle_word,
-        'TK_SEMICOLON': handle_semicolon,
-        'TK_STRING': handle_string,
-        'TK_EQUALS': handle_equals,
-        'TK_OPERATOR': handle_operator,
-        'TK_COMMA': handle_comma,
-        'TK_BLOCK_COMMENT': handle_block_comment,
-        'TK_INLINE_COMMENT': handle_inline_comment,
-        'TK_COMMENT': handle_comment,
-        'TK_DOT': handle_dot,
-        'TK_UNKNOWN': handle_unknown
-    };
-
-    function create_flags(flags_base, mode) {
-        var next_indent_level = 0;
-        if (flags_base) {
-            next_indent_level = flags_base.indentation_level;
-            if (!just_added_newline() &&
-                flags_base.line_indent_level > next_indent_level) {
-                next_indent_level = flags_base.line_indent_level;
-            }
-        }
-
-        var next_flags = {
-            mode: mode,
-            parent: flags_base,
-            last_text: flags_base ? flags_base.last_text : '', // last token text
-            last_word: flags_base ? flags_base.last_word : '', // last 'TK_WORD' passed
-            declaration_statement: false,
-            declaration_assignment: false,
-            in_html_comment: false,
-            multiline_frame: false,
-            if_block: false,
-            else_block: false,
-            do_block: false,
-            do_while: false,
-            in_case_statement: false, // switch(..){ INSIDE HERE }
-            in_case: false, // we're on the exact line with "case 0:"
-            case_body: false, // the indented case-action block
-            indentation_level: next_indent_level,
-            line_indent_level: flags_base ? flags_base.line_indent_level : next_indent_level,
-            start_line_index: output_lines.length,
-            had_comment: false,
-            ternary_depth: 0
-        };
-        return next_flags;
-    }
-
-    // Using object instead of string to allow for later expansion of info about each line
-
-    function create_output_line() {
-        return {
-            text: []
-        };
-    }
-
-    // Some interpreters have unexpected results with foo = baz || bar;
-    options = options ? options : {};
-    opt = {};
-
-    // compatibility
-    if (options.space_after_anon_function !== undefined && options.jslint_happy === undefined) {
-        options.jslint_happy = options.space_after_anon_function;
-    }
-    if (options.braces_on_own_line !== undefined) { //graceful handling of deprecated option
-        opt.brace_style = options.braces_on_own_line ? "expand" : "collapse";
-    }
-    opt.brace_style = options.brace_style ? options.brace_style : (opt.brace_style ? opt.brace_style : "collapse");
-
-    // graceful handling of deprecated option
-    if (opt.brace_style === "expand-strict") {
-        opt.brace_style = "expand";
-    }
-
-
-    opt.indent_size = options.indent_size ? parseInt(options.indent_size, 10) : 4;
-    opt.indent_char = options.indent_char ? options.indent_char : ' ';
-    opt.preserve_newlines = (options.preserve_newlines === undefined) ? true : options.preserve_newlines;
-    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.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;
-    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.e4x = (options.e4x === undefined) ? false : options.e4x;
-
-    if(options.indent_with_tabs){
-        opt.indent_char = '\t';
-        opt.indent_size = 1;
-    }
-
-    //----------------------------------
-    indent_string = '';
-    while (opt.indent_size > 0) {
-        indent_string += opt.indent_char;
-        opt.indent_size -= 1;
-    }
-
-    while (js_source_text && (js_source_text.charAt(0) === ' ' || js_source_text.charAt(0) === '\t')) {
-        preindent_string += js_source_text.charAt(0);
-        js_source_text = js_source_text.substring(1);
-    }
-    input = js_source_text;
-    // cache the source's length.
-    input_length = js_source_text.length;
-
-    last_type = 'TK_START_BLOCK'; // last token type
-    last_last_text = ''; // pre-last token text
-    output_lines = [create_output_line()];
-    output_space_before_token = false;
-    whitespace_before_token = [];
-
-    // Stack of parsing/formatting states, including MODE.
-    // We tokenize, parse, and output in an almost purely a forward-only stream of token input
-    // and formatted output.  This makes the beautifier less accurate than full parsers
-    // but also far more tolerant of syntax errors.
-    //
-    // For example, the default mode is MODE.BlockStatement. If we see a '{' we push a new frame of type
-    // MODE.BlockStatement on the the stack, even though it could be object literal.  If we later
-    // encounter a ":", we'll switch to to MODE.ObjectLiteral.  If we then see a ";",
-    // most full parsers would die, but the beautifier gracefully falls back to
-    // MODE.BlockStatement and continues on.
-    flag_store = [];
-    set_mode(MODE.BlockStatement);
-
-    parser_pos = 0;
-
-    this.beautify = function() {
-        /*jshint onevar:true */
-        var t, i, keep_whitespace, sweet_code;
-
-        while (true) {
-            t = get_next_token();
-            token_text = t[0];
-            token_type = t[1];
-
-            if (token_type === 'TK_EOF') {
-                // Unwind any open statements
-                while (flags.mode === MODE.Statement) {
-                    restore_mode();
-                }
-                break;
-            }
-
-            keep_whitespace = opt.keep_array_indentation && is_array(flags.mode);
-            input_wanted_newline = n_newlines > 0;
-
-            if (keep_whitespace) {
-                for (i = 0; i < n_newlines; i += 1) {
-                    print_newline(i > 0);
-                }
-            } else {
-                if (opt.max_preserve_newlines && n_newlines > opt.max_preserve_newlines) {
-                    n_newlines = opt.max_preserve_newlines;
-                }
-
-                if (opt.preserve_newlines) {
-                    if (n_newlines > 1) {
-                        print_newline();
-                        for (i = 1; i < n_newlines; i += 1) {
-                            print_newline(true);
-                        }
-                    }
-                }
-            }
-
-            handlers[token_type]();
-
-            // The cleanest handling of inline comments is to treat them as though they aren't there.
-            // Just continue formatting and the behavior should be logical.
-            // Also ignore unknown tokens.  Again, this should result in better behavior.
-            if (token_type !== 'TK_INLINE_COMMENT' && token_type !== 'TK_COMMENT' &&
-                token_type !== 'TK_BLOCK_COMMENT' && token_type !== 'TK_UNKNOWN') {
-                last_last_text = flags.last_text;
-                last_type = token_type;
-                flags.last_text = token_text;
-            }
-            flags.had_comment = (token_type === 'TK_INLINE_COMMENT' || token_type === 'TK_COMMENT'
-                || token_type === 'TK_BLOCK_COMMENT');
-        }
-
-
-        sweet_code = output_lines[0].text.join('');
-        for (var line_index = 1; line_index < output_lines.length; line_index++) {
-            sweet_code += '\n' + output_lines[line_index].text.join('');
-        }
-        sweet_code = sweet_code.replace(/[\r\n ]+$/, '');
-        return sweet_code;
-    };
-
-    function trim_output(eat_newlines) {
-        eat_newlines = (eat_newlines === undefined) ? false : eat_newlines;
-
-        if (output_lines.length) {
-            trim_output_line(output_lines[output_lines.length - 1], eat_newlines);
-
-            while (eat_newlines && output_lines.length > 1 &&
-                output_lines[output_lines.length - 1].text.length === 0) {
-                output_lines.pop();
-                trim_output_line(output_lines[output_lines.length - 1], eat_newlines);
-            }
-        }
-    }
-
-    function trim_output_line(line) {
-        while (line.text.length &&
-            (line.text[line.text.length - 1] === ' ' ||
-                line.text[line.text.length - 1] === indent_string ||
-                line.text[line.text.length - 1] === preindent_string)) {
-            line.text.pop();
-        }
-    }
-
-    function trim(s) {
-        return s.replace(/^\s+|\s+$/g, '');
-    }
-
-    // we could use just string.split, but
-    // IE doesn't like returning empty strings
-
-    function split_newlines(s) {
-        //return s.split(/\x0d\x0a|\x0a/);
-
-        s = s.replace(/\x0d/g, '');
-        var out = [],
-            idx = s.indexOf("\n");
-        while (idx !== -1) {
-            out.push(s.substring(0, idx));
-            s = s.substring(idx + 1);
-            idx = s.indexOf("\n");
-        }
-        if (s.length) {
-            out.push(s);
-        }
-        return out;
-    }
-
-    function just_added_newline() {
-        var line = output_lines[output_lines.length - 1];
-        return line.text.length === 0;
-    }
-
-    function just_added_blankline() {
-        if (just_added_newline()) {
-            if (output_lines.length === 1) {
-                return true; // start of the file and newline = blank
-            }
-
-            var line = output_lines[output_lines.length - 2];
-            return line.text.length === 0;
-        }
-        return false;
-    }
-
-    function allow_wrap_or_preserved_newline(force_linewrap) {
-        force_linewrap = (force_linewrap === undefined) ? false : force_linewrap;
-        if (opt.wrap_line_length && !force_linewrap) {
-            var line = output_lines[output_lines.length - 1];
-            var proposed_line_length = 0;
-            // never wrap the first token of a line.
-            if (line.text.length > 0) {
-                proposed_line_length = line.text.join('').length + token_text.length +
-                    (output_space_before_token ? 1 : 0);
-                if (proposed_line_length >= opt.wrap_line_length) {
-                    force_linewrap = true;
-                }
-            }
-        }
-        if (((opt.preserve_newlines && input_wanted_newline) || force_linewrap) && !just_added_newline()) {
-            print_newline(false, true);
-
-        }
-    }
-
-    function print_newline(force_newline, preserve_statement_flags) {
-        output_space_before_token = false;
-
-        if (!preserve_statement_flags) {
-            if (flags.last_text !== ';' && flags.last_text !== ',' && flags.last_text !== '=' && last_type !== 'TK_OPERATOR') {
-                while (flags.mode === MODE.Statement && !flags.if_block && !flags.do_block) {
-                    restore_mode();
-                }
-            }
-        }
-
-        if (output_lines.length === 1 && just_added_newline()) {
-            return; // no newline on start of file
-        }
-
-        if (force_newline || !just_added_newline()) {
-            flags.multiline_frame = true;
-            output_lines.push(create_output_line());
-        }
-    }
-
-    function print_token_line_indentation() {
-        if (just_added_newline()) {
-            var line = output_lines[output_lines.length - 1];
-            if (opt.keep_array_indentation && is_array(flags.mode) && input_wanted_newline) {
-                // prevent removing of this whitespace as redundant
-                line.text.push('');
-                for (var i = 0; i < whitespace_before_token.length; i += 1) {
-                    line.text.push(whitespace_before_token[i]);
-                }
-            } else {
-                if (preindent_string) {
-                    line.text.push(preindent_string);
-                }
-
-                print_indent_string(flags.indentation_level);
-            }
-        }
-    }
-
-    function print_indent_string(level) {
-        // Never indent your first output indent at the start of the file
-        if (output_lines.length > 1) {
-            var line = output_lines[output_lines.length - 1];
-
-            flags.line_indent_level = level;
-            for (var i = 0; i < level; i += 1) {
-                line.text.push(indent_string);
-            }
-        }
-    }
-
-    function print_token_space_before() {
-        var line = output_lines[output_lines.length - 1];
-        if (output_space_before_token && line.text.length) {
-            var last_output = line.text[line.text.length - 1];
-            if (last_output !== ' ' && last_output !== indent_string) { // prevent occassional duplicate space
-                line.text.push(' ');
-            }
-        }
-    }
-
-    function print_token(printable_token) {
-        printable_token = printable_token || token_text;
-        print_token_line_indentation();
-        print_token_space_before();
-        output_space_before_token = false;
-        output_lines[output_lines.length - 1].text.push(printable_token);
-    }
-
-    function indent() {
-        flags.indentation_level += 1;
-    }
-
-    function deindent() {
-        if (flags.indentation_level > 0 &&
-            ((!flags.parent) || flags.indentation_level > flags.parent.indentation_level))
-            flags.indentation_level -= 1;
-    }
-
-    function remove_redundant_indentation(frame) {
-        // This implementation is effective but has some issues:
-        //     - less than great performance due to array splicing
-        //     - can cause line wrap to happen too soon due to indent removal
-        //           after wrap points are calculated
-        // These issues are minor compared to ugly indentation.
-
-        if (frame.multiline_frame) return;
-
-        // remove one indent from each line inside this section
-        var index = frame.start_line_index;
-        var splice_index = 0;
-        var line;
-
-        while (index < output_lines.length) {
-            line = output_lines[index];
-            index++;
-
-            // skip empty lines
-            if (line.text.length === 0) {
-                continue;
-            }
-
-            // skip the preindent string if present
-            if (preindent_string && line.text[0] === preindent_string) {
-                splice_index = 1;
-            } else {
-                splice_index = 0;
-            }
-
-            // remove one indent, if present
-            if (line.text[splice_index] === indent_string) {
-                line.text.splice(splice_index, 1);
-            }
-        }
-    }
-
-    function set_mode(mode) {
-        if (flags) {
-            flag_store.push(flags);
-            previous_flags = flags;
-        } else {
-            previous_flags = create_flags(null, mode);
-        }
-
-        flags = create_flags(previous_flags, mode);
-    }
-
-    function is_array(mode) {
-        return mode === MODE.ArrayLiteral;
-    }
-
-    function is_expression(mode) {
-        return in_array(mode, [MODE.Expression, MODE.ForInitializer, MODE.Conditional]);
-    }
-
-    function restore_mode() {
-        if (flag_store.length > 0) {
-            previous_flags = flags;
-            flags = flag_store.pop();
-            if (previous_flags.mode === MODE.Statement) {
-                remove_redundant_indentation(previous_flags);
-            }
-        }
-    }
-
-    function start_of_object_property() {
-        return flags.parent.mode === MODE.ObjectLiteral && flags.mode === MODE.Statement && flags.last_text === ':' &&
-            flags.ternary_depth === 0;
-    }
-
-    function start_of_statement() {
-        if (
-                (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['var', 'let', 'const']) && token_type === 'TK_WORD') ||
-                (last_type === 'TK_RESERVED' && flags.last_text === 'do') ||
-                (last_type === 'TK_RESERVED' && flags.last_text === 'return' && !input_wanted_newline) ||
-                (last_type === 'TK_RESERVED' && flags.last_text === 'else' && !(token_type === 'TK_RESERVED' && token_text === 'if')) ||
-                (last_type === 'TK_END_EXPR' && (previous_flags.mode === MODE.ForInitializer || previous_flags.mode === MODE.Conditional)) ||
-                (last_type === 'TK_WORD' && flags.mode === MODE.BlockStatement
-                    && !flags.in_case
-                    && !(token_text === '--' || token_text === '++')
-                    && token_type !== 'TK_WORD' && token_type !== 'TK_RESERVED') ||
-                (flags.mode === MODE.ObjectLiteral && flags.last_text === ':' && flags.ternary_depth === 0)
-
-            ) {
-
-            set_mode(MODE.Statement);
-            indent();
-
-            if (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['var', 'let', 'const']) && token_type === 'TK_WORD') {
-                flags.declaration_statement = 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(
-                    token_type === 'TK_RESERVED' && in_array(token_text, ['do', 'for', 'if', 'while']));
-            }
-
-            return true;
-        }
-        return false;
-    }
-
-    function all_lines_start_with(lines, c) {
-        for (var i = 0; i < lines.length; i++) {
-            var line = trim(lines[i]);
-            if (line.charAt(0) !== c) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    function each_line_matches_indent(lines, indent) {
-        var i = 0,
-            len = lines.length,
-            line;
-        for (; i < len; i++) {
-            line = lines[i];
-            // allow empty lines to pass through
-            if (line && line.indexOf(indent) !== 0) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    function is_special_word(word) {
-        return in_array(word, ['case', 'return', 'do', 'if', 'throw', 'else']);
-    }
-
-    function in_array(what, arr) {
-        for (var i = 0; i < arr.length; i += 1) {
-            if (arr[i] === what) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    function unescape_string(s) {
-        var esc = false,
-            out = '',
-            pos = 0,
-            s_hex = '',
-            escaped = 0,
-            c;
-
-        while (esc || pos < s.length) {
-
-            c = s.charAt(pos);
-            pos++;
-
-            if (esc) {
-                esc = false;
-                if (c === 'x') {
-                    // simple hex-escape \x24
-                    s_hex = s.substr(pos, 2);
-                    pos += 2;
-                } else if (c === 'u') {
-                    // unicode-escape, \u2134
-                    s_hex = s.substr(pos, 4);
-                    pos += 4;
-                } else {
-                    // some common escape, e.g \n
-                    out += '\\' + c;
-                    continue;
-                }
-                if (!s_hex.match(/^[0123456789abcdefABCDEF]+$/)) {
-                    // some weird escaping, bail out,
-                    // leaving whole string intact
-                    return s;
-                }
-
-                escaped = parseInt(s_hex, 16);
-
-                if (escaped >= 0x00 && escaped < 0x20) {
-                    // leave 0x00...0x1f escaped
-                    if (c === 'x') {
-                        out += '\\x' + s_hex;
-                    } else {
-                        out += '\\u' + s_hex;
-                    }
-                    continue;
-                } else if (escaped === 0x22 || escaped === 0x27 || escaped === 0x5c) {
-                    // single-quote, apostrophe, backslash - escape these
-                    out += '\\' + String.fromCharCode(escaped);
-                } else if (c === 'x' && escaped > 0x7e && escaped <= 0xff) {
-                    // we bail out on \x7f..\xff,
-                    // leaving whole string escaped,
-                    // as it's probably completely binary
-                    return s;
-                } else {
-                    out += String.fromCharCode(escaped);
-                }
-            } else if (c === '\\') {
-                esc = true;
-            } else {
-                out += c;
-            }
-        }
-        return out;
-    }
-
-    function is_next(find) {
-        var local_pos = parser_pos;
-        var c = input.charAt(local_pos);
-        while (in_array(c, whitespace) && c !== find) {
-            local_pos++;
-            if (local_pos >= input_length) {
-                return false;
-            }
-            c = input.charAt(local_pos);
-        }
-        return c === find;
-    }
-
-    function get_next_token() {
-        var i, resulting_string;
-
-        n_newlines = 0;
-
-        if (parser_pos >= input_length) {
-            return ['', 'TK_EOF'];
-        }
-
-        input_wanted_newline = false;
-        whitespace_before_token = [];
-
-        var c = input.charAt(parser_pos);
-        parser_pos += 1;
-
-        while (in_array(c, whitespace)) {
-
-            if (c === '\n') {
-                n_newlines += 1;
-                whitespace_before_token = [];
-            } else if (n_newlines) {
-                if (c === indent_string) {
-                    whitespace_before_token.push(indent_string);
-                } else if (c !== '\r') {
-                    whitespace_before_token.push(' ');
-                }
-            }
-
-            if (parser_pos >= input_length) {
-                return ['', 'TK_EOF'];
-            }
-
-            c = input.charAt(parser_pos);
-            parser_pos += 1;
-        }
-
-        // NOTE: because beautifier doesn't fully parse, it doesn't use acorn.isIdentifierStart.
-        // It just treats all identifiers and numbers and such the same.
-        if (acorn.isIdentifierChar(input.charCodeAt(parser_pos-1))) {
-            if (parser_pos < input_length) {
-                while (acorn.isIdentifierChar(input.charCodeAt(parser_pos))) {
-                    c += input.charAt(parser_pos);
-                    parser_pos += 1;
-                    if (parser_pos === input_length) {
-                        break;
-                    }
-                }
-            }
-
-            // small and surprisingly unugly hack for 1E-10 representation
-            if (parser_pos !== input_length && c.match(/^[0-9]+[Ee]$/) && (input.charAt(parser_pos) === '-' || input.charAt(parser_pos) === '+')) {
-
-                var sign = input.charAt(parser_pos);
-                parser_pos += 1;
-
-                var t = get_next_token();
-                c += sign + t[0];
-                return [c, 'TK_WORD'];
-            }
-
-            if (!(last_type === 'TK_DOT' ||
-                    (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['set', 'get'])))
-                && in_array(c, reserved_words)) {
-                if (c === 'in') { // hack for 'in' operator
-                    return [c, 'TK_OPERATOR'];
-                }
-                return [c, 'TK_RESERVED'];
-            }
-            return [c, 'TK_WORD'];
-        }
-
-        if (c === '(' || c === '[') {
-            return [c, 'TK_START_EXPR'];
-        }
-
-        if (c === ')' || c === ']') {
-            return [c, 'TK_END_EXPR'];
-        }
-
-        if (c === '{') {
-            return [c, 'TK_START_BLOCK'];
-        }
-
-        if (c === '}') {
-            return [c, 'TK_END_BLOCK'];
-        }
-
-        if (c === ';') {
-            return [c, 'TK_SEMICOLON'];
-        }
-
-        if (c === '/') {
-            var comment = '';
-            // peek for comment /* ... */
-            var inline_comment = true;
-            if (input.charAt(parser_pos) === '*') {
-                parser_pos += 1;
-                if (parser_pos < input_length) {
-                    while (parser_pos < input_length && !(input.charAt(parser_pos) === '*' && input.charAt(parser_pos + 1) && input.charAt(parser_pos + 1) === '/')) {
-                        c = input.charAt(parser_pos);
-                        comment += c;
-                        if (c === "\n" || c === "\r") {
-                            inline_comment = false;
-                        }
-                        parser_pos += 1;
-                        if (parser_pos >= input_length) {
-                            break;
-                        }
-                    }
-                }
-                parser_pos += 2;
-                if (inline_comment && n_newlines === 0) {
-                    return ['/*' + comment + '*/', 'TK_INLINE_COMMENT'];
-                } else {
-                    return ['/*' + comment + '*/', 'TK_BLOCK_COMMENT'];
-                }
-            }
-            // peek for comment // ...
-            if (input.charAt(parser_pos) === '/') {
-                comment = c;
-                while (input.charAt(parser_pos) !== '\r' && input.charAt(parser_pos) !== '\n') {
-                    comment += input.charAt(parser_pos);
-                    parser_pos += 1;
-                    if (parser_pos >= input_length) {
-                        break;
-                    }
-                }
-                return [comment, 'TK_COMMENT'];
-            }
-
-        }
-
-
-        if (c === '`' || c === "'" || c === '"' || // string
-            (
-                (c === '/') || // regexp
-                (opt.e4x && c === "<" && input.slice(parser_pos - 1).match(/^<([-a-zA-Z:0-9_.]+|{[^{}]*}|!\[CDATA\[[\s\S]*?\]\])\s*([-a-zA-Z:0-9_.]+=('[^']*'|"[^"]*"|{[^{}]*})\s*)*\/?\s*>/)) // xml
-            ) && ( // regex and xml can only appear in specific locations during parsing
-                (last_type === 'TK_RESERVED' && is_special_word(flags.last_text)) ||
-                (last_type === 'TK_END_EXPR' && in_array(previous_flags.mode, [MODE.Conditional, MODE.ForInitializer])) ||
-                (in_array(last_type, ['TK_COMMENT', 'TK_START_EXPR', 'TK_START_BLOCK',
-                    'TK_END_BLOCK', 'TK_OPERATOR', 'TK_EQUALS', 'TK_EOF', 'TK_SEMICOLON', 'TK_COMMA'
-                ]))
-            )) {
-
-            var sep = c,
-                esc = false,
-                has_char_escapes = false;
-
-            resulting_string = c;
-
-            if (parser_pos < input_length) {
-                if (sep === '/') {
-                    //
-                    // handle regexp
-                    //
-                    var in_char_class = false;
-                    while (esc || in_char_class || input.charAt(parser_pos) !== sep) {
-                        resulting_string += input.charAt(parser_pos);
-                        if (!esc) {
-                            esc = input.charAt(parser_pos) === '\\';
-                            if (input.charAt(parser_pos) === '[') {
-                                in_char_class = true;
-                            } else if (input.charAt(parser_pos) === ']') {
-                                in_char_class = false;
-                            }
-                        } else {
-                            esc = false;
-                        }
-                        parser_pos += 1;
-                        if (parser_pos >= input_length) {
-                            // incomplete string/rexp when end-of-file reached.
-                            // bail out with what had been received so far.
-                            return [resulting_string, 'TK_STRING'];
-                        }
-                    }
-                } else if (opt.e4x && sep === '<') {
-                    //
-                    // handle e4x xml literals
-                    //
-                    var xmlRegExp = /<(\/?)([-a-zA-Z:0-9_.]+|{[^{}]*}|!\[CDATA\[[\s\S]*?\]\])\s*([-a-zA-Z:0-9_.]+=('[^']*'|"[^"]*"|{[^{}]*})\s*)*(\/?)\s*>/g;
-                    var xmlStr = input.slice(parser_pos - 1);
-                    var match = xmlRegExp.exec(xmlStr);
-                    if (match && match.index === 0) {
-                        var rootTag = match[2];
-                        var depth = 0;
-                        while (match) {
-                            var isEndTag = !! match[1];
-                            var tagName = match[2];
-                            var isSingletonTag = ( !! match[match.length - 1]) || (tagName.slice(0, 8) === "![CDATA[");
-                            if (tagName === rootTag && !isSingletonTag) {
-                                if (isEndTag) {
-                                    --depth;
-                                } else {
-                                    ++depth;
-                                }
-                            }
-                            if (depth <= 0) {
-                                break;
-                            }
-                            match = xmlRegExp.exec(xmlStr);
-                        }
-                        var xmlLength = match ? match.index + match[0].length : xmlStr.length;
-                        parser_pos += xmlLength - 1;
-                        return [xmlStr.slice(0, xmlLength), "TK_STRING"];
-                    }
-                } else {
-                    //
-                    // handle string
-                    //
-                    while (esc || input.charAt(parser_pos) !== sep) {
-                        resulting_string += input.charAt(parser_pos);
-                        if (esc) {
-                            if (input.charAt(parser_pos) === 'x' || input.charAt(parser_pos) === 'u') {
-                                has_char_escapes = true;
-                            }
-                            esc = false;
-                        } else {
-                            esc = input.charAt(parser_pos) === '\\';
-                        }
-                        parser_pos += 1;
-                        if (parser_pos >= input_length) {
-                            // incomplete string/rexp when end-of-file reached.
-                            // bail out with what had been received so far.
-                            return [resulting_string, 'TK_STRING'];
-                        }
-                    }
-
-                }
-            }
-
-            parser_pos += 1;
-            resulting_string += sep;
-
-            if (has_char_escapes && opt.unescape_strings) {
-                resulting_string = unescape_string(resulting_string);
-            }
-
-            if (sep === '/') {
-                // regexps may have modifiers /regexp/MOD , so fetch those, too
-                while (parser_pos < input_length && in_array(input.charAt(parser_pos), wordchar)) {
-                    resulting_string += input.charAt(parser_pos);
-                    parser_pos += 1;
-                }
-            }
-            return [resulting_string, 'TK_STRING'];
-        }
-
-        if (c === '#') {
-
-
-            if (output_lines.length === 1 && output_lines[0].text.length === 0 &&
-                input.charAt(parser_pos) === '!') {
-                // shebang
-                resulting_string = c;
-                while (parser_pos < input_length && c !== '\n') {
-                    c = input.charAt(parser_pos);
-                    resulting_string += c;
-                    parser_pos += 1;
-                }
-                return [trim(resulting_string) + '\n', 'TK_UNKNOWN'];
-            }
-
-
-
-            // Spidermonkey-specific sharp variables for circular references
-            // https://developer.mozilla.org/En/Sharp_variables_in_JavaScript
-            // http://mxr.mozilla.org/mozilla-central/source/js/src/jsscan.cpp around line 1935
-            var sharp = '#';
-            if (parser_pos < input_length && in_array(input.charAt(parser_pos), digits)) {
-                do {
-                    c = input.charAt(parser_pos);
-                    sharp += c;
-                    parser_pos += 1;
-                } while (parser_pos < input_length && c !== '#' && c !== '=');
-                if (c === '#') {
-                    //
-                } else if (input.charAt(parser_pos) === '[' && input.charAt(parser_pos + 1) === ']') {
-                    sharp += '[]';
-                    parser_pos += 2;
-                } else if (input.charAt(parser_pos) === '{' && input.charAt(parser_pos + 1) === '}') {
-                    sharp += '{}';
-                    parser_pos += 2;
-                }
-                return [sharp, 'TK_WORD'];
-            }
-        }
-
-        if (c === '<' && input.substring(parser_pos - 1, parser_pos + 3) === '') {
-            flags.in_html_comment = false;
-            parser_pos += 2;
-            return ['-->', 'TK_COMMENT'];
-        }
-
-        if (c === '.') {
-            return [c, 'TK_DOT'];
-        }
-
-        if (in_array(c, punct)) {
-            while (parser_pos < input_length && in_array(c + input.charAt(parser_pos), punct)) {
-                c += input.charAt(parser_pos);
-                parser_pos += 1;
-                if (parser_pos >= input_length) {
-                    break;
-                }
-            }
-
-            if (c === ',') {
-                return [c, 'TK_COMMA'];
-            } else if (c === '=') {
-                return [c, 'TK_EQUALS'];
-            } else {
-                return [c, 'TK_OPERATOR'];
-            }
-        }
-
-        return [c, 'TK_UNKNOWN'];
-    }
-
-    function handle_start_expr() {
-        if (start_of_statement()) {
-            // The conditional starts the statement if appropriate.
-        }
-
-        var next_mode = MODE.Expression;
-        if (token_text === '[') {
-
-            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, line_starters)) {
-                    output_space_before_token = true;
-                }
-                set_mode(next_mode);
-                print_token();
-                indent();
-                if (opt.space_in_paren) {
-                    output_space_before_token = true;
-                }
-                return;
-            }
-
-            next_mode = MODE.ArrayLiteral;
-            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();
-                    }
-                }
-            }
-
-        } else {
-            if (last_type === 'TK_RESERVED' && flags.last_text === 'for') {
-                next_mode = MODE.ForInitializer;
-            } else if (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['if', 'while'])) {
-                next_mode = MODE.Conditional;
-            } else {
-                // next_mode = MODE.Expression;
-            }
-        }
-
-        if (flags.last_text === ';' || last_type === 'TK_START_BLOCK') {
-            print_newline();
-        } else if (last_type === 'TK_END_EXPR' || last_type === 'TK_START_EXPR' || last_type === 'TK_END_BLOCK' || flags.last_text === '.') {
-            // TODO: Consider whether forcing this is required.  Review failing tests when removed.
-            allow_wrap_or_preserved_newline(input_wanted_newline);
-            // do nothing on (( and )( and ][ and ]( and .(
-        } else if (!(last_type === 'TK_RESERVED' && token_text === '(') && last_type !== 'TK_WORD' && last_type !== 'TK_OPERATOR') {
-            output_space_before_token = true;
-        } else if ((last_type === 'TK_RESERVED' && (flags.last_word === 'function' || flags.last_word === 'typeof')) ||
-            (flags.last_text === '*' && last_last_text === 'function')) {
-            // function() vs function ()
-            if (opt.jslint_happy) {
-                output_space_before_token = true;
-            }
-        } else if (last_type === 'TK_RESERVED' && (in_array(flags.last_text, line_starters) || flags.last_text === 'catch')) {
-            if (opt.space_before_conditional) {
-                output_space_before_token = true;
-            }
-        }
-
-        // Support of this kind of newline preservation.
-        // a = (b &&
-        //     (c || d));
-        if (token_text === '(') {
-            if (last_type === 'TK_EQUALS' || last_type === 'TK_OPERATOR') {
-                if (!start_of_object_property()) {
-                    allow_wrap_or_preserved_newline();
-                }
-            }
-        }
-
-        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();
-    }
-
-    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();
-        }
-
-        if (flags.multiline_frame) {
-            allow_wrap_or_preserved_newline(token_text === ']' && is_array(flags.mode) && !opt.keep_array_indentation);
-        }
-
-        if (opt.space_in_paren) {
-            if (last_type === 'TK_START_EXPR' && ! opt.space_in_empty_paren) {
-                // () [] no inner space in empty parens like these, ever, ref #320
-                trim_output();
-                output_space_before_token = false;
-            } else {
-                output_space_before_token = true;
-            }
-        }
-        if (token_text === ']' && opt.keep_array_indentation) {
-            print_token();
-            restore_mode();
-        } else {
-            restore_mode();
-            print_token();
-        }
-        remove_redundant_indentation(previous_flags);
-
-        // do {} while () // no statement required after
-        if (flags.do_while && previous_flags.mode === MODE.Conditional) {
-            previous_flags.mode = MODE.Expression;
-            flags.do_block = false;
-            flags.do_while = false;
-
-        }
-    }
-
-    function handle_start_block() {
-        set_mode(MODE.BlockStatement);
-
-        var empty_braces = is_next('}');
-        var empty_anonymous_function = empty_braces && flags.last_word === 'function' &&
-            last_type === 'TK_END_EXPR';
-
-        if (opt.brace_style === "expand") {
-            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'))) {
-                output_space_before_token = true;
-            } else {
-                print_newline(false, true);
-            }
-        } else { // collapse
-            if (last_type !== 'TK_OPERATOR' && last_type !== 'TK_START_EXPR') {
-                if (last_type === 'TK_START_BLOCK') {
-                    print_newline();
-                } else {
-                    output_space_before_token = true;
-                }
-            } else {
-                // if TK_OPERATOR or TK_START_EXPR
-                if (is_array(previous_flags.mode) && flags.last_text === ',') {
-                    if (last_last_text === '}') {
-                        // }, { in array context
-                        output_space_before_token = true;
-                    } else {
-                        print_newline(); // [a, b, c, {
-                    }
-                }
-            }
-        }
-        print_token();
-        indent();
-    }
-
-    function handle_end_block() {
-        // statements must all be closed when their container closes
-        while (flags.mode === MODE.Statement) {
-            restore_mode();
-        }
-        var empty_braces = last_type === 'TK_START_BLOCK';
-
-        if (opt.brace_style === "expand") {
-            if (!empty_braces) {
-                print_newline();
-            }
-        } else {
-            // skip {}
-            if (!empty_braces) {
-                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();
-                    opt.keep_array_indentation = true;
-
-                } else {
-                    print_newline();
-                }
-            }
-        }
-        restore_mode();
-        print_token();
-    }
-
-    function handle_word() {
-        if (start_of_statement()) {
-            // The conditional starts the statement if appropriate.
-        } else if (input_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'])))) {
-
-            print_newline();
-        }
-
-        if (flags.do_block && !flags.do_while) {
-            if (token_type === 'TK_RESERVED' && token_text === 'while') {
-                // do {} ## while ()
-                output_space_before_token = true;
-                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();
-                flags.do_block = false;
-            }
-        }
-
-        // if may be followed by else, or not
-        // Bare/inline ifs are tricky
-        // Need to unwind the modes correctly: if (a) if (b) c(); else d(); else e();
-        if (flags.if_block) {
-            if (!flags.else_block && (token_type === 'TK_RESERVED' && token_text === 'else')) {
-                flags.else_block = true;
-            } else {
-                while (flags.mode === MODE.Statement) {
-                    restore_mode();
-                }
-                flags.if_block = false;
-                flags.else_block = false;
-            }
-        }
-
-        if (token_type === 'TK_RESERVED' && (token_text === 'case' || (token_text === 'default' && flags.in_case_statement))) {
-            print_newline();
-            if (flags.case_body || opt.jslint_happy) {
-                // switch cases following one another
-                deindent();
-                flags.case_body = false;
-            }
-            print_token();
-            flags.in_case = true;
-            flags.in_case_statement = true;
-            return;
-        }
-
-        if (token_type === 'TK_RESERVED' && token_text === 'function') {
-            if (in_array(flags.last_text, ['}', ';']) || (just_added_newline() && ! in_array(flags.last_text, ['{', ':', '=', ',']))) {
-                // make sure there is a nice clean space of at least one blank line
-                // before a new function definition
-                if ( ! just_added_blankline() && ! flags.had_comment) {
-                    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', 'return'])) {
-                    output_space_before_token = true;
-                } else {
-                    print_newline();
-                }
-            } else if (last_type === 'TK_OPERATOR' || flags.last_text === '=') {
-                // foo = function
-                output_space_before_token = true;
-            } else if (is_expression(flags.mode)) {
-                // (function
-            } else {
-                print_newline();
-            }
-        }
-
-        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 (token_type === 'TK_RESERVED' && token_text === 'function') {
-            print_token();
-            flags.last_word = token_text;
-            return;
-        }
-
-        prefix = 'NONE';
-
-        if (last_type === 'TK_END_BLOCK') {
-            if (!(token_type === 'TK_RESERVED' && in_array(token_text, ['else', 'catch', 'finally']))) {
-                prefix = 'NEWLINE';
-            } else {
-                if (opt.brace_style === "expand" || opt.brace_style === "end-expand") {
-                    prefix = 'NEWLINE';
-                } else {
-                    prefix = 'SPACE';
-                    output_space_before_token = true;
-                }
-            }
-        } 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)) {
-            prefix = 'SPACE';
-        } else if (last_type === 'TK_STRING') {
-            prefix = 'NEWLINE';
-        } else if (last_type === 'TK_RESERVED' || last_type === 'TK_WORD' ||
-            (flags.last_text === '*' && last_last_text === 'function')) {
-            prefix = 'SPACE';
-        } else if (last_type === 'TK_START_BLOCK') {
-            prefix = 'NEWLINE';
-        } else if (last_type === 'TK_END_EXPR') {
-            output_space_before_token = true;
-            prefix = 'NEWLINE';
-        }
-
-        if (token_type === 'TK_RESERVED' && in_array(token_text, line_starters) && flags.last_text !== ')') {
-            if (flags.last_text === 'else') {
-                prefix = 'SPACE';
-            } else {
-                prefix = 'NEWLINE';
-            }
-
-        }
-
-        if (token_type === 'TK_RESERVED' && in_array(token_text, ['else', 'catch', 'finally'])) {
-            if (last_type !== 'TK_END_BLOCK' || opt.brace_style === "expand" || opt.brace_style === "end-expand") {
-                print_newline();
-            } else {
-                trim_output(true);
-                var line = output_lines[output_lines.length - 1];
-                // If we trimmed and there's something other than a close block before us
-                // put a newline back in.  Handles '} // comment' scenario.
-                if (line.text[line.text.length - 1] !== '}') {
-                    print_newline();
-                }
-                output_space_before_token = true;
-            }
-        } else if (prefix === 'NEWLINE') {
-            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' || !(token_type === 'TK_RESERVED' && in_array(token_text, ['var', 'let', 'const']))) && flags.last_text !== ':') {
-                    // no need to force newline on 'var': for (var x = 0...)
-                    if (token_type === 'TK_RESERVED' && token_text === 'if' && flags.last_word === 'else' && flags.last_text !== '{') {
-                        // no newline for } else if {
-                        output_space_before_token = true;
-                    } else {
-                        print_newline();
-                    }
-                }
-            } else if (token_type === 'TK_RESERVED' && in_array(token_text, line_starters) && flags.last_text !== ')') {
-                print_newline();
-            }
-        } else if (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();
-        flags.last_word = token_text;
-
-        if (token_type === 'TK_RESERVED' && token_text === 'do') {
-            flags.do_block = true;
-        }
-
-        if (token_type === 'TK_RESERVED' && token_text === 'if') {
-            flags.if_block = true;
-        }
-    }
-
-    function handle_semicolon() {
-        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;
-        }
-        while (flags.mode === MODE.Statement && !flags.if_block && !flags.do_block) {
-            restore_mode();
-        }
-        print_token();
-        if (flags.mode === MODE.ObjectLiteral) {
-            // if we're in OBJECT mode and see a semicolon, its invalid syntax
-            // recover back to treating this as a BLOCK
-            flags.mode = MODE.BlockStatement;
-        }
-    }
-
-    function handle_string() {
-        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 if (last_type === 'TK_RESERVED' || last_type === 'TK_WORD') {
-            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();
-            }
-        } else {
-            print_newline();
-        }
-        print_token();
-    }
-
-    function handle_equals() {
-        if (start_of_statement()) {
-            // The conditional starts the statement if appropriate.
-        }
-
-        if (flags.declaration_statement) {
-            // just got an '=' in a var-line, different formatting/line-breaking, etc will now be done
-            flags.declaration_assignment = true;
-        }
-        output_space_before_token = true;
-        print_token();
-        output_space_before_token = true;
-    }
-
-    function handle_comma() {
-        if (flags.declaration_statement) {
-            if (is_expression(flags.parent.mode)) {
-                // do not break on comma, for(var a = 1, b = 2)
-                flags.declaration_assignment = false;
-            }
-
-            print_token();
-
-            if (flags.declaration_assignment) {
-                flags.declaration_assignment = false;
-                print_newline(false, true);
-            } else {
-                output_space_before_token = true;
-            }
-            return;
-        }
-
-        print_token();
-        if (flags.mode === MODE.ObjectLiteral ||
-            (flags.mode === MODE.Statement && flags.parent.mode === MODE.ObjectLiteral)) {
-            if (flags.mode === MODE.Statement) {
-                restore_mode();
-            }
-            print_newline();
-        } else {
-            // EXPR or DO_BLOCK
-            output_space_before_token = true;
-        }
-
-    }
-
-    function handle_operator() {
-        // Check if this is a BlockStatement that should be treated as a ObjectLiteral
-        if (token_text === ':' && flags.mode === MODE.BlockStatement &&
-                last_last_text === '{' &&
-                (last_type === 'TK_WORD' || last_type === 'TK_RESERVED')){
-            flags.mode = MODE.ObjectLiteral;
-        }
-
-        if (start_of_statement()) {
-            // The conditional starts the statement if appropriate.
-        }
-
-        var space_before = true;
-        var space_after = true;
-        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();
-            return;
-        }
-
-        // hack for actionscript's import .*;
-        if (token_text === '*' && last_type === 'TK_DOT' && !last_last_text.match(/^\d+$/)) {
-            print_token();
-            return;
-        }
-
-        if (token_text === ':' && flags.in_case) {
-            flags.case_body = true;
-            indent();
-            print_token();
-            print_newline();
-            flags.in_case = false;
-            return;
-        }
-
-        if (token_text === '::') {
-            // no spaces around exotic namespacing syntax operator
-            print_token();
-            return;
-        }
-
-        // 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 (input_wanted_newline && (token_text === '--' || token_text === '++')) {
-            print_newline();
-        }
-
-        // Allow line wrapping between operators
-        if (last_type === 'TK_OPERATOR') {
-            allow_wrap_or_preserved_newline();
-        }
-
-        if (in_array(token_text, ['--', '++', '!', '~']) || (in_array(token_text, ['-', '+']) && (in_array(last_type, ['TK_START_BLOCK', 'TK_START_EXPR', 'TK_EQUALS', 'TK_OPERATOR']) || in_array(flags.last_text, line_starters) || flags.last_text === ','))) {
-            // unary operators (and binary +/- pretending to be unary) special cases
-
-            space_before = false;
-            space_after = false;
-
-            if (flags.last_text === ';' && is_expression(flags.mode)) {
-                // for (;; ++i)
-                //        ^^^
-                space_before = true;
-            }
-
-            if (last_type === 'TK_RESERVED') {
-                space_before = true;
-            }
-
-            if ((flags.mode === MODE.BlockStatement || flags.mode === MODE.Statement) && (flags.last_text === '{' || flags.last_text === ';')) {
-                // { foo; --i }
-                // foo(); --bar;
-                print_newline();
-            }
-        } else if (token_text === ':') {
-            if (flags.ternary_depth === 0) {
-                if (flags.mode === MODE.BlockStatement) {
-                    flags.mode = MODE.ObjectLiteral;
-                }
-                space_before = false;
-            } else {
-                flags.ternary_depth -= 1;
-            }
-        } else if (token_text === '?') {
-            flags.ternary_depth += 1;
-        } else if (token_text === '*' && last_type === 'TK_RESERVED' && flags.last_text === 'function') {
-            space_before = false;
-            space_after = false;
-        }
-        output_space_before_token = output_space_before_token || space_before;
-        print_token();
-        output_space_before_token = space_after;
-    }
-
-    function handle_block_comment() {
-        var lines = split_newlines(token_text);
-        var j; // iterator for this case
-        var javadoc = false;
-        var starless = false;
-        var lastIndent = whitespace_before_token.join('');
-        var lastIndentLength = lastIndent.length;
-
-        // block comment starts with a new line
-        print_newline(false, true);
-        if (lines.length > 1) {
-            if (all_lines_start_with(lines.slice(1), '*')) {
-                javadoc = true;
-            }
-            else if (each_line_matches_indent(lines.slice(1), lastIndent)) {
-                starless = true;
-            }
-        }
-
-        // first line always indented
-        print_token(lines[0]);
-        for (j = 1; j < lines.length; j++) {
-            print_newline(false, true);
-            if (javadoc) {
-                // javadoc: reformat and re-indent
-                print_token(' ' + trim(lines[j]));
-            } else if (starless && lines[j].length > lastIndentLength) {
-                // starless: re-indent non-empty content, avoiding trim
-                print_token(lines[j].substring(lastIndentLength));
-            } else {
-                // normal comments output raw
-                output_lines[output_lines.length - 1].text.push(lines[j]);
-            }
-        }
-
-        // for comments of more than one line, make sure there's a new line after
-        print_newline(false, true);
-    }
-
-    function handle_inline_comment() {
-        output_space_before_token = true;
-        print_token();
-        output_space_before_token = true;
-    }
-
-    function handle_comment() {
-        if (input_wanted_newline) {
-            print_newline(false, true);
-        } else {
-            trim_output(true);
-        }
-
-        output_space_before_token = true;
-        print_token();
-        print_newline(false, true);
-    }
-
-    function handle_dot() {
-        if (start_of_statement()) {
-            // The conditional starts the statement if appropriate.
-        }
-
-        if (last_type === 'TK_RESERVED' && is_special_word(flags.last_text)) {
-            output_space_before_token = true;
-        } 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);
-        }
-
-        print_token();
-    }
-
-    function handle_unknown() {
-        print_token();
-
-        if (token_text[token_text.length - 1] === '\n') {
-            print_newline();
-        }
-    }
-}
diff --git a/toolkit/devtools/jsbeautify/src/beautify-tests.js b/toolkit/devtools/jsbeautify/src/beautify-tests.js
deleted file mode 100644
index 254a9ca9401c..000000000000
--- a/toolkit/devtools/jsbeautify/src/beautify-tests.js
+++ /dev/null
@@ -1,2096 +0,0 @@
-/*global js_beautify: true */
-
-function run_beautifier_tests(test_obj, Urlencoded, js_beautify, html_beautify, css_beautify)
-{
-
-    var opts = {
-        indent_size: 4,
-        indent_char: ' ',
-        preserve_newlines: true,
-        jslint_happy: false,
-        keep_array_indentation: false,
-        brace_style: 'collapse',
-        space_before_conditional: true,
-        break_chained_methods: false,
-        selector_separator: '\n',
-        end_with_newline: true
-    };
-
-    function test_js_beautifier(input)
-    {
-        return js_beautify(input, opts);
-    }
-
-    function test_html_beautifier(input)
-    {
-        return html_beautify(input, opts);
-    }
-
-    function test_css_beautifier(input)
-    {
-        return css_beautify(input, opts);
-    }
-
-    var sanitytest;
-
-    // test the input on beautifier with the current flag settings
-    // does not check the indentation / surroundings as bt() does
-    function test_fragment(input, expected)
-    {
-        expected = expected || input;
-        sanitytest.expect(input, expected);
-        // if the expected is different from input, run it again
-        // expected output should be unchanged when run twice.
-        if (expected != input) {
-            sanitytest.expect(expected, expected);
-        }
-    }
-
-
-
-    // test the input on beautifier with the current flag settings
-    // test both the input as well as { input } wrapping
-    function bt(input, expectation)
-    {
-        var wrapped_input, wrapped_expectation;
-
-        expectation = expectation || input;
-        sanitytest.test_function(test_js_beautifier, 'js_beautify');
-        test_fragment(input, expectation);
-
-        // test also the returned indentation
-        // e.g if input = "asdf();"
-        // then test that this remains properly formatted as well:
-        // {
-        //     asdf();
-        //     indent;
-        // }
-
-        if (opts.indent_size === 4 && input) {
-            wrapped_input = '{\n' + input.replace(/^(.+)$/mg, '    $1') + '\n    foo = bar;\n}';
-            wrapped_expectation = '{\n' + expectation.replace(/^(.+)$/mg, '    $1') + '\n    foo = bar;\n}';
-            test_fragment(wrapped_input, wrapped_expectation);
-        }
-
-    }
-
-    // test html
-    function bth(input, expectation)
-    {
-        var wrapped_input, wrapped_expectation, field_input, field_expectation;
-
-        expectation = expectation || input;
-        sanitytest.test_function(test_html_beautifier, 'html_beautify');
-        test_fragment(input, expectation);
-
-        if (opts.indent_size === 4 && input) {
-            wrapped_input = '
\n' + input.replace(/^(.+)$/mg, '    $1') + '\n    inline\n
';
-            wrapped_expectation = '
\n' + expectation.replace(/^(.+)$/mg, '    $1') + '\n    inline\n
';
-            test_fragment(wrapped_input, wrapped_expectation);
-        }
-
-        // Test that handlebars non-block {{}} tags act as content and do not
-        // get any spacing or line breaks.
-        if (input.indexOf('content') != -1) {
-            // Just {{field}}
-            field_input = input.replace(/content/g, '{{field}}');
-            field_expectation = expectation.replace(/content/g, '{{field}}');
-            test_fragment(field_input, field_expectation);
-
-            // handlebars comment
-            field_input = input.replace(/content/g, '{{! comment}}');
-            field_expectation = expectation.replace(/content/g, '{{! comment}}');
-            test_fragment(field_input, field_expectation);
-
-            // mixed {{field}} and content
-            field_input = input.replace(/content/g, 'pre{{field1}} {{field2}} {{field3}}post');
-            field_expectation = expectation.replace(/content/g, 'pre{{field1}} {{field2}} {{field3}}post');
-            test_fragment(field_input, field_expectation);
-        }
-    }
-
-    // test css
-    function btc(input, expectation)
-    {
-        var wrapped_input, wrapped_expectation;
-
-        expectation = expectation || input;
-        sanitytest.test_function(test_css_beautifier, 'css_beautify');
-        test_fragment(input, expectation);
-    }
-
-    // test the input on beautifier with the current flag settings,
-    // but dont't
-    function bt_braces(input, expectation)
-    {
-        var braces_ex = opts.brace_style;
-        opts.brace_style = 'expand';
-        bt(input, expectation);
-        opts.brace_style = braces_ex;
-    }
-
-    function beautifier_tests()
-    {
-        sanitytest = test_obj;
-
-        opts.indent_size       = 4;
-        opts.indent_char       = ' ';
-        opts.preserve_newlines = true;
-        opts.jslint_happy      = false;
-        opts.keep_array_indentation = false;
-        opts.brace_style       = "collapse";
-
-
-        // unicode support
-        bt('var ' + String.fromCharCode(3232) + '_' + String.fromCharCode(3232) + ' = "hi";');
-        bt('var ' + String.fromCharCode(228) + 'x = {\n    ' + String.fromCharCode(228) + 'rgerlich: true\n};');
-
-        bt('');
-        bt('return .5');
-        test_fragment('   return .5');
-        test_fragment('   return .5;\n   a();');
-        bt('a        =          1', 'a = 1');
-        bt('a=1', 'a = 1');
-        bt("a();\n\nb();", "a();\n\nb();");
-        bt('var a = 1 var b = 2', "var a = 1\nvar b = 2");
-        bt('var a=1, b=c[d], e=6;', 'var a = 1,\n    b = c[d],\n    e = 6;');
-        bt('var a,\n    b,\n    c;');
-        bt('let a = 1 let b = 2', "let a = 1\nlet b = 2");
-        bt('let a=1, b=c[d], e=6;', 'let a = 1,\n    b = c[d],\n    e = 6;');
-        bt('let a,\n    b,\n    c;');
-        bt('const a = 1 const b = 2', "const a = 1\nconst b = 2");
-        bt('const a=1, b=c[d], e=6;', 'const a = 1,\n    b = c[d],\n    e = 6;');
-        bt('const a,\n    b,\n    c;');
-        bt('a = " 12345 "');
-        bt("a = ' 12345 '");
-        bt('if (a == 1) b = 2;', "if (a == 1) b = 2;");
-        bt('if(1){2}else{3}', "if (1) {\n    2\n} else {\n    3\n}");
-        bt('if(1||2);', 'if (1 || 2);');
-        bt('(a==1)||(b==2)', '(a == 1) || (b == 2)');
-        bt('var a = 1 if (2) 3;', "var a = 1\nif (2) 3;");
-        bt('a = a + 1');
-        bt('a = a == 1');
-        bt('/12345[^678]*9+/.match(a)');
-        bt('a /= 5');
-        bt('a = 0.5 * 3');
-        bt('a *= 10.55');
-        bt('a < .5');
-        bt('a <= .5');
-        bt('a<.5', 'a < .5');
-        bt('a<=.5', 'a <= .5');
-        bt('a = 0xff;');
-        bt('a=0xff+4', 'a = 0xff + 4');
-        bt('a = [1, 2, 3, 4]');
-        bt('F*(g/=f)*g+b', 'F * (g /= f) * g + b');
-        bt('a.b({c:d})', 'a.b({\n    c: d\n})');
-        bt('a.b\n(\n{\nc:\nd\n}\n)', 'a.b({\n    c: d\n})');
-        bt('a.b({c:"d"})', 'a.b({\n    c: "d"\n})');
-        bt('a.b\n(\n{\nc:\n"d"\n}\n)', 'a.b({\n    c: "d"\n})');
-        bt('a=!b', 'a = !b');
-        bt('a=!!b', 'a = !!b');
-        bt('a?b:c', 'a ? b : c');
-        bt('a?1:2', 'a ? 1 : 2');
-        bt('a?(b):c', 'a ? (b) : c');
-        bt('x={a:1,b:w=="foo"?x:y,c:z}', 'x = {\n    a: 1,\n    b: w == "foo" ? x : y,\n    c: z\n}');
-        bt('x=a?b?c?d:e:f:g;', 'x = a ? b ? c ? d : e : f : g;');
-        bt('x=a?b?c?d:{e1:1,e2:2}:f:g;', 'x = a ? b ? c ? d : {\n    e1: 1,\n    e2: 2\n} : f : g;');
-        bt('function void(void) {}');
-        bt('if(!a)foo();', 'if (!a) foo();');
-        bt('a=~a', 'a = ~a');
-        bt('a;/*comment*/b;', "a; /*comment*/\nb;");
-        bt('a;/* comment */b;', "a; /* comment */\nb;");
-        test_fragment('a;/*\ncomment\n*/b;', "a;\n/*\ncomment\n*/\nb;"); // simple comments don't get touched at all
-        bt('a;/**\n* javadoc\n*/b;', "a;\n/**\n * javadoc\n */\nb;");
-        test_fragment('a;/**\n\nno javadoc\n*/b;', "a;\n/**\n\nno javadoc\n*/\nb;");
-        bt('a;/*\n* javadoc\n*/b;', "a;\n/*\n * javadoc\n */\nb;"); // comment blocks detected and reindented even w/o javadoc starter
-        bt('if(a)break;', "if (a) break;");
-        bt('if(a){break}', "if (a) {\n    break\n}");
-        bt('if((a))foo();', 'if ((a)) foo();');
-        bt('for(var i=0;;) a', 'for (var i = 0;;) a');
-        bt('for(var i=0;;)\na', 'for (var i = 0;;)\n    a');
-        bt('a++;', 'a++;');
-        bt('for(;;i++)a()', 'for (;; i++) a()');
-        bt('for(;;i++)\na()', 'for (;; i++)\n    a()');
-        bt('for(;;++i)a', 'for (;; ++i) a');
-        bt('return(1)', 'return (1)');
-        bt('try{a();}catch(b){c();}finally{d();}', "try {\n    a();\n} catch (b) {\n    c();\n} finally {\n    d();\n}");
-        bt('(xx)()'); // magic function call
-        bt('a[1]()'); // another magic function call
-        bt('if(a){b();}else if(c) foo();', "if (a) {\n    b();\n} else if (c) foo();");
-        bt('switch(x) {case 0: case 1: a(); break; default: break}', "switch (x) {\n    case 0:\n    case 1:\n        a();\n        break;\n    default:\n        break\n}");
-        bt('switch(x){case -1:break;case !y:break;}', 'switch (x) {\n    case -1:\n        break;\n    case !y:\n        break;\n}');
-        bt('a !== b');
-        bt('if (a) b(); else c();', "if (a) b();\nelse c();");
-        bt("// comment\n(function something() {})"); // typical greasemonkey start
-        bt("{\n\n    x();\n\n}"); // was: duplicating newlines
-        bt('if (a in b) foo();');
-        bt('var a, b;');
-        //  bt('var a, b');
-        bt('{a:1, b:2}', "{\n    a: 1,\n    b: 2\n}");
-        bt('a={1:[-1],2:[+1]}', 'a = {\n    1: [-1],\n    2: [+1]\n}');
-        bt('var l = {\'a\':\'1\', \'b\':\'2\'}', "var l = {\n    'a': '1',\n    'b': '2'\n}");
-        bt('if (template.user[n] in bk) foo();');
-        bt('{{}/z/}', "{\n    {}\n    /z/\n}");
-        bt('return 45', "return 45");
-        bt('return this.prevObject ||\n\n    this.constructor(null);');
-        bt('If[1]', "If[1]");
-        bt('Then[1]', "Then[1]");
-        bt('a = 1e10', "a = 1e10");
-        bt('a = 1.3e10', "a = 1.3e10");
-        bt('a = 1.3e-10', "a = 1.3e-10");
-        bt('a = -1.3e-10', "a = -1.3e-10");
-        bt('a = 1e-10', "a = 1e-10");
-        bt('a = e - 10', "a = e - 10");
-        bt('a = 11-10', "a = 11 - 10");
-        bt("a = 1;// comment", "a = 1; // comment");
-        bt("a = 1; // comment", "a = 1; // comment");
-        bt("a = 1;\n // comment", "a = 1;\n// comment");
-        bt('a = [-1, -1, -1]');
-
-        // The exact formatting these should have is open for discussion, but they are at least reasonable
-        bt('a = [ // comment\n    -1, -1, -1\n]');
-        bt('var a = [ // comment\n    -1, -1, -1\n]');
-        bt('a = [ // comment\n    -1, // comment\n    -1, -1\n]');
-        bt('var a = [ // comment\n    -1, // comment\n    -1, -1\n]');
-
-        bt('o = [{a:b},{c:d}]', 'o = [{\n    a: b\n}, {\n    c: d\n}]');
-
-        bt("if (a) {\n    do();\n}"); // was: extra space appended
-
-        bt("if (a) {\n// comment\n}else{\n// comment\n}", "if (a) {\n    // comment\n} else {\n    // comment\n}"); // if/else statement with empty body
-        bt("if (a) {\n// comment\n// comment\n}", "if (a) {\n    // comment\n    // comment\n}"); // multiple comments indentation
-        bt("if (a) b() else c();", "if (a) b()\nelse c();");
-        bt("if (a) b() else if c() d();", "if (a) b()\nelse if c() d();");
-
-        bt("{}");
-        bt("{\n\n}");
-        bt("do { a(); } while ( 1 );", "do {\n    a();\n} while (1);");
-        bt("do {} while (1);");
-        bt("do {\n} while (1);", "do {} while (1);");
-        bt("do {\n\n} while (1);");
-        bt("var a = x(a, b, c)");
-        bt("delete x if (a) b();", "delete x\nif (a) b();");
-        bt("delete x[x] if (a) b();", "delete x[x]\nif (a) b();");
-        bt("for(var a=1,b=2)d", "for (var a = 1, b = 2) d");
-        bt("for(var a=1,b=2,c=3) d", "for (var a = 1, b = 2, c = 3) d");
-        bt("for(var a=1,b=2,c=3;d<3;d++)\ne", "for (var a = 1, b = 2, c = 3; d < 3; d++)\n    e");
-        bt("function x(){(a||b).c()}", "function x() {\n    (a || b).c()\n}");
-        bt("function x(){return - 1}", "function x() {\n    return -1\n}");
-        bt("function x(){return ! a}", "function x() {\n    return !a\n}");
-        bt("x => x", "x => x");
-        bt("(x) => x", "(x) => x");
-        bt("x => { x }", "x => {\n    x\n}");
-        bt("(x) => { x }", "(x) => {\n    x\n}");
-
-        // a common snippet in jQuery plugins
-        bt("settings = $.extend({},defaults,settings);", "settings = $.extend({}, defaults, settings);");
-
-        // reserved words used as property names
-        bt("$http().then().finally().default()", "$http().then().finally().default()");
-        bt("$http()\n.then()\n.finally()\n.default()", "$http()\n    .then()\n    .finally()\n    .default()");
-        bt("$http().when.in.new.catch().throw()", "$http().when.in.new.catch().throw()");
-        bt("$http()\n.when\n.in\n.new\n.catch()\n.throw()", "$http()\n    .when\n    .in\n    .new\n    .catch()\n    .throw()");
-
-        bt('{xxx;}()', '{\n    xxx;\n}()');
-
-        bt("a = 'a'\nb = 'b'");
-        bt("a = /reg/exp");
-        bt("a = /reg/");
-        bt('/abc/.test()');
-        bt('/abc/i.test()');
-        bt("{/abc/i.test()}", "{\n    /abc/i.test()\n}");
-        bt('var x=(a)/a;', 'var x = (a) / a;');
-
-        bt('x != -1', 'x != -1');
-
-        bt('for (; s-->0;)t', 'for (; s-- > 0;) t');
-        bt('for (; s++>0;)u', 'for (; s++ > 0;) u');
-        bt('a = s++>s--;', 'a = s++ > s--;');
-        bt('a = s++>--s;', 'a = s++ > --s;');
-
-        bt('{x=#1=[]}', '{\n    x = #1=[]\n}');
-        bt('{a:#1={}}', '{\n    a: #1={}\n}');
-        bt('{a:#1#}', '{\n    a: #1#\n}');
-
-        test_fragment('"incomplete-string');
-        test_fragment("'incomplete-string");
-        test_fragment('/incomplete-regex');
-        test_fragment('`incomplete-template-string');
-
-        test_fragment('{a:1},{a:2}', '{\n    a: 1\n}, {\n    a: 2\n}');
-        test_fragment('var ary=[{a:1}, {a:2}];', 'var ary = [{\n    a: 1\n}, {\n    a: 2\n}];');
-
-        test_fragment('{a:#1', '{\n    a: #1'); // incomplete
-        test_fragment('{a:#', '{\n    a: #'); // incomplete
-
-        test_fragment('}}}', '}\n}\n}'); // incomplete
-
-        test_fragment('', '');
-
-        test_fragment('a=/regexp', 'a = /regexp'); // incomplete regexp
-
-        bt('{a:#1=[],b:#1#,c:#999999#}', '{\n    a: #1=[],\n    b: #1#,\n    c: #999999#\n}');
-
-        bt("a = 1e+2");
-        bt("a = 1e-2");
-        bt("do{x()}while(a>1)", "do {\n    x()\n} while (a > 1)");
-
-        bt("x(); /reg/exp.match(something)", "x();\n/reg/exp.match(something)");
-
-        test_fragment("something();(", "something();\n(");
-        test_fragment("#!she/bangs, she bangs\nf=1", "#!she/bangs, she bangs\n\nf = 1");
-        test_fragment("#!she/bangs, she bangs\n\nf=1", "#!she/bangs, she bangs\n\nf = 1");
-        test_fragment("#!she/bangs, she bangs\n\n/* comment */", "#!she/bangs, she bangs\n\n/* comment */");
-        test_fragment("#!she/bangs, she bangs\n\n\n/* comment */", "#!she/bangs, she bangs\n\n\n/* comment */");
-        test_fragment("#", "#");
-        test_fragment("#!", "#!");
-
-        bt("function namespace::something()");
-
-        test_fragment("", "");
-        test_fragment("", "");
-
-        bt('{foo();--bar;}', '{\n    foo();\n    --bar;\n}');
-        bt('{foo();++bar;}', '{\n    foo();\n    ++bar;\n}');
-        bt('{--bar;}', '{\n    --bar;\n}');
-        bt('{++bar;}', '{\n    ++bar;\n}');
-
-        // Handling of newlines around unary ++ and -- operators
-        bt('{foo\n++bar;}', '{\n    foo\n    ++bar;\n}');
-        bt('{foo++\nbar;}', '{\n    foo++\n    bar;\n}');
-
-        // This is invalid, but harder to guard against. Issue #203.
-        bt('{foo\n++\nbar;}', '{\n    foo\n    ++\n    bar;\n}');
-
-
-        // regexps
-        bt('a(/abc\\/\\/def/);b()', "a(/abc\\/\\/def/);\nb()");
-        bt('a(/a[b\\[\\]c]d/);b()', "a(/a[b\\[\\]c]d/);\nb()");
-        test_fragment('a(/a[b\\[', "a(/a[b\\["); // incomplete char class
-        // allow unescaped / in char classes
-        bt('a(/[a/b]/);b()', "a(/[a/b]/);\nb()");
-
-        bt('function foo() {\n    return [\n        "one",\n        "two"\n    ];\n}');
-        bt('a=[[1,2],[4,5],[7,8]]', "a = [\n    [1, 2],\n    [4, 5],\n    [7, 8]\n]");
-        bt('a=[[1,2],[4,5],function(){},[7,8]]',
-            "a = [\n    [1, 2],\n    [4, 5],\n    function() {},\n    [7, 8]\n]");
-        bt('a=[[1,2],[4,5],function(){},function(){},[7,8]]',
-            "a = [\n    [1, 2],\n    [4, 5],\n    function() {},\n    function() {},\n    [7, 8]\n]");
-        bt('a=[[1,2],[4,5],function(){},[7,8]]',
-            "a = [\n    [1, 2],\n    [4, 5],\n    function() {},\n    [7, 8]\n]");
-        bt('a=[b,c,function(){},function(){},d]',
-            "a = [b, c,\n    function() {},\n    function() {},\n    d\n]");
-        bt('a=[a[1],b[4],c[d[7]]]', "a = [a[1], b[4], c[d[7]]]");
-        bt('[1,2,[3,4,[5,6],7],8]', "[1, 2, [3, 4, [5, 6], 7], 8]");
-
-        bt('[[["1","2"],["3","4"]],[["5","6","7"],["8","9","0"]],[["1","2","3"],["4","5","6","7"],["8","9","0"]]]',
-            '[\n    [\n        ["1", "2"],\n        ["3", "4"]\n    ],\n    [\n        ["5", "6", "7"],\n        ["8", "9", "0"]\n    ],\n    [\n        ["1", "2", "3"],\n        ["4", "5", "6", "7"],\n        ["8", "9", "0"]\n    ]\n]');
-
-        bt('{[x()[0]];indent;}', '{\n    [x()[0]];\n    indent;\n}');
-
-        bt('return ++i', 'return ++i');
-        bt('return !!x', 'return !!x');
-        bt('return !x', 'return !x');
-        bt('return [1,2]', 'return [1, 2]');
-        bt('return;', 'return;');
-        bt('return\nfunc', 'return\nfunc');
-        bt('catch(e)', 'catch (e)');
-        bt('yield [1, 2]');
-
-        bt('var a=1,b={foo:2,bar:3},{baz:4,wham:5},c=4;',
-            'var a = 1,\n    b = {\n        foo: 2,\n        bar: 3\n    },\n    {\n        baz: 4,\n        wham: 5\n    }, c = 4;');
-        bt('var a=1,b={foo:2,bar:3},{baz:4,wham:5},\nc=4;',
-            'var a = 1,\n    b = {\n        foo: 2,\n        bar: 3\n    },\n    {\n        baz: 4,\n        wham: 5\n    },\n    c = 4;');
-
-
-        // inline comment
-        bt('function x(/*int*/ start, /*string*/ foo)', 'function x( /*int*/ start, /*string*/ foo)');
-
-        // javadoc comment
-        bt('/**\n* foo\n*/', '/**\n * foo\n */');
-        bt('{\n/**\n* foo\n*/\n}', '{\n    /**\n     * foo\n     */\n}');
-
-        // starless block comment
-        bt('/**\nfoo\n*/');
-        bt('/**\nfoo\n**/');
-        bt('/**\nfoo\nbar\n**/');
-        bt('/**\nfoo\n\nbar\n**/');
-        bt('/**\nfoo\n    bar\n**/');
-        bt('{\n/**\nfoo\n*/\n}', '{\n    /**\n    foo\n    */\n}');
-        bt('{\n/**\nfoo\n**/\n}', '{\n    /**\n    foo\n    **/\n}');
-        bt('{\n/**\nfoo\nbar\n**/\n}', '{\n    /**\n    foo\n    bar\n    **/\n}');
-        bt('{\n/**\nfoo\n\nbar\n**/\n}', '{\n    /**\n    foo\n\n    bar\n    **/\n}');
-        bt('{\n/**\nfoo\n    bar\n**/\n}', '{\n    /**\n    foo\n        bar\n    **/\n}');
-        bt('{\n    /**\n    foo\nbar\n    **/\n}');
-
-        bt('var a,b,c=1,d,e,f=2;', 'var a, b, c = 1,\n    d, e, f = 2;');
-        bt('var a,b,c=[],d,e,f=2;', 'var a, b, c = [],\n    d, e, f = 2;');
-        bt('function() {\n    var a, b, c, d, e = [],\n        f;\n}');
-
-        bt('do/regexp/;\nwhile(1);', 'do /regexp/;\nwhile (1);'); // hmmm
-
-        bt('var a = a,\na;\nb = {\nb\n}', 'var a = a,\n    a;\nb = {\n    b\n}');
-
-        bt('var a = a,\n    /* c */\n    b;');
-        bt('var a = a,\n    // c\n    b;');
-
-        bt('foo.("bar");'); // weird element referencing
-
-
-        bt('if (a) a()\nelse b()\nnewline()');
-        bt('if (a) a()\nnewline()');
-        bt('a=typeof(x)', 'a = typeof(x)');
-
-        bt('var a = function() {\n        return null;\n    },\n    b = false;');
-
-        bt('var a = function() {\n    func1()\n}');
-        bt('var a = function() {\n    func1()\n}\nvar b = function() {\n    func2()\n}');
-
-        // code with and without semicolons
-        bt( 'var whatever = require("whatever");\nfunction() {\n    a = 6;\n}',
-            'var whatever = require("whatever");\n\nfunction() {\n    a = 6;\n}');
-        bt( 'var whatever = require("whatever")\nfunction() {\n    a = 6\n}',
-            'var whatever = require("whatever")\n\nfunction() {\n    a = 6\n}');
-
-
-        opts.jslint_happy = true;
-
-        bt('a=typeof(x)', 'a = typeof (x)');
-        bt('x();\n\nfunction(){}', 'x();\n\nfunction () {}');
-        bt('function () {\n    var a, b, c, d, e = [],\n        f;\n}');
-        bt('switch(x) {case 0: case 1: a(); break; default: break}',
-            "switch (x) {\ncase 0:\ncase 1:\n    a();\n    break;\ndefault:\n    break\n}");
-        bt('switch(x){case -1:break;case !y:break;}',
-            'switch (x) {\ncase -1:\n    break;\ncase !y:\n    break;\n}');
-        test_fragment("// comment 1\n(function()", "// comment 1\n(function ()"); // typical greasemonkey start
-        bt('var o1=$.extend(a);function(){alert(x);}', 'var o1 = $.extend(a);\n\nfunction () {\n    alert(x);\n}');
-        bt('function* () {\n    yield 1;\n}');
-
-        opts.jslint_happy = false;
-
-        bt('switch(x) {case 0: case 1: a(); break; default: break}',
-            "switch (x) {\n    case 0:\n    case 1:\n        a();\n        break;\n    default:\n        break\n}");
-        bt('switch(x){case -1:break;case !y:break;}',
-            'switch (x) {\n    case -1:\n        break;\n    case !y:\n        break;\n}');
-        test_fragment("// comment 2\n(function()", "// comment 2\n(function()"); // typical greasemonkey start
-        bt("var a2, b2, c2, d2 = 0, c = function() {}, d = '';", "var a2, b2, c2, d2 = 0,\n    c = function() {},\n    d = '';");
-        bt("var a2, b2, c2, d2 = 0, c = function() {},\nd = '';", "var a2, b2, c2, d2 = 0,\n    c = function() {},\n    d = '';");
-        bt('var o2=$.extend(a);function(){alert(x);}', 'var o2 = $.extend(a);\n\nfunction() {\n    alert(x);\n}');
-        bt('function*() {\n    yield 1;\n}');
-
-        bt('function* x() {\n    yield 1;\n}');
-
-        bt('{"x":[{"a":1,"b":3},7,8,8,8,8,{"b":99},{"a":11}]}', '{\n    "x": [{\n            "a": 1,\n            "b": 3\n        },\n        7, 8, 8, 8, 8, {\n            "b": 99\n        }, {\n            "a": 11\n        }\n    ]\n}');
-
-        bt('{"1":{"1a":"1b"},"2"}', '{\n    "1": {\n        "1a": "1b"\n    },\n    "2"\n}');
-        bt('{a:{a:b},c}', '{\n    a: {\n        a: b\n    },\n    c\n}');
-
-        bt('{[y[a]];keep_indent;}', '{\n    [y[a]];\n    keep_indent;\n}');
-
-        bt('if (x) {y} else { if (x) {y}}', 'if (x) {\n    y\n} else {\n    if (x) {\n        y\n    }\n}');
-
-        bt('if (foo) one()\ntwo()\nthree()');
-        bt('if (1 + foo() && bar(baz()) / 2) one()\ntwo()\nthree()');
-        bt('if (1 + foo() && bar(baz()) / 2) one();\ntwo();\nthree();');
-
-        opts.indent_size = 1;
-        opts.indent_char = ' ';
-        bt('{ one_char() }', "{\n one_char()\n}");
-
-        bt('var a,b=1,c=2', 'var a, b = 1,\n c = 2');
-
-        opts.indent_size = 4;
-        opts.indent_char = ' ';
-        bt('{ one_char() }', "{\n    one_char()\n}");
-
-        opts.indent_size = 1;
-        opts.indent_char = "\t";
-        bt('{ one_char() }', "{\n\tone_char()\n}");
-        bt('x = a ? b : c; x;', 'x = a ? b : c;\nx;');
-
-        //set to something else than it should change to, but with tabs on, should override
-        opts.indent_size = 5;
-        opts.indent_char = ' ';
-        opts.indent_with_tabs = true;
-
-        bt('{ one_char() }', "{\n\tone_char()\n}");
-        bt('x = a ? b : c; x;', 'x = a ? b : c;\nx;');
-
-        opts.indent_size = 4;
-        opts.indent_char = ' ';
-        opts.indent_with_tabs = false;
-
-        opts.preserve_newlines = false;
-
-        bt('var\na=dont_preserve_newlines;', 'var a = dont_preserve_newlines;');
-
-        // make sure the blank line between function definitions stays
-        // even when preserve_newlines = false
-        bt('function foo() {\n    return 1;\n}\n\nfunction foo() {\n    return 1;\n}');
-        bt('function foo() {\n    return 1;\n}\nfunction foo() {\n    return 1;\n}',
-           'function foo() {\n    return 1;\n}\n\nfunction foo() {\n    return 1;\n}'
-          );
-        bt('function foo() {\n    return 1;\n}\n\n\nfunction foo() {\n    return 1;\n}',
-           'function foo() {\n    return 1;\n}\n\nfunction foo() {\n    return 1;\n}'
-          );
-
-        opts.preserve_newlines = true;
-        bt('var\na=do_preserve_newlines;', 'var\n    a = do_preserve_newlines;');
-        bt('// a\n// b\n\n// c\n// d');
-        bt('if (foo) //  comment\n{\n    bar();\n}');
-
-
-        opts.keep_array_indentation = false;
-        bt("a = ['a', 'b', 'c',\n   'd', 'e', 'f']",
-            "a = ['a', 'b', 'c',\n    'd', 'e', 'f'\n]");
-        bt("a = ['a', 'b', 'c',\n   'd', 'e', 'f',\n        'g', 'h', 'i']",
-            "a = ['a', 'b', 'c',\n    'd', 'e', 'f',\n    'g', 'h', 'i'\n]");
-        bt("a = ['a', 'b', 'c',\n       'd', 'e', 'f',\n            'g', 'h', 'i']",
-            "a = ['a', 'b', 'c',\n    'd', 'e', 'f',\n    'g', 'h', 'i'\n]");
-        bt('var x = [{}\n]', 'var x = [{}]');
-        bt('var x = [{foo:bar}\n]', 'var x = [{\n    foo: bar\n}]');
-        bt("a = ['something',\n    'completely',\n    'different'];\nif (x);",
-            "a = ['something',\n    'completely',\n    'different'\n];\nif (x);");
-        bt("a = ['a','b','c']", "a = ['a', 'b', 'c']");
-
-        bt("a = ['a',   'b','c']", "a = ['a', 'b', 'c']");
-        bt("x = [{'a':0}]",
-            "x = [{\n    'a': 0\n}]");
-        bt('{a([[a1]], {b;});}',
-            '{\n    a([\n        [a1]\n    ], {\n        b;\n    });\n}');
-        bt("a();\n   [\n   ['sdfsdfsd'],\n        ['sdfsdfsdf']\n   ].toString();",
-            "a();\n[\n    ['sdfsdfsd'],\n    ['sdfsdfsdf']\n].toString();");
-        bt("a();\na = [\n   ['sdfsdfsd'],\n        ['sdfsdfsdf']\n   ].toString();",
-            "a();\na = [\n    ['sdfsdfsd'],\n    ['sdfsdfsdf']\n].toString();");
-        bt("function() {\n    Foo([\n        ['sdfsdfsd'],\n        ['sdfsdfsdf']\n    ]);\n}",
-            "function() {\n    Foo([\n        ['sdfsdfsd'],\n        ['sdfsdfsdf']\n    ]);\n}");
-        bt('function foo() {\n    return [\n        "one",\n        "two"\n    ];\n}');
-        // 4 spaces per indent input, processed with 4-spaces per indent
-        bt( "function foo() {\n" +
-            "    return [\n" +
-            "        {\n" +
-            "            one: 'x',\n" +
-            "            two: [\n" +
-            "                {\n" +
-            "                    id: 'a',\n" +
-            "                    name: 'apple'\n" +
-            "                }, {\n" +
-            "                    id: 'b',\n" +
-            "                    name: 'banana'\n" +
-            "                }\n" +
-            "            ]\n" +
-            "        }\n" +
-            "    ];\n" +
-            "}",
-            "function foo() {\n" +
-            "    return [{\n" +
-            "        one: 'x',\n" +
-            "        two: [{\n" +
-            "            id: 'a',\n" +
-            "            name: 'apple'\n" +
-            "        }, {\n" +
-            "            id: 'b',\n" +
-            "            name: 'banana'\n" +
-            "        }]\n" +
-            "    }];\n" +
-            "}");
-        // 3 spaces per indent input, processed with 4-spaces per indent
-        bt( "function foo() {\n" +
-            "   return [\n" +
-            "      {\n" +
-            "         one: 'x',\n" +
-            "         two: [\n" +
-            "            {\n" +
-            "               id: 'a',\n" +
-            "               name: 'apple'\n" +
-            "            }, {\n" +
-            "               id: 'b',\n" +
-            "               name: 'banana'\n" +
-            "            }\n" +
-            "         ]\n" +
-            "      }\n" +
-            "   ];\n" +
-            "}",
-            "function foo() {\n" +
-            "    return [{\n" +
-            "        one: 'x',\n" +
-            "        two: [{\n" +
-            "            id: 'a',\n" +
-            "            name: 'apple'\n" +
-            "        }, {\n" +
-            "            id: 'b',\n" +
-            "            name: 'banana'\n" +
-            "        }]\n" +
-            "    }];\n" +
-            "}");
-
-        opts.keep_array_indentation = true;
-        bt("a = ['a', 'b', 'c',\n   'd', 'e', 'f']");
-        bt("a = ['a', 'b', 'c',\n   'd', 'e', 'f',\n        'g', 'h', 'i']");
-        bt("a = ['a', 'b', 'c',\n       'd', 'e', 'f',\n            'g', 'h', 'i']");
-        bt('var x = [{}\n]', 'var x = [{}\n]');
-        bt('var x = [{foo:bar}\n]', 'var x = [{\n        foo: bar\n    }\n]');
-        bt("a = ['something',\n    'completely',\n    'different'];\nif (x);");
-        bt("a = ['a','b','c']", "a = ['a', 'b', 'c']");
-        bt("a = ['a',   'b','c']", "a = ['a', 'b', 'c']");
-        bt("x = [{'a':0}]",
-            "x = [{\n    'a': 0\n}]");
-        bt('{a([[a1]], {b;});}',
-            '{\n    a([[a1]], {\n        b;\n    });\n}');
-        bt("a();\n   [\n   ['sdfsdfsd'],\n        ['sdfsdfsdf']\n   ].toString();",
-            "a();\n   [\n   ['sdfsdfsd'],\n        ['sdfsdfsdf']\n   ].toString();");
-        bt("a();\na = [\n   ['sdfsdfsd'],\n        ['sdfsdfsdf']\n   ].toString();",
-            "a();\na = [\n   ['sdfsdfsd'],\n        ['sdfsdfsdf']\n   ].toString();");
-        bt("function() {\n    Foo([\n        ['sdfsdfsd'],\n        ['sdfsdfsdf']\n    ]);\n}",
-            "function() {\n    Foo([\n        ['sdfsdfsd'],\n        ['sdfsdfsdf']\n    ]);\n}");
-        bt('function foo() {\n    return [\n        "one",\n        "two"\n    ];\n}');
-        // 4 spaces per indent input, processed with 4-spaces per indent
-        bt( "function foo() {\n" +
-            "    return [\n" +
-            "        {\n" +
-            "            one: 'x',\n" +
-            "            two: [\n" +
-            "                {\n" +
-            "                    id: 'a',\n" +
-            "                    name: 'apple'\n" +
-            "                }, {\n" +
-            "                    id: 'b',\n" +
-            "                    name: 'banana'\n" +
-            "                }\n" +
-            "            ]\n" +
-            "        }\n" +
-            "    ];\n" +
-            "}");
-        // 3 spaces per indent input, processed with 4-spaces per indent
-        // Should be unchanged, but is not - #445
-//         bt( "function foo() {\n" +
-//             "   return [\n" +
-//             "      {\n" +
-//             "         one: 'x',\n" +
-//             "         two: [\n" +
-//             "            {\n" +
-//             "               id: 'a',\n" +
-//             "               name: 'apple'\n" +
-//             "            }, {\n" +
-//             "               id: 'b',\n" +
-//             "               name: 'banana'\n" +
-//             "            }\n" +
-//             "         ]\n" +
-//             "      }\n" +
-//             "   ];\n" +
-//             "}");
-
-
-        opts.keep_array_indentation = false;
-
-
-        bt('a = //comment\n    /regex/;');
-
-        test_fragment('/*\n * X\n */');
-        test_fragment('/*\r\n * X\r\n */', '/*\n * X\n */');
-
-        bt('if (a)\n{\nb;\n}\nelse\n{\nc;\n}', 'if (a) {\n    b;\n} else {\n    c;\n}');
-
-
-        opts.brace_style = 'expand';
-
-        bt('//case 1\nif (a == 1)\n{}\n//case 2\nelse if (a == 2)\n{}');
-        bt('if(1){2}else{3}', "if (1)\n{\n    2\n}\nelse\n{\n    3\n}");
-        bt('try{a();}catch(b){c();}catch(d){}finally{e();}',
-            "try\n{\n    a();\n}\ncatch (b)\n{\n    c();\n}\ncatch (d)\n{}\nfinally\n{\n    e();\n}");
-        bt('if(a){b();}else if(c) foo();',
-            "if (a)\n{\n    b();\n}\nelse if (c) foo();");
-        bt('if(X)if(Y)a();else b();else c();',
-            "if (X)\n    if (Y) a();\n    else b();\nelse c();");
-        bt("if (a) {\n// comment\n}else{\n// comment\n}",
-            "if (a)\n{\n    // comment\n}\nelse\n{\n    // comment\n}"); // if/else statement with empty body
-        bt('if (x) {y} else { if (x) {y}}',
-            'if (x)\n{\n    y\n}\nelse\n{\n    if (x)\n    {\n        y\n    }\n}');
-        bt('if (a)\n{\nb;\n}\nelse\n{\nc;\n}',
-            'if (a)\n{\n    b;\n}\nelse\n{\n    c;\n}');
-        test_fragment('    /*\n* xx\n*/\n// xx\nif (foo) {\n    bar();\n}',
-                      '    /*\n     * xx\n     */\n    // xx\n    if (foo)\n    {\n        bar();\n    }');
-        bt('if (foo)\n{}\nelse /regex/.test();');
-        bt('if (foo) /regex/.test();');
-        bt('if (a)\n{\nb;\n}\nelse\n{\nc;\n}', 'if (a)\n{\n    b;\n}\nelse\n{\n    c;\n}');
-        test_fragment('if (foo) {', 'if (foo)\n{');
-        test_fragment('foo {', 'foo\n{');
-        test_fragment('return {', 'return {'); // return needs the brace.
-        test_fragment('return /* inline */ {', 'return /* inline */ {');
-        // test_fragment('return\n{', 'return\n{'); // can't support this?, but that's an improbable and extreme case anyway.
-        test_fragment('return;\n{', 'return;\n{');
-        bt("throw {}");
-        bt("throw {\n    foo;\n}");
-        bt('var foo = {}');
-        bt('if (foo) bar();\nelse break');
-        bt('function x() {\n    foo();\n}zzz', 'function x()\n{\n    foo();\n}\nzzz');
-        bt('a: do {} while (); xxx', 'a: do {} while ();\nxxx');
-        bt('var a = new function();');
-        bt('var a = new function() {};');
-        bt('var a = new function()\n{};', 'var a = new function() {};');
-        bt('var a = new function a()\n{};');
-        bt('var a = new function a()\n    {},\n    b = new function b()\n    {};');
-        test_fragment('new function');
-        bt("foo({\n    'a': 1\n},\n10);",
-            "foo(\n    {\n        'a': 1\n    },\n    10);");
-        bt('(["foo","bar"]).each(function(i) {return i;});',
-            '(["foo", "bar"]).each(function(i)\n{\n    return i;\n});');
-        bt('(function(i) {return i;})();',
-            '(function(i)\n{\n    return i;\n})();');
-        bt( "test( /*Argument 1*/ {\n" +
-            "    'Value1': '1'\n" +
-            "}, /*Argument 2\n" +
-            " */ {\n" +
-            "    'Value2': '2'\n" +
-            "});",
-            // expected
-            "test( /*Argument 1*/\n" +
-            "    {\n" +
-            "        'Value1': '1'\n" +
-            "    },\n" +
-            "    /*Argument 2\n" +
-            "     */\n" +
-            "    {\n" +
-            "        'Value2': '2'\n" +
-            "    });");
-        bt( "test(\n" +
-            "/*Argument 1*/ {\n" +
-            "    'Value1': '1'\n" +
-            "},\n" +
-            "/*Argument 2\n" +
-            " */ {\n" +
-            "    'Value2': '2'\n" +
-            "});",
-            // expected
-            "test(\n" +
-            "    /*Argument 1*/\n" +
-            "    {\n" +
-            "        'Value1': '1'\n" +
-            "    },\n" +
-            "    /*Argument 2\n" +
-            "     */\n" +
-            "    {\n" +
-            "        'Value2': '2'\n" +
-            "    });");
-        bt( "test( /*Argument 1*/\n" +
-            "{\n" +
-            "    'Value1': '1'\n" +
-            "}, /*Argument 2\n" +
-            " */\n" +
-            "{\n" +
-            "    'Value2': '2'\n" +
-            "});",
-            // expected
-            "test( /*Argument 1*/\n" +
-            "    {\n" +
-            "        'Value1': '1'\n" +
-            "    },\n" +
-            "    /*Argument 2\n" +
-            "     */\n" +
-            "    {\n" +
-            "        'Value2': '2'\n" +
-            "    });");
-
-        opts.brace_style = 'collapse';
-
-        bt('//case 1\nif (a == 1) {}\n//case 2\nelse if (a == 2) {}');
-        bt('if(1){2}else{3}', "if (1) {\n    2\n} else {\n    3\n}");
-        bt('try{a();}catch(b){c();}catch(d){}finally{e();}',
-             "try {\n    a();\n} catch (b) {\n    c();\n} catch (d) {} finally {\n    e();\n}");
-        bt('if(a){b();}else if(c) foo();',
-            "if (a) {\n    b();\n} else if (c) foo();");
-        bt("if (a) {\n// comment\n}else{\n// comment\n}",
-            "if (a) {\n    // comment\n} else {\n    // comment\n}"); // if/else statement with empty body
-        bt('if (x) {y} else { if (x) {y}}',
-            'if (x) {\n    y\n} else {\n    if (x) {\n        y\n    }\n}');
-        bt('if (a)\n{\nb;\n}\nelse\n{\nc;\n}',
-            'if (a) {\n    b;\n} else {\n    c;\n}');
-        test_fragment('    /*\n* xx\n*/\n// xx\nif (foo) {\n    bar();\n}',
-                      '    /*\n     * xx\n     */\n    // xx\n    if (foo) {\n        bar();\n    }');
-        bt('if (foo) {} else /regex/.test();');
-        bt('if (foo) /regex/.test();');
-        bt('if (a)\n{\nb;\n}\nelse\n{\nc;\n}', 'if (a) {\n    b;\n} else {\n    c;\n}');
-        test_fragment('if (foo) {', 'if (foo) {');
-        test_fragment('foo {', 'foo {');
-        test_fragment('return {', 'return {'); // return needs the brace.
-        test_fragment('return /* inline */ {', 'return /* inline */ {');
-        // test_fragment('return\n{', 'return\n{'); // can't support this?, but that's an improbable and extreme case anyway.
-        test_fragment('return;\n{', 'return; {');
-        bt("throw {}");
-        bt("throw {\n    foo;\n}");
-        bt('var foo = {}');
-        bt('if (foo) bar();\nelse break');
-        bt('function x() {\n    foo();\n}zzz', 'function x() {\n    foo();\n}\nzzz');
-        bt('a: do {} while (); xxx', 'a: do {} while ();\nxxx');
-        bt('var a = new function();');
-        bt('var a = new function() {};');
-        bt('var a = new function a() {};');
-        test_fragment('new function');
-        bt("foo({\n    'a': 1\n},\n10);",
-            "foo({\n        'a': 1\n    },\n    10);");
-        bt('(["foo","bar"]).each(function(i) {return i;});',
-            '(["foo", "bar"]).each(function(i) {\n    return i;\n});');
-        bt('(function(i) {return i;})();',
-            '(function(i) {\n    return i;\n})();');
-        bt( "test( /*Argument 1*/ {\n" +
-            "    'Value1': '1'\n" +
-            "}, /*Argument 2\n" +
-            " */ {\n" +
-            "    'Value2': '2'\n" +
-            "});",
-            // expected
-            "test( /*Argument 1*/ {\n" +
-            "        'Value1': '1'\n" +
-            "    },\n" +
-            "    /*Argument 2\n" +
-            "     */\n" +
-            "    {\n" +
-            "        'Value2': '2'\n" +
-            "    });");
-        bt( "test(\n" +
-            "/*Argument 1*/ {\n" +
-            "    'Value1': '1'\n" +
-            "},\n" +
-            "/*Argument 2\n" +
-            " */ {\n" +
-            "    'Value2': '2'\n" +
-            "});",
-            // expected
-            "test(\n" +
-            "    /*Argument 1*/\n" +
-            "    {\n" +
-            "        'Value1': '1'\n" +
-            "    },\n" +
-            "    /*Argument 2\n" +
-            "     */\n" +
-            "    {\n" +
-            "        'Value2': '2'\n" +
-            "    });");
-        bt( "test( /*Argument 1*/\n" +
-            "{\n" +
-            "    'Value1': '1'\n" +
-            "}, /*Argument 2\n" +
-            " */\n" +
-            "{\n" +
-            "    'Value2': '2'\n" +
-            "});",
-            // expected
-            "test( /*Argument 1*/ {\n" +
-            "        'Value1': '1'\n" +
-            "    },\n" +
-            "    /*Argument 2\n" +
-            "     */\n" +
-            "    {\n" +
-            "        'Value2': '2'\n" +
-            "    });");
-
-        opts.brace_style = "end-expand";
-
-        bt('//case 1\nif (a == 1) {}\n//case 2\nelse if (a == 2) {}');
-        bt('if(1){2}else{3}', "if (1) {\n    2\n}\nelse {\n    3\n}");
-        bt('try{a();}catch(b){c();}catch(d){}finally{e();}',
-            "try {\n    a();\n}\ncatch (b) {\n    c();\n}\ncatch (d) {}\nfinally {\n    e();\n}");
-        bt('if(a){b();}else if(c) foo();',
-            "if (a) {\n    b();\n}\nelse if (c) foo();");
-        bt("if (a) {\n// comment\n}else{\n// comment\n}",
-            "if (a) {\n    // comment\n}\nelse {\n    // comment\n}"); // if/else statement with empty body
-        bt('if (x) {y} else { if (x) {y}}',
-            'if (x) {\n    y\n}\nelse {\n    if (x) {\n        y\n    }\n}');
-        bt('if (a)\n{\nb;\n}\nelse\n{\nc;\n}',
-            'if (a) {\n    b;\n}\nelse {\n    c;\n}');
-        test_fragment('    /*\n* xx\n*/\n// xx\nif (foo) {\n    bar();\n}',
-                      '    /*\n     * xx\n     */\n    // xx\n    if (foo) {\n        bar();\n    }');
-        bt('if (foo) {}\nelse /regex/.test();');
-        bt('if (foo) /regex/.test();');
-        bt('if (a)\n{\nb;\n}\nelse\n{\nc;\n}', 'if (a) {\n    b;\n}\nelse {\n    c;\n}');
-        test_fragment('if (foo) {', 'if (foo) {');
-        test_fragment('foo {', 'foo {');
-        test_fragment('return {', 'return {'); // return needs the brace.
-        test_fragment('return /* inline */ {', 'return /* inline */ {');
-        // test_fragment('return\n{', 'return\n{'); // can't support this?, but that's an improbable and extreme case anyway.
-        test_fragment('return;\n{', 'return; {');
-        bt("throw {}");
-        bt("throw {\n    foo;\n}");
-        bt('var foo = {}');
-        bt('if (foo) bar();\nelse break');
-        bt('function x() {\n    foo();\n}zzz', 'function x() {\n    foo();\n}\nzzz');
-        bt('a: do {} while (); xxx', 'a: do {} while ();\nxxx');
-        bt('var a = new function();');
-        bt('var a = new function() {};');
-        bt('var a = new function a() {};');
-        test_fragment('new function');
-        bt("foo({\n    'a': 1\n},\n10);",
-            "foo({\n        'a': 1\n    },\n    10);");
-        bt('(["foo","bar"]).each(function(i) {return i;});',
-            '(["foo", "bar"]).each(function(i) {\n    return i;\n});');
-        bt('(function(i) {return i;})();',
-            '(function(i) {\n    return i;\n})();');
-        bt( "test( /*Argument 1*/ {\n" +
-            "    'Value1': '1'\n" +
-            "}, /*Argument 2\n" +
-            " */ {\n" +
-            "    'Value2': '2'\n" +
-            "});",
-            // expected
-            "test( /*Argument 1*/ {\n" +
-            "        'Value1': '1'\n" +
-            "    },\n" +
-            "    /*Argument 2\n" +
-            "     */\n" +
-            "    {\n" +
-            "        'Value2': '2'\n" +
-            "    });");
-        bt( "test(\n" +
-            "/*Argument 1*/ {\n" +
-            "    'Value1': '1'\n" +
-            "},\n" +
-            "/*Argument 2\n" +
-            " */ {\n" +
-            "    'Value2': '2'\n" +
-            "});",
-            // expected
-            "test(\n" +
-            "    /*Argument 1*/\n" +
-            "    {\n" +
-            "        'Value1': '1'\n" +
-            "    },\n" +
-            "    /*Argument 2\n" +
-            "     */\n" +
-            "    {\n" +
-            "        'Value2': '2'\n" +
-            "    });");
-        bt( "test( /*Argument 1*/\n" +
-            "{\n" +
-            "    'Value1': '1'\n" +
-            "}, /*Argument 2\n" +
-            " */\n" +
-            "{\n" +
-            "    'Value2': '2'\n" +
-            "});",
-            // expected
-            "test( /*Argument 1*/ {\n" +
-            "        'Value1': '1'\n" +
-            "    },\n" +
-            "    /*Argument 2\n" +
-            "     */\n" +
-            "    {\n" +
-            "        'Value2': '2'\n" +
-            "    });");
-
-        opts.brace_style = 'collapse';
-
-
-        bt('a =  ;'); // not the most perfect thing in the world, but you're the weirdo beaufifying php mix-ins with javascript beautifier
-        bt('a = <%= external() %> ;');
-
-        bt('// func-comment\n\nfunction foo() {}\n\n// end-func-comment');
-
-        test_fragment('roo = {\n    /*\n    ****\n      FOO\n    ****\n    */\n    BAR: 0\n};');
-
-        bt('"foo""bar""baz"', '"foo"\n"bar"\n"baz"');
-        bt("'foo''bar''baz'", "'foo'\n'bar'\n'baz'");
-
-
-        test_fragment("if (zz) {\n    // ....\n}\n(function");
-
-        bt("{\n    get foo() {}\n}");
-        bt("{\n    var a = get\n    foo();\n}");
-        bt("{\n    set foo() {}\n}");
-        bt("{\n    var a = set\n    foo();\n}");
-        bt("var x = {\n    get function()\n}");
-        bt("var x = {\n    set function()\n}");
-        bt("var x = set\n\na() {}", "var x = set\n\n    a() {}");
-        bt("var x = set\n\nfunction() {}", "var x = set\n\n    function() {}");
-
-        bt('');
-        bt('