diff --git a/client/src/com/mirth/connect/client/ui/components/rsta/MirthRSyntaxTextArea.java b/client/src/com/mirth/connect/client/ui/components/rsta/MirthRSyntaxTextArea.java index e2e5c5c193..42c9e718c9 100644 --- a/client/src/com/mirth/connect/client/ui/components/rsta/MirthRSyntaxTextArea.java +++ b/client/src/com/mirth/connect/client/ui/components/rsta/MirthRSyntaxTextArea.java @@ -62,6 +62,7 @@ import com.mirth.connect.client.ui.components.rsta.actions.ExpandFoldAction; import com.mirth.connect.client.ui.components.rsta.actions.FindNextAction; import com.mirth.connect.client.ui.components.rsta.actions.FindReplaceAction; +import com.mirth.connect.client.ui.components.rsta.actions.FormatCodeAction; import com.mirth.connect.client.ui.components.rsta.actions.GoToMatchingBracketAction; import com.mirth.connect.client.ui.components.rsta.actions.HorizontalPageAction; import com.mirth.connect.client.ui.components.rsta.actions.InsertBreakAction; @@ -127,6 +128,9 @@ public class MirthRSyntaxTextArea extends RSyntaxTextArea implements MirthTextIn private CustomJCheckBoxMenuItem showWhitespaceMenuItem; private CustomJCheckBoxMenuItem showLineEndingsMenuItem; private CustomJCheckBoxMenuItem wrapLinesMenuItem; + private JMenu codeMenu; + private CustomMenuItem formatCodeMenuItem; + private CustomMenuItem toggleCommentMenuItem; private JMenu macroMenu; private CustomMenuItem beginMacroMenuItem; private CustomMenuItem endMacroMenuItem; @@ -228,6 +232,9 @@ public void keyPressed(KeyEvent e) { showWhitespaceMenuItem = new CustomJCheckBoxMenuItem(this, new ShowWhitespaceAction(this), ActionInfo.DISPLAY_SHOW_WHITESPACE); showLineEndingsMenuItem = new CustomJCheckBoxMenuItem(this, new ShowLineEndingsAction(this), ActionInfo.DISPLAY_SHOW_LINE_ENDINGS); wrapLinesMenuItem = new CustomJCheckBoxMenuItem(this, new WrapLinesAction(this), ActionInfo.DISPLAY_WRAP_LINES); + codeMenu = new JMenu("Code"); + formatCodeMenuItem = new CustomMenuItem(this, new FormatCodeAction(this), ActionInfo.FORMAT_CODE); + toggleCommentMenuItem = new CustomMenuItem(this, new ToggleCommentAction(this), ActionInfo.TOGGLE_COMMENT); macroMenu = new JMenu("Macro"); beginMacroMenuItem = new CustomMenuItem(this, new BeginMacroAction(), ActionInfo.MACRO_BEGIN); endMacroMenuItem = new CustomMenuItem(this, new EndMacroAction(), ActionInfo.MACRO_END); @@ -239,7 +246,8 @@ public void keyPressed(KeyEvent e) { getActionMap().put(ActionInfo.DELETE_LINE.getActionMapKey(), new DeleteLineAction()); getActionMap().put(ActionInfo.JOIN_LINE.getActionMapKey(), new JoinLineAction()); getActionMap().put(ActionInfo.GO_TO_MATCHING_BRACKET.getActionMapKey(), new GoToMatchingBracketAction()); - getActionMap().put(ActionInfo.TOGGLE_COMMENT.getActionMapKey(), new ToggleCommentAction()); + getActionMap().put(ActionInfo.FORMAT_CODE.getActionMapKey(), new FormatCodeAction(this)); + getActionMap().put(ActionInfo.TOGGLE_COMMENT.getActionMapKey(), new ToggleCommentAction(this)); getActionMap().put(ActionInfo.DOCUMENT_START.getActionMapKey(), new DocumentStartAction(false)); getActionMap().put(ActionInfo.DOCUMENT_SELECT_START.getActionMapKey(), new DocumentStartAction(true)); getActionMap().put(ActionInfo.DOCUMENT_END.getActionMapKey(), new DocumentEndAction(false)); @@ -489,6 +497,11 @@ protected JPopupMenu createPopupMenu() { menu.add(displayMenu); menu.addSeparator(); + codeMenu.add(formatCodeMenuItem); + codeMenu.add(toggleCommentMenuItem); + menu.add(codeMenu); + menu.addSeparator(); + macroMenu.add(beginMacroMenuItem); macroMenu.add(endMacroMenuItem); macroMenu.add(playbackMacroMenuItem); @@ -514,6 +527,8 @@ protected void configurePopupMenu(JPopupMenu popupMenu) { findNextMenuItem.setEnabled(findNextMenuItem.getAction().isEnabled() && CollectionUtils.isNotEmpty(rstaPreferences.getFindReplaceProperties().getFindHistory())); clearMarkedOccurrencesMenuItem.setEnabled(clearMarkedOccurrencesMenuItem.getAction().isEnabled() && canType && ((RSyntaxTextAreaHighlighter) getHighlighter()).getMarkAllHighlightCount() > 0); foldingMenu.setEnabled(getFoldManager().isCodeFoldingSupportedAndEnabled()); + formatCodeMenuItem.setEnabled(formatCodeMenuItem.getAction().isEnabled()); + toggleCommentMenuItem.setEnabled(toggleCommentMenuItem.getAction().isEnabled()); beginMacroMenuItem.setEnabled(!isRecordingMacro()); endMacroMenuItem.setEnabled(isRecordingMacro()); playbackMacroMenuItem.setEnabled(!isRecordingMacro() && getCurrentMacro() != null); @@ -533,6 +548,8 @@ protected void configurePopupMenu(JPopupMenu popupMenu) { collapseAllFoldsMenuItem.updateAccelerator(); collapseAllCommentFoldsMenuItem.updateAccelerator(); expandAllFoldsMenuItem.updateAccelerator(); + formatCodeMenuItem.updateAccelerator(); + toggleCommentMenuItem.updateAccelerator(); beginMacroMenuItem.updateAccelerator(); endMacroMenuItem.updateAccelerator(); playbackMacroMenuItem.updateAccelerator(); diff --git a/client/src/com/mirth/connect/client/ui/components/rsta/MirthRSyntaxTextArea.properties b/client/src/com/mirth/connect/client/ui/components/rsta/MirthRSyntaxTextArea.properties index d97bbb27a1..9fc98fdd4f 100644 --- a/client/src/com/mirth/connect/client/ui/components/rsta/MirthRSyntaxTextArea.properties +++ b/client/src/com/mirth/connect/client/ui/components/rsta/MirthRSyntaxTextArea.properties @@ -118,6 +118,11 @@ TOGGLE_COMMENT.Name=Toggle Comment TOGGLE_COMMENT.Desc=Comments / uncomments the current selected line(s). TOGGLE_COMMENT.Toggle=false +FORMAT_CODE.Mnemonic=F +FORMAT_CODE.Name=Format +FORMAT_CODE.Desc=Format the current script / selected line(s). +FORMAT_CODE.Toggle=false + VIEW_USER_API.Mnemonic=V VIEW_USER_API.Name=View User API VIEW_USER_API.Desc=Opens up the User API Javadoc in a browser. diff --git a/client/src/com/mirth/connect/client/ui/components/rsta/RSTAPreferences.java b/client/src/com/mirth/connect/client/ui/components/rsta/RSTAPreferences.java index db7d182508..cb460d8b2c 100644 --- a/client/src/com/mirth/connect/client/ui/components/rsta/RSTAPreferences.java +++ b/client/src/com/mirth/connect/client/ui/components/rsta/RSTAPreferences.java @@ -234,6 +234,7 @@ private void setDefaultKeyStrokeMap() { putKeyStroke(ActionInfo.FOLD_EXPAND_ALL, KeyEvent.VK_MULTIPLY, defaultModifier); putKeyStroke(ActionInfo.GO_TO_MATCHING_BRACKET, KeyEvent.VK_OPEN_BRACKET, defaultModifier); putKeyStroke(ActionInfo.TOGGLE_COMMENT, KeyEvent.VK_SLASH, defaultModifier); + putKeyStroke(ActionInfo.FORMAT_CODE, KeyEvent.VK_F, ctrl + shift); putKeyStroke(ActionInfo.AUTO_COMPLETE, KeyEvent.VK_SPACE, ctrl); if (isOSX) { diff --git a/client/src/com/mirth/connect/client/ui/components/rsta/actions/ActionInfo.java b/client/src/com/mirth/connect/client/ui/components/rsta/actions/ActionInfo.java index 9059199dff..1a05aaafda 100644 --- a/client/src/com/mirth/connect/client/ui/components/rsta/actions/ActionInfo.java +++ b/client/src/com/mirth/connect/client/ui/components/rsta/actions/ActionInfo.java @@ -40,6 +40,7 @@ public enum ActionInfo { DISPLAY_WRAP_LINES ("mirth-wrap-lines"), GO_TO_MATCHING_BRACKET (RSyntaxTextAreaEditorKit.rstaGoToMatchingBracketAction), TOGGLE_COMMENT (RSyntaxTextAreaEditorKit.rstaToggleCommentAction), + FORMAT_CODE ("mirth-format-code"), VIEW_USER_API ("mirth-view-user-api"), AUTO_COMPLETE ("AutoComplete"), DOCUMENT_START (DefaultEditorKit.beginAction), diff --git a/client/src/com/mirth/connect/client/ui/components/rsta/actions/FormatCodeAction.java b/client/src/com/mirth/connect/client/ui/components/rsta/actions/FormatCodeAction.java new file mode 100644 index 0000000000..5958d2db96 --- /dev/null +++ b/client/src/com/mirth/connect/client/ui/components/rsta/actions/FormatCodeAction.java @@ -0,0 +1,111 @@ +/* + * Copyright (c) Mirth Corporation. All rights reserved. + * + * http://www.mirthcorp.com + * + * The software in this package is published under the terms of the MPL license a copy of which has + * been included with this distribution in the LICENSE.txt file. + */ + +package com.mirth.connect.client.ui.components.rsta.actions; + +import java.awt.event.ActionEvent; + +import javax.swing.UIManager; +import javax.swing.text.BadLocationException; +import javax.swing.text.Caret; +import javax.swing.text.Element; + +import org.fife.ui.rsyntaxtextarea.RSyntaxDocument; + +import com.mirth.connect.client.ui.components.rsta.MirthRSyntaxTextArea; +import com.mirth.connect.util.JavaScriptSharedUtil; + +public class FormatCodeAction extends MirthRecordableTextAction { + + public FormatCodeAction(MirthRSyntaxTextArea textArea) { + super(textArea, ActionInfo.FORMAT_CODE); + } + + @Override + public void actionPerformedImpl(ActionEvent evt) { + + if (!textArea.isEditable() || !textArea.isEnabled()) { + UIManager.getLookAndFeel().provideErrorFeedback(textArea); + return; + } + + Caret c = textArea.getCaret(); + int start = Math.min(c.getDot(), c.getMark()); + int end = Math.max(c.getDot(), c.getMark()); + if (start == end) { + formatAll(); + } else { + formatRange(start, end); + } + + } + + @Override + public boolean isEnabled() { + return textArea.isEditable() && textArea.isEnabled(); + } + + private void formatAll() { + + String code = textArea.getText(); + formatAndReplace(code, 0, code.length()); + } + + private void formatRange(int start, int end) { + + // We want to format all the lines of the selection (not only the selected text) + + try { + RSyntaxDocument doc = (RSyntaxDocument) textArea.getDocument(); + Element map = doc.getDefaultRootElement(); + + // Get the lines indexes from the selected text indexes. + int startLine = map.getElementIndex(start); + int endLine = map.getElementIndex(end); + + int replaceRangeStart = 0; + int replaceRangeEnd = 0; + + // Build a string from the selected lines. + StringBuilder sb = new StringBuilder(); + for (int line = startLine; line <= endLine; line++) { + Element elem = map.getElement(line); + + int startOffset = elem.getStartOffset(); + int endOffset = elem.getEndOffset() - 1; + + // Save the start index of the first line for the final replacement. + if (line == startLine) { + replaceRangeStart = startOffset; + } + + // Save the end index of the last line for the final replacement. + if (line == endLine) { + replaceRangeEnd = endOffset; + } + + sb.append(doc.getText(startOffset, endOffset - startOffset + 1)); + } + + // Format the code and replace the selected lines. + formatAndReplace(sb.toString(), replaceRangeStart, replaceRangeEnd); + + } catch (BadLocationException ble) { + ble.printStackTrace(); + UIManager.getLookAndFeel().provideErrorFeedback(textArea); + } + } + + private void formatAndReplace(String code, int start, int end) { + + String formattedCode = JavaScriptSharedUtil.prettyPrint(code); + textArea.replaceRange(formattedCode, start, end); + textArea.setCaretPosition(start); + } +} \ No newline at end of file diff --git a/client/src/com/mirth/connect/client/ui/components/rsta/actions/ToggleCommentAction.java b/client/src/com/mirth/connect/client/ui/components/rsta/actions/ToggleCommentAction.java index 567cbc1fae..002a609c0a 100644 --- a/client/src/com/mirth/connect/client/ui/components/rsta/actions/ToggleCommentAction.java +++ b/client/src/com/mirth/connect/client/ui/components/rsta/actions/ToggleCommentAction.java @@ -13,7 +13,16 @@ public class ToggleCommentAction extends org.fife.ui.rsyntaxtextarea.RSyntaxTextAreaEditorKit.ToggleCommentAction { - public ToggleCommentAction() { + protected MirthRSyntaxTextArea textArea; + + public ToggleCommentAction(MirthRSyntaxTextArea textArea) { setProperties(MirthRSyntaxTextArea.getResourceBundle(), ActionInfo.TOGGLE_COMMENT.toString()); + + this.textArea = textArea; + } + + @Override + public boolean isEnabled() { + return textArea.isEditable() && textArea.isEnabled(); } } \ No newline at end of file diff --git a/server/src/com/mirth/connect/util/JavaScriptSharedUtil.java b/server/src/com/mirth/connect/util/JavaScriptSharedUtil.java index 9d0b1679ac..81a3cc3e40 100644 --- a/server/src/com/mirth/connect/util/JavaScriptSharedUtil.java +++ b/server/src/com/mirth/connect/util/JavaScriptSharedUtil.java @@ -196,14 +196,14 @@ public static String prettyPrint(String script) { private static ScriptableObject getFormatterScope() { Context context = getGlobalContextForValidation(); InputStream is = null; - + try { - is = JavaScriptSharedUtil.class.getResourceAsStream("beautify-1.6.8.js"); + is = JavaScriptSharedUtil.class.getResourceAsStream("beautify-1.15.3.js"); String script = IOUtils.toString(is); ScriptableObject scope = context.initStandardObjects(); context.evaluateString(scope, "var global = {};", UUID.randomUUID().toString(), 1, null); context.evaluateString(scope, script, UUID.randomUUID().toString(), 1, null); - context.evaluateString(scope, "var opts = { 'e4x': true };", UUID.randomUUID().toString(), 1, null); + context.evaluateString(scope, "var opts = { 'e4x': true, 'indent_with_tabs': true };", UUID.randomUUID().toString(), 1, null); return scope; } catch (Exception e) { logger.error("Failed to load beautify library."); diff --git a/server/src/com/mirth/connect/util/beautify-1.15.3.js b/server/src/com/mirth/connect/util/beautify-1.15.3.js new file mode 100644 index 0000000000..76f78c6220 --- /dev/null +++ b/server/src/com/mirth/connect/util/beautify-1.15.3.js @@ -0,0 +1,4053 @@ +/* AUTO-GENERATED. DO NOT MODIFY. */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + + JS Beautifier +--------------- + + + Written by Einar Lielmanis, + https://beautifier.io/ + + Originally converted to javascript by Vital, + "End braces on own line" added by Chris J. Shull, + Parsing improvements for brace-less statements by Liam Newman + + + Usage: + js_beautify(js_source_text); + js_beautify(js_source_text, options); + + The options are: + indent_size (default 4) - indentation size, + indent_char (default space) - character to indent with, + preserve_newlines (default true) - whether existing line breaks should be preserved, + max_preserve_newlines (default unlimited) - maximum number of line breaks to be preserved in one chunk, + + jslint_happy (default false) - if true, then jslint-stricter mode is enforced. + + jslint_happy !jslint_happy + --------------------------------- + function () function() + + switch () { switch() { + case 1: case 1: + break; break; + } } + + space_after_anon_function (default false) - should the space before an anonymous function's parens be added, "function()" vs "function ()", + NOTE: This option is overridden by jslint_happy (i.e. if jslint_happy is true, space_after_anon_function is true by design) + + brace_style (default "collapse") - "collapse" | "expand" | "end-expand" | "none" | any of the former + ",preserve-inline" + put braces on the same line as control statements (default), or put braces on own line (Allman / ANSI style), or just put end braces on own line, or attempt to keep them where they are. + preserve-inline will try to preserve inline blocks of curly braces + + space_before_conditional (default true) - should the space before conditional statement be added, "if(true)" vs "if (true)", + + unescape_strings (default false) - should printable characters in strings encoded in \xNN notation be unescaped, "example" vs "\x65\x78\x61\x6d\x70\x6c\x65" + + wrap_line_length (default unlimited) - lines should wrap at next opportunity after this number of characters. + NOTE: This is not a hard limit. Lines will continue until a point where a newline would + be preserved if it were present. + + end_with_newline (default false) - end output with a newline + + + e.g + + js_beautify(js_source_text, { + 'indent_size': 1, + 'indent_char': '\t' + }); + +*/ + +(function() { + +/* GENERATED_BUILD_OUTPUT */ +var legacy_beautify_js; +/******/ (function() { // webpackBootstrap +/******/ "use strict"; +/******/ var __webpack_modules__ = ([ +/* 0 */ +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + + + +var Beautifier = (__webpack_require__(1).Beautifier), + Options = (__webpack_require__(5).Options); + +function js_beautify(js_source_text, options) { + var beautifier = new Beautifier(js_source_text, options); + return beautifier.beautify(); +} + +module.exports = js_beautify; +module.exports.defaultOptions = function() { + return new Options(); +}; + + +/***/ }), +/* 1 */ +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + + + +var Output = (__webpack_require__(2).Output); +var Token = (__webpack_require__(3).Token); +var acorn = __webpack_require__(4); +var Options = (__webpack_require__(5).Options); +var Tokenizer = (__webpack_require__(7).Tokenizer); +var line_starters = (__webpack_require__(7).line_starters); +var positionable_operators = (__webpack_require__(7).positionable_operators); +var TOKEN = (__webpack_require__(7).TOKEN); + + +function in_array(what, arr) { + return arr.indexOf(what) !== -1; +} + +function ltrim(s) { + return s.replace(/^\s+/g, ''); +} + +function generateMapFromStrings(list) { + var result = {}; + for (var x = 0; x < list.length; x++) { + // make the mapped names underscored instead of dash + result[list[x].replace(/-/g, '_')] = list[x]; + } + return result; +} + +function reserved_word(token, word) { + return token && token.type === TOKEN.RESERVED && token.text === word; +} + +function reserved_array(token, words) { + return token && token.type === TOKEN.RESERVED && in_array(token.text, words); +} +// Unsure of what they mean, but they work. Worth cleaning up in future. +var special_words = ['case', 'return', 'do', 'if', 'throw', 'else', 'await', 'break', 'continue', 'async']; + +var validPositionValues = ['before-newline', 'after-newline', 'preserve-newline']; + +// Generate map from array +var OPERATOR_POSITION = generateMapFromStrings(validPositionValues); + +var OPERATOR_POSITION_BEFORE_OR_PRESERVE = [OPERATOR_POSITION.before_newline, OPERATOR_POSITION.preserve_newline]; + +var MODE = { + BlockStatement: 'BlockStatement', // 'BLOCK' + Statement: 'Statement', // 'STATEMENT' + ObjectLiteral: 'ObjectLiteral', // 'OBJECT', + ArrayLiteral: 'ArrayLiteral', //'[EXPRESSION]', + ForInitializer: 'ForInitializer', //'(FOR-EXPRESSION)', + Conditional: 'Conditional', //'(COND-EXPRESSION)', + Expression: 'Expression' //'(EXPRESSION)' +}; + +function remove_redundant_indentation(output, frame) { + // This implementation is effective but has some issues: + // - can cause line wrap to happen too soon due to indent removal + // after wrap points are calculated + // These issues are minor compared to ugly indentation. + + if (frame.multiline_frame || + frame.mode === MODE.ForInitializer || + frame.mode === MODE.Conditional) { + return; + } + + // remove one indent from each line inside this section + output.remove_indent(frame.start_line_index); +} + +// we could use just string.split, but +// IE doesn't like returning empty strings +function split_linebreaks(s) { + //return s.split(/\x0d\x0a|\x0a/); + + s = s.replace(acorn.allLineBreaks, '\n'); + var out = [], + idx = s.indexOf("\n"); + while (idx !== -1) { + out.push(s.substring(0, idx)); + s = s.substring(idx + 1); + idx = s.indexOf("\n"); + } + if (s.length) { + out.push(s); + } + return out; +} + +function is_array(mode) { + return mode === MODE.ArrayLiteral; +} + +function is_expression(mode) { + return in_array(mode, [MODE.Expression, MODE.ForInitializer, MODE.Conditional]); +} + +function all_lines_start_with(lines, c) { + for (var i = 0; i < lines.length; i++) { + var line = lines[i].trim(); + if (line.charAt(0) !== c) { + return false; + } + } + return true; +} + +function each_line_matches_indent(lines, indent) { + var i = 0, + len = lines.length, + line; + for (; i < len; i++) { + line = lines[i]; + // allow empty lines to pass through + if (line && line.indexOf(indent) !== 0) { + return false; + } + } + return true; +} + + +function Beautifier(source_text, options) { + options = options || {}; + this._source_text = source_text || ''; + + this._output = null; + this._tokens = null; + this._last_last_text = null; + this._flags = null; + this._previous_flags = null; + + this._flag_store = null; + this._options = new Options(options); +} + +Beautifier.prototype.create_flags = function(flags_base, mode) { + var next_indent_level = 0; + if (flags_base) { + next_indent_level = flags_base.indentation_level; + if (!this._output.just_added_newline() && + flags_base.line_indent_level > next_indent_level) { + next_indent_level = flags_base.line_indent_level; + } + } + + var next_flags = { + mode: mode, + parent: flags_base, + last_token: flags_base ? flags_base.last_token : new Token(TOKEN.START_BLOCK, ''), // last token text + last_word: flags_base ? flags_base.last_word : '', // last TOKEN.WORD passed + declaration_statement: false, + declaration_assignment: false, + multiline_frame: false, + inline_frame: false, + if_block: false, + else_block: false, + class_start_block: false, // class A { INSIDE HERE } or class B extends C { INSIDE HERE } + do_block: false, + do_while: false, + import_block: false, + in_case_statement: false, // switch(..){ INSIDE HERE } + in_case: false, // we're on the exact line with "case 0:" + case_body: false, // the indented case-action block + case_block: false, // the indented case-action block is wrapped with {} + indentation_level: next_indent_level, + alignment: 0, + line_indent_level: flags_base ? flags_base.line_indent_level : next_indent_level, + start_line_index: this._output.get_line_number(), + ternary_depth: 0 + }; + return next_flags; +}; + +Beautifier.prototype._reset = function(source_text) { + var baseIndentString = source_text.match(/^[\t ]*/)[0]; + + this._last_last_text = ''; // pre-last token text + this._output = new Output(this._options, baseIndentString); + + // If testing the ignore directive, start with output disable set to true + this._output.raw = this._options.test_output_raw; + + + // Stack of parsing/formatting states, including MODE. + // We tokenize, parse, and output in an almost purely a forward-only stream of token input + // and formatted output. This makes the beautifier less accurate than full parsers + // but also far more tolerant of syntax errors. + // + // For example, the default mode is MODE.BlockStatement. If we see a '{' we push a new frame of type + // MODE.BlockStatement on the the stack, even though it could be object literal. If we later + // encounter a ":", we'll switch to to MODE.ObjectLiteral. If we then see a ";", + // most full parsers would die, but the beautifier gracefully falls back to + // MODE.BlockStatement and continues on. + this._flag_store = []; + this.set_mode(MODE.BlockStatement); + var tokenizer = new Tokenizer(source_text, this._options); + this._tokens = tokenizer.tokenize(); + return source_text; +}; + +Beautifier.prototype.beautify = function() { + // if disabled, return the input unchanged. + if (this._options.disabled) { + return this._source_text; + } + + var sweet_code; + var source_text = this._reset(this._source_text); + + var eol = this._options.eol; + if (this._options.eol === 'auto') { + eol = '\n'; + if (source_text && acorn.lineBreak.test(source_text || '')) { + eol = source_text.match(acorn.lineBreak)[0]; + } + } + + var current_token = this._tokens.next(); + while (current_token) { + this.handle_token(current_token); + + this._last_last_text = this._flags.last_token.text; + this._flags.last_token = current_token; + + current_token = this._tokens.next(); + } + + sweet_code = this._output.get_code(eol); + + return sweet_code; +}; + +Beautifier.prototype.handle_token = function(current_token, preserve_statement_flags) { + if (current_token.type === TOKEN.START_EXPR) { + this.handle_start_expr(current_token); + } else if (current_token.type === TOKEN.END_EXPR) { + this.handle_end_expr(current_token); + } else if (current_token.type === TOKEN.START_BLOCK) { + this.handle_start_block(current_token); + } else if (current_token.type === TOKEN.END_BLOCK) { + this.handle_end_block(current_token); + } else if (current_token.type === TOKEN.WORD) { + this.handle_word(current_token); + } else if (current_token.type === TOKEN.RESERVED) { + this.handle_word(current_token); + } else if (current_token.type === TOKEN.SEMICOLON) { + this.handle_semicolon(current_token); + } else if (current_token.type === TOKEN.STRING) { + this.handle_string(current_token); + } else if (current_token.type === TOKEN.EQUALS) { + this.handle_equals(current_token); + } else if (current_token.type === TOKEN.OPERATOR) { + this.handle_operator(current_token); + } else if (current_token.type === TOKEN.COMMA) { + this.handle_comma(current_token); + } else if (current_token.type === TOKEN.BLOCK_COMMENT) { + this.handle_block_comment(current_token, preserve_statement_flags); + } else if (current_token.type === TOKEN.COMMENT) { + this.handle_comment(current_token, preserve_statement_flags); + } else if (current_token.type === TOKEN.DOT) { + this.handle_dot(current_token); + } else if (current_token.type === TOKEN.EOF) { + this.handle_eof(current_token); + } else if (current_token.type === TOKEN.UNKNOWN) { + this.handle_unknown(current_token, preserve_statement_flags); + } else { + this.handle_unknown(current_token, preserve_statement_flags); + } +}; + +Beautifier.prototype.handle_whitespace_and_comments = function(current_token, preserve_statement_flags) { + var newlines = current_token.newlines; + var keep_whitespace = this._options.keep_array_indentation && is_array(this._flags.mode); + + if (current_token.comments_before) { + var comment_token = current_token.comments_before.next(); + while (comment_token) { + // The cleanest handling of inline comments is to treat them as though they aren't there. + // Just continue formatting and the behavior should be logical. + // Also ignore unknown tokens. Again, this should result in better behavior. + this.handle_whitespace_and_comments(comment_token, preserve_statement_flags); + this.handle_token(comment_token, preserve_statement_flags); + comment_token = current_token.comments_before.next(); + } + } + + if (keep_whitespace) { + for (var i = 0; i < newlines; i += 1) { + this.print_newline(i > 0, preserve_statement_flags); + } + } else { + if (this._options.max_preserve_newlines && newlines > this._options.max_preserve_newlines) { + newlines = this._options.max_preserve_newlines; + } + + if (this._options.preserve_newlines) { + if (newlines > 1) { + this.print_newline(false, preserve_statement_flags); + for (var j = 1; j < newlines; j += 1) { + this.print_newline(true, preserve_statement_flags); + } + } + } + } + +}; + +var newline_restricted_tokens = ['async', 'break', 'continue', 'return', 'throw', 'yield']; + +Beautifier.prototype.allow_wrap_or_preserved_newline = function(current_token, force_linewrap) { + force_linewrap = (force_linewrap === undefined) ? false : force_linewrap; + + // Never wrap the first token on a line + if (this._output.just_added_newline()) { + return; + } + + var shouldPreserveOrForce = (this._options.preserve_newlines && current_token.newlines) || force_linewrap; + var operatorLogicApplies = in_array(this._flags.last_token.text, positionable_operators) || + in_array(current_token.text, positionable_operators); + + if (operatorLogicApplies) { + var shouldPrintOperatorNewline = ( + in_array(this._flags.last_token.text, positionable_operators) && + in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE) + ) || + in_array(current_token.text, positionable_operators); + shouldPreserveOrForce = shouldPreserveOrForce && shouldPrintOperatorNewline; + } + + if (shouldPreserveOrForce) { + this.print_newline(false, true); + } else if (this._options.wrap_line_length) { + if (reserved_array(this._flags.last_token, newline_restricted_tokens)) { + // These tokens should never have a newline inserted + // between them and the following expression. + return; + } + this._output.set_wrap_point(); + } +}; + +Beautifier.prototype.print_newline = function(force_newline, preserve_statement_flags) { + if (!preserve_statement_flags) { + if (this._flags.last_token.text !== ';' && this._flags.last_token.text !== ',' && this._flags.last_token.text !== '=' && (this._flags.last_token.type !== TOKEN.OPERATOR || this._flags.last_token.text === '--' || this._flags.last_token.text === '++')) { + var next_token = this._tokens.peek(); + while (this._flags.mode === MODE.Statement && + !(this._flags.if_block && reserved_word(next_token, 'else')) && + !this._flags.do_block) { + this.restore_mode(); + } + } + } + + if (this._output.add_new_line(force_newline)) { + this._flags.multiline_frame = true; + } +}; + +Beautifier.prototype.print_token_line_indentation = function(current_token) { + if (this._output.just_added_newline()) { + if (this._options.keep_array_indentation && + current_token.newlines && + (current_token.text === '[' || is_array(this._flags.mode))) { + this._output.current_line.set_indent(-1); + this._output.current_line.push(current_token.whitespace_before); + this._output.space_before_token = false; + } else if (this._output.set_indent(this._flags.indentation_level, this._flags.alignment)) { + this._flags.line_indent_level = this._flags.indentation_level; + } + } +}; + +Beautifier.prototype.print_token = function(current_token) { + if (this._output.raw) { + this._output.add_raw_token(current_token); + return; + } + + if (this._options.comma_first && current_token.previous && current_token.previous.type === TOKEN.COMMA && + this._output.just_added_newline()) { + if (this._output.previous_line.last() === ',') { + var popped = this._output.previous_line.pop(); + // if the comma was already at the start of the line, + // pull back onto that line and reprint the indentation + if (this._output.previous_line.is_empty()) { + this._output.previous_line.push(popped); + this._output.trim(true); + this._output.current_line.pop(); + this._output.trim(); + } + + // add the comma in front of the next token + this.print_token_line_indentation(current_token); + this._output.add_token(','); + this._output.space_before_token = true; + } + } + + this.print_token_line_indentation(current_token); + this._output.non_breaking_space = true; + this._output.add_token(current_token.text); + if (this._output.previous_token_wrapped) { + this._flags.multiline_frame = true; + } +}; + +Beautifier.prototype.indent = function() { + this._flags.indentation_level += 1; + this._output.set_indent(this._flags.indentation_level, this._flags.alignment); +}; + +Beautifier.prototype.deindent = function() { + if (this._flags.indentation_level > 0 && + ((!this._flags.parent) || this._flags.indentation_level > this._flags.parent.indentation_level)) { + this._flags.indentation_level -= 1; + this._output.set_indent(this._flags.indentation_level, this._flags.alignment); + } +}; + +Beautifier.prototype.set_mode = function(mode) { + if (this._flags) { + this._flag_store.push(this._flags); + this._previous_flags = this._flags; + } else { + this._previous_flags = this.create_flags(null, mode); + } + + this._flags = this.create_flags(this._previous_flags, mode); + this._output.set_indent(this._flags.indentation_level, this._flags.alignment); +}; + + +Beautifier.prototype.restore_mode = function() { + if (this._flag_store.length > 0) { + this._previous_flags = this._flags; + this._flags = this._flag_store.pop(); + if (this._previous_flags.mode === MODE.Statement) { + remove_redundant_indentation(this._output, this._previous_flags); + } + this._output.set_indent(this._flags.indentation_level, this._flags.alignment); + } +}; + +Beautifier.prototype.start_of_object_property = function() { + return this._flags.parent.mode === MODE.ObjectLiteral && this._flags.mode === MODE.Statement && ( + (this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) || (reserved_array(this._flags.last_token, ['get', 'set']))); +}; + +Beautifier.prototype.start_of_statement = function(current_token) { + var start = false; + start = start || reserved_array(this._flags.last_token, ['var', 'let', 'const']) && current_token.type === TOKEN.WORD; + start = start || reserved_word(this._flags.last_token, 'do'); + start = start || (!(this._flags.parent.mode === MODE.ObjectLiteral && this._flags.mode === MODE.Statement)) && reserved_array(this._flags.last_token, newline_restricted_tokens) && !current_token.newlines; + start = start || reserved_word(this._flags.last_token, 'else') && + !(reserved_word(current_token, 'if') && !current_token.comments_before); + start = start || (this._flags.last_token.type === TOKEN.END_EXPR && (this._previous_flags.mode === MODE.ForInitializer || this._previous_flags.mode === MODE.Conditional)); + start = start || (this._flags.last_token.type === TOKEN.WORD && this._flags.mode === MODE.BlockStatement && + !this._flags.in_case && + !(current_token.text === '--' || current_token.text === '++') && + this._last_last_text !== 'function' && + current_token.type !== TOKEN.WORD && current_token.type !== TOKEN.RESERVED); + start = start || (this._flags.mode === MODE.ObjectLiteral && ( + (this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) || reserved_array(this._flags.last_token, ['get', 'set']))); + + if (start) { + this.set_mode(MODE.Statement); + this.indent(); + + this.handle_whitespace_and_comments(current_token, true); + + // Issue #276: + // If starting a new statement with [if, for, while, do], push to a new line. + // if (a) if (b) if(c) d(); else e(); else f(); + if (!this.start_of_object_property()) { + this.allow_wrap_or_preserved_newline(current_token, + reserved_array(current_token, ['do', 'for', 'if', 'while'])); + } + return true; + } + return false; +}; + +Beautifier.prototype.handle_start_expr = function(current_token) { + // The conditional starts the statement if appropriate. + if (!this.start_of_statement(current_token)) { + this.handle_whitespace_and_comments(current_token); + } + + var next_mode = MODE.Expression; + if (current_token.text === '[') { + + if (this._flags.last_token.type === TOKEN.WORD || this._flags.last_token.text === ')') { + // this is array index specifier, break immediately + // a[x], fn()[x] + if (reserved_array(this._flags.last_token, line_starters)) { + this._output.space_before_token = true; + } + this.print_token(current_token); + this.set_mode(next_mode); + this.indent(); + if (this._options.space_in_paren) { + this._output.space_before_token = true; + } + return; + } + + next_mode = MODE.ArrayLiteral; + if (is_array(this._flags.mode)) { + if (this._flags.last_token.text === '[' || + (this._flags.last_token.text === ',' && (this._last_last_text === ']' || this._last_last_text === '}'))) { + // ], [ goes to new line + // }, [ goes to new line + if (!this._options.keep_array_indentation) { + this.print_newline(); + } + } + } + + if (!in_array(this._flags.last_token.type, [TOKEN.START_EXPR, TOKEN.END_EXPR, TOKEN.WORD, TOKEN.OPERATOR, TOKEN.DOT])) { + this._output.space_before_token = true; + } + } else { + if (this._flags.last_token.type === TOKEN.RESERVED) { + if (this._flags.last_token.text === 'for') { + this._output.space_before_token = this._options.space_before_conditional; + next_mode = MODE.ForInitializer; + } else if (in_array(this._flags.last_token.text, ['if', 'while', 'switch'])) { + this._output.space_before_token = this._options.space_before_conditional; + next_mode = MODE.Conditional; + } else if (in_array(this._flags.last_word, ['await', 'async'])) { + // Should be a space between await and an IIFE, or async and an arrow function + this._output.space_before_token = true; + } else if (this._flags.last_token.text === 'import' && current_token.whitespace_before === '') { + this._output.space_before_token = false; + } else if (in_array(this._flags.last_token.text, line_starters) || this._flags.last_token.text === 'catch') { + this._output.space_before_token = true; + } + } else if (this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) { + // Support of this kind of newline preservation. + // a = (b && + // (c || d)); + if (!this.start_of_object_property()) { + this.allow_wrap_or_preserved_newline(current_token); + } + } else if (this._flags.last_token.type === TOKEN.WORD) { + this._output.space_before_token = false; + + // function name() vs function name () + // function* name() vs function* name () + // async name() vs async name () + // In ES6, you can also define the method properties of an object + // var obj = {a: function() {}} + // It can be abbreviated + // var obj = {a() {}} + // var obj = { a() {}} vs var obj = { a () {}} + // var obj = { * a() {}} vs var obj = { * a () {}} + var peek_back_two = this._tokens.peek(-3); + if (this._options.space_after_named_function && peek_back_two) { + // peek starts at next character so -1 is current token + var peek_back_three = this._tokens.peek(-4); + if (reserved_array(peek_back_two, ['async', 'function']) || + (peek_back_two.text === '*' && reserved_array(peek_back_three, ['async', 'function']))) { + this._output.space_before_token = true; + } else if (this._flags.mode === MODE.ObjectLiteral) { + if ((peek_back_two.text === '{' || peek_back_two.text === ',') || + (peek_back_two.text === '*' && (peek_back_three.text === '{' || peek_back_three.text === ','))) { + this._output.space_before_token = true; + } + } else if (this._flags.parent && this._flags.parent.class_start_block) { + this._output.space_before_token = true; + } + } + } else { + // Support preserving wrapped arrow function expressions + // a.b('c', + // () => d.e + // ) + this.allow_wrap_or_preserved_newline(current_token); + } + + // function() vs function () + // yield*() vs yield* () + // function*() vs function* () + if ((this._flags.last_token.type === TOKEN.RESERVED && (this._flags.last_word === 'function' || this._flags.last_word === 'typeof')) || + (this._flags.last_token.text === '*' && + (in_array(this._last_last_text, ['function', 'yield']) || + (this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ',']))))) { + this._output.space_before_token = this._options.space_after_anon_function; + } + } + + if (this._flags.last_token.text === ';' || this._flags.last_token.type === TOKEN.START_BLOCK) { + this.print_newline(); + } else if (this._flags.last_token.type === TOKEN.END_EXPR || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.END_BLOCK || this._flags.last_token.text === '.' || this._flags.last_token.type === TOKEN.COMMA) { + // do nothing on (( and )( and ][ and ]( and .( + // TODO: Consider whether forcing this is required. Review failing tests when removed. + this.allow_wrap_or_preserved_newline(current_token, current_token.newlines); + } + + this.print_token(current_token); + this.set_mode(next_mode); + if (this._options.space_in_paren) { + this._output.space_before_token = true; + } + + // In all cases, if we newline while inside an expression it should be indented. + this.indent(); +}; + +Beautifier.prototype.handle_end_expr = function(current_token) { + // statements inside expressions are not valid syntax, but... + // statements must all be closed when their container closes + while (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + + this.handle_whitespace_and_comments(current_token); + + if (this._flags.multiline_frame) { + this.allow_wrap_or_preserved_newline(current_token, + current_token.text === ']' && is_array(this._flags.mode) && !this._options.keep_array_indentation); + } + + if (this._options.space_in_paren) { + if (this._flags.last_token.type === TOKEN.START_EXPR && !this._options.space_in_empty_paren) { + // () [] no inner space in empty parens like these, ever, ref #320 + this._output.trim(); + this._output.space_before_token = false; + } else { + this._output.space_before_token = true; + } + } + this.deindent(); + this.print_token(current_token); + this.restore_mode(); + + remove_redundant_indentation(this._output, this._previous_flags); + + // do {} while () // no statement required after + if (this._flags.do_while && this._previous_flags.mode === MODE.Conditional) { + this._previous_flags.mode = MODE.Expression; + this._flags.do_block = false; + this._flags.do_while = false; + + } +}; + +Beautifier.prototype.handle_start_block = function(current_token) { + this.handle_whitespace_and_comments(current_token); + + // Check if this is should be treated as a ObjectLiteral + var next_token = this._tokens.peek(); + var second_token = this._tokens.peek(1); + if (this._flags.last_word === 'switch' && this._flags.last_token.type === TOKEN.END_EXPR) { + this.set_mode(MODE.BlockStatement); + this._flags.in_case_statement = true; + } else if (this._flags.case_body) { + this.set_mode(MODE.BlockStatement); + } else if (second_token && ( + (in_array(second_token.text, [':', ',']) && in_array(next_token.type, [TOKEN.STRING, TOKEN.WORD, TOKEN.RESERVED])) || + (in_array(next_token.text, ['get', 'set', '...']) && in_array(second_token.type, [TOKEN.WORD, TOKEN.RESERVED])) + )) { + // We don't support TypeScript,but we didn't break it for a very long time. + // We'll try to keep not breaking it. + if (in_array(this._last_last_text, ['class', 'interface']) && !in_array(second_token.text, [':', ','])) { + this.set_mode(MODE.BlockStatement); + } else { + this.set_mode(MODE.ObjectLiteral); + } + } else if (this._flags.last_token.type === TOKEN.OPERATOR && this._flags.last_token.text === '=>') { + // arrow function: (param1, paramN) => { statements } + this.set_mode(MODE.BlockStatement); + } else if (in_array(this._flags.last_token.type, [TOKEN.EQUALS, TOKEN.START_EXPR, TOKEN.COMMA, TOKEN.OPERATOR]) || + reserved_array(this._flags.last_token, ['return', 'throw', 'import', 'default']) + ) { + // Detecting shorthand function syntax is difficult by scanning forward, + // so check the surrounding context. + // If the block is being returned, imported, export default, passed as arg, + // assigned with = or assigned in a nested object, treat as an ObjectLiteral. + this.set_mode(MODE.ObjectLiteral); + } else { + this.set_mode(MODE.BlockStatement); + } + + if (this._flags.last_token) { + if (reserved_array(this._flags.last_token.previous, ['class', 'extends'])) { + this._flags.class_start_block = true; + } + } + + var empty_braces = !next_token.comments_before && next_token.text === '}'; + var empty_anonymous_function = empty_braces && this._flags.last_word === 'function' && + this._flags.last_token.type === TOKEN.END_EXPR; + + if (this._options.brace_preserve_inline) // check for inline, set inline_frame if so + { + // search forward for a newline wanted inside this block + var index = 0; + var check_token = null; + this._flags.inline_frame = true; + do { + index += 1; + check_token = this._tokens.peek(index - 1); + if (check_token.newlines) { + this._flags.inline_frame = false; + break; + } + } while (check_token.type !== TOKEN.EOF && + !(check_token.type === TOKEN.END_BLOCK && check_token.opened === current_token)); + } + + if ((this._options.brace_style === "expand" || + (this._options.brace_style === "none" && current_token.newlines)) && + !this._flags.inline_frame) { + if (this._flags.last_token.type !== TOKEN.OPERATOR && + (empty_anonymous_function || + this._flags.last_token.type === TOKEN.EQUALS || + (reserved_array(this._flags.last_token, special_words) && this._flags.last_token.text !== 'else'))) { + this._output.space_before_token = true; + } else { + this.print_newline(false, true); + } + } else { // collapse || inline_frame + if (is_array(this._previous_flags.mode) && (this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.COMMA)) { + if (this._flags.last_token.type === TOKEN.COMMA || this._options.space_in_paren) { + this._output.space_before_token = true; + } + + if (this._flags.last_token.type === TOKEN.COMMA || (this._flags.last_token.type === TOKEN.START_EXPR && this._flags.inline_frame)) { + this.allow_wrap_or_preserved_newline(current_token); + this._previous_flags.multiline_frame = this._previous_flags.multiline_frame || this._flags.multiline_frame; + this._flags.multiline_frame = false; + } + } + if (this._flags.last_token.type !== TOKEN.OPERATOR && this._flags.last_token.type !== TOKEN.START_EXPR) { + if (in_array(this._flags.last_token.type, [TOKEN.START_BLOCK, TOKEN.SEMICOLON]) && !this._flags.inline_frame) { + this.print_newline(); + } else { + this._output.space_before_token = true; + } + } + } + this.print_token(current_token); + this.indent(); + + // Except for specific cases, open braces are followed by a new line. + if (!empty_braces && !(this._options.brace_preserve_inline && this._flags.inline_frame)) { + this.print_newline(); + } +}; + +Beautifier.prototype.handle_end_block = function(current_token) { + // statements must all be closed when their container closes + this.handle_whitespace_and_comments(current_token); + + while (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + + var empty_braces = this._flags.last_token.type === TOKEN.START_BLOCK; + + if (this._flags.inline_frame && !empty_braces) { // try inline_frame (only set if this._options.braces-preserve-inline) first + this._output.space_before_token = true; + } else if (this._options.brace_style === "expand") { + if (!empty_braces) { + this.print_newline(); + } + } else { + // skip {} + if (!empty_braces) { + if (is_array(this._flags.mode) && this._options.keep_array_indentation) { + // we REALLY need a newline here, but newliner would skip that + this._options.keep_array_indentation = false; + this.print_newline(); + this._options.keep_array_indentation = true; + + } else { + this.print_newline(); + } + } + } + this.restore_mode(); + this.print_token(current_token); +}; + +Beautifier.prototype.handle_word = function(current_token) { + if (current_token.type === TOKEN.RESERVED) { + if (in_array(current_token.text, ['set', 'get']) && this._flags.mode !== MODE.ObjectLiteral) { + current_token.type = TOKEN.WORD; + } else if (current_token.text === 'import' && in_array(this._tokens.peek().text, ['(', '.'])) { + current_token.type = TOKEN.WORD; + } else if (in_array(current_token.text, ['as', 'from']) && !this._flags.import_block) { + current_token.type = TOKEN.WORD; + } else if (this._flags.mode === MODE.ObjectLiteral) { + var next_token = this._tokens.peek(); + if (next_token.text === ':') { + current_token.type = TOKEN.WORD; + } + } + } + + if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + if (reserved_array(this._flags.last_token, ['var', 'let', 'const']) && current_token.type === TOKEN.WORD) { + this._flags.declaration_statement = true; + } + } else if (current_token.newlines && !is_expression(this._flags.mode) && + (this._flags.last_token.type !== TOKEN.OPERATOR || (this._flags.last_token.text === '--' || this._flags.last_token.text === '++')) && + this._flags.last_token.type !== TOKEN.EQUALS && + (this._options.preserve_newlines || !reserved_array(this._flags.last_token, ['var', 'let', 'const', 'set', 'get']))) { + this.handle_whitespace_and_comments(current_token); + this.print_newline(); + } else { + this.handle_whitespace_and_comments(current_token); + } + + if (this._flags.do_block && !this._flags.do_while) { + if (reserved_word(current_token, 'while')) { + // do {} ## while () + this._output.space_before_token = true; + this.print_token(current_token); + this._output.space_before_token = true; + this._flags.do_while = true; + return; + } else { + // do {} should always have while as the next word. + // if we don't see the expected while, recover + this.print_newline(); + this._flags.do_block = false; + } + } + + // if may be followed by else, or not + // Bare/inline ifs are tricky + // Need to unwind the modes correctly: if (a) if (b) c(); else d(); else e(); + if (this._flags.if_block) { + if (!this._flags.else_block && reserved_word(current_token, 'else')) { + this._flags.else_block = true; + } else { + while (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + this._flags.if_block = false; + this._flags.else_block = false; + } + } + + if (this._flags.in_case_statement && reserved_array(current_token, ['case', 'default'])) { + this.print_newline(); + if (!this._flags.case_block && (this._flags.case_body || this._options.jslint_happy)) { + // switch cases following one another + this.deindent(); + } + this._flags.case_body = false; + + this.print_token(current_token); + this._flags.in_case = true; + return; + } + + if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) { + if (!this.start_of_object_property() && !( + // start of object property is different for numeric values with +/- prefix operators + in_array(this._flags.last_token.text, ['+', '-']) && this._last_last_text === ':' && this._flags.parent.mode === MODE.ObjectLiteral)) { + this.allow_wrap_or_preserved_newline(current_token); + } + } + + if (reserved_word(current_token, 'function')) { + if (in_array(this._flags.last_token.text, ['}', ';']) || + (this._output.just_added_newline() && !(in_array(this._flags.last_token.text, ['(', '[', '{', ':', '=', ',']) || this._flags.last_token.type === TOKEN.OPERATOR))) { + // make sure there is a nice clean space of at least one blank line + // before a new function definition + if (!this._output.just_added_blankline() && !current_token.comments_before) { + this.print_newline(); + this.print_newline(true); + } + } + if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD) { + if (reserved_array(this._flags.last_token, ['get', 'set', 'new', 'export']) || + reserved_array(this._flags.last_token, newline_restricted_tokens)) { + this._output.space_before_token = true; + } else if (reserved_word(this._flags.last_token, 'default') && this._last_last_text === 'export') { + this._output.space_before_token = true; + } else if (this._flags.last_token.text === 'declare') { + // accomodates Typescript declare function formatting + this._output.space_before_token = true; + } else { + this.print_newline(); + } + } else if (this._flags.last_token.type === TOKEN.OPERATOR || this._flags.last_token.text === '=') { + // foo = function + this._output.space_before_token = true; + } else if (!this._flags.multiline_frame && (is_expression(this._flags.mode) || is_array(this._flags.mode))) { + // (function + } else { + this.print_newline(); + } + + this.print_token(current_token); + this._flags.last_word = current_token.text; + return; + } + + var prefix = 'NONE'; + + if (this._flags.last_token.type === TOKEN.END_BLOCK) { + + if (this._previous_flags.inline_frame) { + prefix = 'SPACE'; + } else if (!reserved_array(current_token, ['else', 'catch', 'finally', 'from'])) { + prefix = 'NEWLINE'; + } else { + if (this._options.brace_style === "expand" || + this._options.brace_style === "end-expand" || + (this._options.brace_style === "none" && current_token.newlines)) { + prefix = 'NEWLINE'; + } else { + prefix = 'SPACE'; + this._output.space_before_token = true; + } + } + } else if (this._flags.last_token.type === TOKEN.SEMICOLON && this._flags.mode === MODE.BlockStatement) { + // TODO: Should this be for STATEMENT as well? + prefix = 'NEWLINE'; + } else if (this._flags.last_token.type === TOKEN.SEMICOLON && is_expression(this._flags.mode)) { + prefix = 'SPACE'; + } else if (this._flags.last_token.type === TOKEN.STRING) { + prefix = 'NEWLINE'; + } else if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD || + (this._flags.last_token.text === '*' && + (in_array(this._last_last_text, ['function', 'yield']) || + (this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ',']))))) { + prefix = 'SPACE'; + } else if (this._flags.last_token.type === TOKEN.START_BLOCK) { + if (this._flags.inline_frame) { + prefix = 'SPACE'; + } else { + prefix = 'NEWLINE'; + } + } else if (this._flags.last_token.type === TOKEN.END_EXPR) { + this._output.space_before_token = true; + prefix = 'NEWLINE'; + } + + if (reserved_array(current_token, line_starters) && this._flags.last_token.text !== ')') { + if (this._flags.inline_frame || this._flags.last_token.text === 'else' || this._flags.last_token.text === 'export') { + prefix = 'SPACE'; + } else { + prefix = 'NEWLINE'; + } + + } + + if (reserved_array(current_token, ['else', 'catch', 'finally'])) { + if ((!(this._flags.last_token.type === TOKEN.END_BLOCK && this._previous_flags.mode === MODE.BlockStatement) || + this._options.brace_style === "expand" || + this._options.brace_style === "end-expand" || + (this._options.brace_style === "none" && current_token.newlines)) && + !this._flags.inline_frame) { + this.print_newline(); + } else { + this._output.trim(true); + var line = this._output.current_line; + // If we trimmed and there's something other than a close block before us + // put a newline back in. Handles '} // comment' scenario. + if (line.last() !== '}') { + this.print_newline(); + } + this._output.space_before_token = true; + } + } else if (prefix === 'NEWLINE') { + if (reserved_array(this._flags.last_token, special_words)) { + // no newline between 'return nnn' + this._output.space_before_token = true; + } else if (this._flags.last_token.text === 'declare' && reserved_array(current_token, ['var', 'let', 'const'])) { + // accomodates Typescript declare formatting + this._output.space_before_token = true; + } else if (this._flags.last_token.type !== TOKEN.END_EXPR) { + if ((this._flags.last_token.type !== TOKEN.START_EXPR || !reserved_array(current_token, ['var', 'let', 'const'])) && this._flags.last_token.text !== ':') { + // no need to force newline on 'var': for (var x = 0...) + if (reserved_word(current_token, 'if') && reserved_word(current_token.previous, 'else')) { + // no newline for } else if { + this._output.space_before_token = true; + } else { + this.print_newline(); + } + } + } else if (reserved_array(current_token, line_starters) && this._flags.last_token.text !== ')') { + this.print_newline(); + } + } else if (this._flags.multiline_frame && is_array(this._flags.mode) && this._flags.last_token.text === ',' && this._last_last_text === '}') { + this.print_newline(); // }, in lists get a newline treatment + } else if (prefix === 'SPACE') { + this._output.space_before_token = true; + } + if (current_token.previous && (current_token.previous.type === TOKEN.WORD || current_token.previous.type === TOKEN.RESERVED)) { + this._output.space_before_token = true; + } + this.print_token(current_token); + this._flags.last_word = current_token.text; + + if (current_token.type === TOKEN.RESERVED) { + if (current_token.text === 'do') { + this._flags.do_block = true; + } else if (current_token.text === 'if') { + this._flags.if_block = true; + } else if (current_token.text === 'import') { + this._flags.import_block = true; + } else if (this._flags.import_block && reserved_word(current_token, 'from')) { + this._flags.import_block = false; + } + } +}; + +Beautifier.prototype.handle_semicolon = function(current_token) { + if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + // Semicolon can be the start (and end) of a statement + this._output.space_before_token = false; + } else { + this.handle_whitespace_and_comments(current_token); + } + + var next_token = this._tokens.peek(); + while (this._flags.mode === MODE.Statement && + !(this._flags.if_block && reserved_word(next_token, 'else')) && + !this._flags.do_block) { + this.restore_mode(); + } + + // hacky but effective for the moment + if (this._flags.import_block) { + this._flags.import_block = false; + } + this.print_token(current_token); +}; + +Beautifier.prototype.handle_string = function(current_token) { + if (current_token.text.startsWith("`") && current_token.newlines === 0 && current_token.whitespace_before === '' && (current_token.previous.text === ')' || this._flags.last_token.type === TOKEN.WORD)) { + //Conditional for detectign backtick strings + } else if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + // One difference - strings want at least a space before + this._output.space_before_token = true; + } else { + this.handle_whitespace_and_comments(current_token); + if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD || this._flags.inline_frame) { + this._output.space_before_token = true; + } else if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) { + if (!this.start_of_object_property()) { + this.allow_wrap_or_preserved_newline(current_token); + } + } else if ((current_token.text.startsWith("`") && this._flags.last_token.type === TOKEN.END_EXPR && (current_token.previous.text === ']' || current_token.previous.text === ')') && current_token.newlines === 0)) { + this._output.space_before_token = true; + } else { + this.print_newline(); + } + } + this.print_token(current_token); +}; + +Beautifier.prototype.handle_equals = function(current_token) { + if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + } else { + this.handle_whitespace_and_comments(current_token); + } + + if (this._flags.declaration_statement) { + // just got an '=' in a var-line, different formatting/line-breaking, etc will now be done + this._flags.declaration_assignment = true; + } + this._output.space_before_token = true; + this.print_token(current_token); + this._output.space_before_token = true; +}; + +Beautifier.prototype.handle_comma = function(current_token) { + this.handle_whitespace_and_comments(current_token, true); + + this.print_token(current_token); + this._output.space_before_token = true; + if (this._flags.declaration_statement) { + if (is_expression(this._flags.parent.mode)) { + // do not break on comma, for(var a = 1, b = 2) + this._flags.declaration_assignment = false; + } + + if (this._flags.declaration_assignment) { + this._flags.declaration_assignment = false; + this.print_newline(false, true); + } else if (this._options.comma_first) { + // for comma-first, we want to allow a newline before the comma + // to turn into a newline after the comma, which we will fixup later + this.allow_wrap_or_preserved_newline(current_token); + } + } else if (this._flags.mode === MODE.ObjectLiteral || + (this._flags.mode === MODE.Statement && this._flags.parent.mode === MODE.ObjectLiteral)) { + if (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + + if (!this._flags.inline_frame) { + this.print_newline(); + } + } else if (this._options.comma_first) { + // EXPR or DO_BLOCK + // for comma-first, we want to allow a newline before the comma + // to turn into a newline after the comma, which we will fixup later + this.allow_wrap_or_preserved_newline(current_token); + } +}; + +Beautifier.prototype.handle_operator = function(current_token) { + var isGeneratorAsterisk = current_token.text === '*' && + (reserved_array(this._flags.last_token, ['function', 'yield']) || + (in_array(this._flags.last_token.type, [TOKEN.START_BLOCK, TOKEN.COMMA, TOKEN.END_BLOCK, TOKEN.SEMICOLON])) + ); + var isUnary = in_array(current_token.text, ['-', '+']) && ( + in_array(this._flags.last_token.type, [TOKEN.START_BLOCK, TOKEN.START_EXPR, TOKEN.EQUALS, TOKEN.OPERATOR]) || + in_array(this._flags.last_token.text, line_starters) || + this._flags.last_token.text === ',' + ); + + if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + } else { + var preserve_statement_flags = !isGeneratorAsterisk; + this.handle_whitespace_and_comments(current_token, preserve_statement_flags); + } + + // hack for actionscript's import .*; + if (current_token.text === '*' && this._flags.last_token.type === TOKEN.DOT) { + this.print_token(current_token); + return; + } + + if (current_token.text === '::') { + // no spaces around exotic namespacing syntax operator + this.print_token(current_token); + return; + } + + if (in_array(current_token.text, ['-', '+']) && this.start_of_object_property()) { + // numeric value with +/- symbol in front as a property + this.print_token(current_token); + return; + } + + // Allow line wrapping between operators when operator_position is + // set to before or preserve + if (this._flags.last_token.type === TOKEN.OPERATOR && in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)) { + this.allow_wrap_or_preserved_newline(current_token); + } + + if (current_token.text === ':' && this._flags.in_case) { + this.print_token(current_token); + + this._flags.in_case = false; + this._flags.case_body = true; + if (this._tokens.peek().type !== TOKEN.START_BLOCK) { + this.indent(); + this.print_newline(); + this._flags.case_block = false; + } else { + this._flags.case_block = true; + this._output.space_before_token = true; + } + return; + } + + var space_before = true; + var space_after = true; + var in_ternary = false; + if (current_token.text === ':') { + if (this._flags.ternary_depth === 0) { + // Colon is invalid javascript outside of ternary and object, but do our best to guess what was meant. + space_before = false; + } else { + this._flags.ternary_depth -= 1; + in_ternary = true; + } + } else if (current_token.text === '?') { + this._flags.ternary_depth += 1; + } + + // let's handle the operator_position option prior to any conflicting logic + if (!isUnary && !isGeneratorAsterisk && this._options.preserve_newlines && in_array(current_token.text, positionable_operators)) { + var isColon = current_token.text === ':'; + var isTernaryColon = (isColon && in_ternary); + var isOtherColon = (isColon && !in_ternary); + + switch (this._options.operator_position) { + case OPERATOR_POSITION.before_newline: + // if the current token is : and it's not a ternary statement then we set space_before to false + this._output.space_before_token = !isOtherColon; + + this.print_token(current_token); + + if (!isColon || isTernaryColon) { + this.allow_wrap_or_preserved_newline(current_token); + } + + this._output.space_before_token = true; + return; + + case OPERATOR_POSITION.after_newline: + // if the current token is anything but colon, or (via deduction) it's a colon and in a ternary statement, + // then print a newline. + + this._output.space_before_token = true; + + if (!isColon || isTernaryColon) { + if (this._tokens.peek().newlines) { + this.print_newline(false, true); + } else { + this.allow_wrap_or_preserved_newline(current_token); + } + } else { + this._output.space_before_token = false; + } + + this.print_token(current_token); + + this._output.space_before_token = true; + return; + + case OPERATOR_POSITION.preserve_newline: + if (!isOtherColon) { + this.allow_wrap_or_preserved_newline(current_token); + } + + // if we just added a newline, or the current token is : and it's not a ternary statement, + // then we set space_before to false + space_before = !(this._output.just_added_newline() || isOtherColon); + + this._output.space_before_token = space_before; + this.print_token(current_token); + this._output.space_before_token = true; + return; + } + } + + if (isGeneratorAsterisk) { + this.allow_wrap_or_preserved_newline(current_token); + space_before = false; + var next_token = this._tokens.peek(); + space_after = next_token && in_array(next_token.type, [TOKEN.WORD, TOKEN.RESERVED]); + } else if (current_token.text === '...') { + this.allow_wrap_or_preserved_newline(current_token); + space_before = this._flags.last_token.type === TOKEN.START_BLOCK; + space_after = false; + } else if (in_array(current_token.text, ['--', '++', '!', '~']) || isUnary) { + // unary operators (and binary +/- pretending to be unary) special cases + if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR) { + this.allow_wrap_or_preserved_newline(current_token); + } + + space_before = false; + space_after = false; + + // http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1 + // if there is a newline between -- or ++ and anything else we should preserve it. + if (current_token.newlines && (current_token.text === '--' || current_token.text === '++' || current_token.text === '~')) { + var new_line_needed = reserved_array(this._flags.last_token, special_words) && current_token.newlines; + if (new_line_needed && (this._previous_flags.if_block || this._previous_flags.else_block)) { + this.restore_mode(); + } + this.print_newline(new_line_needed, true); + } + + if (this._flags.last_token.text === ';' && is_expression(this._flags.mode)) { + // for (;; ++i) + // ^^^ + space_before = true; + } + + if (this._flags.last_token.type === TOKEN.RESERVED) { + space_before = true; + } else if (this._flags.last_token.type === TOKEN.END_EXPR) { + space_before = !(this._flags.last_token.text === ']' && (current_token.text === '--' || current_token.text === '++')); + } else if (this._flags.last_token.type === TOKEN.OPERATOR) { + // a++ + ++b; + // a - -b + space_before = in_array(current_token.text, ['--', '-', '++', '+']) && in_array(this._flags.last_token.text, ['--', '-', '++', '+']); + // + and - are not unary when preceeded by -- or ++ operator + // a-- + b + // a * +b + // a - -b + if (in_array(current_token.text, ['+', '-']) && in_array(this._flags.last_token.text, ['--', '++'])) { + space_after = true; + } + } + + + if (((this._flags.mode === MODE.BlockStatement && !this._flags.inline_frame) || this._flags.mode === MODE.Statement) && + (this._flags.last_token.text === '{' || this._flags.last_token.text === ';')) { + // { foo; --i } + // foo(); --bar; + this.print_newline(); + } + } + + this._output.space_before_token = this._output.space_before_token || space_before; + this.print_token(current_token); + this._output.space_before_token = space_after; +}; + +Beautifier.prototype.handle_block_comment = function(current_token, preserve_statement_flags) { + if (this._output.raw) { + this._output.add_raw_token(current_token); + if (current_token.directives && current_token.directives.preserve === 'end') { + // If we're testing the raw output behavior, do not allow a directive to turn it off. + this._output.raw = this._options.test_output_raw; + } + return; + } + + if (current_token.directives) { + this.print_newline(false, preserve_statement_flags); + this.print_token(current_token); + if (current_token.directives.preserve === 'start') { + this._output.raw = true; + } + this.print_newline(false, true); + return; + } + + // inline block + if (!acorn.newline.test(current_token.text) && !current_token.newlines) { + this._output.space_before_token = true; + this.print_token(current_token); + this._output.space_before_token = true; + return; + } else { + this.print_block_commment(current_token, preserve_statement_flags); + } +}; + +Beautifier.prototype.print_block_commment = function(current_token, preserve_statement_flags) { + var lines = split_linebreaks(current_token.text); + var j; // iterator for this case + var javadoc = false; + var starless = false; + var lastIndent = current_token.whitespace_before; + var lastIndentLength = lastIndent.length; + + // block comment starts with a new line + this.print_newline(false, preserve_statement_flags); + + // first line always indented + this.print_token_line_indentation(current_token); + this._output.add_token(lines[0]); + this.print_newline(false, preserve_statement_flags); + + + if (lines.length > 1) { + lines = lines.slice(1); + javadoc = all_lines_start_with(lines, '*'); + starless = each_line_matches_indent(lines, lastIndent); + + if (javadoc) { + this._flags.alignment = 1; + } + + for (j = 0; j < lines.length; j++) { + if (javadoc) { + // javadoc: reformat and re-indent + this.print_token_line_indentation(current_token); + this._output.add_token(ltrim(lines[j])); + } else if (starless && lines[j]) { + // starless: re-indent non-empty content, avoiding trim + this.print_token_line_indentation(current_token); + this._output.add_token(lines[j].substring(lastIndentLength)); + } else { + // normal comments output raw + this._output.current_line.set_indent(-1); + this._output.add_token(lines[j]); + } + + // for comments on their own line or more than one line, make sure there's a new line after + this.print_newline(false, preserve_statement_flags); + } + + this._flags.alignment = 0; + } +}; + + +Beautifier.prototype.handle_comment = function(current_token, preserve_statement_flags) { + if (current_token.newlines) { + this.print_newline(false, preserve_statement_flags); + } else { + this._output.trim(true); + } + + this._output.space_before_token = true; + this.print_token(current_token); + this.print_newline(false, preserve_statement_flags); +}; + +Beautifier.prototype.handle_dot = function(current_token) { + if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + } else { + this.handle_whitespace_and_comments(current_token, true); + } + + if (this._flags.last_token.text.match('^[0-9]+$')) { + this._output.space_before_token = true; + } + + if (reserved_array(this._flags.last_token, special_words)) { + this._output.space_before_token = false; + } else { + // allow preserved newlines before dots in general + // force newlines on dots after close paren when break_chained - for bar().baz() + this.allow_wrap_or_preserved_newline(current_token, + this._flags.last_token.text === ')' && this._options.break_chained_methods); + } + + // Only unindent chained method dot if this dot starts a new line. + // Otherwise the automatic extra indentation removal will handle the over indent + if (this._options.unindent_chained_methods && this._output.just_added_newline()) { + this.deindent(); + } + + this.print_token(current_token); +}; + +Beautifier.prototype.handle_unknown = function(current_token, preserve_statement_flags) { + this.print_token(current_token); + + if (current_token.text[current_token.text.length - 1] === '\n') { + this.print_newline(false, preserve_statement_flags); + } +}; + +Beautifier.prototype.handle_eof = function(current_token) { + // Unwind any open statements + while (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + this.handle_whitespace_and_comments(current_token); +}; + +module.exports.Beautifier = Beautifier; + + +/***/ }), +/* 2 */ +/***/ (function(module) { + +/*jshint node:true */ +/* + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + + + +function OutputLine(parent) { + this.__parent = parent; + this.__character_count = 0; + // use indent_count as a marker for this.__lines that have preserved indentation + this.__indent_count = -1; + this.__alignment_count = 0; + this.__wrap_point_index = 0; + this.__wrap_point_character_count = 0; + this.__wrap_point_indent_count = -1; + this.__wrap_point_alignment_count = 0; + + this.__items = []; +} + +OutputLine.prototype.clone_empty = function() { + var line = new OutputLine(this.__parent); + line.set_indent(this.__indent_count, this.__alignment_count); + return line; +}; + +OutputLine.prototype.item = function(index) { + if (index < 0) { + return this.__items[this.__items.length + index]; + } else { + return this.__items[index]; + } +}; + +OutputLine.prototype.has_match = function(pattern) { + for (var lastCheckedOutput = this.__items.length - 1; lastCheckedOutput >= 0; lastCheckedOutput--) { + if (this.__items[lastCheckedOutput].match(pattern)) { + return true; + } + } + return false; +}; + +OutputLine.prototype.set_indent = function(indent, alignment) { + if (this.is_empty()) { + this.__indent_count = indent || 0; + this.__alignment_count = alignment || 0; + this.__character_count = this.__parent.get_indent_size(this.__indent_count, this.__alignment_count); + } +}; + +OutputLine.prototype._set_wrap_point = function() { + if (this.__parent.wrap_line_length) { + this.__wrap_point_index = this.__items.length; + this.__wrap_point_character_count = this.__character_count; + this.__wrap_point_indent_count = this.__parent.next_line.__indent_count; + this.__wrap_point_alignment_count = this.__parent.next_line.__alignment_count; + } +}; + +OutputLine.prototype._should_wrap = function() { + return this.__wrap_point_index && + this.__character_count > this.__parent.wrap_line_length && + this.__wrap_point_character_count > this.__parent.next_line.__character_count; +}; + +OutputLine.prototype._allow_wrap = function() { + if (this._should_wrap()) { + this.__parent.add_new_line(); + var next = this.__parent.current_line; + next.set_indent(this.__wrap_point_indent_count, this.__wrap_point_alignment_count); + next.__items = this.__items.slice(this.__wrap_point_index); + this.__items = this.__items.slice(0, this.__wrap_point_index); + + next.__character_count += this.__character_count - this.__wrap_point_character_count; + this.__character_count = this.__wrap_point_character_count; + + if (next.__items[0] === " ") { + next.__items.splice(0, 1); + next.__character_count -= 1; + } + return true; + } + return false; +}; + +OutputLine.prototype.is_empty = function() { + return this.__items.length === 0; +}; + +OutputLine.prototype.last = function() { + if (!this.is_empty()) { + return this.__items[this.__items.length - 1]; + } else { + return null; + } +}; + +OutputLine.prototype.push = function(item) { + this.__items.push(item); + var last_newline_index = item.lastIndexOf('\n'); + if (last_newline_index !== -1) { + this.__character_count = item.length - last_newline_index; + } else { + this.__character_count += item.length; + } +}; + +OutputLine.prototype.pop = function() { + var item = null; + if (!this.is_empty()) { + item = this.__items.pop(); + this.__character_count -= item.length; + } + return item; +}; + + +OutputLine.prototype._remove_indent = function() { + if (this.__indent_count > 0) { + this.__indent_count -= 1; + this.__character_count -= this.__parent.indent_size; + } +}; + +OutputLine.prototype._remove_wrap_indent = function() { + if (this.__wrap_point_indent_count > 0) { + this.__wrap_point_indent_count -= 1; + } +}; +OutputLine.prototype.trim = function() { + while (this.last() === ' ') { + this.__items.pop(); + this.__character_count -= 1; + } +}; + +OutputLine.prototype.toString = function() { + var result = ''; + if (this.is_empty()) { + if (this.__parent.indent_empty_lines) { + result = this.__parent.get_indent_string(this.__indent_count); + } + } else { + result = this.__parent.get_indent_string(this.__indent_count, this.__alignment_count); + result += this.__items.join(''); + } + return result; +}; + +function IndentStringCache(options, baseIndentString) { + this.__cache = ['']; + this.__indent_size = options.indent_size; + this.__indent_string = options.indent_char; + if (!options.indent_with_tabs) { + this.__indent_string = new Array(options.indent_size + 1).join(options.indent_char); + } + + // Set to null to continue support for auto detection of base indent + baseIndentString = baseIndentString || ''; + if (options.indent_level > 0) { + baseIndentString = new Array(options.indent_level + 1).join(this.__indent_string); + } + + this.__base_string = baseIndentString; + this.__base_string_length = baseIndentString.length; +} + +IndentStringCache.prototype.get_indent_size = function(indent, column) { + var result = this.__base_string_length; + column = column || 0; + if (indent < 0) { + result = 0; + } + result += indent * this.__indent_size; + result += column; + return result; +}; + +IndentStringCache.prototype.get_indent_string = function(indent_level, column) { + var result = this.__base_string; + column = column || 0; + if (indent_level < 0) { + indent_level = 0; + result = ''; + } + column += indent_level * this.__indent_size; + this.__ensure_cache(column); + result += this.__cache[column]; + return result; +}; + +IndentStringCache.prototype.__ensure_cache = function(column) { + while (column >= this.__cache.length) { + this.__add_column(); + } +}; + +IndentStringCache.prototype.__add_column = function() { + var column = this.__cache.length; + var indent = 0; + var result = ''; + if (this.__indent_size && column >= this.__indent_size) { + indent = Math.floor(column / this.__indent_size); + column -= indent * this.__indent_size; + result = new Array(indent + 1).join(this.__indent_string); + } + if (column) { + result += new Array(column + 1).join(' '); + } + + this.__cache.push(result); +}; + +function Output(options, baseIndentString) { + this.__indent_cache = new IndentStringCache(options, baseIndentString); + this.raw = false; + this._end_with_newline = options.end_with_newline; + this.indent_size = options.indent_size; + this.wrap_line_length = options.wrap_line_length; + this.indent_empty_lines = options.indent_empty_lines; + this.__lines = []; + this.previous_line = null; + this.current_line = null; + this.next_line = new OutputLine(this); + this.space_before_token = false; + this.non_breaking_space = false; + this.previous_token_wrapped = false; + // initialize + this.__add_outputline(); +} + +Output.prototype.__add_outputline = function() { + this.previous_line = this.current_line; + this.current_line = this.next_line.clone_empty(); + this.__lines.push(this.current_line); +}; + +Output.prototype.get_line_number = function() { + return this.__lines.length; +}; + +Output.prototype.get_indent_string = function(indent, column) { + return this.__indent_cache.get_indent_string(indent, column); +}; + +Output.prototype.get_indent_size = function(indent, column) { + return this.__indent_cache.get_indent_size(indent, column); +}; + +Output.prototype.is_empty = function() { + return !this.previous_line && this.current_line.is_empty(); +}; + +Output.prototype.add_new_line = function(force_newline) { + // never newline at the start of file + // otherwise, newline only if we didn't just add one or we're forced + if (this.is_empty() || + (!force_newline && this.just_added_newline())) { + return false; + } + + // if raw output is enabled, don't print additional newlines, + // but still return True as though you had + if (!this.raw) { + this.__add_outputline(); + } + return true; +}; + +Output.prototype.get_code = function(eol) { + this.trim(true); + + // handle some edge cases where the last tokens + // has text that ends with newline(s) + var last_item = this.current_line.pop(); + if (last_item) { + if (last_item[last_item.length - 1] === '\n') { + last_item = last_item.replace(/\n+$/g, ''); + } + this.current_line.push(last_item); + } + + if (this._end_with_newline) { + this.__add_outputline(); + } + + var sweet_code = this.__lines.join('\n'); + + if (eol !== '\n') { + sweet_code = sweet_code.replace(/[\n]/g, eol); + } + return sweet_code; +}; + +Output.prototype.set_wrap_point = function() { + this.current_line._set_wrap_point(); +}; + +Output.prototype.set_indent = function(indent, alignment) { + indent = indent || 0; + alignment = alignment || 0; + + // Next line stores alignment values + this.next_line.set_indent(indent, alignment); + + // Never indent your first output indent at the start of the file + if (this.__lines.length > 1) { + this.current_line.set_indent(indent, alignment); + return true; + } + + this.current_line.set_indent(); + return false; +}; + +Output.prototype.add_raw_token = function(token) { + for (var x = 0; x < token.newlines; x++) { + this.__add_outputline(); + } + this.current_line.set_indent(-1); + this.current_line.push(token.whitespace_before); + this.current_line.push(token.text); + this.space_before_token = false; + this.non_breaking_space = false; + this.previous_token_wrapped = false; +}; + +Output.prototype.add_token = function(printable_token) { + this.__add_space_before_token(); + this.current_line.push(printable_token); + this.space_before_token = false; + this.non_breaking_space = false; + this.previous_token_wrapped = this.current_line._allow_wrap(); +}; + +Output.prototype.__add_space_before_token = function() { + if (this.space_before_token && !this.just_added_newline()) { + if (!this.non_breaking_space) { + this.set_wrap_point(); + } + this.current_line.push(' '); + } +}; + +Output.prototype.remove_indent = function(index) { + var output_length = this.__lines.length; + while (index < output_length) { + this.__lines[index]._remove_indent(); + index++; + } + this.current_line._remove_wrap_indent(); +}; + +Output.prototype.trim = function(eat_newlines) { + eat_newlines = (eat_newlines === undefined) ? false : eat_newlines; + + this.current_line.trim(); + + while (eat_newlines && this.__lines.length > 1 && + this.current_line.is_empty()) { + this.__lines.pop(); + this.current_line = this.__lines[this.__lines.length - 1]; + this.current_line.trim(); + } + + this.previous_line = this.__lines.length > 1 ? + this.__lines[this.__lines.length - 2] : null; +}; + +Output.prototype.just_added_newline = function() { + return this.current_line.is_empty(); +}; + +Output.prototype.just_added_blankline = function() { + return this.is_empty() || + (this.current_line.is_empty() && this.previous_line.is_empty()); +}; + +Output.prototype.ensure_empty_line_above = function(starts_with, ends_with) { + var index = this.__lines.length - 2; + while (index >= 0) { + var potentialEmptyLine = this.__lines[index]; + if (potentialEmptyLine.is_empty()) { + break; + } else if (potentialEmptyLine.item(0).indexOf(starts_with) !== 0 && + potentialEmptyLine.item(-1) !== ends_with) { + this.__lines.splice(index + 1, 0, new OutputLine(this)); + this.previous_line = this.__lines[this.__lines.length - 2]; + break; + } + index--; + } +}; + +module.exports.Output = Output; + + +/***/ }), +/* 3 */ +/***/ (function(module) { + +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + + + +function Token(type, text, newlines, whitespace_before) { + this.type = type; + this.text = text; + + // comments_before are + // comments that have a new line before them + // and may or may not have a newline after + // this is a set of comments before + this.comments_before = null; /* inline comment*/ + + + // this.comments_after = new TokenStream(); // no new line before and newline after + this.newlines = newlines || 0; + this.whitespace_before = whitespace_before || ''; + this.parent = null; + this.next = null; + this.previous = null; + this.opened = null; + this.closed = null; + this.directives = null; +} + + +module.exports.Token = Token; + + +/***/ }), +/* 4 */ +/***/ (function(__unused_webpack_module, exports) { + +/* jshint node: true, curly: false */ +// Parts of this section of code is taken from acorn. +// +// Acorn was written by Marijn Haverbeke and released under an MIT +// license. The Unicode regexps (for identifiers and whitespace) were +// taken from [Esprima](http://esprima.org) by Ariya Hidayat. +// +// Git repositories for Acorn are available at +// +// http://marijnhaverbeke.nl/git/acorn +// https://github.com/marijnh/acorn.git + +// ## Character categories + + + + +// acorn used char codes to squeeze the last bit of performance out +// Beautifier is okay without that, so we're using regex +// permit # (23), $ (36), and @ (64). @ is used in ES7 decorators. +// 65 through 91 are uppercase letters. +// permit _ (95). +// 97 through 123 are lowercase letters. +var baseASCIIidentifierStartChars = "\\x23\\x24\\x40\\x41-\\x5a\\x5f\\x61-\\x7a"; + +// inside an identifier @ is not allowed but 0-9 are. +var baseASCIIidentifierChars = "\\x24\\x30-\\x39\\x41-\\x5a\\x5f\\x61-\\x7a"; + +// Big ugly regular expressions that match characters in the +// whitespace, identifier, and identifier-start categories. These +// are only applied when a character is found to actually have a +// code point above 128. +var nonASCIIidentifierStartChars = "\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05d0-\\u05ea\\u05f0-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u08a0\\u08a2-\\u08ac\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0977\\u0979-\\u097f\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c33\\u0c35-\\u0c39\\u0c3d\\u0c58\\u0c59\\u0c60\\u0c61\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d60\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e87\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa\\u0eab\\u0ead-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f4\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f0\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1877\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191c\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19c1-\\u19c7\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1ce9-\\u1cec\\u1cee-\\u1cf1\\u1cf5\\u1cf6\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2119-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u212d\\u212f-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u2e2f\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309d-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312d\\u3131-\\u318e\\u31a0-\\u31ba\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fcc\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua697\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua78e\\ua790-\\ua793\\ua7a0-\\ua7aa\\ua7f8-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa80-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uabc0-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc"; +var nonASCIIidentifierChars = "\\u0300-\\u036f\\u0483-\\u0487\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u0620-\\u0649\\u0672-\\u06d3\\u06e7-\\u06e8\\u06fb-\\u06fc\\u0730-\\u074a\\u0800-\\u0814\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0840-\\u0857\\u08e4-\\u08fe\\u0900-\\u0903\\u093a-\\u093c\\u093e-\\u094f\\u0951-\\u0957\\u0962-\\u0963\\u0966-\\u096f\\u0981-\\u0983\\u09bc\\u09be-\\u09c4\\u09c7\\u09c8\\u09d7\\u09df-\\u09e0\\u0a01-\\u0a03\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a66-\\u0a71\\u0a75\\u0a81-\\u0a83\\u0abc\\u0abe-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ae2-\\u0ae3\\u0ae6-\\u0aef\\u0b01-\\u0b03\\u0b3c\\u0b3e-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b56\\u0b57\\u0b5f-\\u0b60\\u0b66-\\u0b6f\\u0b82\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd7\\u0be6-\\u0bef\\u0c01-\\u0c03\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62-\\u0c63\\u0c66-\\u0c6f\\u0c82\\u0c83\\u0cbc\\u0cbe-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0ce2-\\u0ce3\\u0ce6-\\u0cef\\u0d02\\u0d03\\u0d46-\\u0d48\\u0d57\\u0d62-\\u0d63\\u0d66-\\u0d6f\\u0d82\\u0d83\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0df2\\u0df3\\u0e34-\\u0e3a\\u0e40-\\u0e45\\u0e50-\\u0e59\\u0eb4-\\u0eb9\\u0ec8-\\u0ecd\\u0ed0-\\u0ed9\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f41-\\u0f47\\u0f71-\\u0f84\\u0f86-\\u0f87\\u0f8d-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u1000-\\u1029\\u1040-\\u1049\\u1067-\\u106d\\u1071-\\u1074\\u1082-\\u108d\\u108f-\\u109d\\u135d-\\u135f\\u170e-\\u1710\\u1720-\\u1730\\u1740-\\u1750\\u1772\\u1773\\u1780-\\u17b2\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u1810-\\u1819\\u1920-\\u192b\\u1930-\\u193b\\u1951-\\u196d\\u19b0-\\u19c0\\u19c8-\\u19c9\\u19d0-\\u19d9\\u1a00-\\u1a15\\u1a20-\\u1a53\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1b46-\\u1b4b\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1bb0-\\u1bb9\\u1be6-\\u1bf3\\u1c00-\\u1c22\\u1c40-\\u1c49\\u1c5b-\\u1c7d\\u1cd0-\\u1cd2\\u1d00-\\u1dbe\\u1e01-\\u1f15\\u200c\\u200d\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2d81-\\u2d96\\u2de0-\\u2dff\\u3021-\\u3028\\u3099\\u309a\\ua640-\\ua66d\\ua674-\\ua67d\\ua69f\\ua6f0-\\ua6f1\\ua7f8-\\ua800\\ua806\\ua80b\\ua823-\\ua827\\ua880-\\ua881\\ua8b4-\\ua8c4\\ua8d0-\\ua8d9\\ua8f3-\\ua8f7\\ua900-\\ua909\\ua926-\\ua92d\\ua930-\\ua945\\ua980-\\ua983\\ua9b3-\\ua9c0\\uaa00-\\uaa27\\uaa40-\\uaa41\\uaa4c-\\uaa4d\\uaa50-\\uaa59\\uaa7b\\uaae0-\\uaae9\\uaaf2-\\uaaf3\\uabc0-\\uabe1\\uabec\\uabed\\uabf0-\\uabf9\\ufb20-\\ufb28\\ufe00-\\ufe0f\\ufe20-\\ufe26\\ufe33\\ufe34\\ufe4d-\\ufe4f\\uff10-\\uff19\\uff3f"; +//var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]"); +//var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]"); + +var unicodeEscapeOrCodePoint = "\\\\u[0-9a-fA-F]{4}|\\\\u\\{[0-9a-fA-F]+\\}"; +var identifierStart = "(?:" + unicodeEscapeOrCodePoint + "|[" + baseASCIIidentifierStartChars + nonASCIIidentifierStartChars + "])"; +var identifierChars = "(?:" + unicodeEscapeOrCodePoint + "|[" + baseASCIIidentifierChars + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "])*"; + +exports.identifier = new RegExp(identifierStart + identifierChars, 'g'); +exports.identifierStart = new RegExp(identifierStart); +exports.identifierMatch = new RegExp("(?:" + unicodeEscapeOrCodePoint + "|[" + baseASCIIidentifierChars + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "])+"); + +var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/; // jshint ignore:line + +// Whether a single character denotes a newline. + +exports.newline = /[\n\r\u2028\u2029]/; + +// Matches a whole line break (where CRLF is considered a single +// line break). Used to count lines. + +// in javascript, these two differ +// in python they are the same, different methods are called on them +exports.lineBreak = new RegExp('\r\n|' + exports.newline.source); +exports.allLineBreaks = new RegExp(exports.lineBreak.source, 'g'); + + +/***/ }), +/* 5 */ +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + + + +var BaseOptions = (__webpack_require__(6).Options); + +var validPositionValues = ['before-newline', 'after-newline', 'preserve-newline']; + +function Options(options) { + BaseOptions.call(this, options, 'js'); + + // compatibility, re + var raw_brace_style = this.raw_options.brace_style || null; + if (raw_brace_style === "expand-strict") { //graceful handling of deprecated option + this.raw_options.brace_style = "expand"; + } else if (raw_brace_style === "collapse-preserve-inline") { //graceful handling of deprecated option + this.raw_options.brace_style = "collapse,preserve-inline"; + } else if (this.raw_options.braces_on_own_line !== undefined) { //graceful handling of deprecated option + this.raw_options.brace_style = this.raw_options.braces_on_own_line ? "expand" : "collapse"; + // } else if (!raw_brace_style) { //Nothing exists to set it + // raw_brace_style = "collapse"; + } + + //preserve-inline in delimited string will trigger brace_preserve_inline, everything + //else is considered a brace_style and the last one only will have an effect + + var brace_style_split = this._get_selection_list('brace_style', ['collapse', 'expand', 'end-expand', 'none', 'preserve-inline']); + + this.brace_preserve_inline = false; //Defaults in case one or other was not specified in meta-option + this.brace_style = "collapse"; + + for (var bs = 0; bs < brace_style_split.length; bs++) { + if (brace_style_split[bs] === "preserve-inline") { + this.brace_preserve_inline = true; + } else { + this.brace_style = brace_style_split[bs]; + } + } + + this.unindent_chained_methods = this._get_boolean('unindent_chained_methods'); + this.break_chained_methods = this._get_boolean('break_chained_methods'); + this.space_in_paren = this._get_boolean('space_in_paren'); + this.space_in_empty_paren = this._get_boolean('space_in_empty_paren'); + this.jslint_happy = this._get_boolean('jslint_happy'); + this.space_after_anon_function = this._get_boolean('space_after_anon_function'); + this.space_after_named_function = this._get_boolean('space_after_named_function'); + this.keep_array_indentation = this._get_boolean('keep_array_indentation'); + this.space_before_conditional = this._get_boolean('space_before_conditional', true); + this.unescape_strings = this._get_boolean('unescape_strings'); + this.e4x = this._get_boolean('e4x'); + this.comma_first = this._get_boolean('comma_first'); + this.operator_position = this._get_selection('operator_position', validPositionValues); + + // For testing of beautify preserve:start directive + this.test_output_raw = this._get_boolean('test_output_raw'); + + // force this._options.space_after_anon_function to true if this._options.jslint_happy + if (this.jslint_happy) { + this.space_after_anon_function = true; + } + +} +Options.prototype = new BaseOptions(); + + + +module.exports.Options = Options; + + +/***/ }), +/* 6 */ +/***/ (function(module) { + +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + + + +function Options(options, merge_child_field) { + this.raw_options = _mergeOpts(options, merge_child_field); + + // Support passing the source text back with no change + this.disabled = this._get_boolean('disabled'); + + this.eol = this._get_characters('eol', 'auto'); + this.end_with_newline = this._get_boolean('end_with_newline'); + this.indent_size = this._get_number('indent_size', 4); + this.indent_char = this._get_characters('indent_char', ' '); + this.indent_level = this._get_number('indent_level'); + + this.preserve_newlines = this._get_boolean('preserve_newlines', true); + this.max_preserve_newlines = this._get_number('max_preserve_newlines', 32786); + if (!this.preserve_newlines) { + this.max_preserve_newlines = 0; + } + + this.indent_with_tabs = this._get_boolean('indent_with_tabs', this.indent_char === '\t'); + if (this.indent_with_tabs) { + this.indent_char = '\t'; + + // indent_size behavior changed after 1.8.6 + // It used to be that indent_size would be + // set to 1 for indent_with_tabs. That is no longer needed and + // actually doesn't make sense - why not use spaces? Further, + // that might produce unexpected behavior - tabs being used + // for single-column alignment. So, when indent_with_tabs is true + // and indent_size is 1, reset indent_size to 4. + if (this.indent_size === 1) { + this.indent_size = 4; + } + } + + // Backwards compat with 1.3.x + this.wrap_line_length = this._get_number('wrap_line_length', this._get_number('max_char')); + + this.indent_empty_lines = this._get_boolean('indent_empty_lines'); + + // valid templating languages ['django', 'erb', 'handlebars', 'php', 'smarty', 'angular'] + // For now, 'auto' = all off for javascript, all except angular on for html (and inline javascript/css). + // other values ignored + this.templating = this._get_selection_list('templating', ['auto', 'none', 'angular', 'django', 'erb', 'handlebars', 'php', 'smarty'], ['auto']); +} + +Options.prototype._get_array = function(name, default_value) { + var option_value = this.raw_options[name]; + var result = default_value || []; + if (typeof option_value === 'object') { + if (option_value !== null && typeof option_value.concat === 'function') { + result = option_value.concat(); + } + } else if (typeof option_value === 'string') { + result = option_value.split(/[^a-zA-Z0-9_\/\-]+/); + } + return result; +}; + +Options.prototype._get_boolean = function(name, default_value) { + var option_value = this.raw_options[name]; + var result = option_value === undefined ? !!default_value : !!option_value; + return result; +}; + +Options.prototype._get_characters = function(name, default_value) { + var option_value = this.raw_options[name]; + var result = default_value || ''; + if (typeof option_value === 'string') { + result = option_value.replace(/\\r/, '\r').replace(/\\n/, '\n').replace(/\\t/, '\t'); + } + return result; +}; + +Options.prototype._get_number = function(name, default_value) { + var option_value = this.raw_options[name]; + default_value = parseInt(default_value, 10); + if (isNaN(default_value)) { + default_value = 0; + } + var result = parseInt(option_value, 10); + if (isNaN(result)) { + result = default_value; + } + return result; +}; + +Options.prototype._get_selection = function(name, selection_list, default_value) { + var result = this._get_selection_list(name, selection_list, default_value); + if (result.length !== 1) { + throw new Error( + "Invalid Option Value: The option '" + name + "' can only be one of the following values:\n" + + selection_list + "\nYou passed in: '" + this.raw_options[name] + "'"); + } + + return result[0]; +}; + + +Options.prototype._get_selection_list = function(name, selection_list, default_value) { + if (!selection_list || selection_list.length === 0) { + throw new Error("Selection list cannot be empty."); + } + + default_value = default_value || [selection_list[0]]; + if (!this._is_valid_selection(default_value, selection_list)) { + throw new Error("Invalid Default Value!"); + } + + var result = this._get_array(name, default_value); + if (!this._is_valid_selection(result, selection_list)) { + throw new Error( + "Invalid Option Value: The option '" + name + "' can contain only the following values:\n" + + selection_list + "\nYou passed in: '" + this.raw_options[name] + "'"); + } + + return result; +}; + +Options.prototype._is_valid_selection = function(result, selection_list) { + return result.length && selection_list.length && + !result.some(function(item) { return selection_list.indexOf(item) === -1; }); +}; + + +// merges child options up with the parent options object +// Example: obj = {a: 1, b: {a: 2}} +// mergeOpts(obj, 'b') +// +// Returns: {a: 2} +function _mergeOpts(allOptions, childFieldName) { + var finalOpts = {}; + allOptions = _normalizeOpts(allOptions); + var name; + + for (name in allOptions) { + if (name !== childFieldName) { + finalOpts[name] = allOptions[name]; + } + } + + //merge in the per type settings for the childFieldName + if (childFieldName && allOptions[childFieldName]) { + for (name in allOptions[childFieldName]) { + finalOpts[name] = allOptions[childFieldName][name]; + } + } + return finalOpts; +} + +function _normalizeOpts(options) { + var convertedOpts = {}; + var key; + + for (key in options) { + var newKey = key.replace(/-/g, "_"); + convertedOpts[newKey] = options[key]; + } + return convertedOpts; +} + +module.exports.Options = Options; +module.exports.normalizeOpts = _normalizeOpts; +module.exports.mergeOpts = _mergeOpts; + + +/***/ }), +/* 7 */ +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + + + +var InputScanner = (__webpack_require__(8).InputScanner); +var BaseTokenizer = (__webpack_require__(9).Tokenizer); +var BASETOKEN = (__webpack_require__(9).TOKEN); +var Directives = (__webpack_require__(13).Directives); +var acorn = __webpack_require__(4); +var Pattern = (__webpack_require__(12).Pattern); +var TemplatablePattern = (__webpack_require__(14).TemplatablePattern); + + +function in_array(what, arr) { + return arr.indexOf(what) !== -1; +} + + +var TOKEN = { + START_EXPR: 'TK_START_EXPR', + END_EXPR: 'TK_END_EXPR', + START_BLOCK: 'TK_START_BLOCK', + END_BLOCK: 'TK_END_BLOCK', + WORD: 'TK_WORD', + RESERVED: 'TK_RESERVED', + SEMICOLON: 'TK_SEMICOLON', + STRING: 'TK_STRING', + EQUALS: 'TK_EQUALS', + OPERATOR: 'TK_OPERATOR', + COMMA: 'TK_COMMA', + BLOCK_COMMENT: 'TK_BLOCK_COMMENT', + COMMENT: 'TK_COMMENT', + DOT: 'TK_DOT', + UNKNOWN: 'TK_UNKNOWN', + START: BASETOKEN.START, + RAW: BASETOKEN.RAW, + EOF: BASETOKEN.EOF +}; + + +var directives_core = new Directives(/\/\*/, /\*\//); + +var number_pattern = /0[xX][0123456789abcdefABCDEF_]*n?|0[oO][01234567_]*n?|0[bB][01_]*n?|\d[\d_]*n|(?:\.\d[\d_]*|\d[\d_]*\.?[\d_]*)(?:[eE][+-]?[\d_]+)?/; + +var digit = /[0-9]/; + +// Dot "." must be distinguished from "..." and decimal +var dot_pattern = /[^\d\.]/; + +var positionable_operators = ( + ">>> === !== &&= ??= ||= " + + "<< && >= ** != == <= >> || ?? |> " + + "< / - + > : & % ? ^ | *").split(' '); + +// IMPORTANT: this must be sorted longest to shortest or tokenizing many not work. +// Also, you must update possitionable operators separately from punct +var punct = + ">>>= " + + "... >>= <<= === >>> !== **= &&= ??= ||= " + + "=> ^= :: /= << <= == && -= >= >> != -- += ** || ?? ++ %= &= *= |= |> " + + "= ! ? > < : / ^ - + * & % ~ |"; + +punct = punct.replace(/[-[\]{}()*+?.,\\^$|#]/g, "\\$&"); +// ?. but not if followed by a number +punct = '\\?\\.(?!\\d) ' + punct; +punct = punct.replace(/ /g, '|'); + +var punct_pattern = new RegExp(punct); + +// words which should always start on new line. +var line_starters = 'continue,try,throw,return,var,let,const,if,switch,case,default,for,while,break,function,import,export'.split(','); +var reserved_words = line_starters.concat(['do', 'in', 'of', 'else', 'get', 'set', 'new', 'catch', 'finally', 'typeof', 'yield', 'async', 'await', 'from', 'as', 'class', 'extends']); +var reserved_word_pattern = new RegExp('^(?:' + reserved_words.join('|') + ')$'); + +// var template_pattern = /(?:(?:<\?php|<\?=)[\s\S]*?\?>)|(?:<%[\s\S]*?%>)/g; + +var in_html_comment; + +var Tokenizer = function(input_string, options) { + BaseTokenizer.call(this, input_string, options); + + this._patterns.whitespace = this._patterns.whitespace.matching( + /\u00A0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff/.source, + /\u2028\u2029/.source); + + var pattern_reader = new Pattern(this._input); + var templatable = new TemplatablePattern(this._input) + .read_options(this._options); + + this.__patterns = { + template: templatable, + identifier: templatable.starting_with(acorn.identifier).matching(acorn.identifierMatch), + number: pattern_reader.matching(number_pattern), + punct: pattern_reader.matching(punct_pattern), + // comment ends just before nearest linefeed or end of file + comment: pattern_reader.starting_with(/\/\//).until(/[\n\r\u2028\u2029]/), + // /* ... */ comment ends with nearest */ or end of file + block_comment: pattern_reader.starting_with(/\/\*/).until_after(/\*\//), + html_comment_start: pattern_reader.matching(//), + include: pattern_reader.starting_with(/#include/).until_after(acorn.lineBreak), + shebang: pattern_reader.starting_with(/#!/).until_after(acorn.lineBreak), + xml: pattern_reader.matching(/[\s\S]*?<(\/?)([-a-zA-Z:0-9_.]+|{[^}]+?}|!\[CDATA\[[^\]]*?\]\]|)(\s*{[^}]+?}|\s+[-a-zA-Z:0-9_.]+|\s+[-a-zA-Z:0-9_.]+\s*=\s*('[^']*'|"[^"]*"|{([^{}]|{[^}]+?})+?}))*\s*(\/?)\s*>/), + single_quote: templatable.until(/['\\\n\r\u2028\u2029]/), + double_quote: templatable.until(/["\\\n\r\u2028\u2029]/), + template_text: templatable.until(/[`\\$]/), + template_expression: templatable.until(/[`}\\]/) + }; + +}; +Tokenizer.prototype = new BaseTokenizer(); + +Tokenizer.prototype._is_comment = function(current_token) { + return current_token.type === TOKEN.COMMENT || current_token.type === TOKEN.BLOCK_COMMENT || current_token.type === TOKEN.UNKNOWN; +}; + +Tokenizer.prototype._is_opening = function(current_token) { + return current_token.type === TOKEN.START_BLOCK || current_token.type === TOKEN.START_EXPR; +}; + +Tokenizer.prototype._is_closing = function(current_token, open_token) { + return (current_token.type === TOKEN.END_BLOCK || current_token.type === TOKEN.END_EXPR) && + (open_token && ( + (current_token.text === ']' && open_token.text === '[') || + (current_token.text === ')' && open_token.text === '(') || + (current_token.text === '}' && open_token.text === '{'))); +}; + +Tokenizer.prototype._reset = function() { + in_html_comment = false; +}; + +Tokenizer.prototype._get_next_token = function(previous_token, open_token) { // jshint unused:false + var token = null; + this._readWhitespace(); + var c = this._input.peek(); + + if (c === null) { + return this._create_token(TOKEN.EOF, ''); + } + + token = token || this._read_non_javascript(c); + token = token || this._read_string(c); + token = token || this._read_pair(c, this._input.peek(1)); // Issue #2062 hack for record type '#{' + token = token || this._read_word(previous_token); + token = token || this._read_singles(c); + token = token || this._read_comment(c); + token = token || this._read_regexp(c, previous_token); + token = token || this._read_xml(c, previous_token); + token = token || this._read_punctuation(); + token = token || this._create_token(TOKEN.UNKNOWN, this._input.next()); + + return token; +}; + +Tokenizer.prototype._read_word = function(previous_token) { + var resulting_string; + resulting_string = this.__patterns.identifier.read(); + if (resulting_string !== '') { + resulting_string = resulting_string.replace(acorn.allLineBreaks, '\n'); + if (!(previous_token.type === TOKEN.DOT || + (previous_token.type === TOKEN.RESERVED && (previous_token.text === 'set' || previous_token.text === 'get'))) && + reserved_word_pattern.test(resulting_string)) { + if ((resulting_string === 'in' || resulting_string === 'of') && + (previous_token.type === TOKEN.WORD || previous_token.type === TOKEN.STRING)) { // hack for 'in' and 'of' operators + return this._create_token(TOKEN.OPERATOR, resulting_string); + } + return this._create_token(TOKEN.RESERVED, resulting_string); + } + return this._create_token(TOKEN.WORD, resulting_string); + } + + resulting_string = this.__patterns.number.read(); + if (resulting_string !== '') { + return this._create_token(TOKEN.WORD, resulting_string); + } +}; + +Tokenizer.prototype._read_singles = function(c) { + var token = null; + if (c === '(' || c === '[') { + token = this._create_token(TOKEN.START_EXPR, c); + } else if (c === ')' || c === ']') { + token = this._create_token(TOKEN.END_EXPR, c); + } else if (c === '{') { + token = this._create_token(TOKEN.START_BLOCK, c); + } else if (c === '}') { + token = this._create_token(TOKEN.END_BLOCK, c); + } else if (c === ';') { + token = this._create_token(TOKEN.SEMICOLON, c); + } else if (c === '.' && dot_pattern.test(this._input.peek(1))) { + token = this._create_token(TOKEN.DOT, c); + } else if (c === ',') { + token = this._create_token(TOKEN.COMMA, c); + } + + if (token) { + this._input.next(); + } + return token; +}; + +Tokenizer.prototype._read_pair = function(c, d) { + var token = null; + if (c === '#' && d === '{') { + token = this._create_token(TOKEN.START_BLOCK, c + d); + } + + if (token) { + this._input.next(); + this._input.next(); + } + return token; +}; + +Tokenizer.prototype._read_punctuation = function() { + var resulting_string = this.__patterns.punct.read(); + + if (resulting_string !== '') { + if (resulting_string === '=') { + return this._create_token(TOKEN.EQUALS, resulting_string); + } else if (resulting_string === '?.') { + return this._create_token(TOKEN.DOT, resulting_string); + } else { + return this._create_token(TOKEN.OPERATOR, resulting_string); + } + } +}; + +Tokenizer.prototype._read_non_javascript = function(c) { + var resulting_string = ''; + + if (c === '#') { + if (this._is_first_token()) { + resulting_string = this.__patterns.shebang.read(); + + if (resulting_string) { + return this._create_token(TOKEN.UNKNOWN, resulting_string.trim() + '\n'); + } + } + + // handles extendscript #includes + resulting_string = this.__patterns.include.read(); + + if (resulting_string) { + return this._create_token(TOKEN.UNKNOWN, resulting_string.trim() + '\n'); + } + + c = this._input.next(); + + // Spidermonkey-specific sharp variables for circular references. Considered obsolete. + var sharp = '#'; + if (this._input.hasNext() && this._input.testChar(digit)) { + do { + c = this._input.next(); + sharp += c; + } while (this._input.hasNext() && c !== '#' && c !== '='); + if (c === '#') { + // + } else if (this._input.peek() === '[' && this._input.peek(1) === ']') { + sharp += '[]'; + this._input.next(); + this._input.next(); + } else if (this._input.peek() === '{' && this._input.peek(1) === '}') { + sharp += '{}'; + this._input.next(); + this._input.next(); + } + return this._create_token(TOKEN.WORD, sharp); + } + + this._input.back(); + + } else if (c === '<' && this._is_first_token()) { + resulting_string = this.__patterns.html_comment_start.read(); + if (resulting_string) { + while (this._input.hasNext() && !this._input.testChar(acorn.newline)) { + resulting_string += this._input.next(); + } + in_html_comment = true; + return this._create_token(TOKEN.COMMENT, resulting_string); + } + } else if (in_html_comment && c === '-') { + resulting_string = this.__patterns.html_comment_end.read(); + if (resulting_string) { + in_html_comment = false; + return this._create_token(TOKEN.COMMENT, resulting_string); + } + } + + return null; +}; + +Tokenizer.prototype._read_comment = function(c) { + var token = null; + if (c === '/') { + var comment = ''; + if (this._input.peek(1) === '*') { + // peek for comment /* ... */ + comment = this.__patterns.block_comment.read(); + var directives = directives_core.get_directives(comment); + if (directives && directives.ignore === 'start') { + comment += directives_core.readIgnored(this._input); + } + comment = comment.replace(acorn.allLineBreaks, '\n'); + token = this._create_token(TOKEN.BLOCK_COMMENT, comment); + token.directives = directives; + } else if (this._input.peek(1) === '/') { + // peek for comment // ... + comment = this.__patterns.comment.read(); + token = this._create_token(TOKEN.COMMENT, comment); + } + } + return token; +}; + +Tokenizer.prototype._read_string = function(c) { + if (c === '`' || c === "'" || c === '"') { + var resulting_string = this._input.next(); + this.has_char_escapes = false; + + if (c === '`') { + resulting_string += this._read_string_recursive('`', true, '${'); + } else { + resulting_string += this._read_string_recursive(c); + } + + if (this.has_char_escapes && this._options.unescape_strings) { + resulting_string = unescape_string(resulting_string); + } + + if (this._input.peek() === c) { + resulting_string += this._input.next(); + } + + resulting_string = resulting_string.replace(acorn.allLineBreaks, '\n'); + + return this._create_token(TOKEN.STRING, resulting_string); + } + + return null; +}; + +Tokenizer.prototype._allow_regexp_or_xml = function(previous_token) { + // regex and xml can only appear in specific locations during parsing + return (previous_token.type === TOKEN.RESERVED && in_array(previous_token.text, ['return', 'case', 'throw', 'else', 'do', 'typeof', 'yield'])) || + (previous_token.type === TOKEN.END_EXPR && previous_token.text === ')' && + previous_token.opened.previous.type === TOKEN.RESERVED && in_array(previous_token.opened.previous.text, ['if', 'while', 'for'])) || + (in_array(previous_token.type, [TOKEN.COMMENT, TOKEN.START_EXPR, TOKEN.START_BLOCK, TOKEN.START, + TOKEN.END_BLOCK, TOKEN.OPERATOR, TOKEN.EQUALS, TOKEN.EOF, TOKEN.SEMICOLON, TOKEN.COMMA + ])); +}; + +Tokenizer.prototype._read_regexp = function(c, previous_token) { + + if (c === '/' && this._allow_regexp_or_xml(previous_token)) { + // handle regexp + // + var resulting_string = this._input.next(); + var esc = false; + + var in_char_class = false; + while (this._input.hasNext() && + ((esc || in_char_class || this._input.peek() !== c) && + !this._input.testChar(acorn.newline))) { + resulting_string += this._input.peek(); + if (!esc) { + esc = this._input.peek() === '\\'; + if (this._input.peek() === '[') { + in_char_class = true; + } else if (this._input.peek() === ']') { + in_char_class = false; + } + } else { + esc = false; + } + this._input.next(); + } + + if (this._input.peek() === c) { + resulting_string += this._input.next(); + + // regexps may have modifiers /regexp/MOD , so fetch those, too + // Only [gim] are valid, but if the user puts in garbage, do what we can to take it. + resulting_string += this._input.read(acorn.identifier); + } + return this._create_token(TOKEN.STRING, resulting_string); + } + return null; +}; + +Tokenizer.prototype._read_xml = function(c, previous_token) { + + if (this._options.e4x && c === "<" && this._allow_regexp_or_xml(previous_token)) { + var xmlStr = ''; + var match = this.__patterns.xml.read_match(); + // handle e4x xml literals + // + if (match) { + // Trim root tag to attempt to + var rootTag = match[2].replace(/^{\s+/, '{').replace(/\s+}$/, '}'); + var isCurlyRoot = rootTag.indexOf('{') === 0; + var depth = 0; + while (match) { + var isEndTag = !!match[1]; + var tagName = match[2]; + var isSingletonTag = (!!match[match.length - 1]) || (tagName.slice(0, 8) === "![CDATA["); + if (!isSingletonTag && + (tagName === rootTag || (isCurlyRoot && tagName.replace(/^{\s+/, '{').replace(/\s+}$/, '}')))) { + if (isEndTag) { + --depth; + } else { + ++depth; + } + } + xmlStr += match[0]; + if (depth <= 0) { + break; + } + match = this.__patterns.xml.read_match(); + } + // if we didn't close correctly, keep unformatted. + if (!match) { + xmlStr += this._input.match(/[\s\S]*/g)[0]; + } + xmlStr = xmlStr.replace(acorn.allLineBreaks, '\n'); + return this._create_token(TOKEN.STRING, xmlStr); + } + } + + return null; +}; + +function unescape_string(s) { + // You think that a regex would work for this + // return s.replace(/\\x([0-9a-f]{2})/gi, function(match, val) { + // return String.fromCharCode(parseInt(val, 16)); + // }) + // However, dealing with '\xff', '\\xff', '\\\xff' makes this more fun. + var out = '', + escaped = 0; + + var input_scan = new InputScanner(s); + var matched = null; + + while (input_scan.hasNext()) { + // Keep any whitespace, non-slash characters + // also keep slash pairs. + matched = input_scan.match(/([\s]|[^\\]|\\\\)+/g); + + if (matched) { + out += matched[0]; + } + + if (input_scan.peek() === '\\') { + input_scan.next(); + if (input_scan.peek() === 'x') { + matched = input_scan.match(/x([0-9A-Fa-f]{2})/g); + } else if (input_scan.peek() === 'u') { + matched = input_scan.match(/u([0-9A-Fa-f]{4})/g); + if (!matched) { + matched = input_scan.match(/u\{([0-9A-Fa-f]+)\}/g); + } + } else { + out += '\\'; + if (input_scan.hasNext()) { + out += input_scan.next(); + } + continue; + } + + // If there's some error decoding, return the original string + if (!matched) { + return s; + } + + escaped = parseInt(matched[1], 16); + + if (escaped > 0x7e && escaped <= 0xff && matched[0].indexOf('x') === 0) { + // we bail out on \x7f..\xff, + // leaving whole string escaped, + // as it's probably completely binary + return s; + } else if (escaped >= 0x00 && escaped < 0x20) { + // leave 0x00...0x1f escaped + out += '\\' + matched[0]; + } else if (escaped > 0x10FFFF) { + // If the escape sequence is out of bounds, keep the original sequence and continue conversion + out += '\\' + matched[0]; + } else if (escaped === 0x22 || escaped === 0x27 || escaped === 0x5c) { + // single-quote, apostrophe, backslash - escape these + out += '\\' + String.fromCharCode(escaped); + } else { + out += String.fromCharCode(escaped); + } + } + } + + return out; +} + +// handle string +// +Tokenizer.prototype._read_string_recursive = function(delimiter, allow_unescaped_newlines, start_sub) { + var current_char; + var pattern; + if (delimiter === '\'') { + pattern = this.__patterns.single_quote; + } else if (delimiter === '"') { + pattern = this.__patterns.double_quote; + } else if (delimiter === '`') { + pattern = this.__patterns.template_text; + } else if (delimiter === '}') { + pattern = this.__patterns.template_expression; + } + + var resulting_string = pattern.read(); + var next = ''; + while (this._input.hasNext()) { + next = this._input.next(); + if (next === delimiter || + (!allow_unescaped_newlines && acorn.newline.test(next))) { + this._input.back(); + break; + } else if (next === '\\' && this._input.hasNext()) { + current_char = this._input.peek(); + + if (current_char === 'x' || current_char === 'u') { + this.has_char_escapes = true; + } else if (current_char === '\r' && this._input.peek(1) === '\n') { + this._input.next(); + } + next += this._input.next(); + } else if (start_sub) { + if (start_sub === '${' && next === '$' && this._input.peek() === '{') { + next += this._input.next(); + } + + if (start_sub === next) { + if (delimiter === '`') { + next += this._read_string_recursive('}', allow_unescaped_newlines, '`'); + } else { + next += this._read_string_recursive('`', allow_unescaped_newlines, '${'); + } + if (this._input.hasNext()) { + next += this._input.next(); + } + } + } + next += pattern.read(); + resulting_string += next; + } + + return resulting_string; +}; + +module.exports.Tokenizer = Tokenizer; +module.exports.TOKEN = TOKEN; +module.exports.positionable_operators = positionable_operators.slice(); +module.exports.line_starters = line_starters.slice(); + + +/***/ }), +/* 8 */ +/***/ (function(module) { + +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + + + +var regexp_has_sticky = RegExp.prototype.hasOwnProperty('sticky'); + +function InputScanner(input_string) { + this.__input = input_string || ''; + this.__input_length = this.__input.length; + this.__position = 0; +} + +InputScanner.prototype.restart = function() { + this.__position = 0; +}; + +InputScanner.prototype.back = function() { + if (this.__position > 0) { + this.__position -= 1; + } +}; + +InputScanner.prototype.hasNext = function() { + return this.__position < this.__input_length; +}; + +InputScanner.prototype.next = function() { + var val = null; + if (this.hasNext()) { + val = this.__input.charAt(this.__position); + this.__position += 1; + } + return val; +}; + +InputScanner.prototype.peek = function(index) { + var val = null; + index = index || 0; + index += this.__position; + if (index >= 0 && index < this.__input_length) { + val = this.__input.charAt(index); + } + return val; +}; + +// This is a JavaScript only helper function (not in python) +// Javascript doesn't have a match method +// and not all implementation support "sticky" flag. +// If they do not support sticky then both this.match() and this.test() method +// must get the match and check the index of the match. +// If sticky is supported and set, this method will use it. +// Otherwise it will check that global is set, and fall back to the slower method. +InputScanner.prototype.__match = function(pattern, index) { + pattern.lastIndex = index; + var pattern_match = pattern.exec(this.__input); + + if (pattern_match && !(regexp_has_sticky && pattern.sticky)) { + if (pattern_match.index !== index) { + pattern_match = null; + } + } + + return pattern_match; +}; + +InputScanner.prototype.test = function(pattern, index) { + index = index || 0; + index += this.__position; + + if (index >= 0 && index < this.__input_length) { + return !!this.__match(pattern, index); + } else { + return false; + } +}; + +InputScanner.prototype.testChar = function(pattern, index) { + // test one character regex match + var val = this.peek(index); + pattern.lastIndex = 0; + return val !== null && pattern.test(val); +}; + +InputScanner.prototype.match = function(pattern) { + var pattern_match = this.__match(pattern, this.__position); + if (pattern_match) { + this.__position += pattern_match[0].length; + } else { + pattern_match = null; + } + return pattern_match; +}; + +InputScanner.prototype.read = function(starting_pattern, until_pattern, until_after) { + var val = ''; + var match; + if (starting_pattern) { + match = this.match(starting_pattern); + if (match) { + val += match[0]; + } + } + if (until_pattern && (match || !starting_pattern)) { + val += this.readUntil(until_pattern, until_after); + } + return val; +}; + +InputScanner.prototype.readUntil = function(pattern, until_after) { + var val = ''; + var match_index = this.__position; + pattern.lastIndex = this.__position; + var pattern_match = pattern.exec(this.__input); + if (pattern_match) { + match_index = pattern_match.index; + if (until_after) { + match_index += pattern_match[0].length; + } + } else { + match_index = this.__input_length; + } + + val = this.__input.substring(this.__position, match_index); + this.__position = match_index; + return val; +}; + +InputScanner.prototype.readUntilAfter = function(pattern) { + return this.readUntil(pattern, true); +}; + +InputScanner.prototype.get_regexp = function(pattern, match_from) { + var result = null; + var flags = 'g'; + if (match_from && regexp_has_sticky) { + flags = 'y'; + } + // strings are converted to regexp + if (typeof pattern === "string" && pattern !== '') { + // result = new RegExp(pattern.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), flags); + result = new RegExp(pattern, flags); + } else if (pattern) { + result = new RegExp(pattern.source, flags); + } + return result; +}; + +InputScanner.prototype.get_literal_regexp = function(literal_string) { + return RegExp(literal_string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&')); +}; + +/* css beautifier legacy helpers */ +InputScanner.prototype.peekUntilAfter = function(pattern) { + var start = this.__position; + var val = this.readUntilAfter(pattern); + this.__position = start; + return val; +}; + +InputScanner.prototype.lookBack = function(testVal) { + var start = this.__position - 1; + return start >= testVal.length && this.__input.substring(start - testVal.length, start) + .toLowerCase() === testVal; +}; + +module.exports.InputScanner = InputScanner; + + +/***/ }), +/* 9 */ +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + + + +var InputScanner = (__webpack_require__(8).InputScanner); +var Token = (__webpack_require__(3).Token); +var TokenStream = (__webpack_require__(10).TokenStream); +var WhitespacePattern = (__webpack_require__(11).WhitespacePattern); + +var TOKEN = { + START: 'TK_START', + RAW: 'TK_RAW', + EOF: 'TK_EOF' +}; + +var Tokenizer = function(input_string, options) { + this._input = new InputScanner(input_string); + this._options = options || {}; + this.__tokens = null; + + this._patterns = {}; + this._patterns.whitespace = new WhitespacePattern(this._input); +}; + +Tokenizer.prototype.tokenize = function() { + this._input.restart(); + this.__tokens = new TokenStream(); + + this._reset(); + + var current; + var previous = new Token(TOKEN.START, ''); + var open_token = null; + var open_stack = []; + var comments = new TokenStream(); + + while (previous.type !== TOKEN.EOF) { + current = this._get_next_token(previous, open_token); + while (this._is_comment(current)) { + comments.add(current); + current = this._get_next_token(previous, open_token); + } + + if (!comments.isEmpty()) { + current.comments_before = comments; + comments = new TokenStream(); + } + + current.parent = open_token; + + if (this._is_opening(current)) { + open_stack.push(open_token); + open_token = current; + } else if (open_token && this._is_closing(current, open_token)) { + current.opened = open_token; + open_token.closed = current; + open_token = open_stack.pop(); + current.parent = open_token; + } + + current.previous = previous; + previous.next = current; + + this.__tokens.add(current); + previous = current; + } + + return this.__tokens; +}; + + +Tokenizer.prototype._is_first_token = function() { + return this.__tokens.isEmpty(); +}; + +Tokenizer.prototype._reset = function() {}; + +Tokenizer.prototype._get_next_token = function(previous_token, open_token) { // jshint unused:false + this._readWhitespace(); + var resulting_string = this._input.read(/.+/g); + if (resulting_string) { + return this._create_token(TOKEN.RAW, resulting_string); + } else { + return this._create_token(TOKEN.EOF, ''); + } +}; + +Tokenizer.prototype._is_comment = function(current_token) { // jshint unused:false + return false; +}; + +Tokenizer.prototype._is_opening = function(current_token) { // jshint unused:false + return false; +}; + +Tokenizer.prototype._is_closing = function(current_token, open_token) { // jshint unused:false + return false; +}; + +Tokenizer.prototype._create_token = function(type, text) { + var token = new Token(type, text, + this._patterns.whitespace.newline_count, + this._patterns.whitespace.whitespace_before_token); + return token; +}; + +Tokenizer.prototype._readWhitespace = function() { + return this._patterns.whitespace.read(); +}; + + + +module.exports.Tokenizer = Tokenizer; +module.exports.TOKEN = TOKEN; + + +/***/ }), +/* 10 */ +/***/ (function(module) { + +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + + + +function TokenStream(parent_token) { + // private + this.__tokens = []; + this.__tokens_length = this.__tokens.length; + this.__position = 0; + this.__parent_token = parent_token; +} + +TokenStream.prototype.restart = function() { + this.__position = 0; +}; + +TokenStream.prototype.isEmpty = function() { + return this.__tokens_length === 0; +}; + +TokenStream.prototype.hasNext = function() { + return this.__position < this.__tokens_length; +}; + +TokenStream.prototype.next = function() { + var val = null; + if (this.hasNext()) { + val = this.__tokens[this.__position]; + this.__position += 1; + } + return val; +}; + +TokenStream.prototype.peek = function(index) { + var val = null; + index = index || 0; + index += this.__position; + if (index >= 0 && index < this.__tokens_length) { + val = this.__tokens[index]; + } + return val; +}; + +TokenStream.prototype.add = function(token) { + if (this.__parent_token) { + token.parent = this.__parent_token; + } + this.__tokens.push(token); + this.__tokens_length += 1; +}; + +module.exports.TokenStream = TokenStream; + + +/***/ }), +/* 11 */ +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + + + +var Pattern = (__webpack_require__(12).Pattern); + +function WhitespacePattern(input_scanner, parent) { + Pattern.call(this, input_scanner, parent); + if (parent) { + this._line_regexp = this._input.get_regexp(parent._line_regexp); + } else { + this.__set_whitespace_patterns('', ''); + } + + this.newline_count = 0; + this.whitespace_before_token = ''; +} +WhitespacePattern.prototype = new Pattern(); + +WhitespacePattern.prototype.__set_whitespace_patterns = function(whitespace_chars, newline_chars) { + whitespace_chars += '\\t '; + newline_chars += '\\n\\r'; + + this._match_pattern = this._input.get_regexp( + '[' + whitespace_chars + newline_chars + ']+', true); + this._newline_regexp = this._input.get_regexp( + '\\r\\n|[' + newline_chars + ']'); +}; + +WhitespacePattern.prototype.read = function() { + this.newline_count = 0; + this.whitespace_before_token = ''; + + var resulting_string = this._input.read(this._match_pattern); + if (resulting_string === ' ') { + this.whitespace_before_token = ' '; + } else if (resulting_string) { + var matches = this.__split(this._newline_regexp, resulting_string); + this.newline_count = matches.length - 1; + this.whitespace_before_token = matches[this.newline_count]; + } + + return resulting_string; +}; + +WhitespacePattern.prototype.matching = function(whitespace_chars, newline_chars) { + var result = this._create(); + result.__set_whitespace_patterns(whitespace_chars, newline_chars); + result._update(); + return result; +}; + +WhitespacePattern.prototype._create = function() { + return new WhitespacePattern(this._input, this); +}; + +WhitespacePattern.prototype.__split = function(regexp, input_string) { + regexp.lastIndex = 0; + var start_index = 0; + var result = []; + var next_match = regexp.exec(input_string); + while (next_match) { + result.push(input_string.substring(start_index, next_match.index)); + start_index = next_match.index + next_match[0].length; + next_match = regexp.exec(input_string); + } + + if (start_index < input_string.length) { + result.push(input_string.substring(start_index, input_string.length)); + } else { + result.push(''); + } + + return result; +}; + + + +module.exports.WhitespacePattern = WhitespacePattern; + + +/***/ }), +/* 12 */ +/***/ (function(module) { + +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + + + +function Pattern(input_scanner, parent) { + this._input = input_scanner; + this._starting_pattern = null; + this._match_pattern = null; + this._until_pattern = null; + this._until_after = false; + + if (parent) { + this._starting_pattern = this._input.get_regexp(parent._starting_pattern, true); + this._match_pattern = this._input.get_regexp(parent._match_pattern, true); + this._until_pattern = this._input.get_regexp(parent._until_pattern); + this._until_after = parent._until_after; + } +} + +Pattern.prototype.read = function() { + var result = this._input.read(this._starting_pattern); + if (!this._starting_pattern || result) { + result += this._input.read(this._match_pattern, this._until_pattern, this._until_after); + } + return result; +}; + +Pattern.prototype.read_match = function() { + return this._input.match(this._match_pattern); +}; + +Pattern.prototype.until_after = function(pattern) { + var result = this._create(); + result._until_after = true; + result._until_pattern = this._input.get_regexp(pattern); + result._update(); + return result; +}; + +Pattern.prototype.until = function(pattern) { + var result = this._create(); + result._until_after = false; + result._until_pattern = this._input.get_regexp(pattern); + result._update(); + return result; +}; + +Pattern.prototype.starting_with = function(pattern) { + var result = this._create(); + result._starting_pattern = this._input.get_regexp(pattern, true); + result._update(); + return result; +}; + +Pattern.prototype.matching = function(pattern) { + var result = this._create(); + result._match_pattern = this._input.get_regexp(pattern, true); + result._update(); + return result; +}; + +Pattern.prototype._create = function() { + return new Pattern(this._input, this); +}; + +Pattern.prototype._update = function() {}; + +module.exports.Pattern = Pattern; + + +/***/ }), +/* 13 */ +/***/ (function(module) { + +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + + + +function Directives(start_block_pattern, end_block_pattern) { + start_block_pattern = typeof start_block_pattern === 'string' ? start_block_pattern : start_block_pattern.source; + end_block_pattern = typeof end_block_pattern === 'string' ? end_block_pattern : end_block_pattern.source; + this.__directives_block_pattern = new RegExp(start_block_pattern + / beautify( \w+[:]\w+)+ /.source + end_block_pattern, 'g'); + this.__directive_pattern = / (\w+)[:](\w+)/g; + + this.__directives_end_ignore_pattern = new RegExp(start_block_pattern + /\sbeautify\signore:end\s/.source + end_block_pattern, 'g'); +} + +Directives.prototype.get_directives = function(text) { + if (!text.match(this.__directives_block_pattern)) { + return null; + } + + var directives = {}; + this.__directive_pattern.lastIndex = 0; + var directive_match = this.__directive_pattern.exec(text); + + while (directive_match) { + directives[directive_match[1]] = directive_match[2]; + directive_match = this.__directive_pattern.exec(text); + } + + return directives; +}; + +Directives.prototype.readIgnored = function(input) { + return input.readUntilAfter(this.__directives_end_ignore_pattern); +}; + + +module.exports.Directives = Directives; + + +/***/ }), +/* 14 */ +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + + + +var Pattern = (__webpack_require__(12).Pattern); + + +var template_names = { + django: false, + erb: false, + handlebars: false, + php: false, + smarty: false, + angular: false +}; + +// This lets templates appear anywhere we would do a readUntil +// The cost is higher but it is pay to play. +function TemplatablePattern(input_scanner, parent) { + Pattern.call(this, input_scanner, parent); + this.__template_pattern = null; + this._disabled = Object.assign({}, template_names); + this._excluded = Object.assign({}, template_names); + + if (parent) { + this.__template_pattern = this._input.get_regexp(parent.__template_pattern); + this._excluded = Object.assign(this._excluded, parent._excluded); + this._disabled = Object.assign(this._disabled, parent._disabled); + } + var pattern = new Pattern(input_scanner); + this.__patterns = { + handlebars_comment: pattern.starting_with(/{{!--/).until_after(/--}}/), + handlebars_unescaped: pattern.starting_with(/{{{/).until_after(/}}}/), + handlebars: pattern.starting_with(/{{/).until_after(/}}/), + php: pattern.starting_with(/<\?(?:[= ]|php)/).until_after(/\?>/), + erb: pattern.starting_with(/<%[^%]/).until_after(/[^%]%>/), + // django coflicts with handlebars a bit. + django: pattern.starting_with(/{%/).until_after(/%}/), + django_value: pattern.starting_with(/{{/).until_after(/}}/), + django_comment: pattern.starting_with(/{#/).until_after(/#}/), + smarty: pattern.starting_with(/{(?=[^}{\s\n])/).until_after(/[^\s\n]}/), + smarty_comment: pattern.starting_with(/{\*/).until_after(/\*}/), + smarty_literal: pattern.starting_with(/{literal}/).until_after(/{\/literal}/) + }; +} +TemplatablePattern.prototype = new Pattern(); + +TemplatablePattern.prototype._create = function() { + return new TemplatablePattern(this._input, this); +}; + +TemplatablePattern.prototype._update = function() { + this.__set_templated_pattern(); +}; + +TemplatablePattern.prototype.disable = function(language) { + var result = this._create(); + result._disabled[language] = true; + result._update(); + return result; +}; + +TemplatablePattern.prototype.read_options = function(options) { + var result = this._create(); + for (var language in template_names) { + result._disabled[language] = options.templating.indexOf(language) === -1; + } + result._update(); + return result; +}; + +TemplatablePattern.prototype.exclude = function(language) { + var result = this._create(); + result._excluded[language] = true; + result._update(); + return result; +}; + +TemplatablePattern.prototype.read = function() { + var result = ''; + if (this._match_pattern) { + result = this._input.read(this._starting_pattern); + } else { + result = this._input.read(this._starting_pattern, this.__template_pattern); + } + var next = this._read_template(); + while (next) { + if (this._match_pattern) { + next += this._input.read(this._match_pattern); + } else { + next += this._input.readUntil(this.__template_pattern); + } + result += next; + next = this._read_template(); + } + + if (this._until_after) { + result += this._input.readUntilAfter(this._until_pattern); + } + return result; +}; + +TemplatablePattern.prototype.__set_templated_pattern = function() { + var items = []; + + if (!this._disabled.php) { + items.push(this.__patterns.php._starting_pattern.source); + } + if (!this._disabled.handlebars) { + items.push(this.__patterns.handlebars._starting_pattern.source); + } + if (!this._disabled.angular) { + // Handlebars ('{{' and '}}') are also special tokens in Angular) + items.push(this.__patterns.handlebars._starting_pattern.source); + } + if (!this._disabled.erb) { + items.push(this.__patterns.erb._starting_pattern.source); + } + if (!this._disabled.django) { + items.push(this.__patterns.django._starting_pattern.source); + // The starting pattern for django is more complex because it has different + // patterns for value, comment, and other sections + items.push(this.__patterns.django_value._starting_pattern.source); + items.push(this.__patterns.django_comment._starting_pattern.source); + } + if (!this._disabled.smarty) { + items.push(this.__patterns.smarty._starting_pattern.source); + } + + if (this._until_pattern) { + items.push(this._until_pattern.source); + } + this.__template_pattern = this._input.get_regexp('(?:' + items.join('|') + ')'); +}; + +TemplatablePattern.prototype._read_template = function() { + var resulting_string = ''; + var c = this._input.peek(); + if (c === '<') { + var peek1 = this._input.peek(1); + //if we're in a comment, do something special + // We treat all comments as literals, even more than preformatted tags + // we just look for the appropriate close tag + if (!this._disabled.php && !this._excluded.php && peek1 === '?') { + resulting_string = resulting_string || + this.__patterns.php.read(); + } + if (!this._disabled.erb && !this._excluded.erb && peek1 === '%') { + resulting_string = resulting_string || + this.__patterns.erb.read(); + } + } else if (c === '{') { + if (!this._disabled.handlebars && !this._excluded.handlebars) { + resulting_string = resulting_string || + this.__patterns.handlebars_comment.read(); + resulting_string = resulting_string || + this.__patterns.handlebars_unescaped.read(); + resulting_string = resulting_string || + this.__patterns.handlebars.read(); + } + if (!this._disabled.django) { + // django coflicts with handlebars a bit. + if (!this._excluded.django && !this._excluded.handlebars) { + resulting_string = resulting_string || + this.__patterns.django_value.read(); + } + if (!this._excluded.django) { + resulting_string = resulting_string || + this.__patterns.django_comment.read(); + resulting_string = resulting_string || + this.__patterns.django.read(); + } + } + if (!this._disabled.smarty) { + // smarty cannot be enabled with django or handlebars enabled + if (this._disabled.django && this._disabled.handlebars) { + resulting_string = resulting_string || + this.__patterns.smarty_comment.read(); + resulting_string = resulting_string || + this.__patterns.smarty_literal.read(); + resulting_string = resulting_string || + this.__patterns.smarty.read(); + } + } + } + return resulting_string; +}; + + +module.exports.TemplatablePattern = TemplatablePattern; + + +/***/ }) +/******/ ]); +/************************************************************************/ +/******/ // The module cache +/******/ var __webpack_module_cache__ = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ // Check if module is in cache +/******/ var cachedModule = __webpack_module_cache__[moduleId]; +/******/ if (cachedModule !== undefined) { +/******/ return cachedModule.exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = __webpack_module_cache__[moduleId] = { +/******/ // no module.id needed +/******/ // no module.loaded needed +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/************************************************************************/ +/******/ +/******/ // startup +/******/ // Load entry module and return exports +/******/ // This entry module is referenced by other modules so it can't be inlined +/******/ var __webpack_exports__ = __webpack_require__(0); +/******/ legacy_beautify_js = __webpack_exports__; +/******/ +/******/ })() +; +var js_beautify = legacy_beautify_js; +/* Footer */ +if (typeof define === "function" && define.amd) { + // Add support for AMD ( https://github.com/amdjs/amdjs-api/wiki/AMD#defineamd-property- ) + define([], function() { + return { js_beautify: js_beautify }; + }); +} else if (typeof exports !== "undefined") { + // Add support for CommonJS. Just put this file somewhere on your require.paths + // and you will be able to `var js_beautify = require("beautify").js_beautify`. + exports.js_beautify = js_beautify; +} else if (typeof window !== "undefined") { + // If we're running a web page and don't have either of the above, add our one global + window.js_beautify = js_beautify; +} else if (typeof global !== "undefined") { + // If we don't even have window, try global. + global.js_beautify = js_beautify; +} + +}()); + diff --git a/server/src/com/mirth/connect/util/beautify-1.6.8.js b/server/src/com/mirth/connect/util/beautify-1.6.8.js deleted file mode 100644 index 7710fa38a8..0000000000 --- a/server/src/com/mirth/connect/util/beautify-1.6.8.js +++ /dev/null @@ -1,2481 +0,0 @@ -/*jshint curly:true, eqeqeq:true, laxbreak:true, noempty:false */ -/* - - The MIT License (MIT) - - Copyright (c) 2007-2017 Einar Lielmanis, Liam Newman, and contributors. - - Permission is hereby granted, free of charge, to any person - obtaining a copy of this software and associated documentation files - (the "Software"), to deal in the Software without restriction, - including without limitation the rights to use, copy, modify, merge, - publish, distribute, sublicense, and/or sell copies of the Software, - and to permit persons to whom the Software is furnished to do so, - subject to the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS - BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN - ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - SOFTWARE. - - JS Beautifier ---------------- - - - Written by Einar Lielmanis, - http://jsbeautifier.org/ - - Originally converted to javascript by Vital, - "End braces on own line" added by Chris J. Shull, - Parsing improvements for brace-less statements by Liam Newman - - - Usage: - js_beautify(js_source_text); - js_beautify(js_source_text, options); - - The options are: - indent_size (default 4) - indentation size, - indent_char (default space) - character to indent with, - preserve_newlines (default true) - whether existing line breaks should be preserved, - max_preserve_newlines (default unlimited) - maximum number of line breaks to be preserved in one chunk, - - jslint_happy (default false) - if true, then jslint-stricter mode is enforced. - - jslint_happy !jslint_happy - --------------------------------- - function () function() - - switch () { switch() { - case 1: case 1: - break; break; - } } - - space_after_anon_function (default false) - should the space before an anonymous function's parens be added, "function()" vs "function ()", - NOTE: This option is 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)", - - unescape_strings (default false) - should printable characters in strings encoded in \xNN notation be unescaped, "example" vs "\x65\x78\x61\x6d\x70\x6c\x65" - - wrap_line_length (default unlimited) - lines should wrap at next opportunity after this number of characters. - NOTE: This is not a hard limit. Lines will continue until a point where a newline would - be preserved if it were present. - - end_with_newline (default false) - end output with a newline - - - e.g - - js_beautify(js_source_text, { - 'indent_size': 1, - 'indent_char': '\t' - }); - -*/ - -// Object.values polyfill found here: -// http://tokenposts.blogspot.com.au/2012/04/javascript-objectkeys-browser.html -if (!Object.values) { - Object.values = function(o) { - if (o !== Object(o)) { - throw new TypeError('Object.values called on a non-object'); - } - var k = [], - p; - for (p in o) { - if (Object.prototype.hasOwnProperty.call(o, p)) { - k.push(o[p]); - } - } - return k; - }; -} - -(function() { - - function mergeOpts(allOptions, targetType) { - var finalOpts = {}; - var name; - - for (name in allOptions) { - if (name !== targetType) { - finalOpts[name] = allOptions[name]; - } - } - - //merge in the per type settings for the targetType - if (targetType in allOptions) { - for (name in allOptions[targetType]) { - finalOpts[name] = allOptions[targetType][name]; - } - } - return finalOpts; - } - - function js_beautify(js_source_text, options) { - - var acorn = {}; - (function(exports) { - /* jshint curly: false */ - // 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 - - // 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 nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/; // jshint ignore:line - 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 + "]"); - - // 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'); - - - // Test whether a given character code starts an identifier. - - exports.isIdentifierStart = function(code) { - // permit $ (36) and @ (64). @ is used in ES7 decorators. - if (code < 65) return code === 36 || code === 64; - // 65 through 91 are uppercase letters. - if (code < 91) return true; - // permit _ (95). - if (code < 97) return code === 95; - // 97 through 123 are lowercase letters. - if (code < 123) return true; - return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)); - }; - - // Test whether a given character is part of an identifier. - - exports.isIdentifierChar = function(code) { - if (code < 48) return code === 36; - if (code < 58) return true; - if (code < 65) return false; - if (code < 91) return true; - if (code < 97) return code === 95; - if (code < 123) return true; - return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)); - }; - })(acorn); - /* jshint curly: true */ - - function in_array(what, arr) { - for (var i = 0; i < arr.length; i += 1) { - if (arr[i] === what) { - return true; - } - } - return false; - } - - function trim(s) { - return s.replace(/^\s+|\s+$/g, ''); - } - - function ltrim(s) { - return s.replace(/^\s+/g, ''); - } - - // function rtrim(s) { - // return s.replace(/\s+$/g, ''); - // } - - function sanitizeOperatorPosition(opPosition) { - opPosition = opPosition || OPERATOR_POSITION.before_newline; - - var validPositionValues = Object.values(OPERATOR_POSITION); - - if (!in_array(opPosition, validPositionValues)) { - throw new Error("Invalid Option Value: The option 'operator_position' must be one of the following values\n" + - validPositionValues + - "\nYou passed in: '" + opPosition + "'"); - } - - return opPosition; - } - - var OPERATOR_POSITION = { - before_newline: 'before-newline', - after_newline: 'after-newline', - preserve_newline: 'preserve-newline', - }; - - 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 Beautifier(js_source_text, options) { - "use strict"; - var output; - var tokens = [], - token_pos; - var Tokenizer; - var current_token; - var last_type, last_last_text, indent_string; - var flags, previous_flags, flag_store; - var prefix; - - var handlers, opt; - var baseIndentString = ''; - - 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_RESERVED': 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_COMMENT': handle_comment, - 'TK_DOT': handle_dot, - 'TK_UNKNOWN': handle_unknown, - 'TK_EOF': handle_eof - }; - - function create_flags(flags_base, mode) { - var next_indent_level = 0; - if (flags_base) { - next_indent_level = flags_base.indentation_level; - if (!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_text: flags_base ? flags_base.last_text : '', // last token text - last_word: flags_base ? flags_base.last_word : '', // last 'TK_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, - line_indent_level: flags_base ? flags_base.line_indent_level : next_indent_level, - start_line_index: output.get_line_number(), - ternary_depth: 0 - }; - return next_flags; - } - - // Some interpreters have unexpected results with foo = baz || bar; - options = options ? options : {}; - - // Allow the setting of language/file-type specific options - // with inheritance of overall settings - options = mergeOpts(options, 'js'); - - opt = {}; - - // compatibility, re - if (options.brace_style === "expand-strict") { //graceful handling of deprecated option - options.brace_style = "expand"; - } else if (options.brace_style === "collapse-preserve-inline") { //graceful handling of deprecated option - options.brace_style = "collapse,preserve-inline"; - } else if (options.braces_on_own_line !== undefined) { //graceful handling of deprecated option - options.brace_style = options.braces_on_own_line ? "expand" : "collapse"; - } else if (!options.brace_style) //Nothing exists to set it - { - options.brace_style = "collapse"; - } - - - var brace_style_split = options.brace_style.split(/[^a-zA-Z0-9_\-]+/); - opt.brace_style = brace_style_split[0]; - opt.brace_preserve_inline = brace_style_split[1] ? brace_style_split[1] : false; - - opt.indent_size = options.indent_size ? parseInt(options.indent_size, 10) : 4; - opt.indent_char = options.indent_char ? options.indent_char : ' '; - opt.eol = options.eol ? options.eol : 'auto'; - 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.space_in_empty_paren = (options.space_in_empty_paren === undefined) ? false : options.space_in_empty_paren; - opt.jslint_happy = (options.jslint_happy === undefined) ? false : options.jslint_happy; - opt.space_after_anon_function = (options.space_after_anon_function === undefined) ? false : options.space_after_anon_function; - 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; - opt.end_with_newline = (options.end_with_newline === undefined) ? false : options.end_with_newline; - opt.comma_first = (options.comma_first === undefined) ? false : options.comma_first; - opt.operator_position = sanitizeOperatorPosition(options.operator_position); - - // For testing of beautify ignore:start directive - opt.test_output_raw = (options.test_output_raw === undefined) ? false : options.test_output_raw; - - // force opt.space_after_anon_function to true if opt.jslint_happy - if (opt.jslint_happy) { - opt.space_after_anon_function = true; - } - - if (options.indent_with_tabs) { - opt.indent_char = '\t'; - opt.indent_size = 1; - } - - if (opt.eol === 'auto') { - opt.eol = '\n'; - if (js_source_text && acorn.lineBreak.test(js_source_text || '')) { - opt.eol = js_source_text.match(acorn.lineBreak)[0]; - } - } - - opt.eol = opt.eol.replace(/\\r/, '\r').replace(/\\n/, '\n'); - - //---------------------------------- - indent_string = ''; - while (opt.indent_size > 0) { - indent_string += opt.indent_char; - opt.indent_size -= 1; - } - - var preindent_index = 0; - if (js_source_text && js_source_text.length) { - while ((js_source_text.charAt(preindent_index) === ' ' || - js_source_text.charAt(preindent_index) === '\t')) { - baseIndentString += js_source_text.charAt(preindent_index); - preindent_index += 1; - } - js_source_text = js_source_text.substring(preindent_index); - } - - last_type = 'TK_START_BLOCK'; // last token type - last_last_text = ''; // pre-last token text - output = new Output(indent_string, baseIndentString); - - // If testing the ignore directive, start with output disable set to true - output.raw = opt.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. - flag_store = []; - set_mode(MODE.BlockStatement); - - this.beautify = function() { - - /*jshint onevar:true */ - var sweet_code; - Tokenizer = new tokenizer(js_source_text, opt, indent_string); - tokens = Tokenizer.tokenize(); - token_pos = 0; - - current_token = get_token(); - while (current_token) { - handlers[current_token.type](); - - last_last_text = flags.last_text; - last_type = current_token.type; - flags.last_text = current_token.text; - - token_pos += 1; - current_token = get_token(); - } - - sweet_code = output.get_code(); - if (opt.end_with_newline) { - sweet_code += '\n'; - } - - if (opt.eol !== '\n') { - sweet_code = sweet_code.replace(/[\n]/g, opt.eol); - } - - return sweet_code; - }; - - function handle_whitespace_and_comments(local_token, preserve_statement_flags) { - var newlines = local_token.newlines; - var keep_whitespace = opt.keep_array_indentation && is_array(flags.mode); - var temp_token = current_token; - - for (var h = 0; h < local_token.comments_before.length; h++) { - // 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. - current_token = local_token.comments_before[h]; - handle_whitespace_and_comments(current_token, preserve_statement_flags); - handlers[current_token.type](preserve_statement_flags); - } - current_token = temp_token; - - if (keep_whitespace) { - for (var i = 0; i < newlines; i += 1) { - print_newline(i > 0, preserve_statement_flags); - } - } else { - if (opt.max_preserve_newlines && newlines > opt.max_preserve_newlines) { - newlines = opt.max_preserve_newlines; - } - - if (opt.preserve_newlines) { - if (local_token.newlines > 1) { - print_newline(false, preserve_statement_flags); - for (var j = 1; j < newlines; j += 1) { - print_newline(true, preserve_statement_flags); - } - } - } - } - - } - - // 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; - } - - var newline_restricted_tokens = ['break', 'continue', 'return', 'throw']; - - function allow_wrap_or_preserved_newline(force_linewrap) { - force_linewrap = (force_linewrap === undefined) ? false : force_linewrap; - - // Never wrap the first token on a line - if (output.just_added_newline()) { - return; - } - - var shouldPreserveOrForce = (opt.preserve_newlines && current_token.wanted_newline) || force_linewrap; - var operatorLogicApplies = in_array(flags.last_text, Tokenizer.positionable_operators) || in_array(current_token.text, Tokenizer.positionable_operators); - - if (operatorLogicApplies) { - var shouldPrintOperatorNewline = ( - in_array(flags.last_text, Tokenizer.positionable_operators) && - in_array(opt.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE) - ) || - in_array(current_token.text, Tokenizer.positionable_operators); - shouldPreserveOrForce = shouldPreserveOrForce && shouldPrintOperatorNewline; - } - - if (shouldPreserveOrForce) { - print_newline(false, true); - } else if (opt.wrap_line_length) { - if (last_type === 'TK_RESERVED' && in_array(flags.last_text, newline_restricted_tokens)) { - // These tokens should never have a newline inserted - // between them and the following expression. - return; - } - var proposed_line_length = output.current_line.get_character_count() + current_token.text.length + - (output.space_before_token ? 1 : 0); - if (proposed_line_length >= opt.wrap_line_length) { - print_newline(false, true); - } - } - } - - function print_newline(force_newline, preserve_statement_flags) { - if (!preserve_statement_flags) { - if (flags.last_text !== ';' && flags.last_text !== ',' && flags.last_text !== '=' && last_type !== 'TK_OPERATOR') { - var next_token = get_token(1); - while (flags.mode === MODE.Statement && - !(flags.if_block && next_token && next_token.type === 'TK_RESERVED' && next_token.text === 'else') && - !flags.do_block) { - restore_mode(); - } - } - } - - if (output.add_new_line(force_newline)) { - flags.multiline_frame = true; - } - } - - function print_token_line_indentation() { - if (output.just_added_newline()) { - if (opt.keep_array_indentation && is_array(flags.mode) && current_token.wanted_newline) { - output.current_line.push(current_token.whitespace_before); - output.space_before_token = false; - } else if (output.set_indent(flags.indentation_level)) { - flags.line_indent_level = flags.indentation_level; - } - } - } - - function print_token(printable_token) { - if (output.raw) { - output.add_raw_token(current_token); - return; - } - - if (opt.comma_first && last_type === 'TK_COMMA' && - output.just_added_newline()) { - if (output.previous_line.last() === ',') { - var popped = 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 (output.previous_line.is_empty()) { - output.previous_line.push(popped); - output.trim(true); - output.current_line.pop(); - output.trim(); - } - - // add the comma in front of the next token - print_token_line_indentation(); - output.add_token(','); - output.space_before_token = true; - } - } - - printable_token = printable_token || current_token.text; - print_token_line_indentation(); - output.add_token(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 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(); - if (previous_flags.mode === MODE.Statement) { - output.remove_redundant_indentation(previous_flags); - } - } - } - - function start_of_object_property() { - return flags.parent.mode === MODE.ObjectLiteral && flags.mode === MODE.Statement && ( - (flags.last_text === ':' && flags.ternary_depth === 0) || (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['get', 'set']))); - } - - function start_of_statement() { - if ( - (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['var', 'let', 'const']) && current_token.type === 'TK_WORD') || - (last_type === 'TK_RESERVED' && flags.last_text === 'do') || - (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['return', 'throw']) && !current_token.wanted_newline) || - (last_type === 'TK_RESERVED' && flags.last_text === 'else' && - !(current_token.type === 'TK_RESERVED' && current_token.text === 'if' && !current_token.comments_before.length)) || - (last_type === 'TK_END_EXPR' && (previous_flags.mode === MODE.ForInitializer || previous_flags.mode === MODE.Conditional)) || - (last_type === 'TK_WORD' && flags.mode === MODE.BlockStatement && - !flags.in_case && - !(current_token.text === '--' || current_token.text === '++') && - last_last_text !== 'function' && - current_token.type !== 'TK_WORD' && current_token.type !== 'TK_RESERVED') || - (flags.mode === MODE.ObjectLiteral && ( - (flags.last_text === ':' && flags.ternary_depth === 0) || (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['get', 'set'])))) - ) { - - set_mode(MODE.Statement); - indent(); - - 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 (!start_of_object_property()) { - allow_wrap_or_preserved_newline( - current_token.type === 'TK_RESERVED' && in_array(current_token.text, ['do', 'for', 'if', 'while'])); - } - - 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 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 is_special_word(word) { - return in_array(word, ['case', 'return', 'do', 'if', 'throw', 'else']); - } - - function get_token(offset) { - var index = token_pos + (offset || 0); - return (index < 0 || index >= tokens.length) ? null : tokens[index]; - } - - function handle_start_expr() { - // The conditional starts the statement if appropriate. - if (!start_of_statement()) { - handle_whitespace_and_comments(current_token); - } - - var next_mode = MODE.Expression; - if (current_token.text === '[') { - - if (last_type === 'TK_WORD' || flags.last_text === ')') { - // this is array index specifier, break immediately - // a[x], fn()[x] - if (last_type === 'TK_RESERVED' && in_array(flags.last_text, Tokenizer.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 (last_type === 'TK_RESERVED' && flags.last_text === 'for') { - next_mode = MODE.ForInitializer; - } else if (last_type === 'TK_RESERVED' && 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(current_token.wanted_newline); - // do nothing on (( and )( and ][ and ]( and .( - } else if (!(last_type === 'TK_RESERVED' && current_token.text === '(') && last_type !== 'TK_WORD' && last_type !== 'TK_OPERATOR') { - output.space_before_token = true; - } else if ((last_type === 'TK_RESERVED' && (flags.last_word === 'function' || flags.last_word === 'typeof')) || - (flags.last_text === '*' && - (in_array(last_last_text, ['function', 'yield']) || - (flags.mode === MODE.ObjectLiteral && in_array(last_last_text, ['{', ',']))))) { - // function() vs function () - // yield*() vs yield* () - // function*() vs function* () - if (opt.space_after_anon_function) { - output.space_before_token = true; - } - } else if (last_type === 'TK_RESERVED' && (in_array(flags.last_text, Tokenizer.line_starters) || flags.last_text === 'catch')) { - if (opt.space_before_conditional) { - output.space_before_token = true; - } - } - - // Should be a space between await and an IIFE - if (current_token.text === '(' && last_type === 'TK_RESERVED' && flags.last_word === 'await') { - output.space_before_token = true; - } - - // Support of this kind of newline preservation. - // a = (b && - // (c || d)); - if (current_token.text === '(') { - if (last_type === 'TK_EQUALS' || last_type === 'TK_OPERATOR') { - if (!start_of_object_property()) { - allow_wrap_or_preserved_newline(); - } - } - } - - // Support preserving wrapped arrow function expressions - // a.b('c', - // () => d.e - // ) - if (current_token.text === '(' && last_type !== 'TK_WORD' && last_type !== 'TK_RESERVED') { - 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(); - } - - handle_whitespace_and_comments(current_token); - - if (flags.multiline_frame) { - allow_wrap_or_preserved_newline(current_token.text === ']' && is_array(flags.mode) && !opt.keep_array_indentation); - } - - if (opt.space_in_paren) { - if (last_type === 'TK_START_EXPR' && !opt.space_in_empty_paren) { - // () [] no inner space in empty parens like these, ever, ref #320 - output.trim(); - output.space_before_token = false; - } else { - output.space_before_token = true; - } - } - if (current_token.text === ']' && opt.keep_array_indentation) { - print_token(); - restore_mode(); - } else { - restore_mode(); - print_token(); - } - output.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() { - handle_whitespace_and_comments(current_token); - - // Check if this is should be treated as a ObjectLiteral - var next_token = get_token(1); - var second_token = get_token(2); - if (second_token && ( - (in_array(second_token.text, [':', ',']) && in_array(next_token.type, ['TK_STRING', 'TK_WORD', 'TK_RESERVED'])) || - (in_array(next_token.text, ['get', 'set', '...']) && in_array(second_token.type, ['TK_WORD', 'TK_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(last_last_text, ['class', 'interface'])) { - set_mode(MODE.ObjectLiteral); - } else { - set_mode(MODE.BlockStatement); - } - } else if (last_type === 'TK_OPERATOR' && flags.last_text === '=>') { - // arrow function: (param1, paramN) => { statements } - set_mode(MODE.BlockStatement); - } else if (in_array(last_type, ['TK_EQUALS', 'TK_START_EXPR', 'TK_COMMA', 'TK_OPERATOR']) || - (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['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. - set_mode(MODE.ObjectLiteral); - } else { - set_mode(MODE.BlockStatement); - } - - var empty_braces = !next_token.comments_before.length && next_token.text === '}'; - var empty_anonymous_function = empty_braces && flags.last_word === 'function' && - last_type === 'TK_END_EXPR'; - - if (opt.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; - flags.inline_frame = true; - do { - index += 1; - check_token = get_token(index); - if (check_token.wanted_newline) { - flags.inline_frame = false; - break; - } - } while (check_token.type !== 'TK_EOF' && - !(check_token.type === 'TK_END_BLOCK' && check_token.opened === current_token)); - } - - if ((opt.brace_style === "expand" || - (opt.brace_style === "none" && current_token.wanted_newline)) && - !flags.inline_frame) { - if (last_type !== 'TK_OPERATOR' && - (empty_anonymous_function || - last_type === 'TK_EQUALS' || - (last_type === 'TK_RESERVED' && is_special_word(flags.last_text) && flags.last_text !== 'else'))) { - output.space_before_token = true; - } else { - print_newline(false, true); - } - } else { // collapse || inline_frame - if (is_array(previous_flags.mode) && (last_type === 'TK_START_EXPR' || last_type === 'TK_COMMA')) { - if (last_type === 'TK_COMMA' || opt.space_in_paren) { - output.space_before_token = true; - } - - if (last_type === 'TK_COMMA' || (last_type === 'TK_START_EXPR' && flags.inline_frame)) { - allow_wrap_or_preserved_newline(); - previous_flags.multiline_frame = previous_flags.multiline_frame || flags.multiline_frame; - flags.multiline_frame = false; - } - } - if (last_type !== 'TK_OPERATOR' && last_type !== 'TK_START_EXPR') { - if (last_type === 'TK_START_BLOCK' && !flags.inline_frame) { - print_newline(); - } else { - output.space_before_token = true; - } - } - } - print_token(); - indent(); - } - - function handle_end_block() { - // statements must all be closed when their container closes - handle_whitespace_and_comments(current_token); - - while (flags.mode === MODE.Statement) { - restore_mode(); - } - - var empty_braces = last_type === 'TK_START_BLOCK'; - - if (flags.inline_frame && !empty_braces) { // try inline_frame (only set if opt.braces-preserve-inline) first - output.space_before_token = true; - } else 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 (current_token.type === 'TK_RESERVED') { - if (in_array(current_token.text, ['set', 'get']) && flags.mode !== MODE.ObjectLiteral) { - current_token.type = 'TK_WORD'; - } else if (in_array(current_token.text, ['as', 'from']) && !flags.import_block) { - current_token.type = 'TK_WORD'; - } else if (flags.mode === MODE.ObjectLiteral) { - var next_token = get_token(1); - if (next_token.text === ':') { - current_token.type = 'TK_WORD'; - } - } - } - - if (start_of_statement()) { - // The conditional starts the statement if appropriate. - if (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['var', 'let', 'const']) && current_token.type === 'TK_WORD') { - flags.declaration_statement = true; - } - } else if (current_token.wanted_newline && !is_expression(flags.mode) && - (last_type !== 'TK_OPERATOR' || (flags.last_text === '--' || flags.last_text === '++')) && - last_type !== 'TK_EQUALS' && - (opt.preserve_newlines || !(last_type === 'TK_RESERVED' && in_array(flags.last_text, ['var', 'let', 'const', 'set', 'get'])))) { - handle_whitespace_and_comments(current_token); - print_newline(); - } else { - handle_whitespace_and_comments(current_token); - } - - if (flags.do_block && !flags.do_while) { - if (current_token.type === 'TK_RESERVED' && current_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 (!flags.else_block && (current_token.type === 'TK_RESERVED' && current_token.text === 'else')) { - flags.else_block = true; - } else { - while (flags.mode === MODE.Statement) { - restore_mode(); - } - flags.if_block = false; - flags.else_block = false; - } - } - - if (current_token.type === 'TK_RESERVED' && (current_token.text === 'case' || (current_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 (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 (current_token.type === 'TK_RESERVED' && current_token.text === 'function') { - if (in_array(flags.last_text, ['}', ';']) || - (output.just_added_newline() && !(in_array(flags.last_text, ['(', '[', '{', ':', '=', ',']) || last_type === 'TK_OPERATOR'))) { - // make sure there is a nice clean space of at least one blank line - // before a new function definition - if (!output.just_added_blankline() && !current_token.comments_before.length) { - print_newline(); - print_newline(true); - } - } - if (last_type === 'TK_RESERVED' || last_type === 'TK_WORD') { - if (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['get', 'set', 'new', 'return', 'export', 'async'])) { - output.space_before_token = true; - } else if (last_type === 'TK_RESERVED' && flags.last_text === 'default' && last_last_text === 'export') { - 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 (!flags.multiline_frame && (is_expression(flags.mode) || is_array(flags.mode))) { - // (function - } else { - print_newline(); - } - - print_token(); - flags.last_word = current_token.text; - return; - } - - prefix = 'NONE'; - - if (last_type === 'TK_END_BLOCK') { - - if (previous_flags.inline_frame) { - prefix = 'SPACE'; - } else if (!(current_token.type === 'TK_RESERVED' && in_array(current_token.text, ['else', 'catch', 'finally', 'from']))) { - prefix = 'NEWLINE'; - } else { - if (opt.brace_style === "expand" || - opt.brace_style === "end-expand" || - (opt.brace_style === "none" && current_token.wanted_newline)) { - 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_RESERVED' || last_type === 'TK_WORD' || - (flags.last_text === '*' && - (in_array(last_last_text, ['function', 'yield']) || - (flags.mode === MODE.ObjectLiteral && in_array(last_last_text, ['{', ',']))))) { - prefix = 'SPACE'; - } else if (last_type === 'TK_START_BLOCK') { - if (flags.inline_frame) { - prefix = 'SPACE'; - } else { - prefix = 'NEWLINE'; - } - } else if (last_type === 'TK_END_EXPR') { - output.space_before_token = true; - prefix = 'NEWLINE'; - } - - if (current_token.type === 'TK_RESERVED' && in_array(current_token.text, Tokenizer.line_starters) && flags.last_text !== ')') { - if (flags.inline_frame || flags.last_text === 'else' || flags.last_text === 'export') { - prefix = 'SPACE'; - } else { - prefix = 'NEWLINE'; - } - - } - - if (current_token.type === 'TK_RESERVED' && in_array(current_token.text, ['else', 'catch', 'finally'])) { - if ((!(last_type === 'TK_END_BLOCK' && previous_flags.mode === MODE.BlockStatement) || - opt.brace_style === "expand" || - opt.brace_style === "end-expand" || - (opt.brace_style === "none" && current_token.wanted_newline)) && - !flags.inline_frame) { - print_newline(); - } else { - output.trim(true); - var line = 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() !== '}') { - print_newline(); - } - output.space_before_token = true; - } - } else if (prefix === 'NEWLINE') { - if (last_type === 'TK_RESERVED' && 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' || !(current_token.type === 'TK_RESERVED' && in_array(current_token.text, ['var', 'let', 'const']))) && flags.last_text !== ':') { - // no need to force newline on 'var': for (var x = 0...) - if (current_token.type === 'TK_RESERVED' && current_token.text === 'if' && flags.last_text === 'else') { - // no newline for } else if { - output.space_before_token = true; - } else { - print_newline(); - } - } - } else if (current_token.type === 'TK_RESERVED' && in_array(current_token.text, Tokenizer.line_starters) && flags.last_text !== ')') { - print_newline(); - } - } else if (flags.multiline_frame && 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 = current_token.text; - - if (current_token.type === 'TK_RESERVED') { - if (current_token.text === 'do') { - flags.do_block = true; - } else if (current_token.text === 'if') { - flags.if_block = true; - } else if (current_token.text === 'import') { - flags.import_block = true; - } else if (flags.import_block && current_token.type === 'TK_RESERVED' && current_token.text === 'from') { - flags.import_block = false; - } - } - } - - 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; - } else { - handle_whitespace_and_comments(current_token); - } - - var next_token = get_token(1); - while (flags.mode === MODE.Statement && - !(flags.if_block && next_token && next_token.type === 'TK_RESERVED' && next_token.text === 'else') && - !flags.do_block) { - restore_mode(); - } - - // hacky but effective for the moment - if (flags.import_block) { - flags.import_block = false; - } - print_token(); - } - - 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 { - handle_whitespace_and_comments(current_token); - if (last_type === 'TK_RESERVED' || last_type === 'TK_WORD' || flags.inline_frame) { - 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 (start_of_statement()) { - // The conditional starts the statement if appropriate. - } else { - handle_whitespace_and_comments(current_token); - } - - if (flags.declaration_statement) { - // just got an '=' in a var-line, different formatting/line-breaking, etc will now be done - flags.declaration_assignment = true; - } - output.space_before_token = true; - print_token(); - output.space_before_token = true; - } - - function handle_comma() { - handle_whitespace_and_comments(current_token, true); - - print_token(); - output.space_before_token = true; - if (flags.declaration_statement) { - if (is_expression(flags.parent.mode)) { - // do not break on comma, for(var a = 1, b = 2) - flags.declaration_assignment = false; - } - - if (flags.declaration_assignment) { - flags.declaration_assignment = false; - print_newline(false, true); - } else if (opt.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 - allow_wrap_or_preserved_newline(); - } - } else if (flags.mode === MODE.ObjectLiteral || - (flags.mode === MODE.Statement && flags.parent.mode === MODE.ObjectLiteral)) { - if (flags.mode === MODE.Statement) { - restore_mode(); - } - - if (!flags.inline_frame) { - print_newline(); - } - } else if (opt.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 - allow_wrap_or_preserved_newline(); - } - } - - function handle_operator() { - var isGeneratorAsterisk = current_token.text === '*' && - ((last_type === 'TK_RESERVED' && in_array(flags.last_text, ['function', 'yield'])) || - (in_array(last_type, ['TK_START_BLOCK', 'TK_COMMA', 'TK_END_BLOCK', 'TK_SEMICOLON'])) - ); - var isUnary = in_array(current_token.text, ['-', '+']) && ( - in_array(last_type, ['TK_START_BLOCK', 'TK_START_EXPR', 'TK_EQUALS', 'TK_OPERATOR']) || - in_array(flags.last_text, Tokenizer.line_starters) || - flags.last_text === ',' - ); - - if (start_of_statement()) { - // The conditional starts the statement if appropriate. - } else { - var preserve_statement_flags = !isGeneratorAsterisk; - handle_whitespace_and_comments(current_token, preserve_statement_flags); - } - - if (last_type === 'TK_RESERVED' && 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 (current_token.text === '*' && last_type === 'TK_DOT') { - print_token(); - return; - } - - if (current_token.text === '::') { - // no spaces around exotic namespacing syntax operator - print_token(); - return; - } - - // Allow line wrapping between operators when operator_position is - // set to before or preserve - if (last_type === 'TK_OPERATOR' && in_array(opt.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)) { - allow_wrap_or_preserved_newline(); - } - - if (current_token.text === ':' && flags.in_case) { - flags.case_body = true; - indent(); - print_token(); - print_newline(); - flags.in_case = false; - return; - } - - var space_before = true; - var space_after = true; - var in_ternary = false; - if (current_token.text === ':') { - if (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 { - flags.ternary_depth -= 1; - in_ternary = true; - } - } else if (current_token.text === '?') { - flags.ternary_depth += 1; - } - - // let's handle the operator_position option prior to any conflicting logic - if (!isUnary && !isGeneratorAsterisk && opt.preserve_newlines && in_array(current_token.text, Tokenizer.positionable_operators)) { - var isColon = current_token.text === ':'; - var isTernaryColon = (isColon && in_ternary); - var isOtherColon = (isColon && !in_ternary); - - switch (opt.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 - output.space_before_token = !isOtherColon; - - print_token(); - - if (!isColon || isTernaryColon) { - allow_wrap_or_preserved_newline(); - } - - output.space_before_token = true; - return; - - case OPERATOR_POSITION.after_newline: - // if the current token is anything but colon, or (via deduction) it's a colon and in a ternary statement, - // then print a newline. - - output.space_before_token = true; - - if (!isColon || isTernaryColon) { - if (get_token(1).wanted_newline) { - print_newline(false, true); - } else { - allow_wrap_or_preserved_newline(); - } - } else { - output.space_before_token = false; - } - - print_token(); - - output.space_before_token = true; - return; - - case OPERATOR_POSITION.preserve_newline: - if (!isOtherColon) { - allow_wrap_or_preserved_newline(); - } - - // 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 = !(output.just_added_newline() || isOtherColon); - - output.space_before_token = space_before; - print_token(); - output.space_before_token = true; - return; - } - } - - if (isGeneratorAsterisk) { - allow_wrap_or_preserved_newline(); - space_before = false; - var next_token = get_token(1); - space_after = next_token && in_array(next_token.type, ['TK_WORD', 'TK_RESERVED']); - } else if (current_token.text === '...') { - allow_wrap_or_preserved_newline(); - space_before = last_type === 'TK_START_BLOCK'; - space_after = false; - } else if (in_array(current_token.text, ['--', '++', '!', '~']) || isUnary) { - // unary operators (and binary +/- pretending to be unary) special cases - - space_before = false; - space_after = false; - - // http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1 - // if there is a newline between -- or ++ and anything else we should preserve it. - if (current_token.wanted_newline && (current_token.text === '--' || current_token.text === '++')) { - print_newline(false, true); - } - - if (flags.last_text === ';' && is_expression(flags.mode)) { - // for (;; ++i) - // ^^^ - space_before = true; - } - - if (last_type === 'TK_RESERVED') { - space_before = true; - } else if (last_type === 'TK_END_EXPR') { - space_before = !(flags.last_text === ']' && (current_token.text === '--' || current_token.text === '++')); - } else if (last_type === 'TK_OPERATOR') { - // a++ + ++b; - // a - -b - space_before = in_array(current_token.text, ['--', '-', '++', '+']) && in_array(flags.last_text, ['--', '-', '++', '+']); - // + and - are not unary when preceeded by -- or ++ operator - // a-- + b - // a * +b - // a - -b - if (in_array(current_token.text, ['+', '-']) && in_array(flags.last_text, ['--', '++'])) { - space_after = true; - } - } - - - if (((flags.mode === MODE.BlockStatement && !flags.inline_frame) || flags.mode === MODE.Statement) && - (flags.last_text === '{' || flags.last_text === ';')) { - // { foo; --i } - // foo(); --bar; - print_newline(); - } - } - - output.space_before_token = output.space_before_token || space_before; - print_token(); - output.space_before_token = space_after; - } - - function handle_block_comment(preserve_statement_flags) { - if (output.raw) { - 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. - output.raw = opt.test_output_raw; - } - return; - } - - if (current_token.directives) { - print_newline(false, preserve_statement_flags); - print_token(); - if (current_token.directives.preserve === 'start') { - output.raw = true; - } - print_newline(false, true); - return; - } - - // inline block - if (!acorn.newline.test(current_token.text) && !current_token.wanted_newline) { - output.space_before_token = true; - print_token(); - output.space_before_token = true; - return; - } - - 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 - print_newline(false, preserve_statement_flags); - if (lines.length > 1) { - javadoc = all_lines_start_with(lines.slice(1), '*'); - starless = each_line_matches_indent(lines.slice(1), lastIndent); - } - - // 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(' ' + ltrim(lines[j])); - } else if (starless && lines[j].length > lastIndentLength) { - // starless: re-indent non-empty content, avoiding trim - print_token(lines[j].substring(lastIndentLength)); - } else { - // normal comments output raw - output.add_token(lines[j]); - } - } - - // for comments of more than one line, make sure there's a new line after - print_newline(false, preserve_statement_flags); - } - - function handle_comment(preserve_statement_flags) { - if (current_token.wanted_newline) { - print_newline(false, preserve_statement_flags); - } else { - output.trim(true); - } - - output.space_before_token = true; - print_token(); - print_newline(false, preserve_statement_flags); - } - - function handle_dot() { - if (start_of_statement()) { - // The conditional starts the statement if appropriate. - } else { - handle_whitespace_and_comments(current_token, true); - } - - if (last_type === 'TK_RESERVED' && 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(preserve_statement_flags) { - print_token(); - - if (current_token.text[current_token.text.length - 1] === '\n') { - print_newline(false, preserve_statement_flags); - } - } - - function handle_eof() { - // Unwind any open statements - while (flags.mode === MODE.Statement) { - restore_mode(); - } - handle_whitespace_and_comments(current_token); - } - } - - - function OutputLine(parent) { - var _character_count = 0; - // use indent_count as a marker for lines that have preserved indentation - var _indent_count = -1; - - var _items = []; - var _empty = true; - - this.set_indent = function(level) { - _character_count = parent.baseIndentLength + level * parent.indent_length; - _indent_count = level; - }; - - this.get_character_count = function() { - return _character_count; - }; - - this.is_empty = function() { - return _empty; - }; - - this.last = function() { - if (!this._empty) { - return _items[_items.length - 1]; - } else { - return null; - } - }; - - this.push = function(input) { - _items.push(input); - _character_count += input.length; - _empty = false; - }; - - this.pop = function() { - var item = null; - if (!_empty) { - item = _items.pop(); - _character_count -= item.length; - _empty = _items.length === 0; - } - return item; - }; - - this.remove_indent = function() { - if (_indent_count > 0) { - _indent_count -= 1; - _character_count -= parent.indent_length; - } - }; - - this.trim = function() { - while (this.last() === ' ') { - _items.pop(); - _character_count -= 1; - } - _empty = _items.length === 0; - }; - - this.toString = function() { - var result = ''; - if (!this._empty) { - if (_indent_count >= 0) { - result = parent.indent_cache[_indent_count]; - } - result += _items.join(''); - } - return result; - }; - } - - function Output(indent_string, baseIndentString) { - baseIndentString = baseIndentString || ''; - this.indent_cache = [baseIndentString]; - this.baseIndentLength = baseIndentString.length; - this.indent_length = indent_string.length; - this.raw = false; - - var lines = []; - this.baseIndentString = baseIndentString; - this.indent_string = indent_string; - this.previous_line = null; - this.current_line = null; - this.space_before_token = false; - - this.add_outputline = function() { - this.previous_line = this.current_line; - this.current_line = new OutputLine(this); - lines.push(this.current_line); - }; - - // initialize - this.add_outputline(); - - - this.get_line_number = function() { - return lines.length; - }; - - // Using object instead of string to allow for later expansion of info about each line - this.add_new_line = function(force_newline) { - if (this.get_line_number() === 1 && this.just_added_newline()) { - return false; // no newline on start of file - } - - if (force_newline || !this.just_added_newline()) { - if (!this.raw) { - this.add_outputline(); - } - return true; - } - - return false; - }; - - this.get_code = function() { - var sweet_code = lines.join('\n').replace(/[\r\n\t ]+$/, ''); - return sweet_code; - }; - - this.set_indent = function(level) { - // Never indent your first output indent at the start of the file - if (lines.length > 1) { - while (level >= this.indent_cache.length) { - this.indent_cache.push(this.indent_cache[this.indent_cache.length - 1] + this.indent_string); - } - - this.current_line.set_indent(level); - return true; - } - this.current_line.set_indent(0); - return false; - }; - - this.add_raw_token = function(token) { - for (var x = 0; x < token.newlines; x++) { - this.add_outputline(); - } - this.current_line.push(token.whitespace_before); - this.current_line.push(token.text); - this.space_before_token = false; - }; - - this.add_token = function(printable_token) { - this.add_space_before_token(); - this.current_line.push(printable_token); - }; - - this.add_space_before_token = function() { - if (this.space_before_token && !this.just_added_newline()) { - this.current_line.push(' '); - } - this.space_before_token = false; - }; - - this.remove_redundant_indentation = function(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 - var index = frame.start_line_index; - - var output_length = lines.length; - while (index < output_length) { - lines[index].remove_indent(); - index++; - } - }; - - this.trim = function(eat_newlines) { - eat_newlines = (eat_newlines === undefined) ? false : eat_newlines; - - this.current_line.trim(indent_string, baseIndentString); - - while (eat_newlines && lines.length > 1 && - this.current_line.is_empty()) { - lines.pop(); - this.current_line = lines[lines.length - 1]; - this.current_line.trim(); - } - - this.previous_line = lines.length > 1 ? lines[lines.length - 2] : null; - }; - - this.just_added_newline = function() { - return this.current_line.is_empty(); - }; - - this.just_added_blankline = function() { - if (this.just_added_newline()) { - if (lines.length === 1) { - return true; // start of the file and newline = blank - } - - var line = lines[lines.length - 2]; - return line.is_empty(); - } - return false; - }; - } - - var InputScanner = function(input) { - var _input = input; - var _input_length = _input.length; - var _position = 0; - - this.back = function() { - _position -= 1; - }; - - this.hasNext = function() { - return _position < _input_length; - }; - - this.next = function() { - var val = null; - if (this.hasNext()) { - val = _input.charAt(_position); - _position += 1; - } - return val; - }; - - this.peek = function(index) { - var val = null; - index = index || 0; - index += _position; - if (index >= 0 && index < _input_length) { - val = _input.charAt(index); - } - return val; - }; - - this.peekCharCode = function(index) { - var val = 0; - index = index || 0; - index += _position; - if (index >= 0 && index < _input_length) { - val = _input.charCodeAt(index); - } - return val; - }; - - this.test = function(pattern, index) { - index = index || 0; - pattern.lastIndex = _position + index; - return pattern.test(_input); - }; - - this.testChar = function(pattern, index) { - var val = this.peek(index); - return val !== null && pattern.test(val); - }; - - this.match = function(pattern) { - pattern.lastIndex = _position; - var pattern_match = pattern.exec(_input); - if (pattern_match && pattern_match.index === _position) { - _position += pattern_match[0].length; - } else { - pattern_match = null; - } - return pattern_match; - }; - }; - - var Token = function(type, text, newlines, whitespace_before, parent) { - 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 = /* inline comment*/ []; - - - this.comments_after = []; // no new line before and newline after - this.newlines = newlines || 0; - this.wanted_newline = newlines > 0; - this.whitespace_before = whitespace_before || ''; - this.parent = parent || null; - this.opened = null; - this.directives = null; - }; - - function tokenizer(input_string, opts) { - - var whitespace = "\n\r\t ".split(''); - var digit = /[0-9]/; - var digit_bin = /[01]/; - var digit_oct = /[01234567]/; - var digit_hex = /[0123456789abcdefABCDEF]/; - - this.positionable_operators = '!= !== % & && * ** + - / : < << <= == === > >= >> >>> ? ^ | ||'.split(' '); - var punct = this.positionable_operators.concat( - // non-positionable operators - these do not follow operator position settings - '! %= &= *= **= ++ += , -- -= /= :: <<= = => >>= >>>= ^= |= ~ ...'.split(' ')); - - // words which should always start on new line. - this.line_starters = 'continue,try,throw,return,var,let,const,if,switch,case,default,for,while,break,function,import,export'.split(','); - var reserved_words = this.line_starters.concat(['do', 'in', 'of', 'else', 'get', 'set', 'new', 'catch', 'finally', 'typeof', 'yield', 'async', 'await', 'from', 'as']); - - // /* ... */ comment ends with nearest */ or end of file - var block_comment_pattern = /([\s\S]*?)((?:\*\/)|$)/g; - - // comment ends just before nearest linefeed or end of file - var comment_pattern = /([^\n\r\u2028\u2029]*)/g; - - var directives_block_pattern = /\/\* beautify( \w+[:]\w+)+ \*\//g; - var directive_pattern = / (\w+)[:](\w+)/g; - var directives_end_ignore_pattern = /([\s\S]*?)((?:\/\*\sbeautify\signore:end\s\*\/)|$)/g; - - var template_pattern = /((<\?php|<\?=)[\s\S]*?\?>)|(<%[\s\S]*?%>)/g; - - var n_newlines, whitespace_before_token, in_html_comment, tokens; - var input; - - this.tokenize = function() { - input = new InputScanner(input_string); - in_html_comment = false; - tokens = []; - - var next, last; - var token_values; - var open = null; - var open_stack = []; - var comments = []; - - while (!(last && last.type === 'TK_EOF')) { - token_values = tokenize_next(); - next = new Token(token_values[1], token_values[0], n_newlines, whitespace_before_token); - while (next.type === 'TK_COMMENT' || next.type === 'TK_BLOCK_COMMENT' || next.type === 'TK_UNKNOWN') { - if (next.type === 'TK_BLOCK_COMMENT') { - next.directives = token_values[2]; - } - comments.push(next); - token_values = tokenize_next(); - next = new Token(token_values[1], token_values[0], n_newlines, whitespace_before_token); - } - - if (comments.length) { - next.comments_before = comments; - comments = []; - } - - if (next.type === 'TK_START_BLOCK' || next.type === 'TK_START_EXPR') { - next.parent = last; - open_stack.push(open); - open = next; - } else if ((next.type === 'TK_END_BLOCK' || next.type === 'TK_END_EXPR') && - (open && ( - (next.text === ']' && open.text === '[') || - (next.text === ')' && open.text === '(') || - (next.text === '}' && open.text === '{')))) { - next.parent = open.parent; - next.opened = open; - - open = open_stack.pop(); - } - - tokens.push(next); - last = next; - } - - return tokens; - }; - - function get_directives(text) { - if (!text.match(directives_block_pattern)) { - return null; - } - - var directives = {}; - directive_pattern.lastIndex = 0; - var directive_match = directive_pattern.exec(text); - - while (directive_match) { - directives[directive_match[1]] = directive_match[2]; - directive_match = directive_pattern.exec(text); - } - - return directives; - } - - function tokenize_next() { - var resulting_string; - var whitespace_on_this_line = []; - - n_newlines = 0; - whitespace_before_token = ''; - - var c = input.next(); - - if (c === null) { - return ['', 'TK_EOF']; - } - - var last_token; - if (tokens.length) { - last_token = tokens[tokens.length - 1]; - } else { - // For the sake of tokenizing we can pretend that there was on open brace to start - last_token = new Token('TK_START_BLOCK', '{'); - } - - while (in_array(c, whitespace)) { - - if (acorn.newline.test(c)) { - if (!(c === '\n' && input.peek(-2) === '\r')) { - n_newlines += 1; - whitespace_on_this_line = []; - } - } else { - whitespace_on_this_line.push(c); - } - - c = input.next(); - - if (c === null) { - return ['', 'TK_EOF']; - } - } - - if (whitespace_on_this_line.length) { - whitespace_before_token = whitespace_on_this_line.join(''); - } - - if (digit.test(c) || (c === '.' && input.testChar(digit))) { - var allow_decimal = true; - var allow_e = true; - var local_digit = digit; - - if (c === '0' && input.testChar(/[XxOoBb]/)) { - // switch to hex/oct/bin number, no decimal or e, just hex/oct/bin digits - allow_decimal = false; - allow_e = false; - if (input.testChar(/[Bb]/)) { - local_digit = digit_bin; - } else if (input.testChar(/[Oo]/)) { - local_digit = digit_oct; - } else { - local_digit = digit_hex; - } - c += input.next(); - } else if (c === '.') { - // Already have a decimal for this literal, don't allow another - allow_decimal = false; - } else { - // we know this first loop will run. It keeps the logic simpler. - c = ''; - input.back(); - } - - // Add the digits - while (input.testChar(local_digit)) { - c += input.next(); - - if (allow_decimal && input.peek() === '.') { - c += input.next(); - allow_decimal = false; - } - - // a = 1.e-7 is valid, so we test for . then e in one loop - if (allow_e && input.testChar(/[Ee]/)) { - c += input.next(); - - if (input.testChar(/[+-]/)) { - c += input.next(); - } - - allow_e = false; - allow_decimal = false; - } - } - - return [c, 'TK_WORD']; - } - - if (acorn.isIdentifierStart(input.peekCharCode(-1))) { - if (input.hasNext()) { - while (acorn.isIdentifierChar(input.peekCharCode())) { - c += input.next(); - if (!input.hasNext()) { - break; - } - } - } - - if (!(last_token.type === 'TK_DOT' || - (last_token.type === 'TK_RESERVED' && in_array(last_token.text, ['set', 'get']))) && - in_array(c, reserved_words)) { - if (c === 'in' || c === 'of') { // hack for 'in' and 'of' operators - return [c, 'TK_OPERATOR']; - } - return [c, 'TK_RESERVED']; - } - - 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 = ''; - var comment_match; - // peek for comment /* ... */ - if (input.peek() === '*') { - input.next(); - comment_match = input.match(block_comment_pattern); - comment = '/*' + comment_match[0]; - var directives = get_directives(comment); - if (directives && directives.ignore === 'start') { - comment_match = input.match(directives_end_ignore_pattern); - comment += comment_match[0]; - } - comment = comment.replace(acorn.allLineBreaks, '\n'); - return [comment, 'TK_BLOCK_COMMENT', directives]; - } - // peek for comment // ... - if (input.peek() === '/') { - input.next(); - comment_match = input.match(comment_pattern); - comment = '//' + comment_match[0]; - return [comment, 'TK_COMMENT']; - } - - } - - var startXmlRegExp = /<()([-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*>/g; - - if (c === '`' || c === "'" || c === '"' || // string - ( - (c === '/') || // regexp - (opts.e4x && c === "<" && input.test(startXmlRegExp, -1)) // xml - ) && ( // regex and xml can only appear in specific locations during parsing - (last_token.type === 'TK_RESERVED' && in_array(last_token.text, ['return', 'case', 'throw', 'else', 'do', 'typeof', 'yield'])) || - (last_token.type === 'TK_END_EXPR' && last_token.text === ')' && - last_token.parent && last_token.parent.type === 'TK_RESERVED' && in_array(last_token.parent.text, ['if', 'while', 'for'])) || - (in_array(last_token.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 (sep === '/') { - // - // handle regexp - // - var in_char_class = false; - while (input.hasNext() && - ((esc || in_char_class || input.peek() !== sep) && - !input.testChar(acorn.newline))) { - resulting_string += input.peek(); - if (!esc) { - esc = input.peek() === '\\'; - if (input.peek() === '[') { - in_char_class = true; - } else if (input.peek() === ']') { - in_char_class = false; - } - } else { - esc = false; - } - input.next(); - } - } else if (opts.e4x && sep === '<') { - // - // handle e4x xml literals - // - - var xmlRegExp = /[\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*>/g; - input.back(); - var xmlStr = ''; - var match = input.match(startXmlRegExp); - 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 = input.match(xmlRegExp); - } - // if we didn't close correctly, keep unformatted. - if (!match) { - xmlStr += input.match(/[\s\S]*/g)[0]; - } - xmlStr = xmlStr.replace(acorn.allLineBreaks, '\n'); - return [xmlStr, "TK_STRING"]; - } - } else { - // - // handle string - // - var parse_string = function(delimiter, allow_unescaped_newlines, start_sub) { - // Template strings can travers lines without escape characters. - // Other strings cannot - var current_char; - while (input.hasNext()) { - current_char = input.peek(); - if (!(esc || (current_char !== delimiter && - (allow_unescaped_newlines || !acorn.newline.test(current_char))))) { - break; - } - - // Handle \r\n linebreaks after escapes or in template strings - if ((esc || allow_unescaped_newlines) && acorn.newline.test(current_char)) { - if (current_char === '\r' && input.peek(1) === '\n') { - input.next(); - current_char = input.peek(); - } - resulting_string += '\n'; - } else { - resulting_string += current_char; - } - - if (esc) { - if (current_char === 'x' || current_char === 'u') { - has_char_escapes = true; - } - esc = false; - } else { - esc = current_char === '\\'; - } - - input.next(); - - if (start_sub && resulting_string.indexOf(start_sub, resulting_string.length - start_sub.length) !== -1) { - if (delimiter === '`') { - parse_string('}', allow_unescaped_newlines, '`'); - } else { - parse_string('`', allow_unescaped_newlines, '${'); - } - - if (input.hasNext()) { - resulting_string += input.next(); - } - } - } - }; - - if (sep === '`') { - parse_string('`', true, '${'); - } else { - parse_string(sep); - } - } - - if (has_char_escapes && opts.unescape_strings) { - resulting_string = unescape_string(resulting_string); - } - - if (input.peek() === sep) { - resulting_string += sep; - input.next(); - - if (sep === '/') { - // 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. - while (input.hasNext() && acorn.isIdentifierStart(input.peekCharCode())) { - resulting_string += input.next(); - } - } - } - return [resulting_string, 'TK_STRING']; - } - - if (c === '#') { - - if (tokens.length === 0 && input.peek() === '!') { - // shebang - resulting_string = c; - while (input.hasNext() && c !== '\n') { - c = input.next(); - resulting_string += c; - } - 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 (input.hasNext() && input.testChar(digit)) { - do { - c = input.next(); - sharp += c; - } while (input.hasNext() && c !== '#' && c !== '='); - if (c === '#') { - // - } else if (input.peek() === '[' && input.peek(1) === ']') { - sharp += '[]'; - input.next(); - input.next(); - } else if (input.peek() === '{' && input.peek(1) === '}') { - sharp += '{}'; - input.next(); - input.next(); - } - return [sharp, 'TK_WORD']; - } - } - - if (c === '<' && (input.peek() === '?' || input.peek() === '%')) { - input.back(); - var template_match = input.match(template_pattern); - if (template_match) { - c = template_match[0]; - c = c.replace(acorn.allLineBreaks, '\n'); - return [c, 'TK_STRING']; - } - } - - if (c === '<' && input.match(/\!--/g)) { - c = '', 'TK_COMMENT']; - } - - if (c === '.') { - if (input.peek() === '.' && input.peek(1) === '.') { - c += input.next() + input.next(); - return [c, 'TK_OPERATOR']; - } - return [c, 'TK_DOT']; - } - - if (in_array(c, punct)) { - while (input.hasNext() && in_array(c + input.peek(), punct)) { - c += input.next(); - if (!input.hasNext()) { - break; - } - } - - if (c === ',') { - return [c, 'TK_COMMA']; - } else if (c === '=') { - return [c, 'TK_EQUALS']; - } else { - return [c, 'TK_OPERATOR']; - } - } - - return [c, 'TK_UNKNOWN']; - } - - - 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; - } - } - - var beautifier = new Beautifier(js_source_text, options); - return beautifier.beautify(); - - } - - 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; - } - -}()); \ No newline at end of file