You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4049 lines
146 KiB
4049 lines
146 KiB
/* AUTO-GENERATED. DO NOT MODIFY. */ |
|
/* |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
|
|
JS Beautifier |
|
--------------- |
|
|
|
|
|
Written by Einar Lielmanis, <einar@beautifier.io> |
|
https://beautifier.io/ |
|
|
|
Originally converted to javascript by Vital, <vital76@gmail.com> |
|
"End braces on own line" added by Chris J. Shull, <chrisjshull@gmail.com> |
|
Parsing improvements for brace-less statements by Liam Newman <bitwiseman@beautifier.io> |
|
|
|
|
|
Usage: |
|
js_beautify(js_source_text); |
|
js_beautify(js_source_text, options); |
|
|
|
The options are: |
|
indent_size (default 4) - indentation size, |
|
indent_char (default space) - character to indent with, |
|
preserve_newlines (default true) - whether existing line breaks should be preserved, |
|
max_preserve_newlines (default unlimited) - maximum number of line breaks to be preserved in one chunk, |
|
|
|
jslint_happy (default false) - if true, then jslint-stricter mode is enforced. |
|
|
|
jslint_happy !jslint_happy |
|
--------------------------------- |
|
function () function() |
|
|
|
switch () { switch() { |
|
case 1: case 1: |
|
break; break; |
|
} } |
|
|
|
space_after_anon_function (default false) - should the space before an anonymous function's parens be added, "function()" vs "function ()", |
|
NOTE: This option is overridden by jslint_happy (i.e. if jslint_happy is true, space_after_anon_function is true by design) |
|
|
|
brace_style (default "collapse") - "collapse" | "expand" | "end-expand" | "none" | any of the former + ",preserve-inline" |
|
put braces on the same line as control statements (default), or put braces on own line (Allman / ANSI style), or just put end braces on own line, or attempt to keep them where they are. |
|
preserve-inline will try to preserve inline blocks of curly braces |
|
|
|
space_before_conditional (default true) - should the space before conditional statement be added, "if(true)" vs "if (true)", |
|
|
|
unescape_strings (default false) - should printable characters in strings encoded in \xNN notation be unescaped, "example" vs "\x65\x78\x61\x6d\x70\x6c\x65" |
|
|
|
wrap_line_length (default unlimited) - lines should wrap at next opportunity after this number of characters. |
|
NOTE: This is not a hard limit. Lines will continue until a point where a newline would |
|
be preserved if it were present. |
|
|
|
end_with_newline (default false) - end output with a newline |
|
|
|
|
|
e.g |
|
|
|
js_beautify(js_source_text, { |
|
'indent_size': 1, |
|
'indent_char': '\t' |
|
}); |
|
|
|
*/ |
|
|
|
(function() { |
|
|
|
/* GENERATED_BUILD_OUTPUT */ |
|
var legacy_beautify_js; |
|
/******/ (function() { // webpackBootstrap |
|
/******/ "use strict"; |
|
/******/ var __webpack_modules__ = ([ |
|
/* 0 */ |
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) { |
|
|
|
/*jshint node:true */ |
|
/* |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
|
|
|
|
var Beautifier = (__webpack_require__(1).Beautifier), |
|
Options = (__webpack_require__(5).Options); |
|
|
|
function js_beautify(js_source_text, options) { |
|
var beautifier = new Beautifier(js_source_text, options); |
|
return beautifier.beautify(); |
|
} |
|
|
|
module.exports = js_beautify; |
|
module.exports.defaultOptions = function() { |
|
return new Options(); |
|
}; |
|
|
|
|
|
/***/ }), |
|
/* 1 */ |
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) { |
|
|
|
/*jshint node:true */ |
|
/* |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
|
|
|
|
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_word(token, word) { |
|
return token && token.type === TOKEN.RESERVED && token.text === word; |
|
} |
|
|
|
function reserved_array(token, words) { |
|
return token && token.type === TOKEN.RESERVED && in_array(token.text, words); |
|
} |
|
// Unsure of what they mean, but they work. Worth cleaning up in future. |
|
var special_words = ['case', 'return', 'do', 'if', 'throw', 'else', 'await', 'break', 'continue', 'async']; |
|
|
|
var validPositionValues = ['before-newline', 'after-newline', 'preserve-newline']; |
|
|
|
// Generate map from array |
|
var OPERATOR_POSITION = generateMapFromStrings(validPositionValues); |
|
|
|
var OPERATOR_POSITION_BEFORE_OR_PRESERVE = [OPERATOR_POSITION.before_newline, OPERATOR_POSITION.preserve_newline]; |
|
|
|
var MODE = { |
|
BlockStatement: 'BlockStatement', // 'BLOCK' |
|
Statement: 'Statement', // 'STATEMENT' |
|
ObjectLiteral: 'ObjectLiteral', // 'OBJECT', |
|
ArrayLiteral: 'ArrayLiteral', //'[EXPRESSION]', |
|
ForInitializer: 'ForInitializer', //'(FOR-EXPRESSION)', |
|
Conditional: 'Conditional', //'(COND-EXPRESSION)', |
|
Expression: 'Expression' //'(EXPRESSION)' |
|
}; |
|
|
|
function remove_redundant_indentation(output, frame) { |
|
// This implementation is effective but has some issues: |
|
// - can cause line wrap to happen too soon due to indent removal |
|
// after wrap points are calculated |
|
// These issues are minor compared to ugly indentation. |
|
|
|
if (frame.multiline_frame || |
|
frame.mode === MODE.ForInitializer || |
|
frame.mode === MODE.Conditional) { |
|
return; |
|
} |
|
|
|
// remove one indent from each line inside this section |
|
output.remove_indent(frame.start_line_index); |
|
} |
|
|
|
// we could use just string.split, but |
|
// IE doesn't like returning empty strings |
|
function split_linebreaks(s) { |
|
//return s.split(/\x0d\x0a|\x0a/); |
|
|
|
s = s.replace(acorn.allLineBreaks, '\n'); |
|
var out = [], |
|
idx = s.indexOf("\n"); |
|
while (idx !== -1) { |
|
out.push(s.substring(0, idx)); |
|
s = s.substring(idx + 1); |
|
idx = s.indexOf("\n"); |
|
} |
|
if (s.length) { |
|
out.push(s); |
|
} |
|
return out; |
|
} |
|
|
|
function is_array(mode) { |
|
return mode === MODE.ArrayLiteral; |
|
} |
|
|
|
function is_expression(mode) { |
|
return in_array(mode, [MODE.Expression, MODE.ForInitializer, MODE.Conditional]); |
|
} |
|
|
|
function all_lines_start_with(lines, c) { |
|
for (var i = 0; i < lines.length; i++) { |
|
var line = lines[i].trim(); |
|
if (line.charAt(0) !== c) { |
|
return false; |
|
} |
|
} |
|
return true; |
|
} |
|
|
|
function each_line_matches_indent(lines, indent) { |
|
var i = 0, |
|
len = lines.length, |
|
line; |
|
for (; i < len; i++) { |
|
line = lines[i]; |
|
// allow empty lines to pass through |
|
if (line && line.indexOf(indent) !== 0) { |
|
return false; |
|
} |
|
} |
|
return true; |
|
} |
|
|
|
|
|
function Beautifier(source_text, options) { |
|
options = options || {}; |
|
this._source_text = source_text || ''; |
|
|
|
this._output = null; |
|
this._tokens = null; |
|
this._last_last_text = null; |
|
this._flags = null; |
|
this._previous_flags = null; |
|
|
|
this._flag_store = null; |
|
this._options = new Options(options); |
|
} |
|
|
|
Beautifier.prototype.create_flags = function(flags_base, mode) { |
|
var next_indent_level = 0; |
|
if (flags_base) { |
|
next_indent_level = flags_base.indentation_level; |
|
if (!this._output.just_added_newline() && |
|
flags_base.line_indent_level > next_indent_level) { |
|
next_indent_level = flags_base.line_indent_level; |
|
} |
|
} |
|
|
|
var next_flags = { |
|
mode: mode, |
|
parent: flags_base, |
|
last_token: flags_base ? flags_base.last_token : new Token(TOKEN.START_BLOCK, ''), // last token text |
|
last_word: flags_base ? flags_base.last_word : '', // last TOKEN.WORD passed |
|
declaration_statement: false, |
|
declaration_assignment: false, |
|
multiline_frame: false, |
|
inline_frame: false, |
|
if_block: false, |
|
else_block: false, |
|
class_start_block: false, // class A { INSIDE HERE } or class B extends C { INSIDE HERE } |
|
do_block: false, |
|
do_while: false, |
|
import_block: false, |
|
in_case_statement: false, // switch(..){ INSIDE HERE } |
|
in_case: false, // we're on the exact line with "case 0:" |
|
case_body: false, // the indented case-action block |
|
case_block: false, // the indented case-action block is wrapped with {} |
|
indentation_level: next_indent_level, |
|
alignment: 0, |
|
line_indent_level: flags_base ? flags_base.line_indent_level : next_indent_level, |
|
start_line_index: this._output.get_line_number(), |
|
ternary_depth: 0 |
|
}; |
|
return next_flags; |
|
}; |
|
|
|
Beautifier.prototype._reset = function(source_text) { |
|
var baseIndentString = source_text.match(/^[\t ]*/)[0]; |
|
|
|
this._last_last_text = ''; // pre-last token text |
|
this._output = new Output(this._options, baseIndentString); |
|
|
|
// If testing the ignore directive, start with output disable set to true |
|
this._output.raw = this._options.test_output_raw; |
|
|
|
|
|
// Stack of parsing/formatting states, including MODE. |
|
// We tokenize, parse, and output in an almost purely a forward-only stream of token input |
|
// and formatted output. This makes the beautifier less accurate than full parsers |
|
// but also far more tolerant of syntax errors. |
|
// |
|
// For example, the default mode is MODE.BlockStatement. If we see a '{' we push a new frame of type |
|
// MODE.BlockStatement on the the stack, even though it could be object literal. If we later |
|
// encounter a ":", we'll switch to to MODE.ObjectLiteral. If we then see a ";", |
|
// most full parsers would die, but the beautifier gracefully falls back to |
|
// MODE.BlockStatement and continues on. |
|
this._flag_store = []; |
|
this.set_mode(MODE.BlockStatement); |
|
var tokenizer = new Tokenizer(source_text, this._options); |
|
this._tokens = tokenizer.tokenize(); |
|
return source_text; |
|
}; |
|
|
|
Beautifier.prototype.beautify = function() { |
|
// if disabled, return the input unchanged. |
|
if (this._options.disabled) { |
|
return this._source_text; |
|
} |
|
|
|
var sweet_code; |
|
var source_text = this._reset(this._source_text); |
|
|
|
var eol = this._options.eol; |
|
if (this._options.eol === 'auto') { |
|
eol = '\n'; |
|
if (source_text && acorn.lineBreak.test(source_text || '')) { |
|
eol = source_text.match(acorn.lineBreak)[0]; |
|
} |
|
} |
|
|
|
var current_token = this._tokens.next(); |
|
while (current_token) { |
|
this.handle_token(current_token); |
|
|
|
this._last_last_text = this._flags.last_token.text; |
|
this._flags.last_token = current_token; |
|
|
|
current_token = this._tokens.next(); |
|
} |
|
|
|
sweet_code = this._output.get_code(eol); |
|
|
|
return sweet_code; |
|
}; |
|
|
|
Beautifier.prototype.handle_token = function(current_token, preserve_statement_flags) { |
|
if (current_token.type === TOKEN.START_EXPR) { |
|
this.handle_start_expr(current_token); |
|
} else if (current_token.type === TOKEN.END_EXPR) { |
|
this.handle_end_expr(current_token); |
|
} else if (current_token.type === TOKEN.START_BLOCK) { |
|
this.handle_start_block(current_token); |
|
} else if (current_token.type === TOKEN.END_BLOCK) { |
|
this.handle_end_block(current_token); |
|
} else if (current_token.type === TOKEN.WORD) { |
|
this.handle_word(current_token); |
|
} else if (current_token.type === TOKEN.RESERVED) { |
|
this.handle_word(current_token); |
|
} else if (current_token.type === TOKEN.SEMICOLON) { |
|
this.handle_semicolon(current_token); |
|
} else if (current_token.type === TOKEN.STRING) { |
|
this.handle_string(current_token); |
|
} else if (current_token.type === TOKEN.EQUALS) { |
|
this.handle_equals(current_token); |
|
} else if (current_token.type === TOKEN.OPERATOR) { |
|
this.handle_operator(current_token); |
|
} else if (current_token.type === TOKEN.COMMA) { |
|
this.handle_comma(current_token); |
|
} else if (current_token.type === TOKEN.BLOCK_COMMENT) { |
|
this.handle_block_comment(current_token, preserve_statement_flags); |
|
} else if (current_token.type === TOKEN.COMMENT) { |
|
this.handle_comment(current_token, preserve_statement_flags); |
|
} else if (current_token.type === TOKEN.DOT) { |
|
this.handle_dot(current_token); |
|
} else if (current_token.type === TOKEN.EOF) { |
|
this.handle_eof(current_token); |
|
} else if (current_token.type === TOKEN.UNKNOWN) { |
|
this.handle_unknown(current_token, preserve_statement_flags); |
|
} else { |
|
this.handle_unknown(current_token, preserve_statement_flags); |
|
} |
|
}; |
|
|
|
Beautifier.prototype.handle_whitespace_and_comments = function(current_token, preserve_statement_flags) { |
|
var newlines = current_token.newlines; |
|
var keep_whitespace = this._options.keep_array_indentation && is_array(this._flags.mode); |
|
|
|
if (current_token.comments_before) { |
|
var comment_token = current_token.comments_before.next(); |
|
while (comment_token) { |
|
// The cleanest handling of inline comments is to treat them as though they aren't there. |
|
// Just continue formatting and the behavior should be logical. |
|
// Also ignore unknown tokens. Again, this should result in better behavior. |
|
this.handle_whitespace_and_comments(comment_token, preserve_statement_flags); |
|
this.handle_token(comment_token, preserve_statement_flags); |
|
comment_token = current_token.comments_before.next(); |
|
} |
|
} |
|
|
|
if (keep_whitespace) { |
|
for (var i = 0; i < newlines; i += 1) { |
|
this.print_newline(i > 0, preserve_statement_flags); |
|
} |
|
} else { |
|
if (this._options.max_preserve_newlines && newlines > this._options.max_preserve_newlines) { |
|
newlines = this._options.max_preserve_newlines; |
|
} |
|
|
|
if (this._options.preserve_newlines) { |
|
if (newlines > 1) { |
|
this.print_newline(false, preserve_statement_flags); |
|
for (var j = 1; j < newlines; j += 1) { |
|
this.print_newline(true, preserve_statement_flags); |
|
} |
|
} |
|
} |
|
} |
|
|
|
}; |
|
|
|
var newline_restricted_tokens = ['async', 'break', 'continue', 'return', 'throw', 'yield']; |
|
|
|
Beautifier.prototype.allow_wrap_or_preserved_newline = function(current_token, force_linewrap) { |
|
force_linewrap = (force_linewrap === undefined) ? false : force_linewrap; |
|
|
|
// Never wrap the first token on a line |
|
if (this._output.just_added_newline()) { |
|
return; |
|
} |
|
|
|
var shouldPreserveOrForce = (this._options.preserve_newlines && current_token.newlines) || force_linewrap; |
|
var operatorLogicApplies = in_array(this._flags.last_token.text, positionable_operators) || |
|
in_array(current_token.text, positionable_operators); |
|
|
|
if (operatorLogicApplies) { |
|
var shouldPrintOperatorNewline = ( |
|
in_array(this._flags.last_token.text, positionable_operators) && |
|
in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE) |
|
) || |
|
in_array(current_token.text, positionable_operators); |
|
shouldPreserveOrForce = shouldPreserveOrForce && shouldPrintOperatorNewline; |
|
} |
|
|
|
if (shouldPreserveOrForce) { |
|
this.print_newline(false, true); |
|
} else if (this._options.wrap_line_length) { |
|
if (reserved_array(this._flags.last_token, newline_restricted_tokens)) { |
|
// These tokens should never have a newline inserted |
|
// between them and the following expression. |
|
return; |
|
} |
|
this._output.set_wrap_point(); |
|
} |
|
}; |
|
|
|
Beautifier.prototype.print_newline = function(force_newline, preserve_statement_flags) { |
|
if (!preserve_statement_flags) { |
|
if (this._flags.last_token.text !== ';' && this._flags.last_token.text !== ',' && this._flags.last_token.text !== '=' && (this._flags.last_token.type !== TOKEN.OPERATOR || this._flags.last_token.text === '--' || this._flags.last_token.text === '++')) { |
|
var next_token = this._tokens.peek(); |
|
while (this._flags.mode === MODE.Statement && |
|
!(this._flags.if_block && reserved_word(next_token, 'else')) && |
|
!this._flags.do_block) { |
|
this.restore_mode(); |
|
} |
|
} |
|
} |
|
|
|
if (this._output.add_new_line(force_newline)) { |
|
this._flags.multiline_frame = true; |
|
} |
|
}; |
|
|
|
Beautifier.prototype.print_token_line_indentation = function(current_token) { |
|
if (this._output.just_added_newline()) { |
|
if (this._options.keep_array_indentation && |
|
current_token.newlines && |
|
(current_token.text === '[' || is_array(this._flags.mode))) { |
|
this._output.current_line.set_indent(-1); |
|
this._output.current_line.push(current_token.whitespace_before); |
|
this._output.space_before_token = false; |
|
} else if (this._output.set_indent(this._flags.indentation_level, this._flags.alignment)) { |
|
this._flags.line_indent_level = this._flags.indentation_level; |
|
} |
|
} |
|
}; |
|
|
|
Beautifier.prototype.print_token = function(current_token) { |
|
if (this._output.raw) { |
|
this._output.add_raw_token(current_token); |
|
return; |
|
} |
|
|
|
if (this._options.comma_first && current_token.previous && current_token.previous.type === TOKEN.COMMA && |
|
this._output.just_added_newline()) { |
|
if (this._output.previous_line.last() === ',') { |
|
var popped = this._output.previous_line.pop(); |
|
// if the comma was already at the start of the line, |
|
// pull back onto that line and reprint the indentation |
|
if (this._output.previous_line.is_empty()) { |
|
this._output.previous_line.push(popped); |
|
this._output.trim(true); |
|
this._output.current_line.pop(); |
|
this._output.trim(); |
|
} |
|
|
|
// add the comma in front of the next token |
|
this.print_token_line_indentation(current_token); |
|
this._output.add_token(','); |
|
this._output.space_before_token = true; |
|
} |
|
} |
|
|
|
this.print_token_line_indentation(current_token); |
|
this._output.non_breaking_space = true; |
|
this._output.add_token(current_token.text); |
|
if (this._output.previous_token_wrapped) { |
|
this._flags.multiline_frame = true; |
|
} |
|
}; |
|
|
|
Beautifier.prototype.indent = function() { |
|
this._flags.indentation_level += 1; |
|
this._output.set_indent(this._flags.indentation_level, this._flags.alignment); |
|
}; |
|
|
|
Beautifier.prototype.deindent = function() { |
|
if (this._flags.indentation_level > 0 && |
|
((!this._flags.parent) || this._flags.indentation_level > this._flags.parent.indentation_level)) { |
|
this._flags.indentation_level -= 1; |
|
this._output.set_indent(this._flags.indentation_level, this._flags.alignment); |
|
} |
|
}; |
|
|
|
Beautifier.prototype.set_mode = function(mode) { |
|
if (this._flags) { |
|
this._flag_store.push(this._flags); |
|
this._previous_flags = this._flags; |
|
} else { |
|
this._previous_flags = this.create_flags(null, mode); |
|
} |
|
|
|
this._flags = this.create_flags(this._previous_flags, mode); |
|
this._output.set_indent(this._flags.indentation_level, this._flags.alignment); |
|
}; |
|
|
|
|
|
Beautifier.prototype.restore_mode = function() { |
|
if (this._flag_store.length > 0) { |
|
this._previous_flags = this._flags; |
|
this._flags = this._flag_store.pop(); |
|
if (this._previous_flags.mode === MODE.Statement) { |
|
remove_redundant_indentation(this._output, this._previous_flags); |
|
} |
|
this._output.set_indent(this._flags.indentation_level, this._flags.alignment); |
|
} |
|
}; |
|
|
|
Beautifier.prototype.start_of_object_property = function() { |
|
return this._flags.parent.mode === MODE.ObjectLiteral && this._flags.mode === MODE.Statement && ( |
|
(this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) || (reserved_array(this._flags.last_token, ['get', 'set']))); |
|
}; |
|
|
|
Beautifier.prototype.start_of_statement = function(current_token) { |
|
var start = false; |
|
start = start || reserved_array(this._flags.last_token, ['var', 'let', 'const']) && current_token.type === TOKEN.WORD; |
|
start = start || reserved_word(this._flags.last_token, 'do'); |
|
start = start || (!(this._flags.parent.mode === MODE.ObjectLiteral && this._flags.mode === MODE.Statement)) && reserved_array(this._flags.last_token, newline_restricted_tokens) && !current_token.newlines; |
|
start = start || reserved_word(this._flags.last_token, 'else') && |
|
!(reserved_word(current_token, 'if') && !current_token.comments_before); |
|
start = start || (this._flags.last_token.type === TOKEN.END_EXPR && (this._previous_flags.mode === MODE.ForInitializer || this._previous_flags.mode === MODE.Conditional)); |
|
start = start || (this._flags.last_token.type === TOKEN.WORD && this._flags.mode === MODE.BlockStatement && |
|
!this._flags.in_case && |
|
!(current_token.text === '--' || current_token.text === '++') && |
|
this._last_last_text !== 'function' && |
|
current_token.type !== TOKEN.WORD && current_token.type !== TOKEN.RESERVED); |
|
start = start || (this._flags.mode === MODE.ObjectLiteral && ( |
|
(this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) || reserved_array(this._flags.last_token, ['get', 'set']))); |
|
|
|
if (start) { |
|
this.set_mode(MODE.Statement); |
|
this.indent(); |
|
|
|
this.handle_whitespace_and_comments(current_token, true); |
|
|
|
// Issue #276: |
|
// If starting a new statement with [if, for, while, do], push to a new line. |
|
// if (a) if (b) if(c) d(); else e(); else f(); |
|
if (!this.start_of_object_property()) { |
|
this.allow_wrap_or_preserved_newline(current_token, |
|
reserved_array(current_token, ['do', 'for', 'if', 'while'])); |
|
} |
|
return true; |
|
} |
|
return false; |
|
}; |
|
|
|
Beautifier.prototype.handle_start_expr = function(current_token) { |
|
// The conditional starts the statement if appropriate. |
|
if (!this.start_of_statement(current_token)) { |
|
this.handle_whitespace_and_comments(current_token); |
|
} |
|
|
|
var next_mode = MODE.Expression; |
|
if (current_token.text === '[') { |
|
|
|
if (this._flags.last_token.type === TOKEN.WORD || this._flags.last_token.text === ')') { |
|
// this is array index specifier, break immediately |
|
// a[x], fn()[x] |
|
if (reserved_array(this._flags.last_token, line_starters)) { |
|
this._output.space_before_token = true; |
|
} |
|
this.print_token(current_token); |
|
this.set_mode(next_mode); |
|
this.indent(); |
|
if (this._options.space_in_paren) { |
|
this._output.space_before_token = true; |
|
} |
|
return; |
|
} |
|
|
|
next_mode = MODE.ArrayLiteral; |
|
if (is_array(this._flags.mode)) { |
|
if (this._flags.last_token.text === '[' || |
|
(this._flags.last_token.text === ',' && (this._last_last_text === ']' || this._last_last_text === '}'))) { |
|
// ], [ goes to new line |
|
// }, [ goes to new line |
|
if (!this._options.keep_array_indentation) { |
|
this.print_newline(); |
|
} |
|
} |
|
} |
|
|
|
if (!in_array(this._flags.last_token.type, [TOKEN.START_EXPR, TOKEN.END_EXPR, TOKEN.WORD, TOKEN.OPERATOR, TOKEN.DOT])) { |
|
this._output.space_before_token = true; |
|
} |
|
} else { |
|
if (this._flags.last_token.type === TOKEN.RESERVED) { |
|
if (this._flags.last_token.text === 'for') { |
|
this._output.space_before_token = this._options.space_before_conditional; |
|
next_mode = MODE.ForInitializer; |
|
} else if (in_array(this._flags.last_token.text, ['if', 'while', 'switch'])) { |
|
this._output.space_before_token = this._options.space_before_conditional; |
|
next_mode = MODE.Conditional; |
|
} else if (in_array(this._flags.last_word, ['await', 'async'])) { |
|
// Should be a space between await and an IIFE, or async and an arrow function |
|
this._output.space_before_token = true; |
|
} else if (this._flags.last_token.text === 'import' && current_token.whitespace_before === '') { |
|
this._output.space_before_token = false; |
|
} else if (in_array(this._flags.last_token.text, line_starters) || this._flags.last_token.text === 'catch') { |
|
this._output.space_before_token = true; |
|
} |
|
} else if (this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) { |
|
// Support of this kind of newline preservation. |
|
// a = (b && |
|
// (c || d)); |
|
if (!this.start_of_object_property()) { |
|
this.allow_wrap_or_preserved_newline(current_token); |
|
} |
|
} else if (this._flags.last_token.type === TOKEN.WORD) { |
|
this._output.space_before_token = false; |
|
|
|
// function name() vs function name () |
|
// function* name() vs function* name () |
|
// async name() vs async name () |
|
// In ES6, you can also define the method properties of an object |
|
// var obj = {a: function() {}} |
|
// It can be abbreviated |
|
// var obj = {a() {}} |
|
// var obj = { a() {}} vs var obj = { a () {}} |
|
// var obj = { * a() {}} vs var obj = { * a () {}} |
|
var peek_back_two = this._tokens.peek(-3); |
|
if (this._options.space_after_named_function && peek_back_two) { |
|
// peek starts at next character so -1 is current token |
|
var peek_back_three = this._tokens.peek(-4); |
|
if (reserved_array(peek_back_two, ['async', 'function']) || |
|
(peek_back_two.text === '*' && reserved_array(peek_back_three, ['async', 'function']))) { |
|
this._output.space_before_token = true; |
|
} else if (this._flags.mode === MODE.ObjectLiteral) { |
|
if ((peek_back_two.text === '{' || peek_back_two.text === ',') || |
|
(peek_back_two.text === '*' && (peek_back_three.text === '{' || peek_back_three.text === ','))) { |
|
this._output.space_before_token = true; |
|
} |
|
} else if (this._flags.parent && this._flags.parent.class_start_block) { |
|
this._output.space_before_token = true; |
|
} |
|
} |
|
} else { |
|
// Support preserving wrapped arrow function expressions |
|
// a.b('c', |
|
// () => d.e |
|
// ) |
|
this.allow_wrap_or_preserved_newline(current_token); |
|
} |
|
|
|
// function() vs function () |
|
// yield*() vs yield* () |
|
// function*() vs function* () |
|
if ((this._flags.last_token.type === TOKEN.RESERVED && (this._flags.last_word === 'function' || this._flags.last_word === 'typeof')) || |
|
(this._flags.last_token.text === '*' && |
|
(in_array(this._last_last_text, ['function', 'yield']) || |
|
(this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ',']))))) { |
|
this._output.space_before_token = this._options.space_after_anon_function; |
|
} |
|
} |
|
|
|
if (this._flags.last_token.text === ';' || this._flags.last_token.type === TOKEN.START_BLOCK) { |
|
this.print_newline(); |
|
} else if (this._flags.last_token.type === TOKEN.END_EXPR || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.END_BLOCK || this._flags.last_token.text === '.' || this._flags.last_token.type === TOKEN.COMMA) { |
|
// do nothing on (( and )( and ][ and ]( and .( |
|
// TODO: Consider whether forcing this is required. Review failing tests when removed. |
|
this.allow_wrap_or_preserved_newline(current_token, current_token.newlines); |
|
} |
|
|
|
this.print_token(current_token); |
|
this.set_mode(next_mode); |
|
if (this._options.space_in_paren) { |
|
this._output.space_before_token = true; |
|
} |
|
|
|
// In all cases, if we newline while inside an expression it should be indented. |
|
this.indent(); |
|
}; |
|
|
|
Beautifier.prototype.handle_end_expr = function(current_token) { |
|
// statements inside expressions are not valid syntax, but... |
|
// statements must all be closed when their container closes |
|
while (this._flags.mode === MODE.Statement) { |
|
this.restore_mode(); |
|
} |
|
|
|
this.handle_whitespace_and_comments(current_token); |
|
|
|
if (this._flags.multiline_frame) { |
|
this.allow_wrap_or_preserved_newline(current_token, |
|
current_token.text === ']' && is_array(this._flags.mode) && !this._options.keep_array_indentation); |
|
} |
|
|
|
if (this._options.space_in_paren) { |
|
if (this._flags.last_token.type === TOKEN.START_EXPR && !this._options.space_in_empty_paren) { |
|
// () [] no inner space in empty parens like these, ever, ref #320 |
|
this._output.trim(); |
|
this._output.space_before_token = false; |
|
} else { |
|
this._output.space_before_token = true; |
|
} |
|
} |
|
this.deindent(); |
|
this.print_token(current_token); |
|
this.restore_mode(); |
|
|
|
remove_redundant_indentation(this._output, this._previous_flags); |
|
|
|
// do {} while () // no statement required after |
|
if (this._flags.do_while && this._previous_flags.mode === MODE.Conditional) { |
|
this._previous_flags.mode = MODE.Expression; |
|
this._flags.do_block = false; |
|
this._flags.do_while = false; |
|
|
|
} |
|
}; |
|
|
|
Beautifier.prototype.handle_start_block = function(current_token) { |
|
this.handle_whitespace_and_comments(current_token); |
|
|
|
// Check if this is should be treated as a ObjectLiteral |
|
var next_token = this._tokens.peek(); |
|
var second_token = this._tokens.peek(1); |
|
if (this._flags.last_word === 'switch' && this._flags.last_token.type === TOKEN.END_EXPR) { |
|
this.set_mode(MODE.BlockStatement); |
|
this._flags.in_case_statement = true; |
|
} else if (this._flags.case_body) { |
|
this.set_mode(MODE.BlockStatement); |
|
} else if (second_token && ( |
|
(in_array(second_token.text, [':', ',']) && in_array(next_token.type, [TOKEN.STRING, TOKEN.WORD, TOKEN.RESERVED])) || |
|
(in_array(next_token.text, ['get', 'set', '...']) && in_array(second_token.type, [TOKEN.WORD, TOKEN.RESERVED])) |
|
)) { |
|
// We don't support TypeScript,but we didn't break it for a very long time. |
|
// We'll try to keep not breaking it. |
|
if (in_array(this._last_last_text, ['class', 'interface']) && !in_array(second_token.text, [':', ','])) { |
|
this.set_mode(MODE.BlockStatement); |
|
} else { |
|
this.set_mode(MODE.ObjectLiteral); |
|
} |
|
} else if (this._flags.last_token.type === TOKEN.OPERATOR && this._flags.last_token.text === '=>') { |
|
// arrow function: (param1, paramN) => { statements } |
|
this.set_mode(MODE.BlockStatement); |
|
} else if (in_array(this._flags.last_token.type, [TOKEN.EQUALS, TOKEN.START_EXPR, TOKEN.COMMA, TOKEN.OPERATOR]) || |
|
reserved_array(this._flags.last_token, ['return', 'throw', 'import', 'default']) |
|
) { |
|
// Detecting shorthand function syntax is difficult by scanning forward, |
|
// so check the surrounding context. |
|
// If the block is being returned, imported, export default, passed as arg, |
|
// assigned with = or assigned in a nested object, treat as an ObjectLiteral. |
|
this.set_mode(MODE.ObjectLiteral); |
|
} else { |
|
this.set_mode(MODE.BlockStatement); |
|
} |
|
|
|
if (this._flags.last_token) { |
|
if (reserved_array(this._flags.last_token.previous, ['class', 'extends'])) { |
|
this._flags.class_start_block = true; |
|
} |
|
} |
|
|
|
var empty_braces = !next_token.comments_before && next_token.text === '}'; |
|
var empty_anonymous_function = empty_braces && this._flags.last_word === 'function' && |
|
this._flags.last_token.type === TOKEN.END_EXPR; |
|
|
|
if (this._options.brace_preserve_inline) // check for inline, set inline_frame if so |
|
{ |
|
// search forward for a newline wanted inside this block |
|
var index = 0; |
|
var check_token = null; |
|
this._flags.inline_frame = true; |
|
do { |
|
index += 1; |
|
check_token = this._tokens.peek(index - 1); |
|
if (check_token.newlines) { |
|
this._flags.inline_frame = false; |
|
break; |
|
} |
|
} while (check_token.type !== TOKEN.EOF && |
|
!(check_token.type === TOKEN.END_BLOCK && check_token.opened === current_token)); |
|
} |
|
|
|
if ((this._options.brace_style === "expand" || |
|
(this._options.brace_style === "none" && current_token.newlines)) && |
|
!this._flags.inline_frame) { |
|
if (this._flags.last_token.type !== TOKEN.OPERATOR && |
|
(empty_anonymous_function || |
|
this._flags.last_token.type === TOKEN.EQUALS || |
|
(reserved_array(this._flags.last_token, special_words) && this._flags.last_token.text !== 'else'))) { |
|
this._output.space_before_token = true; |
|
} else { |
|
this.print_newline(false, true); |
|
} |
|
} else { // collapse || inline_frame |
|
if (is_array(this._previous_flags.mode) && (this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.COMMA)) { |
|
if (this._flags.last_token.type === TOKEN.COMMA || this._options.space_in_paren) { |
|
this._output.space_before_token = true; |
|
} |
|
|
|
if (this._flags.last_token.type === TOKEN.COMMA || (this._flags.last_token.type === TOKEN.START_EXPR && this._flags.inline_frame)) { |
|
this.allow_wrap_or_preserved_newline(current_token); |
|
this._previous_flags.multiline_frame = this._previous_flags.multiline_frame || this._flags.multiline_frame; |
|
this._flags.multiline_frame = false; |
|
} |
|
} |
|
if (this._flags.last_token.type !== TOKEN.OPERATOR && this._flags.last_token.type !== TOKEN.START_EXPR) { |
|
if (in_array(this._flags.last_token.type, [TOKEN.START_BLOCK, TOKEN.SEMICOLON]) && !this._flags.inline_frame) { |
|
this.print_newline(); |
|
} else { |
|
this._output.space_before_token = true; |
|
} |
|
} |
|
} |
|
this.print_token(current_token); |
|
this.indent(); |
|
|
|
// Except for specific cases, open braces are followed by a new line. |
|
if (!empty_braces && !(this._options.brace_preserve_inline && this._flags.inline_frame)) { |
|
this.print_newline(); |
|
} |
|
}; |
|
|
|
Beautifier.prototype.handle_end_block = function(current_token) { |
|
// statements must all be closed when their container closes |
|
this.handle_whitespace_and_comments(current_token); |
|
|
|
while (this._flags.mode === MODE.Statement) { |
|
this.restore_mode(); |
|
} |
|
|
|
var empty_braces = this._flags.last_token.type === TOKEN.START_BLOCK; |
|
|
|
if (this._flags.inline_frame && !empty_braces) { // try inline_frame (only set if this._options.braces-preserve-inline) first |
|
this._output.space_before_token = true; |
|
} else if (this._options.brace_style === "expand") { |
|
if (!empty_braces) { |
|
this.print_newline(); |
|
} |
|
} else { |
|
// skip {} |
|
if (!empty_braces) { |
|
if (is_array(this._flags.mode) && this._options.keep_array_indentation) { |
|
// we REALLY need a newline here, but newliner would skip that |
|
this._options.keep_array_indentation = false; |
|
this.print_newline(); |
|
this._options.keep_array_indentation = true; |
|
|
|
} else { |
|
this.print_newline(); |
|
} |
|
} |
|
} |
|
this.restore_mode(); |
|
this.print_token(current_token); |
|
}; |
|
|
|
Beautifier.prototype.handle_word = function(current_token) { |
|
if (current_token.type === TOKEN.RESERVED) { |
|
if (in_array(current_token.text, ['set', 'get']) && this._flags.mode !== MODE.ObjectLiteral) { |
|
current_token.type = TOKEN.WORD; |
|
} else if (current_token.text === 'import' && in_array(this._tokens.peek().text, ['(', '.'])) { |
|
current_token.type = TOKEN.WORD; |
|
} else if (in_array(current_token.text, ['as', 'from']) && !this._flags.import_block) { |
|
current_token.type = TOKEN.WORD; |
|
} else if (this._flags.mode === MODE.ObjectLiteral) { |
|
var next_token = this._tokens.peek(); |
|
if (next_token.text === ':') { |
|
current_token.type = TOKEN.WORD; |
|
} |
|
} |
|
} |
|
|
|
if (this.start_of_statement(current_token)) { |
|
// The conditional starts the statement if appropriate. |
|
if (reserved_array(this._flags.last_token, ['var', 'let', 'const']) && current_token.type === TOKEN.WORD) { |
|
this._flags.declaration_statement = true; |
|
} |
|
} else if (current_token.newlines && !is_expression(this._flags.mode) && |
|
(this._flags.last_token.type !== TOKEN.OPERATOR || (this._flags.last_token.text === '--' || this._flags.last_token.text === '++')) && |
|
this._flags.last_token.type !== TOKEN.EQUALS && |
|
(this._options.preserve_newlines || !reserved_array(this._flags.last_token, ['var', 'let', 'const', 'set', 'get']))) { |
|
this.handle_whitespace_and_comments(current_token); |
|
this.print_newline(); |
|
} else { |
|
this.handle_whitespace_and_comments(current_token); |
|
} |
|
|
|
if (this._flags.do_block && !this._flags.do_while) { |
|
if (reserved_word(current_token, 'while')) { |
|
// do {} ## while () |
|
this._output.space_before_token = true; |
|
this.print_token(current_token); |
|
this._output.space_before_token = true; |
|
this._flags.do_while = true; |
|
return; |
|
} else { |
|
// do {} should always have while as the next word. |
|
// if we don't see the expected while, recover |
|
this.print_newline(); |
|
this._flags.do_block = false; |
|
} |
|
} |
|
|
|
// if may be followed by else, or not |
|
// Bare/inline ifs are tricky |
|
// Need to unwind the modes correctly: if (a) if (b) c(); else d(); else e(); |
|
if (this._flags.if_block) { |
|
if (!this._flags.else_block && reserved_word(current_token, 'else')) { |
|
this._flags.else_block = true; |
|
} else { |
|
while (this._flags.mode === MODE.Statement) { |
|
this.restore_mode(); |
|
} |
|
this._flags.if_block = false; |
|
this._flags.else_block = false; |
|
} |
|
} |
|
|
|
if (this._flags.in_case_statement && reserved_array(current_token, ['case', 'default'])) { |
|
this.print_newline(); |
|
if (!this._flags.case_block && (this._flags.case_body || this._options.jslint_happy)) { |
|
// switch cases following one another |
|
this.deindent(); |
|
} |
|
this._flags.case_body = false; |
|
|
|
this.print_token(current_token); |
|
this._flags.in_case = true; |
|
return; |
|
} |
|
|
|
if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) { |
|
if (!this.start_of_object_property() && !( |
|
// start of object property is different for numeric values with +/- prefix operators |
|
in_array(this._flags.last_token.text, ['+', '-']) && this._last_last_text === ':' && this._flags.parent.mode === MODE.ObjectLiteral)) { |
|
this.allow_wrap_or_preserved_newline(current_token); |
|
} |
|
} |
|
|
|
if (reserved_word(current_token, 'function')) { |
|
if (in_array(this._flags.last_token.text, ['}', ';']) || |
|
(this._output.just_added_newline() && !(in_array(this._flags.last_token.text, ['(', '[', '{', ':', '=', ',']) || this._flags.last_token.type === TOKEN.OPERATOR))) { |
|
// make sure there is a nice clean space of at least one blank line |
|
// before a new function definition |
|
if (!this._output.just_added_blankline() && !current_token.comments_before) { |
|
this.print_newline(); |
|
this.print_newline(true); |
|
} |
|
} |
|
if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD) { |
|
if (reserved_array(this._flags.last_token, ['get', 'set', 'new', 'export']) || |
|
reserved_array(this._flags.last_token, newline_restricted_tokens)) { |
|
this._output.space_before_token = true; |
|
} else if (reserved_word(this._flags.last_token, 'default') && this._last_last_text === 'export') { |
|
this._output.space_before_token = true; |
|
} else if (this._flags.last_token.text === 'declare') { |
|
// accomodates Typescript declare function formatting |
|
this._output.space_before_token = true; |
|
} else { |
|
this.print_newline(); |
|
} |
|
} else if (this._flags.last_token.type === TOKEN.OPERATOR || this._flags.last_token.text === '=') { |
|
// foo = function |
|
this._output.space_before_token = true; |
|
} else if (!this._flags.multiline_frame && (is_expression(this._flags.mode) || is_array(this._flags.mode))) { |
|
// (function |
|
} else { |
|
this.print_newline(); |
|
} |
|
|
|
this.print_token(current_token); |
|
this._flags.last_word = current_token.text; |
|
return; |
|
} |
|
|
|
var prefix = 'NONE'; |
|
|
|
if (this._flags.last_token.type === TOKEN.END_BLOCK) { |
|
|
|
if (this._previous_flags.inline_frame) { |
|
prefix = 'SPACE'; |
|
} else if (!reserved_array(current_token, ['else', 'catch', 'finally', 'from'])) { |
|
prefix = 'NEWLINE'; |
|
} else { |
|
if (this._options.brace_style === "expand" || |
|
this._options.brace_style === "end-expand" || |
|
(this._options.brace_style === "none" && current_token.newlines)) { |
|
prefix = 'NEWLINE'; |
|
} else { |
|
prefix = 'SPACE'; |
|
this._output.space_before_token = true; |
|
} |
|
} |
|
} else if (this._flags.last_token.type === TOKEN.SEMICOLON && this._flags.mode === MODE.BlockStatement) { |
|
// TODO: Should this be for STATEMENT as well? |
|
prefix = 'NEWLINE'; |
|
} else if (this._flags.last_token.type === TOKEN.SEMICOLON && is_expression(this._flags.mode)) { |
|
prefix = 'SPACE'; |
|
} else if (this._flags.last_token.type === TOKEN.STRING) { |
|
prefix = 'NEWLINE'; |
|
} else if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD || |
|
(this._flags.last_token.text === '*' && |
|
(in_array(this._last_last_text, ['function', 'yield']) || |
|
(this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ',']))))) { |
|
prefix = 'SPACE'; |
|
} else if (this._flags.last_token.type === TOKEN.START_BLOCK) { |
|
if (this._flags.inline_frame) { |
|
prefix = 'SPACE'; |
|
} else { |
|
prefix = 'NEWLINE'; |
|
} |
|
} else if (this._flags.last_token.type === TOKEN.END_EXPR) { |
|
this._output.space_before_token = true; |
|
prefix = 'NEWLINE'; |
|
} |
|
|
|
if (reserved_array(current_token, line_starters) && this._flags.last_token.text !== ')') { |
|
if (this._flags.inline_frame || this._flags.last_token.text === 'else' || this._flags.last_token.text === 'export') { |
|
prefix = 'SPACE'; |
|
} else { |
|
prefix = 'NEWLINE'; |
|
} |
|
|
|
} |
|
|
|
if (reserved_array(current_token, ['else', 'catch', 'finally'])) { |
|
if ((!(this._flags.last_token.type === TOKEN.END_BLOCK && this._previous_flags.mode === MODE.BlockStatement) || |
|
this._options.brace_style === "expand" || |
|
this._options.brace_style === "end-expand" || |
|
(this._options.brace_style === "none" && current_token.newlines)) && |
|
!this._flags.inline_frame) { |
|
this.print_newline(); |
|
} else { |
|
this._output.trim(true); |
|
var line = this._output.current_line; |
|
// If we trimmed and there's something other than a close block before us |
|
// put a newline back in. Handles '} // comment' scenario. |
|
if (line.last() !== '}') { |
|
this.print_newline(); |
|
} |
|
this._output.space_before_token = true; |
|
} |
|
} else if (prefix === 'NEWLINE') { |
|
if (reserved_array(this._flags.last_token, special_words)) { |
|
// no newline between 'return nnn' |
|
this._output.space_before_token = true; |
|
} else if (this._flags.last_token.text === 'declare' && reserved_array(current_token, ['var', 'let', 'const'])) { |
|
// accomodates Typescript declare formatting |
|
this._output.space_before_token = true; |
|
} else if (this._flags.last_token.type !== TOKEN.END_EXPR) { |
|
if ((this._flags.last_token.type !== TOKEN.START_EXPR || !reserved_array(current_token, ['var', 'let', 'const'])) && this._flags.last_token.text !== ':') { |
|
// no need to force newline on 'var': for (var x = 0...) |
|
if (reserved_word(current_token, 'if') && reserved_word(current_token.previous, 'else')) { |
|
// no newline for } else if { |
|
this._output.space_before_token = true; |
|
} else { |
|
this.print_newline(); |
|
} |
|
} |
|
} else if (reserved_array(current_token, line_starters) && this._flags.last_token.text !== ')') { |
|
this.print_newline(); |
|
} |
|
} else if (this._flags.multiline_frame && is_array(this._flags.mode) && this._flags.last_token.text === ',' && this._last_last_text === '}') { |
|
this.print_newline(); // }, in lists get a newline treatment |
|
} else if (prefix === 'SPACE') { |
|
this._output.space_before_token = true; |
|
} |
|
if (current_token.previous && (current_token.previous.type === TOKEN.WORD || current_token.previous.type === TOKEN.RESERVED)) { |
|
this._output.space_before_token = true; |
|
} |
|
this.print_token(current_token); |
|
this._flags.last_word = current_token.text; |
|
|
|
if (current_token.type === TOKEN.RESERVED) { |
|
if (current_token.text === 'do') { |
|
this._flags.do_block = true; |
|
} else if (current_token.text === 'if') { |
|
this._flags.if_block = true; |
|
} else if (current_token.text === 'import') { |
|
this._flags.import_block = true; |
|
} else if (this._flags.import_block && reserved_word(current_token, 'from')) { |
|
this._flags.import_block = false; |
|
} |
|
} |
|
}; |
|
|
|
Beautifier.prototype.handle_semicolon = function(current_token) { |
|
if (this.start_of_statement(current_token)) { |
|
// The conditional starts the statement if appropriate. |
|
// Semicolon can be the start (and end) of a statement |
|
this._output.space_before_token = false; |
|
} else { |
|
this.handle_whitespace_and_comments(current_token); |
|
} |
|
|
|
var next_token = this._tokens.peek(); |
|
while (this._flags.mode === MODE.Statement && |
|
!(this._flags.if_block && reserved_word(next_token, 'else')) && |
|
!this._flags.do_block) { |
|
this.restore_mode(); |
|
} |
|
|
|
// hacky but effective for the moment |
|
if (this._flags.import_block) { |
|
this._flags.import_block = false; |
|
} |
|
this.print_token(current_token); |
|
}; |
|
|
|
Beautifier.prototype.handle_string = function(current_token) { |
|
if (current_token.text.startsWith("`") && current_token.newlines === 0 && current_token.whitespace_before === '' && (current_token.previous.text === ')' || this._flags.last_token.type === TOKEN.WORD)) { |
|
//Conditional for detectign backtick strings |
|
} else if (this.start_of_statement(current_token)) { |
|
// The conditional starts the statement if appropriate. |
|
// One difference - strings want at least a space before |
|
this._output.space_before_token = true; |
|
} else { |
|
this.handle_whitespace_and_comments(current_token); |
|
if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD || this._flags.inline_frame) { |
|
this._output.space_before_token = true; |
|
} else if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) { |
|
if (!this.start_of_object_property()) { |
|
this.allow_wrap_or_preserved_newline(current_token); |
|
} |
|
} else if ((current_token.text.startsWith("`") && this._flags.last_token.type === TOKEN.END_EXPR && (current_token.previous.text === ']' || current_token.previous.text === ')') && current_token.newlines === 0)) { |
|
this._output.space_before_token = true; |
|
} else { |
|
this.print_newline(); |
|
} |
|
} |
|
this.print_token(current_token); |
|
}; |
|
|
|
Beautifier.prototype.handle_equals = function(current_token) { |
|
if (this.start_of_statement(current_token)) { |
|
// The conditional starts the statement if appropriate. |
|
} else { |
|
this.handle_whitespace_and_comments(current_token); |
|
} |
|
|
|
if (this._flags.declaration_statement) { |
|
// just got an '=' in a var-line, different formatting/line-breaking, etc will now be done |
|
this._flags.declaration_assignment = true; |
|
} |
|
this._output.space_before_token = true; |
|
this.print_token(current_token); |
|
this._output.space_before_token = true; |
|
}; |
|
|
|
Beautifier.prototype.handle_comma = function(current_token) { |
|
this.handle_whitespace_and_comments(current_token, true); |
|
|
|
this.print_token(current_token); |
|
this._output.space_before_token = true; |
|
if (this._flags.declaration_statement) { |
|
if (is_expression(this._flags.parent.mode)) { |
|
// do not break on comma, for(var a = 1, b = 2) |
|
this._flags.declaration_assignment = false; |
|
} |
|
|
|
if (this._flags.declaration_assignment) { |
|
this._flags.declaration_assignment = false; |
|
this.print_newline(false, true); |
|
} else if (this._options.comma_first) { |
|
// for comma-first, we want to allow a newline before the comma |
|
// to turn into a newline after the comma, which we will fixup later |
|
this.allow_wrap_or_preserved_newline(current_token); |
|
} |
|
} else if (this._flags.mode === MODE.ObjectLiteral || |
|
(this._flags.mode === MODE.Statement && this._flags.parent.mode === MODE.ObjectLiteral)) { |
|
if (this._flags.mode === MODE.Statement) { |
|
this.restore_mode(); |
|
} |
|
|
|
if (!this._flags.inline_frame) { |
|
this.print_newline(); |
|
} |
|
} else if (this._options.comma_first) { |
|
// EXPR or DO_BLOCK |
|
// for comma-first, we want to allow a newline before the comma |
|
// to turn into a newline after the comma, which we will fixup later |
|
this.allow_wrap_or_preserved_newline(current_token); |
|
} |
|
}; |
|
|
|
Beautifier.prototype.handle_operator = function(current_token) { |
|
var isGeneratorAsterisk = current_token.text === '*' && |
|
(reserved_array(this._flags.last_token, ['function', 'yield']) || |
|
(in_array(this._flags.last_token.type, [TOKEN.START_BLOCK, TOKEN.COMMA, TOKEN.END_BLOCK, TOKEN.SEMICOLON])) |
|
); |
|
var isUnary = in_array(current_token.text, ['-', '+']) && ( |
|
in_array(this._flags.last_token.type, [TOKEN.START_BLOCK, TOKEN.START_EXPR, TOKEN.EQUALS, TOKEN.OPERATOR]) || |
|
in_array(this._flags.last_token.text, line_starters) || |
|
this._flags.last_token.text === ',' |
|
); |
|
|
|
if (this.start_of_statement(current_token)) { |
|
// The conditional starts the statement if appropriate. |
|
} else { |
|
var preserve_statement_flags = !isGeneratorAsterisk; |
|
this.handle_whitespace_and_comments(current_token, preserve_statement_flags); |
|
} |
|
|
|
// hack for actionscript's import .*; |
|
if (current_token.text === '*' && this._flags.last_token.type === TOKEN.DOT) { |
|
this.print_token(current_token); |
|
return; |
|
} |
|
|
|
if (current_token.text === '::') { |
|
// no spaces around exotic namespacing syntax operator |
|
this.print_token(current_token); |
|
return; |
|
} |
|
|
|
if (in_array(current_token.text, ['-', '+']) && this.start_of_object_property()) { |
|
// numeric value with +/- symbol in front as a property |
|
this.print_token(current_token); |
|
return; |
|
} |
|
|
|
// Allow line wrapping between operators when operator_position is |
|
// set to before or preserve |
|
if (this._flags.last_token.type === TOKEN.OPERATOR && in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)) { |
|
this.allow_wrap_or_preserved_newline(current_token); |
|
} |
|
|
|
if (current_token.text === ':' && this._flags.in_case) { |
|
this.print_token(current_token); |
|
|
|
this._flags.in_case = false; |
|
this._flags.case_body = true; |
|
if (this._tokens.peek().type !== TOKEN.START_BLOCK) { |
|
this.indent(); |
|
this.print_newline(); |
|
this._flags.case_block = false; |
|
} else { |
|
this._flags.case_block = true; |
|
this._output.space_before_token = true; |
|
} |
|
return; |
|
} |
|
|
|
var space_before = true; |
|
var space_after = true; |
|
var in_ternary = false; |
|
if (current_token.text === ':') { |
|
if (this._flags.ternary_depth === 0) { |
|
// Colon is invalid javascript outside of ternary and object, but do our best to guess what was meant. |
|
space_before = false; |
|
} else { |
|
this._flags.ternary_depth -= 1; |
|
in_ternary = true; |
|
} |
|
} else if (current_token.text === '?') { |
|
this._flags.ternary_depth += 1; |
|
} |
|
|
|
// let's handle the operator_position option prior to any conflicting logic |
|
if (!isUnary && !isGeneratorAsterisk && this._options.preserve_newlines && in_array(current_token.text, positionable_operators)) { |
|
var isColon = current_token.text === ':'; |
|
var isTernaryColon = (isColon && in_ternary); |
|
var isOtherColon = (isColon && !in_ternary); |
|
|
|
switch (this._options.operator_position) { |
|
case OPERATOR_POSITION.before_newline: |
|
// if the current token is : and it's not a ternary statement then we set space_before to false |
|
this._output.space_before_token = !isOtherColon; |
|
|
|
this.print_token(current_token); |
|
|
|
if (!isColon || isTernaryColon) { |
|
this.allow_wrap_or_preserved_newline(current_token); |
|
} |
|
|
|
this._output.space_before_token = true; |
|
return; |
|
|
|
case OPERATOR_POSITION.after_newline: |
|
// if the current token is anything but colon, or (via deduction) it's a colon and in a ternary statement, |
|
// then print a newline. |
|
|
|
this._output.space_before_token = true; |
|
|
|
if (!isColon || isTernaryColon) { |
|
if (this._tokens.peek().newlines) { |
|
this.print_newline(false, true); |
|
} else { |
|
this.allow_wrap_or_preserved_newline(current_token); |
|
} |
|
} else { |
|
this._output.space_before_token = false; |
|
} |
|
|
|
this.print_token(current_token); |
|
|
|
this._output.space_before_token = true; |
|
return; |
|
|
|
case OPERATOR_POSITION.preserve_newline: |
|
if (!isOtherColon) { |
|
this.allow_wrap_or_preserved_newline(current_token); |
|
} |
|
|
|
// if we just added a newline, or the current token is : and it's not a ternary statement, |
|
// then we set space_before to false |
|
space_before = !(this._output.just_added_newline() || isOtherColon); |
|
|
|
this._output.space_before_token = space_before; |
|
this.print_token(current_token); |
|
this._output.space_before_token = true; |
|
return; |
|
} |
|
} |
|
|
|
if (isGeneratorAsterisk) { |
|
this.allow_wrap_or_preserved_newline(current_token); |
|
space_before = false; |
|
var next_token = this._tokens.peek(); |
|
space_after = next_token && in_array(next_token.type, [TOKEN.WORD, TOKEN.RESERVED]); |
|
} else if (current_token.text === '...') { |
|
this.allow_wrap_or_preserved_newline(current_token); |
|
space_before = this._flags.last_token.type === TOKEN.START_BLOCK; |
|
space_after = false; |
|
} else if (in_array(current_token.text, ['--', '++', '!', '~']) || isUnary) { |
|
// unary operators (and binary +/- pretending to be unary) special cases |
|
if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR) { |
|
this.allow_wrap_or_preserved_newline(current_token); |
|
} |
|
|
|
space_before = false; |
|
space_after = false; |
|
|
|
// http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1 |
|
// if there is a newline between -- or ++ and anything else we should preserve it. |
|
if (current_token.newlines && (current_token.text === '--' || current_token.text === '++' || current_token.text === '~')) { |
|
var new_line_needed = reserved_array(this._flags.last_token, special_words) && current_token.newlines; |
|
if (new_line_needed && (this._previous_flags.if_block || this._previous_flags.else_block)) { |
|
this.restore_mode(); |
|
} |
|
this.print_newline(new_line_needed, true); |
|
} |
|
|
|
if (this._flags.last_token.text === ';' && is_expression(this._flags.mode)) { |
|
// for (;; ++i) |
|
// ^^^ |
|
space_before = true; |
|
} |
|
|
|
if (this._flags.last_token.type === TOKEN.RESERVED) { |
|
space_before = true; |
|
} else if (this._flags.last_token.type === TOKEN.END_EXPR) { |
|
space_before = !(this._flags.last_token.text === ']' && (current_token.text === '--' || current_token.text === '++')); |
|
} else if (this._flags.last_token.type === TOKEN.OPERATOR) { |
|
// a++ + ++b; |
|
// a - -b |
|
space_before = in_array(current_token.text, ['--', '-', '++', '+']) && in_array(this._flags.last_token.text, ['--', '-', '++', '+']); |
|
// + and - are not unary when preceeded by -- or ++ operator |
|
// a-- + b |
|
// a * +b |
|
// a - -b |
|
if (in_array(current_token.text, ['+', '-']) && in_array(this._flags.last_token.text, ['--', '++'])) { |
|
space_after = true; |
|
} |
|
} |
|
|
|
|
|
if (((this._flags.mode === MODE.BlockStatement && !this._flags.inline_frame) || this._flags.mode === MODE.Statement) && |
|
(this._flags.last_token.text === '{' || this._flags.last_token.text === ';')) { |
|
// { foo; --i } |
|
// foo(); --bar; |
|
this.print_newline(); |
|
} |
|
} |
|
|
|
this._output.space_before_token = this._output.space_before_token || space_before; |
|
this.print_token(current_token); |
|
this._output.space_before_token = space_after; |
|
}; |
|
|
|
Beautifier.prototype.handle_block_comment = function(current_token, preserve_statement_flags) { |
|
if (this._output.raw) { |
|
this._output.add_raw_token(current_token); |
|
if (current_token.directives && current_token.directives.preserve === 'end') { |
|
// If we're testing the raw output behavior, do not allow a directive to turn it off. |
|
this._output.raw = this._options.test_output_raw; |
|
} |
|
return; |
|
} |
|
|
|
if (current_token.directives) { |
|
this.print_newline(false, preserve_statement_flags); |
|
this.print_token(current_token); |
|
if (current_token.directives.preserve === 'start') { |
|
this._output.raw = true; |
|
} |
|
this.print_newline(false, true); |
|
return; |
|
} |
|
|
|
// inline block |
|
if (!acorn.newline.test(current_token.text) && !current_token.newlines) { |
|
this._output.space_before_token = true; |
|
this.print_token(current_token); |
|
this._output.space_before_token = true; |
|
return; |
|
} else { |
|
this.print_block_commment(current_token, preserve_statement_flags); |
|
} |
|
}; |
|
|
|
Beautifier.prototype.print_block_commment = function(current_token, preserve_statement_flags) { |
|
var lines = split_linebreaks(current_token.text); |
|
var j; // iterator for this case |
|
var javadoc = false; |
|
var starless = false; |
|
var lastIndent = current_token.whitespace_before; |
|
var lastIndentLength = lastIndent.length; |
|
|
|
// block comment starts with a new line |
|
this.print_newline(false, preserve_statement_flags); |
|
|
|
// first line always indented |
|
this.print_token_line_indentation(current_token); |
|
this._output.add_token(lines[0]); |
|
this.print_newline(false, preserve_statement_flags); |
|
|
|
|
|
if (lines.length > 1) { |
|
lines = lines.slice(1); |
|
javadoc = all_lines_start_with(lines, '*'); |
|
starless = each_line_matches_indent(lines, lastIndent); |
|
|
|
if (javadoc) { |
|
this._flags.alignment = 1; |
|
} |
|
|
|
for (j = 0; j < lines.length; j++) { |
|
if (javadoc) { |
|
// javadoc: reformat and re-indent |
|
this.print_token_line_indentation(current_token); |
|
this._output.add_token(ltrim(lines[j])); |
|
} else if (starless && lines[j]) { |
|
// starless: re-indent non-empty content, avoiding trim |
|
this.print_token_line_indentation(current_token); |
|
this._output.add_token(lines[j].substring(lastIndentLength)); |
|
} else { |
|
// normal comments output raw |
|
this._output.current_line.set_indent(-1); |
|
this._output.add_token(lines[j]); |
|
} |
|
|
|
// for comments on their own line or more than one line, make sure there's a new line after |
|
this.print_newline(false, preserve_statement_flags); |
|
} |
|
|
|
this._flags.alignment = 0; |
|
} |
|
}; |
|
|
|
|
|
Beautifier.prototype.handle_comment = function(current_token, preserve_statement_flags) { |
|
if (current_token.newlines) { |
|
this.print_newline(false, preserve_statement_flags); |
|
} else { |
|
this._output.trim(true); |
|
} |
|
|
|
this._output.space_before_token = true; |
|
this.print_token(current_token); |
|
this.print_newline(false, preserve_statement_flags); |
|
}; |
|
|
|
Beautifier.prototype.handle_dot = function(current_token) { |
|
if (this.start_of_statement(current_token)) { |
|
// The conditional starts the statement if appropriate. |
|
} else { |
|
this.handle_whitespace_and_comments(current_token, true); |
|
} |
|
|
|
if (this._flags.last_token.text.match('^[0-9]+$')) { |
|
this._output.space_before_token = true; |
|
} |
|
|
|
if (reserved_array(this._flags.last_token, special_words)) { |
|
this._output.space_before_token = false; |
|
} else { |
|
// allow preserved newlines before dots in general |
|
// force newlines on dots after close paren when break_chained - for bar().baz() |
|
this.allow_wrap_or_preserved_newline(current_token, |
|
this._flags.last_token.text === ')' && this._options.break_chained_methods); |
|
} |
|
|
|
// Only unindent chained method dot if this dot starts a new line. |
|
// Otherwise the automatic extra indentation removal will handle the over indent |
|
if (this._options.unindent_chained_methods && this._output.just_added_newline()) { |
|
this.deindent(); |
|
} |
|
|
|
this.print_token(current_token); |
|
}; |
|
|
|
Beautifier.prototype.handle_unknown = function(current_token, preserve_statement_flags) { |
|
this.print_token(current_token); |
|
|
|
if (current_token.text[current_token.text.length - 1] === '\n') { |
|
this.print_newline(false, preserve_statement_flags); |
|
} |
|
}; |
|
|
|
Beautifier.prototype.handle_eof = function(current_token) { |
|
// Unwind any open statements |
|
while (this._flags.mode === MODE.Statement) { |
|
this.restore_mode(); |
|
} |
|
this.handle_whitespace_and_comments(current_token); |
|
}; |
|
|
|
module.exports.Beautifier = Beautifier; |
|
|
|
|
|
/***/ }), |
|
/* 2 */ |
|
/***/ (function(module) { |
|
|
|
/*jshint node:true */ |
|
/* |
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
|
|
|
|
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--; |
|
} |
|
}; |
|
|
|
module.exports.Output = Output; |
|
|
|
|
|
/***/ }), |
|
/* 3 */ |
|
/***/ (function(module) { |
|
|
|
/*jshint node:true */ |
|
/* |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
|
|
|
|
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; |
|
} |
|
|
|
|
|
module.exports.Token = Token; |
|
|
|
|
|
/***/ }), |
|
/* 4 */ |
|
/***/ (function(__unused_webpack_module, exports) { |
|
|
|
/* 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 + "]"); |
|
|
|
var unicodeEscapeOrCodePoint = "\\\\u[0-9a-fA-F]{4}|\\\\u\\{[0-9a-fA-F]+\\}"; |
|
var identifierStart = "(?:" + unicodeEscapeOrCodePoint + "|[" + baseASCIIidentifierStartChars + nonASCIIidentifierStartChars + "])"; |
|
var identifierChars = "(?:" + unicodeEscapeOrCodePoint + "|[" + baseASCIIidentifierChars + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "])*"; |
|
|
|
exports.identifier = new RegExp(identifierStart + identifierChars, 'g'); |
|
exports.identifierStart = new RegExp(identifierStart); |
|
exports.identifierMatch = new RegExp("(?:" + unicodeEscapeOrCodePoint + "|[" + 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'); |
|
|
|
|
|
/***/ }), |
|
/* 5 */ |
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) { |
|
|
|
/*jshint node:true */ |
|
/* |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
|
|
|
|
var BaseOptions = (__webpack_require__(6).Options); |
|
|
|
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"; |
|
} 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.prototype = new BaseOptions(); |
|
|
|
|
|
|
|
module.exports.Options = Options; |
|
|
|
|
|
/***/ }), |
|
/* 6 */ |
|
/***/ (function(module) { |
|
|
|
/*jshint node:true */ |
|
/* |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
|
|
|
|
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', 'smarty', 'angular'] |
|
// For now, 'auto' = all off for javascript, all except angular on for html (and inline javascript/css). |
|
// other values ignored |
|
this.templating = this._get_selection_list('templating', ['auto', 'none', 'angular', 'django', 'erb', 'handlebars', 'php', 'smarty'], ['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; |
|
} |
|
|
|
module.exports.Options = Options; |
|
module.exports.normalizeOpts = _normalizeOpts; |
|
module.exports.mergeOpts = _mergeOpts; |
|
|
|
|
|
/***/ }), |
|
/* 7 */ |
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) { |
|
|
|
/*jshint node:true */ |
|
/* |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
|
|
|
|
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; |
|
} |
|
|
|
|
|
var TOKEN = { |
|
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(/\/\*/, /\*\//); |
|
|
|
var number_pattern = /0[xX][0123456789abcdefABCDEF_]*n?|0[oO][01234567_]*n?|0[bB][01_]*n?|\d[\d_]*n|(?:\.\d[\d_]*|\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, "\\$&"); |
|
// ?. 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', 'class', 'extends']); |
|
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); |
|
|
|
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(this._input); |
|
var templatable = new TemplatablePattern(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_.]+|{[^}]+?}|!\[CDATA\[[^\]]*?\]\]|)(\s*{[^}]+?}|\s+[-a-zA-Z:0-9_.]+|\s+[-a-zA-Z:0-9_.]+\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.prototype = new BaseTokenizer(); |
|
|
|
Tokenizer.prototype._is_comment = function(current_token) { |
|
return current_token.type === TOKEN.COMMENT || current_token.type === TOKEN.BLOCK_COMMENT || current_token.type === TOKEN.UNKNOWN; |
|
}; |
|
|
|
Tokenizer.prototype._is_opening = function(current_token) { |
|
return current_token.type === TOKEN.START_BLOCK || current_token.type === TOKEN.START_EXPR; |
|
}; |
|
|
|
Tokenizer.prototype._is_closing = function(current_token, open_token) { |
|
return (current_token.type === TOKEN.END_BLOCK || current_token.type === TOKEN.END_EXPR) && |
|
(open_token && ( |
|
(current_token.text === ']' && open_token.text === '[') || |
|
(current_token.text === ')' && open_token.text === '(') || |
|
(current_token.text === '}' && open_token.text === '{'))); |
|
}; |
|
|
|
Tokenizer.prototype._reset = function() { |
|
in_html_comment = false; |
|
}; |
|
|
|
Tokenizer.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.EOF, ''); |
|
} |
|
|
|
token = token || this._read_non_javascript(c); |
|
token = token || this._read_string(c); |
|
token = token || this._read_pair(c, this._input.peek(1)); // Issue #2062 hack for record type '#{' |
|
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_punctuation(); |
|
token = token || this._create_token(TOKEN.UNKNOWN, this._input.next()); |
|
|
|
return token; |
|
}; |
|
|
|
Tokenizer.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.DOT || |
|
(previous_token.type === TOKEN.RESERVED && (previous_token.text === 'set' || previous_token.text === 'get'))) && |
|
reserved_word_pattern.test(resulting_string)) { |
|
if ((resulting_string === 'in' || resulting_string === 'of') && |
|
(previous_token.type === TOKEN.WORD || previous_token.type === TOKEN.STRING)) { // hack for 'in' and 'of' operators |
|
return this._create_token(TOKEN.OPERATOR, resulting_string); |
|
} |
|
return this._create_token(TOKEN.RESERVED, resulting_string); |
|
} |
|
return this._create_token(TOKEN.WORD, resulting_string); |
|
} |
|
|
|
resulting_string = this.__patterns.number.read(); |
|
if (resulting_string !== '') { |
|
return this._create_token(TOKEN.WORD, resulting_string); |
|
} |
|
}; |
|
|
|
Tokenizer.prototype._read_singles = function(c) { |
|
var token = null; |
|
if (c === '(' || c === '[') { |
|
token = this._create_token(TOKEN.START_EXPR, c); |
|
} else if (c === ')' || c === ']') { |
|
token = this._create_token(TOKEN.END_EXPR, c); |
|
} else if (c === '{') { |
|
token = this._create_token(TOKEN.START_BLOCK, c); |
|
} else if (c === '}') { |
|
token = this._create_token(TOKEN.END_BLOCK, c); |
|
} else if (c === ';') { |
|
token = this._create_token(TOKEN.SEMICOLON, c); |
|
} else if (c === '.' && dot_pattern.test(this._input.peek(1))) { |
|
token = this._create_token(TOKEN.DOT, c); |
|
} else if (c === ',') { |
|
token = this._create_token(TOKEN.COMMA, c); |
|
} |
|
|
|
if (token) { |
|
this._input.next(); |
|
} |
|
return token; |
|
}; |
|
|
|
Tokenizer.prototype._read_pair = function(c, d) { |
|
var token = null; |
|
if (c === '#' && d === '{') { |
|
token = this._create_token(TOKEN.START_BLOCK, c + d); |
|
} |
|
|
|
if (token) { |
|
this._input.next(); |
|
this._input.next(); |
|
} |
|
return token; |
|
}; |
|
|
|
Tokenizer.prototype._read_punctuation = function() { |
|
var resulting_string = this.__patterns.punct.read(); |
|
|
|
if (resulting_string !== '') { |
|
if (resulting_string === '=') { |
|
return this._create_token(TOKEN.EQUALS, resulting_string); |
|
} else if (resulting_string === '?.') { |
|
return this._create_token(TOKEN.DOT, resulting_string); |
|
} else { |
|
return this._create_token(TOKEN.OPERATOR, resulting_string); |
|
} |
|
} |
|
}; |
|
|
|
Tokenizer.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.UNKNOWN, resulting_string.trim() + '\n'); |
|
} |
|
} |
|
|
|
// handles extendscript #includes |
|
resulting_string = this.__patterns.include.read(); |
|
|
|
if (resulting_string) { |
|
return this._create_token(TOKEN.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.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.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.COMMENT, resulting_string); |
|
} |
|
} |
|
|
|
return null; |
|
}; |
|
|
|
Tokenizer.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.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.COMMENT, comment); |
|
} |
|
} |
|
return token; |
|
}; |
|
|
|
Tokenizer.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.STRING, resulting_string); |
|
} |
|
|
|
return null; |
|
}; |
|
|
|
Tokenizer.prototype._allow_regexp_or_xml = function(previous_token) { |
|
// regex and xml can only appear in specific locations during parsing |
|
return (previous_token.type === TOKEN.RESERVED && in_array(previous_token.text, ['return', 'case', 'throw', 'else', 'do', 'typeof', 'yield'])) || |
|
(previous_token.type === TOKEN.END_EXPR && previous_token.text === ')' && |
|
previous_token.opened.previous.type === TOKEN.RESERVED && in_array(previous_token.opened.previous.text, ['if', 'while', 'for'])) || |
|
(in_array(previous_token.type, [TOKEN.COMMENT, TOKEN.START_EXPR, TOKEN.START_BLOCK, TOKEN.START, |
|
TOKEN.END_BLOCK, TOKEN.OPERATOR, TOKEN.EQUALS, TOKEN.EOF, TOKEN.SEMICOLON, TOKEN.COMMA |
|
])); |
|
}; |
|
|
|
Tokenizer.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.STRING, resulting_string); |
|
} |
|
return null; |
|
}; |
|
|
|
Tokenizer.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.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(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); |
|
if (!matched) { |
|
matched = input_scan.match(/u\{([0-9A-Fa-f]+)\}/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]; |
|
} else if (escaped > 0x10FFFF) { |
|
// If the escape sequence is out of bounds, keep the original sequence and continue conversion |
|
out += '\\' + matched[0]; |
|
} 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.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; |
|
}; |
|
|
|
module.exports.Tokenizer = Tokenizer; |
|
module.exports.TOKEN = TOKEN; |
|
module.exports.positionable_operators = positionable_operators.slice(); |
|
module.exports.line_starters = line_starters.slice(); |
|
|
|
|
|
/***/ }), |
|
/* 8 */ |
|
/***/ (function(module) { |
|
|
|
/*jshint node:true */ |
|
/* |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
|
|
|
|
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; |
|
}; |
|
|
|
module.exports.InputScanner = InputScanner; |
|
|
|
|
|
/***/ }), |
|
/* 9 */ |
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) { |
|
|
|
/*jshint node:true */ |
|
/* |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
|
|
|
|
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 TOKEN = { |
|
START: 'TK_START', |
|
RAW: 'TK_RAW', |
|
EOF: 'TK_EOF' |
|
}; |
|
|
|
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(); |
|
} |
|
|
|
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(type, text, |
|
this._patterns.whitespace.newline_count, |
|
this._patterns.whitespace.whitespace_before_token); |
|
return token; |
|
}; |
|
|
|
Tokenizer.prototype._readWhitespace = function() { |
|
return this._patterns.whitespace.read(); |
|
}; |
|
|
|
|
|
|
|
module.exports.Tokenizer = Tokenizer; |
|
module.exports.TOKEN = TOKEN; |
|
|
|
|
|
/***/ }), |
|
/* 10 */ |
|
/***/ (function(module) { |
|
|
|
/*jshint node:true */ |
|
/* |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
|
|
|
|
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; |
|
}; |
|
|
|
module.exports.TokenStream = TokenStream; |
|
|
|
|
|
/***/ }), |
|
/* 11 */ |
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) { |
|
|
|
/*jshint node:true */ |
|
/* |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
|
|
|
|
var Pattern = (__webpack_require__(12).Pattern); |
|
|
|
function WhitespacePattern(input_scanner, parent) { |
|
Pattern.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(); |
|
|
|
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; |
|
}; |
|
|
|
|
|
|
|
module.exports.WhitespacePattern = WhitespacePattern; |
|
|
|
|
|
/***/ }), |
|
/* 12 */ |
|
/***/ (function(module) { |
|
|
|
/*jshint node:true */ |
|
/* |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
|
|
|
|
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() {}; |
|
|
|
module.exports.Pattern = Pattern; |
|
|
|
|
|
/***/ }), |
|
/* 13 */ |
|
/***/ (function(module) { |
|
|
|
/*jshint node:true */ |
|
/* |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
|
|
|
|
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); |
|
}; |
|
|
|
|
|
module.exports.Directives = Directives; |
|
|
|
|
|
/***/ }), |
|
/* 14 */ |
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) { |
|
|
|
/*jshint node:true */ |
|
/* |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. |
|
|
|
Permission is hereby granted, free of charge, to any person |
|
obtaining a copy of this software and associated documentation files |
|
(the "Software"), to deal in the Software without restriction, |
|
including without limitation the rights to use, copy, modify, merge, |
|
publish, distribute, sublicense, and/or sell copies of the Software, |
|
and to permit persons to whom the Software is furnished to do so, |
|
subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
|
|
|
|
var Pattern = (__webpack_require__(12).Pattern); |
|
|
|
|
|
var template_names = { |
|
django: false, |
|
erb: false, |
|
handlebars: false, |
|
php: false, |
|
smarty: false, |
|
angular: 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.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(/#}/), |
|
smarty: pattern.starting_with(/{(?=[^}{\s\n])/).until_after(/[^\s\n]}/), |
|
smarty_comment: pattern.starting_with(/{\*/).until_after(/\*}/), |
|
smarty_literal: pattern.starting_with(/{literal}/).until_after(/{\/literal}/) |
|
}; |
|
} |
|
TemplatablePattern.prototype = new Pattern(); |
|
|
|
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); |
|
// The starting pattern for django is more complex because it has different |
|
// patterns for value, comment, and other sections |
|
items.push(this.__patterns.django_value._starting_pattern.source); |
|
items.push(this.__patterns.django_comment._starting_pattern.source); |
|
} |
|
if (!this._disabled.smarty) { |
|
items.push(this.__patterns.smarty._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_unescaped.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(); |
|
} |
|
} |
|
if (!this._disabled.smarty) { |
|
// smarty cannot be enabled with django or handlebars enabled |
|
if (this._disabled.django && this._disabled.handlebars) { |
|
resulting_string = resulting_string || |
|
this.__patterns.smarty_comment.read(); |
|
resulting_string = resulting_string || |
|
this.__patterns.smarty_literal.read(); |
|
resulting_string = resulting_string || |
|
this.__patterns.smarty.read(); |
|
} |
|
} |
|
} |
|
return resulting_string; |
|
}; |
|
|
|
|
|
module.exports.TemplatablePattern = TemplatablePattern; |
|
|
|
|
|
/***/ }) |
|
/******/ ]); |
|
/************************************************************************/ |
|
/******/ // The module cache |
|
/******/ var __webpack_module_cache__ = {}; |
|
/******/ |
|
/******/ // The require function |
|
/******/ function __webpack_require__(moduleId) { |
|
/******/ // Check if module is in cache |
|
/******/ var cachedModule = __webpack_module_cache__[moduleId]; |
|
/******/ if (cachedModule !== undefined) { |
|
/******/ return cachedModule.exports; |
|
/******/ } |
|
/******/ // Create a new module (and put it into the cache) |
|
/******/ var module = __webpack_module_cache__[moduleId] = { |
|
/******/ // no module.id needed |
|
/******/ // no module.loaded needed |
|
/******/ exports: {} |
|
/******/ }; |
|
/******/ |
|
/******/ // Execute the module function |
|
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); |
|
/******/ |
|
/******/ // Return the exports of the module |
|
/******/ return module.exports; |
|
/******/ } |
|
/******/ |
|
/************************************************************************/ |
|
/******/ |
|
/******/ // startup |
|
/******/ // Load entry module and return exports |
|
/******/ // This entry module is referenced by other modules so it can't be inlined |
|
/******/ var __webpack_exports__ = __webpack_require__(0); |
|
/******/ legacy_beautify_js = __webpack_exports__; |
|
/******/ |
|
/******/ })() |
|
; |
|
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 }; |
|
}); |
|
} else if (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; |
|
} else if (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; |
|
} else if (typeof global !== "undefined") { |
|
// If we don't even have window, try global. |
|
global.js_beautify = js_beautify; |
|
} |
|
|
|
}()); |
|
|
|
|