// ========================================================================== // Project: Greenhouse // ========================================================================== /*globals Greenhouse */ /*

JS Beautifier

Written by Einar Lielmanis, <einar@jsbeautifier.org>
    http://jsbeautifier.org/

Originally converted to javascript by Vital, <vital76@gmail.com>

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,
  indent_level (default 0)         — initial indentation level, you probably won't need this ever,

  space_after_anon_function (default false) — if true, then space is added between "function ()"
          (jslint is happy about this); if false, then the common "function()" output is used.
  braces_on_own_line (default false) - ANSI / Allman brace style, each opening/closing brace gets its own line.

  e.g

  js_beautify(js_source_text, {indent_size: 1, indent_char: '\t'});

  Copyright (c) 2009 Einar Lielmanis

  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.

*/ 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;

// Some interpreters have unexpected results with foo = baz || bar;
options = options ? options : {};
var opt_braces_on_own_line = options.braces_on_own_line ? options.braces_on_own_line : false;
var opt_indent_size = options.indent_size ? options.indent_size : 2;
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_indent_level = options.indent_level ? options.indent_level : 0; // starting indentation
var opt_space_after_anon_function = options.space_after_anon_function === 'undefined' ? false : options.space_after_anon_function;
var opt_keep_array_indentation = typeof options.keep_array_indentation === 'undefined' ? true : options.keep_array_indentation;

just_added_newline = false;

// cache the source's length.
var input_length = js_source_text.length;

function trim_output() {
    while (output.length && (output[output.length - 1] === ' ' || output[output.length - 1] === indent_string)) {
        output.pop();
    }
}

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");
    }
    for (var i = 0; i < flags.indentation_level; i += 1) {
        output.push(indent_string);
    }
}

function print_single_space() {
    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 = {
        mode: mode,
        var_line: false,
        var_line_tainted: false,
        var_line_reindented: false,
        in_html_comment: false,
        if_line: false,
        in_case: false,
        eat_next_space: false,
        indentation_baseline: -1,
        indentation_level: (flags ? flags.indentation_level + (flags.var_line_reindented ? 1 : 0) : opt_indent_level)
    };
}

function is_expression(mode) {
    return mode === '[EXPRESSION]' || mode === '[INDENTED-EXPRESSION]' || mode === '(EXPRESSION)';
}

function is_array(mode) {
    return mode === '[EXPRESSION]' || mode === '[INDENTED-EXPRESSION]';
}

function restore_mode() {
    do_block_just_closed = flags.mode === 'DO_BLOCK';
    if (flag_store.length > 0) {
        flags = flag_store.pop();
    }
}

function in_array(what, arr) {
    for (var i = 0; i < arr.length; i += 1) {
        if (arr[i] === what) {
            return true;
        }
    }
    return false;
}

// Walk backwards from the colon to find a '?' (colon is part of a ternary op)
// or a '{' (colon is part of a class literal).  Along the way, keep track of
// the blocks and expressions we pass so we only trigger on those chars in our
// own level, and keep track of the colons so we only trigger on the matching '?'.

function is_ternary_op() {
    var level = 0,
        colon_count = 0;
    for (var i = output.length - 1; i >= 0; i--) {
        switch (output[i]) {
        case ':':
            if (level === 0) {
                colon_count++;
            }
            break;
        case '?':
            if (level === 0) {
                if (colon_count === 0) {
                    return true;
                } else {
                    colon_count--;
                }
            }
            break;
        case '{':
            if (level === 0) {
                return false;
            }
            level--;
            break;
        case '(':
        case '[':
            level--;
            break;
        case ')':
        case ']':
        case '}':
            level++;
            break;
        }
    }
}

function get_next_token() {
    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 {
                    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 (var i = 0; i < flags.indentation_level + 1; i += 1) {
                output.push(indent_string);
            }
            if (flags.indentation_baseline !== -1) {
                for (var i = 0; i < whitespace_count - flags.indentation_baseline; i++) {
                    output.push(' ');
                }
            }
        }

    } else {
        while (in_array(c, whitespace)) {

            if (c === "\n") {
                n_newlines += 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 (var 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(parser_pos);
            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' && !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 (! (input.charAt(parser_pos) === '*' && input.charAt(parser_pos + 1) && input.charAt(parser_pos + 1) === '/') && parser_pos < input_length) {
                    c = input.charAt(parser_pos);
                    comment += c;
                    if (c === '\x0d' || c === '\x0a') {
                        inline_comment = false;
                    }
                    parser_pos += 1;
                    if (parser_pos >= input_length) {
                        break;
                    }
                }
            }
            parser_pos += 2;
            if (inline_comment) {
                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) !== "\x0d" && input.charAt(parser_pos) !== "\x0a") {
                comment += input.charAt(parser_pos);
                parser_pos += 1;
                if (parser_pos >= input_length) {
                    break;
                }
            }
            parser_pos += 1;
            if (wanted_newline) {
                print_newline();
            }
            return [comment, 'TK_COMMENT'];
        }

    }

    if (c === "'" || // string
    c === '"' || // string
    (c === '/' && ((last_type === 'TK_WORD' && in_array(last_text, ['return', 'do'])) || (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 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 (!esc) {
                        esc = input.charAt(parser_pos) === '\\';
                    } 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'];
                    }
                }
            }

        }

        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 === '#') {
        // 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) === '<!--') {
        parser_pos += 3;
        flags.in_html_comment = true;
        return ['<!--', 'TK_COMMENT'];
    }

    if (c === '-' && flags.in_html_comment && input.substring(parser_pos - 1, parser_pos + 2) === '-->') {
        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_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;
}

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 = '+ - * / % & ++ -- = += -= *= /= %= == === != !== > < >= <= >> << >>> >>>= >>= <<= && &= | || ! !! , : ? ^ ^= |= ::'.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(parser_pos);
    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 {
            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') {
            // do nothing on (( and )( and ][ and ]( ..
        } else if (last_type !== 'TK_WORD' && last_type !== 'TK_OPERATOR') {
            print_single_space();
        } else if (last_word === 'function') {
            // function() vs function ()
            if (opt_space_after_anon_function) {
                print_single_space();
            }
        } else if (in_array(last_text, line_starters) || last_text === 'catch') {
            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_braces_on_own_line) {
            if (last_type !== 'TK_OPERATOR') {
                print_newline(true);
            }
            print_token();
            indent();
        } else {
            if (last_type !== 'TK_OPERATOR' && last_type !== 'TK_START_EXPR') {
                if (last_type === 'TK_START_BLOCK') {
                    print_newline();
                } else {
                    print_single_space();
                }
            }
            indent();
            print_token();
        }

        break;

    case 'TK_END_BLOCK':
        restore_mode();
        if (opt_braces_on_own_line) {
            print_newline();
            if (flags.var_line_reindented) {
                output.push(indent_string);
            }
            print_token();
        } else {
            if (last_type === 'TK_START_BLOCK') {
                // nothing
                if (just_added_newline) {
                    remove_indent();
                } else {
                    // {}
                    trim_output();
                }
            } else {
                print_newline();
                if (flags.var_line_reindented) {
                    output.push(indent_string);
                }
            }
            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;
        }

        if (token_text === 'function') {
            if ((just_added_newline || last_text == ';') && last_text !== '{') {
                // 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;

                for (var i = 0; i < 2 - n_newlines; i++) {
                    print_newline(false);
                }

            }
        }
        if (token_text === 'case' || token_text === 'default') {
            if (last_text === ':') {
                // switch cases following one another
                remove_indent();
            } else {
                // case statement starts in the same line where switch
                flags.indentation_level--;
                print_newline();
                flags.indentation_level++;
            }
            print_token();
            flags.in_case = true;
            break;
        }

        prefix = 'NONE';

        if (last_type === 'TK_END_BLOCK') {
            if (!in_array(token_text.toLowerCase(), ['else', 'catch', 'finally'])) {
                prefix = 'NEWLINE';
            } else {
                if (opt_braces_on_own_line) {
                    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') {
            prefix = 'SPACE';
        } else if (last_type === 'TK_START_BLOCK') {
            prefix = 'NEWLINE';
        } else if (last_type === 'TK_END_EXPR') {
            print_single_space();
            prefix = 'NEWLINE';
        }

        if (last_type !== 'TK_END_BLOCK' && in_array(token_text.toLowerCase(), ['else', 'catch', 'finally'])) {
            print_newline();
        } else if (in_array(token_text, line_starters) || prefix === 'NEWLINE') {
            if (last_text === 'else') {
                // no need to force newline on else break
                print_single_space();
            } else if ((last_type === 'TK_START_EXPR' || last_text === '=' || last_text === ',') && token_text === 'function') {
                // no need to force newline on 'function': (function
                // DONOTHING
            } else if (last_text === 'return' || last_text === 'throw') {
                // 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 {
                        print_newline();
                    }
                }
            } else {
                if (in_array(token_text, line_starters) && last_text !== ')') {
                    print_newline();
                }
            }
        } else if (prefix === 'SPACE') {
            print_single_space();
        }
        print_token();
        last_word = token_text;

        if (token_text === 'var') {
            flags.var_line = true;
            flags.var_line_tainted = false;
        }

        if (token_text === 'if' || token_text === 'else') {
            flags.if_line = true;
        }

        break;

    case 'TK_SEMICOLON':

        print_token();
        flags.var_line = false;
        break;

    case 'TK_STRING':

        if (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_OPERATOR':

        var space_before = true;
        var space_after = true;

        if (flags.var_line && token_text === ',' && (is_expression(flags.mode))) {
            // do not break on comma, for(var a = 1, b = 2)
            flags.var_line_tainted = false;
        }

        if (flags.var_line) {
            if (token_text === ',') {
                if (flags.var_line_tainted) {
                    print_token();
                    print_newline();
                    output.push(indent_string);
                    flags.var_line_reindented = true;
                    flags.var_line_tainted = false;
                    break;
                } else {
                    flags.var_line_tainted = false;
                }
            // } else if (token_text === ':') {
                // hmm, when does this happen? tests don't catch this
                // flags.var_line = false;
            }
        }

        if (last_text === 'return' || last_text === 'throw') {
            // "return" had a special handling in TK_WORD. Now we need to return the favor
            print_single_space();
            print_token();
            break;
        }

        if (token_text === ':' && flags.in_case) {
            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 (token_text === ',') {
            if (flags.var_line) {
                if (flags.var_line_tainted) {
                    print_token();
                    print_newline();
                    flags.var_line_tainted = false;
                } else {
                    print_token();
                    print_single_space();
                }
            } else if (last_type === 'TK_END_BLOCK' && flags.mode !== "(EXPRESSION)") {
                print_token();
                print_newline();
            } else {
                if (flags.mode === 'BLOCK') {
                    print_token();
                    print_newline();
                } else {
                    // EXPR or DO_BLOCK
                    print_token();
                    print_single_space();
                }
            }
            break;
        // } else if (in_array(token_text, ['--', '++', '!']) || (in_array(token_text, ['-', '+']) && (in_array(last_type, ['TK_START_BLOCK', 'TK_START_EXPR', 'TK_EQUALS']) || in_array(last_text, line_starters) || in_array(last_text, ['==', '!=', '+=', '-=', '*=', '/=', '+', '-'])))) { 
        } else 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 ( ! is_ternary_op()) {
                space_before = false;
            }
        }
        if (space_before) {
            print_single_space();
        }

        print_token();

        if (space_after) {
            print_single_space();
        }

        if (token_text === '!') {
            // flags.eat_next_space = true;
        }

        break;

    case 'TK_BLOCK_COMMENT':

        var lines = token_text.split(/\x0a|\x0d\x0a/);

        print_newline();
        output.push(lines[0]);
        for (var i = 1, l = lines.length; i < l; i++) {
            print_newline();
            output.push(' ');
            output.push(lines[i].replace(/^\s\s*|\s\s*$/, ''));
        }

        print_newline();
        break;

    case 'TK_INLINE_COMMENT':

        print_single_space();
        print_token();
        if (is_expression(flags.mode)) {
            print_single_space();
        } else {
            print_newline();
        }
        break;

    case 'TK_COMMENT':

        // print_newline();
        if (wanted_newline) {
            print_newline();
        } else {
            print_single_space();
        }
        print_token();
        print_newline();
        break;

    case 'TK_UNKNOWN':
        print_token();
        break;
    }

    last_last_text = last_text;
    last_type = token_type;
    last_text = token_text;
}

return output.join('').replace(/[\n ]+$/, '');

}