var Output = __webpack_require__(2).Output; var Token = __webpack_require__(3).Token; var acorn = __webpack_require__(4); var Options = __webpack_require__(5).Options; var Tokenizer = __webpack_require__(7).Tokenizer; var line_starters = __webpack_require__(7).line_starters; var positionable_operators = __webpack_require__(7).positionable_operators; var TOKEN = __webpack_require__(7).TOKEN;
function in_array(what, arr) { return arr.indexOf(what) !== -1;
}
function ltrim(s) { return s.replace(/^\s+/g, '');
}
function generateMapFromStrings(list) { var result = {}; for (var x = 0; x < list.length; x++) { // make the mapped names underscored instead of dash
result[list[x].replace(/-/g, '_')] = list[x];
} return result;
}
function reserved_array(token, words) { return token && token.type === TOKEN.RESERVED && in_array(token.text, words);
} // Unsure of what they mean, but they work. Worth cleaning up in future. var special_words = ['case', 'return', 'do', 'if', 'throw', 'else', 'await', 'break', 'continue', 'async'];
var validPositionValues = ['before-newline', 'after-newline', 'preserve-newline'];
// Generate map from array var OPERATOR_POSITION = generateMapFromStrings(validPositionValues);
var OPERATOR_POSITION_BEFORE_OR_PRESERVE = [OPERATOR_POSITION.before_newline, OPERATOR_POSITION.preserve_newline];
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.
// remove one indent from each line inside this section
output.remove_indent(frame.start_line_index);
}
// we could use just string.split, but // IE doesn't like returning empty strings function split_linebreaks(s) { //return s.split(/\x0d\x0a|\x0a/);
s = s.replace(acorn.allLineBreaks, '\n'); var out = [],
idx = s.indexOf("\n"); while (idx !== -1) {
out.push(s.substring(0, idx));
s = s.substring(idx + 1);
idx = s.indexOf("\n");
} if (s.length) {
out.push(s);
} return out;
}
function is_array(mode) { return mode === MODE.ArrayLiteral;
}
function is_expression(mode) { return in_array(mode, [MODE.Expression, MODE.ForInitializer, MODE.Conditional]);
}
function all_lines_start_with(lines, c) { for (var i = 0; i < lines.length; i++) { var line = lines[i].trim(); if (line.charAt(0) !== c) { returnfalse;
}
} returntrue;
}
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) { returnfalse;
}
} returntrue;
}
this._flag_store = null; this._options = new Options(options);
}
Beautifier.prototype.create_flags = function(flags_base, mode) { var next_indent_level = 0; if (flags_base) {
next_indent_level = flags_base.indentation_level; if (!this._output.just_added_newline() &&
flags_base.line_indent_level > next_indent_level) {
next_indent_level = flags_base.line_indent_level;
}
}
var next_flags = {
mode: mode,
parent: flags_base,
last_token: flags_base ? flags_base.last_token : new Token(TOKEN.START_BLOCK, ''), // last token text
last_word: flags_base ? flags_base.last_word : '', // last TOKEN.WORD passed
declaration_statement: false,
declaration_assignment: false,
multiline_frame: false,
inline_frame: false,
if_block: false,
else_block: false,
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(this._options, baseIndentString);
// If testing the ignore directive, start with output disable set to true this._output.raw = this._options.test_output_raw;
// Stack of parsing/formatting states, including MODE. // We tokenize, parse, and output in an almost purely a forward-only stream of token input // and formatted output. This makes the beautifier less accurate than full parsers // but also far more tolerant of syntax errors. // // For example, the default mode is MODE.BlockStatement. If we see a '{' we push a new frame of type // MODE.BlockStatement on the the stack, even though it could be object literal. If we later // encounter a ":", we'll switch to to MODE.ObjectLiteral. If we then see a ";", // most full parsers would die, but the beautifier gracefully falls back to // MODE.BlockStatement and continues on. this._flag_store = []; this.set_mode(MODE.BlockStatement); var tokenizer = new Tokenizer(source_text, this._options); this._tokens = tokenizer.tokenize(); return source_text;
};
Beautifier.prototype.beautify = function() { // if disabled, return the input unchanged. if (this._options.disabled) { returnthis._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);
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'];
if (shouldPreserveOrForce) { this.print_newline(false, true);
} elseif (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_token = function(current_token) { if (this._output.raw) { this._output.add_raw_token(current_token); return;
}
if (this._options.comma_first && current_token.previous && current_token.previous.type === TOKEN.COMMA && this._output.just_added_newline()) { if (this._output.previous_line.last() === ',') { var popped = this._output.previous_line.pop(); // if the comma was already at the start of the line, // pull back onto that line and reprint the indentation if (this._output.previous_line.is_empty()) { this._output.previous_line.push(popped); this._output.trim(true); this._output.current_line.pop(); this._output.trim();
}
// add the comma in front of the next token this.print_token_line_indentation(current_token); this._output.add_token(','); this._output.space_before_token = true;
}
}
// 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']));
} returntrue;
} returnfalse;
};
Beautifier.prototype.handle_start_expr = function(current_token) { // The conditional starts the statement if appropriate. if (!this.start_of_statement(current_token)) { this.handle_whitespace_and_comments(current_token);
}
var next_mode = MODE.Expression; if (current_token.text === '[') {
if (this._flags.last_token.type === TOKEN.WORD || this._flags.last_token.text === ')') { // this is array index specifier, break immediately // a[x], fn()[x] if (reserved_array(this._flags.last_token, line_starters)) { this._output.space_before_token = true;
} this.print_token(current_token); this.set_mode(next_mode); this.indent(); if (this._options.space_in_paren) { this._output.space_before_token = true;
} return;
}
next_mode = MODE.ArrayLiteral; if (is_array(this._flags.mode)) { if (this._flags.last_token.text === '[' ||
(this._flags.last_token.text === ',' && (this._last_last_text === ']' || this._last_last_text === '}'))) { // ], [ goes to new line // }, [ goes to new line if (!this._options.keep_array_indentation) { this.print_newline();
}
}
}
if (!in_array(this._flags.last_token.type, [TOKEN.START_EXPR, TOKEN.END_EXPR, TOKEN.WORD, TOKEN.OPERATOR])) { this._output.space_before_token = true;
}
} else { if (this._flags.last_token.type === TOKEN.RESERVED) { if (this._flags.last_token.text === 'for') { this._output.space_before_token = this._options.space_before_conditional;
next_mode = MODE.ForInitializer;
} elseif (in_array(this._flags.last_token.text, ['if', 'while'])) { this._output.space_before_token = this._options.space_before_conditional;
next_mode = MODE.Conditional;
} elseif (in_array(this._flags.last_word, ['await', 'async'])) { // Should be a space between await and an IIFE, or async and an arrow function this._output.space_before_token = true;
} elseif (this._flags.last_token.text === 'import' && current_token.whitespace_before === '') { this._output.space_before_token = false;
} elseif (in_array(this._flags.last_token.text, line_starters) || this._flags.last_token.text === 'catch') { this._output.space_before_token = true;
}
} elseif (this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) { // Support of this kind of newline preservation. // a = (b && // (c || d)); if (!this.start_of_object_property()) { this.allow_wrap_or_preserved_newline(current_token);
}
} elseif (this._flags.last_token.type === TOKEN.WORD) { this._output.space_before_token = false;
// function name() vs function name () // function* name() vs function* name () // async name() vs async name () // In ES6, you can also define the method properties of an object // var obj = {a: function() {}} // It can be abbreviated // var obj = {a() {}} // var obj = { a() {}} vs var obj = { a () {}} // var obj = { * a() {}} vs var obj = { * a () {}} var peek_back_two = this._tokens.peek(-3); if (this._options.space_after_named_function && peek_back_two) { // peek starts at next character so -1 is current token var peek_back_three = this._tokens.peek(-4); if (reserved_array(peek_back_two, ['async', 'function']) ||
(peek_back_two.text === '*' && reserved_array(peek_back_three, ['async', 'function']))) { this._output.space_before_token = true;
} elseif (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.RESERVED && (this._flags.last_word === 'function' || this._flags.last_word === 'typeof')) ||
(this._flags.last_token.text === '*' &&
(in_array(this._last_last_text, ['function', 'yield']) ||
(this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ',']))))) { this._output.space_before_token = this._options.space_after_anon_function;
}
}
if (this._flags.last_token.text === ';' || this._flags.last_token.type === TOKEN.START_BLOCK) { this.print_newline();
} elseif (this._flags.last_token.type === TOKEN.END_EXPR || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.END_BLOCK || this._flags.last_token.text === '.' || this._flags.last_token.type === TOKEN.COMMA) { // do nothing on (( and )( and ][ and ]( and .( // TODO: Consider whether forcing this is required. Review failing tests when removed. this.allow_wrap_or_preserved_newline(current_token, current_token.newlines);
}
this.print_token(current_token); this.set_mode(next_mode); if (this._options.space_in_paren) { this._output.space_before_token = true;
}
// In all cases, if we newline while inside an expression it should be indented. this.indent();
};
Beautifier.prototype.handle_end_expr = function(current_token) { // statements inside expressions are not valid syntax, but... // statements must all be closed when their container closes while (this._flags.mode === MODE.Statement) { this.restore_mode();
}
// Check if this is should be treated as a ObjectLiteral var next_token = this._tokens.peek(); var second_token = this._tokens.peek(1); if (this._flags.last_word === 'switch' && this._flags.last_token.type === TOKEN.END_EXPR) { this.set_mode(MODE.BlockStatement); this._flags.in_case_statement = true;
} elseif (this._flags.case_body) { this.set_mode(MODE.BlockStatement);
} elseif (second_token && (
(in_array(second_token.text, [':', ',']) && in_array(next_token.type, [TOKEN.STRING, TOKEN.WORD, TOKEN.RESERVED])) ||
(in_array(next_token.text, ['get', 'set', '...']) && in_array(second_token.type, [TOKEN.WORD, TOKEN.RESERVED]))
)) { // We don't support TypeScript,but we didn't break it for a very long time. // We'll try to keep not breaking it. if (!in_array(this._last_last_text, ['class', 'interface'])) { this.set_mode(MODE.ObjectLiteral);
} else { this.set_mode(MODE.BlockStatement);
}
} elseif (this._flags.last_token.type === TOKEN.OPERATOR && this._flags.last_token.text === '=>') { // arrow function: (param1, paramN) => { statements } this.set_mode(MODE.BlockStatement);
} elseif (in_array(this._flags.last_token.type, [TOKEN.EQUALS, TOKEN.START_EXPR, TOKEN.COMMA, TOKEN.OPERATOR]) ||
reserved_array(this._flags.last_token, ['return', 'throw', 'import', 'default'])
) { // Detecting shorthand function syntax is difficult by scanning forward, // so check the surrounding context. // If the block is being returned, imported, export default, passed as arg, // assigned with = or assigned in a nested object, treat as an ObjectLiteral. this.set_mode(MODE.ObjectLiteral);
} else { this.set_mode(MODE.BlockStatement);
}
var empty_braces = !next_token.comments_before && next_token.text === '}'; var empty_anonymous_function = empty_braces && this._flags.last_word === 'function' && this._flags.last_token.type === TOKEN.END_EXPR;
if (this._options.brace_preserve_inline) // check for inline, set inline_frame if so
{ // search forward for a newline wanted inside this block var index = 0; var check_token = null; this._flags.inline_frame = true; do {
index += 1;
check_token = this._tokens.peek(index - 1); if (check_token.newlines) { this._flags.inline_frame = false; break;
}
} while (check_token.type !== TOKEN.EOF &&
!(check_token.type === TOKEN.END_BLOCK && check_token.opened === current_token));
}
// Except for specific cases, open braces are followed by a new line. if (!empty_braces && !(this._options.brace_preserve_inline && this._flags.inline_frame)) { this.print_newline();
}
};
Beautifier.prototype.handle_end_block = function(current_token) { // statements must all be closed when their container closes this.handle_whitespace_and_comments(current_token);
while (this._flags.mode === MODE.Statement) { this.restore_mode();
}
var empty_braces = this._flags.last_token.type === TOKEN.START_BLOCK;
if (this._flags.inline_frame && !empty_braces) { // try inline_frame (only set if this._options.braces-preserve-inline) first this._output.space_before_token = true;
} elseif (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;
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.END_BLOCK && (this._flags.case_body || this._options.jslint_happy)) { // switch cases following one another this.deindent();
} this._flags.case_body = 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.RESERVED || this._flags.last_token.type === TOKEN.WORD || this._flags.inline_frame) { this._output.space_before_token = true;
} elseif (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) { if (!this.start_of_object_property()) { this.allow_wrap_or_preserved_newline(current_token);
}
} else { this.print_newline();
}
} this.print_token(current_token);
};
Beautifier.prototype.handle_equals = function(current_token) { if (this.start_of_statement(current_token)) { // The conditional starts the statement if appropriate.
} else { this.handle_whitespace_and_comments(current_token);
}
if (this._flags.declaration_statement) { // just got an '=' in a var-line, different formatting/line-breaking, etc will now be done this._flags.declaration_assignment = true;
} this._output.space_before_token = true; this.print_token(current_token); this._output.space_before_token = true;
};
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);
} elseif (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);
}
} elseif (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();
}
} elseif (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);
}
};
if (this.start_of_statement(current_token)) { // The conditional starts the statement if appropriate.
} else { var preserve_statement_flags = !isGeneratorAsterisk; this.handle_whitespace_and_comments(current_token, preserve_statement_flags);
}
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.DOT) { this.print_token(current_token); return;
}
if (current_token.text === '::') { // no spaces around exotic namespacing syntax operator this.print_token(current_token); return;
}
// Allow line wrapping between operators when operator_position is // set to before or preserve if (this._flags.last_token.type === TOKEN.OPERATOR && in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)) { this.allow_wrap_or_preserved_newline(current_token);
}
if (current_token.text === ':' && this._flags.in_case) { this.print_token(current_token);
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;
}
} elseif (current_token.text === '?') { this._flags.ternary_depth += 1;
}
// let's handle the operator_position option prior to any conflicting logic if (!isUnary && !isGeneratorAsterisk && this._options.preserve_newlines && in_array(current_token.text, positionable_operators)) { var isColon = current_token.text === ':'; var isTernaryColon = (isColon && in_ternary); var isOtherColon = (isColon && !in_ternary);
switch (this._options.operator_position) { case OPERATOR_POSITION.before_newline: // if the current token is : and it's not a ternary statement then we set space_before to false this._output.space_before_token = !isOtherColon;
this.print_token(current_token);
if (!isColon || isTernaryColon) { this.allow_wrap_or_preserved_newline(current_token);
}
this._output.space_before_token = true; return;
case OPERATOR_POSITION.after_newline: // if the current token is anything but colon, or (via deduction) it's a colon and in a ternary statement, // then print a newline.
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);
// 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.RESERVED) {
space_before = true;
} elseif (this._flags.last_token.type === TOKEN.END_EXPR) {
space_before = !(this._flags.last_token.text === ']' && (current_token.text === '--' || current_token.text === '++'));
} elseif (this._flags.last_token.type === TOKEN.OPERATOR) { // a++ + ++b; // a - -b
space_before = in_array(current_token.text, ['--', '-', '++', '+']) && in_array(this._flags.last_token.text, ['--', '-', '++', '+']); // + and - are not unary when preceeded by -- or ++ operator // a-- + b // a * +b // a - -b if (in_array(current_token.text, ['+', '-']) && in_array(this._flags.last_token.text, ['--', '++'])) {
space_after = true;
}
}
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;
}
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);
Beautifier.prototype.handle_dot = function(current_token) { if (this.start_of_statement(current_token)) { // The conditional starts the statement if appropriate.
} else { this.handle_whitespace_and_comments(current_token, true);
}
if (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();
}
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.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);
}
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())) { returnfalse;
}
// if raw output is enabled, don't print additional newlines, // but still return True as though you had if (!this.raw) { this.__add_outputline();
} returntrue;
};
// 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();
}
// 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); returntrue;
}
this.current_line.set_indent(); returnfalse;
};
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;
};
// 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;
}
"use strict"; /* jshint node: true, curly: false */ // Parts of this section of code is taken from acorn. // // Acorn was written by Marijn Haverbeke and released under an MIT // license. The Unicode regexps (for identifiers and whitespace) were // taken from [Esprima](http://esprima.org) by Ariya Hidayat. // // Git repositories for Acorn are available at // // http://marijnhaverbeke.nl/git/acorn // https://github.com/marijnh/acorn.git
// ## Character categories
// acorn used char codes to squeeze the last bit of performance out // Beautifier is okay without that, so we're using regex // permit # (23), $ (36), and @ (64). @ is used in ES7 decorators. // 65 through 91 are uppercase letters. // permit _ (95). // 97 through 123 are lowercase letters. var baseASCIIidentifierStartChars = "\\x23\\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 + "]");
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 + "])+");
var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/; // jshint ignore:line
// 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 validPositionValues = ['before-newline', 'after-newline', 'preserve-newline'];
function Options(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";
} elseif (raw_brace_style === "collapse-preserve-inline") { //graceful handling of deprecated option this.raw_options.brace_style = "collapse,preserve-inline";
} elseif (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 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;
}
// 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'));
// 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();
}
} elseif (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) { thrownew 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) { thrownew Error("Selection list cannot be empty.");
}
var result = this._get_array(name, default_value); if (!this._is_valid_selection(result, selection_list)) { thrownew Error( "Invalid Option Value: The option '" + name + "' can contain only the following values:\n" +
selection_list + "\nYou passed in: '" + this.raw_options[name] + "'");
}
// 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 InputScanner = __webpack_require__(8).InputScanner; var BaseTokenizer = __webpack_require__(9).Tokenizer; var BASETOKEN = __webpack_require__(9).TOKEN; var Directives = __webpack_require__(13).Directives; var acorn = __webpack_require__(4); var Pattern = __webpack_require__(12).Pattern; var TemplatablePattern = __webpack_require__(14).TemplatablePattern;
function in_array(what, arr) { return arr.indexOf(what) !== -1;
}
// 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, "\\$&"); // ?. but not if followed by a number
punct = '\\?\\.(?!\\d) ' + punct;
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 = function(input_string, options) {
BaseTokenizer.call(this, input_string, options);
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);
} returnthis._create_token(TOKEN.STRING, resulting_string);
} returnnull;
};
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'); returnthis._create_token(TOKEN.STRING, xmlStr);
}
}
returnnull;
};
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(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);
} elseif (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;
} elseif (escaped >= 0x00 && escaped < 0x20) { // leave 0x00...0x1f escaped
out += '\\' + matched[0]; continue;
} elseif (escaped === 0x22 || escaped === 0x27 || escaped === 0x5c) { // single-quote, apostrophe, backslash - escape these
out += '\\' + String.fromCharCode(escaped);
} else {
out += String.fromCharCode(escaped);
}
}
}
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 { returnfalse;
}
};
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.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.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);
} elseif (pattern) {
result = new RegExp(pattern.source, flags);
} return result;
};
var InputScanner = __webpack_require__(8).InputScanner; var Token = __webpack_require__(3).Token; var TokenStream = __webpack_require__(10).TokenStream; var WhitespacePattern = __webpack_require__(11).WhitespacePattern;
var Tokenizer = function(input_string, options) { this._input = new InputScanner(input_string); this._options = options || {}; this.__tokens = null;
this._patterns = {}; this._patterns.whitespace = new WhitespacePattern(this._input);
};
Tokenizer.prototype.tokenize = function() { this._input.restart(); this.__tokens = new TokenStream();
this._reset();
var current; var previous = new Token(TOKEN.START, ''); var open_token = null; var open_stack = []; var comments = new TokenStream();
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();
}
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;
};
// 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.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(input_scanner); this.__patterns = {
handlebars_comment: pattern.starting_with(/{{!--/).until_after(/--}}/),
handlebars_unescaped: 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();
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);
}
/***/ }) /******/ ]); var js_beautify = legacy_beautify_js; /* Footer */ if (typeof define === "function" && define.amd) { // Add support for AMD ( https://github.com/amdjs/amdjs-api/wiki/AMD#defineamd-property- )
define([], function() { return { js_beautify: js_beautify };
});
} elseif (typeof exports !== "undefined") { // Add support for CommonJS. Just put this file somewhere on your require.paths // and you will be able to `var js_beautify = require("beautify").js_beautify`.
exports.js_beautify = js_beautify;
} elseif (typeof window !== "undefined") { // If we're running a web page and don't have either of the above, add our one global
window.js_beautify = js_beautify;
} elseif (typeof global !== "undefined") { // If we don't even have window, try global.
global.js_beautify = js_beautify;
}
}());
Messung V0.5 in Prozent
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.151Bemerkung:
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
