save me

node_modules/js-beautify/js/bin/css-beautify.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+var cli = require('../lib/cli'); cli.interpret();
+
+

node_modules/js-beautify/js/bin/html-beautify.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+var cli = require('../lib/cli'); cli.interpret();
+
+

node_modules/js-beautify/js/bin/js-beautify.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+var cli = require('../lib/cli');
+cli.interpret();

node_modules/js-beautify/js/config/defaults.json

@@ -0,0 +1,18 @@
+{
+    "indent_size": 4,
+    "indent_char": " ",
+    "indent_level": 0,
+    "indent_with_tabs": false,
+    "preserve_newlines": true,
+    "max_preserve_newlines": 10,
+    "jslint_happy": false,
+    "space_after_anon_function": false,
+    "brace_style": "collapse",
+    "keep_array_indentation": false,
+    "keep_function_indentation": false,
+    "space_before_conditional": true,
+    "break_chained_methods": false,
+    "eval_code": false,
+    "unescape_strings": false,
+    "wrap_line_length": 0
+}

node_modules/js-beautify/js/index.js

@@ -0,0 +1,81 @@
+/*
+  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.
+
+*/
+
+/**
+The following batches are equivalent:
+
+var beautify_js = require('js-beautify');
+var beautify_js = require('js-beautify').js;
+var beautify_js = require('js-beautify').js_beautify;
+
+var beautify_css = require('js-beautify').css;
+var beautify_css = require('js-beautify').css_beautify;
+
+var beautify_html = require('js-beautify').html;
+var beautify_html = require('js-beautify').html_beautify;
+
+All methods returned accept two arguments, the source string and an options object.
+**/
+
+function get_beautify(js_beautify, css_beautify, html_beautify) {
+    // the default is js
+    var beautify = function(src, config) {
+        return js_beautify.js_beautify(src, config);
+    };
+
+    // short aliases
+    beautify.js = js_beautify.js_beautify;
+    beautify.css = css_beautify.css_beautify;
+    beautify.html = html_beautify.html_beautify;
+
+    // legacy aliases
+    beautify.js_beautify = js_beautify.js_beautify;
+    beautify.css_beautify = css_beautify.css_beautify;
+    beautify.html_beautify = html_beautify.html_beautify;
+
+    return beautify;
+}
+
+if (typeof define === "function" && define.amd) {
+    // Add support for AMD ( https://github.com/amdjs/amdjs-api/wiki/AMD#defineamd-property- )
+    define([
+        "./lib/beautify",
+        "./lib/beautify-css",
+        "./lib/beautify-html"
+    ], function(js_beautify, css_beautify, html_beautify) {
+        return get_beautify(js_beautify, css_beautify, html_beautify);
+    });
+} else {
+    (function(mod) {
+        var js_beautify = require('./lib/beautify');
+        var css_beautify = require('./lib/beautify-css');
+        var html_beautify = require('./lib/beautify-html');
+
+        mod.exports = get_beautify(js_beautify, css_beautify, html_beautify);
+
+    })(module);
+}

node_modules/js-beautify/js/lib/beautify-css.js

@@ -0,0 +1,571 @@
+/*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.
+
+
+ CSS Beautifier
+---------------
+
+    Written by Harutyun Amirjanyan, (amirjanyan@gmail.com)
+
+    Based on code initially developed by: Einar Lielmanis, <einar@jsbeautifier.org>
+        http://jsbeautifier.org/
+
+    Usage:
+        css_beautify(source_text);
+        css_beautify(source_text, options);
+
+    The options are (default in brackets):
+        indent_size (4)                         — indentation size,
+        indent_char (space)                     — character to indent with,
+        preserve_newlines (default false)       - whether existing line breaks should be preserved,
+        selector_separator_newline (true)       - separate selectors with newline or
+                                                  not (e.g. "a,\nbr" or "a, br")
+        end_with_newline (false)                - end with a newline
+        newline_between_rules (true)            - add a new line after every css rule
+        space_around_selector_separator (false) - ensure space around selector separators:
+                                                  '>', '+', '~' (e.g. "a>b" -> "a > b")
+    e.g
+
+    css_beautify(css_source_text, {
+      'indent_size': 1,
+      'indent_char': '\t',
+      'selector_separator': ' ',
+      'end_with_newline': false,
+      'newline_between_rules': true,
+      'space_around_selector_separator': true
+    });
+*/
+
+// http://www.w3.org/TR/CSS21/syndata.html#tokenization
+// http://www.w3.org/TR/css3-syntax/
+
+(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;
+    }
+
+    var lineBreak = /\r\n|[\n\r\u2028\u2029]/;
+    var allLineBreaks = new RegExp(lineBreak.source, 'g');
+
+    function css_beautify(source_text, options) {
+        options = options || {};
+
+        // Allow the setting of language/file-type specific options
+        // with inheritance of overall settings
+        options = mergeOpts(options, 'css');
+
+        source_text = source_text || '';
+
+        var newlinesFromLastWSEat = 0;
+        var indentSize = options.indent_size ? parseInt(options.indent_size, 10) : 4;
+        var indentCharacter = options.indent_char || ' ';
+        var preserve_newlines = (options.preserve_newlines === undefined) ? false : options.preserve_newlines;
+        var selectorSeparatorNewline = (options.selector_separator_newline === undefined) ? true : options.selector_separator_newline;
+        var end_with_newline = (options.end_with_newline === undefined) ? false : options.end_with_newline;
+        var newline_between_rules = (options.newline_between_rules === undefined) ? true : options.newline_between_rules;
+        var space_around_combinator = (options.space_around_combinator === undefined) ? false : options.space_around_combinator;
+        space_around_combinator = space_around_combinator || ((options.space_around_selector_separator === undefined) ? false : options.space_around_selector_separator);
+        var eol = options.eol ? options.eol : 'auto';
+
+        if (options.indent_with_tabs) {
+            indentCharacter = '\t';
+            indentSize = 1;
+        }
+
+        if (eol === 'auto') {
+            eol = '\n';
+            if (source_text && lineBreak.test(source_text || '')) {
+                eol = source_text.match(lineBreak)[0];
+            }
+        }
+
+        eol = eol.replace(/\\r/, '\r').replace(/\\n/, '\n');
+
+        // HACK: newline parsing inconsistent. This brute force normalizes the input.
+        source_text = source_text.replace(allLineBreaks, '\n');
+
+        // tokenizer
+        var whiteRe = /^\s+$/;
+
+        var pos = -1,
+            ch;
+        var parenLevel = 0;
+
+        function next() {
+            ch = source_text.charAt(++pos);
+            return ch || '';
+        }
+
+        function peek(skipWhitespace) {
+            var result = '';
+            var prev_pos = pos;
+            if (skipWhitespace) {
+                eatWhitespace();
+            }
+            result = source_text.charAt(pos + 1) || '';
+            pos = prev_pos - 1;
+            next();
+            return result;
+        }
+
+        function eatString(endChars) {
+            var start = pos;
+            while (next()) {
+                if (ch === "\\") {
+                    next();
+                } else if (endChars.indexOf(ch) !== -1) {
+                    break;
+                } else if (ch === "\n") {
+                    break;
+                }
+            }
+            return source_text.substring(start, pos + 1);
+        }
+
+        function peekString(endChar) {
+            var prev_pos = pos;
+            var str = eatString(endChar);
+            pos = prev_pos - 1;
+            next();
+            return str;
+        }
+
+        function eatWhitespace(preserve_newlines_local) {
+            var result = 0;
+            while (whiteRe.test(peek())) {
+                next();
+                if (ch === '\n' && preserve_newlines_local && preserve_newlines) {
+                    print.newLine(true);
+                    result++;
+                }
+            }
+            newlinesFromLastWSEat = result;
+            return result;
+        }
+
+        function skipWhitespace() {
+            var result = '';
+            if (ch && whiteRe.test(ch)) {
+                result = ch;
+            }
+            while (whiteRe.test(next())) {
+                result += ch;
+            }
+            return result;
+        }
+
+        function eatComment(singleLine) {
+            var start = pos;
+            singleLine = peek() === "/";
+            next();
+            while (next()) {
+                if (!singleLine && ch === "*" && peek() === "/") {
+                    next();
+                    break;
+                } else if (singleLine && ch === "\n") {
+                    return source_text.substring(start, pos);
+                }
+            }
+
+            return source_text.substring(start, pos) + ch;
+        }
+
+
+        function lookBack(str) {
+            return source_text.substring(pos - str.length, pos).toLowerCase() ===
+                str;
+        }
+
+        // Nested pseudo-class if we are insideRule
+        // and the next special character found opens
+        // a new block
+        function foundNestedPseudoClass() {
+            var openParen = 0;
+            for (var i = pos + 1; i < source_text.length; i++) {
+                var ch = source_text.charAt(i);
+                if (ch === "{") {
+                    return true;
+                } else if (ch === '(') {
+                    // pseudoclasses can contain ()
+                    openParen += 1;
+                } else if (ch === ')') {
+                    if (openParen === 0) {
+                        return false;
+                    }
+                    openParen -= 1;
+                } else if (ch === ";" || ch === "}") {
+                    return false;
+                }
+            }
+            return false;
+        }
+
+        // printer
+        var basebaseIndentString = source_text.match(/^[\t ]*/)[0];
+        var singleIndent = new Array(indentSize + 1).join(indentCharacter);
+        var indentLevel = 0;
+        var nestedLevel = 0;
+
+        function indent() {
+            indentLevel++;
+            basebaseIndentString += singleIndent;
+        }
+
+        function outdent() {
+            indentLevel--;
+            basebaseIndentString = basebaseIndentString.slice(0, -indentSize);
+        }
+
+        var print = {};
+        print["{"] = function(ch) {
+            print.singleSpace();
+            output.push(ch);
+            if (!eatWhitespace(true)) {
+                print.newLine();
+            }
+        };
+        print["}"] = function(newline) {
+            if (newline) {
+                print.newLine();
+            }
+            output.push('}');
+            if (!eatWhitespace(true)) {
+                print.newLine();
+            }
+        };
+
+        print._lastCharWhitespace = function() {
+            return whiteRe.test(output[output.length - 1]);
+        };
+
+        print.newLine = function(keepWhitespace) {
+            if (output.length) {
+                if (!keepWhitespace && output[output.length - 1] !== '\n') {
+                    print.trim();
+                } else if (output[output.length - 1] === basebaseIndentString) {
+                    output.pop();
+                }
+                output.push('\n');
+
+                if (basebaseIndentString) {
+                    output.push(basebaseIndentString);
+                }
+            }
+        };
+        print.singleSpace = function() {
+            if (output.length && !print._lastCharWhitespace()) {
+                output.push(' ');
+            }
+        };
+
+        print.preserveSingleSpace = function() {
+            if (isAfterSpace) {
+                print.singleSpace();
+            }
+        };
+
+        print.trim = function() {
+            while (print._lastCharWhitespace()) {
+                output.pop();
+            }
+        };
+
+
+        var output = [];
+        /*_____________________--------------------_____________________*/
+
+        var insideRule = false;
+        var insidePropertyValue = false;
+        var enteringConditionalGroup = false;
+        var top_ch = '';
+        var last_top_ch = '';
+
+        while (true) {
+            var whitespace = skipWhitespace();
+            var isAfterSpace = whitespace !== '';
+            var isAfterNewline = whitespace.indexOf('\n') !== -1;
+            last_top_ch = top_ch;
+            top_ch = ch;
+
+            if (!ch) {
+                break;
+            } else if (ch === '/' && peek() === '*') { /* css comment */
+                var header = indentLevel === 0;
+
+                if (isAfterNewline || header) {
+                    print.newLine();
+                }
+
+                output.push(eatComment());
+                print.newLine();
+                if (header) {
+                    print.newLine(true);
+                }
+            } else if (ch === '/' && peek() === '/') { // single line comment
+                if (!isAfterNewline && last_top_ch !== '{') {
+                    print.trim();
+                }
+                print.singleSpace();
+                output.push(eatComment());
+                print.newLine();
+            } else if (ch === '@') {
+                print.preserveSingleSpace();
+
+                // deal with less propery mixins @{...}
+                if (peek() === '{') {
+                    output.push(eatString('}'));
+                } else {
+                    output.push(ch);
+
+                    // strip trailing space, if present, for hash property checks
+                    var variableOrRule = peekString(": ,;{}()[]/='\"");
+
+                    if (variableOrRule.match(/[ :]$/)) {
+                        // we have a variable or pseudo-class, add it and insert one space before continuing
+                        next();
+                        variableOrRule = eatString(": ").replace(/\s$/, '');
+                        output.push(variableOrRule);
+                        print.singleSpace();
+                    }
+
+                    variableOrRule = variableOrRule.replace(/\s$/, '');
+
+                    // might be a nesting at-rule
+                    if (variableOrRule in css_beautify.NESTED_AT_RULE) {
+                        nestedLevel += 1;
+                        if (variableOrRule in css_beautify.CONDITIONAL_GROUP_RULE) {
+                            enteringConditionalGroup = true;
+                        }
+                    }
+                }
+            } else if (ch === '#' && peek() === '{') {
+                print.preserveSingleSpace();
+                output.push(eatString('}'));
+            } else if (ch === '{') {
+                if (peek(true) === '}') {
+                    eatWhitespace();
+                    next();
+                    print.singleSpace();
+                    output.push("{");
+                    print['}'](false);
+                    if (newlinesFromLastWSEat < 2 && newline_between_rules && indentLevel === 0) {
+                        print.newLine(true);
+                    }
+                } else {
+                    indent();
+                    print["{"](ch);
+                    // when entering conditional groups, only rulesets are allowed
+                    if (enteringConditionalGroup) {
+                        enteringConditionalGroup = false;
+                        insideRule = (indentLevel > nestedLevel);
+                    } else {
+                        // otherwise, declarations are also allowed
+                        insideRule = (indentLevel >= nestedLevel);
+                    }
+                }
+            } else if (ch === '}') {
+                outdent();
+                print["}"](true);
+                insideRule = false;
+                insidePropertyValue = false;
+                if (nestedLevel) {
+                    nestedLevel--;
+                }
+                if (newlinesFromLastWSEat < 2 && newline_between_rules && indentLevel === 0) {
+                    print.newLine(true);
+                }
+            } else if (ch === ":") {
+                eatWhitespace();
+                if ((insideRule || enteringConditionalGroup) &&
+                    !(lookBack("&") || foundNestedPseudoClass()) &&
+                    !lookBack("(")) {
+                    // 'property: value' delimiter
+                    // which could be in a conditional group query
+                    output.push(':');
+                    if (!insidePropertyValue) {
+                        insidePropertyValue = true;
+                        print.singleSpace();
+                    }
+                } else {
+                    // sass/less parent reference don't use a space
+                    // sass nested pseudo-class don't use a space
+
+                    // preserve space before pseudoclasses/pseudoelements, as it means "in any child"
+                    if (lookBack(" ") && output[output.length - 1] !== " ") {
+                        output.push(" ");
+                    }
+                    if (peek() === ":") {
+                        // pseudo-element
+                        next();
+                        output.push("::");
+                    } else {
+                        // pseudo-class
+                        output.push(':');
+                    }
+                }
+            } else if (ch === '"' || ch === '\'') {
+                print.preserveSingleSpace();
+                output.push(eatString(ch));
+            } else if (ch === ';') {
+                insidePropertyValue = false;
+                output.push(ch);
+                if (!eatWhitespace(true)) {
+                    print.newLine();
+                }
+            } else if (ch === '(') { // may be a url
+                if (lookBack("url")) {
+                    output.push(ch);
+                    eatWhitespace();
+                    if (next()) {
+                        if (ch !== ')' && ch !== '"' && ch !== '\'') {
+                            output.push(eatString(')'));
+                        } else {
+                            pos--;
+                        }
+                    }
+                } else {
+                    parenLevel++;
+                    print.preserveSingleSpace();
+                    output.push(ch);
+                    eatWhitespace();
+                }
+            } else if (ch === ')') {
+                output.push(ch);
+                parenLevel--;
+            } else if (ch === ',') {
+                output.push(ch);
+                if (!eatWhitespace(true) && selectorSeparatorNewline && !insidePropertyValue && parenLevel < 1) {
+                    print.newLine();
+                } else {
+                    print.singleSpace();
+                }
+            } else if ((ch === '>' || ch === '+' || ch === '~') &&
+                !insidePropertyValue && parenLevel < 1) {
+                //handle combinator spacing
+                if (space_around_combinator) {
+                    print.singleSpace();
+                    output.push(ch);
+                    print.singleSpace();
+                } else {
+                    output.push(ch);
+                    eatWhitespace();
+                    // squash extra whitespace
+                    if (ch && whiteRe.test(ch)) {
+                        ch = '';
+                    }
+                }
+            } else if (ch === ']') {
+                output.push(ch);
+            } else if (ch === '[') {
+                print.preserveSingleSpace();
+                output.push(ch);
+            } else if (ch === '=') { // no whitespace before or after
+                eatWhitespace();
+                output.push('=');
+                if (whiteRe.test(ch)) {
+                    ch = '';
+                }
+            } else {
+                print.preserveSingleSpace();
+                output.push(ch);
+            }
+        }
+
+
+        var sweetCode = '';
+        if (basebaseIndentString) {
+            sweetCode += basebaseIndentString;
+        }
+
+        sweetCode += output.join('').replace(/[\r\n\t ]+$/, '');
+
+        // establish end_with_newline
+        if (end_with_newline) {
+            sweetCode += '\n';
+        }
+
+        if (eol !== '\n') {
+            sweetCode = sweetCode.replace(/[\n]/g, eol);
+        }
+
+        return sweetCode;
+    }
+
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/At-rule
+    css_beautify.NESTED_AT_RULE = {
+        "@page": true,
+        "@font-face": true,
+        "@keyframes": true,
+        // also in CONDITIONAL_GROUP_RULE below
+        "@media": true,
+        "@supports": true,
+        "@document": true
+    };
+    css_beautify.CONDITIONAL_GROUP_RULE = {
+        "@media": true,
+        "@supports": true,
+        "@document": true
+    };
+
+    /*global define */
+    if (typeof define === "function" && define.amd) {
+        // Add support for AMD ( https://github.com/amdjs/amdjs-api/wiki/AMD#defineamd-property- )
+        define([], function() {
+            return {
+                css_beautify: css_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 html_beautify = require("beautify").html_beautify`.
+        exports.css_beautify = css_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.css_beautify = css_beautify;
+    } else if (typeof global !== "undefined") {
+        // If we don't even have window, try global.
+        global.css_beautify = css_beautify;
+    }
+
+}());

node_modules/js-beautify/js/lib/cli.js

@@ -0,0 +1,620 @@
+#!/usr/bin/env node
+
+/*
+  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-Beautify Command-line for node.js
+  -------------------------------------
+
+  Written by Daniel Stockman (daniel.stockman@gmail.com)
+
+*/
+
+var debug = process.env.DEBUG_JSBEAUTIFY || process.env.JSBEAUTIFY_DEBUG ? function() {
+    console.error.apply(console, arguments);
+} : function() {};
+
+var fs = require('fs'),
+    cc = require('config-chain'),
+    beautify = require('../index'),
+    mkdirp = require('mkdirp'),
+    nopt = require('nopt');
+nopt.typeDefs.brace_style = {
+    type: "brace_style",
+    validate: function(data, key, val) {
+        data[key] = val;
+        // TODO: expand-strict is obsolete, now identical to expand.  Remove in future version
+        // TODO: collapse-preserve-inline is obselete, now identical to collapse,preserve-inline = true. Remove in future version
+        var validVals = ["collapse", "collapse-preserve-inline", "expand", "end-expand", "expand-strict", "none"];
+        var valSplit = val.split(/[^a-zA-Z0-9_\-]+/);
+        for (var i = 0; i < validVals.length; i++) {
+            if (validVals[i] === val || validVals[i] === valSplit[0] && valSplit[1] === "preserve-inline") {
+                return true;
+            }
+        }
+        return false;
+    }
+};
+var path = require('path'),
+    editorconfig = require('editorconfig'),
+    knownOpts = {
+        // Beautifier
+        "indent_size": Number,
+        "indent_char": String,
+        "eol": String,
+        "indent_level": Number,
+        "indent_with_tabs": Boolean,
+        "preserve_newlines": Boolean,
+        "max_preserve_newlines": Number,
+        "space_in_paren": Boolean,
+        "space_in_empty_paren": Boolean,
+        "jslint_happy": Boolean,
+        "space_after_anon_function": Boolean,
+        "brace_style": "brace_style", //See above for validation
+        "break_chained_methods": Boolean,
+        "keep_array_indentation": Boolean,
+        "unescape_strings": Boolean,
+        "wrap_line_length": Number,
+        "wrap_attributes": ["auto", "force", "force-aligned"],
+        "wrap_attributes_indent_size": Number,
+        "e4x": Boolean,
+        "end_with_newline": Boolean,
+        "comma_first": Boolean,
+        "operator_position": ["before-newline", "after-newline", "preserve-newline"],
+        // CSS-only
+        "selector_separator_newline": Boolean,
+        "newline_between_rules": Boolean,
+        "space_around_combinator": Boolean,
+        //deprecated - replaced with space_around_combinator, remove in future version
+        "space_around_selector_separator": Boolean,
+        // HTML-only
+        "max_char": Number, // obsolete since 1.3.5
+        "unformatted": [String, Array],
+        "content_unformatted": [String, Array],
+        "indent_inner_html": [Boolean],
+        "indent_handlebars": [Boolean],
+        "indent_scripts": ["keep", "separate", "normal"],
+        "extra_liners": [String, Array],
+        // CLI
+        "version": Boolean,
+        "help": Boolean,
+        "files": [path, Array],
+        "outfile": path,
+        "replace": Boolean,
+        "quiet": Boolean,
+        "type": ["js", "css", "html"],
+        "config": path,
+        "editorconfig": Boolean
+    },
+    // dasherizeShorthands provides { "indent-size": ["--indent_size"] }
+    // translation, allowing more convenient dashes in CLI arguments
+    shortHands = dasherizeShorthands({
+        // Beautifier
+        "s": ["--indent_size"],
+        "c": ["--indent_char"],
+        "e": ["--eol"],
+        "l": ["--indent_level"],
+        "t": ["--indent_with_tabs"],
+        "p": ["--preserve_newlines"],
+        "m": ["--max_preserve_newlines"],
+        "P": ["--space_in_paren"],
+        "Q": ["--space_in_empty_paren"],
+        "j": ["--jslint_happy"],
+        "a": ["--space_after_anon_function"],
+        "b": ["--brace_style"],
+        "B": ["--break_chained_methods"],
+        "k": ["--keep_array_indentation"],
+        "x": ["--unescape_strings"],
+        "w": ["--wrap_line_length"],
+        "X": ["--e4x"],
+        "n": ["--end_with_newline"],
+        "C": ["--comma_first"],
+        "O": ["--operator_position"],
+        // CSS-only
+        "L": ["--selector_separator_newline"],
+        "N": ["--newline_between_rules"],
+        // HTML-only
+        "A": ["--wrap_attributes"],
+        "i": ["--wrap_attributes_indent_size"],
+        "W": ["--max_char"], // obsolete since 1.3.5
+        "U": ["--unformatted"],
+        "T": ["--content_unformatted"],
+        "I": ["--indent_inner_html"],
+        "H": ["--indent_handlebars"],
+        "S": ["--indent_scripts"],
+        "E": ["--extra_liners"],
+        // non-dasherized hybrid shortcuts
+        "good-stuff": [
+            "--keep_array_indentation",
+            "--keep_function_indentation",
+            "--jslint_happy"
+        ],
+        "js": ["--type", "js"],
+        "css": ["--type", "css"],
+        "html": ["--type", "html"],
+        // CLI
+        "v": ["--version"],
+        "h": ["--help"],
+        "f": ["--files"],
+        "o": ["--outfile"],
+        "r": ["--replace"],
+        "q": ["--quiet"]
+        // no shorthand for "config"
+        // no shorthand for "editorconfig"
+    });
+
+function verifyExists(fullPath) {
+    return fs.existsSync(fullPath) ? fullPath : null;
+}
+
+function findRecursive(dir, fileName) {
+    var fullPath = path.join(dir, fileName);
+    var nextDir = path.dirname(dir);
+    var result = verifyExists(fullPath);
+
+    if (!result && (nextDir !== dir)) {
+        result = findRecursive(nextDir, fileName);
+    }
+
+    return result;
+}
+
+function getUserHome() {
+    var user_home = '';
+    try {
+        user_home = process.env.USERPROFILE || process.env.HOME || '';
+    } catch (ex) {}
+    return user_home;
+}
+
+function set_file_editorconfig_opts(file, config) {
+    try {
+        var eConfigs = editorconfig.parseSync(file);
+
+        if (eConfigs.indent_style === "tab") {
+            config.indent_with_tabs = true;
+        } else if (eConfigs.indent_style === "space") {
+            config.indent_with_tabs = false;
+        }
+
+        if (eConfigs.indent_size) {
+            config.indent_size = eConfigs.indent_size;
+        }
+
+        if (eConfigs.max_line_length) {
+            if (eConfigs.max_line_length === "off") {
+                config.wrap_line_length = 0;
+            } else {
+                config.wrap_line_length = parseInt(eConfigs.max_line_length);
+            }
+        }
+
+        if (eConfigs.insert_final_newline === true) {
+            config.end_with_newline = true;
+        } else if (eConfigs.insert_final_newline === false) {
+            config.end_with_newline = false;
+        }
+
+        if (eConfigs.end_of_line) {
+            if (eConfigs.end_of_line === 'cr') {
+                config.eol = '\r';
+            } else if (eConfigs.end_of_line === 'lf') {
+                config.eol = '\n';
+            } else if (eConfigs.end_of_line === 'crlf') {
+                config.eol = '\r\n';
+            }
+        }
+    } catch (e) {
+        debug(e);
+    }
+}
+
+// var cli = require('js-beautify/cli'); cli.interpret();
+var interpret = exports.interpret = function(argv, slice) {
+    var parsed = nopt(knownOpts, shortHands, argv, slice);
+
+    if (parsed.version) {
+        console.log(require('../../package.json').version);
+        process.exit(0);
+    } else if (parsed.help) {
+        usage();
+        process.exit(0);
+    }
+
+    var cfg;
+    var configRecursive = findRecursive(process.cwd(), '.jsbeautifyrc');
+    var configHome = verifyExists(path.join(getUserHome() || "", ".jsbeautifyrc"));
+    var configDefault = __dirname + '/../config/defaults.json';
+
+    try {
+        cfg = cc(
+            parsed,
+            cleanOptions(cc.env('jsbeautify_'), knownOpts),
+            parsed.config,
+            configRecursive,
+            configHome,
+            configDefault
+        ).snapshot;
+    } catch (ex) {
+        debug(cfg);
+        // usage(ex);
+        console.error(ex);
+        console.error('Error while loading beautifier configuration.');
+        console.error('Configuration file chain included:');
+        if (parsed.config) {
+            console.error(parsed.config);
+        }
+        if (configRecursive) {
+            console.error(configRecursive);
+        }
+        if (configHome) {
+            console.error(configHome);
+        }
+        console.error(configDefault);
+        console.error('Run `' + getScriptName() + ' -h` for help.');
+        process.exit(1);
+    }
+
+    try {
+        // Verify arguments
+        checkType(cfg);
+        checkFiles(cfg);
+        debug(cfg);
+
+        // Process files synchronously to avoid EMFILE error
+        cfg.files.forEach(processInputSync, {
+            cfg: cfg
+        });
+    } catch (ex) {
+        debug(cfg);
+        // usage(ex);
+        console.error(ex);
+        console.error('Run `' + getScriptName() + ' -h` for help.');
+        process.exit(1);
+    }
+};
+
+// interpret args immediately when called as executable
+if (require.main === module) {
+    interpret();
+}
+
+function usage(err) {
+    var scriptName = getScriptName();
+    var msg = [
+        scriptName + '@' + require('../../package.json').version,
+        '',
+        'CLI Options:',
+        '  -f, --file       Input file(s) (Pass \'-\' for stdin)',
+        '  -r, --replace    Write output in-place, replacing input',
+        '  -o, --outfile    Write output to file (default stdout)',
+        '  --config         Path to config file',
+        '  --type           [js|css|html] ["js"]',
+        '  -q, --quiet      Suppress logging to stdout',
+        '  -h, --help       Show this help',
+        '  -v, --version    Show the version',
+        '',
+        'Beautifier Options:',
+        '  -s, --indent-size                 Indentation size [4]',
+        '  -c, --indent-char                 Indentation character [" "]',
+        '  -t, --indent-with-tabs            Indent with tabs, overrides -s and -c',
+        '  -e, --eol                         Character(s) to use as line terminators.',
+        '                                    [first newline in file, otherwise "\\n]',
+        '  -n, --end-with-newline            End output with newline',
+        '  --editorconfig                    Use EditorConfig to set up the options'
+    ];
+
+    switch (scriptName.split('-').shift()) {
+        case "js":
+            msg.push('  -l, --indent-level                Initial indentation level [0]');
+            msg.push('  -p, --preserve-newlines           Preserve line-breaks (--no-preserve-newlines disables)');
+            msg.push('  -m, --max-preserve-newlines       Number of line-breaks to be preserved in one chunk [10]');
+            msg.push('  -P, --space-in-paren              Add padding spaces within paren, ie. f( a, b )');
+            msg.push('  -E, --space-in-empty-paren        Add a single space inside empty paren, ie. f( )');
+            msg.push('  -j, --jslint-happy                Enable jslint-stricter mode');
+            msg.push('  -a, --space-after-anon-function   Add a space before an anonymous function\'s parens, ie. function ()');
+            msg.push('  -b, --brace-style                 [collapse|expand|end-expand|none][,preserve-inline] [collapse,preserve-inline]');
+            msg.push('  -B, --break-chained-methods       Break chained method calls across subsequent lines');
+            msg.push('  -k, --keep-array-indentation      Preserve array indentation');
+            msg.push('  -x, --unescape-strings            Decode printable characters encoded in xNN notation');
+            msg.push('  -w, --wrap-line-length            Wrap lines at next opportunity after N characters [0]');
+            msg.push('  -X, --e4x                         Pass E4X xml literals through untouched');
+            msg.push('  --good-stuff                      Warm the cockles of Crockford\'s heart');
+            msg.push('  -C, --comma-first                 Put commas at the beginning of new line instead of end');
+            msg.push('  -O, --operator-position           Set operator position (before-newline|after-newline|preserve-newline) [before-newline]');
+            break;
+        case "html":
+            msg.push('  -b, --brace-style                 [collapse|expand|end-expand] ["collapse"]');
+            msg.push('  -I, --indent-inner-html           Indent body and head sections. Default is false.');
+            msg.push('  -H, --indent-handlebars           Indent handlebars. Default is false.');
+            msg.push('  -S, --indent-scripts              [keep|separate|normal] ["normal"]');
+            msg.push('  -w, --wrap-line-length            Wrap lines at next opportunity after N characters [0]');
+            msg.push('  -A, --wrap-attributes             Wrap html tag attributes to new lines [auto|force] ["auto"]');
+            msg.push('  -i, --wrap-attributes-indent-size Indent wrapped tags to after N characters [indent-level]');
+            msg.push('  -p, --preserve-newlines           Preserve line-breaks (--no-preserve-newlines disables)');
+            msg.push('  -m, --max-preserve-newlines       Number of line-breaks to be preserved in one chunk [10]');
+            msg.push('  -U, --unformatted                 List of tags (defaults to inline) that should not be reformatted');
+            msg.push('  -T, --content_unformatted         List of tags (defaults to pre) that its content should not be reformatted');
+            msg.push('  -E, --extra_liners                List of tags (defaults to [head,body,/html] that should have an extra newline');
+            break;
+        case "css":
+            msg.push('  -L, --selector-separator-newline        Add a newline between multiple selectors.');
+            msg.push('  -N, --newline-between-rules             Add a newline between CSS rules.');
+    }
+
+    if (err) {
+        msg.push(err);
+        msg.push('');
+        console.error(msg.join('\n'));
+    } else {
+        console.log(msg.join('\n'));
+    }
+}
+
+// main iterator, {cfg} passed as thisArg of forEach call
+
+function processInputSync(filepath) {
+    var data = '',
+        config = this.cfg,
+        outfile = config.outfile,
+        input;
+
+    // -o passed with no value overwrites
+    if (outfile === true || config.replace) {
+        outfile = filepath;
+    }
+
+    var fileType = getOutputType(outfile, filepath, config.type);
+
+    if (config.editorconfig) {
+        var editorconfig_filepath = filepath;
+
+        if (editorconfig_filepath === '-') {
+            if (outfile) {
+                editorconfig_filepath = outfile;
+            } else {
+                editorconfig_filepath = 'stdin.' + fileType;
+            }
+        }
+
+        debug("EditorConfig is enabled for ", editorconfig_filepath);
+        config = cc(config).snapshot;
+        set_file_editorconfig_opts(editorconfig_filepath, config);
+        debug(config);
+    }
+
+    if (filepath === '-') {
+        input = process.stdin;
+        input.resume();
+
+        input.setEncoding('utf8');
+
+        input.on('data', function(chunk) {
+            data += chunk;
+        });
+
+        input.on('end', function() {
+            makePretty(fileType, data, config, outfile, writePretty); // Where things get beautified
+        });
+    } else {
+        data = fs.readFileSync(filepath, 'utf8');
+        makePretty(fileType, data, config, outfile, writePretty);
+    }
+}
+
+function makePretty(fileType, code, config, outfile, callback) {
+    try {
+        var pretty = beautify[fileType](code, config);
+
+        callback(null, pretty, outfile, config);
+    } catch (ex) {
+        callback(ex);
+    }
+}
+
+function writePretty(err, pretty, outfile, config) {
+    debug('writing ' + outfile);
+    if (err) {
+        console.error(err);
+        process.exit(1);
+    }
+
+    if (outfile) {
+        mkdirp.sync(path.dirname(outfile));
+
+        if (isFileDifferent(outfile, pretty)) {
+            try {
+                fs.writeFileSync(outfile, pretty, 'utf8');
+                logToStdout('beautified ' + path.relative(process.cwd(), outfile), config);
+            } catch (ex) {
+                onOutputError(ex);
+            }
+        } else {
+            logToStdout('beautified ' + path.relative(process.cwd(), outfile) + ' - unchanged', config);
+        }
+    } else {
+        process.stdout.write(pretty);
+    }
+}
+
+function isFileDifferent(filePath, expected) {
+    try {
+        return fs.readFileSync(filePath, 'utf8') !== expected;
+    } catch (ex) {
+        // failing to read is the same as different
+        return true;
+    }
+}
+
+// workaround the fact that nopt.clean doesn't return the object passed in :P
+
+function cleanOptions(data, types) {
+    nopt.clean(data, types);
+    return data;
+}
+
+// error handler for output stream that swallows errors silently,
+// allowing the loop to continue over unwritable files.
+
+function onOutputError(err) {
+    if (err.code === 'EACCES') {
+        console.error(err.path + " is not writable. Skipping!");
+    } else {
+        console.error(err);
+        process.exit(0);
+    }
+}
+
+// turn "--foo_bar" into "foo-bar"
+
+function dasherizeFlag(str) {
+    return str.replace(/^\-+/, '').replace(/_/g, '-');
+}
+
+// translate weird python underscored keys into dashed argv,
+// avoiding single character aliases.
+
+function dasherizeShorthands(hash) {
+    // operate in-place
+    Object.keys(hash).forEach(function(key) {
+        // each key value is an array
+        var val = hash[key][0];
+        // only dasherize one-character shorthands
+        if (key.length === 1 && val.indexOf('_') > -1) {
+            hash[dasherizeFlag(val)] = val;
+        }
+    });
+
+    return hash;
+}
+
+function getOutputType(outfile, filepath, configType) {
+    if (outfile && /\.(js|css|html)$/.test(outfile)) {
+        return outfile.split('.').pop();
+    } else if (filepath !== '-' && /\.(js|css|html)$/.test(filepath)) {
+        return filepath.split('.').pop();
+    } else if (configType) {
+        return configType;
+    } else {
+        throw 'Could not determine appropriate beautifier from file paths: ' + filepath;
+    }
+}
+
+function getScriptName() {
+    return path.basename(process.argv[1]);
+}
+
+function checkType(parsed) {
+    var scriptType = getScriptName().split('-').shift();
+    if (!/^(js|css|html)$/.test(scriptType)) {
+        scriptType = null;
+    }
+
+    debug("executable type:", scriptType);
+
+    var parsedType = parsed.type;
+    debug("parsed type:", parsedType);
+
+    if (!parsedType) {
+        debug("type defaulted:", scriptType);
+        parsed.type = scriptType;
+    }
+}
+
+function checkFiles(parsed) {
+    var argv = parsed.argv;
+    var isTTY = true;
+
+    try {
+        isTTY = process.stdin.isTTY;
+    } catch (ex) {
+        debug("error querying for isTTY:", ex);
+    }
+
+    debug('isTTY: ' + isTTY);
+
+    if (!parsed.files) {
+        parsed.files = [];
+    } else {
+        if (argv.cooked.indexOf('-') > -1) {
+            // strip stdin path eagerly added by nopt in '-f -' case
+            parsed.files.some(removeDashedPath);
+        }
+    }
+
+    if (argv.remain.length) {
+        // assume any remaining args are files
+        argv.remain.forEach(function(f) {
+            if (f !== '-') {
+                parsed.files.push(path.resolve(f));
+            }
+        });
+    }
+
+    if ('string' === typeof parsed.outfile && isTTY && !parsed.files.length) {
+        // use outfile as input when no other files passed in args
+        parsed.files.push(parsed.outfile);
+        // operation is now an implicit overwrite
+        parsed.replace = true;
+    }
+
+    if (!parsed.files.length) {
+        // read stdin by default
+        parsed.files.push('-');
+    }
+    debug('files.length ' + parsed.files.length);
+
+    if (parsed.files.indexOf('-') > -1 && isTTY) {
+        throw 'Must pipe input or define at least one file.';
+    }
+
+    parsed.files.forEach(testFilePath);
+
+    return parsed;
+}
+
+function removeDashedPath(filepath, i, arr) {
+    var found = filepath.lastIndexOf('-') === (filepath.length - 1);
+    if (found) {
+        arr.splice(i, 1);
+    }
+    return found;
+}
+
+function testFilePath(filepath) {
+    try {
+        if (filepath !== "-") {
+            fs.statSync(filepath);
+        }
+    } catch (err) {
+        throw 'Unable to open path "' + filepath + '"';
+    }
+}
+
+function logToStdout(str, config) {
+    if (typeof config.quiet === "undefined" || !config.quiet) {
+        console.log(str);
+    }
+}

node_modules/js-beautify/js/lib/unpackers/javascriptobfuscator_unpacker.js

@@ -0,0 +1,103 @@
+//
+// simple unpacker/deobfuscator for scripts messed up with javascriptobfuscator.com
+// written by Einar Lielmanis <einar@jsbeautifier.org>
+//
+// usage:
+//
+// if (JavascriptObfuscator.detect(some_string)) {
+//     var unpacked = JavascriptObfuscator.unpack(some_string);
+// }
+//
+//
+
+var JavascriptObfuscator = {
+    detect: function(str) {
+        return /^var _0x[a-f0-9]+ ?\= ?\[/.test(str);
+    },
+
+    unpack: function(str) {
+        if (JavascriptObfuscator.detect(str)) {
+            var matches = /var (_0x[a-f\d]+) ?\= ?\[(.*?)\];/.exec(str);
+            if (matches) {
+                var var_name = matches[1];
+                var strings = JavascriptObfuscator._smart_split(matches[2]);
+                str = str.substring(matches[0].length);
+                for (var k in strings) {
+                    str = str.replace(new RegExp(var_name + '\\[' + k + '\\]', 'g'),
+                        JavascriptObfuscator._fix_quotes(JavascriptObfuscator._unescape(strings[k])));
+                }
+            }
+        }
+        return str;
+    },
+
+    _fix_quotes: function(str) {
+        var matches = /^"(.*)"$/.exec(str);
+        if (matches) {
+            str = matches[1];
+            str = "'" + str.replace(/'/g, "\\'") + "'";
+        }
+        return str;
+    },
+
+    _smart_split: function(str) {
+        var strings = [];
+        var pos = 0;
+        while (pos < str.length) {
+            if (str.charAt(pos) === '"') {
+                // new word
+                var word = '';
+                pos += 1;
+                while (pos < str.length) {
+                    if (str.charAt(pos) === '"') {
+                        break;
+                    }
+                    if (str.charAt(pos) === '\\') {
+                        word += '\\';
+                        pos++;
+                    }
+                    word += str.charAt(pos);
+                    pos++;
+                }
+                strings.push('"' + word + '"');
+            }
+            pos += 1;
+        }
+        return strings;
+    },
+
+
+    _unescape: function(str) {
+        // inefficient if used repeatedly or on small strings, but wonderful on single large chunk of text
+        for (var i = 32; i < 128; i++) {
+            str = str.replace(new RegExp('\\\\x' + i.toString(16), 'ig'), String.fromCharCode(i));
+        }
+        str = str.replace(/\\x09/g, "\t");
+        return str;
+    },
+
+    run_tests: function(sanity_test) {
+        var t = sanity_test || new SanityTest();
+
+        t.test_function(JavascriptObfuscator._smart_split, "JavascriptObfuscator._smart_split");
+        t.expect('', []);
+        t.expect('"a", "b"', ['"a"', '"b"']);
+        t.expect('"aaa","bbbb"', ['"aaa"', '"bbbb"']);
+        t.expect('"a", "b\\\""', ['"a"', '"b\\\""']);
+        t.test_function(JavascriptObfuscator._unescape, 'JavascriptObfuscator._unescape');
+        t.expect('\\x40', '@');
+        t.expect('\\x10', '\\x10');
+        t.expect('\\x1', '\\x1');
+        t.expect("\\x61\\x62\\x22\\x63\\x64", 'ab"cd');
+        t.test_function(JavascriptObfuscator.detect, 'JavascriptObfuscator.detect');
+        t.expect('', false);
+        t.expect('abcd', false);
+        t.expect('var _0xaaaa', false);
+        t.expect('var _0xaaaa = ["a", "b"]', true);
+        t.expect('var _0xaaaa=["a", "b"]', true);
+        t.expect('var _0x1234=["a","b"]', true);
+        return t;
+    }
+
+
+};

node_modules/js-beautify/js/lib/unpackers/myobfuscate_unpacker.js

@@ -0,0 +1,90 @@
+//
+// simple unpacker/deobfuscator for scripts messed up with myobfuscate.com
+// You really don't want to obfuscate your scripts there: they're tracking
+// your unpackings, your script gets turned into something like this,
+// as of 2011-04-25:
+/*
+
+    var _escape = 'your_script_escaped';
+    var _111 = document.createElement('script');
+    _111.src = 'http://api.www.myobfuscate.com/?getsrc=ok' +
+        '&ref=' + encodeURIComponent(document.referrer) +
+        '&url=' + encodeURIComponent(document.URL);
+    var 000 = document.getElementsByTagName('head')[0];
+    000.appendChild(_111);
+    document.write(unescape(_escape));
+
+*/
+//
+// written by Einar Lielmanis <einar@jsbeautifier.org>
+//
+// usage:
+//
+// if (MyObfuscate.detect(some_string)) {
+//     var unpacked = MyObfuscate.unpack(some_string);
+// }
+//
+//
+
+var MyObfuscate = {
+    detect: function(str) {
+        if (/^var _?[0O1lI]{3}\=('|\[).*\)\)\);/.test(str)) {
+            return true;
+        }
+        if (/^function _?[0O1lI]{3}\(_/.test(str) && /eval\(/.test(str)) {
+            return true;
+        }
+        return false;
+    },
+
+    unpack: function(str) {
+        if (MyObfuscate.detect(str)) {
+            var __eval = eval;
+            try {
+                eval = function(unpacked) { // jshint ignore:line
+                    if (MyObfuscate.starts_with(unpacked, 'var _escape')) {
+                        // fetch the urlencoded stuff from the script,
+                        var matches = /'([^']*)'/.exec(unpacked);
+                        var unescaped = unescape(matches[1]);
+                        if (MyObfuscate.starts_with(unescaped, '<script>')) {
+                            unescaped = unescaped.substr(8, unescaped.length - 8);
+                        }
+                        if (MyObfuscate.ends_with(unescaped, '</script>')) {
+                            unescaped = unescaped.substr(0, unescaped.length - 9);
+                        }
+                        unpacked = unescaped;
+                    }
+                    // throw to terminate the script
+                    unpacked = "// Unpacker warning: be careful when using myobfuscate.com for your projects:\n" +
+                        "// scripts obfuscated by the free online version may call back home.\n" +
+                        "\n//\n" + unpacked;
+                    throw unpacked;
+                }; // jshint ignore:line
+                __eval(str); // should throw
+            } catch (e) {
+                // well, it failed. we'll just return the original, instead of crashing on user.
+                if (typeof e === "string") {
+                    str = e;
+                }
+            }
+            eval = __eval; // jshint ignore:line
+        }
+        return str;
+    },
+
+    starts_with: function(str, what) {
+        return str.substr(0, what.length) === what;
+    },
+
+    ends_with: function(str, what) {
+        return str.substr(str.length - what.length, what.length) === what;
+    },
+
+    run_tests: function(sanity_test) {
+        var t = sanity_test || new SanityTest();
+
+        return t;
+    }
+
+
+};

node_modules/js-beautify/js/lib/unpackers/p_a_c_k_e_r_unpacker.js

@@ -0,0 +1,83 @@
+//
+// Unpacker for Dean Edward's p.a.c.k.e.r, a part of javascript beautifier
+// written by Einar Lielmanis <einar@jsbeautifier.org>
+//
+// Coincidentally, it can defeat a couple of other eval-based compressors.
+//
+// usage:
+//
+// if (P_A_C_K_E_R.detect(some_string)) {
+//     var unpacked = P_A_C_K_E_R.unpack(some_string);
+// }
+//
+//
+
+var P_A_C_K_E_R = {
+    detect: function(str) {
+        return (P_A_C_K_E_R.get_chunks(str).length > 0);
+    },
+
+    get_chunks: function(str) {
+        var chunks = str.match(/eval\(\(?function\(.*?(,0,\{\}\)\)|split\('\|'\)\)\))($|\n)/g);
+        return chunks ? chunks : [];
+    },
+
+    unpack: function(str) {
+        var chunks = P_A_C_K_E_R.get_chunks(str),
+            chunk;
+        for (var i = 0; i < chunks.length; i++) {
+            chunk = chunks[i].replace(/\n$/, '');
+            str = str.split(chunk).join(P_A_C_K_E_R.unpack_chunk(chunk));
+        }
+        return str;
+    },
+
+    unpack_chunk: function(str) {
+        var unpacked_source = '';
+        var __eval = eval;
+        if (P_A_C_K_E_R.detect(str)) {
+            try {
+                eval = function(s) { // jshint ignore:line
+                    unpacked_source += s;
+                    return unpacked_source;
+                }; // jshint ignore:line
+                __eval(str);
+                if (typeof unpacked_source === 'string' && unpacked_source) {
+                    str = unpacked_source;
+                }
+            } catch (e) {
+                // well, it failed. we'll just return the original, instead of crashing on user.
+            }
+        }
+        eval = __eval; // jshint ignore:line
+        return str;
+    },
+
+    run_tests: function(sanity_test) {
+        var t = sanity_test || new SanityTest();
+
+        var pk1 = "eval(function(p,a,c,k,e,r){e=String;if(!''.replace(/^/,String)){while(c--)r[c]=k[c]||c;k=[function(e){return r[e]}];e=function(){return'\\\\w+'};c=1};while(c--)if(k[c])p=p.replace(new RegExp('\\\\b'+e(c)+'\\\\b','g'),k[c]);return p}('0 2=1',3,3,'var||a'.split('|'),0,{}))";
+        var unpk1 = 'var a=1';
+        var pk2 = "eval(function(p,a,c,k,e,r){e=String;if(!''.replace(/^/,String)){while(c--)r[c]=k[c]||c;k=[function(e){return r[e]}];e=function(){return'\\\\w+'};c=1};while(c--)if(k[c])p=p.replace(new RegExp('\\\\b'+e(c)+'\\\\b','g'),k[c]);return p}('0 2=1',3,3,'foo||b'.split('|'),0,{}))";
+        var unpk2 = 'foo b=1';
+        var pk_broken = "eval(function(p,a,c,k,e,r){BORKBORK;if(!''.replace(/^/,String)){while(c--)r[c]=k[c]||c;k=[function(e){return r[e]}];e=function(){return'\\\\w+'};c=1};while(c--)if(k[c])p=p.replace(new RegExp('\\\\b'+e(c)+'\\\\b','g'),k[c]);return p}('0 2=1',3,3,'var||a'.split('|'),0,{}))";
+        var pk3 = "eval(function(p,a,c,k,e,r){e=String;if(!''.replace(/^/,String)){while(c--)r[c]=k[c]||c;k=[function(e){return r[e]}];e=function(){return'\\\\w+'};c=1};while(c--)if(k[c])p=p.replace(new RegExp('\\\\b'+e(c)+'\\\\b','g'),k[c]);return p}('0 2=1{}))',3,3,'var||a'.split('|'),0,{}))";
+        var unpk3 = 'var a=1{}))';
+
+        t.test_function(P_A_C_K_E_R.detect, "P_A_C_K_E_R.detect");
+        t.expect('', false);
+        t.expect('var a = b', false);
+        t.test_function(P_A_C_K_E_R.unpack, "P_A_C_K_E_R.unpack");
+        t.expect(pk_broken, pk_broken);
+        t.expect(pk1, unpk1);
+        t.expect(pk2, unpk2);
+        t.expect(pk3, unpk3);
+
+        var filler = '\nfiller\n';
+        t.expect(filler + pk1 + "\n" + pk_broken + filler + pk2 + filler, filler + unpk1 + "\n" + pk_broken + filler + unpk2 + filler);
+
+        return t;
+    }
+
+
+};

node_modules/js-beautify/js/lib/unpackers/urlencode_unpacker.js

@@ -0,0 +1,73 @@
+/*global unescape */
+/*jshint curly: false, scripturl: true */
+//
+// trivial bookmarklet/escaped script detector for the javascript beautifier
+// written by Einar Lielmanis <einar@jsbeautifier.org>
+//
+// usage:
+//
+// if (Urlencoded.detect(some_string)) {
+//     var unpacked = Urlencoded.unpack(some_string);
+// }
+//
+//
+
+var isNode = (typeof module !== 'undefined' && module.exports);
+if (isNode) {
+    var SanityTest = require(__dirname + '/../../test/sanitytest');
+}
+
+var Urlencoded = {
+    detect: function(str) {
+        // the fact that script doesn't contain any space, but has %20 instead
+        // should be sufficient check for now.
+        if (str.indexOf(' ') === -1) {
+            if (str.indexOf('%2') !== -1) return true;
+            if (str.replace(/[^%]+/g, '').length > 3) return true;
+        }
+        return false;
+    },
+
+    unpack: function(str) {
+        if (Urlencoded.detect(str)) {
+            if (str.indexOf('%2B') !== -1 || str.indexOf('%2b') !== -1) {
+                // "+" escaped as "%2B"
+                return unescape(str.replace(/\+/g, '%20'));
+            } else {
+                return unescape(str);
+            }
+        }
+        return str;
+    },
+
+
+
+    run_tests: function(sanity_test) {
+        var t = sanity_test || new SanityTest();
+        t.test_function(Urlencoded.detect, "Urlencoded.detect");
+        t.expect('', false);
+        t.expect('var a = b', false);
+        t.expect('var%20a+=+b', true);
+        t.expect('var%20a=b', true);
+        t.expect('var%20%21%22', true);
+        t.expect('javascript:(function(){var%20whatever={init:function(){alert(%22a%22+%22b%22)}};whatever.init()})();', true);
+        t.test_function(Urlencoded.unpack, 'Urlencoded.unpack');
+
+        t.expect('javascript:(function(){var%20whatever={init:function(){alert(%22a%22+%22b%22)}};whatever.init()})();',
+            'javascript:(function(){var whatever={init:function(){alert("a"+"b")}};whatever.init()})();'
+        );
+        t.expect('', '');
+        t.expect('abcd', 'abcd');
+        t.expect('var a = b', 'var a = b');
+        t.expect('var%20a=b', 'var a=b');
+        t.expect('var%20a=b+1', 'var a=b+1');
+        t.expect('var%20a=b%2b1', 'var a=b+1');
+        return t;
+    }
+
+
+};
+
+if (isNode) {
+    module.exports = Urlencoded;
+}

node_modules/js-beautify/js/test/amd-beautify-tests.js

@@ -0,0 +1,62 @@
+/*jshint node:true */
+
+var requirejs = require('requirejs'),
+    SanityTest = require('./sanitytest'),
+    Urlencoded = require('../lib/unpackers/urlencode_unpacker'),
+    run_javascript_tests = require('./generated/beautify-javascript-tests').run_javascript_tests,
+    run_css_tests = require('./generated/beautify-css-tests').run_css_tests,
+    run_html_tests = require('./generated/beautify-html-tests').run_html_tests;
+
+requirejs.config({
+    paths: {
+        'beautify': "..",
+        'beautify-lib': "../lib"
+    }
+});
+
+function amd_beautifier_index_tests(name, test_runner) {
+    console.log('Testing ' + name + ' with node.js Require.js (index file)...');
+    var results = new SanityTest();
+    var beautify = requirejs('beautify/index');
+
+    test_runner(
+        results,
+        Urlencoded,
+        beautify.js,
+        beautify.html,
+        beautify.css);
+
+    console.log(results.results_raw());
+    return results;
+}
+
+function amd_beautifier_tests(name, test_runner) {
+    console.log('Testing ' + name + ' with node.js Require.js (separate file)...');
+    var results = new SanityTest();
+    var js_beautify = requirejs('beautify-lib/beautify'),
+        css_beautify = requirejs('beautify-lib/beautify-css'),
+        html_beautify = requirejs('beautify-lib/beautify-html');
+
+    test_runner(
+        results,
+        Urlencoded,
+        js_beautify.js_beautify,
+        html_beautify.html_beautify,
+        css_beautify.css_beautify);
+
+    console.log(results.results_raw());
+    return results;
+}
+
+
+
+if (require.main === module) {
+    process.exit(
+        amd_beautifier_tests('js-beautifier', run_javascript_tests).get_exitcode() +
+        amd_beautifier_index_tests('js-beautifier', run_javascript_tests).get_exitcode() +
+        amd_beautifier_tests('cs-beautifier', run_css_tests).get_exitcode() +
+        amd_beautifier_index_tests('css-beautifier', run_css_tests).get_exitcode() +
+        amd_beautifier_tests('html-beautifier', run_html_tests).get_exitcode() +
+        amd_beautifier_index_tests('html-beautifier', run_html_tests).get_exitcode()
+    );
+}

node_modules/js-beautify/js/test/node-beautify-html-perf-tests.js

@@ -0,0 +1,51 @@
+/*global js_beautify: true */
+/*jshint node:true */
+/*jshint unused:false */
+
+
+var fs = require('fs'),
+    SanityTest = require('./sanitytest'),
+    Benchmark = require('benchmark'),
+    Urlencoded = require('../lib/unpackers/urlencode_unpacker'),
+    js_beautify = require('../index').js_beautify,
+    css_beautify = require('../index').css_beautify,
+    html_beautify = require('../index').html_beautify;
+
+function node_beautifier_html_tests() {
+    console.log('Testing performance...');
+    var index_html = fs.readFileSync(__dirname + '/../../index.html', 'utf8');
+    var data_attr = fs.readFileSync(__dirname + '/../../test/resources/html-with-base64image.html', 'utf8');
+    var options = {
+        wrap_line_length: 80
+    };
+
+    //warm-up
+    html_beautify(index_html, options);
+    html_beautify(data_attr, options);
+
+    var suite = new Benchmark.Suite();
+
+    suite.add("html-beautify (index.html)", function() {
+            html_beautify(index_html, options);
+        })
+        .add("html-beautify (base64 image)", function() {
+            html_beautify(data_attr, options);
+        })
+        // add listeners
+        .on('cycle', function(event) {
+            console.log(String(event.target));
+        })
+        .on('error', function(event) {
+            return 1;
+        })
+        .on('complete', function(event) {})
+        .run();
+    return 0;
+}
+
+
+
+
+if (require.main === module) {
+    process.exit(node_beautifier_html_tests());
+}

node_modules/js-beautify/js/test/node-beautify-perf-tests.js

@@ -0,0 +1,50 @@
+/*global js_beautify: true */
+/*jshint node:true */
+/*jshint unused:false */
+
+var fs = require('fs'),
+    SanityTest = require('./sanitytest'),
+    Benchmark = require('benchmark'),
+    Urlencoded = require('../lib/unpackers/urlencode_unpacker'),
+    js_beautify = require('../index').js_beautify,
+    css_beautify = require('../index').css_beautify,
+    html_beautify = require('../index').html_beautify;
+
+function node_beautifier_tests() {
+    console.log('Testing performance...');
+    var data = fs.readFileSync(__dirname + '/../../test/resources/underscore.js', 'utf8');
+    var data_min = fs.readFileSync(__dirname + '/../../test/resources/underscore-min.js', 'utf8');
+    var options = {
+        wrap_line_length: 80
+    };
+
+    //warm-up
+    js_beautify(data, options);
+    js_beautify(data_min, options);
+
+    var suite = new Benchmark.Suite();
+
+    suite.add("js-beautify (underscore)", function() {
+            js_beautify(data, options);
+        })
+        .add("js-beautify (underscore-min)", function() {
+            js_beautify(data_min, options);
+        })
+        // add listeners
+        .on('cycle', function(event) {
+            console.log(String(event.target));
+        })
+        .on('error', function(event) {
+            return 1;
+        })
+        .on('complete', function(event) {})
+        .run();
+    return 0;
+}
+
+
+
+
+if (require.main === module) {
+    process.exit(node_beautifier_tests());
+}

node_modules/js-beautify/js/test/node-beautify-tests.js

@@ -0,0 +1,45 @@
+/*jshint node:true */
+
+var SanityTest = require('./sanitytest'),
+    Urlencoded = require('../lib/unpackers/urlencode_unpacker'),
+    run_javascript_tests = require('./generated/beautify-javascript-tests').run_javascript_tests,
+    run_css_tests = require('./generated/beautify-css-tests').run_css_tests,
+    run_html_tests = require('./generated/beautify-html-tests').run_html_tests;
+
+function test_legacy_names() {
+    var beautify = require('../index');
+    var results = new SanityTest();
+
+    console.log('First ensure that legacy import names equal the new ones');
+    results.expect(beautify.js, beautify.js_beautify);
+    results.expect(beautify.css, beautify.css_beautify);
+    results.expect(beautify.html, beautify.html_beautify);
+
+    console.log(results.results_raw());
+    return results;
+}
+
+function node_beautifier_tests(name, test_runner) {
+    console.log('Testing ' + name + ' with node.js CommonJS...');
+    var beautify = require('../index');
+
+    var results = new SanityTest();
+    test_runner(
+        results,
+        Urlencoded,
+        beautify.js,
+        beautify.html,
+        beautify.css);
+
+    console.log(results.results_raw());
+    return results;
+}
+
+if (require.main === module) {
+    process.exit(
+        test_legacy_names() +
+        node_beautifier_tests('js-beautifier', run_javascript_tests).get_exitcode() +
+        node_beautifier_tests('css-beautifier', run_css_tests).get_exitcode() +
+        node_beautifier_tests('html-beautifier', run_html_tests).get_exitcode()
+    );
+}

node_modules/js-beautify/js/test/requirejs-html-beautify.html

@@ -0,0 +1,58 @@
+<!doctype html>
+<html lang="en-US">
+<head>
+	<meta charset="UTF-8">
+	<title></title>
+
+	<script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/require.js/2.1.10/require.min.js"></script>
+	<script type="text/javascript">
+
+		require(["../lib/beautify-html"],function(html_beautify){
+			var input = document.getElementById("input").value;
+			var output = html_beautify.html_beautify(input);
+			document.getElementById("output").innerHTML = output;
+		});
+
+	</script>
+
+	<style type="text/css">
+		#output{
+			border: 1px solid black;
+			height: 300px;
+			width: 100%;
+		}
+		#input{
+			width: 100%;
+			height: 300px;
+		}
+	</style>
+</head>
+<body>
+
+<h1>RequireJS test</h1>
+
+<p>
+	This example loads the html-beautifier by using a relative path in the require call to the beautify-html.js file.
+	(also works works with absolute paths)
+</p>
+
+<pre>
+require(["../lib/beautify-html"],function(html_beautify){
+	var input = document.getElementById("input").value;
+	var output = html_beautify.html_beautify(input);
+	document.getElementById("output").innerHTML = output;
+});
+</pre>
+
+<h2>Input</h2>
+<textarea name="" id="input">
+<ul><li><a href="test"></a></li></ul>
+</textarea>
+
+<h2>Output</h2>
+<textarea name="" id="output">
+
+</textarea>
+
+</body>
+</html>

node_modules/js-beautify/js/test/resources/configerror/.jsbeautifyrc

@@ -0,0 +1,6 @@
+{
+    "indent_size": 11,
+    "indent_char": " "
+    "indent_level": 0,
+    "indent_with_tabs": false
+}

node_modules/js-beautify/js/test/resources/editorconfig/.editorconfig

@@ -0,0 +1,6 @@
+root = true
+
+[*.js]
+indent_style = space
+indent_size = 2
+insert_final_newline = false

node_modules/js-beautify/js/test/resources/editorconfig/cr/.editorconfig

@@ -0,0 +1,3 @@
+
+[*.js]
+end_of_line = cr

node_modules/js-beautify/js/test/resources/editorconfig/crlf/.editorconfig

@@ -0,0 +1,3 @@
+
+[*.js]
+end_of_line = crlf

node_modules/js-beautify/js/test/resources/editorconfig/error/.editorconfig

@@ -0,0 +1 @@
+Random stuff in here to cause parse error

node_modules/js-beautify/js/test/resources/editorconfig/example-base.js

@@ -0,0 +1,3 @@
+function indentMe() {
+    "no, me!"; // indent_size 4, will be beautified to 2 with editorconfig
+}

node_modules/js-beautify/js/test/resources/example1.js

@@ -0,0 +1,3 @@
+function indentMe() {
+"no, me!";
+}

node_modules/js-beautify/js/test/resources/indent11chars/.jsbeautifyrc

@@ -0,0 +1,6 @@
+{
+    "indent_size": 11,
+    "indent_char": " ",
+    "indent_level": 0,
+    "indent_with_tabs": false
+}

node_modules/js-beautify/js/test/run-tests

@@ -0,0 +1,17 @@
+#!/usr/bin/spidermonkey-1.7 -s
+
+//#!/usr/bin/js
+
+// a little helper for testing from command line
+// just run it, it will output the test results
+
+load('js/lib/beautify.js');
+load('js/test/sanitytest.js')
+load('js/test/beautify-tests.js')
+load('js/lib/unpackers/urlencode_unpacker.js')
+
+print(run_beautifier_tests(new SanityTest(), Urlencoded, js_beautify).results_raw())
+
+
+// for nodejs use this from the command line from the main directory:
+// node test/beautify-tests.js

node_modules/js-beautify/js/test/sanitytest.js

@@ -0,0 +1,144 @@
+//
+// simple testing interface
+// written by Einar Lielmanis, einar@jsbeautifier.org
+//
+// usage:
+//
+// var t = new SanityTest(function (x) { return x; }, 'my function');
+// t.expect('input', 'output');
+// t.expect('a', 'a');
+// output_somewhere(t.results()); // good for <pre>, html safe-ish
+// alert(t.results_raw());        // html unescaped
+
+
+function SanityTest(func, name_of_test) {
+
+    var test_func = func || function(x) {
+        return x;
+    };
+
+    var test_name = name_of_test || '';
+
+    var n_failed = 0;
+    var n_succeeded = 0;
+
+    var failures = [];
+
+    this.test_function = function(func, name) {
+        test_func = func;
+        test_name = name || '';
+    };
+
+    this.get_exitcode = function() {
+        return n_succeeded === 0 || n_failed !== 0 ? 1 : 0;
+    };
+
+    this.expect = function(parameters, expected_value) {
+        // multi-parameter calls not supported (I don't need them now).
+        var result = test_func(parameters);
+        // proper array checking is a pain. i'll maybe do it later, compare strings representations instead
+        if ((result === expected_value) || (expected_value instanceof Array && result.join(', ') === expected_value.join(', '))) {
+            n_succeeded += 1;
+        } else {
+            n_failed += 1;
+            failures.push([test_name, parameters, expected_value, result]);
+        }
+    };
+
+
+    this.results_raw = function() {
+        var results = '';
+        if (n_failed === 0) {
+            if (n_succeeded === 0) {
+                results = 'No tests run.';
+            } else {
+                results = 'All ' + n_succeeded + ' tests passed.';
+            }
+        } else {
+            for (var i = 0; i < failures.length; i++) {
+                var f = failures[i];
+                if (f[0]) {
+                    f[0] = f[0] + ' ';
+                }
+                results += '==== ' + f[0] + '============================================================\n';
+                results += '---- input -------\n' + this.prettyprint(f[1]) + '\n';
+                results += '---- expected ----\n' + this.prettyprint(f[2]) + '\n';
+                results += '---- output ------\n' + this.prettyprint(f[3]) + '\n';
+                results += '---- expected-ws ------\n' + this.prettyprint_whitespace(f[2]) + '\n';
+                results += '---- output-ws ------\n' + this.prettyprint_whitespace(f[3]) + '\n';
+                results += '================================================================\n\n';
+            }
+            results += n_failed + ' tests failed.\n';
+        }
+        return results;
+    };
+
+
+    this.results = function() {
+        return this.lazy_escape(this.results_raw());
+    };
+
+    this.prettyprint_whitespace = function(something, quote_strings) {
+        return (this.prettyprint(something, quote_strings)
+            .replace(/\r\n/g, '\\r\n')
+            .replace(/\n/g, '\\n\n')
+            .replace(/\r/g, '\\r\n')
+            .replace(/ /g, '_')
+            .replace(/\t/g, '===|'));
+    };
+
+    this.prettyprint = function(something, quote_strings) {
+        var type = typeof something;
+        switch (type.toLowerCase()) {
+            case 'string':
+                if (quote_strings) {
+                    return "'" + something.replace("'", "\\'") + "'";
+                }
+                return something;
+            case 'number':
+                return '' + something;
+            case 'boolean':
+                return something ? 'true' : 'false';
+            case 'undefined':
+                return 'undefined';
+            case 'object':
+                if (something instanceof Array) {
+                    var x = [];
+                    var expected_index = 0;
+                    for (var k in something) {
+                        if (k === expected_index) {
+                            x.push(this.prettyprint(something[k], true));
+                            expected_index += 1;
+                        } else {
+                            x.push('\n' + k + ': ' + this.prettyprint(something[k], true));
+                        }
+                    }
+                    return '[' + x.join(', ') + ']';
+                }
+                return 'object: ' + something;
+            default:
+                return type + ': ' + something;
+        }
+    };
+
+
+    this.lazy_escape = function(str) {
+        return str.replace(/</g, '&lt;').replace(/\>/g, '&gt;').replace(/\n/g, '<br />');
+    };
+
+
+    this.log = function() {
+        if (window.console) {
+            if (console.firebug) {
+                console.log.apply(console, Array.prototype.slice.call(arguments));
+            } else {
+                console.log.call(console, Array.prototype.slice.call(arguments));
+            }
+        }
+    };
+
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = SanityTest;
+}

node_modules/js-beautify/js/test/shell-smoke-test.sh

@@ -0,0 +1,383 @@
+#!/usr/bin/env bash
+
+REL_SCRIPT_DIR="`dirname \"$0\"`"
+SCRIPT_DIR="`( cd \"$REL_SCRIPT_DIR\" && pwd )`"
+
+
+test_cli_common()
+{
+  echo ----------------------------------------
+  echo Testing common cli behavior...
+  CLI_SCRIPT_NAME=${1:?missing_param}.js
+  CLI_SCRIPT=$SCRIPT_DIR/../bin/$CLI_SCRIPT_NAME
+  echo Script: $CLI_SCRIPT
+
+  # should find the minimal help output
+  $CLI_SCRIPT 2>&1 | grep -q "Must pipe input or define at least one file\." || {
+      $CLI_SCRIPT 2>&1
+      echo "[$CLI_SCRIPT_NAME] Output should be help message."
+      exit 1
+  }
+
+  $CLI_SCRIPT 2> /dev/null && {
+      echo "[$CLI_SCRIPT_NAME (with no parameters)] Return code should be error."
+      exit 1
+  }
+
+  $CLI_SCRIPT -Z 2> /dev/null && {
+      echo "[$CLI_SCRIPT_NAME -Z] Return code for invalid parameter should be error."
+      exit 1
+  }
+
+  $CLI_SCRIPT -h > /dev/null || {
+      echo "[$CLI_SCRIPT_NAME -h] Return code should be success."
+      exit 1
+  }
+
+  $CLI_SCRIPT -v > /dev/null || {
+      echo "[$CLI_SCRIPT_NAME -v] Return code should be success."
+      exit 1
+  }
+
+  MISSING_FILE="$SCRIPT_DIR/../../../js/bin/missing_file"
+  MISSING_FILE_MESSAGE="Unable to open path"
+  $CLI_SCRIPT $MISSING_FILE 2> /dev/null && {
+      echo "[$CLI_SCRIPT_NAME $MISSING_FILE] Return code should be error."
+      exit 1
+  }
+
+  $CLI_SCRIPT $MISSING_FILE 2>&1 | grep -q "$MISSING_FILE_MESSAGE" || {
+      echo "[$CLI_SCRIPT_NAME $MISSING_FILE] Stderr should have useful message."
+      exit 1
+  }
+
+  if [ "`$CLI_SCRIPT $MISSING_FILE 2> /dev/null`" != "" ]; then
+      echo "[$CLI_SCRIPT_NAME $MISSING_FILE] Stdout should have no text."
+      exit 1
+  fi
+
+}
+
+setup_temp()
+{
+    mkdir -p target
+    TEST_TEMP=$PWD/`mktemp -d target/test_temp_XXXX`
+    echo Created $TEST_TEMP...
+}
+
+cleanup()
+{
+    rm -rf $TEST_TEMP && echo Removed $TEST_TEMP...
+    test -z $1 || exit $1
+}
+
+
+test_cli_js_beautify()
+{
+  echo ----------------------------------------
+  echo Testing js-beautify cli behavior...
+  CLI_SCRIPT=$SCRIPT_DIR/../bin/js-beautify.js
+
+  $CLI_SCRIPT $SCRIPT_DIR/../bin/js-beautify.js > /dev/null || {
+      echo "js-beautify output for $SCRIPT_DIR/../bin/js-beautify.js was expected succeed."
+      exit 1
+  }
+
+  $CLI_SCRIPT $SCRIPT_DIR/../bin/css-beautify.js > /dev/null || {
+      echo "js-beautify output for $SCRIPT_DIR/../bin/css-beautify.js was expected succeed."
+      exit 1
+  }
+
+  $CLI_SCRIPT $SCRIPT_DIR/../bin/js-beautify.js | diff $SCRIPT_DIR/../bin/js-beautify.js - || {
+      echo "js-beautify output for $SCRIPT_DIR/../bin/js-beautify.js was expected to be unchanged."
+      exit 1
+  }
+
+  node $SCRIPT_DIR/../lib/cli.js $SCRIPT_DIR/../bin/js-beautify.js | diff $SCRIPT_DIR/../bin/js-beautify.js - || {
+      echo "js-beautify output for $SCRIPT_DIR/../bin/js-beautify.js was expected to be unchanged."
+      exit 1
+  }
+
+  cat $SCRIPT_DIR/../bin/js-beautify.js | $CLI_SCRIPT | diff $SCRIPT_DIR/../bin/js-beautify.js - || {
+      echo "js-beautify output for $SCRIPT_DIR/../bin/js-beautify.js was expected to be unchanged."
+      exit 1
+  }
+
+  cat $SCRIPT_DIR/../bin/js-beautify.js | $CLI_SCRIPT - | diff $SCRIPT_DIR/../bin/js-beautify.js - || {
+      echo "js-beautify output for $SCRIPT_DIR/../bin/js-beautify.js was expected to be unchanged."
+      exit 1
+  }
+
+  setup_temp
+  cat $SCRIPT_DIR/../bin/js-beautify.js | $CLI_SCRIPT -o $TEST_TEMP/js-beautify-pipe.js - && diff $TEST_TEMP/js-beautify-pipe.js $SCRIPT_DIR/../bin/js-beautify.js || {
+      echo "js-beautify output for $SCRIPT_DIR/../bin/js-beautify.js should have been created in $TEST_TEMP/js-beautify-pipe.js."
+      cleanup 1
+  }
+
+  $CLI_SCRIPT -o $TEST_TEMP/js-beautify.js $SCRIPT_DIR/../bin/js-beautify.js && diff $SCRIPT_DIR/../bin/js-beautify.js $TEST_TEMP/js-beautify.js || {
+      echo "js-beautify output for $SCRIPT_DIR/../bin/js-beautify.js should have been created in $TEST_TEMP/js-beautify.js."
+      cleanup 1
+  }
+
+  # ensure new line settings work
+  $CLI_SCRIPT -o $TEST_TEMP/js-beautify-n.js -e '\n' $SCRIPT_DIR/../bin/js-beautify.js
+  $CLI_SCRIPT -o $TEST_TEMP/js-beautify-rn.js -e '\r\n' $TEST_TEMP/js-beautify-n.js
+
+  # ensure eol processed correctly
+  $CLI_SCRIPT -o $TEST_TEMP/js-beautify-n-dash.js --indent-size 2 --eol '\n' $TEST_TEMP/js-beautify-n.js
+  $CLI_SCRIPT -o $TEST_TEMP/js-beautify-rn-dash.js --indent-size 2 --eol '\r\n' $TEST_TEMP/js-beautify-n.js
+  diff -q $TEST_TEMP/js-beautify-n-dash.js $TEST_TEMP/js-beautify-rn-dash.js && {
+      diff $TEST_TEMP/js-beautify-n-dash.js $TEST_TEMP/js-beautify-rn-dash.js | cat -t -e
+      echo "js-beautify output for $TEST_TEMP/js-beautify-n-dash.js and $TEST_TEMP/js-beautify-rn-dash.js was expected to be different."
+      cleanup 1
+  }
+
+  diff -q $TEST_TEMP/js-beautify-n.js $TEST_TEMP/js-beautify-rn.js && {
+      diff $TEST_TEMP/js-beautify-n.js $TEST_TEMP/js-beautify-rn.js | cat -t -e
+      echo "js-beautify output for $TEST_TEMP/js-beautify-n.js and $TEST_TEMP/js-beautify-rn.js was expected to be different."
+      cleanup 1
+  }
+
+  $CLI_SCRIPT $TEST_TEMP/js-beautify-n.js | diff -q $TEST_TEMP/js-beautify-n.js - || {
+      echo "js-beautify output for $TEST_TEMP/js-beautify-n.js was expected to be unchanged."
+      cleanup 1
+  }
+
+  $CLI_SCRIPT -e 'auto' $TEST_TEMP/js-beautify-rn.js | diff -q $TEST_TEMP/js-beautify-rn.js - || {
+      echo "js-beautify output for $TEST_TEMP/js-beautify-rn.js was expected to be unchanged."
+      cleanup 1
+  }
+
+  # EditorConfig related tests
+  cp -r js/test/resources/editorconfig $TEST_TEMP/
+  $CLI_SCRIPT -o $TEST_TEMP/editorconfig/example.js --end-with-newline --indent-size 4 -e '\n' $TEST_TEMP/editorconfig/example-base.js
+  $CLI_SCRIPT -o $TEST_TEMP/editorconfig/example-ec.js --indent-size 2 -e '\n' $TEST_TEMP/editorconfig/example-base.js
+
+  $CLI_SCRIPT -o $TEST_TEMP/editorconfig/cr/example.js --end-with-newline --indent-size 4 -e '\n' $TEST_TEMP/editorconfig/example-base.js
+  $CLI_SCRIPT -o $TEST_TEMP/editorconfig/cr/example-ec.js --indent-size 2 -e '\r' $TEST_TEMP/editorconfig/example-base.js
+
+  $CLI_SCRIPT -o $TEST_TEMP/editorconfig/crlf/example.js --end-with-newline --indent-size 4 -e '\n' $TEST_TEMP/editorconfig/example-base.js
+  $CLI_SCRIPT -o $TEST_TEMP/editorconfig/crlf/example-ec.js --indent-size 2 -e '\r\n' $TEST_TEMP/editorconfig/example-base.js
+
+  $CLI_SCRIPT -o $TEST_TEMP/editorconfig/error/example.js --end-with-newline --indent-size 4 -e '\n' $TEST_TEMP/editorconfig/example-base.js
+
+  pushd $TEST_TEMP/editorconfig
+
+  cd $TEST_TEMP/editorconfig/error
+  $CLI_SCRIPT --editorconfig $TEST_TEMP/js-beautify-n.js \
+  > /dev/null || {
+      echo "Invalid editorconfig file should not report error (consistent with the EditorConfig)."
+      cleanup 1
+  }
+
+  $CLI_SCRIPT --editorconfig example.js \
+  > /dev/null || {
+      echo "Invalid editorconfig file should not report error (consistent with the EditorConfig)."
+      cleanup 1
+  }
+
+  # TODO: EditorConfig setting should NOT overide cli setting, but that is
+  # the current by-design behavior, due to code limitations.
+
+  # file input scenario
+  SCENARIO=a
+  cd $TEST_TEMP/editorconfig || exit 1
+  $CLI_SCRIPT --end-with-newline --indent-size 6 --editorconfig -o example-${SCENARIO}.js example.js \
+  && diff -q example-${SCENARIO}.js example-ec.js || {
+      echo "EditorConfig setting should overide cli setting."
+      diff example-${SCENARIO}.js example-ec.js | cat -t -e
+      cleanup 1
+  }
+
+  cd $TEST_TEMP/editorconfig/crlf || exit 1
+  $CLI_SCRIPT --end-with-newline --indent-size 6 --editorconfig -o example-${SCENARIO}.js example.js \
+  && diff -q example-${SCENARIO}.js example-ec.js || {
+      echo "EditorConfig setting should overide cli setting."
+      diff example-${SCENARIO}.js example-ec.js | cat -t -e
+      cleanup 1
+  }
+
+  cd $TEST_TEMP/editorconfig/cr || exit 1
+  $CLI_SCRIPT --end-with-newline --indent-size 6 --editorconfig -o example-${SCENARIO}.js example.js \
+  && diff -q example-${SCENARIO}.js example-ec.js || {
+      echo "EditorConfig setting should overide cli setting."
+      diff example-${SCENARIO}.js example-ec.js | cat -t -e
+      cleanup 1
+  }
+
+  # stdin input to stdout scenario
+  SCENARIO=b
+  cd $TEST_TEMP/editorconfig || exit 1
+  echo "cat example.js | $CLI_SCRIPT --end-with-newline --indent-size 6 --editorconfig > example-${SCENARIO}.js"
+  cat example.js | $CLI_SCRIPT --end-with-newline --indent-size 6 --editorconfig > example-${SCENARIO}.js \
+  && diff -q example-${SCENARIO}.js example-ec.js || {
+      echo "EditorConfig setting should overide cli setting."
+      diff example-${SCENARIO}.js example-ec.js | cat -t -e
+      cleanup 1
+  }
+
+  cd $TEST_TEMP/editorconfig/crlf || exit 1
+  echo "cat example.js | $CLI_SCRIPT --end-with-newline --indent-size 6 --editorconfig > example-${SCENARIO}.js"
+  cat example.js | $CLI_SCRIPT --end-with-newline --indent-size 6 --editorconfig > example-${SCENARIO}.js \
+  && diff -q example-${SCENARIO}.js example-ec.js || {
+      echo "EditorConfig setting should overide cli setting."
+      diff example-${SCENARIO}.js example-ec.js | cat -t -e
+      cleanup 1
+  }
+
+  cd $TEST_TEMP/editorconfig/cr || exit 1
+  echo "cat example.js | $CLI_SCRIPT --end-with-newline --indent-size 6 --editorconfig > example-${SCENARIO}.js"
+  cat example.js | $CLI_SCRIPT --end-with-newline --indent-size 6 --editorconfig > example-${SCENARIO}.js \
+  && diff -q example-${SCENARIO}.js example-ec.js || {
+      echo "EditorConfig setting should overide cli setting."
+      diff example-${SCENARIO}.js example-ec.js | cat -t -e
+      cleanup 1
+  }
+
+
+  # stdin input to file scenario
+  SCENARIO=c
+  cd $TEST_TEMP/editorconfig || exit 1
+  echo "cat example.js | $CLI_SCRIPT --end-with-newline --indent-size 6 --editorconfig -o example-${SCENARIO}.js"
+  cat example.js | $CLI_SCRIPT --end-with-newline --indent-size 6 --editorconfig -o example-${SCENARIO}.js - \
+  && diff -q example-${SCENARIO}.js example-ec.js || {
+      echo "EditorConfig setting should overide cli setting."
+      diff example-${SCENARIO}.js example-ec.js | cat -t -e
+      cleanup 1
+  }
+
+  cd $TEST_TEMP/editorconfig/crlf || exit 1
+  cat example.js | $CLI_SCRIPT --end-with-newline --indent-size 6 --editorconfig -o example-${SCENARIO}.js - \
+  && diff -q example-${SCENARIO}.js example-ec.js || {
+      echo "EditorConfig setting should overide cli setting."
+      diff example-${SCENARIO}.js example-ec.js | cat -t -e
+      cleanup 1
+  }
+
+  cd $TEST_TEMP/editorconfig/cr || exit 1
+  cat example.js | $CLI_SCRIPT --end-with-newline --indent-size 6 --editorconfig -o example-${SCENARIO}.js - \
+  && diff -q example-${SCENARIO}.js example-ec.js || {
+      echo "EditorConfig setting should overide cli setting."
+      diff example-${SCENARIO}.js example-ec.js | cat -t -e
+      cleanup 1
+  }
+
+  popd
+  # End EditorConfig
+
+  # ensure unchanged files are not overwritten
+  $CLI_SCRIPT -o $TEST_TEMP/js-beautify.js $SCRIPT_DIR/../bin/js-beautify.js
+  cp -p $TEST_TEMP/js-beautify.js $TEST_TEMP/js-beautify-old.js
+  touch $TEST_TEMP/js-beautify.js
+  sleep 2
+  touch $TEST_TEMP/js-beautify-old.js
+  $CLI_SCRIPT -r $TEST_TEMP/js-beautify.js && test $TEST_TEMP/js-beautify.js -nt $TEST_TEMP/js-beautify-old.js && {
+      echo "js-beautify should not replace unchanged file $TEST_TEMP/js-beautify.js when using -r"
+      cleanup 1
+  }
+
+  $CLI_SCRIPT -o $TEST_TEMP/js-beautify.js $TEST_TEMP/js-beautify.js && test $TEST_TEMP/js-beautify.js -nt $TEST_TEMP/js-beautify-old.js && {
+      echo "js-beautify should not replace unchanged file $TEST_TEMP/js-beautify.js when using -o and same file name"
+      cleanup 1
+  }
+
+  $CLI_SCRIPT -o $TEST_TEMP/js-beautify.js $TEST_TEMP/js-beautify-old.js && test $TEST_TEMP/js-beautify.js -nt $TEST_TEMP/js-beautify-old.js && {
+      echo "js-beautify should not replace unchanged file $TEST_TEMP/js-beautify.js when using -o and different file name"
+      cleanup 1
+  }
+
+  $CLI_SCRIPT $SCRIPT_DIR/../bin/css-beautify.js | diff -q $SCRIPT_DIR/../bin/css-beautify.js - && {
+      echo "js-beautify output for $SCRIPT_DIR/../bin/css-beautify.js was expected to be different."
+      cleanup 1
+  }
+
+  unset HOME
+  unset USERPROFILE
+  $CLI_SCRIPT -o $TEST_TEMP/example1-default.js $SCRIPT_DIR/resources/example1.js || exit 1
+
+  $CLI_SCRIPT -o $TEST_TEMP/example1-sanity.js $TEST_TEMP/example1-default.js || exit 1
+  diff -q $TEST_TEMP/example1-default.js $TEST_TEMP/example1-sanity.js || {
+      echo "js-beautify output for $TEST_TEMP/example1-default.js was expected to be identical after no change in settings."
+      cleanup 1
+  }
+
+  cd $SCRIPT_DIR/resources/configerror
+  $CLI_SCRIPT $TEST_TEMP/example1-default.js 2>&1 |  grep -q "Error while loading beautifier configuration\." || {
+      echo "js-beautify output for $TEST_TEMP/example1-default.js was expected to be configration load error message."
+      cleanup 1
+  }
+
+  cd $SCRIPT_DIR/resources/indent11chars
+  $CLI_SCRIPT $TEST_TEMP/example1-default.js | diff -q $TEST_TEMP/example1-default.js - && {
+      echo "js-beautify output for $TEST_TEMP/example1-default.js was expected to be different based on CWD settings."
+      cleanup 1
+  }
+
+  cd $SCRIPT_DIR/resources/indent11chars/subDir1/subDir2
+  $CLI_SCRIPT $TEST_TEMP/example1-default.js | diff -q $TEST_TEMP/example1-default.js - && {
+      echo "js-beautify output for $TEST_TEMP/example1-default.js was expected to be different based on CWD parent folder settings."
+      cleanup 1
+  }
+  cd $SCRIPT_DIR
+
+  export HOME=$SCRIPT_DIR/resources/indent11chars
+  $CLI_SCRIPT $TEST_TEMP/example1-default.js | diff -q $TEST_TEMP/example1-default.js - && {
+      echo "js-beautify output for $TEST_TEMP/example1-default.js was expected to be different based on HOME settings."
+      cleanup 1
+  }
+
+  $CLI_SCRIPT -o $TEST_TEMP/example1-indent11chars.js $TEST_TEMP/example1-default.js
+
+  unset HOME
+  export USERPROFILE=$SCRIPT_DIR/resources/indent11chars
+  # node -p 'process.env["USERPROFILE"] || process.env["HOME"] || "unset"'
+  $CLI_SCRIPT $TEST_TEMP/example1-default.js | diff -q $TEST_TEMP/example1-indent11chars.js - || {
+      echo "js-beautify output for $TEST_TEMP/example1-default.js was expected to be identical for same HOME and USERPROFILE settings."
+      cleanup 1
+  }
+
+  $CLI_SCRIPT $TEST_TEMP/example1-default.js | diff -q $TEST_TEMP/example1-default.js - && {
+      echo "js-beautify output for $TEST_TEMP/example1-default.js was expected to be different based on USERPROFILE settings."
+      cleanup 1
+  }
+
+  cleanup
+}
+
+test_smoke_js_beautify()
+{
+  echo ----------------------------------------
+  echo Testing js-beautify functionality...
+  node $SCRIPT_DIR/node-beautify-tests.js || exit 1
+  node $SCRIPT_DIR/amd-beautify-tests.js || exit 1
+}
+
+
+test_performance_js_beautify()
+{
+  echo ----------------------------------------
+  echo Testing js-beautify performance...
+  node $SCRIPT_DIR/node-beautify-perf-tests.js || exit 1
+  echo ----------------------------------------
+}
+
+test_performance_html_beautify()
+{
+  echo ----------------------------------------
+  echo Testing html-beautify performance...
+  node $SCRIPT_DIR/node-beautify-html-perf-tests.js || exit 1
+  echo ----------------------------------------
+}
+
+test_cli_common css-beautify
+test_cli_common html-beautify
+test_cli_common js-beautify
+
+test_cli_js_beautify
+test_smoke_js_beautify
+test_performance_js_beautify
+test_performance_html_beautify
+
+echo ----------------------------------------
+echo $0 - PASSED.
+echo ----------------------------------------