koa-classic-server 1.0.0 → 1.0.2

package/test/node_modules/js-beautify/js/src/javascript/beautifier.js

@@ -1,1472 +0,0 @@
-/*jshint node:true */
-/*
-
-  The MIT License (MIT)
-
-  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, 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.
-*/
-
-'use strict';
-
-var Output = require('../core/output').Output;
-var Token = require('../core/token').Token;
-var acorn = require('./acorn');
-var Options = require('./options').Options;
-var Tokenizer = require('./tokenizer').Tokenizer;
-var line_starters = require('./tokenizer').line_starters;
-var positionable_operators = require('./tokenizer').positionable_operators;
-var TOKEN = require('./tokenizer').TOKEN;
-
-
-function in_array(what, arr) {
-  return arr.indexOf(what) !== -1;
-}
-
-function ltrim(s) {
-  return s.replace(/^\s+/g, '');
-}
-
-function generateMapFromStrings(list) {
-  var result = {};
-  for (var x = 0; x < list.length; x++) {
-    // make the mapped names underscored instead of dash
-    result[list[x].replace(/-/g, '_')] = list[x];
-  }
-  return result;
-}
-
-function reserved_word(token, word) {
-  return token && token.type === TOKEN.RESERVED && token.text === word;
-}
-
-function reserved_array(token, words) {
-  return token && token.type === TOKEN.RESERVED && in_array(token.text, words);
-}
-// Unsure of what they mean, but they work. Worth cleaning up in future.
-var special_words = ['case', 'return', 'do', 'if', 'throw', 'else', 'await', 'break', 'continue', 'async'];
-
-var validPositionValues = ['before-newline', 'after-newline', 'preserve-newline'];
-
-// Generate map from array
-var OPERATOR_POSITION = generateMapFromStrings(validPositionValues);
-
-var OPERATOR_POSITION_BEFORE_OR_PRESERVE = [OPERATOR_POSITION.before_newline, OPERATOR_POSITION.preserve_newline];
-
-var MODE = {
-  BlockStatement: 'BlockStatement', // 'BLOCK'
-  Statement: 'Statement', // 'STATEMENT'
-  ObjectLiteral: 'ObjectLiteral', // 'OBJECT',
-  ArrayLiteral: 'ArrayLiteral', //'[EXPRESSION]',
-  ForInitializer: 'ForInitializer', //'(FOR-EXPRESSION)',
-  Conditional: 'Conditional', //'(COND-EXPRESSION)',
-  Expression: 'Expression' //'(EXPRESSION)'
-};
-
-function remove_redundant_indentation(output, frame) {
-  // This implementation is effective but has some issues:
-  //     - 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 ||
-    frame.mode === MODE.ForInitializer ||
-    frame.mode === MODE.Conditional) {
-    return;
-  }
-
-  // remove one indent from each line inside this section
-  output.remove_indent(frame.start_line_index);
-}
-
-// we could use just string.split, but
-// IE doesn't like returning empty strings
-function split_linebreaks(s) {
-  //return s.split(/\x0d\x0a|\x0a/);
-
-  s = s.replace(acorn.allLineBreaks, '\n');
-  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 is_array(mode) {
-  return mode === MODE.ArrayLiteral;
-}
-
-function is_expression(mode) {
-  return in_array(mode, [MODE.Expression, MODE.ForInitializer, MODE.Conditional]);
-}
-
-function all_lines_start_with(lines, c) {
-  for (var i = 0; i < lines.length; i++) {
-    var line = lines[i].trim();
-    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 Beautifier(source_text, options) {
-  options = options || {};
-  this._source_text = source_text || '';
-
-  this._output = null;
-  this._tokens = null;
-  this._last_last_text = null;
-  this._flags = null;
-  this._previous_flags = null;
-
-  this._flag_store = null;
-  this._options = new Options(options);
-}
-
-Beautifier.prototype.create_flags = function(flags_base, mode) {
-  var next_indent_level = 0;
-  if (flags_base) {
-    next_indent_level = flags_base.indentation_level;
-    if (!this._output.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_token: flags_base ? flags_base.last_token : new Token(TOKEN.START_BLOCK, ''), // last token text
-    last_word: flags_base ? flags_base.last_word : '', // last TOKEN.WORD passed
-    declaration_statement: false,
-    declaration_assignment: false,
-    multiline_frame: false,
-    inline_frame: false,
-    if_block: false,
-    else_block: false,
-    class_start_block: false, // class A { INSIDE HERE } or class B extends C { INSIDE HERE }
-    do_block: false,
-    do_while: false,
-    import_block: 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
-    case_block: false, // the indented case-action block is wrapped with {}
-    indentation_level: next_indent_level,
-    alignment: 0,
-    line_indent_level: flags_base ? flags_base.line_indent_level : next_indent_level,
-    start_line_index: this._output.get_line_number(),
-    ternary_depth: 0
-  };
-  return next_flags;
-};
-
-Beautifier.prototype._reset = function(source_text) {
-  var baseIndentString = source_text.match(/^[\t ]*/)[0];
-
-  this._last_last_text = ''; // pre-last token text
-  this._output = new Output(this._options, baseIndentString);
-
-  // If testing the ignore directive, start with output disable set to true
-  this._output.raw = this._options.test_output_raw;
-
-
-  // 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.
-  this._flag_store = [];
-  this.set_mode(MODE.BlockStatement);
-  var tokenizer = new Tokenizer(source_text, this._options);
-  this._tokens = tokenizer.tokenize();
-  return source_text;
-};
-
-Beautifier.prototype.beautify = function() {
-  // if disabled, return the input unchanged.
-  if (this._options.disabled) {
-    return this._source_text;
-  }
-
-  var sweet_code;
-  var source_text = this._reset(this._source_text);
-
-  var eol = this._options.eol;
-  if (this._options.eol === 'auto') {
-    eol = '\n';
-    if (source_text && acorn.lineBreak.test(source_text || '')) {
-      eol = source_text.match(acorn.lineBreak)[0];
-    }
-  }
-
-  var current_token = this._tokens.next();
-  while (current_token) {
-    this.handle_token(current_token);
-
-    this._last_last_text = this._flags.last_token.text;
-    this._flags.last_token = current_token;
-
-    current_token = this._tokens.next();
-  }
-
-  sweet_code = this._output.get_code(eol);
-
-  return sweet_code;
-};
-
-Beautifier.prototype.handle_token = function(current_token, preserve_statement_flags) {
-  if (current_token.type === TOKEN.START_EXPR) {
-    this.handle_start_expr(current_token);
-  } else if (current_token.type === TOKEN.END_EXPR) {
-    this.handle_end_expr(current_token);
-  } else if (current_token.type === TOKEN.START_BLOCK) {
-    this.handle_start_block(current_token);
-  } else if (current_token.type === TOKEN.END_BLOCK) {
-    this.handle_end_block(current_token);
-  } else if (current_token.type === TOKEN.WORD) {
-    this.handle_word(current_token);
-  } else if (current_token.type === TOKEN.RESERVED) {
-    this.handle_word(current_token);
-  } else if (current_token.type === TOKEN.SEMICOLON) {
-    this.handle_semicolon(current_token);
-  } else if (current_token.type === TOKEN.STRING) {
-    this.handle_string(current_token);
-  } else if (current_token.type === TOKEN.EQUALS) {
-    this.handle_equals(current_token);
-  } else if (current_token.type === TOKEN.OPERATOR) {
-    this.handle_operator(current_token);
-  } else if (current_token.type === TOKEN.COMMA) {
-    this.handle_comma(current_token);
-  } else if (current_token.type === TOKEN.BLOCK_COMMENT) {
-    this.handle_block_comment(current_token, preserve_statement_flags);
-  } else if (current_token.type === TOKEN.COMMENT) {
-    this.handle_comment(current_token, preserve_statement_flags);
-  } else if (current_token.type === TOKEN.DOT) {
-    this.handle_dot(current_token);
-  } else if (current_token.type === TOKEN.EOF) {
-    this.handle_eof(current_token);
-  } else if (current_token.type === TOKEN.UNKNOWN) {
-    this.handle_unknown(current_token, preserve_statement_flags);
-  } else {
-    this.handle_unknown(current_token, preserve_statement_flags);
-  }
-};
-
-Beautifier.prototype.handle_whitespace_and_comments = function(current_token, preserve_statement_flags) {
-  var newlines = current_token.newlines;
-  var keep_whitespace = this._options.keep_array_indentation && is_array(this._flags.mode);
-
-  if (current_token.comments_before) {
-    var comment_token = current_token.comments_before.next();
-    while (comment_token) {
-      // 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.
-      this.handle_whitespace_and_comments(comment_token, preserve_statement_flags);
-      this.handle_token(comment_token, preserve_statement_flags);
-      comment_token = current_token.comments_before.next();
-    }
-  }
-
-  if (keep_whitespace) {
-    for (var i = 0; i < newlines; i += 1) {
-      this.print_newline(i > 0, preserve_statement_flags);
-    }
-  } else {
-    if (this._options.max_preserve_newlines && newlines > this._options.max_preserve_newlines) {
-      newlines = this._options.max_preserve_newlines;
-    }
-
-    if (this._options.preserve_newlines) {
-      if (newlines > 1) {
-        this.print_newline(false, preserve_statement_flags);
-        for (var j = 1; j < newlines; j += 1) {
-          this.print_newline(true, preserve_statement_flags);
-        }
-      }
-    }
-  }
-
-};
-
-var newline_restricted_tokens = ['async', 'break', 'continue', 'return', 'throw', 'yield'];
-
-Beautifier.prototype.allow_wrap_or_preserved_newline = function(current_token, force_linewrap) {
-  force_linewrap = (force_linewrap === undefined) ? false : force_linewrap;
-
-  // Never wrap the first token on a line
-  if (this._output.just_added_newline()) {
-    return;
-  }
-
-  var shouldPreserveOrForce = (this._options.preserve_newlines && current_token.newlines) || force_linewrap;
-  var operatorLogicApplies = in_array(this._flags.last_token.text, positionable_operators) ||
-    in_array(current_token.text, positionable_operators);
-
-  if (operatorLogicApplies) {
-    var shouldPrintOperatorNewline = (
-        in_array(this._flags.last_token.text, positionable_operators) &&
-        in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)
-      ) ||
-      in_array(current_token.text, positionable_operators);
-    shouldPreserveOrForce = shouldPreserveOrForce && shouldPrintOperatorNewline;
-  }
-
-  if (shouldPreserveOrForce) {
-    this.print_newline(false, true);
-  } else if (this._options.wrap_line_length) {
-    if (reserved_array(this._flags.last_token, newline_restricted_tokens)) {
-      // These tokens should never have a newline inserted
-      // between them and the following expression.
-      return;
-    }
-    this._output.set_wrap_point();
-  }
-};
-
-Beautifier.prototype.print_newline = function(force_newline, preserve_statement_flags) {
-  if (!preserve_statement_flags) {
-    if (this._flags.last_token.text !== ';' && this._flags.last_token.text !== ',' && this._flags.last_token.text !== '=' && (this._flags.last_token.type !== TOKEN.OPERATOR || this._flags.last_token.text === '--' || this._flags.last_token.text === '++')) {
-      var next_token = this._tokens.peek();
-      while (this._flags.mode === MODE.Statement &&
-        !(this._flags.if_block && reserved_word(next_token, 'else')) &&
-        !this._flags.do_block) {
-        this.restore_mode();
-      }
-    }
-  }
-
-  if (this._output.add_new_line(force_newline)) {
-    this._flags.multiline_frame = true;
-  }
-};
-
-Beautifier.prototype.print_token_line_indentation = function(current_token) {
-  if (this._output.just_added_newline()) {
-    if (this._options.keep_array_indentation &&
-      current_token.newlines &&
-      (current_token.text === '[' || is_array(this._flags.mode))) {
-      this._output.current_line.set_indent(-1);
-      this._output.current_line.push(current_token.whitespace_before);
-      this._output.space_before_token = false;
-    } else if (this._output.set_indent(this._flags.indentation_level, this._flags.alignment)) {
-      this._flags.line_indent_level = this._flags.indentation_level;
-    }
-  }
-};
-
-Beautifier.prototype.print_token = function(current_token) {
-  if (this._output.raw) {
-    this._output.add_raw_token(current_token);
-    return;
-  }
-
-  if (this._options.comma_first && current_token.previous && current_token.previous.type === TOKEN.COMMA &&
-    this._output.just_added_newline()) {
-    if (this._output.previous_line.last() === ',') {
-      var popped = this._output.previous_line.pop();
-      // if the comma was already at the start of the line,
-      // pull back onto that line and reprint the indentation
-      if (this._output.previous_line.is_empty()) {
-        this._output.previous_line.push(popped);
-        this._output.trim(true);
-        this._output.current_line.pop();
-        this._output.trim();
-      }
-
-      // add the comma in front of the next token
-      this.print_token_line_indentation(current_token);
-      this._output.add_token(',');
-      this._output.space_before_token = true;
-    }
-  }
-
-  this.print_token_line_indentation(current_token);
-  this._output.non_breaking_space = true;
-  this._output.add_token(current_token.text);
-  if (this._output.previous_token_wrapped) {
-    this._flags.multiline_frame = true;
-  }
-};
-
-Beautifier.prototype.indent = function() {
-  this._flags.indentation_level += 1;
-  this._output.set_indent(this._flags.indentation_level, this._flags.alignment);
-};
-
-Beautifier.prototype.deindent = function() {
-  if (this._flags.indentation_level > 0 &&
-    ((!this._flags.parent) || this._flags.indentation_level > this._flags.parent.indentation_level)) {
-    this._flags.indentation_level -= 1;
-    this._output.set_indent(this._flags.indentation_level, this._flags.alignment);
-  }
-};
-
-Beautifier.prototype.set_mode = function(mode) {
-  if (this._flags) {
-    this._flag_store.push(this._flags);
-    this._previous_flags = this._flags;
-  } else {
-    this._previous_flags = this.create_flags(null, mode);
-  }
-
-  this._flags = this.create_flags(this._previous_flags, mode);
-  this._output.set_indent(this._flags.indentation_level, this._flags.alignment);
-};
-
-
-Beautifier.prototype.restore_mode = function() {
-  if (this._flag_store.length > 0) {
-    this._previous_flags = this._flags;
-    this._flags = this._flag_store.pop();
-    if (this._previous_flags.mode === MODE.Statement) {
-      remove_redundant_indentation(this._output, this._previous_flags);
-    }
-    this._output.set_indent(this._flags.indentation_level, this._flags.alignment);
-  }
-};
-
-Beautifier.prototype.start_of_object_property = function() {
-  return this._flags.parent.mode === MODE.ObjectLiteral && this._flags.mode === MODE.Statement && (
-    (this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) || (reserved_array(this._flags.last_token, ['get', 'set'])));
-};
-
-Beautifier.prototype.start_of_statement = function(current_token) {
-  var start = false;
-  start = start || reserved_array(this._flags.last_token, ['var', 'let', 'const']) && current_token.type === TOKEN.WORD;
-  start = start || reserved_word(this._flags.last_token, 'do');
-  start = start || (!(this._flags.parent.mode === MODE.ObjectLiteral && this._flags.mode === MODE.Statement)) && reserved_array(this._flags.last_token, newline_restricted_tokens) && !current_token.newlines;
-  start = start || reserved_word(this._flags.last_token, 'else') &&
-    !(reserved_word(current_token, 'if') && !current_token.comments_before);
-  start = start || (this._flags.last_token.type === TOKEN.END_EXPR && (this._previous_flags.mode === MODE.ForInitializer || this._previous_flags.mode === MODE.Conditional));
-  start = start || (this._flags.last_token.type === TOKEN.WORD && this._flags.mode === MODE.BlockStatement &&
-    !this._flags.in_case &&
-    !(current_token.text === '--' || current_token.text === '++') &&
-    this._last_last_text !== 'function' &&
-    current_token.type !== TOKEN.WORD && current_token.type !== TOKEN.RESERVED);
-  start = start || (this._flags.mode === MODE.ObjectLiteral && (
-    (this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) || reserved_array(this._flags.last_token, ['get', 'set'])));
-
-  if (start) {
-    this.set_mode(MODE.Statement);
-    this.indent();
-
-    this.handle_whitespace_and_comments(current_token, true);
-
-    // Issue #276:
-    // If starting a new statement with [if, for, while, do], push to a new line.
-    // if (a) if (b) if(c) d(); else e(); else f();
-    if (!this.start_of_object_property()) {
-      this.allow_wrap_or_preserved_newline(current_token,
-        reserved_array(current_token, ['do', 'for', 'if', 'while']));
-    }
-    return true;
-  }
-  return false;
-};
-
-Beautifier.prototype.handle_start_expr = function(current_token) {
-  // The conditional starts the statement if appropriate.
-  if (!this.start_of_statement(current_token)) {
-    this.handle_whitespace_and_comments(current_token);
-  }
-
-  var next_mode = MODE.Expression;
-  if (current_token.text === '[') {
-
-    if (this._flags.last_token.type === TOKEN.WORD || this._flags.last_token.text === ')') {
-      // this is array index specifier, break immediately
-      // a[x], fn()[x]
-      if (reserved_array(this._flags.last_token, line_starters)) {
-        this._output.space_before_token = true;
-      }
-      this.print_token(current_token);
-      this.set_mode(next_mode);
-      this.indent();
-      if (this._options.space_in_paren) {
-        this._output.space_before_token = true;
-      }
-      return;
-    }
-
-    next_mode = MODE.ArrayLiteral;
-    if (is_array(this._flags.mode)) {
-      if (this._flags.last_token.text === '[' ||
-        (this._flags.last_token.text === ',' && (this._last_last_text === ']' || this._last_last_text === '}'))) {
-        // ], [ goes to new line
-        // }, [ goes to new line
-        if (!this._options.keep_array_indentation) {
-          this.print_newline();
-        }
-      }
-    }
-
-    if (!in_array(this._flags.last_token.type, [TOKEN.START_EXPR, TOKEN.END_EXPR, TOKEN.WORD, TOKEN.OPERATOR, TOKEN.DOT])) {
-      this._output.space_before_token = true;
-    }
-  } else {
-    if (this._flags.last_token.type === TOKEN.RESERVED) {
-      if (this._flags.last_token.text === 'for') {
-        this._output.space_before_token = this._options.space_before_conditional;
-        next_mode = MODE.ForInitializer;
-      } else if (in_array(this._flags.last_token.text, ['if', 'while', 'switch'])) {
-        this._output.space_before_token = this._options.space_before_conditional;
-        next_mode = MODE.Conditional;
-      } else if (in_array(this._flags.last_word, ['await', 'async'])) {
-        // Should be a space between await and an IIFE, or async and an arrow function
-        this._output.space_before_token = true;
-      } else if (this._flags.last_token.text === 'import' && current_token.whitespace_before === '') {
-        this._output.space_before_token = false;
-      } else if (in_array(this._flags.last_token.text, line_starters) || this._flags.last_token.text === 'catch') {
-        this._output.space_before_token = true;
-      }
-    } else if (this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) {
-      // Support of this kind of newline preservation.
-      // a = (b &&
-      //     (c || d));
-      if (!this.start_of_object_property()) {
-        this.allow_wrap_or_preserved_newline(current_token);
-      }
-    } else if (this._flags.last_token.type === TOKEN.WORD) {
-      this._output.space_before_token = false;
-
-      // function name() vs function name ()
-      // function* name() vs function* name ()
-      // async name() vs async name ()
-      // In ES6, you can also define the method properties of an object
-      // var obj = {a: function() {}}
-      // It can be abbreviated
-      // var obj = {a() {}}
-      // var obj = { a() {}} vs var obj = { a () {}}
-      // var obj = { * a() {}} vs var obj = { * a () {}}
-      var peek_back_two = this._tokens.peek(-3);
-      if (this._options.space_after_named_function && peek_back_two) {
-        // peek starts at next character so -1 is current token
-        var peek_back_three = this._tokens.peek(-4);
-        if (reserved_array(peek_back_two, ['async', 'function']) ||
-          (peek_back_two.text === '*' && reserved_array(peek_back_three, ['async', 'function']))) {
-          this._output.space_before_token = true;
-        } else if (this._flags.mode === MODE.ObjectLiteral) {
-          if ((peek_back_two.text === '{' || peek_back_two.text === ',') ||
-            (peek_back_two.text === '*' && (peek_back_three.text === '{' || peek_back_three.text === ','))) {
-            this._output.space_before_token = true;
-          }
-        } else if (this._flags.parent && this._flags.parent.class_start_block) {
-          this._output.space_before_token = true;
-        }
-      }
-    } else {
-      // Support preserving wrapped arrow function expressions
-      // a.b('c',
-      //     () => d.e
-      // )
-      this.allow_wrap_or_preserved_newline(current_token);
-    }
-
-    // function() vs function ()
-    // yield*() vs yield* ()
-    // function*() vs function* ()
-    if ((this._flags.last_token.type === TOKEN.RESERVED && (this._flags.last_word === 'function' || this._flags.last_word === 'typeof')) ||
-      (this._flags.last_token.text === '*' &&
-        (in_array(this._last_last_text, ['function', 'yield']) ||
-          (this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ',']))))) {
-      this._output.space_before_token = this._options.space_after_anon_function;
-    }
-  }
-
-  if (this._flags.last_token.text === ';' || this._flags.last_token.type === TOKEN.START_BLOCK) {
-    this.print_newline();
-  } else if (this._flags.last_token.type === TOKEN.END_EXPR || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.END_BLOCK || this._flags.last_token.text === '.' || this._flags.last_token.type === TOKEN.COMMA) {
-    // do nothing on (( and )( and ][ and ]( and .(
-    // TODO: Consider whether forcing this is required.  Review failing tests when removed.
-    this.allow_wrap_or_preserved_newline(current_token, current_token.newlines);
-  }
-
-  this.print_token(current_token);
-  this.set_mode(next_mode);
-  if (this._options.space_in_paren) {
-    this._output.space_before_token = true;
-  }
-
-  // In all cases, if we newline while inside an expression it should be indented.
-  this.indent();
-};
-
-Beautifier.prototype.handle_end_expr = function(current_token) {
-  // statements inside expressions are not valid syntax, but...
-  // statements must all be closed when their container closes
-  while (this._flags.mode === MODE.Statement) {
-    this.restore_mode();
-  }
-
-  this.handle_whitespace_and_comments(current_token);
-
-  if (this._flags.multiline_frame) {
-    this.allow_wrap_or_preserved_newline(current_token,
-      current_token.text === ']' && is_array(this._flags.mode) && !this._options.keep_array_indentation);
-  }
-
-  if (this._options.space_in_paren) {
-    if (this._flags.last_token.type === TOKEN.START_EXPR && !this._options.space_in_empty_paren) {
-      // () [] no inner space in empty parens like these, ever, ref #320
-      this._output.trim();
-      this._output.space_before_token = false;
-    } else {
-      this._output.space_before_token = true;
-    }
-  }
-  this.deindent();
-  this.print_token(current_token);
-  this.restore_mode();
-
-  remove_redundant_indentation(this._output, this._previous_flags);
-
-  // do {} while () // no statement required after
-  if (this._flags.do_while && this._previous_flags.mode === MODE.Conditional) {
-    this._previous_flags.mode = MODE.Expression;
-    this._flags.do_block = false;
-    this._flags.do_while = false;
-
-  }
-};
-
-Beautifier.prototype.handle_start_block = function(current_token) {
-  this.handle_whitespace_and_comments(current_token);
-
-  // Check if this is should be treated as a ObjectLiteral
-  var next_token = this._tokens.peek();
-  var second_token = this._tokens.peek(1);
-  if (this._flags.last_word === 'switch' && this._flags.last_token.type === TOKEN.END_EXPR) {
-    this.set_mode(MODE.BlockStatement);
-    this._flags.in_case_statement = true;
-  } else if (this._flags.case_body) {
-    this.set_mode(MODE.BlockStatement);
-  } else if (second_token && (
-      (in_array(second_token.text, [':', ',']) && in_array(next_token.type, [TOKEN.STRING, TOKEN.WORD, TOKEN.RESERVED])) ||
-      (in_array(next_token.text, ['get', 'set', '...']) && in_array(second_token.type, [TOKEN.WORD, TOKEN.RESERVED]))
-    )) {
-    // We don't support TypeScript,but we didn't break it for a very long time.
-    // We'll try to keep not breaking it.
-    if (in_array(this._last_last_text, ['class', 'interface']) && !in_array(second_token.text, [':', ','])) {
-      this.set_mode(MODE.BlockStatement);
-    } else {
-      this.set_mode(MODE.ObjectLiteral);
-    }
-  } else if (this._flags.last_token.type === TOKEN.OPERATOR && this._flags.last_token.text === '=>') {
-    // arrow function: (param1, paramN) => { statements }
-    this.set_mode(MODE.BlockStatement);
-  } else if (in_array(this._flags.last_token.type, [TOKEN.EQUALS, TOKEN.START_EXPR, TOKEN.COMMA, TOKEN.OPERATOR]) ||
-    reserved_array(this._flags.last_token, ['return', 'throw', 'import', 'default'])
-  ) {
-    // Detecting shorthand function syntax is difficult by scanning forward,
-    //     so check the surrounding context.
-    // If the block is being returned, imported, export default, passed as arg,
-    //     assigned with = or assigned in a nested object, treat as an ObjectLiteral.
-    this.set_mode(MODE.ObjectLiteral);
-  } else {
-    this.set_mode(MODE.BlockStatement);
-  }
-
-  if (this._flags.last_token) {
-    if (reserved_array(this._flags.last_token.previous, ['class', 'extends'])) {
-      this._flags.class_start_block = true;
-    }
-  }
-
-  var empty_braces = !next_token.comments_before && next_token.text === '}';
-  var empty_anonymous_function = empty_braces && this._flags.last_word === 'function' &&
-    this._flags.last_token.type === TOKEN.END_EXPR;
-
-  if (this._options.brace_preserve_inline) // check for inline, set inline_frame if so
-  {
-    // search forward for a newline wanted inside this block
-    var index = 0;
-    var check_token = null;
-    this._flags.inline_frame = true;
-    do {
-      index += 1;
-      check_token = this._tokens.peek(index - 1);
-      if (check_token.newlines) {
-        this._flags.inline_frame = false;
-        break;
-      }
-    } while (check_token.type !== TOKEN.EOF &&
-      !(check_token.type === TOKEN.END_BLOCK && check_token.opened === current_token));
-  }
-
-  if ((this._options.brace_style === "expand" ||
-      (this._options.brace_style === "none" && current_token.newlines)) &&
-    !this._flags.inline_frame) {
-    if (this._flags.last_token.type !== TOKEN.OPERATOR &&
-      (empty_anonymous_function ||
-        this._flags.last_token.type === TOKEN.EQUALS ||
-        (reserved_array(this._flags.last_token, special_words) && this._flags.last_token.text !== 'else'))) {
-      this._output.space_before_token = true;
-    } else {
-      this.print_newline(false, true);
-    }
-  } else { // collapse || inline_frame
-    if (is_array(this._previous_flags.mode) && (this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.COMMA)) {
-      if (this._flags.last_token.type === TOKEN.COMMA || this._options.space_in_paren) {
-        this._output.space_before_token = true;
-      }
-
-      if (this._flags.last_token.type === TOKEN.COMMA || (this._flags.last_token.type === TOKEN.START_EXPR && this._flags.inline_frame)) {
-        this.allow_wrap_or_preserved_newline(current_token);
-        this._previous_flags.multiline_frame = this._previous_flags.multiline_frame || this._flags.multiline_frame;
-        this._flags.multiline_frame = false;
-      }
-    }
-    if (this._flags.last_token.type !== TOKEN.OPERATOR && this._flags.last_token.type !== TOKEN.START_EXPR) {
-      if (this._flags.last_token.type === TOKEN.START_BLOCK && !this._flags.inline_frame) {
-        this.print_newline();
-      } else {
-        this._output.space_before_token = true;
-      }
-    }
-  }
-  this.print_token(current_token);
-  this.indent();
-
-  // Except for specific cases, open braces are followed by a new line.
-  if (!empty_braces && !(this._options.brace_preserve_inline && this._flags.inline_frame)) {
-    this.print_newline();
-  }
-};
-
-Beautifier.prototype.handle_end_block = function(current_token) {
-  // statements must all be closed when their container closes
-  this.handle_whitespace_and_comments(current_token);
-
-  while (this._flags.mode === MODE.Statement) {
-    this.restore_mode();
-  }
-
-  var empty_braces = this._flags.last_token.type === TOKEN.START_BLOCK;
-
-  if (this._flags.inline_frame && !empty_braces) { // try inline_frame (only set if this._options.braces-preserve-inline) first
-    this._output.space_before_token = true;
-  } else if (this._options.brace_style === "expand") {
-    if (!empty_braces) {
-      this.print_newline();
-    }
-  } else {
-    // skip {}
-    if (!empty_braces) {
-      if (is_array(this._flags.mode) && this._options.keep_array_indentation) {
-        // we REALLY need a newline here, but newliner would skip that
-        this._options.keep_array_indentation = false;
-        this.print_newline();
-        this._options.keep_array_indentation = true;
-
-      } else {
-        this.print_newline();
-      }
-    }
-  }
-  this.restore_mode();
-  this.print_token(current_token);
-};
-
-Beautifier.prototype.handle_word = function(current_token) {
-  if (current_token.type === TOKEN.RESERVED) {
-    if (in_array(current_token.text, ['set', 'get']) && this._flags.mode !== MODE.ObjectLiteral) {
-      current_token.type = TOKEN.WORD;
-    } else if (current_token.text === 'import' && in_array(this._tokens.peek().text, ['(', '.'])) {
-      current_token.type = TOKEN.WORD;
-    } else if (in_array(current_token.text, ['as', 'from']) && !this._flags.import_block) {
-      current_token.type = TOKEN.WORD;
-    } else if (this._flags.mode === MODE.ObjectLiteral) {
-      var next_token = this._tokens.peek();
-      if (next_token.text === ':') {
-        current_token.type = TOKEN.WORD;
-      }
-    }
-  }
-
-  if (this.start_of_statement(current_token)) {
-    // The conditional starts the statement if appropriate.
-    if (reserved_array(this._flags.last_token, ['var', 'let', 'const']) && current_token.type === TOKEN.WORD) {
-      this._flags.declaration_statement = true;
-    }
-  } else if (current_token.newlines && !is_expression(this._flags.mode) &&
-    (this._flags.last_token.type !== TOKEN.OPERATOR || (this._flags.last_token.text === '--' || this._flags.last_token.text === '++')) &&
-    this._flags.last_token.type !== TOKEN.EQUALS &&
-    (this._options.preserve_newlines || !reserved_array(this._flags.last_token, ['var', 'let', 'const', 'set', 'get']))) {
-    this.handle_whitespace_and_comments(current_token);
-    this.print_newline();
-  } else {
-    this.handle_whitespace_and_comments(current_token);
-  }
-
-  if (this._flags.do_block && !this._flags.do_while) {
-    if (reserved_word(current_token, 'while')) {
-      // do {} ## while ()
-      this._output.space_before_token = true;
-      this.print_token(current_token);
-      this._output.space_before_token = true;
-      this._flags.do_while = true;
-      return;
-    } else {
-      // do {} should always have while as the next word.
-      // if we don't see the expected while, recover
-      this.print_newline();
-      this._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 (this._flags.if_block) {
-    if (!this._flags.else_block && reserved_word(current_token, 'else')) {
-      this._flags.else_block = true;
-    } else {
-      while (this._flags.mode === MODE.Statement) {
-        this.restore_mode();
-      }
-      this._flags.if_block = false;
-      this._flags.else_block = false;
-    }
-  }
-
-  if (this._flags.in_case_statement && reserved_array(current_token, ['case', 'default'])) {
-    this.print_newline();
-    if (!this._flags.case_block && (this._flags.case_body || this._options.jslint_happy)) {
-      // switch cases following one another
-      this.deindent();
-    }
-    this._flags.case_body = false;
-
-    this.print_token(current_token);
-    this._flags.in_case = true;
-    return;
-  }
-
-  if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) {
-    if (!this.start_of_object_property()) {
-      this.allow_wrap_or_preserved_newline(current_token);
-    }
-  }
-
-  if (reserved_word(current_token, 'function')) {
-    if (in_array(this._flags.last_token.text, ['}', ';']) ||
-      (this._output.just_added_newline() && !(in_array(this._flags.last_token.text, ['(', '[', '{', ':', '=', ',']) || this._flags.last_token.type === TOKEN.OPERATOR))) {
-      // make sure there is a nice clean space of at least one blank line
-      // before a new function definition
-      if (!this._output.just_added_blankline() && !current_token.comments_before) {
-        this.print_newline();
-        this.print_newline(true);
-      }
-    }
-    if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD) {
-      if (reserved_array(this._flags.last_token, ['get', 'set', 'new', 'export']) ||
-        reserved_array(this._flags.last_token, newline_restricted_tokens)) {
-        this._output.space_before_token = true;
-      } else if (reserved_word(this._flags.last_token, 'default') && this._last_last_text === 'export') {
-        this._output.space_before_token = true;
-      } else if (this._flags.last_token.text === 'declare') {
-        // accomodates Typescript declare function formatting
-        this._output.space_before_token = true;
-      } else {
-        this.print_newline();
-      }
-    } else if (this._flags.last_token.type === TOKEN.OPERATOR || this._flags.last_token.text === '=') {
-      // foo = function
-      this._output.space_before_token = true;
-    } else if (!this._flags.multiline_frame && (is_expression(this._flags.mode) || is_array(this._flags.mode))) {
-      // (function
-    } else {
-      this.print_newline();
-    }
-
-    this.print_token(current_token);
-    this._flags.last_word = current_token.text;
-    return;
-  }
-
-  var prefix = 'NONE';
-
-  if (this._flags.last_token.type === TOKEN.END_BLOCK) {
-
-    if (this._previous_flags.inline_frame) {
-      prefix = 'SPACE';
-    } else if (!reserved_array(current_token, ['else', 'catch', 'finally', 'from'])) {
-      prefix = 'NEWLINE';
-    } else {
-      if (this._options.brace_style === "expand" ||
-        this._options.brace_style === "end-expand" ||
-        (this._options.brace_style === "none" && current_token.newlines)) {
-        prefix = 'NEWLINE';
-      } else {
-        prefix = 'SPACE';
-        this._output.space_before_token = true;
-      }
-    }
-  } else if (this._flags.last_token.type === TOKEN.SEMICOLON && this._flags.mode === MODE.BlockStatement) {
-    // TODO: Should this be for STATEMENT as well?
-    prefix = 'NEWLINE';
-  } else if (this._flags.last_token.type === TOKEN.SEMICOLON && is_expression(this._flags.mode)) {
-    prefix = 'SPACE';
-  } else if (this._flags.last_token.type === TOKEN.STRING) {
-    prefix = 'NEWLINE';
-  } else if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD ||
-    (this._flags.last_token.text === '*' &&
-      (in_array(this._last_last_text, ['function', 'yield']) ||
-        (this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ',']))))) {
-    prefix = 'SPACE';
-  } else if (this._flags.last_token.type === TOKEN.START_BLOCK) {
-    if (this._flags.inline_frame) {
-      prefix = 'SPACE';
-    } else {
-      prefix = 'NEWLINE';
-    }
-  } else if (this._flags.last_token.type === TOKEN.END_EXPR) {
-    this._output.space_before_token = true;
-    prefix = 'NEWLINE';
-  }
-
-  if (reserved_array(current_token, line_starters) && this._flags.last_token.text !== ')') {
-    if (this._flags.inline_frame || this._flags.last_token.text === 'else' || this._flags.last_token.text === 'export') {
-      prefix = 'SPACE';
-    } else {
-      prefix = 'NEWLINE';
-    }
-
-  }
-
-  if (reserved_array(current_token, ['else', 'catch', 'finally'])) {
-    if ((!(this._flags.last_token.type === TOKEN.END_BLOCK && this._previous_flags.mode === MODE.BlockStatement) ||
-        this._options.brace_style === "expand" ||
-        this._options.brace_style === "end-expand" ||
-        (this._options.brace_style === "none" && current_token.newlines)) &&
-      !this._flags.inline_frame) {
-      this.print_newline();
-    } else {
-      this._output.trim(true);
-      var line = this._output.current_line;
-      // If we trimmed and there's something other than a close block before us
-      // put a newline back in.  Handles '} // comment' scenario.
-      if (line.last() !== '}') {
-        this.print_newline();
-      }
-      this._output.space_before_token = true;
-    }
-  } else if (prefix === 'NEWLINE') {
-    if (reserved_array(this._flags.last_token, special_words)) {
-      // no newline between 'return nnn'
-      this._output.space_before_token = true;
-    } else if (this._flags.last_token.text === 'declare' && reserved_array(current_token, ['var', 'let', 'const'])) {
-      // accomodates Typescript declare formatting
-      this._output.space_before_token = true;
-    } else if (this._flags.last_token.type !== TOKEN.END_EXPR) {
-      if ((this._flags.last_token.type !== TOKEN.START_EXPR || !reserved_array(current_token, ['var', 'let', 'const'])) && this._flags.last_token.text !== ':') {
-        // no need to force newline on 'var': for (var x = 0...)
-        if (reserved_word(current_token, 'if') && reserved_word(current_token.previous, 'else')) {
-          // no newline for } else if {
-          this._output.space_before_token = true;
-        } else {
-          this.print_newline();
-        }
-      }
-    } else if (reserved_array(current_token, line_starters) && this._flags.last_token.text !== ')') {
-      this.print_newline();
-    }
-  } else if (this._flags.multiline_frame && is_array(this._flags.mode) && this._flags.last_token.text === ',' && this._last_last_text === '}') {
-    this.print_newline(); // }, in lists get a newline treatment
-  } else if (prefix === 'SPACE') {
-    this._output.space_before_token = true;
-  }
-  if (current_token.previous && (current_token.previous.type === TOKEN.WORD || current_token.previous.type === TOKEN.RESERVED)) {
-    this._output.space_before_token = true;
-  }
-  this.print_token(current_token);
-  this._flags.last_word = current_token.text;
-
-  if (current_token.type === TOKEN.RESERVED) {
-    if (current_token.text === 'do') {
-      this._flags.do_block = true;
-    } else if (current_token.text === 'if') {
-      this._flags.if_block = true;
-    } else if (current_token.text === 'import') {
-      this._flags.import_block = true;
-    } else if (this._flags.import_block && reserved_word(current_token, 'from')) {
-      this._flags.import_block = false;
-    }
-  }
-};
-
-Beautifier.prototype.handle_semicolon = function(current_token) {
-  if (this.start_of_statement(current_token)) {
-    // The conditional starts the statement if appropriate.
-    // Semicolon can be the start (and end) of a statement
-    this._output.space_before_token = false;
-  } else {
-    this.handle_whitespace_and_comments(current_token);
-  }
-
-  var next_token = this._tokens.peek();
-  while (this._flags.mode === MODE.Statement &&
-    !(this._flags.if_block && reserved_word(next_token, 'else')) &&
-    !this._flags.do_block) {
-    this.restore_mode();
-  }
-
-  // hacky but effective for the moment
-  if (this._flags.import_block) {
-    this._flags.import_block = false;
-  }
-  this.print_token(current_token);
-};
-
-Beautifier.prototype.handle_string = function(current_token) {
-  if (current_token.text.startsWith("`") && current_token.newlines === 0 && current_token.whitespace_before === '' && (current_token.previous.text === ')' || this._flags.last_token.type === TOKEN.WORD)) {
-    //Conditional for detectign backtick strings
-  } else if (this.start_of_statement(current_token)) {
-    // The conditional starts the statement if appropriate.
-    // One difference - strings want at least a space before
-    this._output.space_before_token = true;
-  } else {
-    this.handle_whitespace_and_comments(current_token);
-    if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD || this._flags.inline_frame) {
-      this._output.space_before_token = true;
-    } else if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) {
-      if (!this.start_of_object_property()) {
-        this.allow_wrap_or_preserved_newline(current_token);
-      }
-    } else if ((current_token.text.startsWith("`") && this._flags.last_token.type === TOKEN.END_EXPR && (current_token.previous.text === ']' || current_token.previous.text === ')') && current_token.newlines === 0)) {
-      this._output.space_before_token = true;
-    } else {
-      this.print_newline();
-    }
-  }
-  this.print_token(current_token);
-};
-
-Beautifier.prototype.handle_equals = function(current_token) {
-  if (this.start_of_statement(current_token)) {
-    // The conditional starts the statement if appropriate.
-  } else {
-    this.handle_whitespace_and_comments(current_token);
-  }
-
-  if (this._flags.declaration_statement) {
-    // just got an '=' in a var-line, different formatting/line-breaking, etc will now be done
-    this._flags.declaration_assignment = true;
-  }
-  this._output.space_before_token = true;
-  this.print_token(current_token);
-  this._output.space_before_token = true;
-};
-
-Beautifier.prototype.handle_comma = function(current_token) {
-  this.handle_whitespace_and_comments(current_token, true);
-
-  this.print_token(current_token);
-  this._output.space_before_token = true;
-  if (this._flags.declaration_statement) {
-    if (is_expression(this._flags.parent.mode)) {
-      // do not break on comma, for(var a = 1, b = 2)
-      this._flags.declaration_assignment = false;
-    }
-
-    if (this._flags.declaration_assignment) {
-      this._flags.declaration_assignment = false;
-      this.print_newline(false, true);
-    } else if (this._options.comma_first) {
-      // for comma-first, we want to allow a newline before the comma
-      // to turn into a newline after the comma, which we will fixup later
-      this.allow_wrap_or_preserved_newline(current_token);
-    }
-  } else if (this._flags.mode === MODE.ObjectLiteral ||
-    (this._flags.mode === MODE.Statement && this._flags.parent.mode === MODE.ObjectLiteral)) {
-    if (this._flags.mode === MODE.Statement) {
-      this.restore_mode();
-    }
-
-    if (!this._flags.inline_frame) {
-      this.print_newline();
-    }
-  } else if (this._options.comma_first) {
-    // EXPR or DO_BLOCK
-    // for comma-first, we want to allow a newline before the comma
-    // to turn into a newline after the comma, which we will fixup later
-    this.allow_wrap_or_preserved_newline(current_token);
-  }
-};
-
-Beautifier.prototype.handle_operator = function(current_token) {
-  var isGeneratorAsterisk = current_token.text === '*' &&
-    (reserved_array(this._flags.last_token, ['function', 'yield']) ||
-      (in_array(this._flags.last_token.type, [TOKEN.START_BLOCK, TOKEN.COMMA, TOKEN.END_BLOCK, TOKEN.SEMICOLON]))
-    );
-  var isUnary = in_array(current_token.text, ['-', '+']) && (
-    in_array(this._flags.last_token.type, [TOKEN.START_BLOCK, TOKEN.START_EXPR, TOKEN.EQUALS, TOKEN.OPERATOR]) ||
-    in_array(this._flags.last_token.text, line_starters) ||
-    this._flags.last_token.text === ','
-  );
-
-  if (this.start_of_statement(current_token)) {
-    // The conditional starts the statement if appropriate.
-  } else {
-    var preserve_statement_flags = !isGeneratorAsterisk;
-    this.handle_whitespace_and_comments(current_token, preserve_statement_flags);
-  }
-
-  // hack for actionscript's import .*;
-  if (current_token.text === '*' && this._flags.last_token.type === TOKEN.DOT) {
-    this.print_token(current_token);
-    return;
-  }
-
-  if (current_token.text === '::') {
-    // no spaces around exotic namespacing syntax operator
-    this.print_token(current_token);
-    return;
-  }
-
-  // Allow line wrapping between operators when operator_position is
-  //   set to before or preserve
-  if (this._flags.last_token.type === TOKEN.OPERATOR && in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)) {
-    this.allow_wrap_or_preserved_newline(current_token);
-  }
-
-  if (current_token.text === ':' && this._flags.in_case) {
-    this.print_token(current_token);
-
-    this._flags.in_case = false;
-    this._flags.case_body = true;
-    if (this._tokens.peek().type !== TOKEN.START_BLOCK) {
-      this.indent();
-      this.print_newline();
-      this._flags.case_block = false;
-    } else {
-      this._flags.case_block = true;
-      this._output.space_before_token = true;
-    }
-    return;
-  }
-
-  var space_before = true;
-  var space_after = true;
-  var in_ternary = false;
-  if (current_token.text === ':') {
-    if (this._flags.ternary_depth === 0) {
-      // Colon is invalid javascript outside of ternary and object, but do our best to guess what was meant.
-      space_before = false;
-    } else {
-      this._flags.ternary_depth -= 1;
-      in_ternary = true;
-    }
-  } else if (current_token.text === '?') {
-    this._flags.ternary_depth += 1;
-  }
-
-  // let's handle the operator_position option prior to any conflicting logic
-  if (!isUnary && !isGeneratorAsterisk && this._options.preserve_newlines && in_array(current_token.text, positionable_operators)) {
-    var isColon = current_token.text === ':';
-    var isTernaryColon = (isColon && in_ternary);
-    var isOtherColon = (isColon && !in_ternary);
-
-    switch (this._options.operator_position) {
-      case OPERATOR_POSITION.before_newline:
-        // if the current token is : and it's not a ternary statement then we set space_before to false
-        this._output.space_before_token = !isOtherColon;
-
-        this.print_token(current_token);
-
-        if (!isColon || isTernaryColon) {
-          this.allow_wrap_or_preserved_newline(current_token);
-        }
-
-        this._output.space_before_token = true;
-        return;
-
-      case OPERATOR_POSITION.after_newline:
-        // if the current token is anything but colon, or (via deduction) it's a colon and in a ternary statement,
-        //   then print a newline.
-
-        this._output.space_before_token = true;
-
-        if (!isColon || isTernaryColon) {
-          if (this._tokens.peek().newlines) {
-            this.print_newline(false, true);
-          } else {
-            this.allow_wrap_or_preserved_newline(current_token);
-          }
-        } else {
-          this._output.space_before_token = false;
-        }
-
-        this.print_token(current_token);
-
-        this._output.space_before_token = true;
-        return;
-
-      case OPERATOR_POSITION.preserve_newline:
-        if (!isOtherColon) {
-          this.allow_wrap_or_preserved_newline(current_token);
-        }
-
-        // if we just added a newline, or the current token is : and it's not a ternary statement,
-        //   then we set space_before to false
-        space_before = !(this._output.just_added_newline() || isOtherColon);
-
-        this._output.space_before_token = space_before;
-        this.print_token(current_token);
-        this._output.space_before_token = true;
-        return;
-    }
-  }
-
-  if (isGeneratorAsterisk) {
-    this.allow_wrap_or_preserved_newline(current_token);
-    space_before = false;
-    var next_token = this._tokens.peek();
-    space_after = next_token && in_array(next_token.type, [TOKEN.WORD, TOKEN.RESERVED]);
-  } else if (current_token.text === '...') {
-    this.allow_wrap_or_preserved_newline(current_token);
-    space_before = this._flags.last_token.type === TOKEN.START_BLOCK;
-    space_after = false;
-  } else if (in_array(current_token.text, ['--', '++', '!', '~']) || isUnary) {
-    // unary operators (and binary +/- pretending to be unary) special cases
-    if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR) {
-      this.allow_wrap_or_preserved_newline(current_token);
-    }
-
-    space_before = false;
-    space_after = false;
-
-    // http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1
-    // if there is a newline between -- or ++ and anything else we should preserve it.
-    if (current_token.newlines && (current_token.text === '--' || current_token.text === '++' || current_token.text === '~')) {
-      var new_line_needed = reserved_array(this._flags.last_token, special_words) && current_token.newlines;
-      if (new_line_needed && (this._previous_flags.if_block || this._previous_flags.else_block)) {
-        this.restore_mode();
-      }
-      this.print_newline(new_line_needed, true);
-    }
-
-    if (this._flags.last_token.text === ';' && is_expression(this._flags.mode)) {
-      // for (;; ++i)
-      //        ^^^
-      space_before = true;
-    }
-
-    if (this._flags.last_token.type === TOKEN.RESERVED) {
-      space_before = true;
-    } else if (this._flags.last_token.type === TOKEN.END_EXPR) {
-      space_before = !(this._flags.last_token.text === ']' && (current_token.text === '--' || current_token.text === '++'));
-    } else if (this._flags.last_token.type === TOKEN.OPERATOR) {
-      // a++ + ++b;
-      // a - -b
-      space_before = in_array(current_token.text, ['--', '-', '++', '+']) && in_array(this._flags.last_token.text, ['--', '-', '++', '+']);
-      // + and - are not unary when preceeded by -- or ++ operator
-      // a-- + b
-      // a * +b
-      // a - -b
-      if (in_array(current_token.text, ['+', '-']) && in_array(this._flags.last_token.text, ['--', '++'])) {
-        space_after = true;
-      }
-    }
-
-
-    if (((this._flags.mode === MODE.BlockStatement && !this._flags.inline_frame) || this._flags.mode === MODE.Statement) &&
-      (this._flags.last_token.text === '{' || this._flags.last_token.text === ';')) {
-      // { foo; --i }
-      // foo(); --bar;
-      this.print_newline();
-    }
-  }
-
-  this._output.space_before_token = this._output.space_before_token || space_before;
-  this.print_token(current_token);
-  this._output.space_before_token = space_after;
-};
-
-Beautifier.prototype.handle_block_comment = function(current_token, preserve_statement_flags) {
-  if (this._output.raw) {
-    this._output.add_raw_token(current_token);
-    if (current_token.directives && current_token.directives.preserve === 'end') {
-      // If we're testing the raw output behavior, do not allow a directive to turn it off.
-      this._output.raw = this._options.test_output_raw;
-    }
-    return;
-  }
-
-  if (current_token.directives) {
-    this.print_newline(false, preserve_statement_flags);
-    this.print_token(current_token);
-    if (current_token.directives.preserve === 'start') {
-      this._output.raw = true;
-    }
-    this.print_newline(false, true);
-    return;
-  }
-
-  // inline block
-  if (!acorn.newline.test(current_token.text) && !current_token.newlines) {
-    this._output.space_before_token = true;
-    this.print_token(current_token);
-    this._output.space_before_token = true;
-    return;
-  } else {
-    this.print_block_commment(current_token, preserve_statement_flags);
-  }
-};
-
-Beautifier.prototype.print_block_commment = function(current_token, preserve_statement_flags) {
-  var lines = split_linebreaks(current_token.text);
-  var j; // iterator for this case
-  var javadoc = false;
-  var starless = false;
-  var lastIndent = current_token.whitespace_before;
-  var lastIndentLength = lastIndent.length;
-
-  // block comment starts with a new line
-  this.print_newline(false, preserve_statement_flags);
-
-  // first line always indented
-  this.print_token_line_indentation(current_token);
-  this._output.add_token(lines[0]);
-  this.print_newline(false, preserve_statement_flags);
-
-
-  if (lines.length > 1) {
-    lines = lines.slice(1);
-    javadoc = all_lines_start_with(lines, '*');
-    starless = each_line_matches_indent(lines, lastIndent);
-
-    if (javadoc) {
-      this._flags.alignment = 1;
-    }
-
-    for (j = 0; j < lines.length; j++) {
-      if (javadoc) {
-        // javadoc: reformat and re-indent
-        this.print_token_line_indentation(current_token);
-        this._output.add_token(ltrim(lines[j]));
-      } else if (starless && lines[j]) {
-        // starless: re-indent non-empty content, avoiding trim
-        this.print_token_line_indentation(current_token);
-        this._output.add_token(lines[j].substring(lastIndentLength));
-      } else {
-        // normal comments output raw
-        this._output.current_line.set_indent(-1);
-        this._output.add_token(lines[j]);
-      }
-
-      // for comments on their own line or  more than one line, make sure there's a new line after
-      this.print_newline(false, preserve_statement_flags);
-    }
-
-    this._flags.alignment = 0;
-  }
-};
-
-
-Beautifier.prototype.handle_comment = function(current_token, preserve_statement_flags) {
-  if (current_token.newlines) {
-    this.print_newline(false, preserve_statement_flags);
-  } else {
-    this._output.trim(true);
-  }
-
-  this._output.space_before_token = true;
-  this.print_token(current_token);
-  this.print_newline(false, preserve_statement_flags);
-};
-
-Beautifier.prototype.handle_dot = function(current_token) {
-  if (this.start_of_statement(current_token)) {
-    // The conditional starts the statement if appropriate.
-  } else {
-    this.handle_whitespace_and_comments(current_token, true);
-  }
-
-  if (this._flags.last_token.text.match('^[0-9]+$')) {
-    this._output.space_before_token = true;
-  }
-
-  if (reserved_array(this._flags.last_token, special_words)) {
-    this._output.space_before_token = false;
-  } else {
-    // allow preserved newlines before dots in general
-    // force newlines on dots after close paren when break_chained - for bar().baz()
-    this.allow_wrap_or_preserved_newline(current_token,
-      this._flags.last_token.text === ')' && this._options.break_chained_methods);
-  }
-
-  // Only unindent chained method dot if this dot starts a new line.
-  // Otherwise the automatic extra indentation removal will handle the over indent
-  if (this._options.unindent_chained_methods && this._output.just_added_newline()) {
-    this.deindent();
-  }
-
-  this.print_token(current_token);
-};
-
-Beautifier.prototype.handle_unknown = function(current_token, preserve_statement_flags) {
-  this.print_token(current_token);
-
-  if (current_token.text[current_token.text.length - 1] === '\n') {
-    this.print_newline(false, preserve_statement_flags);
-  }
-};
-
-Beautifier.prototype.handle_eof = function(current_token) {
-  // Unwind any open statements
-  while (this._flags.mode === MODE.Statement) {
-    this.restore_mode();
-  }
-  this.handle_whitespace_and_comments(current_token);
-};
-
-module.exports.Beautifier = Beautifier;