Update JS beautifier to support ES6 syntax (#1268)
* Update the JavaScript beautifier to support ES6 syntax
* Add test for beautifier
diff --git a/app/addons/components/__tests__/beautify.test.js b/app/addons/components/__tests__/beautify.test.js
index f529d88..faefe5f 100644
--- a/app/addons/components/__tests__/beautify.test.js
+++ b/app/addons/components/__tests__/beautify.test.js
@@ -47,4 +47,22 @@
beautifyEl.simulate('click');
expect(fixedCode).toBe(correctCode);
});
+
+ it('on click beautifies es6 code', () => {
+ let fixedCode;
+ const correctCode = '({\n type,\n code\n}) => type === \'WIDGET\' && emit(code, 1)';
+
+ const beautifiedCode = (code) => {
+ fixedCode = code;
+ };
+
+ beautifyEl = mount(
+ <ReactComponents.Beautify
+ beautifiedCode={beautifiedCode}
+ code={'({type,code}) => type === \'WIDGET\' && emit(code,1)'}
+ noOfLines={1}/>
+ );
+ beautifyEl.simulate('click');
+ expect(fixedCode).toBe(correctCode);
+ });
});
diff --git a/assets/js/plugins/beautify.js b/assets/js/plugins/beautify.js
index 07b6617..4beb640 100644
--- a/assets/js/plugins/beautify.js
+++ b/assets/js/plugins/beautify.js
@@ -1,9 +1,10 @@
/*jshint curly:true, eqeqeq:true, laxbreak:true, noempty:false */
+/* AUTO-GENERATED. DO NOT MODIFY. */
/*
The MIT License (MIT)
- Copyright (c) 2007-2013 Einar Lielmanis and contributors.
+ 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
@@ -29,12 +30,12 @@
---------------
- Written by Einar Lielmanis, <einar@jsbeautifier.org>
- http://jsbeautifier.org/
+ 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@gmail.com>
+ Parsing improvements for brace-less statements by Liam Newman <bitwiseman@beautifier.io>
Usage:
@@ -49,12 +50,21 @@
jslint_happy (default false) - if true, then jslint-stricter mode is enforced.
- jslint_happy !jslint_happy
+ jslint_happy !jslint_happy
---------------------------------
- function () function()
+ function () function()
- brace_style (default "collapse") - "collapse" | "expand" | "end-expand"
- 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.
+ 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 overriden 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)",
@@ -64,6 +74,9 @@
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, {
@@ -73,1558 +86,3962 @@
*/
-
(function() {
- function js_beautify(js_source_text, options) {
- "use strict";
- var beautifier = new Beautifier(js_source_text, options);
- return beautifier.beautify();
+
+/* GENERATED_BUILD_OUTPUT */
+var legacy_beautify_js =
+/******/ (function(modules) { // webpackBootstrap
+/******/ // The module cache
+/******/ var installedModules = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/
+/******/ // Check if module is in cache
+/******/ if(installedModules[moduleId]) {
+/******/ return installedModules[moduleId].exports;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = installedModules[moduleId] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = true;
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/******/
+/******/ // expose the modules object (__webpack_modules__)
+/******/ __webpack_require__.m = modules;
+/******/
+/******/ // expose the module cache
+/******/ __webpack_require__.c = installedModules;
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ }
+/******/ };
+/******/
+/******/ // define __esModule on exports
+/******/ __webpack_require__.r = function(exports) {
+/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ }
+/******/ Object.defineProperty(exports, '__esModule', { value: true });
+/******/ };
+/******/
+/******/ // create a fake namespace object
+/******/ // mode & 1: value is a module id, require it
+/******/ // mode & 2: merge all properties of value into the ns
+/******/ // mode & 4: return value when already ns object
+/******/ // mode & 8|1: behave like require
+/******/ __webpack_require__.t = function(value, mode) {
+/******/ if(mode & 1) value = __webpack_require__(value);
+/******/ if(mode & 8) return value;
+/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ var ns = Object.create(null);
+/******/ __webpack_require__.r(ns);
+/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ return ns;
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/*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, exports, __webpack_require__) {
+
+"use strict";
+/*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,
+ do_block: false,
+ do_while: false,
+ import_block: false,
+ in_case_statement: false, // switch(..){ INSIDE HERE }
+ in_case: false, // we're on the exact line with "case 0:"
+ case_body: false, // the indented case-action block
+ indentation_level: next_indent_level,
+ alignment: 0,
+ line_indent_level: flags_base ? flags_base.line_indent_level : next_indent_level,
+ start_line_index: this._output.get_line_number(),
+ ternary_depth: 0
+ };
+ return next_flags;
+};
+
+Beautifier.prototype._reset = function(source_text) {
+ var baseIndentString = source_text.match(/^[\t ]*/)[0];
+
+ this._last_last_text = ''; // pre-last token text
+ this._output = new Output(this._options, baseIndentString);
+
+ // If testing the ignore directive, start with output disable set to true
+ this._output.raw = this._options.test_output_raw;
+
+
+ // Stack of parsing/formatting states, including MODE.
+ // We tokenize, parse, and output in an almost purely a forward-only stream of token input
+ // and formatted output. This makes the beautifier less accurate than full parsers
+ // but also far more tolerant of syntax errors.
+ //
+ // For example, the default mode is MODE.BlockStatement. If we see a '{' we push a new frame of type
+ // MODE.BlockStatement on the the stack, even though it could be object literal. If we later
+ // encounter a ":", we'll switch to to MODE.ObjectLiteral. If we then see a ";",
+ // most full parsers would die, but the beautifier gracefully falls back to
+ // MODE.BlockStatement and continues on.
+ this._flag_store = [];
+ this.set_mode(MODE.BlockStatement);
+ var tokenizer = new Tokenizer(source_text, this._options);
+ this._tokens = tokenizer.tokenize();
+ return source_text;
+};
+
+Beautifier.prototype.beautify = function() {
+ // if disabled, return the input unchanged.
+ if (this._options.disabled) {
+ 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;
}
- function Beautifier(js_source_text, options) {
- "use strict";
- var input, output_lines;
- var token_text, token_type, last_type, last_last_text, indent_string;
- var flags, previous_flags, flag_store;
- var whitespace, wordchar, punct, parser_pos, line_starters, digits;
- var prefix;
- var input_wanted_newline;
- var output_wrapped, output_space_before_token;
- var input_length, n_newlines, whitespace_before_token;
- var handlers, MODE, opt;
- var preindent_string = '';
+ 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);
+ }
+ }
+ }
+ }
- whitespace = "\n\r\t ".split('');
- wordchar = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$'.split('');
- digits = '0123456789'.split('');
+};
- punct = '+ - * / % & ++ -- = += -= *= /= %= == === != !== > < >= <= >> << >>> >>>= >>= <<= && &= | || ! !! , : ? ^ ^= |= ::';
- punct += ' <%= <% %> <?= <? ?>'; // try to be a good boy and try not to break the markup language identifiers
- punct = punct.split(' ');
+var newline_restricted_tokens = ['async', 'break', 'continue', 'return', 'throw', 'yield'];
- // words which should always start on new line.
- line_starters = 'continue,try,throw,return,var,if,switch,case,default,for,while,break,function'.split(',');
+Beautifier.prototype.allow_wrap_or_preserved_newline = function(current_token, force_linewrap) {
+ force_linewrap = (force_linewrap === undefined) ? false : force_linewrap;
- MODE = {
- BlockStatement: 'BlockStatement', // 'BLOCK'
- Statement: 'Statement', // 'STATEMENT'
- ObjectLiteral: 'ObjectLiteral', // 'OBJECT',
- ArrayLiteral: 'ArrayLiteral', //'[EXPRESSION]',
- ForInitializer: 'ForInitializer', //'(FOR-EXPRESSION)',
- Conditional: 'Conditional', //'(COND-EXPRESSION)',
- Expression: 'Expression' //'(EXPRESSION)'
- };
+ // Never wrap the first token on a line
+ if (this._output.just_added_newline()) {
+ return;
+ }
- handlers = {
- 'TK_START_EXPR': handle_start_expr,
- 'TK_END_EXPR': handle_end_expr,
- 'TK_START_BLOCK': handle_start_block,
- 'TK_END_BLOCK': handle_end_block,
- 'TK_WORD': handle_word,
- 'TK_SEMICOLON': handle_semicolon,
- 'TK_STRING': handle_string,
- 'TK_EQUALS': handle_equals,
- 'TK_OPERATOR': handle_operator,
- 'TK_COMMA': handle_comma,
- 'TK_BLOCK_COMMENT': handle_block_comment,
- 'TK_INLINE_COMMENT': handle_inline_comment,
- 'TK_COMMENT': handle_comment,
- 'TK_DOT': handle_dot,
- 'TK_UNKNOWN': handle_unknown
- };
+ 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);
- function create_flags(flags_base, mode) {
- var next_indent_level = 0;
- if (flags_base) {
- next_indent_level = flags_base.indentation_level;
- next_indent_level += (flags_base.var_line && flags_base.var_line_reindented) ? 1 : 0;
- if (!just_added_newline() &&
- flags_base.line_indent_level > next_indent_level) {
- next_indent_level = flags_base.line_indent_level;
- }
- }
+ 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;
+ }
- var next_flags = {
- mode: mode,
- parent: flags_base,
- last_text: flags_base ? flags_base.last_text : '', // last token text
- last_word: flags_base ? flags_base.last_word : '', // last 'TK_WORD' passed
- var_line: false,
- var_line_tainted: false,
- var_line_reindented: false,
- in_html_comment: false,
- multiline_frame: false,
- if_block: false,
- do_block: false,
- do_while: false,
- in_case_statement: false, // switch(..){ INSIDE HERE }
- in_case: false, // we're on the exact line with "case 0:"
- case_body: false, // the indented case-action block
- indentation_level: next_indent_level,
- line_indent_level: flags_base ? flags_base.line_indent_level : next_indent_level,
- start_line_index: output_lines.length,
- had_comment: false,
- ternary_depth: 0
- }
- return next_flags;
+ 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])) {
+ 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'])) {
+ 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 {
+ // 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'])) {
+ this.set_mode(MODE.ObjectLiteral);
+ } else {
+ this.set_mode(MODE.BlockStatement);
+ }
+ } 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);
+ }
+
+ var empty_braces = !next_token.comments_before && next_token.text === '}';
+ var empty_anonymous_function = empty_braces && this._flags.last_word === 'function' &&
+ this._flags.last_token.type === TOKEN.END_EXPR;
+
+ if (this._options.brace_preserve_inline) // check for inline, set inline_frame if so
+ {
+ // search forward for a newline wanted inside this block
+ var index = 0;
+ var check_token = null;
+ this._flags.inline_frame = true;
+ do {
+ index += 1;
+ check_token = this._tokens.peek(index - 1);
+ if (check_token.newlines) {
+ this._flags.inline_frame = false;
+ break;
+ }
+ } while (check_token.type !== TOKEN.EOF &&
+ !(check_token.type === TOKEN.END_BLOCK && check_token.opened === current_token));
+ }
+
+ if ((this._options.brace_style === "expand" ||
+ (this._options.brace_style === "none" && current_token.newlines)) &&
+ !this._flags.inline_frame) {
+ if (this._flags.last_token.type !== TOKEN.OPERATOR &&
+ (empty_anonymous_function ||
+ this._flags.last_token.type === TOKEN.EQUALS ||
+ (reserved_array(this._flags.last_token, special_words) && this._flags.last_token.text !== 'else'))) {
+ this._output.space_before_token = true;
+ } else {
+ this.print_newline(false, true);
+ }
+ } else { // collapse || inline_frame
+ if (is_array(this._previous_flags.mode) && (this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.COMMA)) {
+ if (this._flags.last_token.type === TOKEN.COMMA || this._options.space_in_paren) {
+ this._output.space_before_token = true;
+ }
+
+ if (this._flags.last_token.type === TOKEN.COMMA || (this._flags.last_token.type === TOKEN.START_EXPR && this._flags.inline_frame)) {
+ this.allow_wrap_or_preserved_newline(current_token);
+ this._previous_flags.multiline_frame = this._previous_flags.multiline_frame || this._flags.multiline_frame;
+ this._flags.multiline_frame = false;
+ }
+ }
+ if (this._flags.last_token.type !== TOKEN.OPERATOR && this._flags.last_token.type !== TOKEN.START_EXPR) {
+ if (this._flags.last_token.type === TOKEN.START_BLOCK && !this._flags.inline_frame) {
+ this.print_newline();
+ } else {
+ this._output.space_before_token = true;
+ }
+ }
+ }
+ this.print_token(current_token);
+ this.indent();
+
+ // Except for specific cases, open braces are followed by a new line.
+ if (!empty_braces && !(this._options.brace_preserve_inline && this._flags.inline_frame)) {
+ this.print_newline();
+ }
+};
+
+Beautifier.prototype.handle_end_block = function(current_token) {
+ // statements must all be closed when their container closes
+ this.handle_whitespace_and_comments(current_token);
+
+ while (this._flags.mode === MODE.Statement) {
+ this.restore_mode();
+ }
+
+ var empty_braces = this._flags.last_token.type === TOKEN.START_BLOCK;
+
+ if (this._flags.inline_frame && !empty_braces) { // try inline_frame (only set if this._options.braces-preserve-inline) first
+ this._output.space_before_token = true;
+ } else if (this._options.brace_style === "expand") {
+ if (!empty_braces) {
+ this.print_newline();
+ }
+ } else {
+ // skip {}
+ if (!empty_braces) {
+ if (is_array(this._flags.mode) && this._options.keep_array_indentation) {
+ // we REALLY need a newline here, but newliner would skip that
+ this._options.keep_array_indentation = false;
+ this.print_newline();
+ this._options.keep_array_indentation = true;
+
+ } else {
+ this.print_newline();
+ }
+ }
+ }
+ this.restore_mode();
+ this.print_token(current_token);
+};
+
+Beautifier.prototype.handle_word = function(current_token) {
+ if (current_token.type === TOKEN.RESERVED) {
+ if (in_array(current_token.text, ['set', 'get']) && this._flags.mode !== MODE.ObjectLiteral) {
+ current_token.type = TOKEN.WORD;
+ } else if (current_token.text === 'import' && 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.last_token.type !== TOKEN.END_BLOCK && (this._flags.case_body || this._options.jslint_happy)) {
+ // switch cases following one another
+ this.deindent();
+ }
+ this._flags.case_body = false;
+
+ this.print_token(current_token);
+ this._flags.in_case = true;
+ return;
+ }
+
+ if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) {
+ if (!this.start_of_object_property()) {
+ this.allow_wrap_or_preserved_newline(current_token);
+ }
+ }
+
+ if (reserved_word(current_token, 'function')) {
+ if (in_array(this._flags.last_token.text, ['}', ';']) ||
+ (this._output.just_added_newline() && !(in_array(this._flags.last_token.text, ['(', '[', '{', ':', '=', ',']) || this._flags.last_token.type === TOKEN.OPERATOR))) {
+ // make sure there is a nice clean space of at least one blank line
+ // before a new function definition
+ if (!this._output.just_added_blankline() && !current_token.comments_before) {
+ this.print_newline();
+ this.print_newline(true);
+ }
+ }
+ if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD) {
+ if (reserved_array(this._flags.last_token, ['get', 'set', 'new', 'export']) ||
+ reserved_array(this._flags.last_token, newline_restricted_tokens)) {
+ this._output.space_before_token = true;
+ } else if (reserved_word(this._flags.last_token, 'default') && this._last_last_text === 'export') {
+ this._output.space_before_token = true;
+ } else if (this._flags.last_token.text === 'declare') {
+ // accomodates Typescript declare function formatting
+ this._output.space_before_token = true;
+ } else {
+ this.print_newline();
+ }
+ } else if (this._flags.last_token.type === TOKEN.OPERATOR || this._flags.last_token.text === '=') {
+ // foo = function
+ this._output.space_before_token = true;
+ } else if (!this._flags.multiline_frame && (is_expression(this._flags.mode) || is_array(this._flags.mode))) {
+ // (function
+ } else {
+ this.print_newline();
+ }
+
+ this.print_token(current_token);
+ this._flags.last_word = current_token.text;
+ return;
+ }
+
+ var prefix = 'NONE';
+
+ if (this._flags.last_token.type === TOKEN.END_BLOCK) {
+
+ if (this._previous_flags.inline_frame) {
+ prefix = 'SPACE';
+ } else if (!reserved_array(current_token, ['else', 'catch', 'finally', 'from'])) {
+ prefix = 'NEWLINE';
+ } else {
+ if (this._options.brace_style === "expand" ||
+ this._options.brace_style === "end-expand" ||
+ (this._options.brace_style === "none" && current_token.newlines)) {
+ prefix = 'NEWLINE';
+ } else {
+ prefix = 'SPACE';
+ this._output.space_before_token = true;
+ }
+ }
+ } else if (this._flags.last_token.type === TOKEN.SEMICOLON && this._flags.mode === MODE.BlockStatement) {
+ // TODO: Should this be for STATEMENT as well?
+ prefix = 'NEWLINE';
+ } else if (this._flags.last_token.type === TOKEN.SEMICOLON && is_expression(this._flags.mode)) {
+ prefix = 'SPACE';
+ } else if (this._flags.last_token.type === TOKEN.STRING) {
+ prefix = 'NEWLINE';
+ } else if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD ||
+ (this._flags.last_token.text === '*' &&
+ (in_array(this._last_last_text, ['function', 'yield']) ||
+ (this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ',']))))) {
+ prefix = 'SPACE';
+ } else if (this._flags.last_token.type === TOKEN.START_BLOCK) {
+ if (this._flags.inline_frame) {
+ prefix = 'SPACE';
+ } else {
+ prefix = 'NEWLINE';
+ }
+ } else if (this._flags.last_token.type === TOKEN.END_EXPR) {
+ this._output.space_before_token = true;
+ prefix = 'NEWLINE';
+ }
+
+ if (reserved_array(current_token, line_starters) && this._flags.last_token.text !== ')') {
+ if (this._flags.inline_frame || this._flags.last_token.text === 'else' || this._flags.last_token.text === 'export') {
+ prefix = 'SPACE';
+ } else {
+ prefix = 'NEWLINE';
+ }
+
+ }
+
+ if (reserved_array(current_token, ['else', 'catch', 'finally'])) {
+ if ((!(this._flags.last_token.type === TOKEN.END_BLOCK && this._previous_flags.mode === MODE.BlockStatement) ||
+ this._options.brace_style === "expand" ||
+ this._options.brace_style === "end-expand" ||
+ (this._options.brace_style === "none" && current_token.newlines)) &&
+ !this._flags.inline_frame) {
+ this.print_newline();
+ } else {
+ this._output.trim(true);
+ var line = this._output.current_line;
+ // If we trimmed and there's something other than a close block before us
+ // put a newline back in. Handles '} // comment' scenario.
+ if (line.last() !== '}') {
+ this.print_newline();
+ }
+ this._output.space_before_token = true;
+ }
+ } else if (prefix === 'NEWLINE') {
+ if (reserved_array(this._flags.last_token, special_words)) {
+ // no newline between 'return nnn'
+ this._output.space_before_token = true;
+ } else if (this._flags.last_token.text === 'declare' && reserved_array(current_token, ['var', 'let', 'const'])) {
+ // accomodates Typescript declare formatting
+ this._output.space_before_token = true;
+ } else if (this._flags.last_token.type !== TOKEN.END_EXPR) {
+ if ((this._flags.last_token.type !== TOKEN.START_EXPR || !reserved_array(current_token, ['var', 'let', 'const'])) && this._flags.last_token.text !== ':') {
+ // no need to force newline on 'var': for (var x = 0...)
+ if (reserved_word(current_token, 'if') && reserved_word(current_token.previous, 'else')) {
+ // no newline for } else if {
+ this._output.space_before_token = true;
+ } else {
+ this.print_newline();
+ }
+ }
+ } else if (reserved_array(current_token, line_starters) && this._flags.last_token.text !== ')') {
+ this.print_newline();
+ }
+ } else if (this._flags.multiline_frame && is_array(this._flags.mode) && this._flags.last_token.text === ',' && this._last_last_text === '}') {
+ this.print_newline(); // }, in lists get a newline treatment
+ } else if (prefix === 'SPACE') {
+ this._output.space_before_token = true;
+ }
+ if (current_token.previous && (current_token.previous.type === TOKEN.WORD || current_token.previous.type === TOKEN.RESERVED)) {
+ this._output.space_before_token = true;
+ }
+ this.print_token(current_token);
+ this._flags.last_word = current_token.text;
+
+ if (current_token.type === TOKEN.RESERVED) {
+ if (current_token.text === 'do') {
+ this._flags.do_block = true;
+ } else if (current_token.text === 'if') {
+ this._flags.if_block = true;
+ } else if (current_token.text === 'import') {
+ this._flags.import_block = true;
+ } else if (this._flags.import_block && reserved_word(current_token, 'from')) {
+ this._flags.import_block = false;
+ }
+ }
+};
+
+Beautifier.prototype.handle_semicolon = function(current_token) {
+ if (this.start_of_statement(current_token)) {
+ // The conditional starts the statement if appropriate.
+ // Semicolon can be the start (and end) of a statement
+ this._output.space_before_token = false;
+ } else {
+ this.handle_whitespace_and_comments(current_token);
+ }
+
+ var next_token = this._tokens.peek();
+ while (this._flags.mode === MODE.Statement &&
+ !(this._flags.if_block && reserved_word(next_token, 'else')) &&
+ !this._flags.do_block) {
+ this.restore_mode();
+ }
+
+ // hacky but effective for the moment
+ if (this._flags.import_block) {
+ this._flags.import_block = false;
+ }
+ this.print_token(current_token);
+};
+
+Beautifier.prototype.handle_string = function(current_token) {
+ if (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 {
+ 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);
+ }
+
+ if (reserved_array(this._flags.last_token, special_words)) {
+ // "return" had a special handling in TK_WORD. Now we need to return the favor
+ this._output.space_before_token = true;
+ this.print_token(current_token);
+ return;
+ }
+
+ // hack for actionscript's import .*;
+ if (current_token.text === '*' && this._flags.last_token.type === TOKEN.DOT) {
+ this.print_token(current_token);
+ return;
+ }
+
+ if (current_token.text === '::') {
+ // no spaces around exotic namespacing syntax operator
+ this.print_token(current_token);
+ return;
+ }
+
+ // Allow line wrapping between operators when operator_position is
+ // set to before or preserve
+ if (this._flags.last_token.type === TOKEN.OPERATOR && in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)) {
+ this.allow_wrap_or_preserved_newline(current_token);
+ }
+
+ if (current_token.text === ':' && this._flags.in_case) {
+ this.print_token(current_token);
+
+ this._flags.in_case = false;
+ this._flags.case_body = true;
+ if (this._tokens.peek().type !== TOKEN.START_BLOCK) {
+ this.indent();
+ this.print_newline();
+ } else {
+ this._output.space_before_token = true;
+ }
+ return;
+ }
+
+ var space_before = true;
+ var space_after = true;
+ var in_ternary = false;
+ if (current_token.text === ':') {
+ if (this._flags.ternary_depth === 0) {
+ // Colon is invalid javascript outside of ternary and object, but do our best to guess what was meant.
+ space_before = false;
+ } else {
+ this._flags.ternary_depth -= 1;
+ in_ternary = true;
+ }
+ } else if (current_token.text === '?') {
+ this._flags.ternary_depth += 1;
+ }
+
+ // let's handle the operator_position option prior to any conflicting logic
+ if (!isUnary && !isGeneratorAsterisk && this._options.preserve_newlines && in_array(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);
}
- // Using object instead of string to allow for later expansion of info about each line
+ this._output.space_before_token = true;
+ return;
- function create_output_line() {
- return {
- text: []
- };
+ 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;
}
- // Some interpreters have unexpected results with foo = baz || bar;
- options = options ? options : {};
- opt = {};
+ this.print_token(current_token);
- // compatibility
- if (options.space_after_anon_function !== undefined && options.jslint_happy === undefined) {
- options.jslint_happy = options.space_after_anon_function;
- }
- if (options.braces_on_own_line !== undefined) { //graceful handling of deprecated option
- opt.brace_style = options.braces_on_own_line ? "expand" : "collapse";
- }
- opt.brace_style = options.brace_style ? options.brace_style : (opt.brace_style ? opt.brace_style : "collapse");
+ this._output.space_before_token = true;
+ return;
- // graceful handling of deprecated option
- if (opt.brace_style === "expand-strict") {
- opt.brace_style = "expand";
+ 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);
- opt.indent_size = options.indent_size ? parseInt(options.indent_size, 10) : 4;
- opt.indent_char = options.indent_char ? options.indent_char : ' ';
- opt.preserve_newlines = (options.preserve_newlines === undefined) ? true : options.preserve_newlines;
- opt.break_chained_methods = (options.break_chained_methods === undefined) ? false : options.break_chained_methods;
- opt.max_preserve_newlines = (options.max_preserve_newlines === undefined) ? 0 : parseInt(options.max_preserve_newlines, 10);
- opt.space_in_paren = (options.space_in_paren === undefined) ? false : options.space_in_paren;
- opt.jslint_happy = (options.jslint_happy === undefined) ? false : options.jslint_happy;
- opt.keep_array_indentation = (options.keep_array_indentation === undefined) ? false : options.keep_array_indentation;
- opt.space_before_conditional = (options.space_before_conditional === undefined) ? true : options.space_before_conditional;
- opt.unescape_strings = (options.unescape_strings === undefined) ? false : options.unescape_strings;
- opt.wrap_line_length = (options.wrap_line_length === undefined) ? 0 : parseInt(options.wrap_line_length, 10);
- opt.e4x = (options.e4x === undefined) ? false : options.e4x;
+ this._output.space_before_token = space_before;
+ this.print_token(current_token);
+ this._output.space_before_token = true;
+ return;
+ }
+ }
- if(options.indent_with_tabs){
- opt.indent_char = '\t';
- opt.indent_size = 1;
- }
+ 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);
+ }
- //----------------------------------
- indent_string = '';
- while (opt.indent_size > 0) {
- indent_string += opt.indent_char;
- opt.indent_size -= 1;
- }
+ space_before = false;
+ space_after = false;
- while (js_source_text && (js_source_text.charAt(0) === ' ' || js_source_text.charAt(0) === '\t')) {
- preindent_string += js_source_text.charAt(0);
- js_source_text = js_source_text.substring(1);
- }
- input = js_source_text;
- // cache the source's length.
- input_length = js_source_text.length;
+ // http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1
+ // if there is a newline between -- or ++ and anything else we should preserve it.
+ if (current_token.newlines && (current_token.text === '--' || current_token.text === '++')) {
+ this.print_newline(false, true);
+ }
- last_type = 'TK_START_BLOCK'; // last token type
- last_last_text = ''; // pre-last token text
- output_lines = [create_output_line()];
- output_wrapped = false;
- output_space_before_token = false;
- whitespace_before_token = [];
+ if (this._flags.last_token.text === ';' && is_expression(this._flags.mode)) {
+ // for (;; ++i)
+ // ^^^
+ space_before = true;
+ }
- // 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.
+ 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 (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, exports, __webpack_require__) {
+
+"use strict";
+/*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, exports, __webpack_require__) {
+
+"use strict";
+/*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(module, exports, __webpack_require__) {
+
+"use strict";
+/* jshint node: true, curly: false */
+// Parts of this section of code is taken from acorn.
+//
+// Acorn was written by Marijn Haverbeke and released under an MIT
+// license. The Unicode regexps (for identifiers and whitespace) were
+// taken from [Esprima](http://esprima.org) by Ariya Hidayat.
+//
+// Git repositories for Acorn are available at
+//
+// http://marijnhaverbeke.nl/git/acorn
+// https://github.com/marijnh/acorn.git
+
+// ## Character categories
+
+
+
+
+// acorn used char codes to squeeze the last bit of performance out
+// Beautifier is okay without that, so we're using regex
+// permit # (23), $ (36), and @ (64). @ is used in ES7 decorators.
+// 65 through 91 are uppercase letters.
+// permit _ (95).
+// 97 through 123 are lowercase letters.
+var baseASCIIidentifierStartChars = "\\x23\\x24\\x40\\x41-\\x5a\\x5f\\x61-\\x7a";
+
+// inside an identifier @ is not allowed but 0-9 are.
+var baseASCIIidentifierChars = "\\x24\\x30-\\x39\\x41-\\x5a\\x5f\\x61-\\x7a";
+
+// Big ugly regular expressions that match characters in the
+// whitespace, identifier, and identifier-start categories. These
+// are only applied when a character is found to actually have a
+// code point above 128.
+var nonASCIIidentifierStartChars = "\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05d0-\\u05ea\\u05f0-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u08a0\\u08a2-\\u08ac\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0977\\u0979-\\u097f\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c33\\u0c35-\\u0c39\\u0c3d\\u0c58\\u0c59\\u0c60\\u0c61\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d60\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e87\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa\\u0eab\\u0ead-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f4\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f0\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1877\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191c\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19c1-\\u19c7\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1ce9-\\u1cec\\u1cee-\\u1cf1\\u1cf5\\u1cf6\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2119-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u212d\\u212f-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u2e2f\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309d-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312d\\u3131-\\u318e\\u31a0-\\u31ba\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fcc\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua697\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua78e\\ua790-\\ua793\\ua7a0-\\ua7aa\\ua7f8-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa80-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uabc0-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc";
+var nonASCIIidentifierChars = "\\u0300-\\u036f\\u0483-\\u0487\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u0620-\\u0649\\u0672-\\u06d3\\u06e7-\\u06e8\\u06fb-\\u06fc\\u0730-\\u074a\\u0800-\\u0814\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0840-\\u0857\\u08e4-\\u08fe\\u0900-\\u0903\\u093a-\\u093c\\u093e-\\u094f\\u0951-\\u0957\\u0962-\\u0963\\u0966-\\u096f\\u0981-\\u0983\\u09bc\\u09be-\\u09c4\\u09c7\\u09c8\\u09d7\\u09df-\\u09e0\\u0a01-\\u0a03\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a66-\\u0a71\\u0a75\\u0a81-\\u0a83\\u0abc\\u0abe-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ae2-\\u0ae3\\u0ae6-\\u0aef\\u0b01-\\u0b03\\u0b3c\\u0b3e-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b56\\u0b57\\u0b5f-\\u0b60\\u0b66-\\u0b6f\\u0b82\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd7\\u0be6-\\u0bef\\u0c01-\\u0c03\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62-\\u0c63\\u0c66-\\u0c6f\\u0c82\\u0c83\\u0cbc\\u0cbe-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0ce2-\\u0ce3\\u0ce6-\\u0cef\\u0d02\\u0d03\\u0d46-\\u0d48\\u0d57\\u0d62-\\u0d63\\u0d66-\\u0d6f\\u0d82\\u0d83\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0df2\\u0df3\\u0e34-\\u0e3a\\u0e40-\\u0e45\\u0e50-\\u0e59\\u0eb4-\\u0eb9\\u0ec8-\\u0ecd\\u0ed0-\\u0ed9\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f41-\\u0f47\\u0f71-\\u0f84\\u0f86-\\u0f87\\u0f8d-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u1000-\\u1029\\u1040-\\u1049\\u1067-\\u106d\\u1071-\\u1074\\u1082-\\u108d\\u108f-\\u109d\\u135d-\\u135f\\u170e-\\u1710\\u1720-\\u1730\\u1740-\\u1750\\u1772\\u1773\\u1780-\\u17b2\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u1810-\\u1819\\u1920-\\u192b\\u1930-\\u193b\\u1951-\\u196d\\u19b0-\\u19c0\\u19c8-\\u19c9\\u19d0-\\u19d9\\u1a00-\\u1a15\\u1a20-\\u1a53\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1b46-\\u1b4b\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1bb0-\\u1bb9\\u1be6-\\u1bf3\\u1c00-\\u1c22\\u1c40-\\u1c49\\u1c5b-\\u1c7d\\u1cd0-\\u1cd2\\u1d00-\\u1dbe\\u1e01-\\u1f15\\u200c\\u200d\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2d81-\\u2d96\\u2de0-\\u2dff\\u3021-\\u3028\\u3099\\u309a\\ua640-\\ua66d\\ua674-\\ua67d\\ua69f\\ua6f0-\\ua6f1\\ua7f8-\\ua800\\ua806\\ua80b\\ua823-\\ua827\\ua880-\\ua881\\ua8b4-\\ua8c4\\ua8d0-\\ua8d9\\ua8f3-\\ua8f7\\ua900-\\ua909\\ua926-\\ua92d\\ua930-\\ua945\\ua980-\\ua983\\ua9b3-\\ua9c0\\uaa00-\\uaa27\\uaa40-\\uaa41\\uaa4c-\\uaa4d\\uaa50-\\uaa59\\uaa7b\\uaae0-\\uaae9\\uaaf2-\\uaaf3\\uabc0-\\uabe1\\uabec\\uabed\\uabf0-\\uabf9\\ufb20-\\ufb28\\ufe00-\\ufe0f\\ufe20-\\ufe26\\ufe33\\ufe34\\ufe4d-\\ufe4f\\uff10-\\uff19\\uff3f";
+//var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+//var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+var identifierStart = "(?:\\\\u[0-9a-fA-F]{4}|[" + baseASCIIidentifierStartChars + nonASCIIidentifierStartChars + "])";
+var identifierChars = "(?:\\\\u[0-9a-fA-F]{4}|[" + baseASCIIidentifierChars + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "])*";
+
+exports.identifier = new RegExp(identifierStart + identifierChars, 'g');
+exports.identifierStart = new RegExp(identifierStart);
+exports.identifierMatch = new RegExp("(?:\\\\u[0-9a-fA-F]{4}|[" + baseASCIIidentifierChars + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "])+");
+
+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, exports, __webpack_require__) {
+
+"use strict";
+/*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, exports, __webpack_require__) {
+
+"use strict";
+/*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']
+ // For now, 'auto' = all off for javascript, all on for html (and inline javascript).
+ // other values ignored
+ this.templating = this._get_selection_list('templating', ['auto', 'none', 'django', 'erb', 'handlebars', 'php'], ['auto']);
+}
+
+Options.prototype._get_array = function(name, default_value) {
+ var option_value = this.raw_options[name];
+ var result = default_value || [];
+ if (typeof option_value === 'object') {
+ if (option_value !== null && typeof option_value.concat === 'function') {
+ result = option_value.concat();
+ }
+ } else if (typeof option_value === 'string') {
+ result = option_value.split(/[^a-zA-Z0-9_\/\-]+/);
+ }
+ return result;
+};
+
+Options.prototype._get_boolean = function(name, default_value) {
+ var option_value = this.raw_options[name];
+ var result = option_value === undefined ? !!default_value : !!option_value;
+ return result;
+};
+
+Options.prototype._get_characters = function(name, default_value) {
+ var option_value = this.raw_options[name];
+ var result = default_value || '';
+ if (typeof option_value === 'string') {
+ result = option_value.replace(/\\r/, '\r').replace(/\\n/, '\n').replace(/\\t/, '\t');
+ }
+ return result;
+};
+
+Options.prototype._get_number = function(name, default_value) {
+ var option_value = this.raw_options[name];
+ default_value = parseInt(default_value, 10);
+ if (isNaN(default_value)) {
+ default_value = 0;
+ }
+ var result = parseInt(option_value, 10);
+ if (isNaN(result)) {
+ result = default_value;
+ }
+ return result;
+};
+
+Options.prototype._get_selection = function(name, selection_list, default_value) {
+ var result = this._get_selection_list(name, selection_list, default_value);
+ if (result.length !== 1) {
+ throw new Error(
+ "Invalid Option Value: The option '" + name + "' can only be one of the following values:\n" +
+ selection_list + "\nYou passed in: '" + this.raw_options[name] + "'");
+ }
+
+ return result[0];
+};
+
+
+Options.prototype._get_selection_list = function(name, selection_list, default_value) {
+ if (!selection_list || selection_list.length === 0) {
+ throw new Error("Selection list cannot be empty.");
+ }
+
+ default_value = default_value || [selection_list[0]];
+ if (!this._is_valid_selection(default_value, selection_list)) {
+ throw new Error("Invalid Default Value!");
+ }
+
+ var result = this._get_array(name, default_value);
+ if (!this._is_valid_selection(result, selection_list)) {
+ throw new Error(
+ "Invalid Option Value: The option '" + name + "' can contain only the following values:\n" +
+ selection_list + "\nYou passed in: '" + this.raw_options[name] + "'");
+ }
+
+ return result;
+};
+
+Options.prototype._is_valid_selection = function(result, selection_list) {
+ return result.length && selection_list.length &&
+ !result.some(function(item) { return selection_list.indexOf(item) === -1; });
+};
+
+
+// merges child options up with the parent options object
+// Example: obj = {a: 1, b: {a: 2}}
+// mergeOpts(obj, 'b')
+//
+// Returns: {a: 2}
+function _mergeOpts(allOptions, childFieldName) {
+ var finalOpts = {};
+ allOptions = _normalizeOpts(allOptions);
+ var name;
+
+ for (name in allOptions) {
+ if (name !== childFieldName) {
+ finalOpts[name] = allOptions[name];
+ }
+ }
+
+ //merge in the per type settings for the childFieldName
+ if (childFieldName && allOptions[childFieldName]) {
+ for (name in allOptions[childFieldName]) {
+ finalOpts[name] = allOptions[childFieldName][name];
+ }
+ }
+ return finalOpts;
+}
+
+function _normalizeOpts(options) {
+ var convertedOpts = {};
+ var key;
+
+ for (key in options) {
+ var newKey = key.replace(/-/g, "_");
+ convertedOpts[newKey] = options[key];
+ }
+ return convertedOpts;
+}
+
+module.exports.Options = Options;
+module.exports.normalizeOpts = _normalizeOpts;
+module.exports.mergeOpts = _mergeOpts;
+
+
+/***/ }),
+/* 7 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/*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]*|0[oO][01234567]*|0[bB][01]*|\d+n|(?:\.\d+|\d+\.?\d*)(?:[eE][+-]?\d+)?/;
+
+var digit = /[0-9]/;
+
+// Dot "." must be distinguished from "..." and decimal
+var dot_pattern = /[^\d\.]/;
+
+var positionable_operators = (
+ ">>> === !== " +
+ "<< && >= ** != == <= >> || |> " +
+ "< / - + > : & % ? ^ | *").split(' ');
+
+// IMPORTANT: this must be sorted longest to shortest or tokenizing many not work.
+// Also, you must update possitionable operators separately from punct
+var punct =
+ ">>>= " +
+ "... >>= <<= === >>> !== **= " +
+ "=> ^= :: /= << <= == && -= >= >> != -- += ** || ++ %= &= *= |= |> " +
+ "= ! ? > < : / ^ - + * & % ~ |";
+
+punct = punct.replace(/[-[\]{}()*+?.,\\^$|#]/g, "\\$&");
+// ?. but not if followed by a number
+punct = '\\?\\.(?!\\d) ' + punct;
+punct = punct.replace(/ /g, '|');
+
+var punct_pattern = new RegExp(punct);
+
+// words which should always start on new line.
+var line_starters = 'continue,try,throw,return,var,let,const,if,switch,case,default,for,while,break,function,import,export'.split(',');
+var reserved_words = line_starters.concat(['do', 'in', 'of', 'else', 'get', 'set', 'new', 'catch', 'finally', 'typeof', 'yield', 'async', 'await', 'from', 'as']);
+var reserved_word_pattern = new RegExp('^(?:' + reserved_words.join('|') + ')$');
+
+// var template_pattern = /(?:(?:<\?php|<\?=)[\s\S]*?\?>)|(?:<%[\s\S]*?%>)/g;
+
+var in_html_comment;
+
+var Tokenizer = function(input_string, options) {
+ BaseTokenizer.call(this, input_string, options);
+
+ 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_.]+|{[\s\S]+?}|!\[CDATA\[[\s\S]*?\]\])(\s+{[\s\S]+?}|\s+[-a-zA-Z:0-9_.]+|\s+[-a-zA-Z:0-9_.]+\s*=\s*('[^']*'|"[^"]*"|{[\s\S]+?}))*\s*(\/?)\s*>/),
+ single_quote: templatable.until(/['\\\n\r\u2028\u2029]/),
+ double_quote: templatable.until(/["\\\n\r\u2028\u2029]/),
+ template_text: templatable.until(/[`\\$]/),
+ template_expression: templatable.until(/[`}\\]/)
+ };
+
+};
+Tokenizer.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_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') { // 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_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 === '#') {
//
- // 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.
- flag_store = [];
- set_mode(MODE.BlockStatement);
-
- parser_pos = 0;
-
- this.beautify = function() {
- /*jshint onevar:true */
- var t, i, keep_whitespace, sweet_code;
-
- while (true) {
- t = get_next_token();
- token_text = t[0];
- token_type = t[1];
-
- if (token_type === 'TK_EOF') {
- break;
- }
-
- keep_whitespace = opt.keep_array_indentation && is_array(flags.mode);
- input_wanted_newline = n_newlines > 0;
-
- if (keep_whitespace) {
- for (i = 0; i < n_newlines; i += 1) {
- print_newline(i > 0);
- }
- } else {
- if (opt.max_preserve_newlines && n_newlines > opt.max_preserve_newlines) {
- n_newlines = opt.max_preserve_newlines;
- }
-
- if (opt.preserve_newlines) {
- if (n_newlines > 1) {
- print_newline();
- for (i = 1; i < n_newlines; i += 1) {
- print_newline(true);
- }
- }
- }
- }
-
- handlers[token_type]();
-
- // 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.
- if (token_type !== 'TK_INLINE_COMMENT' && token_type !== 'TK_COMMENT' &&
- token_type !== 'TK_BLOCK_COMMENT' && token_type !== 'TK_UNKNOWN') {
- last_last_text = flags.last_text;
- last_type = token_type;
- flags.last_text = token_text;
- }
- flags.had_comment = (token_type === 'TK_INLINE_COMMENT' || token_type === 'TK_COMMENT'
- || token_type === 'TK_BLOCK_COMMENT');
- }
-
-
- sweet_code = output_lines[0].text.join('');
- for (var line_index = 1; line_index < output_lines.length; line_index++) {
- sweet_code += '\n' + output_lines[line_index].text.join('');
- }
- sweet_code = sweet_code.replace(/[\r\n ]+$/, '');
- return sweet_code;
- };
-
- function trim_output(eat_newlines) {
- eat_newlines = (eat_newlines === undefined) ? false : eat_newlines;
-
- if (output_lines.length) {
- trim_output_line(output_lines[output_lines.length - 1], eat_newlines);
-
- while (eat_newlines && output_lines.length > 1 &&
- output_lines[output_lines.length - 1].text.length === 0) {
- output_lines.pop();
- trim_output_line(output_lines[output_lines.length - 1], eat_newlines);
- }
- }
- }
-
- function trim_output_line(line) {
- while (line.text.length &&
- (line.text[line.text.length - 1] === ' ' ||
- line.text[line.text.length - 1] === indent_string ||
- line.text[line.text.length - 1] === preindent_string)) {
- line.text.pop();
- }
- }
-
- function trim(s) {
- return s.replace(/^\s+|\s+$/g, '');
- }
-
- // we could use just string.split, but
- // IE doesn't like returning empty strings
-
- function split_newlines(s) {
- //return s.split(/\x0d\x0a|\x0a/);
-
- s = s.replace(/\x0d/g, '');
- 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 just_added_newline() {
- var line = output_lines[output_lines.length - 1];
- return line.text.length === 0;
- }
-
- function just_added_blankline() {
- if (just_added_newline()) {
- if (output_lines.length === 1) {
- return true; // start of the file and newline = blank
- }
-
- var line = output_lines[output_lines.length - 2];
- return line.text.length === 0;
- }
- return false;
- }
-
- function allow_wrap_or_preserved_newline(force_linewrap) {
- force_linewrap = (force_linewrap === undefined) ? false : force_linewrap;
- if (opt.wrap_line_length && !force_linewrap) {
- var line = output_lines[output_lines.length - 1];
- var proposed_line_length = 0;
- // never wrap the first token of a line.
- if (line.text.length > 0) {
- proposed_line_length = line.text.join('').length + token_text.length +
- (output_space_before_token ? 1 : 0);
- if (proposed_line_length >= opt.wrap_line_length) {
- force_linewrap = true;
- }
- }
- }
- if (((opt.preserve_newlines && input_wanted_newline) || force_linewrap) && !just_added_newline()) {
- print_newline(false, true);
-
- // Expressions and array literals already indent their contents.
- if (!(is_array(flags.mode) || is_expression(flags.mode))) {
- output_wrapped = true;
- }
- }
- }
-
- function print_newline(force_newline, preserve_statement_flags) {
- output_wrapped = false;
- output_space_before_token = false;
-
- if (!preserve_statement_flags) {
- if (flags.last_text !== ';') {
- while (flags.mode === MODE.Statement && !flags.if_block && !flags.do_block) {
- restore_mode();
- }
- }
- }
-
- if (output_lines.length === 1 && just_added_newline()) {
- return; // no newline on start of file
- }
-
- if (force_newline || !just_added_newline()) {
- flags.multiline_frame = true;
- output_lines.push(create_output_line());
- }
- }
-
- function print_token_line_indentation() {
- if (just_added_newline()) {
- var line = output_lines[output_lines.length - 1];
- if (opt.keep_array_indentation && is_array(flags.mode) && input_wanted_newline) {
- // prevent removing of this whitespace as redundant
- line.text.push('');
- for (var i = 0; i < whitespace_before_token.length; i += 1) {
- line.text.push(whitespace_before_token[i]);
- }
- } else {
- if (preindent_string) {
- line.text.push(preindent_string);
- }
-
- print_indent_string(flags.indentation_level +
- (flags.var_line && flags.var_line_reindented ? 1 : 0) +
- (output_wrapped ? 1 : 0));
- }
- }
- }
-
- function print_indent_string(level) {
- // Never indent your first output indent at the start of the file
- if (output_lines.length > 1) {
- var line = output_lines[output_lines.length - 1];
-
- flags.line_indent_level = level;
- for (var i = 0; i < level; i += 1) {
- line.text.push(indent_string);
- }
- }
- }
-
- function print_token_space_before() {
- var line = output_lines[output_lines.length - 1];
- if (output_space_before_token && line.text.length) {
- var last_output = line.text[line.text.length - 1];
- if (last_output !== ' ' && last_output !== indent_string) { // prevent occassional duplicate space
- line.text.push(' ');
- }
- }
- }
-
- function print_token(printable_token) {
- printable_token = printable_token || token_text;
- print_token_line_indentation();
- output_wrapped = false;
- print_token_space_before();
- output_space_before_token = false;
- output_lines[output_lines.length - 1].text.push(printable_token);
- }
-
- function indent() {
- flags.indentation_level += 1;
- }
-
- function deindent() {
- if (flags.indentation_level > 0 &&
- ((!flags.parent) || flags.indentation_level > flags.parent.indentation_level))
- flags.indentation_level -= 1;
- }
-
- function remove_redundant_indentation(frame) {
- // This implementation is effective but has some issues:
- // - less than great performance due to array splicing
- // - 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) return;
-
- // remove one indent from each line inside this section
- var index = frame.start_line_index;
- var splice_index = 0;
- var line;
-
- while (index < output_lines.length) {
- line = output_lines[index];
- index++;
-
- // skip empty lines
- if (line.text.length === 0) {
- continue;
- }
-
- // skip the preindent string if present
- if (preindent_string && line.text[0] === preindent_string) {
- splice_index = 1;
- } else {
- splice_index = 0;
- }
-
- // remove one indent, if present
- if (line.text[splice_index] === indent_string) {
- line.text.splice(splice_index, 1);
- }
- }
- }
-
- function set_mode(mode) {
- if (flags) {
- flag_store.push(flags);
- previous_flags = flags;
- } else {
- previous_flags = create_flags(null, mode);
- }
-
- flags = create_flags(previous_flags, mode);
- }
-
- function is_array(mode) {
- return mode === MODE.ArrayLiteral;
- }
-
- function is_expression(mode) {
- return in_array(mode, [MODE.Expression, MODE.ForInitializer, MODE.Conditional]);
- }
-
- function restore_mode() {
- if (flag_store.length > 0) {
- previous_flags = flags;
- flags = flag_store.pop();
- }
- }
-
- function start_of_object_property() {
- return flags.mode === MODE.ObjectLiteral && flags.last_text === ':' &&
- flags.ternary_depth === 0;
- }
-
- function start_of_statement() {
- if (
- (flags.last_text === 'do' ||
- (flags.last_text === 'else' && token_text !== 'if') ||
- (last_type === 'TK_END_EXPR' && (previous_flags.mode === MODE.ForInitializer || previous_flags.mode === MODE.Conditional)))) {
- // 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();
- allow_wrap_or_preserved_newline(
- in_array(token_text, ['do', 'for', 'if', 'while']));
-
- set_mode(MODE.Statement);
- // Issue #275:
- // If starting on a newline, all of a statement should be indented.
- // if not, use line wrapping logic for indent.
- if (just_added_newline()) {
- indent();
- output_wrapped = false;
- }
- return true;
- }
- return false;
- }
-
- function all_lines_start_with(lines, c) {
- for (var i = 0; i < lines.length; i++) {
- var line = trim(lines[i]);
- if (line.charAt(0) !== c) {
- return false;
- }
- }
- return true;
- }
-
- function is_special_word(word) {
- return in_array(word, ['case', 'return', 'do', 'if', 'throw', 'else']);
- }
-
- function in_array(what, arr) {
- for (var i = 0; i < arr.length; i += 1) {
- if (arr[i] === what) {
- return true;
- }
- }
- return false;
- }
-
- function unescape_string(s) {
- var esc = false,
- out = '',
- pos = 0,
- s_hex = '',
- escaped = 0,
- c;
-
- while (esc || pos < s.length) {
-
- c = s.charAt(pos);
- pos++;
-
- if (esc) {
- esc = false;
- if (c === 'x') {
- // simple hex-escape \x24
- s_hex = s.substr(pos, 2);
- pos += 2;
- } else if (c === 'u') {
- // unicode-escape, \u2134
- s_hex = s.substr(pos, 4);
- pos += 4;
- } else {
- // some common escape, e.g \n
- out += '\\' + c;
- continue;
- }
- if (!s_hex.match(/^[0123456789abcdefABCDEF]+$/)) {
- // some weird escaping, bail out,
- // leaving whole string intact
- return s;
- }
-
- escaped = parseInt(s_hex, 16);
-
- if (escaped >= 0x00 && escaped < 0x20) {
- // leave 0x00...0x1f escaped
- if (c === 'x') {
- out += '\\x' + s_hex;
- } else {
- out += '\\u' + s_hex;
- }
- continue;
- } else if (escaped === 0x22 || escaped === 0x27 || escaped === 0x5c) {
- // single-quote, apostrophe, backslash - escape these
- out += '\\' + String.fromCharCode(escaped);
- } else if (c === 'x' && escaped > 0x7e && escaped <= 0xff) {
- // we bail out on \x7f..\xff,
- // leaving whole string escaped,
- // as it's probably completely binary
- return s;
- } else {
- out += String.fromCharCode(escaped);
- }
- } else if (c === '\\') {
- esc = true;
- } else {
- out += c;
- }
- }
- return out;
- }
-
- function is_next(find) {
- var local_pos = parser_pos;
- var c = input.charAt(local_pos);
- while (in_array(c, whitespace) && c !== find) {
- local_pos++;
- if (local_pos >= input_length) {
- return false;
- }
- c = input.charAt(local_pos);
- }
- return c === find;
- }
-
- function get_next_token() {
- var i, resulting_string;
-
- n_newlines = 0;
-
- if (parser_pos >= input_length) {
- return ['', 'TK_EOF'];
- }
-
- input_wanted_newline = false;
- whitespace_before_token = [];
-
- var c = input.charAt(parser_pos);
- parser_pos += 1;
-
- while (in_array(c, whitespace)) {
-
- if (c === '\n') {
- n_newlines += 1;
- whitespace_before_token = [];
- } else if (n_newlines) {
- if (c === indent_string) {
- whitespace_before_token.push(indent_string);
- } else if (c !== '\r') {
- whitespace_before_token.push(' ');
- }
- }
-
- if (parser_pos >= input_length) {
- return ['', 'TK_EOF'];
- }
-
- c = input.charAt(parser_pos);
- parser_pos += 1;
- }
-
- if (in_array(c, wordchar)) {
- if (parser_pos < input_length) {
- while (in_array(input.charAt(parser_pos), wordchar)) {
- c += input.charAt(parser_pos);
- parser_pos += 1;
- if (parser_pos === input_length) {
- break;
- }
- }
- }
-
- // small and surprisingly unugly hack for 1E-10 representation
- if (parser_pos !== input_length && c.match(/^[0-9]+[Ee]$/) && (input.charAt(parser_pos) === '-' || input.charAt(parser_pos) === '+')) {
-
- var sign = input.charAt(parser_pos);
- parser_pos += 1;
-
- var t = get_next_token();
- c += sign + t[0];
- return [c, 'TK_WORD'];
- }
-
- if (c === 'in') { // hack for 'in' operator
- return [c, 'TK_OPERATOR'];
- }
- return [c, 'TK_WORD'];
- }
-
- if (c === '(' || c === '[') {
- return [c, 'TK_START_EXPR'];
- }
-
- if (c === ')' || c === ']') {
- return [c, 'TK_END_EXPR'];
- }
-
- if (c === '{') {
- return [c, 'TK_START_BLOCK'];
- }
-
- if (c === '}') {
- return [c, 'TK_END_BLOCK'];
- }
-
- if (c === ';') {
- return [c, 'TK_SEMICOLON'];
- }
-
- if (c === '/') {
- var comment = '';
- // peek for comment /* ... */
- var inline_comment = true;
- if (input.charAt(parser_pos) === '*') {
- parser_pos += 1;
- if (parser_pos < input_length) {
- while (parser_pos < input_length && !(input.charAt(parser_pos) === '*' && input.charAt(parser_pos + 1) && input.charAt(parser_pos + 1) === '/')) {
- c = input.charAt(parser_pos);
- comment += c;
- if (c === "\n" || c === "\r") {
- inline_comment = false;
- }
- parser_pos += 1;
- if (parser_pos >= input_length) {
- break;
- }
- }
- }
- parser_pos += 2;
- if (inline_comment && n_newlines === 0) {
- return ['/*' + comment + '*/', 'TK_INLINE_COMMENT'];
- } else {
- return ['/*' + comment + '*/', 'TK_BLOCK_COMMENT'];
- }
- }
- // peek for comment // ...
- if (input.charAt(parser_pos) === '/') {
- comment = c;
- while (input.charAt(parser_pos) !== '\r' && input.charAt(parser_pos) !== '\n') {
- comment += input.charAt(parser_pos);
- parser_pos += 1;
- if (parser_pos >= input_length) {
- break;
- }
- }
- return [comment, 'TK_COMMENT'];
- }
-
- }
-
-
- if (c === "'" || c === '"' || // string
- (
- (c === '/') || // regexp
- (opt.e4x && c === "<" && input.slice(parser_pos - 1).match(/^<([-a-zA-Z:0-9_.]+|{[^{}]*}|!\[CDATA\[[\s\S]*?\]\])\s*([-a-zA-Z:0-9_.]+=('[^']*'|"[^"]*"|{[^{}]*})\s*)*\/?\s*>/)) // xml
- ) && ( // regex and xml can only appear in specific locations during parsing
- (last_type === 'TK_WORD' && is_special_word(flags.last_text)) ||
- (last_type === 'TK_END_EXPR' && in_array(previous_flags.mode, [MODE.Conditional, MODE.ForInitializer])) ||
- (in_array(last_type, ['TK_COMMENT', 'TK_START_EXPR', 'TK_START_BLOCK',
- 'TK_END_BLOCK', 'TK_OPERATOR', 'TK_EQUALS', 'TK_EOF', 'TK_SEMICOLON', 'TK_COMMA'
- ]))
- )) {
-
- var sep = c,
- esc = false,
- has_char_escapes = false;
-
- resulting_string = c;
-
- if (parser_pos < input_length) {
- if (sep === '/') {
- //
- // handle regexp
- //
- var in_char_class = false;
- while (esc || in_char_class || input.charAt(parser_pos) !== sep) {
- resulting_string += input.charAt(parser_pos);
- if (!esc) {
- esc = input.charAt(parser_pos) === '\\';
- if (input.charAt(parser_pos) === '[') {
- in_char_class = true;
- } else if (input.charAt(parser_pos) === ']') {
- in_char_class = false;
- }
- } else {
- esc = false;
- }
- parser_pos += 1;
- if (parser_pos >= input_length) {
- // incomplete string/rexp when end-of-file reached.
- // bail out with what had been received so far.
- return [resulting_string, 'TK_STRING'];
- }
- }
- } else if (opt.e4x && sep === '<') {
- //
- // handle e4x xml literals
- //
- var xmlRegExp = /<(\/?)([-a-zA-Z:0-9_.]+|{[^{}]*}|!\[CDATA\[[\s\S]*?\]\])\s*([-a-zA-Z:0-9_.]+=('[^']*'|"[^"]*"|{[^{}]*})\s*)*(\/?)\s*>/g;
- var xmlStr = input.slice(parser_pos - 1);
- var match = xmlRegExp.exec(xmlStr);
- if (match && match.index === 0) {
- var rootTag = match[2];
- 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 (tagName === rootTag && !isSingletonTag) {
- if (isEndTag) {
- --depth;
- } else {
- ++depth;
- }
- }
- if (depth <= 0) {
- break;
- }
- match = xmlRegExp.exec(xmlStr);
- }
- var xmlLength = match ? match.index + match[0].length : xmlStr.length;
- parser_pos += xmlLength - 1;
- return [xmlStr.slice(0, xmlLength), "TK_STRING"];
- }
- } else {
- //
- // handle string
- //
- while (esc || input.charAt(parser_pos) !== sep) {
- resulting_string += input.charAt(parser_pos);
- if (esc) {
- if (input.charAt(parser_pos) === 'x' || input.charAt(parser_pos) === 'u') {
- has_char_escapes = true;
- }
- esc = false;
- } else {
- esc = input.charAt(parser_pos) === '\\';
- }
- parser_pos += 1;
- if (parser_pos >= input_length) {
- // incomplete string/rexp when end-of-file reached.
- // bail out with what had been received so far.
- return [resulting_string, 'TK_STRING'];
- }
- }
-
- }
- }
-
- parser_pos += 1;
- resulting_string += sep;
-
- if (has_char_escapes && opt.unescape_strings) {
- resulting_string = unescape_string(resulting_string);
- }
-
- if (sep === '/') {
- // regexps may have modifiers /regexp/MOD , so fetch those, too
- while (parser_pos < input_length && in_array(input.charAt(parser_pos), wordchar)) {
- resulting_string += input.charAt(parser_pos);
- parser_pos += 1;
- }
- }
- return [resulting_string, 'TK_STRING'];
- }
-
- if (c === '#') {
-
-
- if (output_lines.length === 1 && output_lines[0].text.length === 0 &&
- input.charAt(parser_pos) === '!') {
- // shebang
- resulting_string = c;
- while (parser_pos < input_length && c !== '\n') {
- c = input.charAt(parser_pos);
- resulting_string += c;
- parser_pos += 1;
- }
- return [trim(resulting_string) + '\n', 'TK_UNKNOWN'];
- }
-
-
-
- // Spidermonkey-specific sharp variables for circular references
- // https://developer.mozilla.org/En/Sharp_variables_in_JavaScript
- // http://mxr.mozilla.org/mozilla-central/source/js/src/jsscan.cpp around line 1935
- var sharp = '#';
- if (parser_pos < input_length && in_array(input.charAt(parser_pos), digits)) {
- do {
- c = input.charAt(parser_pos);
- sharp += c;
- parser_pos += 1;
- } while (parser_pos < input_length && c !== '#' && c !== '=');
- if (c === '#') {
- //
- } else if (input.charAt(parser_pos) === '[' && input.charAt(parser_pos + 1) === ']') {
- sharp += '[]';
- parser_pos += 2;
- } else if (input.charAt(parser_pos) === '{' && input.charAt(parser_pos + 1) === '}') {
- sharp += '{}';
- parser_pos += 2;
- }
- return [sharp, 'TK_WORD'];
- }
- }
-
- if (c === '<' && input.substring(parser_pos - 1, parser_pos + 3) === '<!--') {
- parser_pos += 3;
- c = '<!--';
- while (input.charAt(parser_pos) !== '\n' && parser_pos < input_length) {
- c += input.charAt(parser_pos);
- parser_pos++;
- }
- flags.in_html_comment = true;
- return [c, 'TK_COMMENT'];
- }
-
- if (c === '-' && flags.in_html_comment && input.substring(parser_pos - 1, parser_pos + 2) === '-->') {
- flags.in_html_comment = false;
- parser_pos += 2;
- return ['-->', 'TK_COMMENT'];
- }
-
- if (c === '.') {
- return [c, 'TK_DOT'];
- }
-
- if (in_array(c, punct)) {
- while (parser_pos < input_length && in_array(c + input.charAt(parser_pos), punct)) {
- c += input.charAt(parser_pos);
- parser_pos += 1;
- if (parser_pos >= input_length) {
- break;
- }
- }
-
- if (c === ',') {
- return [c, 'TK_COMMA'];
- } else if (c === '=') {
- return [c, 'TK_EQUALS'];
- } else {
- return [c, 'TK_OPERATOR'];
- }
- }
-
- return [c, 'TK_UNKNOWN'];
- }
-
- function handle_start_expr() {
- if (start_of_statement()) {
- // The conditional starts the statement if appropriate.
- }
-
- var next_mode = MODE.Expression;
- if (token_text === '[') {
-
- if (last_type === 'TK_WORD' || flags.last_text === ')') {
- // this is array index specifier, break immediately
- // a[x], fn()[x]
- if (in_array(flags.last_text, line_starters)) {
- output_space_before_token = true;
- }
- set_mode(next_mode);
- print_token();
- indent();
- if (opt.space_in_paren) {
- output_space_before_token = true;
- }
- return;
- }
-
- next_mode = MODE.ArrayLiteral;
- if (is_array(flags.mode)) {
- if (flags.last_text === '[' ||
- (flags.last_text === ',' && (last_last_text === ']' || last_last_text === '}'))) {
- // ], [ goes to new line
- // }, [ goes to new line
- if (!opt.keep_array_indentation) {
- print_newline();
- }
- }
- }
-
- } else {
- if (flags.last_text === 'for') {
- next_mode = MODE.ForInitializer;
- } else if (in_array(flags.last_text, ['if', 'while'])) {
- next_mode = MODE.Conditional;
- } else {
- // next_mode = MODE.Expression;
- }
- }
-
- if (flags.last_text === ';' || last_type === 'TK_START_BLOCK') {
- print_newline();
- } else if (last_type === 'TK_END_EXPR' || last_type === 'TK_START_EXPR' || last_type === 'TK_END_BLOCK' || flags.last_text === '.') {
- // TODO: Consider whether forcing this is required. Review failing tests when removed.
- allow_wrap_or_preserved_newline(input_wanted_newline);
- output_wrapped = false;
- // do nothing on (( and )( and ][ and ]( and .(
- } else if (last_type !== 'TK_WORD' && last_type !== 'TK_OPERATOR') {
- output_space_before_token = true;
- } else if (flags.last_word === 'function' || flags.last_word === 'typeof') {
- // function() vs function ()
- if (opt.jslint_happy) {
- output_space_before_token = true;
- }
- } else if (in_array(flags.last_text, line_starters) || flags.last_text === 'catch') {
- if (opt.space_before_conditional) {
- output_space_before_token = true;
- }
- }
-
- // Support of this kind of newline preservation.
- // a = (b &&
- // (c || d));
- if (token_text === '(') {
- if (last_type === 'TK_EQUALS' || last_type === 'TK_OPERATOR') {
- if (!start_of_object_property()) {
- allow_wrap_or_preserved_newline();
- }
- }
- }
-
- set_mode(next_mode);
- print_token();
- if (opt.space_in_paren) {
- output_space_before_token = true;
- }
-
- // In all cases, if we newline while inside an expression it should be indented.
- indent();
- }
-
- function handle_end_expr() {
- // statements inside expressions are not valid syntax, but...
- // statements must all be closed when their container closes
- while (flags.mode === MODE.Statement) {
- restore_mode();
- }
-
- if (token_text === ']' && is_array(flags.mode) && flags.multiline_frame && !opt.keep_array_indentation) {
- print_newline();
- }
-
- if (flags.multiline_frame) {
- allow_wrap_or_preserved_newline();
- }
- if (opt.space_in_paren) {
- if (last_type === 'TK_START_EXPR') {
- // () [] no inner space in empty parens like these, ever, ref #320
- trim_output();
- output_space_before_token = false;
- } else {
- output_space_before_token = true;
- }
- }
- if (token_text === ']' && opt.keep_array_indentation) {
- print_token();
- restore_mode();
- } else {
- restore_mode();
- print_token();
- }
- remove_redundant_indentation(previous_flags);
-
- // do {} while () // no statement required after
- if (flags.do_while && previous_flags.mode === MODE.Conditional) {
- previous_flags.mode = MODE.Expression;
- flags.do_block = false;
- flags.do_while = false;
-
- }
- }
-
- function handle_start_block() {
- set_mode(MODE.BlockStatement);
-
- var empty_braces = is_next('}');
- var empty_anonymous_function = empty_braces && flags.last_word === 'function' &&
- last_type === 'TK_END_EXPR';
-
- if (opt.brace_style === "expand") {
- if (last_type !== 'TK_OPERATOR' &&
- (empty_anonymous_function ||
- last_type === 'TK_EQUALS' ||
- (is_special_word(flags.last_text) && flags.last_text !== 'else'))) {
- output_space_before_token = true;
- } else {
- print_newline();
- }
- } else { // collapse
- if (last_type !== 'TK_OPERATOR' && last_type !== 'TK_START_EXPR') {
- if (last_type === 'TK_START_BLOCK') {
- print_newline();
- } else {
- output_space_before_token = true;
- }
- } else {
- // if TK_OPERATOR or TK_START_EXPR
- if (is_array(previous_flags.mode) && flags.last_text === ',') {
- if (last_last_text === '}') {
- // }, { in array context
- output_space_before_token = true;
- } else {
- print_newline(); // [a, b, c, {
- }
- }
- }
- }
- print_token();
- indent();
- }
-
- function handle_end_block() {
- // statements must all be closed when their container closes
- while (flags.mode === MODE.Statement) {
- restore_mode();
- }
- var empty_braces = last_type === 'TK_START_BLOCK';
-
- if (opt.brace_style === "expand") {
- if (!empty_braces) {
- print_newline();
- }
- } else {
- // skip {}
- if (!empty_braces) {
- if (is_array(flags.mode) && opt.keep_array_indentation) {
- // we REALLY need a newline here, but newliner would skip that
- opt.keep_array_indentation = false;
- print_newline();
- opt.keep_array_indentation = true;
-
- } else {
- print_newline();
- }
- }
- }
- restore_mode();
- print_token();
- }
-
- function handle_word() {
- if (start_of_statement()) {
- // The conditional starts the statement if appropriate.
- } else if (input_wanted_newline && !is_expression(flags.mode) &&
- (last_type !== 'TK_OPERATOR' || (flags.last_text === '--' || flags.last_text === '++')) &&
- last_type !== 'TK_EQUALS' &&
- (opt.preserve_newlines || flags.last_text !== 'var')) {
-
- print_newline();
- }
-
- if (flags.do_block && !flags.do_while) {
- if (token_text === 'while') {
- // do {} ## while ()
- output_space_before_token = true;
- print_token();
- output_space_before_token = true;
- flags.do_while = true;
- return;
- } else {
- // do {} should always have while as the next word.
- // if we don't see the expected while, recover
- print_newline();
- 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 (flags.if_block) {
- if (token_text !== 'else') {
- while (flags.mode === MODE.Statement) {
- restore_mode();
- }
- flags.if_block = false;
- }
- }
-
- if (token_text === 'case' || (token_text === 'default' && flags.in_case_statement)) {
- print_newline();
- if (flags.case_body || opt.jslint_happy) {
- // switch cases following one another
- deindent();
- flags.case_body = false;
- }
- print_token();
- flags.in_case = true;
- flags.in_case_statement = true;
- return;
- }
-
- if (token_text === 'function') {
- if (flags.var_line && last_type !== 'TK_EQUALS') {
- flags.var_line_reindented = true;
- }
- if (in_array(flags.last_text, ['}', ';']) || (just_added_newline() && ! in_array(flags.last_text, ['{', ':', '=', ',']))) {
- // make sure there is a nice clean space of at least one blank line
- // before a new function definition
- if ( ! just_added_blankline() && ! flags.had_comment) {
- print_newline();
- print_newline(true);
- }
- }
- if (last_type === 'TK_WORD') {
- if (flags.last_text === 'get' || flags.last_text === 'set' || flags.last_text === 'new' || flags.last_text === 'return') {
- output_space_before_token = true;
- } else {
- print_newline();
- }
- } else if (last_type === 'TK_OPERATOR' || flags.last_text === '=') {
- // foo = function
- output_space_before_token = true;
- } else if (is_expression(flags.mode)) {
- // (function
- } else {
- print_newline();
- }
- }
-
- if (last_type === 'TK_COMMA' || last_type === 'TK_START_EXPR' || last_type === 'TK_EQUALS' || last_type === 'TK_OPERATOR') {
- if (!start_of_object_property()) {
- allow_wrap_or_preserved_newline();
- }
- }
-
- if (token_text === 'function') {
- print_token();
- flags.last_word = token_text;
- return;
- }
-
- prefix = 'NONE';
-
- if (last_type === 'TK_END_BLOCK') {
- if (!in_array(token_text, ['else', 'catch', 'finally'])) {
- prefix = 'NEWLINE';
- } else {
- if (opt.brace_style === "expand" || opt.brace_style === "end-expand") {
- prefix = 'NEWLINE';
- } else {
- prefix = 'SPACE';
- output_space_before_token = true;
- }
- }
- } else if (last_type === 'TK_SEMICOLON' && flags.mode === MODE.BlockStatement) {
- // TODO: Should this be for STATEMENT as well?
- prefix = 'NEWLINE';
- } else if (last_type === 'TK_SEMICOLON' && is_expression(flags.mode)) {
- prefix = 'SPACE';
- } else if (last_type === 'TK_STRING') {
- prefix = 'NEWLINE';
- } else if (last_type === 'TK_WORD') {
- prefix = 'SPACE';
- } else if (last_type === 'TK_START_BLOCK') {
- prefix = 'NEWLINE';
- } else if (last_type === 'TK_END_EXPR') {
- output_space_before_token = true;
- prefix = 'NEWLINE';
- }
-
- if (in_array(token_text, line_starters) && flags.last_text !== ')') {
- if (flags.last_text === 'else') {
- prefix = 'SPACE';
- } else {
- prefix = 'NEWLINE';
- }
-
- }
-
- if (in_array(token_text, ['else', 'catch', 'finally'])) {
- if (last_type !== 'TK_END_BLOCK' || opt.brace_style === "expand" || opt.brace_style === "end-expand") {
- print_newline();
- } else {
- trim_output(true);
- var line = output_lines[output_lines.length - 1];
- // If we trimmed and there's something other than a close block before us
- // put a newline back in. Handles '} // comment' scenario.
- if (line.text[line.text.length - 1] !== '}') {
- print_newline();
- }
- output_space_before_token = true;
- }
- } else if (prefix === 'NEWLINE') {
- if (is_special_word(flags.last_text)) {
- // no newline between 'return nnn'
- output_space_before_token = true;
- } else if (last_type !== 'TK_END_EXPR') {
- if ((last_type !== 'TK_START_EXPR' || token_text !== 'var') && flags.last_text !== ':') {
- // no need to force newline on 'var': for (var x = 0...)
- if (token_text === 'if' && flags.last_word === 'else' && flags.last_text !== '{') {
- // no newline for } else if {
- output_space_before_token = true;
- } else {
- flags.var_line = false;
- flags.var_line_reindented = false;
- print_newline();
- }
- }
- } else if (in_array(token_text, line_starters) && flags.last_text !== ')') {
- flags.var_line = false;
- flags.var_line_reindented = false;
- print_newline();
- }
- } else if (is_array(flags.mode) && flags.last_text === ',' && last_last_text === '}') {
- print_newline(); // }, in lists get a newline treatment
- } else if (prefix === 'SPACE') {
- output_space_before_token = true;
- }
- print_token();
- flags.last_word = token_text;
-
- if (token_text === 'var') {
- flags.var_line = true;
- flags.var_line_reindented = false;
- flags.var_line_tainted = false;
- }
-
- if (token_text === 'do') {
- flags.do_block = true;
- }
-
- if (token_text === 'if') {
- flags.if_block = true;
- }
- }
-
- function handle_semicolon() {
- if (start_of_statement()) {
- // The conditional starts the statement if appropriate.
- // Semicolon can be the start (and end) of a statement
- output_space_before_token = false;
- }
- while (flags.mode === MODE.Statement && !flags.if_block && !flags.do_block) {
- restore_mode();
- }
- print_token();
- flags.var_line = false;
- flags.var_line_reindented = false;
- if (flags.mode === MODE.ObjectLiteral) {
- // if we're in OBJECT mode and see a semicolon, its invalid syntax
- // recover back to treating this as a BLOCK
- flags.mode = MODE.BlockStatement;
- }
- }
-
- function handle_string() {
- if (start_of_statement()) {
- // The conditional starts the statement if appropriate.
- // One difference - strings want at least a space before
- output_space_before_token = true;
- } else if (last_type === 'TK_WORD') {
- output_space_before_token = true;
- } else if (last_type === 'TK_COMMA' || last_type === 'TK_START_EXPR' || last_type === 'TK_EQUALS' || last_type === 'TK_OPERATOR') {
- if (!start_of_object_property()) {
- allow_wrap_or_preserved_newline();
- }
- } else {
- print_newline();
- }
- print_token();
- }
-
- function handle_equals() {
- if (flags.var_line) {
- // just got an '=' in a var-line, different formatting/line-breaking, etc will now be done
- flags.var_line_tainted = true;
- }
- output_space_before_token = true;
- print_token();
- output_space_before_token = true;
- }
-
- function handle_comma() {
- if (flags.var_line) {
- if (is_expression(flags.mode) || last_type === 'TK_END_BLOCK') {
- // do not break on comma, for(var a = 1, b = 2)
- flags.var_line_tainted = false;
- }
-
- if (flags.var_line) {
- flags.var_line_reindented = true;
- }
-
- print_token();
-
- if (flags.var_line_tainted) {
- flags.var_line_tainted = false;
- print_newline();
- } else {
- output_space_before_token = true;
- }
- return;
- }
-
- if (last_type === 'TK_END_BLOCK' && flags.mode !== MODE.Expression) {
- print_token();
- if (flags.mode === MODE.ObjectLiteral && flags.last_text === '}') {
- print_newline();
- } else {
- output_space_before_token = true;
- }
- } else {
- if (flags.mode === MODE.ObjectLiteral) {
- print_token();
- print_newline();
- } else {
- // EXPR or DO_BLOCK
- print_token();
- output_space_before_token = true;
- }
- }
- }
-
- function handle_operator() {
- var space_before = true;
- var space_after = true;
- if (is_special_word(flags.last_text)) {
- // "return" had a special handling in TK_WORD. Now we need to return the favor
- output_space_before_token = true;
- print_token();
- return;
- }
-
- // hack for actionscript's import .*;
- if (token_text === '*' && last_type === 'TK_DOT' && !last_last_text.match(/^\d+$/)) {
- print_token();
- return;
- }
-
- if (token_text === ':' && flags.in_case) {
- flags.case_body = true;
- indent();
- print_token();
- print_newline();
- flags.in_case = false;
- return;
- }
-
- if (token_text === '::') {
- // no spaces around exotic namespacing syntax operator
- print_token();
- return;
- }
-
- // 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 (input_wanted_newline && (token_text === '--' || token_text === '++')) {
- print_newline();
- }
-
- if (in_array(token_text, ['--', '++', '!']) || (in_array(token_text, ['-', '+']) && (in_array(last_type, ['TK_START_BLOCK', 'TK_START_EXPR', 'TK_EQUALS', 'TK_OPERATOR']) || in_array(flags.last_text, line_starters) || flags.last_text === ','))) {
- // unary operators (and binary +/- pretending to be unary) special cases
-
- space_before = false;
- space_after = false;
-
- if (flags.last_text === ';' && is_expression(flags.mode)) {
- // for (;; ++i)
- // ^^^
- space_before = true;
- }
-
- if (last_type === 'TK_WORD' && in_array(flags.last_text, line_starters)) {
- space_before = true;
- }
-
- if ((flags.mode === MODE.BlockStatement || flags.mode === MODE.Statement) && (flags.last_text === '{' || flags.last_text === ';')) {
- // { foo; --i }
- // foo(); --bar;
- print_newline();
- }
- } else if (token_text === ':') {
- if (flags.ternary_depth === 0) {
- if (flags.mode === MODE.BlockStatement) {
- flags.mode = MODE.ObjectLiteral;
- }
- space_before = false;
- } else {
- flags.ternary_depth -= 1;
- }
- } else if (token_text === '?') {
- flags.ternary_depth += 1;
- }
- output_space_before_token = output_space_before_token || space_before;
- print_token();
- output_space_before_token = space_after;
- }
-
- function handle_block_comment() {
- var lines = split_newlines(token_text);
- var j; // iterator for this case
- var javadoc = false;
-
- // block comment starts with a new line
- print_newline(false, true);
- if (lines.length > 1) {
- if (all_lines_start_with(lines.slice(1), '*')) {
- javadoc = true;
- }
- }
-
- // first line always indented
- print_token(lines[0]);
- for (j = 1; j < lines.length; j++) {
- print_newline(false, true);
- if (javadoc) {
- // javadoc: reformat and re-indent
- print_token(' ' + trim(lines[j]));
- } else {
- // normal comments output raw
- output_lines[output_lines.length - 1].text.push(lines[j]);
- }
- }
-
- // for comments of more than one line, make sure there's a new line after
- print_newline(false, true);
- }
-
- function handle_inline_comment() {
- output_space_before_token = true;
- print_token();
- output_space_before_token = true;
- }
-
- function handle_comment() {
- if (input_wanted_newline) {
- print_newline(false, true);
- } else {
- trim_output(true);
- }
-
- output_space_before_token = true;
- print_token();
- print_newline(false, true);
- }
-
- function handle_dot() {
- if (is_special_word(flags.last_text)) {
- output_space_before_token = true;
- } else {
- // allow preserved newlines before dots in general
- // force newlines on dots after close paren when break_chained - for bar().baz()
- allow_wrap_or_preserved_newline(flags.last_text === ')' && opt.break_chained_methods);
- }
-
- print_token();
- }
-
- function handle_unknown() {
- print_token();
-
- if (token_text[token_text.length - 1] === '\n') {
- print_newline();
- }
- }
+ } 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();
- if (typeof define === "function" && define.amd) {
- define([], function() {
- return 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;
+ } 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);
+ } else {
+ out += '\\';
+ if (input_scan.hasNext()) {
+ out += input_scan.next();
+ }
+ continue;
+ }
+
+ // If there's some error decoding, return the original string
+ if (!matched) {
+ return s;
+ }
+
+ escaped = parseInt(matched[1], 16);
+
+ if (escaped > 0x7e && escaped <= 0xff && matched[0].indexOf('x') === 0) {
+ // we bail out on \x7f..\xff,
+ // leaving whole string escaped,
+ // as it's probably completely binary
+ return s;
+ } else if (escaped >= 0x00 && escaped < 0x20) {
+ // leave 0x00...0x1f escaped
+ out += '\\' + matched[0];
+ continue;
+ } else if (escaped === 0x22 || escaped === 0x27 || escaped === 0x5c) {
+ // single-quote, apostrophe, backslash - escape these
+ out += '\\' + String.fromCharCode(escaped);
+ } else {
+ out += String.fromCharCode(escaped);
+ }
+ }
+ }
+
+ return out;
+}
+
+// handle string
+//
+Tokenizer.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, exports, __webpack_require__) {
+
+"use strict";
+/*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, exports, __webpack_require__) {
+
+"use strict";
+/*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, exports, __webpack_require__) {
+
+"use strict";
+/*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, exports, __webpack_require__) {
+
+"use strict";
+/*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, exports, __webpack_require__) {
+
+"use strict";
+/*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, exports, __webpack_require__) {
+
+"use strict";
+/*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, exports, __webpack_require__) {
+
+"use strict";
+/*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
+};
+
+// This lets templates appear anywhere we would do a readUntil
+// The cost is higher but it is pay to play.
+function TemplatablePattern(input_scanner, parent) {
+ Pattern.call(this, input_scanner, parent);
+ this.__template_pattern = null;
+ this._disabled = Object.assign({}, template_names);
+ this._excluded = Object.assign({}, template_names);
+
+ if (parent) {
+ this.__template_pattern = this._input.get_regexp(parent.__template_pattern);
+ this._excluded = Object.assign(this._excluded, parent._excluded);
+ this._disabled = Object.assign(this._disabled, parent._disabled);
+ }
+ var pattern = new Pattern(input_scanner);
+ this.__patterns = {
+ handlebars_comment: pattern.starting_with(/{{!--/).until_after(/--}}/),
+ handlebars_unescaped: pattern.starting_with(/{{{/).until_after(/}}}/),
+ handlebars: pattern.starting_with(/{{/).until_after(/}}/),
+ php: pattern.starting_with(/<\?(?:[=]|php)/).until_after(/\?>/),
+ erb: pattern.starting_with(/<%[^%]/).until_after(/[^%]%>/),
+ // django coflicts with handlebars a bit.
+ django: pattern.starting_with(/{%/).until_after(/%}/),
+ django_value: pattern.starting_with(/{{/).until_after(/}}/),
+ django_comment: pattern.starting_with(/{#/).until_after(/#}/)
+ };
+}
+TemplatablePattern.prototype = new Pattern();
+
+TemplatablePattern.prototype._create = function() {
+ return new TemplatablePattern(this._input, this);
+};
+
+TemplatablePattern.prototype._update = function() {
+ this.__set_templated_pattern();
+};
+
+TemplatablePattern.prototype.disable = function(language) {
+ var result = this._create();
+ result._disabled[language] = true;
+ result._update();
+ return result;
+};
+
+TemplatablePattern.prototype.read_options = function(options) {
+ var result = this._create();
+ for (var language in template_names) {
+ result._disabled[language] = options.templating.indexOf(language) === -1;
+ }
+ result._update();
+ return result;
+};
+
+TemplatablePattern.prototype.exclude = function(language) {
+ var result = this._create();
+ result._excluded[language] = true;
+ result._update();
+ return result;
+};
+
+TemplatablePattern.prototype.read = function() {
+ var result = '';
+ if (this._match_pattern) {
+ result = this._input.read(this._starting_pattern);
+ } else {
+ result = this._input.read(this._starting_pattern, this.__template_pattern);
+ }
+ var next = this._read_template();
+ while (next) {
+ if (this._match_pattern) {
+ next += this._input.read(this._match_pattern);
+ } else {
+ next += this._input.readUntil(this.__template_pattern);
+ }
+ result += next;
+ next = this._read_template();
+ }
+
+ if (this._until_after) {
+ result += this._input.readUntilAfter(this._until_pattern);
+ }
+ return result;
+};
+
+TemplatablePattern.prototype.__set_templated_pattern = function() {
+ var items = [];
+
+ if (!this._disabled.php) {
+ items.push(this.__patterns.php._starting_pattern.source);
+ }
+ if (!this._disabled.handlebars) {
+ items.push(this.__patterns.handlebars._starting_pattern.source);
+ }
+ if (!this._disabled.erb) {
+ items.push(this.__patterns.erb._starting_pattern.source);
+ }
+ if (!this._disabled.django) {
+ items.push(this.__patterns.django._starting_pattern.source);
+ items.push(this.__patterns.django_value._starting_pattern.source);
+ items.push(this.__patterns.django_comment._starting_pattern.source);
+ }
+
+ if (this._until_pattern) {
+ items.push(this._until_pattern.source);
+ }
+ this.__template_pattern = this._input.get_regexp('(?:' + items.join('|') + ')');
+};
+
+TemplatablePattern.prototype._read_template = function() {
+ var resulting_string = '';
+ var c = this._input.peek();
+ if (c === '<') {
+ var peek1 = this._input.peek(1);
+ //if we're in a comment, do something special
+ // We treat all comments as literals, even more than preformatted tags
+ // we just look for the appropriate close tag
+ if (!this._disabled.php && !this._excluded.php && peek1 === '?') {
+ resulting_string = resulting_string ||
+ this.__patterns.php.read();
+ }
+ if (!this._disabled.erb && !this._excluded.erb && peek1 === '%') {
+ resulting_string = resulting_string ||
+ this.__patterns.erb.read();
+ }
+ } else if (c === '{') {
+ if (!this._disabled.handlebars && !this._excluded.handlebars) {
+ resulting_string = resulting_string ||
+ this.__patterns.handlebars_comment.read();
+ resulting_string = resulting_string ||
+ this.__patterns.handlebars_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();
+ }
+ }
+ }
+ return resulting_string;
+};
+
+
+module.exports.TemplatablePattern = TemplatablePattern;
+
+
+/***/ })
+/******/ ]);
+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;
+}
}());
+
