 
// nc-server/source/javascript/js-beautify.js
// https://github.com/beautify-web/js-beautify
import { c as createCommonjsModule } from './commonjs.js';

/*jshint node:true */

function OutputLine(parent) {
	this.__parent = parent;
	this.__character_count = 0;
	// use indent_count as a marker for this.__lines that have preserved indentation
	this.__indent_count = -1;
	this.__alignment_count = 0;
	this.__wrap_point_index = 0;
	this.__wrap_point_character_count = 0;
	this.__wrap_point_indent_count = -1;
	this.__wrap_point_alignment_count = 0;

	this.__items = [];
}

OutputLine.prototype.clone_empty = function () {
	var line = new OutputLine(this.__parent);
	line.set_indent(this.__indent_count, this.__alignment_count);
	return line;
};

OutputLine.prototype.item = function (index) {
	if (index < 0) {
		return this.__items[this.__items.length + index];
	} else {
		return this.__items[index];
	}
};

OutputLine.prototype.has_match = function (pattern) {
	for (var lastCheckedOutput = this.__items.length - 1; lastCheckedOutput >= 0; lastCheckedOutput--) {
		if (this.__items[lastCheckedOutput].match(pattern)) {
			return true;
		}
	}
	return false;
};

OutputLine.prototype.set_indent = function (indent, alignment) {
	if (this.is_empty()) {
		this.__indent_count = indent || 0;
		this.__alignment_count = alignment || 0;
		this.__character_count = this.__parent.get_indent_size(this.__indent_count, this.__alignment_count);
	}
};

OutputLine.prototype._set_wrap_point = function () {
	if (this.__parent.wrap_line_length) {
		this.__wrap_point_index = this.__items.length;
		this.__wrap_point_character_count = this.__character_count;
		this.__wrap_point_indent_count = this.__parent.next_line.__indent_count;
		this.__wrap_point_alignment_count = this.__parent.next_line.__alignment_count;
	}
};

OutputLine.prototype._should_wrap = function () {
	return this.__wrap_point_index &&
		this.__character_count > this.__parent.wrap_line_length &&
		this.__wrap_point_character_count > this.__parent.next_line.__character_count;
};

OutputLine.prototype._allow_wrap = function () {
	if (this._should_wrap()) {
		this.__parent.add_new_line();
		var next = this.__parent.current_line;
		next.set_indent(this.__wrap_point_indent_count, this.__wrap_point_alignment_count);
		next.__items = this.__items.slice(this.__wrap_point_index);
		this.__items = this.__items.slice(0, this.__wrap_point_index);

		next.__character_count += this.__character_count - this.__wrap_point_character_count;
		this.__character_count = this.__wrap_point_character_count;

		if (next.__items[0] === " ") {
			next.__items.splice(0, 1);
			next.__character_count -= 1;
		}
		return true;
	}
	return false;
};

OutputLine.prototype.is_empty = function () {
	return this.__items.length === 0;
};

OutputLine.prototype.last = function () {
	if (!this.is_empty()) {
		return this.__items[this.__items.length - 1];
	} else {
		return null;
	}
};

OutputLine.prototype.push = function (item) {
	this.__items.push(item);
	var last_newline_index = item.lastIndexOf('\n');
	if (last_newline_index !== -1) {
		this.__character_count = item.length - last_newline_index;
	} else {
		this.__character_count += item.length;
	}
};

OutputLine.prototype.pop = function () {
	var item = null;
	if (!this.is_empty()) {
		item = this.__items.pop();
		this.__character_count -= item.length;
	}
	return item;
};


OutputLine.prototype._remove_indent = function () {
	if (this.__indent_count > 0) {
		this.__indent_count -= 1;
		this.__character_count -= this.__parent.indent_size;
	}
};

OutputLine.prototype._remove_wrap_indent = function () {
	if (this.__wrap_point_indent_count > 0) {
		this.__wrap_point_indent_count -= 1;
	}
};
OutputLine.prototype.trim = function () {
	while (this.last() === ' ') {
		this.__items.pop();
		this.__character_count -= 1;
	}
};

OutputLine.prototype.toString = function () {
	var result = '';
	if (this.is_empty()) {
		if (this.__parent.indent_empty_lines) {
			result = this.__parent.get_indent_string(this.__indent_count);
		}
	} else {
		result = this.__parent.get_indent_string(this.__indent_count, this.__alignment_count);
		result += this.__items.join('');
	}
	return result;
};

function IndentStringCache(options, baseIndentString) {
	this.__cache = [''];
	this.__indent_size = options.indent_size;
	this.__indent_string = options.indent_char;
	if (!options.indent_with_tabs) {
		this.__indent_string = new Array(options.indent_size + 1).join(options.indent_char);
	}

	// Set to null to continue support for auto detection of base indent
	baseIndentString = baseIndentString || '';
	if (options.indent_level > 0) {
		baseIndentString = new Array(options.indent_level + 1).join(this.__indent_string);
	}

	this.__base_string = baseIndentString;
	this.__base_string_length = baseIndentString.length;
}

IndentStringCache.prototype.get_indent_size = function (indent, column) {
	var result = this.__base_string_length;
	column = column || 0;
	if (indent < 0) {
		result = 0;
	}
	result += indent * this.__indent_size;
	result += column;
	return result;
};

IndentStringCache.prototype.get_indent_string = function (indent_level, column) {
	var result = this.__base_string;
	column = column || 0;
	if (indent_level < 0) {
		indent_level = 0;
		result = '';
	}
	column += indent_level * this.__indent_size;
	this.__ensure_cache(column);
	result += this.__cache[column];
	return result;
};

IndentStringCache.prototype.__ensure_cache = function (column) {
	while (column >= this.__cache.length) {
		this.__add_column();
	}
};

IndentStringCache.prototype.__add_column = function () {
	var column = this.__cache.length;
	var indent = 0;
	var result = '';
	if (this.__indent_size && column >= this.__indent_size) {
		indent = Math.floor(column / this.__indent_size);
		column -= indent * this.__indent_size;
		result = new Array(indent + 1).join(this.__indent_string);
	}
	if (column) {
		result += new Array(column + 1).join(' ');
	}

	this.__cache.push(result);
};

function Output(options, baseIndentString) {
	this.__indent_cache = new IndentStringCache(options, baseIndentString);
	this.raw = false;
	this._end_with_newline = options.end_with_newline;
	this.indent_size = options.indent_size;
	this.wrap_line_length = options.wrap_line_length;
	this.indent_empty_lines = options.indent_empty_lines;
	this.__lines = [];
	this.previous_line = null;
	this.current_line = null;
	this.next_line = new OutputLine(this);
	this.space_before_token = false;
	this.non_breaking_space = false;
	this.previous_token_wrapped = false;
	// initialize
	this.__add_outputline();
}

Output.prototype.__add_outputline = function () {
	this.previous_line = this.current_line;
	this.current_line = this.next_line.clone_empty();
	this.__lines.push(this.current_line);
};

Output.prototype.get_line_number = function () {
	return this.__lines.length;
};

Output.prototype.get_indent_string = function (indent, column) {
	return this.__indent_cache.get_indent_string(indent, column);
};

Output.prototype.get_indent_size = function (indent, column) {
	return this.__indent_cache.get_indent_size(indent, column);
};

Output.prototype.is_empty = function () {
	return !this.previous_line && this.current_line.is_empty();
};

Output.prototype.add_new_line = function (force_newline) {
	// never newline at the start of file
	// otherwise, newline only if we didn't just add one or we're forced
	if (this.is_empty() ||
		(!force_newline && this.just_added_newline())) {
		return false;
	}

	// if raw output is enabled, don't print additional newlines,
	// but still return True as though you had
	if (!this.raw) {
		this.__add_outputline();
	}
	return true;
};

Output.prototype.get_code = function (eol) {
	this.trim(true);

	// handle some edge cases where the last tokens
	// has text that ends with newline(s)
	var last_item = this.current_line.pop();
	if (last_item) {
		if (last_item[last_item.length - 1] === '\n') {
			last_item = last_item.replace(/\n+$/g, '');
		}
		this.current_line.push(last_item);
	}

	if (this._end_with_newline) {
		this.__add_outputline();
	}

	var sweet_code = this.__lines.join('\n');

	if (eol !== '\n') {
		sweet_code = sweet_code.replace(/[\n]/g, eol);
	}
	return sweet_code;
};

Output.prototype.set_wrap_point = function () {
	this.current_line._set_wrap_point();
};

Output.prototype.set_indent = function (indent, alignment) {
	indent = indent || 0;
	alignment = alignment || 0;

	// Next line stores alignment values
	this.next_line.set_indent(indent, alignment);

	// Never indent your first output indent at the start of the file
	if (this.__lines.length > 1) {
		this.current_line.set_indent(indent, alignment);
		return true;
	}

	this.current_line.set_indent();
	return false;
};

Output.prototype.add_raw_token = function (token) {
	for (var x = 0; x < token.newlines; x++) {
		this.__add_outputline();
	}
	this.current_line.set_indent(-1);
	this.current_line.push(token.whitespace_before);
	this.current_line.push(token.text);
	this.space_before_token = false;
	this.non_breaking_space = false;
	this.previous_token_wrapped = false;
};

Output.prototype.add_token = function (printable_token) {
	this.__add_space_before_token();
	this.current_line.push(printable_token);
	this.space_before_token = false;
	this.non_breaking_space = false;
	this.previous_token_wrapped = this.current_line._allow_wrap();
};

Output.prototype.__add_space_before_token = function () {
	if (this.space_before_token && !this.just_added_newline()) {
		if (!this.non_breaking_space) {
			this.set_wrap_point();
		}
		this.current_line.push(' ');
	}
};

Output.prototype.remove_indent = function (index) {
	var output_length = this.__lines.length;
	while (index < output_length) {
		this.__lines[index]._remove_indent();
		index++;
	}
	this.current_line._remove_wrap_indent();
};

Output.prototype.trim = function (eat_newlines) {
	eat_newlines = (eat_newlines === undefined) ? false : eat_newlines;

	this.current_line.trim();

	while (eat_newlines && this.__lines.length > 1 &&
		this.current_line.is_empty()) {
		this.__lines.pop();
		this.current_line = this.__lines[this.__lines.length - 1];
		this.current_line.trim();
	}

	this.previous_line = this.__lines.length > 1 ?
		this.__lines[this.__lines.length - 2] : null;
};

Output.prototype.just_added_newline = function () {
	return this.current_line.is_empty();
};

Output.prototype.just_added_blankline = function () {
	return this.is_empty() ||
		(this.current_line.is_empty() && this.previous_line.is_empty());
};

Output.prototype.ensure_empty_line_above = function (starts_with, ends_with) {
	var index = this.__lines.length - 2;
	while (index >= 0) {
		var potentialEmptyLine = this.__lines[index];
		if (potentialEmptyLine.is_empty()) {
			break;
		} else if (potentialEmptyLine.item(0).indexOf(starts_with) !== 0 &&
			potentialEmptyLine.item(-1) !== ends_with) {
			this.__lines.splice(index + 1, 0, new OutputLine(this));
			this.previous_line = this.__lines[this.__lines.length - 2];
			break;
		}
		index--;
	}
};

var Output_1 = Output;

var output = {
	Output: Output_1
};

/*jshint node:true */

function Token(type, text, newlines, whitespace_before) {
	this.type = type;
	this.text = text;

	// comments_before are
	// comments that have a new line before them
	// and may or may not have a newline after
	// this is a set of comments before
	this.comments_before = null; /* inline comment*/


	// this.comments_after =  new TokenStream(); // no new line before and newline after
	this.newlines = newlines || 0;
	this.whitespace_before = whitespace_before || '';
	this.parent = null;
	this.next = null;
	this.previous = null;
	this.opened = null;
	this.closed = null;
	this.directives = null;
}


var Token_1 = Token;

var token = {
	Token: Token_1
};

var acorn = createCommonjsModule(function (module, exports) {

	// acorn used char codes to squeeze the last bit of performance out
	// Beautifier is okay without that, so we're using regex
	// permit $ (36) and @ (64). @ is used in ES7 decorators.
	// 65 through 91 are uppercase letters.
	// permit _ (95).
	// 97 through 123 are lowercase letters.
	var baseASCIIidentifierStartChars = "\\x24\\x40\\x41-\\x5a\\x5f\\x61-\\x7a";

	// inside an identifier @ is not allowed but 0-9 are.
	var baseASCIIidentifierChars = "\\x24\\x30-\\x39\\x41-\\x5a\\x5f\\x61-\\x7a";

	// Big ugly regular expressions that match characters in the
	// whitespace, identifier, and identifier-start categories. These
	// are only applied when a character is found to actually have a
	// code point above 128.
	var nonASCIIidentifierStartChars = "\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05d0-\\u05ea\\u05f0-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u08a0\\u08a2-\\u08ac\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0977\\u0979-\\u097f\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c33\\u0c35-\\u0c39\\u0c3d\\u0c58\\u0c59\\u0c60\\u0c61\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d60\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e87\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa\\u0eab\\u0ead-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f4\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f0\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1877\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191c\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19c1-\\u19c7\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1ce9-\\u1cec\\u1cee-\\u1cf1\\u1cf5\\u1cf6\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2119-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u212d\\u212f-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u2e2f\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309d-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312d\\u3131-\\u318e\\u31a0-\\u31ba\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fcc\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua697\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua78e\\ua790-\\ua793\\ua7a0-\\ua7aa\\ua7f8-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa80-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uabc0-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc";
	var nonASCIIidentifierChars = "\\u0300-\\u036f\\u0483-\\u0487\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u0620-\\u0649\\u0672-\\u06d3\\u06e7-\\u06e8\\u06fb-\\u06fc\\u0730-\\u074a\\u0800-\\u0814\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0840-\\u0857\\u08e4-\\u08fe\\u0900-\\u0903\\u093a-\\u093c\\u093e-\\u094f\\u0951-\\u0957\\u0962-\\u0963\\u0966-\\u096f\\u0981-\\u0983\\u09bc\\u09be-\\u09c4\\u09c7\\u09c8\\u09d7\\u09df-\\u09e0\\u0a01-\\u0a03\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a66-\\u0a71\\u0a75\\u0a81-\\u0a83\\u0abc\\u0abe-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ae2-\\u0ae3\\u0ae6-\\u0aef\\u0b01-\\u0b03\\u0b3c\\u0b3e-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b56\\u0b57\\u0b5f-\\u0b60\\u0b66-\\u0b6f\\u0b82\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd7\\u0be6-\\u0bef\\u0c01-\\u0c03\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62-\\u0c63\\u0c66-\\u0c6f\\u0c82\\u0c83\\u0cbc\\u0cbe-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0ce2-\\u0ce3\\u0ce6-\\u0cef\\u0d02\\u0d03\\u0d46-\\u0d48\\u0d57\\u0d62-\\u0d63\\u0d66-\\u0d6f\\u0d82\\u0d83\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0df2\\u0df3\\u0e34-\\u0e3a\\u0e40-\\u0e45\\u0e50-\\u0e59\\u0eb4-\\u0eb9\\u0ec8-\\u0ecd\\u0ed0-\\u0ed9\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f41-\\u0f47\\u0f71-\\u0f84\\u0f86-\\u0f87\\u0f8d-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u1000-\\u1029\\u1040-\\u1049\\u1067-\\u106d\\u1071-\\u1074\\u1082-\\u108d\\u108f-\\u109d\\u135d-\\u135f\\u170e-\\u1710\\u1720-\\u1730\\u1740-\\u1750\\u1772\\u1773\\u1780-\\u17b2\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u1810-\\u1819\\u1920-\\u192b\\u1930-\\u193b\\u1951-\\u196d\\u19b0-\\u19c0\\u19c8-\\u19c9\\u19d0-\\u19d9\\u1a00-\\u1a15\\u1a20-\\u1a53\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1b46-\\u1b4b\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1bb0-\\u1bb9\\u1be6-\\u1bf3\\u1c00-\\u1c22\\u1c40-\\u1c49\\u1c5b-\\u1c7d\\u1cd0-\\u1cd2\\u1d00-\\u1dbe\\u1e01-\\u1f15\\u200c\\u200d\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2d81-\\u2d96\\u2de0-\\u2dff\\u3021-\\u3028\\u3099\\u309a\\ua640-\\ua66d\\ua674-\\ua67d\\ua69f\\ua6f0-\\ua6f1\\ua7f8-\\ua800\\ua806\\ua80b\\ua823-\\ua827\\ua880-\\ua881\\ua8b4-\\ua8c4\\ua8d0-\\ua8d9\\ua8f3-\\ua8f7\\ua900-\\ua909\\ua926-\\ua92d\\ua930-\\ua945\\ua980-\\ua983\\ua9b3-\\ua9c0\\uaa00-\\uaa27\\uaa40-\\uaa41\\uaa4c-\\uaa4d\\uaa50-\\uaa59\\uaa7b\\uaae0-\\uaae9\\uaaf2-\\uaaf3\\uabc0-\\uabe1\\uabec\\uabed\\uabf0-\\uabf9\\ufb20-\\ufb28\\ufe00-\\ufe0f\\ufe20-\\ufe26\\ufe33\\ufe34\\ufe4d-\\ufe4f\\uff10-\\uff19\\uff3f";
	//var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
	//var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");

	var identifierStart = "(?:\\\\u[0-9a-fA-F]{4}|[" + baseASCIIidentifierStartChars + nonASCIIidentifierStartChars + "])";
	var identifierChars = "(?:\\\\u[0-9a-fA-F]{4}|[" + baseASCIIidentifierChars + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "])*";

	exports.identifier = new RegExp(identifierStart + identifierChars, 'g');
	exports.identifierStart = new RegExp(identifierStart);
	exports.identifierMatch = new RegExp("(?:\\\\u[0-9a-fA-F]{4}|[" + baseASCIIidentifierChars + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "])+");

	// Whether a single character denotes a newline.

	exports.newline = /[\n\r\u2028\u2029]/;

	// Matches a whole line break (where CRLF is considered a single
	// line break). Used to count lines.

	// in javascript, these two differ
	// in python they are the same, different methods are called on them
	exports.lineBreak = new RegExp('\r\n|' + exports.newline.source);
	exports.allLineBreaks = new RegExp(exports.lineBreak.source, 'g');
});
var acorn_1 = acorn.identifier;
var acorn_2 = acorn.identifierStart;
var acorn_3 = acorn.identifierMatch;
var acorn_4 = acorn.newline;
var acorn_5 = acorn.lineBreak;
var acorn_6 = acorn.allLineBreaks;

/*jshint node:true */

function Options(options, merge_child_field) {
	this.raw_options = _mergeOpts(options, merge_child_field);

	// Support passing the source text back with no change
	this.disabled = this._get_boolean('disabled');

	this.eol = this._get_characters('eol', 'auto');
	this.end_with_newline = this._get_boolean('end_with_newline');
	this.indent_size = this._get_number('indent_size', 4);
	this.indent_char = this._get_characters('indent_char', ' ');
	this.indent_level = this._get_number('indent_level');

	this.preserve_newlines = this._get_boolean('preserve_newlines', true);
	this.max_preserve_newlines = this._get_number('max_preserve_newlines', 32786);
	if (!this.preserve_newlines) {
		this.max_preserve_newlines = 0;
	}

	this.indent_with_tabs = this._get_boolean('indent_with_tabs', this.indent_char === '\t');
	if (this.indent_with_tabs) {
		this.indent_char = '\t';

		// indent_size behavior changed after 1.8.6
		// It used to be that indent_size would be
		// set to 1 for indent_with_tabs. That is no longer needed and
		// actually doesn't make sense - why not use spaces? Further,
		// that might produce unexpected behavior - tabs being used
		// for single-column alignment. So, when indent_with_tabs is true
		// and indent_size is 1, reset indent_size to 4.
		if (this.indent_size === 1) {
			this.indent_size = 4;
		}
	}

	// Backwards compat with 1.3.x
	this.wrap_line_length = this._get_number('wrap_line_length', this._get_number('max_char'));

	this.indent_empty_lines = this._get_boolean('indent_empty_lines');

	// valid templating languages ['django', 'erb', 'handlebars', 'php']
	// For now, 'auto' = all off for javascript, all on for html (and inline javascript).
	// other values ignored
	this.templating = this._get_selection_list('templating', ['auto', 'none', 'django', 'erb', 'handlebars', 'php'], ['auto']);
}

Options.prototype._get_array = function (name, default_value) {
	var option_value = this.raw_options[name];
	var result = default_value || [];
	if (typeof option_value === 'object') {
		if (option_value !== null && typeof option_value.concat === 'function') {
			result = option_value.concat();
		}
	} else if (typeof option_value === 'string') {
		result = option_value.split(/[^a-zA-Z0-9_\/\-]+/);
	}
	return result;
};

Options.prototype._get_boolean = function (name, default_value) {
	var option_value = this.raw_options[name];
	var result = option_value === undefined ? !!default_value : !!option_value;
	return result;
};

Options.prototype._get_characters = function (name, default_value) {
	var option_value = this.raw_options[name];
	var result = default_value || '';
	if (typeof option_value === 'string') {
		result = option_value.replace(/\\r/, '\r').replace(/\\n/, '\n').replace(/\\t/, '\t');
	}
	return result;
};

Options.prototype._get_number = function (name, default_value) {
	var option_value = this.raw_options[name];
	default_value = parseInt(default_value, 10);
	if (isNaN(default_value)) {
		default_value = 0;
	}
	var result = parseInt(option_value, 10);
	if (isNaN(result)) {
		result = default_value;
	}
	return result;
};

Options.prototype._get_selection = function (name, selection_list, default_value) {
	var result = this._get_selection_list(name, selection_list, default_value);
	if (result.length !== 1) {
		throw new Error(
			"Invalid Option Value: The option '" + name + "' can only be one of the following values:\n" +
			selection_list + "\nYou passed in: '" + this.raw_options[name] + "'");
	}

	return result[0];
};


Options.prototype._get_selection_list = function (name, selection_list, default_value) {
	if (!selection_list || selection_list.length === 0) {
		throw new Error("Selection list cannot be empty.");
	}

	default_value = default_value || [selection_list[0]];
	if (!this._is_valid_selection(default_value, selection_list)) {
		throw new Error("Invalid Default Value!");
	}

	var result = this._get_array(name, default_value);
	if (!this._is_valid_selection(result, selection_list)) {
		throw new Error(
			"Invalid Option Value: The option '" + name + "' can contain only the following values:\n" +
			selection_list + "\nYou passed in: '" + this.raw_options[name] + "'");
	}

	return result;
};

Options.prototype._is_valid_selection = function (result, selection_list) {
	return result.length && selection_list.length &&
		!result.some(function (item) { return selection_list.indexOf(item) === -1; });
};


// merges child options up with the parent options object
// Example: obj = {a: 1, b: {a: 2}}
//          mergeOpts(obj, 'b')
//
//          Returns: {a: 2}
function _mergeOpts(allOptions, childFieldName) {
	var finalOpts = {};
	allOptions = _normalizeOpts(allOptions);
	var name;

	for (name in allOptions) {
		if (name !== childFieldName) {
			finalOpts[name] = allOptions[name];
		}
	}

	//merge in the per type settings for the childFieldName
	if (childFieldName && allOptions[childFieldName]) {
		for (name in allOptions[childFieldName]) {
			finalOpts[name] = allOptions[childFieldName][name];
		}
	}
	return finalOpts;
}

function _normalizeOpts(options) {
	var convertedOpts = {};
	var key;

	for (key in options) {
		var newKey = key.replace(/-/g, "_");
		convertedOpts[newKey] = options[key];
	}
	return convertedOpts;
}

var Options_1 = Options;
var normalizeOpts = _normalizeOpts;
var mergeOpts = _mergeOpts;

var options = {
	Options: Options_1,
	normalizeOpts: normalizeOpts,
	mergeOpts: mergeOpts
};

var BaseOptions = options.Options;

var validPositionValues = ['before-newline', 'after-newline', 'preserve-newline'];

function Options$1(options) {
	BaseOptions.call(this, options, 'js');

	// compatibility, re
	var raw_brace_style = this.raw_options.brace_style || null;
	if (raw_brace_style === "expand-strict") { //graceful handling of deprecated option
		this.raw_options.brace_style = "expand";
	} else if (raw_brace_style === "collapse-preserve-inline") { //graceful handling of deprecated option
		this.raw_options.brace_style = "collapse,preserve-inline";
	} else if (this.raw_options.braces_on_own_line !== undefined) { //graceful handling of deprecated option
		this.raw_options.brace_style = this.raw_options.braces_on_own_line ? "expand" : "collapse";
		// } else if (!raw_brace_style) { //Nothing exists to set it
		//   raw_brace_style = "collapse";
	}

	//preserve-inline in delimited string will trigger brace_preserve_inline, everything
	//else is considered a brace_style and the last one only will have an effect

	var brace_style_split = this._get_selection_list('brace_style', ['collapse', 'expand', 'end-expand', 'none', 'preserve-inline']);

	this.brace_preserve_inline = false; //Defaults in case one or other was not specified in meta-option
	this.brace_style = "collapse";

	for (var bs = 0; bs < brace_style_split.length; bs++) {
		if (brace_style_split[bs] === "preserve-inline") {
			this.brace_preserve_inline = true;
		} else {
			this.brace_style = brace_style_split[bs];
		}
	}

	this.unindent_chained_methods = this._get_boolean('unindent_chained_methods');
	this.break_chained_methods = this._get_boolean('break_chained_methods');
	this.space_in_paren = this._get_boolean('space_in_paren');
	this.space_in_empty_paren = this._get_boolean('space_in_empty_paren');
	this.jslint_happy = this._get_boolean('jslint_happy');
	this.space_after_anon_function = this._get_boolean('space_after_anon_function');
	this.space_after_named_function = this._get_boolean('space_after_named_function');
	this.keep_array_indentation = this._get_boolean('keep_array_indentation');
	this.space_before_conditional = this._get_boolean('space_before_conditional', true);
	this.unescape_strings = this._get_boolean('unescape_strings');
	this.e4x = this._get_boolean('e4x');
	this.comma_first = this._get_boolean('comma_first');
	this.operator_position = this._get_selection('operator_position', validPositionValues);

	// For testing of beautify preserve:start directive
	this.test_output_raw = this._get_boolean('test_output_raw');

	// force this._options.space_after_anon_function to true if this._options.jslint_happy
	if (this.jslint_happy) {
		this.space_after_anon_function = true;
	}

}
Options$1.prototype = new BaseOptions();



var Options_1$1 = Options$1;

var options$1 = {
	Options: Options_1$1
};

/*jshint node:true */

var regexp_has_sticky = RegExp.prototype.hasOwnProperty('sticky');

function InputScanner(input_string) {
	this.__input = input_string || '';
	this.__input_length = this.__input.length;
	this.__position = 0;
}

InputScanner.prototype.restart = function () {
	this.__position = 0;
};

InputScanner.prototype.back = function () {
	if (this.__position > 0) {
		this.__position -= 1;
	}
};

InputScanner.prototype.hasNext = function () {
	return this.__position < this.__input_length;
};

InputScanner.prototype.next = function () {
	var val = null;
	if (this.hasNext()) {
		val = this.__input.charAt(this.__position);
		this.__position += 1;
	}
	return val;
};

InputScanner.prototype.peek = function (index) {
	var val = null;
	index = index || 0;
	index += this.__position;
	if (index >= 0 && index < this.__input_length) {
		val = this.__input.charAt(index);
	}
	return val;
};

// This is a JavaScript only helper function (not in python)
// Javascript doesn't have a match method
// and not all implementation support "sticky" flag.
// If they do not support sticky then both this.match() and this.test() method
// must get the match and check the index of the match.
// If sticky is supported and set, this method will use it.
// Otherwise it will check that global is set, and fall back to the slower method.
InputScanner.prototype.__match = function (pattern, index) {
	pattern.lastIndex = index;
	var pattern_match = pattern.exec(this.__input);

	if (pattern_match && !(regexp_has_sticky && pattern.sticky)) {
		if (pattern_match.index !== index) {
			pattern_match = null;
		}
	}

	return pattern_match;
};

InputScanner.prototype.test = function (pattern, index) {
	index = index || 0;
	index += this.__position;

	if (index >= 0 && index < this.__input_length) {
		return !!this.__match(pattern, index);
	} else {
		return false;
	}
};

InputScanner.prototype.testChar = function (pattern, index) {
	// test one character regex match
	var val = this.peek(index);
	pattern.lastIndex = 0;
	return val !== null && pattern.test(val);
};

InputScanner.prototype.match = function (pattern) {
	var pattern_match = this.__match(pattern, this.__position);
	if (pattern_match) {
		this.__position += pattern_match[0].length;
	} else {
		pattern_match = null;
	}
	return pattern_match;
};

InputScanner.prototype.read = function (starting_pattern, until_pattern, until_after) {
	var val = '';
	var match;
	if (starting_pattern) {
		match = this.match(starting_pattern);
		if (match) {
			val += match[0];
		}
	}
	if (until_pattern && (match || !starting_pattern)) {
		val += this.readUntil(until_pattern, until_after);
	}
	return val;
};

InputScanner.prototype.readUntil = function (pattern, until_after) {
	var val = '';
	var match_index = this.__position;
	pattern.lastIndex = this.__position;
	var pattern_match = pattern.exec(this.__input);
	if (pattern_match) {
		match_index = pattern_match.index;
		if (until_after) {
			match_index += pattern_match[0].length;
		}
	} else {
		match_index = this.__input_length;
	}

	val = this.__input.substring(this.__position, match_index);
	this.__position = match_index;
	return val;
};

InputScanner.prototype.readUntilAfter = function (pattern) {
	return this.readUntil(pattern, true);
};

InputScanner.prototype.get_regexp = function (pattern, match_from) {
	var result = null;
	var flags = 'g';
	if (match_from && regexp_has_sticky) {
		flags = 'y';
	}
	// strings are converted to regexp
	if (typeof pattern === "string" && pattern !== '') {
		// result = new RegExp(pattern.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), flags);
		result = new RegExp(pattern, flags);
	} else if (pattern) {
		result = new RegExp(pattern.source, flags);
	}
	return result;
};

InputScanner.prototype.get_literal_regexp = function (literal_string) {
	return RegExp(literal_string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'));
};

/* css beautifier legacy helpers */
InputScanner.prototype.peekUntilAfter = function (pattern) {
	var start = this.__position;
	var val = this.readUntilAfter(pattern);
	this.__position = start;
	return val;
};

InputScanner.prototype.lookBack = function (testVal) {
	var start = this.__position - 1;
	return start >= testVal.length && this.__input.substring(start - testVal.length, start)
		.toLowerCase() === testVal;
};

var InputScanner_1 = InputScanner;

var inputscanner = {
	InputScanner: InputScanner_1
};

/*jshint node:true */

function TokenStream(parent_token) {
	// private
	this.__tokens = [];
	this.__tokens_length = this.__tokens.length;
	this.__position = 0;
	this.__parent_token = parent_token;
}

TokenStream.prototype.restart = function () {
	this.__position = 0;
};

TokenStream.prototype.isEmpty = function () {
	return this.__tokens_length === 0;
};

TokenStream.prototype.hasNext = function () {
	return this.__position < this.__tokens_length;
};

TokenStream.prototype.next = function () {
	var val = null;
	if (this.hasNext()) {
		val = this.__tokens[this.__position];
		this.__position += 1;
	}
	return val;
};

TokenStream.prototype.peek = function (index) {
	var val = null;
	index = index || 0;
	index += this.__position;
	if (index >= 0 && index < this.__tokens_length) {
		val = this.__tokens[index];
	}
	return val;
};

TokenStream.prototype.add = function (token) {
	if (this.__parent_token) {
		token.parent = this.__parent_token;
	}
	this.__tokens.push(token);
	this.__tokens_length += 1;
};

var TokenStream_1 = TokenStream;

var tokenstream = {
	TokenStream: TokenStream_1
};

/*jshint node:true */

function Pattern(input_scanner, parent) {
	this._input = input_scanner;
	this._starting_pattern = null;
	this._match_pattern = null;
	this._until_pattern = null;
	this._until_after = false;

	if (parent) {
		this._starting_pattern = this._input.get_regexp(parent._starting_pattern, true);
		this._match_pattern = this._input.get_regexp(parent._match_pattern, true);
		this._until_pattern = this._input.get_regexp(parent._until_pattern);
		this._until_after = parent._until_after;
	}
}

Pattern.prototype.read = function () {
	var result = this._input.read(this._starting_pattern);
	if (!this._starting_pattern || result) {
		result += this._input.read(this._match_pattern, this._until_pattern, this._until_after);
	}
	return result;
};

Pattern.prototype.read_match = function () {
	return this._input.match(this._match_pattern);
};

Pattern.prototype.until_after = function (pattern) {
	var result = this._create();
	result._until_after = true;
	result._until_pattern = this._input.get_regexp(pattern);
	result._update();
	return result;
};

Pattern.prototype.until = function (pattern) {
	var result = this._create();
	result._until_after = false;
	result._until_pattern = this._input.get_regexp(pattern);
	result._update();
	return result;
};

Pattern.prototype.starting_with = function (pattern) {
	var result = this._create();
	result._starting_pattern = this._input.get_regexp(pattern, true);
	result._update();
	return result;
};

Pattern.prototype.matching = function (pattern) {
	var result = this._create();
	result._match_pattern = this._input.get_regexp(pattern, true);
	result._update();
	return result;
};

Pattern.prototype._create = function () {
	return new Pattern(this._input, this);
};

Pattern.prototype._update = function () { };

var Pattern_1 = Pattern;

var pattern = {
	Pattern: Pattern_1
};

var Pattern$1 = pattern.Pattern;

function WhitespacePattern(input_scanner, parent) {
	Pattern$1.call(this, input_scanner, parent);
	if (parent) {
		this._line_regexp = this._input.get_regexp(parent._line_regexp);
	} else {
		this.__set_whitespace_patterns('', '');
	}

	this.newline_count = 0;
	this.whitespace_before_token = '';
}
WhitespacePattern.prototype = new Pattern$1();

WhitespacePattern.prototype.__set_whitespace_patterns = function (whitespace_chars, newline_chars) {
	whitespace_chars += '\\t ';
	newline_chars += '\\n\\r';

	this._match_pattern = this._input.get_regexp(
		'[' + whitespace_chars + newline_chars + ']+', true);
	this._newline_regexp = this._input.get_regexp(
		'\\r\\n|[' + newline_chars + ']');
};

WhitespacePattern.prototype.read = function () {
	this.newline_count = 0;
	this.whitespace_before_token = '';

	var resulting_string = this._input.read(this._match_pattern);
	if (resulting_string === ' ') {
		this.whitespace_before_token = ' ';
	} else if (resulting_string) {
		var matches = this.__split(this._newline_regexp, resulting_string);
		this.newline_count = matches.length - 1;
		this.whitespace_before_token = matches[this.newline_count];
	}

	return resulting_string;
};

WhitespacePattern.prototype.matching = function (whitespace_chars, newline_chars) {
	var result = this._create();
	result.__set_whitespace_patterns(whitespace_chars, newline_chars);
	result._update();
	return result;
};

WhitespacePattern.prototype._create = function () {
	return new WhitespacePattern(this._input, this);
};

WhitespacePattern.prototype.__split = function (regexp, input_string) {
	regexp.lastIndex = 0;
	var start_index = 0;
	var result = [];
	var next_match = regexp.exec(input_string);
	while (next_match) {
		result.push(input_string.substring(start_index, next_match.index));
		start_index = next_match.index + next_match[0].length;
		next_match = regexp.exec(input_string);
	}

	if (start_index < input_string.length) {
		result.push(input_string.substring(start_index, input_string.length));
	} else {
		result.push('');
	}

	return result;
};



var WhitespacePattern_1 = WhitespacePattern;

var whitespacepattern = {
	WhitespacePattern: WhitespacePattern_1
};

var InputScanner$1 = inputscanner.InputScanner;
var Token$1 = token.Token;
var TokenStream$1 = tokenstream.TokenStream;
var WhitespacePattern$1 = whitespacepattern.WhitespacePattern;

var TOKEN = {
	START: 'TK_START',
	RAW: 'TK_RAW',
	EOF: 'TK_EOF'
};

var Tokenizer = function (input_string, options) {
	this._input = new InputScanner$1(input_string);
	this._options = options || {};
	this.__tokens = null;

	this._patterns = {};
	this._patterns.whitespace = new WhitespacePattern$1(this._input);
};

Tokenizer.prototype.tokenize = function () {
	this._input.restart();
	this.__tokens = new TokenStream$1();

	this._reset();

	var current;
	var previous = new Token$1(TOKEN.START, '');
	var open_token = null;
	var open_stack = [];
	var comments = new TokenStream$1();

	while (previous.type !== TOKEN.EOF) {
		current = this._get_next_token(previous, open_token);
		while (this._is_comment(current)) {
			comments.add(current);
			current = this._get_next_token(previous, open_token);
		}

		if (!comments.isEmpty()) {
			current.comments_before = comments;
			comments = new TokenStream$1();
		}

		current.parent = open_token;

		if (this._is_opening(current)) {
			open_stack.push(open_token);
			open_token = current;
		} else if (open_token && this._is_closing(current, open_token)) {
			current.opened = open_token;
			open_token.closed = current;
			open_token = open_stack.pop();
			current.parent = open_token;
		}

		current.previous = previous;
		previous.next = current;

		this.__tokens.add(current);
		previous = current;
	}

	return this.__tokens;
};


Tokenizer.prototype._is_first_token = function () {
	return this.__tokens.isEmpty();
};

Tokenizer.prototype._reset = function () { };

Tokenizer.prototype._get_next_token = function (previous_token, open_token) { // jshint unused:false
	this._readWhitespace();
	var resulting_string = this._input.read(/.+/g);
	if (resulting_string) {
		return this._create_token(TOKEN.RAW, resulting_string);
	} else {
		return this._create_token(TOKEN.EOF, '');
	}
};

Tokenizer.prototype._is_comment = function (current_token) { // jshint unused:false
	return false;
};

Tokenizer.prototype._is_opening = function (current_token) { // jshint unused:false
	return false;
};

Tokenizer.prototype._is_closing = function (current_token, open_token) { // jshint unused:false
	return false;
};

Tokenizer.prototype._create_token = function (type, text) {
	var token = new Token$1(type, text,
		this._patterns.whitespace.newline_count,
		this._patterns.whitespace.whitespace_before_token);
	return token;
};

Tokenizer.prototype._readWhitespace = function () {
	return this._patterns.whitespace.read();
};



var Tokenizer_1 = Tokenizer;
var TOKEN_1 = TOKEN;

var tokenizer = {
	Tokenizer: Tokenizer_1,
	TOKEN: TOKEN_1
};

/*jshint node:true */

function Directives(start_block_pattern, end_block_pattern) {
	start_block_pattern = typeof start_block_pattern === 'string' ? start_block_pattern : start_block_pattern.source;
	end_block_pattern = typeof end_block_pattern === 'string' ? end_block_pattern : end_block_pattern.source;
	this.__directives_block_pattern = new RegExp(start_block_pattern + / beautify( \w+[:]\w+)+ /.source + end_block_pattern, 'g');
	this.__directive_pattern = / (\w+)[:](\w+)/g;

	this.__directives_end_ignore_pattern = new RegExp(start_block_pattern + /\sbeautify\signore:end\s/.source + end_block_pattern, 'g');
}

Directives.prototype.get_directives = function (text) {
	if (!text.match(this.__directives_block_pattern)) {
		return null;
	}

	var directives = {};
	this.__directive_pattern.lastIndex = 0;
	var directive_match = this.__directive_pattern.exec(text);

	while (directive_match) {
		directives[directive_match[1]] = directive_match[2];
		directive_match = this.__directive_pattern.exec(text);
	}

	return directives;
};

Directives.prototype.readIgnored = function (input) {
	return input.readUntilAfter(this.__directives_end_ignore_pattern);
};


var Directives_1 = Directives;

var directives = {
	Directives: Directives_1
};

var Pattern$2 = pattern.Pattern;


var template_names = {
	django: false,
	erb: false,
	handlebars: false,
	php: false
};

// This lets templates appear anywhere we would do a readUntil
// The cost is higher but it is pay to play.
function TemplatablePattern(input_scanner, parent) {
	Pattern$2.call(this, input_scanner, parent);
	this.__template_pattern = null;
	this._disabled = Object.assign({}, template_names);
	this._excluded = Object.assign({}, template_names);

	if (parent) {
		this.__template_pattern = this._input.get_regexp(parent.__template_pattern);
		this._excluded = Object.assign(this._excluded, parent._excluded);
		this._disabled = Object.assign(this._disabled, parent._disabled);
	}
	var pattern = new Pattern$2(input_scanner);
	this.__patterns = {
		handlebars_comment: pattern.starting_with(/{{!--/).until_after(/--}}/),
		handlebars: pattern.starting_with(/{{/).until_after(/}}/),
		php: pattern.starting_with(/<\?(?:[=]|php)/).until_after(/\?>/),
		erb: pattern.starting_with(/<%[^%]/).until_after(/[^%]%>/),
		// django coflicts with handlebars a bit.
		django: pattern.starting_with(/{%/).until_after(/%}/),
		django_value: pattern.starting_with(/{{/).until_after(/}}/),
		django_comment: pattern.starting_with(/{#/).until_after(/#}/)
	};
}
TemplatablePattern.prototype = new Pattern$2();

TemplatablePattern.prototype._create = function () {
	return new TemplatablePattern(this._input, this);
};

TemplatablePattern.prototype._update = function () {
	this.__set_templated_pattern();
};

TemplatablePattern.prototype.disable = function (language) {
	var result = this._create();
	result._disabled[language] = true;
	result._update();
	return result;
};

TemplatablePattern.prototype.read_options = function (options) {
	var result = this._create();
	for (var language in template_names) {
		result._disabled[language] = options.templating.indexOf(language) === -1;
	}
	result._update();
	return result;
};

TemplatablePattern.prototype.exclude = function (language) {
	var result = this._create();
	result._excluded[language] = true;
	result._update();
	return result;
};

TemplatablePattern.prototype.read = function () {
	var result = '';
	if (this._match_pattern) {
		result = this._input.read(this._starting_pattern);
	} else {
		result = this._input.read(this._starting_pattern, this.__template_pattern);
	}
	var next = this._read_template();
	while (next) {
		if (this._match_pattern) {
			next += this._input.read(this._match_pattern);
		} else {
			next += this._input.readUntil(this.__template_pattern);
		}
		result += next;
		next = this._read_template();
	}

	if (this._until_after) {
		result += this._input.readUntilAfter(this._until_pattern);
	}
	return result;
};

TemplatablePattern.prototype.__set_templated_pattern = function () {
	var items = [];

	if (!this._disabled.php) {
		items.push(this.__patterns.php._starting_pattern.source);
	}
	if (!this._disabled.handlebars) {
		items.push(this.__patterns.handlebars._starting_pattern.source);
	}
	if (!this._disabled.erb) {
		items.push(this.__patterns.erb._starting_pattern.source);
	}
	if (!this._disabled.django) {
		items.push(this.__patterns.django._starting_pattern.source);
		items.push(this.__patterns.django_value._starting_pattern.source);
		items.push(this.__patterns.django_comment._starting_pattern.source);
	}

	if (this._until_pattern) {
		items.push(this._until_pattern.source);
	}
	this.__template_pattern = this._input.get_regexp('(?:' + items.join('|') + ')');
};

TemplatablePattern.prototype._read_template = function () {
	var resulting_string = '';
	var c = this._input.peek();
	if (c === '<') {
		var peek1 = this._input.peek(1);
		//if we're in a comment, do something special
		// We treat all comments as literals, even more than preformatted tags
		// we just look for the appropriate close tag
		if (!this._disabled.php && !this._excluded.php && peek1 === '?') {
			resulting_string = resulting_string ||
				this.__patterns.php.read();
		}
		if (!this._disabled.erb && !this._excluded.erb && peek1 === '%') {
			resulting_string = resulting_string ||
				this.__patterns.erb.read();
		}
	} else if (c === '{') {
		if (!this._disabled.handlebars && !this._excluded.handlebars) {
			resulting_string = resulting_string ||
				this.__patterns.handlebars_comment.read();
			resulting_string = resulting_string ||
				this.__patterns.handlebars.read();
		}
		if (!this._disabled.django) {
			// django coflicts with handlebars a bit.
			if (!this._excluded.django && !this._excluded.handlebars) {
				resulting_string = resulting_string ||
					this.__patterns.django_value.read();
			}
			if (!this._excluded.django) {
				resulting_string = resulting_string ||
					this.__patterns.django_comment.read();
				resulting_string = resulting_string ||
					this.__patterns.django.read();
			}
		}
	}
	return resulting_string;
};


var TemplatablePattern_1 = TemplatablePattern;

var templatablepattern = {
	TemplatablePattern: TemplatablePattern_1
};

var InputScanner$2 = inputscanner.InputScanner;
var BaseTokenizer = tokenizer.Tokenizer;
var BASETOKEN = tokenizer.TOKEN;
var Directives$1 = directives.Directives;

var Pattern$3 = pattern.Pattern;
var TemplatablePattern$1 = templatablepattern.TemplatablePattern;


function in_array(what, arr) {
	return arr.indexOf(what) !== -1;
}


var TOKEN$1 = {
	START_EXPR: 'TK_START_EXPR',
	END_EXPR: 'TK_END_EXPR',
	START_BLOCK: 'TK_START_BLOCK',
	END_BLOCK: 'TK_END_BLOCK',
	WORD: 'TK_WORD',
	RESERVED: 'TK_RESERVED',
	SEMICOLON: 'TK_SEMICOLON',
	STRING: 'TK_STRING',
	EQUALS: 'TK_EQUALS',
	OPERATOR: 'TK_OPERATOR',
	COMMA: 'TK_COMMA',
	BLOCK_COMMENT: 'TK_BLOCK_COMMENT',
	COMMENT: 'TK_COMMENT',
	DOT: 'TK_DOT',
	UNKNOWN: 'TK_UNKNOWN',
	START: BASETOKEN.START,
	RAW: BASETOKEN.RAW,
	EOF: BASETOKEN.EOF
};


var directives_core = new Directives$1(/\/\*/, /\*\//);

var number_pattern = /0[xX][0123456789abcdefABCDEF]*|0[oO][01234567]*|0[bB][01]*|\d+n|(?:\.\d+|\d+\.?\d*)(?:[eE][+-]?\d+)?/;

var digit = /[0-9]/;

// Dot "." must be distinguished from "..." and decimal
var dot_pattern = /[^\d\.]/;

var positionable_operators = (
	">>> === !== " +
	"<< && >= ** != == <= >> || " +
	"< / - + > : & % ? ^ | *").split(' ');

// IMPORTANT: this must be sorted longest to shortest or tokenizing many not work.
// Also, you must update possitionable operators separately from punct
var punct =
	">>>= " +
	"... >>= <<= === >>> !== **= " +
	"=> ^= :: /= << <= == && -= >= >> != -- += ** || ++ %= &= *= |= " +
	"= ! ? > < : / ^ - + * & % ~ |";

punct = punct.replace(/[-[\]{}()*+?.,\\^$|#]/g, "\\$&");
punct = punct.replace(/ /g, '|');

var punct_pattern = new RegExp(punct);

// words which should always start on new line.
var line_starters = 'continue,try,throw,return,var,let,const,if,switch,case,default,for,while,break,function,import,export'.split(',');
var reserved_words = line_starters.concat(['do', 'in', 'of', 'else', 'get', 'set', 'new', 'catch', 'finally', 'typeof', 'yield', 'async', 'await', 'from', 'as']);
var reserved_word_pattern = new RegExp('^(?:' + reserved_words.join('|') + ')$');

// var template_pattern = /(?:(?:<\?php|<\?=)[\s\S]*?\?>)|(?:<%[\s\S]*?%>)/g;

var in_html_comment;

var Tokenizer$1 = function (input_string, options) {
	BaseTokenizer.call(this, input_string, options);

	this._patterns.whitespace = this._patterns.whitespace.matching(
		/\u00A0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff/.source,
		/\u2028\u2029/.source);

	var pattern_reader = new Pattern$3(this._input);
	var templatable = new TemplatablePattern$1(this._input)
		.read_options(this._options);

	this.__patterns = {
		template: templatable,
		identifier: templatable.starting_with(acorn.identifier).matching(acorn.identifierMatch),
		number: pattern_reader.matching(number_pattern),
		punct: pattern_reader.matching(punct_pattern),
		// comment ends just before nearest linefeed or end of file
		comment: pattern_reader.starting_with(/\/\//).until(/[\n\r\u2028\u2029]/),
		//  /* ... */ comment ends with nearest */ or end of file
		block_comment: pattern_reader.starting_with(/\/\*/).until_after(/\*\//),
		html_comment_start: pattern_reader.matching(/<!--/),
		html_comment_end: pattern_reader.matching(/-->/),
		include: pattern_reader.starting_with(/#include/).until_after(acorn.lineBreak),
		shebang: pattern_reader.starting_with(/#!/).until_after(acorn.lineBreak),
		xml: pattern_reader.matching(/[\s\S]*?<(\/?)([-a-zA-Z:0-9_.]+|{[\s\S]+?}|!\[CDATA\[[\s\S]*?\]\])(\s+{[\s\S]+?}|\s+[-a-zA-Z:0-9_.]+|\s+[-a-zA-Z:0-9_.]+\s*=\s*('[^']*'|"[^"]*"|{[\s\S]+?}))*\s*(\/?)\s*>/),
		single_quote: templatable.until(/['\\\n\r\u2028\u2029]/),
		double_quote: templatable.until(/["\\\n\r\u2028\u2029]/),
		template_text: templatable.until(/[`\\$]/),
		template_expression: templatable.until(/[`}\\]/)
	};

};
Tokenizer$1.prototype = new BaseTokenizer();

Tokenizer$1.prototype._is_comment = function (current_token) {
	return current_token.type === TOKEN$1.COMMENT || current_token.type === TOKEN$1.BLOCK_COMMENT || current_token.type === TOKEN$1.UNKNOWN;
};

Tokenizer$1.prototype._is_opening = function (current_token) {
	return current_token.type === TOKEN$1.START_BLOCK || current_token.type === TOKEN$1.START_EXPR;
};

Tokenizer$1.prototype._is_closing = function (current_token, open_token) {
	return (current_token.type === TOKEN$1.END_BLOCK || current_token.type === TOKEN$1.END_EXPR) &&
		(open_token && (
			(current_token.text === ']' && open_token.text === '[') ||
			(current_token.text === ')' && open_token.text === '(') ||
			(current_token.text === '}' && open_token.text === '{')));
};

Tokenizer$1.prototype._reset = function () {
	in_html_comment = false;
};

Tokenizer$1.prototype._get_next_token = function (previous_token, open_token) { // jshint unused:false
	var token = null;
	this._readWhitespace();
	var c = this._input.peek();

	if (c === null) {
		return this._create_token(TOKEN$1.EOF, '');
	}

	token = token || this._read_string(c);
	token = token || this._read_word(previous_token);
	token = token || this._read_singles(c);
	token = token || this._read_comment(c);
	token = token || this._read_regexp(c, previous_token);
	token = token || this._read_xml(c, previous_token);
	token = token || this._read_non_javascript(c);
	token = token || this._read_punctuation();
	token = token || this._create_token(TOKEN$1.UNKNOWN, this._input.next());

	return token;
};

Tokenizer$1.prototype._read_word = function (previous_token) {
	var resulting_string;
	resulting_string = this.__patterns.identifier.read();
	if (resulting_string !== '') {
		resulting_string = resulting_string.replace(acorn.allLineBreaks, '\n');
		if (!(previous_token.type === TOKEN$1.DOT ||
			(previous_token.type === TOKEN$1.RESERVED && (previous_token.text === 'set' || previous_token.text === 'get'))) &&
			reserved_word_pattern.test(resulting_string)) {
			if (resulting_string === 'in' || resulting_string === 'of') { // hack for 'in' and 'of' operators
				return this._create_token(TOKEN$1.OPERATOR, resulting_string);
			}
			return this._create_token(TOKEN$1.RESERVED, resulting_string);
		}
		return this._create_token(TOKEN$1.WORD, resulting_string);
	}

	resulting_string = this.__patterns.number.read();
	if (resulting_string !== '') {
		return this._create_token(TOKEN$1.WORD, resulting_string);
	}
};

Tokenizer$1.prototype._read_singles = function (c) {
	var token = null;
	if (c === '(' || c === '[') {
		token = this._create_token(TOKEN$1.START_EXPR, c);
	} else if (c === ')' || c === ']') {
		token = this._create_token(TOKEN$1.END_EXPR, c);
	} else if (c === '{') {
		token = this._create_token(TOKEN$1.START_BLOCK, c);
	} else if (c === '}') {
		token = this._create_token(TOKEN$1.END_BLOCK, c);
	} else if (c === ';') {
		token = this._create_token(TOKEN$1.SEMICOLON, c);
	} else if (c === '.' && dot_pattern.test(this._input.peek(1))) {
		token = this._create_token(TOKEN$1.DOT, c);
	} else if (c === ',') {
		token = this._create_token(TOKEN$1.COMMA, c);
	}

	if (token) {
		this._input.next();
	}
	return token;
};

Tokenizer$1.prototype._read_punctuation = function () {
	var resulting_string = this.__patterns.punct.read();

	if (resulting_string !== '') {
		if (resulting_string === '=') {
			return this._create_token(TOKEN$1.EQUALS, resulting_string);
		} else {
			return this._create_token(TOKEN$1.OPERATOR, resulting_string);
		}
	}
};

Tokenizer$1.prototype._read_non_javascript = function (c) {
	var resulting_string = '';

	if (c === '#') {
		if (this._is_first_token()) {
			resulting_string = this.__patterns.shebang.read();

			if (resulting_string) {
				return this._create_token(TOKEN$1.UNKNOWN, resulting_string.trim() + '\n');
			}
		}

		// handles extendscript #includes
		resulting_string = this.__patterns.include.read();

		if (resulting_string) {
			return this._create_token(TOKEN$1.UNKNOWN, resulting_string.trim() + '\n');
		}

		c = this._input.next();

		// Spidermonkey-specific sharp variables for circular references. Considered obsolete.
		var sharp = '#';
		if (this._input.hasNext() && this._input.testChar(digit)) {
			do {
				c = this._input.next();
				sharp += c;
			} while (this._input.hasNext() && c !== '#' && c !== '=');
			if (c === '#'); else if (this._input.peek() === '[' && this._input.peek(1) === ']') {
				sharp += '[]';
				this._input.next();
				this._input.next();
			} else if (this._input.peek() === '{' && this._input.peek(1) === '}') {
				sharp += '{}';
				this._input.next();
				this._input.next();
			}
			return this._create_token(TOKEN$1.WORD, sharp);
		}

		this._input.back();

	} else if (c === '<' && this._is_first_token()) {
		resulting_string = this.__patterns.html_comment_start.read();
		if (resulting_string) {
			while (this._input.hasNext() && !this._input.testChar(acorn.newline)) {
				resulting_string += this._input.next();
			}
			in_html_comment = true;
			return this._create_token(TOKEN$1.COMMENT, resulting_string);
		}
	} else if (in_html_comment && c === '-') {
		resulting_string = this.__patterns.html_comment_end.read();
		if (resulting_string) {
			in_html_comment = false;
			return this._create_token(TOKEN$1.COMMENT, resulting_string);
		}
	}

	return null;
};

Tokenizer$1.prototype._read_comment = function (c) {
	var token = null;
	if (c === '/') {
		var comment = '';
		if (this._input.peek(1) === '*') {
			// peek for comment /* ... */
			comment = this.__patterns.block_comment.read();
			var directives = directives_core.get_directives(comment);
			if (directives && directives.ignore === 'start') {
				comment += directives_core.readIgnored(this._input);
			}
			comment = comment.replace(acorn.allLineBreaks, '\n');
			token = this._create_token(TOKEN$1.BLOCK_COMMENT, comment);
			token.directives = directives;
		} else if (this._input.peek(1) === '/') {
			// peek for comment // ...
			comment = this.__patterns.comment.read();
			token = this._create_token(TOKEN$1.COMMENT, comment);
		}
	}
	return token;
};

Tokenizer$1.prototype._read_string = function (c) {
	if (c === '`' || c === "'" || c === '"') {
		var resulting_string = this._input.next();
		this.has_char_escapes = false;

		if (c === '`') {
			resulting_string += this._read_string_recursive('`', true, '${');
		} else {
			resulting_string += this._read_string_recursive(c);
		}

		if (this.has_char_escapes && this._options.unescape_strings) {
			resulting_string = unescape_string(resulting_string);
		}

		if (this._input.peek() === c) {
			resulting_string += this._input.next();
		}

		resulting_string = resulting_string.replace(acorn.allLineBreaks, '\n');

		return this._create_token(TOKEN$1.STRING, resulting_string);
	}

	return null;
};

Tokenizer$1.prototype._allow_regexp_or_xml = function (previous_token) {
	// regex and xml can only appear in specific locations during parsing
	return (previous_token.type === TOKEN$1.RESERVED && in_array(previous_token.text, ['return', 'case', 'throw', 'else', 'do', 'typeof', 'yield'])) ||
		(previous_token.type === TOKEN$1.END_EXPR && previous_token.text === ')' &&
			previous_token.opened.previous.type === TOKEN$1.RESERVED && in_array(previous_token.opened.previous.text, ['if', 'while', 'for'])) ||
		(in_array(previous_token.type, [TOKEN$1.COMMENT, TOKEN$1.START_EXPR, TOKEN$1.START_BLOCK, TOKEN$1.START,
		TOKEN$1.END_BLOCK, TOKEN$1.OPERATOR, TOKEN$1.EQUALS, TOKEN$1.EOF, TOKEN$1.SEMICOLON, TOKEN$1.COMMA
		]));
};

Tokenizer$1.prototype._read_regexp = function (c, previous_token) {

	if (c === '/' && this._allow_regexp_or_xml(previous_token)) {
		// handle regexp
		//
		var resulting_string = this._input.next();
		var esc = false;

		var in_char_class = false;
		while (this._input.hasNext() &&
			((esc || in_char_class || this._input.peek() !== c) &&
				!this._input.testChar(acorn.newline))) {
			resulting_string += this._input.peek();
			if (!esc) {
				esc = this._input.peek() === '\\';
				if (this._input.peek() === '[') {
					in_char_class = true;
				} else if (this._input.peek() === ']') {
					in_char_class = false;
				}
			} else {
				esc = false;
			}
			this._input.next();
		}

		if (this._input.peek() === c) {
			resulting_string += this._input.next();

			// regexps may have modifiers /regexp/MOD , so fetch those, too
			// Only [gim] are valid, but if the user puts in garbage, do what we can to take it.
			resulting_string += this._input.read(acorn.identifier);
		}
		return this._create_token(TOKEN$1.STRING, resulting_string);
	}
	return null;
};

Tokenizer$1.prototype._read_xml = function (c, previous_token) {

	if (this._options.e4x && c === "<" && this._allow_regexp_or_xml(previous_token)) {
		var xmlStr = '';
		var match = this.__patterns.xml.read_match();
		// handle e4x xml literals
		//
		if (match) {
			// Trim root tag to attempt to
			var rootTag = match[2].replace(/^{\s+/, '{').replace(/\s+}$/, '}');
			var isCurlyRoot = rootTag.indexOf('{') === 0;
			var depth = 0;
			while (match) {
				var isEndTag = !!match[1];
				var tagName = match[2];
				var isSingletonTag = (!!match[match.length - 1]) || (tagName.slice(0, 8) === "![CDATA[");
				if (!isSingletonTag &&
					(tagName === rootTag || (isCurlyRoot && tagName.replace(/^{\s+/, '{').replace(/\s+}$/, '}')))) {
					if (isEndTag) {
						--depth;
					} else {
						++depth;
					}
				}
				xmlStr += match[0];
				if (depth <= 0) {
					break;
				}
				match = this.__patterns.xml.read_match();
			}
			// if we didn't close correctly, keep unformatted.
			if (!match) {
				xmlStr += this._input.match(/[\s\S]*/g)[0];
			}
			xmlStr = xmlStr.replace(acorn.allLineBreaks, '\n');
			return this._create_token(TOKEN$1.STRING, xmlStr);
		}
	}

	return null;
};

function unescape_string(s) {
	// You think that a regex would work for this
	// return s.replace(/\\x([0-9a-f]{2})/gi, function(match, val) {
	//         return String.fromCharCode(parseInt(val, 16));
	//     })
	// However, dealing with '\xff', '\\xff', '\\\xff' makes this more fun.
	var out = '',
		escaped = 0;

	var input_scan = new InputScanner$2(s);
	var matched = null;

	while (input_scan.hasNext()) {
		// Keep any whitespace, non-slash characters
		// also keep slash pairs.
		matched = input_scan.match(/([\s]|[^\\]|\\\\)+/g);

		if (matched) {
			out += matched[0];
		}

		if (input_scan.peek() === '\\') {
			input_scan.next();
			if (input_scan.peek() === 'x') {
				matched = input_scan.match(/x([0-9A-Fa-f]{2})/g);
			} else if (input_scan.peek() === 'u') {
				matched = input_scan.match(/u([0-9A-Fa-f]{4})/g);
			} else {
				out += '\\';
				if (input_scan.hasNext()) {
					out += input_scan.next();
				}
				continue;
			}

			// If there's some error decoding, return the original string
			if (!matched) {
				return s;
			}

			escaped = parseInt(matched[1], 16);

			if (escaped > 0x7e && escaped <= 0xff && matched[0].indexOf('x') === 0) {
				// we bail out on \x7f..\xff,
				// leaving whole string escaped,
				// as it's probably completely binary
				return s;
			} else if (escaped >= 0x00 && escaped < 0x20) {
				// leave 0x00...0x1f escaped
				out += '\\' + matched[0];
				continue;
			} else if (escaped === 0x22 || escaped === 0x27 || escaped === 0x5c) {
				// single-quote, apostrophe, backslash - escape these
				out += '\\' + String.fromCharCode(escaped);
			} else {
				out += String.fromCharCode(escaped);
			}
		}
	}

	return out;
}

// handle string
//
Tokenizer$1.prototype._read_string_recursive = function (delimiter, allow_unescaped_newlines, start_sub) {
	var current_char;
	var pattern;
	if (delimiter === '\'') {
		pattern = this.__patterns.single_quote;
	} else if (delimiter === '"') {
		pattern = this.__patterns.double_quote;
	} else if (delimiter === '`') {
		pattern = this.__patterns.template_text;
	} else if (delimiter === '}') {
		pattern = this.__patterns.template_expression;
	}

	var resulting_string = pattern.read();
	var next = '';
	while (this._input.hasNext()) {
		next = this._input.next();
		if (next === delimiter ||
			(!allow_unescaped_newlines && acorn.newline.test(next))) {
			this._input.back();
			break;
		} else if (next === '\\' && this._input.hasNext()) {
			current_char = this._input.peek();

			if (current_char === 'x' || current_char === 'u') {
				this.has_char_escapes = true;
			} else if (current_char === '\r' && this._input.peek(1) === '\n') {
				this._input.next();
			}
			next += this._input.next();
		} else if (start_sub) {
			if (start_sub === '${' && next === '$' && this._input.peek() === '{') {
				next += this._input.next();
			}

			if (start_sub === next) {
				if (delimiter === '`') {
					next += this._read_string_recursive('}', allow_unescaped_newlines, '`');
				} else {
					next += this._read_string_recursive('`', allow_unescaped_newlines, '${');
				}
				if (this._input.hasNext()) {
					next += this._input.next();
				}
			}
		}
		next += pattern.read();
		resulting_string += next;
	}

	return resulting_string;
};

var Tokenizer_1$1 = Tokenizer$1;
var TOKEN_1$1 = TOKEN$1;
var positionable_operators_1 = positionable_operators.slice();
var line_starters_1 = line_starters.slice();

var tokenizer$1 = {
	Tokenizer: Tokenizer_1$1,
	TOKEN: TOKEN_1$1,
	positionable_operators: positionable_operators_1,
	line_starters: line_starters_1
};

var Output$1 = output.Output;
var Token$2 = token.Token;

var Options$2 = options$1.Options;
var Tokenizer$2 = tokenizer$1.Tokenizer;
var line_starters$1 = tokenizer$1.line_starters;
var positionable_operators$1 = tokenizer$1.positionable_operators;
var TOKEN$2 = tokenizer$1.TOKEN;


function in_array$1(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$2.RESERVED && token.text === word;
}

function reserved_array(token, words) {
	return token && token.type === TOKEN$2.RESERVED && in_array$1(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$1 = ['before-newline', 'after-newline', 'preserve-newline'];

// Generate map from array
var OPERATOR_POSITION = generateMapFromStrings(validPositionValues$1);

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$1(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$2(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$2(TOKEN$2.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,
		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
		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$1(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$2(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$2.START_EXPR) {
		this.handle_start_expr(current_token);
	} else if (current_token.type === TOKEN$2.END_EXPR) {
		this.handle_end_expr(current_token);
	} else if (current_token.type === TOKEN$2.START_BLOCK) {
		this.handle_start_block(current_token);
	} else if (current_token.type === TOKEN$2.END_BLOCK) {
		this.handle_end_block(current_token);
	} else if (current_token.type === TOKEN$2.WORD) {
		this.handle_word(current_token);
	} else if (current_token.type === TOKEN$2.RESERVED) {
		this.handle_word(current_token);
	} else if (current_token.type === TOKEN$2.SEMICOLON) {
		this.handle_semicolon(current_token);
	} else if (current_token.type === TOKEN$2.STRING) {
		this.handle_string(current_token);
	} else if (current_token.type === TOKEN$2.EQUALS) {
		this.handle_equals(current_token);
	} else if (current_token.type === TOKEN$2.OPERATOR) {
		this.handle_operator(current_token);
	} else if (current_token.type === TOKEN$2.COMMA) {
		this.handle_comma(current_token);
	} else if (current_token.type === TOKEN$2.BLOCK_COMMENT) {
		this.handle_block_comment(current_token, preserve_statement_flags);
	} else if (current_token.type === TOKEN$2.COMMENT) {
		this.handle_comment(current_token, preserve_statement_flags);
	} else if (current_token.type === TOKEN$2.DOT) {
		this.handle_dot(current_token);
	} else if (current_token.type === TOKEN$2.EOF) {
		this.handle_eof(current_token);
	} else if (current_token.type === TOKEN$2.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$1(this._flags.last_token.text, positionable_operators$1) ||
		in_array$1(current_token.text, positionable_operators$1);

	if (operatorLogicApplies) {
		var shouldPrintOperatorNewline = (
			in_array$1(this._flags.last_token.text, positionable_operators$1) &&
			in_array$1(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)
		) ||
			in_array$1(current_token.text, positionable_operators$1);
		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$2.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$2.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$2.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$2.END_EXPR && (this._previous_flags.mode === MODE.ForInitializer || this._previous_flags.mode === MODE.Conditional));
	start = start || (this._flags.last_token.type === TOKEN$2.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$2.WORD && current_token.type !== TOKEN$2.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$2.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$1)) {
				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$1(this._flags.last_token.type, [TOKEN$2.START_EXPR, TOKEN$2.END_EXPR, TOKEN$2.WORD, TOKEN$2.OPERATOR])) {
			this._output.space_before_token = true;
		}
	} else {
		if (this._flags.last_token.type === TOKEN$2.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$1(this._flags.last_token.text, ['if', 'while'])) {
				this._output.space_before_token = this._options.space_before_conditional;
				next_mode = MODE.Conditional;
			} else if (in_array$1(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$1(this._flags.last_token.text, line_starters$1) || this._flags.last_token.text === 'catch') {
				this._output.space_before_token = true;
			}
		} else if (this._flags.last_token.type === TOKEN$2.EQUALS || this._flags.last_token.type === TOKEN$2.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$2.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 {
			// 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$2.RESERVED && (this._flags.last_word === 'function' || this._flags.last_word === 'typeof')) ||
			(this._flags.last_token.text === '*' &&
				(in_array$1(this._last_last_text, ['function', 'yield']) ||
					(this._flags.mode === MODE.ObjectLiteral && in_array$1(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$2.START_BLOCK) {
		this.print_newline();
	} else if (this._flags.last_token.type === TOKEN$2.END_EXPR || this._flags.last_token.type === TOKEN$2.START_EXPR || this._flags.last_token.type === TOKEN$2.END_BLOCK || this._flags.last_token.text === '.' || this._flags.last_token.type === TOKEN$2.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$2.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$2.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$1(second_token.text, [':', ',']) && in_array$1(next_token.type, [TOKEN$2.STRING, TOKEN$2.WORD, TOKEN$2.RESERVED])) ||
		(in_array$1(next_token.text, ['get', 'set', '...']) && in_array$1(second_token.type, [TOKEN$2.WORD, TOKEN$2.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$1(this._last_last_text, ['class', 'interface'])) {
			this.set_mode(MODE.ObjectLiteral);
		} else {
			this.set_mode(MODE.BlockStatement);
		}
	} else if (this._flags.last_token.type === TOKEN$2.OPERATOR && this._flags.last_token.text === '=>') {
		// arrow function: (param1, paramN) => { statements }
		this.set_mode(MODE.BlockStatement);
	} else if (in_array$1(this._flags.last_token.type, [TOKEN$2.EQUALS, TOKEN$2.START_EXPR, TOKEN$2.COMMA, TOKEN$2.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);
	}

	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$2.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$2.EOF &&
			!(check_token.type === TOKEN$2.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$2.OPERATOR &&
			(empty_anonymous_function ||
				this._flags.last_token.type === TOKEN$2.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$2.START_EXPR || this._flags.last_token.type === TOKEN$2.COMMA)) {
			if (this._flags.last_token.type === TOKEN$2.COMMA || this._options.space_in_paren) {
				this._output.space_before_token = true;
			}

			if (this._flags.last_token.type === TOKEN$2.COMMA || (this._flags.last_token.type === TOKEN$2.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$2.OPERATOR && this._flags.last_token.type !== TOKEN$2.START_EXPR) {
			if (this._flags.last_token.type === TOKEN$2.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$2.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$2.RESERVED) {
		if (in_array$1(current_token.text, ['set', 'get']) && this._flags.mode !== MODE.ObjectLiteral) {
			current_token.type = TOKEN$2.WORD;
		} else if (current_token.text === 'import' && this._tokens.peek().text === '(') {
			current_token.type = TOKEN$2.WORD;
		} else if (in_array$1(current_token.text, ['as', 'from']) && !this._flags.import_block) {
			current_token.type = TOKEN$2.WORD;
		} else if (this._flags.mode === MODE.ObjectLiteral) {
			var next_token = this._tokens.peek();
			if (next_token.text === ':') {
				current_token.type = TOKEN$2.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$2.WORD) {
			this._flags.declaration_statement = true;
		}
	} else if (current_token.newlines && !is_expression(this._flags.mode) &&
		(this._flags.last_token.type !== TOKEN$2.OPERATOR || (this._flags.last_token.text === '--' || this._flags.last_token.text === '++')) &&
		this._flags.last_token.type !== TOKEN$2.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.last_token.type !== TOKEN$2.END_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$2.COMMA || this._flags.last_token.type === TOKEN$2.START_EXPR || this._flags.last_token.type === TOKEN$2.EQUALS || this._flags.last_token.type === TOKEN$2.OPERATOR) {
		if (!this.start_of_object_property()) {
			this.allow_wrap_or_preserved_newline(current_token);
		}
	}

	if (reserved_word(current_token, 'function')) {
		if (in_array$1(this._flags.last_token.text, ['}', ';']) ||
			(this._output.just_added_newline() && !(in_array$1(this._flags.last_token.text, ['(', '[', '{', ':', '=', ',']) || this._flags.last_token.type === TOKEN$2.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$2.RESERVED || this._flags.last_token.type === TOKEN$2.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$2.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))); 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$2.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$2.SEMICOLON && this._flags.mode === MODE.BlockStatement) {
		// TODO: Should this be for STATEMENT as well?
		prefix = 'NEWLINE';
	} else if (this._flags.last_token.type === TOKEN$2.SEMICOLON && is_expression(this._flags.mode)) {
		prefix = 'SPACE';
	} else if (this._flags.last_token.type === TOKEN$2.STRING) {
		prefix = 'NEWLINE';
	} else if (this._flags.last_token.type === TOKEN$2.RESERVED || this._flags.last_token.type === TOKEN$2.WORD ||
		(this._flags.last_token.text === '*' &&
			(in_array$1(this._last_last_text, ['function', 'yield']) ||
				(this._flags.mode === MODE.ObjectLiteral && in_array$1(this._last_last_text, ['{', ',']))))) {
		prefix = 'SPACE';
	} else if (this._flags.last_token.type === TOKEN$2.START_BLOCK) {
		if (this._flags.inline_frame) {
			prefix = 'SPACE';
		} else {
			prefix = 'NEWLINE';
		}
	} else if (this._flags.last_token.type === TOKEN$2.END_EXPR) {
		this._output.space_before_token = true;
		prefix = 'NEWLINE';
	}

	if (reserved_array(current_token, line_starters$1) && 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$2.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$2.END_EXPR) {
			if ((this._flags.last_token.type !== TOKEN$2.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$1) && 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$2.WORD || current_token.previous.type === TOKEN$2.RESERVED)) {
		this._output.space_before_token = true;
	}
	this.print_token(current_token);
	this._flags.last_word = current_token.text;

	if (current_token.type === TOKEN$2.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 (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$2.RESERVED || this._flags.last_token.type === TOKEN$2.WORD || this._flags.inline_frame) {
			this._output.space_before_token = true;
		} else if (this._flags.last_token.type === TOKEN$2.COMMA || this._flags.last_token.type === TOKEN$2.START_EXPR || this._flags.last_token.type === TOKEN$2.EQUALS || this._flags.last_token.type === TOKEN$2.OPERATOR) {
			if (!this.start_of_object_property()) {
				this.allow_wrap_or_preserved_newline(current_token);
			}
		} else {
			this.print_newline();
		}
	}
	this.print_token(current_token);
};

Beautifier.prototype.handle_equals = function (current_token) {
	if (this.start_of_statement(current_token)); 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$1(this._flags.last_token.type, [TOKEN$2.START_BLOCK, TOKEN$2.COMMA, TOKEN$2.END_BLOCK, TOKEN$2.SEMICOLON]))
		);
	var isUnary = in_array$1(current_token.text, ['-', '+']) && (
		in_array$1(this._flags.last_token.type, [TOKEN$2.START_BLOCK, TOKEN$2.START_EXPR, TOKEN$2.EQUALS, TOKEN$2.OPERATOR]) ||
		in_array$1(this._flags.last_token.text, line_starters$1) ||
		this._flags.last_token.text === ','
	);

	if (this.start_of_statement(current_token)); else {
		var preserve_statement_flags = !isGeneratorAsterisk;
		this.handle_whitespace_and_comments(current_token, preserve_statement_flags);
	}

	if (reserved_array(this._flags.last_token, special_words)) {
		// "return" had a special handling in TK_WORD. Now we need to return the favor
		this._output.space_before_token = true;
		this.print_token(current_token);
		return;
	}

	// hack for actionscript's import .*;
	if (current_token.text === '*' && this._flags.last_token.type === TOKEN$2.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$2.OPERATOR && in_array$1(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$2.START_BLOCK) {
			this.indent();
			this.print_newline();
		} else {
			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$1(current_token.text, positionable_operators$1)) {
		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$1(next_token.type, [TOKEN$2.WORD, TOKEN$2.RESERVED]);
	} else if (current_token.text === '...') {
		this.allow_wrap_or_preserved_newline(current_token);
		space_before = this._flags.last_token.type === TOKEN$2.START_BLOCK;
		space_after = false;
	} else if (in_array$1(current_token.text, ['--', '++', '!', '~']) || isUnary) {
		// unary operators (and binary +/- pretending to be unary) special cases
		if (this._flags.last_token.type === TOKEN$2.COMMA || this._flags.last_token.type === TOKEN$2.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 === '++')) {
			this.print_newline(false, true);
		}

		if (this._flags.last_token.text === ';' && is_expression(this._flags.mode)) {
			// for (;; ++i)
			//        ^^^
			space_before = true;
		}

		if (this._flags.last_token.type === TOKEN$2.RESERVED) {
			space_before = true;
		} else if (this._flags.last_token.type === TOKEN$2.END_EXPR) {
			space_before = !(this._flags.last_token.text === ']' && (current_token.text === '--' || current_token.text === '++'));
		} else if (this._flags.last_token.type === TOKEN$2.OPERATOR) {
			// a++ + ++b;
			// a - -b
			space_before = in_array$1(current_token.text, ['--', '-', '++', '+']) && in_array$1(this._flags.last_token.text, ['--', '-', '++', '+']);
			// + and - are not unary when preceeded by -- or ++ operator
			// a-- + b
			// a * +b
			// a - -b
			if (in_array$1(current_token.text, ['+', '-']) && in_array$1(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)); else {
		this.handle_whitespace_and_comments(current_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);
};

var Beautifier_1 = Beautifier;

var beautifier = {
	Beautifier: Beautifier_1
};

var Beautifier$1 = beautifier.Beautifier,
	Options$3 = options$1.Options;

function js_beautify(js_source_text, options) {
	var beautifier = new Beautifier$1(js_source_text, options);
	return beautifier.beautify();
}

var javascript = js_beautify;
var defaultOptions = function () {
	return new Options$3();
};
javascript.defaultOptions = defaultOptions;

export default javascript;
export { defaultOptions };
//# sourceMappingURL=index.js.map
