@wavemaker/angular-codegen 11.8.0-next.141677 → 11.8.0-next.141680

package/node_modules/js-beautify/test/data/javascript/tests.js

@@ -1,3083 +0,0 @@
-/*
-  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.
-*/
-
-var inputlib = require('./inputlib');
-
-exports.test_data = {
-    default_options: [
-        { name: "indent_size", value: "4" },
-        { name: "indent_char", value: "' '" },
-        { name: "preserve_newlines", value: "true" },
-        { name: "jslint_happy", value: "false" },
-        { name: "keep_array_indentation", value: "false" },
-        { name: "brace_style", value: "'collapse'" },
-        { name: "operator_position", value: "'before-newline'" }
-    ],
-    groups: [{
-        name: "Unicode Support",
-        description: "",
-        tests: [{
-            unchanged: "var ' + unicode_char(3232) + '_' + unicode_char(3232) + ' = \"hi\";"
-        }, {
-            unchanged: [
-                "var ' + unicode_char(228) + 'x = {",
-                "    ' + unicode_char(228) + 'rgerlich: true",
-                "};"
-            ]
-        }]
-    }, {
-        name: "Test template and continuation strings",
-        description: "",
-        tests: [
-            { unchanged: '`This is a ${template} string.`' },
-            { unchanged: '`This\n  is\n  a\n  ${template}\n  string.`' },
-            { unchanged: 'a = `This is a continuation\\\\\nstring.`' },
-            { unchanged: 'a = "This is a continuation\\\\\nstring."' },
-            { unchanged: '`SELECT\n  nextval(\\\'${this.options.schema ? `${this.options.schema}.` : \\\'\\\'}"${this.tableName}_${this.autoIncrementField}_seq"\\\'::regclass\n  ) nextval;`' },
-            {
-                comment: 'Tests for #1030',
-                unchanged: [
-                    'const composeUrl = (host) => {',
-                    '    return `${host `test`}`;',
-                    '};'
-                ]
-            }, {
-                unchanged: [
-                    'const composeUrl = (host, api, key, data) => {',
-                    '    switch (api) {',
-                    '        case "Init":',
-                    '            return `${host}/vwapi/Init?VWID=${key}&DATA=${encodeURIComponent(',
-                    '                Object.keys(data).map((k) => `${k}=${ data[k]}` ).join(";")',
-                    '            )}`;',
-                    '        case "Pay":',
-                    '            return `${host}/vwapi/Pay?SessionId=${par}`;',
-                    '    };',
-                    '};'
-                ]
-            }
-        ]
-    }, {
-        name: "ES7 Decorators",
-        description: "Permit ES7 decorators, which are invoked with a leading \"@\".",
-        tests: [
-            { unchanged: '@foo' },
-            { unchanged: '@foo(bar)' },
-            {
-                unchanged: [
-                    '@foo(function(k, v) {',
-                    '    implementation();',
-                    '})'
-                ]
-            }
-        ]
-    }, {
-        name: "ES7 exponential",
-        description: "ES7 exponential",
-        tests: [
-            { unchanged: 'x ** 2' },
-            { unchanged: 'x ** -2' }
-        ]
-    }, {
-        name: "Spread operator",
-        description: "Spread operator",
-        options: [
-            { name: 'brace_style', value: '"collapse,preserve-inline"' }
-        ],
-        tests: [
-            { unchanged: 'const m = { ...item, c: 3 };' },
-            { unchanged: 'const m = {\n    ...item,\n    c: 3\n};' },
-            { unchanged: 'const m = { c: 3, ...item };' },
-            { unchanged: 'const m = [...item, 3];' },
-            { unchanged: 'const m = [3, ...item];' }
-        ]
-    }, {
-        name: "Object literal shorthand functions",
-        description: "Object literal shorthand functions",
-        tests: [
-            { unchanged: 'return {\n    foo() {\n        return 42;\n    }\n}' },
-            {
-                unchanged: [
-                    'var foo = {',
-                    '    * bar() {',
-                    '        yield 42;',
-                    '    }',
-                    '};'
-                ]
-            },
-            {
-                input: 'var foo = {bar(){return 42;},*barGen(){yield 42;}};',
-                output: ['var foo = {',
-                    '    bar() {',
-                    '        return 42;',
-                    '    },',
-                    '    * barGen() {',
-                    '        yield 42;',
-                    '    }',
-                    '};'
-                ]
-            }, {
-                comment: 'also handle generator shorthand in class - #1013',
-                unchanged: [
-                    'class A {',
-                    '    fn() {',
-                    '        return true;',
-                    '    }',
-                    '',
-                    '    * gen() {',
-                    '        return true;',
-                    '    }',
-                    '}'
-                ]
-            }, {
-                unchanged: [
-                    'class A {',
-                    '    * gen() {',
-                    '        return true;',
-                    '    }',
-                    '',
-                    '    fn() {',
-                    '        return true;',
-                    '    }',
-                    '}'
-                ]
-            }
-        ]
-    }, {
-        name: "End With Newline",
-        description: "",
-        matrix: [{
-                options: [
-                    { name: "end_with_newline", value: "true" }
-                ],
-                eof: '\n'
-            }, {
-                options: [
-                    { name: "end_with_newline", value: "false" }
-                ],
-                eof: ''
-            }
-
-        ],
-        tests: [
-            { fragment: true, input: '', output: '{{eof}}' },
-            { fragment: true, input: '   return .5', output: '   return .5{{eof}}' },
-            { fragment: true, input: '   \n\nreturn .5\n\n\n\n', output: '   return .5{{eof}}' },
-            { fragment: true, input: '\n', output: '{{eof}}' }
-        ],
-    }, {
-        name: "Support simple language specific option inheritance/overriding",
-        description: "Support simple language specific option inheritance/overriding",
-        matrix: [{
-                options: [
-                    { name: "js", value: "{ 'indent_size': 3 }" },
-                    { name: "css", value: "{ 'indent_size': 5 }" }
-                ],
-                j: '   '
-            },
-            {
-                options: [
-                    { name: "html", value: "{ 'js': { 'indent_size': 3 }, 'css': { 'indent_size': 5 } }" }
-                ],
-                j: '    '
-            },
-            {
-                options: [
-                    { name: "indent_size", value: "9" },
-                    { name: "html", value: "{ 'js': { 'indent_size': 3 }, 'css': { 'indent_size': 5 }, 'indent_size': 2}" },
-                    { name: "js", value: "{ 'indent_size': 4 }" },
-                    { name: "css", value: "{ 'indent_size': 3 }" }
-                ],
-                j: '    '
-            }
-        ],
-        tests: [{
-            unchanged: [
-                'if (a == b) {',
-                '{{j}}test();',
-                '}'
-            ]
-        }, ]
-    }, {
-        name: "Brace style permutations",
-        description: "",
-        template: "< >",
-        matrix: [
-            // brace_style collapse,preserve-inline - Should preserve if no newlines
-            {
-                options: [
-                    { name: "brace_style", value: "'collapse,preserve-inline'" }
-                ],
-                ibo: '',
-                iao: '',
-                ibc: '',
-                iac: '',
-                obo: ' ',
-                oao: ' ',
-                obc: ' ',
-                oac: ' '
-            },
-            {
-                options: [
-                    { name: "brace_style", value: "'collapse,preserve-inline'" }
-                ],
-                ibo: '\n',
-                iao: '\n',
-                ibc: '\n',
-                iac: '\n',
-                obo: ' ',
-                oao: '\n    ',
-                obc: '\n',
-                oac: ' '
-            },
-
-            // brace_style collapse - Shouldn't preserve if no newlines (uses collapse styling)
-            {
-                options: [
-                    { name: "brace_style", value: "'collapse'" }
-                ],
-                ibo: '',
-                iao: '',
-                ibc: '',
-                iac: '',
-                obo: ' ',
-                oao: '\n    ',
-                obc: '\n',
-                oac: ' '
-            },
-            {
-                options: [
-                    { name: "brace_style", value: "'collapse'" }
-                ],
-                ibo: '\n',
-                iao: '\n',
-                ibc: '\n',
-                iac: '\n',
-                obo: ' ',
-                oao: '\n    ',
-                obc: '\n',
-                oac: ' '
-            },
-        ],
-        tests: [{
-                input: 'var a =<ibo>{<iao>a: 2<ibc>}<iac>;\nvar a =<ibo>{<iao>a: 2<ibc>}<iac>;',
-                output: 'var a =<obo>{<oao>a: 2<obc>};\nvar a =<obo>{<oao>a: 2<obc>};'
-            },
-            // {
-            //     input: 'var a =<ibo>{<iao>a:<ibo>{<iao>a:<ibo>{<iao>a:2<ibc>}<iac><ibc>}<iac>}<iac>;\nvar a =<ibo>{<iao>a:<ibo>{<iao>a:<ibo>{<iao>a:2<ibc>}<iac><ibc>}<iac>}<iac>;',
-            //     output: 'var a =<obo>{<oao>a:<obo>{<oao>a:<obo>{<oao>a: 2<obc>}<oac><obc>}<oac><obc>};\nvar a =<obo>{<oao>a:<obo>{<oao>a:<obo>{<oao>a: 2<obc>}<oac><obc>}<oac><obc>};'
-            // },
-            {
-                input: '//case 1\nif (a == 1)<ibo>{}\n//case 2\nelse if (a == 2)<ibo>{}',
-                output: '//case 1\nif (a == 1)<obo>{}\n//case 2\nelse if (a == 2)<obo>{}'
-            },
-            {
-                input: 'if(1)<ibo>{<iao>2<ibc>}<iac>else<ibo>{<iao>3<ibc>}',
-                output: 'if (1)<obo>{<oao>2<obc>}<oac>else<obo>{<oao>3<obc>}'
-            },
-            {
-                input: 'try<ibo>{<iao>a();<ibc>}<iac>' +
-                    'catch(b)<ibo>{<iao>c();<ibc>}<iac>' +
-                    'catch(d)<ibo>{}<iac>' +
-                    'finally<ibo>{<iao>e();<ibc>}',
-                output:
-                    // expected
-                    'try<obo>{<oao>a();<obc>}<oac>' +
-                    'catch (b)<obo>{<oao>c();<obc>}<oac>' +
-                    'catch (d)<obo>{}<oac>' +
-                    'finally<obo>{<oao>e();<obc>}'
-            }
-        ],
-    }, {
-        name: "Comma-first option",
-        description: "Put commas at the start of lines instead of the end",
-        matrix: [{
-            options: [
-                { name: "comma_first", value: "false" }
-            ],
-            c0: ',\n',
-            c1: ',\n    ',
-            c2: ',\n        ',
-            c3: ',\n            ',
-            // edge cases where engine bails
-            f1: '    ,\n    '
-        }, {
-            options: [
-                { name: "comma_first", value: "true" }
-            ],
-            c0: '\n, ',
-            c1: '\n    , ',
-            c2: '\n        , ',
-            c3: '\n            , ',
-            // edge cases where engine bails
-            f1: ', '
-        }],
-        tests: [
-            { input: '{a:1, b:2}', output: "{\n    a: 1{{c1}}b: 2\n}" },
-            { input: 'var a=1, b=c[d], e=6;', output: 'var a = 1{{c1}}b = c[d]{{c1}}e = 6;' },
-            { input: "for(var a=1,b=2,c=3;d<3;d++)\ne", output: "for (var a = 1, b = 2, c = 3; d < 3; d++)\n    e" },
-            { input: "for(var a=1,b=2,\nc=3;d<3;d++)\ne", output: "for (var a = 1, b = 2{{c2}}c = 3; d < 3; d++)\n    e" },
-            { unchanged: 'function foo() {\n    return [\n        "one"{{c2}}"two"\n    ];\n}' },
-            { input: 'a=[[1,2],[4,5],[7,8]]', output: "a = [\n    [1, 2]{{c1}}[4, 5]{{c1}}[7, 8]\n]" },
-            { input: 'a=[[1,2],[4,5],[7,8],]', output: "a = [\n    [1, 2]{{c1}}[4, 5]{{c1}}[7, 8]{{c0}}]" },
-            {
-                input: 'a=[[1,2],[4,5],function(){},[7,8]]',
-                output: "a = [\n    [1, 2]{{c1}}[4, 5]{{c1}}function() {}{{c1}}[7, 8]\n]"
-            },
-            {
-                input: 'a=[[1,2],[4,5],function(){},function(){},[7,8]]',
-                output: "a = [\n    [1, 2]{{c1}}[4, 5]{{c1}}function() {}{{c1}}function() {}{{c1}}[7, 8]\n]"
-            },
-            {
-                input: 'a=[[1,2],[4,5],function(){},[7,8]]',
-                output: "a = [\n    [1, 2]{{c1}}[4, 5]{{c1}}function() {}{{c1}}[7, 8]\n]"
-            },
-            {
-                input: 'a=[b,c,function(){},function(){},d]',
-                output: "a = [b, c, function() {}, function() {}, d]"
-            },
-            {
-                input: 'a=[b,c,\nfunction(){},function(){},d]',
-                output: "a = [b, c{{c1}}function() {}{{c1}}function() {}{{c1}}d\n]"
-            },
-            { input: 'a=[a[1],b[4],c[d[7]]]', output: "a = [a[1], b[4], c[d[7]]]" },
-            { input: '[1,2,[3,4,[5,6],7],8]', output: "[1, 2, [3, 4, [5, 6], 7], 8]" },
-
-            {
-                input: '[[["1","2"],["3","4"]],[["5","6","7"],["8","9","0"]],[["1","2","3"],["4","5","6","7"],["8","9","0"]]]',
-                output: '[\n    [\n        ["1", "2"]{{c2}}["3", "4"]\n    ]{{c1}}[\n        ["5", "6", "7"]{{c2}}["8", "9", "0"]\n    ]{{c1}}[\n        ["1", "2", "3"]{{c2}}["4", "5", "6", "7"]{{c2}}["8", "9", "0"]\n    ]\n]'
-            },
-            {
-                input: [
-                    'changeCollection.add({',
-                    '    name: "Jonathan" // New line inserted after this line on every save',
-                    '    , age: 25',
-                    '});'
-                ],
-                output: [
-                    'changeCollection.add({',
-                    '    name: "Jonathan" // New line inserted after this line on every save',
-                    '    {{f1}}age: 25',
-                    '});'
-                ]
-            },
-            {
-                input: [
-                    'changeCollection.add(',
-                    '    function() {',
-                    '        return true;',
-                    '    },',
-                    '    function() {',
-                    '        return true;',
-                    '    }',
-                    ');'
-                ],
-                output: [
-                    'changeCollection.add(',
-                    '    function() {',
-                    '        return true;',
-                    '    }{{c1}}function() {',
-                    '        return true;',
-                    '    }',
-                    ');'
-                ]
-            },
-        ],
-    }, {
-        name: "Space in parens tests",
-        description: "put space inside parens",
-        matrix: [{
-            options: [
-                { name: "space_in_paren", value: "false" },
-                { name: "space_in_empty_paren", value: "false" },
-            ],
-            s: '',
-            e: '',
-        }, {
-            options: [
-                { name: "space_in_paren", value: "false" },
-                { name: "space_in_empty_paren", value: "true" },
-            ],
-            s: '',
-            e: '',
-        }, {
-            options: [
-                { name: "space_in_paren", value: "true" },
-                { name: "space_in_empty_paren", value: "false" },
-            ],
-            s: ' ',
-            e: '',
-        }, {
-            options: [
-                { name: "space_in_paren", value: "true" },
-                { name: "space_in_empty_paren", value: "true" },
-            ],
-            s: ' ',
-            e: ' ',
-        }],
-        tests: [{
-                input: 'if(p) foo(a,b);',
-                output: 'if ({{s}}p{{s}}) foo({{s}}a, b{{s}});'
-            },
-            {
-                input: 'try{while(true){willThrow()}}catch(result)switch(result){case 1:++result }',
-                output: 'try {\n    while ({{s}}true{{s}}) {\n        willThrow({{e}})\n    }\n} catch ({{s}}result{{s}}) switch ({{s}}result{{s}}) {\n    case 1:\n        ++result\n}'
-            },
-            {
-                input: '((e/((a+(b)*c)-d))^2)*5;',
-                output: '({{s}}({{s}}e / ({{s}}({{s}}a + ({{s}}b{{s}}) * c{{s}}) - d{{s}}){{s}}) ^ 2{{s}}) * 5;'
-            },
-            {
-                input: 'function f(a,b) {if(a) b()}function g(a,b) {if(!a) b()}',
-                output: 'function f({{s}}a, b{{s}}) {\n    if ({{s}}a{{s}}) b({{e}})\n}\n\nfunction g({{s}}a, b{{s}}) {\n    if ({{s}}!a{{s}}) b({{e}})\n}'
-            },
-            {
-                input: 'a=[];',
-                output: 'a = [{{e}}];'
-            },
-            {
-                input: 'a=[b,c,d];',
-                output: 'a = [{{s}}b, c, d{{s}}];'
-            },
-            {
-                input: 'a= f[b];',
-                output: 'a = f[{{s}}b{{s}}];'
-            },
-            {
-                input: [
-                    '{',
-                    '    files: [ {',
-                    '        expand: true,',
-                    '        cwd: "www/gui/",',
-                    '        src: [ "im/design_standards/*.*" ],',
-                    '        dest: "www/gui/build"',
-                    '    } ]',
-                    '}'
-                ],
-                output: [
-                    '{',
-                    '    files: [{{s}}{',
-                    '        expand: true,',
-                    '        cwd: "www/gui/",',
-                    '        src: [{{s}}"im/design_standards/*.*"{{s}}],',
-                    '        dest: "www/gui/build"',
-                    '    }{{s}}]',
-                    '}'
-                ],
-            },
-        ],
-    }, {
-        name: "operator_position option - ensure no neswlines if preserve_newlines is false",
-        matrix: [{
-            options: [
-                { name: "operator_position", value: "'before-newline'" },
-                { name: "preserve_newlines", value: "false" }
-            ]
-        }, {
-            options: [
-                { name: "operator_position", value: "'after-newline'" },
-                { name: "preserve_newlines", value: "false" }
-            ]
-        }, {
-            options: [
-                { name: "operator_position", value: "'preserve-newline'" },
-                { name: "preserve_newlines", value: "false" }
-            ]
-        }],
-        tests: [{
-            unchanged: inputlib.operator_position.sanity
-        }, {
-            input: inputlib.operator_position.comprehensive,
-            output: inputlib.operator_position.sanity,
-        }]
-    }, {
-        name: "operator_position option - set to 'before-newline' (default value)",
-        tests: [{
-            comment: 'comprehensive, various newlines',
-            input: inputlib.operator_position.comprehensive,
-            output: [
-                'var res = a + b -',
-                '    c /',
-                '    d * e %',
-                '    f;',
-                'var res = g & h |',
-                '    i ^',
-                '    j;',
-                'var res = (k &&',
-                '        l ||',
-                '        m) ?',
-                '    n :',
-                '    o;',
-                'var res = p >>',
-                '    q <<',
-                '    r >>>',
-                '    s;',
-                'var res = t',
-                '',
-                '    ===',
-                '    u !== v !=',
-                '    w ==',
-                '    x >=',
-                '    y <= z > aa <',
-                '    ab;',
-                'ac +',
-                '    -ad'
-            ]
-        }, {
-            comment: 'colon special case',
-            input: inputlib.operator_position.colon_special_case,
-            output: [
-                'var a = {',
-                '    b: bval,',
-                '    c: cval,',
-                '    d: dval',
-                '};',
-                'var e = f ? g :',
-                '    h;',
-                'var i = j ? k :',
-                '    l;'
-            ]
-        }, {
-            comment: 'catch-all, includes brackets and other various code',
-            input: inputlib.operator_position.catch_all,
-            output: [
-                'var d = 1;',
-                'if (a === b &&',
-                '    c) {',
-                '    d = (c * everything /',
-                '            something_else) %',
-                '        b;',
-                '    e',
-                '        += d;',
-                '',
-                '} else if (!(complex && simple) ||',
-                '    (emotion && emotion.name === "happy")) {',
-                '    cryTearsOfJoy(many ||',
-                '        anOcean ||',
-                '        aRiver);',
-                '}'
-            ]
-        }]
-    }, {
-        name: "operator_position option - set to 'after_newline'",
-        options: [{
-            name: "operator_position",
-            value: "'after-newline'"
-        }],
-        tests: [{
-            comment: 'comprehensive, various newlines',
-            input: inputlib.operator_position.comprehensive,
-            output: [
-                'var res = a + b',
-                '    - c',
-                '    / d * e',
-                '    % f;',
-                'var res = g & h',
-                '    | i',
-                '    ^ j;',
-                'var res = (k',
-                '        && l',
-                '        || m)',
-                '    ? n',
-                '    : o;',
-                'var res = p',
-                '    >> q',
-                '    << r',
-                '    >>> s;',
-                'var res = t',
-                '',
-                '    === u !== v',
-                '    != w',
-                '    == x',
-                '    >= y <= z > aa',
-                '    < ab;',
-                'ac',
-                '    + -ad'
-            ]
-        }, {
-            comment: 'colon special case',
-            input: inputlib.operator_position.colon_special_case,
-            output: [
-                'var a = {',
-                '    b: bval,',
-                '    c: cval,',
-                '    d: dval',
-                '};',
-                'var e = f ? g',
-                '    : h;',
-                'var i = j ? k',
-                '    : l;'
-            ]
-        }, {
-            comment: 'catch-all, includes brackets and other various code',
-            input: inputlib.operator_position.catch_all,
-            output: [
-                'var d = 1;',
-                'if (a === b',
-                '    && c) {',
-                '    d = (c * everything',
-                '            / something_else)',
-                '        % b;',
-                '    e',
-                '        += d;',
-                '',
-                '} else if (!(complex && simple)',
-                '    || (emotion && emotion.name === "happy")) {',
-                '    cryTearsOfJoy(many',
-                '        || anOcean',
-                '        || aRiver);',
-                '}'
-            ]
-        }]
-    }, {
-        name: "operator_position option - set to 'preserve-newline'",
-        options: [{
-            name: "operator_position",
-            value: "'preserve-newline'"
-        }],
-        tests: [{
-            comment: 'comprehensive, various newlines',
-            input: inputlib.operator_position.comprehensive,
-            output: [
-                'var res = a + b',
-                '    - c /',
-                '    d * e',
-                '    %',
-                '    f;',
-                'var res = g & h',
-                '    | i ^',
-                '    j;',
-                'var res = (k &&',
-                '        l',
-                '        || m) ?',
-                '    n',
-                '    : o;',
-                'var res = p',
-                '    >> q <<',
-                '    r',
-                '    >>> s;',
-                'var res = t',
-                '',
-                '    === u !== v',
-                '    !=',
-                '    w',
-                '    == x >=',
-                '    y <= z > aa <',
-                '    ab;',
-                'ac +',
-                '    -ad'
-            ]
-        }, {
-            comment: 'colon special case',
-            input: inputlib.operator_position.colon_special_case,
-            output: [
-                'var a = {',
-                '    b: bval,',
-                '    c: cval,',
-                '    d: dval',
-                '};',
-                'var e = f ? g',
-                '    : h;',
-                'var i = j ? k :',
-                '    l;'
-            ]
-        }, {
-            comment: 'catch-all, includes brackets and other various code',
-            unchanged: inputlib.operator_position.catch_all
-        }]
-    }, {
-        name: "Yield tests",
-        description: "ES6 yield tests",
-        tests: [
-            { unchanged: 'yield /foo\\\\//;' },
-            { unchanged: 'result = yield pgClient.query_(queryString);' },
-            { unchanged: 'yield [1, 2]' },
-            { unchanged: "yield* bar();" },
-            {
-                comment: "yield should have no space between yield and star",
-                input: "yield * bar();",
-                output: "yield* bar();"
-            },
-            {
-                comment: "yield should have space between star and generator",
-                input: "yield *bar();",
-                output: "yield* bar();"
-            }
-        ]
-    }, {
-        name: "Async / await tests",
-        description: "ES7 async / await tests",
-        tests: [
-            { unchanged: "async function foo() {}" },
-            { unchanged: "let w = async function foo() {}" },
-            { unchanged: "async function foo() {}\nvar x = await foo();" },
-            {
-                comment: "async function as an input to another function",
-                unchanged: "wrapper(async function foo() {})"
-            },
-            {
-                comment: "await on inline anonymous function. should have a space after await",
-                input_: "async function() {\n    var w = await(async function() {\n        return await foo();\n    })();\n}",
-                output: "async function() {\n    var w = await (async function() {\n        return await foo();\n    })();\n}"
-            },
-            {
-                comment: "ensure that this doesn't break anyone with the async library",
-                unchanged: "async.map(function(t) {})"
-            }
-        ]
-    }, {
-        name: "e4x - Test that e4x literals passed through when e4x-option is enabled",
-        description: "",
-        options: [
-            { name: 'e4x', value: true }
-        ],
-        tests: [
-            { input: 'xml=<a b="c"><d/><e>\n foo</e>x</a>;', output: 'xml = <a b="c"><d/><e>\n foo</e>x</a>;' },
-            { unchanged: '<a b=\\\'This is a quoted "c".\\\'/>' },
-            { unchanged: '<a b="This is a quoted \\\'c\\\'."/>' },
-            { unchanged: '<a b="A quote \\\' inside string."/>' },
-            { unchanged: '<a b=\\\'A quote " inside string.\\\'/>' },
-            { unchanged: '<a b=\\\'Some """ quotes ""  inside string.\\\'/>' },
-
-            {
-                comment: 'Handles inline expressions',
-                input: 'xml=<{a} b="c"><d/><e v={z}>\n foo</e>x</{a}>;',
-                output: 'xml = <{a} b="c"><d/><e v={z}>\n foo</e>x</{a}>;'
-            },
-            {
-                input: 'xml=<{a} b="c">\n    <e v={z}>\n foo</e>x</{a}>;',
-                output: 'xml = <{a} b="c">\n    <e v={z}>\n foo</e>x</{a}>;'
-            },
-            {
-                comment: 'xml literals with special characters in elem names - see http://www.w3.org/TR/REC-xml/#NT-NameChar',
-                unchanged: 'xml = <_:.valid.xml- _:.valid.xml-="123"/>;'
-            },
-            {
-                comment: 'xml literals with attributes without equal sign',
-                unchanged: 'xml = <elem someAttr/>;'
-            },
-
-            {
-                comment: 'Handles CDATA',
-                input: 'xml=<![CDATA[ b="c"><d/><e v={z}>\n foo</e>x/]]>;',
-                output: 'xml = <![CDATA[ b="c"><d/><e v={z}>\n foo</e>x/]]>;'
-            },
-            { input: 'xml=<![CDATA[]]>;', output: 'xml = <![CDATA[]]>;' },
-            { input: 'xml=<a b="c"><![CDATA[d/></a></{}]]></a>;', output: 'xml = <a b="c"><![CDATA[d/></a></{}]]></a>;' },
-
-            {
-                comment: 'JSX - working jsx from http://prettydiff.com/unit_tests/beautification_javascript_jsx.txt',
-                unchanged: [
-                    'var ListItem = React.createClass({',
-                    '    render: function() {',
-                    '        return (',
-                    '            <li className="ListItem">',
-                    '                <a href={ "/items/" + this.props.item.id }>',
-                    '                    this.props.item.name',
-                    '                </a>',
-                    '            </li>',
-                    '        );',
-                    '    }',
-                    '});'
-                ]
-            },
-            {
-                unchanged: [
-                    'var List = React.createClass({',
-                    '    renderList: function() {',
-                    '        return this.props.items.map(function(item) {',
-                    '            return <ListItem item={item} key={item.id} />;',
-                    '        });',
-                    '    },',
-                    '',
-                    '    render: function() {',
-                    '        return <ul className="List">',
-                    '                this.renderList()',
-                    '            </ul>',
-                    '    }',
-                    '});'
-                ]
-            },
-            {
-                unchanged: [
-                    'var Mist = React.createClass({',
-                    '    renderList: function() {',
-                    '        return this.props.items.map(function(item) {',
-                    '            return <ListItem item={return <tag>{item}</tag>} key={item.id} />;',
-                    '        });',
-                    '    }',
-                    '});',
-                ]
-            },
-            {
-                unchanged: [
-                    '// JSX',
-                    'var box = <Box>',
-                    '    {shouldShowAnswer(user) ?',
-                    '        <Answer value={false}>no</Answer> : <Box.Comment>',
-                    '        Text Content',
-                    '        </Box.Comment>}',
-                    '    </Box>;',
-                    'var a = function() {',
-                    '    return <tsdf>asdf</tsdf>;',
-                    '};',
-                    '',
-                    'var HelloMessage = React.createClass({',
-                    '    render: function() {',
-                    '        return <div {someAttr}>Hello {this.props.name}</div>;',
-                    '    }',
-                    '});',
-                    'React.render(<HelloMessage name="John" />, mountNode);',
-                ]
-            },
-            {
-                unchanged: [
-                    'var Timer = React.createClass({',
-                    '    getInitialState: function() {',
-                    '        return {',
-                    '            secondsElapsed: 0',
-                    '        };',
-                    '    },',
-                    '    tick: function() {',
-                    '        this.setState({',
-                    '            secondsElapsed: this.state.secondsElapsed + 1',
-                    '        });',
-                    '    },',
-                    '    componentDidMount: function() {',
-                    '        this.interval = setInterval(this.tick, 1000);',
-                    '    },',
-                    '    componentWillUnmount: function() {',
-                    '        clearInterval(this.interval);',
-                    '    },',
-                    '    render: function() {',
-                    '        return (',
-                    '            <div>Seconds Elapsed: {this.state.secondsElapsed}</div>',
-                    '        );',
-                    '    }',
-                    '});',
-                    'React.render(<Timer />, mountNode);'
-                ]
-            },
-            {
-                unchanged: [
-                    'var TodoList = React.createClass({',
-                    '    render: function() {',
-                    '        var createItem = function(itemText) {',
-                    '            return <li>{itemText}</li>;',
-                    '        };',
-                    '        return <ul>{this.props.items.map(createItem)}</ul>;',
-                    '    }',
-                    '});'
-                ]
-            },
-            {
-                unchanged: [
-                    'var TodoApp = React.createClass({',
-                    '    getInitialState: function() {',
-                    '        return {',
-                    '            items: [],',
-                    '            text: \\\'\\\'',
-                    '        };',
-                    '    },',
-                    '    onChange: function(e) {',
-                    '        this.setState({',
-                    '            text: e.target.value',
-                    '        });',
-                    '    },',
-                    '    handleSubmit: function(e) {',
-                    '        e.preventDefault();',
-                    '        var nextItems = this.state.items.concat([this.state.text]);',
-                    '        var nextText = \\\'\\\';',
-                    '        this.setState({',
-                    '            items: nextItems,',
-                    '            text: nextText',
-                    '        });',
-                    '    },',
-                    '    render: function() {',
-                    '        return (',
-                    '            <div>',
-                    '                <h3 {someAttr}>TODO</h3>',
-                    '                <TodoList items={this.state.items} />',
-                    '                <form onSubmit={this.handleSubmit}>',
-                    '                    <input onChange={this.onChange} value={this.state.text} />',
-                    '                    <button>{\\\'Add #\\\' + (this.state.items.length + 1)}</button>',
-                    '                </form>',
-                    '            </div>',
-                    '        );',
-                    '    }',
-                    '});',
-                    'React.render(<TodoApp />, mountNode);'
-                ]
-            },
-            {
-                input: [
-                    'var converter = new Showdown.converter();',
-                    'var MarkdownEditor = React.createClass({',
-                    '    getInitialState: function() {',
-                    '        return {value: \\\'Type some *markdown* here!\\\'};',
-                    '    },',
-                    '    handleChange: function() {',
-                    '        this.setState({value: this.refs.textarea.getDOMNode().value});',
-                    '    },',
-                    '    render: function() {',
-                    '        return (',
-                    '            <div className="MarkdownEditor">',
-                    '                <h3>Input</h3>',
-                    '                <textarea',
-                    '                    onChange={this.handleChange}',
-                    '                    ref="textarea"',
-                    '                    defaultValue={this.state.value} />',
-                    '                <h3>Output</h3>',
-                    '            <div',
-                    '                className="content"',
-                    '                dangerouslySetInnerHTML={{',
-                    '                        __html: converter.makeHtml(this.state.value)',
-                    '                    }}',
-                    '                />',
-                    '            </div>',
-                    '        );',
-                    '    }',
-                    '});',
-                    'React.render(<MarkdownEditor />, mountNode);'
-
-                ],
-                output: [
-                    'var converter = new Showdown.converter();',
-                    'var MarkdownEditor = React.createClass({',
-                    '    getInitialState: function() {',
-                    '        return {',
-                    '            value: \\\'Type some *markdown* here!\\\'',
-                    '        };',
-                    '    },',
-                    '    handleChange: function() {',
-                    '        this.setState({',
-                    '            value: this.refs.textarea.getDOMNode().value',
-                    '        });',
-                    '    },',
-                    '    render: function() {',
-                    '        return (',
-                    '            <div className="MarkdownEditor">',
-                    '                <h3>Input</h3>',
-                    '                <textarea',
-                    '                    onChange={this.handleChange}',
-                    '                    ref="textarea"',
-                    '                    defaultValue={this.state.value} />',
-                    '                <h3>Output</h3>',
-                    '            <div',
-                    '                className="content"',
-                    '                dangerouslySetInnerHTML={{',
-                    '                        __html: converter.makeHtml(this.state.value)',
-                    '                    }}',
-                    '                />',
-                    '            </div>',
-                    '        );',
-                    '    }',
-                    '});',
-                    'React.render(<MarkdownEditor />, mountNode);'
-                ]
-            },
-            {
-                comment: 'JSX - Not quite correct jsx formatting that still works',
-                input: [
-                    'var content = (',
-                    '        <Nav>',
-                    '            {/* child comment, put {} around */}',
-                    '            <Person',
-                    '                /* multi',
-                    '         line',
-                    '         comment */',
-                    '         //attr="test"',
-                    '                name={window.isLoggedIn ? window.name : \\\'\\\'} // end of line comment',
-                    '            />',
-                    '        </Nav>',
-                    '    );',
-                    'var qwer = <DropDown> A dropdown list <Menu> <MenuItem>Do Something</MenuItem> <MenuItem>Do Something Fun!</MenuItem> <MenuItem>Do Something Else</MenuItem> </Menu> </DropDown>;',
-                    'render(dropdown);',
-                ],
-                output: [
-                    'var content = (',
-                    '    <Nav>',
-                    '            {/* child comment, put {} around */}',
-                    '            <Person',
-                    '                /* multi',
-                    '         line',
-                    '         comment */',
-                    '         //attr="test"',
-                    '                name={window.isLoggedIn ? window.name : \\\'\\\'} // end of line comment',
-                    '            />',
-                    '        </Nav>',
-                    ');',
-                    'var qwer = <DropDown> A dropdown list <Menu> <MenuItem>Do Something</MenuItem> <MenuItem>Do Something Fun!</MenuItem> <MenuItem>Do Something Else</MenuItem> </Menu> </DropDown>;',
-                    'render(dropdown);',
-                ]
-            },
-            {
-                comment: [
-                    "Handles messed up tags, as long as it isn't the same name",
-                    "as the root tag. Also handles tags of same name as root tag",
-                    "as long as nesting matches."
-                ],
-                input_: 'xml=<a x="jn"><c></b></f><a><d jnj="jnn"><f></a ></nj></a>;',
-                output: 'xml = <a x="jn"><c></b></f><a><d jnj="jnn"><f></a ></nj></a>;'
-            },
-
-            {
-                comment: [
-                    "If xml is not terminated, the remainder of the file is treated",
-                    "as part of the xml-literal (passed through unaltered)"
-                ],
-                fragment: true,
-                input_: 'xml=<a></b>\nc<b;',
-                output: 'xml = <a></b>\nc<b;'
-            },
-            {
-                comment: 'Issue #646 = whitespace is allowed in attribute declarations',
-                unchanged: [
-                    'let a = React.createClass({',
-                    '    render() {',
-                    '        return (',
-                    '            <p className=\\\'a\\\'>',
-                    '                <span>c</span>',
-                    '            </p>',
-                    '        );',
-                    '    }',
-                    '});'
-                ]
-            },
-            {
-                unchanged: [
-                    'let a = React.createClass({',
-                    '    render() {',
-                    '        return (',
-                    '            <p className = \\\'b\\\'>',
-                    '                <span>c</span>',
-                    '            </p>',
-                    '        );',
-                    '    }',
-                    '});'
-                ]
-            },
-            {
-                unchanged: [
-                    'let a = React.createClass({',
-                    '    render() {',
-                    '        return (',
-                    '            <p className = "c">',
-                    '                <span>c</span>',
-                    '            </p>',
-                    '        );',
-                    '    }',
-                    '});'
-                ]
-            },
-            {
-                unchanged: [
-                    'let a = React.createClass({',
-                    '    render() {',
-                    '        return (',
-                    '            <{e}  className = {d}>',
-                    '                <span>c</span>',
-                    '            </{e}>',
-                    '        );',
-                    '    }',
-                    '});'
-                ]
-            },
-            {
-                comment: 'Issue #914 - Multiline attribute in root tag',
-                unchanged: [
-                    'return (',
-                    '    <a href="#"',
-                    '        onClick={e => {',
-                    '            e.preventDefault()',
-                    '            onClick()',
-                    '       }}>',
-                    '       {children}',
-                    '    </a>',
-                    ');'
-                ]
-            },
-            {
-                unchanged: [
-                    'return (',
-                    '    <{',
-                    '        a + b',
-                    '    } href="#"',
-                    '        onClick={e => {',
-                    '            e.preventDefault()',
-                    '            onClick()',
-                    '       }}>',
-                    '       {children}',
-                    '    </{',
-                    '        a + b',
-                    '    }>',
-                    ');'
-                ]
-            },
-            {
-                input: [
-                    'return (',
-                    '    <{',
-                    '        a + b',
-                    '    } href="#"',
-                    '        onClick={e => {',
-                    '            e.preventDefault()',
-                    '            onClick()',
-                    '       }}>',
-                    '       {children}',
-                    '    </{a + b}>',
-                    '    );'
-                ],
-                output: [
-                    'return (',
-                    '    <{',
-                    '        a + b',
-                    '    } href="#"',
-                    '        onClick={e => {',
-                    '            e.preventDefault()',
-                    '            onClick()',
-                    '       }}>',
-                    '       {children}',
-                    '    </{a + b}>',
-                    ');'
-                ]
-            }
-        ]
-    }, {
-        name: "e4x disabled",
-        description: "",
-        options: [
-            { name: 'e4x', value: false }
-        ],
-        tests: [{
-            input_: 'xml=<a b="c"><d/><e>\n foo</e>x</a>;',
-            output: 'xml = < a b = "c" > < d / > < e >\n    foo < /e>x</a > ;'
-        }]
-    }, {
-        name: "Multiple braces",
-        description: "",
-        template: "^^^ $$$",
-        options: [],
-        tests: [
-            { input: '{{}/z/}', output: '{\n    {}\n    /z/\n}' }
-        ]
-    }, {
-        name: "Beautify preserve formatting",
-        description: "Allow beautifier to preserve sections",
-        tests: [
-            { unchanged: "/* beautify preserve:start */\n/* beautify preserve:end */" },
-            { unchanged: "/* beautify preserve:start */\n   var a = 1;\n/* beautify preserve:end */" },
-            { unchanged: "var a = 1;\n/* beautify preserve:start */\n   var a = 1;\n/* beautify preserve:end */" },
-            { unchanged: "/* beautify preserve:start */     {asdklgh;y;;{}dd2d}/* beautify preserve:end */" },
-            {
-                input_: "var a =  1;\n/* beautify preserve:start */\n   var a = 1;\n/* beautify preserve:end */",
-                output: "var a = 1;\n/* beautify preserve:start */\n   var a = 1;\n/* beautify preserve:end */"
-            },
-            {
-                input_: "var a = 1;\n /* beautify preserve:start */\n   var a = 1;\n/* beautify preserve:end */",
-                output: "var a = 1;\n/* beautify preserve:start */\n   var a = 1;\n/* beautify preserve:end */"
-            },
-            {
-                unchanged: [
-                    'var a = {',
-                    '    /* beautify preserve:start */',
-                    '    one   :  1',
-                    '    two   :  2,',
-                    '    three :  3,',
-                    '    ten   : 10',
-                    '    /* beautify preserve:end */',
-                    '};'
-                ]
-            },
-            {
-                input: [
-                    'var a = {',
-                    '/* beautify preserve:start */',
-                    '    one   :  1,',
-                    '    two   :  2,',
-                    '    three :  3,',
-                    '    ten   : 10',
-                    '/* beautify preserve:end */',
-                    '};'
-                ],
-                output: [
-                    'var a = {',
-                    '    /* beautify preserve:start */',
-                    '    one   :  1,',
-                    '    two   :  2,',
-                    '    three :  3,',
-                    '    ten   : 10',
-                    '/* beautify preserve:end */',
-                    '};'
-                ]
-            },
-            {
-                comment: 'one space before and after required, only single spaces inside.',
-                input: [
-                    'var a = {',
-                    '/*  beautify preserve:start  */',
-                    '    one   :  1,',
-                    '    two   :  2,',
-                    '    three :  3,',
-                    '    ten   : 10',
-                    '};'
-                ],
-                output: [
-                    'var a = {',
-                    '    /*  beautify preserve:start  */',
-                    '    one: 1,',
-                    '    two: 2,',
-                    '    three: 3,',
-                    '    ten: 10',
-                    '};'
-                ]
-            },
-            {
-                input: [
-                    'var a = {',
-                    '/*beautify preserve:start*/',
-                    '    one   :  1,',
-                    '    two   :  2,',
-                    '    three :  3,',
-                    '    ten   : 10',
-                    '};'
-                ],
-                output: [
-                    'var a = {',
-                    '    /*beautify preserve:start*/',
-                    '    one: 1,',
-                    '    two: 2,',
-                    '    three: 3,',
-                    '    ten: 10',
-                    '};'
-                ]
-            },
-            {
-                input: [
-                    'var a = {',
-                    '/*beautify  preserve:start*/',
-                    '    one   :  1,',
-                    '    two   :  2,',
-                    '    three :  3,',
-                    '    ten   : 10',
-                    '};'
-                ],
-                output: [
-                    'var a = {',
-                    '    /*beautify  preserve:start*/',
-                    '    one: 1,',
-                    '    two: 2,',
-                    '    three: 3,',
-                    '    ten: 10',
-                    '};'
-                ]
-            },
-
-            {
-                comment: 'Directive: ignore',
-                unchanged: "/* beautify ignore:start */\n/* beautify ignore:end */"
-            },
-            { unchanged: "/* beautify ignore:start */\n   var a,,,{ 1;\n/* beautify ignore:end */" },
-            { unchanged: "var a = 1;\n/* beautify ignore:start */\n   var a = 1;\n/* beautify ignore:end */" },
-            { unchanged: "/* beautify ignore:start */     {asdklgh;y;+++;dd2d}/* beautify ignore:end */" },
-            {
-                input_: "var a =  1;\n/* beautify ignore:start */\n   var a,,,{ 1;\n/* beautify ignore:end */",
-                output: "var a = 1;\n/* beautify ignore:start */\n   var a,,,{ 1;\n/* beautify ignore:end */"
-            },
-            {
-                input_: "var a = 1;\n /* beautify ignore:start */\n   var a,,,{ 1;\n/* beautify ignore:end */",
-                output: "var a = 1;\n/* beautify ignore:start */\n   var a,,,{ 1;\n/* beautify ignore:end */"
-            },
-            {
-                unchanged: [
-                    'var a = {',
-                    '    /* beautify ignore:start */',
-                    '    one   :  1',
-                    '    two   :  2,',
-                    '    three :  {',
-                    '    ten   : 10',
-                    '    /* beautify ignore:end */',
-                    '};'
-                ]
-            },
-            {
-                input: [
-                    'var a = {',
-                    '/* beautify ignore:start */',
-                    '    one   :  1',
-                    '    two   :  2,',
-                    '    three :  {',
-                    '    ten   : 10',
-                    '/* beautify ignore:end */',
-                    '};'
-                ],
-                output: [
-                    'var a = {',
-                    '    /* beautify ignore:start */',
-                    '    one   :  1',
-                    '    two   :  2,',
-                    '    three :  {',
-                    '    ten   : 10',
-                    '/* beautify ignore:end */',
-                    '};'
-                ]
-            },
-            {
-                comment: 'Directives - multiple and interacting',
-                input: [
-                    'var a = {',
-                    '/* beautify preserve:start */',
-                    '/* beautify preserve:start */',
-                    '    one   :  1,',
-                    '  /* beautify preserve:end */',
-                    '    two   :  2,',
-                    '    three :  3,',
-                    '/* beautify preserve:start */',
-                    '    ten   : 10',
-                    '/* beautify preserve:end */',
-                    '};'
-                ],
-                output: [
-                    'var a = {',
-                    '    /* beautify preserve:start */',
-                    '/* beautify preserve:start */',
-                    '    one   :  1,',
-                    '  /* beautify preserve:end */',
-                    '    two: 2,',
-                    '    three: 3,',
-                    '    /* beautify preserve:start */',
-                    '    ten   : 10',
-                    '/* beautify preserve:end */',
-                    '};'
-                ]
-            },
-            {
-                input: [
-                    'var a = {',
-                    '/* beautify ignore:start */',
-                    '    one   :  1',
-                    ' /* beautify ignore:end */',
-                    '    two   :  2,',
-                    '/* beautify ignore:start */',
-                    '    three :  {',
-                    '    ten   : 10',
-                    '/* beautify ignore:end */',
-                    '};'
-                ],
-                output: [
-                    'var a = {',
-                    '    /* beautify ignore:start */',
-                    '    one   :  1',
-                    ' /* beautify ignore:end */',
-                    '    two: 2,',
-                    '    /* beautify ignore:start */',
-                    '    three :  {',
-                    '    ten   : 10',
-                    '/* beautify ignore:end */',
-                    '};'
-                ]
-            },
-            {
-                comment: 'Starts can occur together, ignore:end must occur alone.',
-                input: [
-                    'var a = {',
-                    '/* beautify ignore:start */',
-                    '    one   :  1',
-                    '    NOTE: ignore end block does not support starting other directives',
-                    '    This does not match the ending the ignore...',
-                    ' /* beautify ignore:end preserve:start */',
-                    '    two   :  2,',
-                    '/* beautify ignore:start */',
-                    '    three :  {',
-                    '    ten   : 10',
-                    '    ==The next comment ends the starting ignore==',
-                    '/* beautify ignore:end */',
-                    '};'
-                ],
-                output: [
-                    'var a = {',
-                    '    /* beautify ignore:start */',
-                    '    one   :  1',
-                    '    NOTE: ignore end block does not support starting other directives',
-                    '    This does not match the ending the ignore...',
-                    ' /* beautify ignore:end preserve:start */',
-                    '    two   :  2,',
-                    '/* beautify ignore:start */',
-                    '    three :  {',
-                    '    ten   : 10',
-                    '    ==The next comment ends the starting ignore==',
-                    '/* beautify ignore:end */',
-                    '};'
-                ]
-            },
-            {
-                input: [
-                    'var a = {',
-                    '/* beautify ignore:start preserve:start */',
-                    '    one   :  {',
-                    ' /* beautify ignore:end */',
-                    '    two   :  2,',
-                    '  /* beautify ignore:start */',
-                    '    three :  {',
-                    '/* beautify ignore:end */',
-                    '    ten   : 10',
-                    '   // This is all preserved',
-                    '};'
-                ],
-                output: [
-                    'var a = {',
-                    '    /* beautify ignore:start preserve:start */',
-                    '    one   :  {',
-                    ' /* beautify ignore:end */',
-                    '    two   :  2,',
-                    '  /* beautify ignore:start */',
-                    '    three :  {',
-                    '/* beautify ignore:end */',
-                    '    ten   : 10',
-                    '   // This is all preserved',
-                    '};'
-                ]
-            },
-            {
-                input: [
-                    'var a = {',
-                    '/* beautify ignore:start preserve:start */',
-                    '    one   :  {',
-                    ' /* beautify ignore:end */',
-                    '    two   :  2,',
-                    '  /* beautify ignore:start */',
-                    '    three :  {',
-                    '/* beautify ignore:end */',
-                    '    ten   : 10,',
-                    '/* beautify preserve:end */',
-                    '     eleven: 11',
-                    '};'
-                ],
-                output: [
-                    'var a = {',
-                    '    /* beautify ignore:start preserve:start */',
-                    '    one   :  {',
-                    ' /* beautify ignore:end */',
-                    '    two   :  2,',
-                    '  /* beautify ignore:start */',
-                    '    three :  {',
-                    '/* beautify ignore:end */',
-                    '    ten   : 10,',
-                    '/* beautify preserve:end */',
-                    '    eleven: 11',
-                    '};'
-                ]
-            },
-        ]
-    }, {
-        name: "Comments and  tests",
-        description: "Comments should be in the right indent and not side-ffect.",
-        options: [],
-        tests: [{
-                comment: '#913',
-
-                unchanged: [
-                    'class test {',
-                    '    method1() {',
-                    '        let resp = null;',
-                    '    }',
-                    '    /**',
-                    '     * @param {String} id',
-                    '     */',
-                    '    method2(id) {',
-                    '        let resp2 = null;',
-                    '    }',
-                    '}'
-                ]
-            },
-            {
-                comment: '#1090',
-                unchanged: [
-                    'for (var i = 0; i < 20; ++i) // loop',
-                    '    if (i % 3) {',
-                    '        console.log(i);',
-                    '    }',
-                    'console.log("done");',
-                ]
-            },
-            {
-                comment: '#1043',
-                unchanged: [
-                    'var o = {',
-                    '    k: 0',
-                    '}',
-                    '// ...',
-                    'foo(o)',
-                ]
-            },
-            {
-                comment: '#713 and #964',
-                unchanged: [
-                    'Meteor.call("foo", bar, function(err, result) {',
-                    '    Session.set("baz", result.lorem)',
-                    '})',
-                    '//blah blah',
-                ]
-            },
-            {
-                comment: '#815',
-                unchanged: [
-                    'foo()',
-                    '// this is a comment',
-                    'bar()',
-                    '',
-                    'const foo = 5',
-                    '// comment',
-                    'bar()',
-                ]
-            },
-            {
-                comment: 'This shows current behavior.  Note #1069 is not addressed yet.',
-                unchanged: [
-                    'if (modulus === 2) {',
-                    '    // i might be odd here',
-                    '    i += (i & 1);',
-                    '    // now i is guaranteed to be even',
-                    '    // this block is obviously about the statement above',
-                    '',
-                    '    // #1069 This should attach to the block below',
-                    '    // this comment is about the block after it.',
-                    '} else {',
-                    '    // rounding up using integer arithmetic only',
-                    '    if (i % modulus)',
-                    '        i += modulus - (i % modulus);',
-                    '    // now i is divisible by modulus',
-                    '    // behavior of comments should be different for single statements vs block statements/expressions',
-                    '}',
-                    '',
-                    'if (modulus === 2)',
-                    '    // i might be odd here',
-                    '    i += (i & 1);',
-                    '// now i is guaranteed to be even',
-                    '// non-braced comments unindent immediately',
-                    '',
-                    '// this comment is about the block after it.',
-                    'else',
-                    '    // rounding up using integer arithmetic only',
-                    '    if (i % modulus)',
-                    '        i += modulus - (i % modulus);',
-                    '// behavior of comments should be different for single statements vs block statements/expressions',
-                ]
-            },
-
-        ]
-    }, {
-        name: "Template Formatting",
-        description: "Php (<?php ... ?>) and underscore.js templating treated as strings.",
-        options: [],
-        tests: [
-            { unchanged: '<?=$view["name"]; ?>' },
-            { unchanged: 'a = <?= external() ?>;' },
-            {
-                unchanged: [
-                    '<?php',
-                    'for($i = 1; $i <= 100; $i++;) {',
-                    '    #count to 100!',
-                    '    echo($i . "</br>");',
-                    '}',
-                    '?>'
-                ]
-            },
-            { unchanged: 'a = <%= external() %>;' }
-        ]
-    }, {
-        name: "jslint and space after anon function",
-        description: "jslint_happy and space_after_anon_function tests",
-        matrix: [{
-                options: [
-                    { name: "jslint_happy", value: "true" },
-                    { name: "space_after_anon_function", value: "true" }
-                ],
-                f: ' ',
-                c: ''
-            }, {
-                options: [
-                    { name: "jslint_happy", value: "true" },
-                    { name: "space_after_anon_function", value: "false" }
-                ],
-                f: ' ',
-                c: ''
-            }, {
-                options: [
-                    { name: "jslint_happy", value: "false" },
-                    { name: "space_after_anon_function", value: "true" }
-                ],
-                f: ' ',
-                c: '    '
-            }, {
-                options: [
-                    { name: "jslint_happy", value: "false" },
-                    { name: "space_after_anon_function", value: "false" }
-                ],
-                f: '',
-                c: '    '
-            }
-
-
-        ],
-        tests: [{
-                input_: 'a=typeof(x)',
-                output: 'a = typeof{{f}}(x)'
-            },
-            {
-                input_: 'x();\n\nfunction(){}',
-                output: 'x();\n\nfunction{{f}}() {}'
-            },
-            {
-                input_: 'x();\n\nvar x = {\nx: function(){}\n}',
-                output: 'x();\n\nvar x = {\n    x: function{{f}}() {}\n}'
-            },
-            {
-                input_: 'function () {\n    var a, b, c, d, e = [],\n        f;\n}',
-                output: 'function{{f}}() {\n    var a, b, c, d, e = [],\n        f;\n}'
-            },
-
-            {
-                input_: 'switch(x) {case 0: case 1: a(); break; default: break}',
-                output: 'switch (x) {\n{{c}}case 0:\n{{c}}case 1:\n{{c}}    a();\n{{c}}    break;\n{{c}}default:\n{{c}}    break\n}'
-            },
-            {
-                input: 'switch(x){case -1:break;case !y:break;}',
-                output: 'switch (x) {\n{{c}}case -1:\n{{c}}    break;\n{{c}}case !y:\n{{c}}    break;\n}'
-            },
-            {
-                comment: 'typical greasemonkey start',
-                fragment: true,
-                unchanged: '// comment 2\n(function{{f}}()'
-            },
-
-            {
-                input_: 'var a2, b2, c2, d2 = 0, c = function() {}, d = \\\'\\\';',
-                output: 'var a2, b2, c2, d2 = 0,\n    c = function{{f}}() {},\n    d = \\\'\\\';'
-            },
-            {
-                input_: 'var a2, b2, c2, d2 = 0, c = function() {},\nd = \\\'\\\';',
-                output: 'var a2, b2, c2, d2 = 0,\n    c = function{{f}}() {},\n    d = \\\'\\\';'
-            },
-            {
-                input_: 'var o2=$.extend(a);function(){alert(x);}',
-                output: 'var o2 = $.extend(a);\n\nfunction{{f}}() {\n    alert(x);\n}'
-            },
-            { input: 'function*() {\n    yield 1;\n}', output: 'function*{{f}}() {\n    yield 1;\n}' },
-            { unchanged: 'function* x() {\n    yield 1;\n}' },
-        ]
-    }, {
-        name: "Regression tests",
-        description: "Ensure specific bugs do not recur",
-        options: [],
-        tests: [{
-                comment: "Issue 241",
-                unchanged: [
-                    'obj',
-                    '    .last({',
-                    '        foo: 1,',
-                    '        bar: 2',
-                    '    });',
-                    'var test = 1;'
-                ]
-            },
-            {
-                unchanged: [
-                    'obj',
-                    '    .last(a, function() {',
-                    '        var test;',
-                    '    });',
-                    'var test = 1;'
-                ]
-            },
-            {
-                unchanged: [
-                    'obj.first()',
-                    '    .second()',
-                    '    .last(function(err, response) {',
-                    '        console.log(err);',
-                    '    });'
-                ]
-            },
-            {
-                comment: "Issue 268 and 275",
-                unchanged: [
-                    'obj.last(a, function() {',
-                    '    var test;',
-                    '});',
-                    'var test = 1;'
-                ]
-            },
-            {
-                unchanged: [
-                    'obj.last(a,',
-                    '    function() {',
-                    '        var test;',
-                    '    });',
-                    'var test = 1;'
-                ]
-            },
-            {
-                input: '(function() {if (!window.FOO) window.FOO || (window.FOO = function() {var b = {bar: "zort"};});})();',
-                output: [
-                    '(function() {',
-                    '    if (!window.FOO) window.FOO || (window.FOO = function() {',
-                    '        var b = {',
-                    '            bar: "zort"',
-                    '        };',
-                    '    });',
-                    '})();'
-                ]
-            },
-            {
-                comment: "Issue 281",
-                unchanged: [
-                    'define(["dojo/_base/declare", "my/Employee", "dijit/form/Button",',
-                    '    "dojo/_base/lang", "dojo/Deferred"',
-                    '], function(declare, Employee, Button, lang, Deferred) {',
-                    '    return declare(Employee, {',
-                    '        constructor: function() {',
-                    '            new Button({',
-                    '                onClick: lang.hitch(this, function() {',
-                    '                    new Deferred().then(lang.hitch(this, function() {',
-                    '                        this.salary * 0.25;',
-                    '                    }));',
-                    '                })',
-                    '            });',
-                    '        }',
-                    '    });',
-                    '});'
-                ]
-            },
-            {
-                unchanged: [
-                    'define(["dojo/_base/declare", "my/Employee", "dijit/form/Button",',
-                    '        "dojo/_base/lang", "dojo/Deferred"',
-                    '    ],',
-                    '    function(declare, Employee, Button, lang, Deferred) {',
-                    '        return declare(Employee, {',
-                    '            constructor: function() {',
-                    '                new Button({',
-                    '                    onClick: lang.hitch(this, function() {',
-                    '                        new Deferred().then(lang.hitch(this, function() {',
-                    '                            this.salary * 0.25;',
-                    '                        }));',
-                    '                    })',
-                    '                });',
-                    '            }',
-                    '        });',
-                    '    });'
-                ]
-            },
-            {
-                comment: "Issue 459",
-                unchanged: [
-                    '(function() {',
-                    '    return {',
-                    '        foo: function() {',
-                    '            return "bar";',
-                    '        },',
-                    '        bar: ["bar"]',
-                    '    };',
-                    '}());'
-                ]
-            },
-            {
-                comment: "Issue 505 - strings should end at newline unless continued by backslash",
-                unchanged: [
-                    'var name = "a;',
-                    'name = "b";'
-                ]
-            },
-            {
-                unchanged: [
-                    'var name = "a;\\\\',
-                    '    name = b";'
-                ]
-            },
-            {
-                comment: "Issue 514 - some operators require spaces to distinguish them",
-                unchanged: 'var c = "_ACTION_TO_NATIVEAPI_" + ++g++ + +new Date;'
-            },
-            {
-                unchanged: 'var c = "_ACTION_TO_NATIVEAPI_" - --g-- - -new Date;'
-            },
-            {
-                comment: "Issue 440 - reserved words can be used as object property names",
-                unchanged: [
-                    'a = {',
-                    '    function: {},',
-                    '    "function": {},',
-                    '    throw: {},',
-                    '    "throw": {},',
-                    '    var: {},',
-                    '    "var": {},',
-                    '    set: {},',
-                    '    "set": {},',
-                    '    get: {},',
-                    '    "get": {},',
-                    '    if: {},',
-                    '    "if": {},',
-                    '    then: {},',
-                    '    "then": {},',
-                    '    else: {},',
-                    '    "else": {},',
-                    '    yay: {}',
-                    '};'
-                ]
-            },
-            {
-                comment: "Issue 331 - if-else with braces edge case",
-                input: 'if(x){a();}else{b();}if(y){c();}',
-                output: [
-                    'if (x) {',
-                    '    a();',
-                    '} else {',
-                    '    b();',
-                    '}',
-                    'if (y) {',
-                    '    c();',
-                    '}'
-                ]
-            },
-            {
-                comment: "Issue 485 - ensure function declarations behave the same in arrays as elsewhere",
-                unchanged: [
-                    'var v = ["a",',
-                    '    function() {',
-                    '        return;',
-                    '    }, {',
-                    '        id: 1',
-                    '    }',
-                    '];'
-                ]
-            },
-            {
-                unchanged: [
-                    'var v = ["a", function() {',
-                    '    return;',
-                    '}, {',
-                    '    id: 1',
-                    '}];'
-                ]
-            },
-            {
-                comment: "Issue 382 - initial totally cursory support for es6 module export",
-                unchanged: [
-                    'module "Even" {',
-                    '    import odd from "Odd";',
-                    '    export function sum(x, y) {',
-                    '        return x + y;',
-                    '    }',
-                    '    export var pi = 3.141593;',
-                    '    export default moduleName;',
-                    '}'
-                ]
-            },
-            {
-                unchanged: [
-                    'module "Even" {',
-                    '    export default function div(x, y) {}',
-                    '}'
-                ]
-            },
-            {
-                comment: 'Issue 889 - export default { ... }',
-                unchanged: [
-                    'export default {',
-                    '    func1() {},',
-                    '    func2() {}',
-                    '    func3() {}',
-                    '}'
-                ]
-            },
-            {
-                unchanged: [
-                    'export default {',
-                    '    a() {',
-                    '        return 1;',
-                    '    },',
-                    '    b() {',
-                    '        return 2;',
-                    '    },',
-                    '    c() {',
-                    '        return 3;',
-                    '    }',
-                    '}'
-                ]
-            },
-            {
-                comment: "Issue 508",
-                unchanged: 'set["name"]'
-            },
-            {
-                unchanged: 'get["name"]'
-            },
-            {
-                fragmeent: true,
-                unchanged: [
-                    'a = {',
-                    '    set b(x) {},',
-                    '    c: 1,',
-                    '    d: function() {}',
-                    '};'
-                ]
-            },
-            {
-                fragmeent: true,
-                unchanged: [
-                    'a = {',
-                    '    get b() {',
-                    '        retun 0;',
-                    '    },',
-                    '    c: 1,',
-                    '    d: function() {}',
-                    '};'
-                ]
-            },
-            {
-                comment: "Issue 298 - do not under indent if/while/for condtionals experesions",
-                unchanged: [
-                    '\\\'use strict\\\';',
-                    'if ([].some(function() {',
-                    '        return false;',
-                    '    })) {',
-                    '    console.log("hello");',
-                    '}'
-                ]
-            },
-            {
-                comment: "Issue 298 - do not under indent if/while/for condtionals experesions",
-                unchanged: [
-                    '\\\'use strict\\\';',
-                    'if ([].some(function() {',
-                    '        return false;',
-                    '    })) {',
-                    '    console.log("hello");',
-                    '}'
-                ]
-            },
-            {
-                comment: "Issue 552 - Typescript?  Okay... we didn't break it before, so try not to break it now.",
-                unchanged: [
-                    'class Test {',
-                    '    blah: string[];',
-                    '    foo(): number {',
-                    '        return 0;',
-                    '    }',
-                    '    bar(): number {',
-                    '        return 0;',
-                    '    }',
-                    '}'
-                ]
-            },
-            {
-                unchanged: [
-                    'interface Test {',
-                    '    blah: string[];',
-                    '    foo(): number {',
-                    '        return 0;',
-                    '    }',
-                    '    bar(): number {',
-                    '        return 0;',
-                    '    }',
-                    '}'
-                ]
-            },
-            {
-                comment: "Issue 583 - Functions with comments after them should still indent correctly.",
-                unchanged: [
-                    'function exit(code) {',
-                    '    setTimeout(function() {',
-                    '        phantom.exit(code);',
-                    '    }, 0);',
-                    '    phantom.onError = function() {};',
-                    '}',
-                    '// Comment'
-                ]
-            },
-            {
-                comment: "Issue 806 - newline arrow functions",
-                unchanged: [
-                    'a.b("c",',
-                    '    () => d.e',
-                    ')'
-                ]
-            },
-            {
-                comment: "Issue 810 - es6 object literal detection",
-                unchanged: [
-                    'function badFormatting() {',
-                    '    return {',
-                    '        a,',
-                    '        b: c,',
-                    '        d: e,',
-                    '        f: g,',
-                    '        h,',
-                    '        i,',
-                    '        j: k',
-                    '    }',
-                    '}',
-                    '',
-                    'function goodFormatting() {',
-                    '    return {',
-                    '        a: b,',
-                    '        c,',
-                    '        d: e,',
-                    '        f: g,',
-                    '        h,',
-                    '        i,',
-                    '        j: k',
-                    '    }',
-                    '}'
-                ]
-            },
-            {
-                comment: "Issue 602 - ES6 object literal shorthand functions",
-                unchanged: [
-                    'return {',
-                    '    fn1() {},',
-                    '    fn2() {}',
-                    '}'
-                ]
-            }, {
-                unchanged: [
-                    'throw {',
-                    '    fn1() {},',
-                    '    fn2() {}',
-                    '}'
-                ]
-            }, {
-                unchanged: [
-                    'foo({',
-                    '    fn1(a) {}',
-                    '    fn2(a) {}',
-                    '})'
-                ]
-            }, {
-                unchanged: [
-                    'foo("text", {',
-                    '    fn1(a) {}',
-                    '    fn2(a) {}',
-                    '})'
-                ]
-            }, {
-                unchanged: [
-                    'oneArg = {',
-                    '    fn1(a) {',
-                    '        do();',
-                    '    },',
-                    '    fn2() {}',
-                    '}'
-                ]
-            }, {
-                unchanged: [
-                    'multiArg = {',
-                    '    fn1(a, b, c) {',
-                    '        do();',
-                    '    },',
-                    '    fn2() {}',
-                    '}'
-                ]
-            }, {
-                unchanged: [
-                    'noArgs = {',
-                    '    fn1() {',
-                    '        do();',
-                    '    },',
-                    '    fn2() {}',
-                    '}'
-                ]
-            }, {
-                unchanged: [
-                    'emptyFn = {',
-                    '    fn1() {},',
-                    '    fn2() {}',
-                    '}'
-                ]
-            }, {
-                unchanged: [
-                    'nested = {',
-                    '    fns: {',
-                    '        fn1() {},',
-                    '        fn2() {}',
-                    '    }',
-                    '}'
-                ]
-            }, {
-                unchanged: [
-                    'array = [{',
-                    '    fn1() {},',
-                    '    prop: val,',
-                    '    fn2() {}',
-                    '}]'
-                ]
-            }, {
-                unchanged: [
-                    'expr = expr ? expr : {',
-                    '    fn1() {},',
-                    '    fn2() {}',
-                    '}'
-                ]
-            }, {
-                unchanged: [
-                    'strange = valid + {',
-                    '    fn1() {},',
-                    '    fn2() {',
-                    '        return 1;',
-                    '    }',
-                    '}.fn2()'
-                ]
-            },
-            {
-                comment: "Issue 854 - Arrow function with statement block",
-                unchanged: [
-                    'test(() => {',
-                    '    var a = {}',
-                    '',
-                    '    a.what = () => true ? 1 : 2',
-                    '',
-                    '    a.thing = () => {',
-                    '        b();',
-                    '    }',
-                    '})'
-                ]
-            },
-            {
-                comment: "Issue 406 - Multiline array",
-                unchanged: [
-                    'var tempName = [',
-                    '    "temp",',
-                    '    process.pid,',
-                    '    (Math.random() * 0x1000000000).toString(36),',
-                    '    new Date().getTime()',
-                    '].join("-");'
-                ]
-            },
-            {
-                comment: "Issue #996 - Input ends with backslash throws exception",
-                fragment: true,
-                unchanged: [
-                    'sd = 1;',
-                    '/'
-                ]
-            },
-            {
-                comment: "Issue #1079 - unbraced if with comments should still look right",
-                unchanged: [
-                    'if (console.log)',
-                    '    for (var i = 0; i < 20; ++i)',
-                    '        if (i % 3)',
-                    '            console.log(i);',
-                    '// all done',
-                    'console.log("done");'
-                ]
-            },
-            {
-                comment: "Issue #1085 - function should not have blank line in a number of cases",
-                unchanged: [
-                    'var transformer =',
-                    '    options.transformer ||',
-                    '    globalSettings.transformer ||',
-                    '    function(x) {',
-                    '        return x;',
-                    '    };'
-                ]
-            },
-            {
-                comment: "Issue #569 - function should not have blank line in a number of cases",
-                unchanged: [
-                    '(function(global) {',
-                    '    "use strict";',
-                    '',
-                    '    /* jshint ignore:start */',
-                    '    include "somefile.js"',
-                    '    /* jshint ignore:end */',
-                    '}(this));'
-                ]
-            },
-            {
-                unchanged: [
-                    'function bindAuthEvent(eventName) {',
-                    '    self.auth.on(eventName, function(event, meta) {',
-                    '        self.emit(eventName, event, meta);',
-                    '    });',
-                    '}',
-                    '["logged_in", "logged_out", "signed_up", "updated_user"].forEach(bindAuthEvent);',
-                    '',
-                    'function bindBrowserEvent(eventName) {',
-                    '    browser.on(eventName, function(event, meta) {',
-                    '        self.emit(eventName, event, meta);',
-                    '    });',
-                    '}',
-                    '["navigating"].forEach(bindBrowserEvent);'
-                ]
-            },
-            {
-                comment: "Issue #892 - new line between chained methods ",
-                unchanged: [
-                    'foo',
-                    '    .who()',
-                    '',
-                    '    .knows()',
-                    '    // comment',
-                    '    .nothing() // comment',
-                    '',
-                    '    .more()'
-                ]
-            }
-        ]
-    }, {
-        name: "Test non-positionable-ops",
-        description: "Ensure specific bugs do not recur",
-        tests: [
-            { unchanged: 'a += 2;' },
-            { unchanged: 'a -= 2;' },
-            { unchanged: 'a *= 2;' },
-            { unchanged: 'a /= 2;' },
-            { unchanged: 'a %= 2;' },
-            { unchanged: 'a &= 2;' },
-            { unchanged: 'a ^= 2;' },
-            { unchanged: 'a |= 2;' },
-            { unchanged: 'a **= 2;' },
-            { unchanged: 'a <<= 2;' },
-            { unchanged: 'a >>= 2;' },
-        ]
-    }, {
-        //Relies on the tab being four spaces as default for the tests
-        name: "brace_style ,preserve-inline tests",
-        description: "brace_style *,preserve-inline varying different brace_styles",
-        template: "< >",
-        matrix: [
-            //test for all options of brace_style
-            {
-                options: [
-                    { name: "brace_style", value: "'collapse,preserve-inline'" }
-                ],
-                obo: ' ',
-                obot: '', //Output Before Open curlybrace & Tab character
-                oao: '\n',
-                oaot: '    ', //Output After Open curlybrace & corresponding Tab
-                obc: '\n', //Output Before Close curlybrace
-                oac: ' ',
-                oact: '' //Output After Close curlybrace & corresponding Tab character
-            },
-            {
-                options: [
-                    { name: "brace_style", value: "'expand,preserve-inline'" }
-                ],
-                obo: '\n',
-                obot: '    ',
-                oao: '\n',
-                oaot: '    ',
-                obc: '\n',
-                oac: '\n',
-                oact: '    '
-            },
-            {
-                options: [
-                    { name: "brace_style", value: "'end-expand,preserve-inline'" }
-                ],
-                obo: ' ',
-                obot: '',
-                oao: '\n',
-                oaot: '    ',
-                obc: '\n',
-                oac: '\n',
-                oact: '    '
-            },
-            {
-                //None tries not to touch brace style so all the tests in this
-                //matrix were formatted as if they were collapse
-                options: [
-                    { name: "brace_style", value: "'none,preserve-inline'" }
-                ],
-                obo: ' ',
-                obot: '',
-                oao: '\n',
-                oaot: '    ',
-                obc: '\n',
-                oac: ' ',
-                oact: ''
-            },
-            //Test for backward compatibility
-            {
-                options: [
-                    { name: "brace_style", value: "'collapse-preserve-inline'" }
-                ],
-                //Equivalent to the output of the first test
-                obo: ' ',
-                obot: '',
-                oao: '\n',
-                oaot: '    ',
-                obc: '\n',
-                oac: ' ',
-                oact: ''
-            }
-        ],
-        tests: [
-            //Test single inline blocks
-            {
-                unchanged: 'import { asdf } from "asdf";'
-            },
-            {
-                unchanged: 'import { get } from "asdf";'
-            },
-            {
-                unchanged: 'function inLine() { console.log("oh em gee"); }'
-            },
-            {
-                unchanged: 'if (cancer) { console.log("Im sorry but you only have so long to live..."); }'
-            },
-            //Test more complex inliners
-            {
-                input: 'if (ding) { console.log("dong"); } else { console.log("dang"); }',
-                output: 'if (ding) { console.log("dong"); }<oac>else { console.log("dang"); }'
-            },
-            //Test complex mixes of the two
-            {
-                //The outer function and the third object (obj3) should not
-                //be preserved. All other objects should be
-                input: [
-                    'function kindaComplex() {',
-                    '    var a = 2;',
-                    '    var obj = {};',
-                    '    var obj2 = { a: "a", b: "b" };',
-                    '    var obj3 = {',
-                    '        c: "c",',
-                    '        d: "d",',
-                    '        e: "e"',
-                    '    };',
-                    '}'
-                ],
-                output: [
-                    'function kindaComplex()<obo>{<oao>' + //NL in templates
-                    '<oaot>var a = 2;',
-                    '    var obj = {};',
-                    '    var obj2 = { a: "a", b: "b" };',
-                    '    var obj3 = {<oao>' + //NL in templates, Expand doesnt affect js objects
-                    '<oaot><oaot>c: "c",',
-                    '        d: "d",',
-                    '        e: "e"' + //NL in templates
-                    '<obc>    };' + //NL in templates
-                    '<obc>}'
-                ]
-            },
-            {
-                //All inlines should be preserved, all non-inlines (specifically
-                //complex(), obj, and obj.b should not be preserved (and hence
-                //have the template spacing defined in output)
-                input: [
-                    'function complex() {',
-                    '    console.log("wowe");',
-                    '    (function() { var a = 2; var b = 3; })();',
-                    '    $.each(arr, function(el, idx) { return el; });',
-                    '    var obj = {',
-                    '        a: function() { console.log("test"); },',
-                    '        b() {',
-                    '             console.log("test2");',
-                    '        }',
-                    '    };',
-                    '}'
-
-                ],
-                output: [
-                    'function complex()<obo>{<oao>' + //NL in templates
-                    '<oaot>console.log("wowe");',
-                    '    (function() { var a = 2; var b = 3; })();',
-                    '    $.each(arr, function(el, idx) { return el; });',
-                    '    var obj = {<oao>' + //NL in templates
-                    '<oaot><oaot>a: function() { console.log("test"); },',
-                    '        b()<obo><obot><obot>{<oao>' + //NL in templates
-                    '<oaot><oaot><oaot>console.log("test2");' +
-                    '<obc>        }' + //NL in templates
-                    '<obc>    };' + //NL in templates
-                    '<obc>}'
-                ]
-            }
-        ]
-    }, {
-        name: "Destructured and related",
-        description: "Ensure specific bugs do not recur",
-        options: [
-            { name: "brace_style", value: "'collapse,preserve-inline'" }
-        ], //Issue 1052, now collapse,preserve-inline instead of collapse-preserve-inline
-        tests: [{
-                comment: "Issue 382 - import destructured ",
-                unchanged: [
-                    'module "Even" {',
-                    '    import { odd, oddly } from "Odd";',
-                    '}'
-                ]
-            },
-            {
-                unchanged: [
-                    'import defaultMember from "module-name";',
-                    'import * as name from "module-name";',
-                    'import { member } from "module-name";',
-                    'import { member as alias } from "module-name";',
-                    'import { member1, member2 } from "module-name";',
-                    'import { member1, member2 as alias2 } from "module-name";',
-                    'import defaultMember, { member, member2 } from "module-name";',
-                    'import defaultMember, * as name from "module-name";',
-                    'import "module-name";'
-                ]
-            },
-            {
-                comment: "Issue 858 - from is a keyword only after import",
-                unchanged: [
-                    'if (from < to) {',
-                    '    from++;',
-                    '} else {',
-                    '    from--;',
-                    '}'
-                ]
-            },
-            {
-                comment: "Issue 511 - destrutured",
-                unchanged: [
-                    'var { b, c } = require("../stores");',
-                    'var { ProjectStore } = require("../stores");',
-                    '',
-                    'function takeThing({ prop }) {',
-                    '    console.log("inner prop", prop)',
-                    '}'
-                ]
-            },
-            {
-                comment: "Issue 315 - Short objects",
-                unchanged: [
-                    'var a = { b: { c: { d: e } } };'
-                ]
-            },
-            {
-                unchanged: [
-                    'var a = {',
-                    '    b: {',
-                    '        c: { d: e }',
-                    '        c3: { d: e }',
-                    '    },',
-                    '    b2: { c: { d: e } }',
-                    '};'
-                ]
-            },
-            {
-                comment: "Issue 370 - Short objects in array",
-                unchanged: [
-                    'var methods = [',
-                    '    { name: "to" },',
-                    '    { name: "step" },',
-                    '    { name: "move" },',
-                    '    { name: "min" },',
-                    '    { name: "max" }',
-                    '];'
-                ]
-            },
-            {
-                comment: "Issue 838 - Short objects in array",
-                unchanged: [
-                    'function(url, callback) {',
-                    '    var script = document.createElement("script")',
-                    '    if (true) script.onreadystatechange = function() {',
-                    '        foo();',
-                    '    }',
-                    '    else script.onload = callback;',
-                    '}'
-                ]
-            },
-            {
-                comment: "Issue 578 - Odd indenting after function",
-                unchanged: [
-                    'function bindAuthEvent(eventName) {',
-                    '    self.auth.on(eventName, function(event, meta) {',
-                    '        self.emit(eventName, event, meta);',
-                    '    });',
-                    '}',
-                    '["logged_in", "logged_out", "signed_up", "updated_user"].forEach(bindAuthEvent);',
-                ]
-            },
-            {
-                comment: "Issue #487 - some short expressions examples",
-                unchanged: [
-                    'if (a == 1) { a++; }',
-                    'a = { a: a };',
-                    'UserDB.findOne({ username: "xyz" }, function(err, user) {});',
-                    'import { fs } from "fs";'
-                ]
-            },
-            {
-                comment: "Issue #982 - Fixed return expression collapse-preserve-inline",
-                unchanged: [
-                    'function foo(arg) {',
-                    '    if (!arg) { a(); }',
-                    '    if (!arg) { return false; }',
-                    '    if (!arg) { throw "inline"; }',
-                    '    return true;',
-                    '}'
-                ]
-            },
-            {
-                comment: "Issue #338 - Short expressions ",
-                unchanged: [
-                    'if (someCondition) { return something; }',
-                    'if (someCondition) {',
-                    '    return something;',
-                    '}',
-                    'if (someCondition) { break; }',
-                    'if (someCondition) {',
-                    '    return something;',
-                    '}'
-                ]
-            }
-        ]
-    }, {
-        // =======================================================
-        // New tests groups should be added above this line.
-        // Everything below is a work in progress - converting
-        // old test to generated form.
-        // =======================================================
-        name: "Old tests",
-        description: "Largely unorganized pile of tests",
-        options: [],
-        tests: [
-            { unchanged: '' },
-            { fragment: true, unchanged: '   return .5' },
-            { fragment: true, unchanged: '   return .5;\n   a();' },
-            { fragment: true, unchanged: '    return .5;\n    a();' },
-            { fragment: true, unchanged: '     return .5;\n     a();' },
-            { fragment: true, unchanged: '   < div' },
-            { input: 'a        =          1', output: 'a = 1' },
-            { input: 'a=1', output: 'a = 1' },
-            { unchanged: '(3) / 2' },
-            { unchanged: '["a", "b"].join("")' },
-            { unchanged: 'a();\n\nb();' },
-            { input: 'var a = 1 var b = 2', output: 'var a = 1\nvar b = 2' },
-            { input: 'var a=1, b=c[d], e=6;', output: 'var a = 1,\n    b = c[d],\n    e = 6;' },
-            { unchanged: 'var a,\n    b,\n    c;' },
-            { input: 'let a = 1 let b = 2', output: 'let a = 1\nlet b = 2' },
-            { input: 'let a=1, b=c[d], e=6;', output: 'let a = 1,\n    b = c[d],\n    e = 6;' },
-            { unchanged: 'let a,\n    b,\n    c;' },
-            { input: 'const a = 1 const b = 2', output: 'const a = 1\nconst b = 2' },
-            { input: 'const a=1, b=c[d], e=6;', output: 'const a = 1,\n    b = c[d],\n    e = 6;' },
-            { unchanged: 'const a,\n    b,\n    c;' },
-            { unchanged: 'a = " 12345 "' },
-            { unchanged: "a = \\' 12345 \\'" },
-            { unchanged: 'if (a == 1) b = 2;' },
-            { input: 'if(1){2}else{3}', output: 'if (1) {\n    2\n} else {\n    3\n}' },
-            { input: 'if(1||2);', output: 'if (1 || 2);' },
-            { input: '(a==1)||(b==2)', output: '(a == 1) || (b == 2)' },
-            { input: 'var a = 1 if (2) 3;', output: 'var a = 1\nif (2) 3;' },
-            { unchanged: 'a = a + 1' },
-            { unchanged: 'a = a == 1' },
-            { unchanged: '/12345[^678]*9+/.match(a)' },
-            { unchanged: 'a /= 5' },
-            { unchanged: 'a = 0.5 * 3' },
-            { unchanged: 'a *= 10.55' },
-            { unchanged: 'a < .5' },
-            { unchanged: 'a <= .5' },
-            { input: 'a<.5', output: 'a < .5' },
-            { input: 'a<=.5', output: 'a <= .5' },
-
-            {
-                comment: 'exponent literals',
-                unchanged: 'a = 1e10'
-            },
-            { unchanged: 'a = 1.3e10' },
-            { unchanged: 'a = 1.3e-10' },
-            { unchanged: 'a = -12345.3e-10' },
-            { unchanged: 'a = .12345e-10' },
-            { unchanged: 'a = 06789e-10' },
-            { unchanged: 'a = e - 10' },
-            { unchanged: 'a = 1.3e+10' },
-            { unchanged: 'a = 1.e-7' },
-            { unchanged: 'a = -12345.3e+10' },
-            { unchanged: 'a = .12345e+10' },
-            { unchanged: 'a = 06789e+10' },
-            { unchanged: 'a = e + 10' },
-            { input: 'a=0e-12345.3e-10', output: 'a = 0e-12345 .3e-10' },
-            { input: 'a=0.e-12345.3e-10', output: 'a = 0.e-12345 .3e-10' },
-            { input: 'a=0x.e-12345.3e-10', output: 'a = 0x.e - 12345.3e-10' },
-            { input: 'a=0x0.e-12345.3e-10', output: 'a = 0x0.e - 12345.3e-10' },
-            { input: 'a=0x0.0e-12345.3e-10', output: 'a = 0x0 .0e-12345 .3e-10' },
-            { input: 'a=0g-12345.3e-10', output: 'a = 0 g - 12345.3e-10' },
-            { input: 'a=0.g-12345.3e-10', output: 'a = 0. g - 12345.3e-10' },
-            { input: 'a=0x.g-12345.3e-10', output: 'a = 0x.g - 12345.3e-10' },
-            { input: 'a=0x0.g-12345.3e-10', output: 'a = 0x0.g - 12345.3e-10' },
-            { input: 'a=0x0.0g-12345.3e-10', output: 'a = 0x0 .0 g - 12345.3e-10' },
-
-            {
-                comment: 'Decimal literals',
-                unchanged: 'a = 0123456789;'
-            },
-            { unchanged: 'a = 9876543210;' },
-            { unchanged: 'a = 5647308291;' },
-            { input: 'a=030e-5', output: 'a = 030e-5' },
-            { input: 'a=00+4', output: 'a = 00 + 4' },
-            { input: 'a=32+4', output: 'a = 32 + 4' },
-            { input: 'a=0.6g+4', output: 'a = 0.6 g + 4' },
-            { input: 'a=01.10', output: 'a = 01.10' },
-            { input: 'a=a.10', output: 'a = a .10' },
-            { input: 'a=00B0x0', output: 'a = 00 B0x0' },
-            { input: 'a=00B0xb0', output: 'a = 00 B0xb0' },
-            { input: 'a=00B0x0b0', output: 'a = 00 B0x0b0' },
-            { input: 'a=0090x0', output: 'a = 0090 x0' },
-            { input: 'a=0g0b0o0', output: 'a = 0 g0b0o0' },
-
-            {
-                comment: 'Hexadecimal literals',
-                unchanged: 'a = 0x0123456789abcdef;'
-            },
-            { unchanged: 'a = 0X0123456789ABCDEF;' },
-            { unchanged: 'a = 0xFeDcBa9876543210;' },
-            { input: 'a=0x30e-5', output: 'a = 0x30e - 5' },
-            { input: 'a=0xF0+4', output: 'a = 0xF0 + 4' },
-            { input: 'a=0Xff+4', output: 'a = 0Xff + 4' },
-            { input: 'a=0Xffg+4', output: 'a = 0Xff g + 4' },
-            { input: 'a=0x01.10', output: 'a = 0x01 .10' },
-            { unchanged: 'a = 0xb0ce;' },
-            { unchanged: 'a = 0x0b0;' },
-            { input: 'a=0x0B0x0', output: 'a = 0x0B0 x0' },
-            { input: 'a=0x0B0xb0', output: 'a = 0x0B0 xb0' },
-            { input: 'a=0x0B0x0b0', output: 'a = 0x0B0 x0b0' },
-            { input: 'a=0X090x0', output: 'a = 0X090 x0' },
-            { input: 'a=0Xg0b0o0', output: 'a = 0X g0b0o0' },
-
-            {
-                comment: 'Octal literals',
-                unchanged: 'a = 0o01234567;'
-            },
-            { unchanged: 'a = 0O01234567;' },
-            { unchanged: 'a = 0o34120675;' },
-            { input: 'a=0o30e-5', output: 'a = 0o30 e - 5' },
-            { input: 'a=0o70+4', output: 'a = 0o70 + 4' },
-            { input: 'a=0O77+4', output: 'a = 0O77 + 4' },
-            { input: 'a=0O778+4', output: 'a = 0O77 8 + 4' },
-            { input: 'a=0O77a+4', output: 'a = 0O77 a + 4' },
-            { input: 'a=0o01.10', output: 'a = 0o01 .10' },
-            { input: 'a=0o0B0x0', output: 'a = 0o0 B0x0' },
-            { input: 'a=0o0B0xb0', output: 'a = 0o0 B0xb0' },
-            { input: 'a=0o0B0x0b0', output: 'a = 0o0 B0x0b0' },
-            { input: 'a=0O090x0', output: 'a = 0O0 90 x0' },
-            { input: 'a=0Og0b0o0', output: 'a = 0O g0b0o0' },
-
-            {
-                comment: 'Binary literals',
-                unchanged: 'a = 0b010011;'
-            },
-            { unchanged: 'a = 0B010011;' },
-            { unchanged: 'a = 0b01001100001111;' },
-            { input: 'a=0b10e-5', output: 'a = 0b10 e - 5' },
-            { input: 'a=0b10+4', output: 'a = 0b10 + 4' },
-            { input: 'a=0B11+4', output: 'a = 0B11 + 4' },
-            { input: 'a=0B112+4', output: 'a = 0B11 2 + 4' },
-            { input: 'a=0B11a+4', output: 'a = 0B11 a + 4' },
-            { input: 'a=0b01.10', output: 'a = 0b01 .10' },
-            { input: 'a=0b0B0x0', output: 'a = 0b0 B0x0' },
-            { input: 'a=0b0B0xb0', output: 'a = 0b0 B0xb0' },
-            { input: 'a=0b0B0x0b0', output: 'a = 0b0 B0x0b0' },
-            { input: 'a=0B090x0', output: 'a = 0B0 90 x0' },
-            { input: 'a=0Bg0b0o0', output: 'a = 0B g0b0o0' },
-            { unchanged: 'a = [1, 2, 3, 4]' },
-            { input: 'F*(g/=f)*g+b', output: 'F * (g /= f) * g + b' },
-            { input: 'a.b({c:d})', output: 'a.b({\n    c: d\n})' },
-            { input: 'a.b\n(\n{\nc:\nd\n}\n)', output: 'a.b({\n    c: d\n})' },
-            { input: 'a.b({c:"d"})', output: 'a.b({\n    c: "d"\n})' },
-            { input: 'a.b\n(\n{\nc:\n"d"\n}\n)', output: 'a.b({\n    c: "d"\n})' },
-            { input: 'a=!b', output: 'a = !b' },
-            { input: 'a=!!b', output: 'a = !!b' },
-            { input: 'a?b:c', output: 'a ? b : c' },
-            { input: 'a?1:2', output: 'a ? 1 : 2' },
-            { input: 'a?(b):c', output: 'a ? (b) : c' },
-            { input: 'x={a:1,b:w=="foo"?x:y,c:z}', output: 'x = {\n    a: 1,\n    b: w == "foo" ? x : y,\n    c: z\n}' },
-            { input: 'x=a?b?c?d:e:f:g;', output: 'x = a ? b ? c ? d : e : f : g;' },
-            { input: 'x=a?b?c?d:{e1:1,e2:2}:f:g;', output: 'x = a ? b ? c ? d : {\n    e1: 1,\n    e2: 2\n} : f : g;' },
-            { unchanged: 'function void(void) {}' },
-            { input: 'if(!a)foo();', output: 'if (!a) foo();' },
-            { input: 'a=~a', output: 'a = ~a' },
-            { input: 'a;/*comment*/b;', output: "a; /*comment*/\nb;" },
-            { input: 'a;/* comment */b;', output: "a; /* comment */\nb;" },
-            { fragment: true, input: 'a;/*\ncomment\n*/b;', output: "a;\n/*\ncomment\n*/\nb;", comment: "simple comments don't get touched at all" },
-            { input: 'a;/**\n* javadoc\n*/b;', output: "a;\n/**\n * javadoc\n */\nb;" },
-            { fragment: true, input: 'a;/**\n\nno javadoc\n*/b;', output: "a;\n/**\n\nno javadoc\n*/\nb;" },
-            { input: 'a;/*\n* javadoc\n*/b;', output: "a;\n/*\n * javadoc\n */\nb;", comment: 'comment blocks detected and reindented even w/o javadoc starter' },
-            { input: 'if(a)break;', output: "if (a) break;" },
-            { input: 'if(a){break}', output: "if (a) {\n    break\n}" },
-            { input: 'if((a))foo();', output: 'if ((a)) foo();' },
-            { input: 'for(var i=0;;) a', output: 'for (var i = 0;;) a' },
-            { input: 'for(var i=0;;)\na', output: 'for (var i = 0;;)\n    a' },
-            { unchanged: 'a++;' },
-            { input: 'for(;;i++)a()', output: 'for (;; i++) a()' },
-            { input: 'for(;;i++)\na()', output: 'for (;; i++)\n    a()' },
-            { input: 'for(;;++i)a', output: 'for (;; ++i) a' },
-            { input: 'return(1)', output: 'return (1)' },
-            { input: 'try{a();}catch(b){c();}finally{d();}', output: "try {\n    a();\n} catch (b) {\n    c();\n} finally {\n    d();\n}" },
-            { unchanged: '(xx)()', comment: ' magic function call' },
-            { unchanged: 'a[1]()', comment: 'another magic function call' },
-            { input: 'if(a){b();}else if(c) foo();', output: "if (a) {\n    b();\n} else if (c) foo();" },
-            { input: 'switch(x) {case 0: case 1: a(); break; default: break}', output: "switch (x) {\n    case 0:\n    case 1:\n        a();\n        break;\n    default:\n        break\n}" },
-            { input: 'switch(x){case -1:break;case !y:break;}', output: 'switch (x) {\n    case -1:\n        break;\n    case !y:\n        break;\n}' },
-            { unchanged: 'a !== b' },
-            { input: 'if (a) b(); else c();', output: "if (a) b();\nelse c();" },
-            { unchanged: "// comment\n(function something() {})", comment: 'typical greasemonkey start' },
-            { unchanged: "{\n\n    x();\n\n}", comment: 'duplicating newlines' },
-            { unchanged: 'if (a in b) foo();' },
-            { unchanged: 'if (a of b) foo();' },
-            { unchanged: 'if (a of [1, 2, 3]) foo();' },
-            {
-                input: 'if(X)if(Y)a();else b();else c();',
-                output: "if (X)\n    if (Y) a();\n    else b();\nelse c();"
-            },
-            { unchanged: 'if (foo) bar();\nelse break' },
-            { unchanged: 'var a, b;' },
-            { unchanged: 'var a = new function();' },
-            { fragment: true, unchanged: 'new function' },
-            { unchanged: 'var a, b' },
-            { input: '{a:1, b:2}', output: "{\n    a: 1,\n    b: 2\n}" },
-            { input: 'a={1:[-1],2:[+1]}', output: 'a = {\n    1: [-1],\n    2: [+1]\n}' },
-            { input: "var l = {\\'a\\':\\'1\\', \\'b\\':\\'2\\'}", output: "var l = {\n    \\'a\\': \\'1\\',\n    \\'b\\': \\'2\\'\n}" },
-            { unchanged: 'if (template.user[n] in bk) foo();' },
-            { unchanged: 'return 45' },
-            { unchanged: 'return this.prevObject ||\n\n    this.constructor(null);' },
-            { unchanged: 'If[1]' },
-            { unchanged: 'Then[1]' },
-            { input: "a = 1;// comment", output: "a = 1; // comment" },
-            { unchanged: "a = 1; // comment" },
-            { input: "a = 1;\n // comment", output: "a = 1;\n// comment" },
-            { unchanged: 'a = [-1, -1, -1]' },
-
-            // These must work as non-fragments.
-            { unchanged: ['// a', '// b', '', '', '', '// c', '// d'] },
-            { unchanged: ['// func-comment', '', 'function foo() {}', '', '// end-func-comment'] },
-
-            {
-                comment: 'The exact formatting these should have is open for discussion, but they are at least reasonable',
-                unchanged: 'a = [ // comment\n    -1, -1, -1\n]'
-            },
-            { unchanged: 'var a = [ // comment\n    -1, -1, -1\n]' },
-            { unchanged: 'a = [ // comment\n    -1, // comment\n    -1, -1\n]' },
-            { unchanged: 'var a = [ // comment\n    -1, // comment\n    -1, -1\n]' },
-
-            { input: 'o = [{a:b},{c:d}]', output: 'o = [{\n    a: b\n}, {\n    c: d\n}]' },
-
-            {
-                comment: 'was: extra space appended',
-                unchanged: "if (a) {\n    do();\n}"
-            },
-
-            {
-                comment: 'if/else statement with empty body',
-                input: "if (a) {\n// comment\n}else{\n// comment\n}",
-                output: "if (a) {\n    // comment\n} else {\n    // comment\n}"
-            },
-            { comment: 'multiple comments indentation', input: "if (a) {\n// comment\n// comment\n}", output: "if (a) {\n    // comment\n    // comment\n}" },
-            { input: "if (a) b() else c();", output: "if (a) b()\nelse c();" },
-            { input: "if (a) b() else if c() d();", output: "if (a) b()\nelse if c() d();" },
-
-            { unchanged: "{}" },
-            { unchanged: "{\n\n}" },
-            { input: "do { a(); } while ( 1 );", output: "do {\n    a();\n} while (1);" },
-            { unchanged: "do {} while (1);" },
-            { input: "do {\n} while (1);", output: "do {} while (1);" },
-            { unchanged: "do {\n\n} while (1);" },
-            { unchanged: "var a = x(a, b, c)" },
-            { input: "delete x if (a) b();", output: "delete x\nif (a) b();" },
-            { input: "delete x[x] if (a) b();", output: "delete x[x]\nif (a) b();" },
-            { input: "for(var a=1,b=2)d", output: "for (var a = 1, b = 2) d" },
-            { input: "for(var a=1,b=2,c=3) d", output: "for (var a = 1, b = 2, c = 3) d" },
-            { input: "for(var a=1,b=2,c=3;d<3;d++)\ne", output: "for (var a = 1, b = 2, c = 3; d < 3; d++)\n    e" },
-            { input: "function x(){(a||b).c()}", output: "function x() {\n    (a || b).c()\n}" },
-            { input: "function x(){return - 1}", output: "function x() {\n    return -1\n}" },
-            { input: "function x(){return ! a}", output: "function x() {\n    return !a\n}" },
-            { unchanged: "x => x" },
-            { unchanged: "(x) => x" },
-            { input: "x => { x }", output: "x => {\n    x\n}" },
-            { input: "(x) => { x }", output: "(x) => {\n    x\n}" },
-
-            {
-                comment: 'a common snippet in jQuery plugins',
-                input_: "settings = $.extend({},defaults,settings);",
-                output: "settings = $.extend({}, defaults, settings);"
-            },
-
-            // reserved words used as property names
-            { unchanged: "$http().then().finally().default()" },
-            { input: "$http()\n.then()\n.finally()\n.default()", output: "$http()\n    .then()\n    .finally()\n    .default()" },
-            { unchanged: "$http().when.in.new.catch().throw()" },
-            { input: "$http()\n.when\n.in\n.new\n.catch()\n.throw()", output: "$http()\n    .when\n    .in\n    .new\n    .catch()\n    .throw()" },
-
-            { input: '{xxx;}()', output: '{\n    xxx;\n}()' },
-
-            { unchanged: "a = \\'a\\'\nb = \\'b\\'" },
-            { unchanged: "a = /reg/exp" },
-            { unchanged: "a = /reg/" },
-            { unchanged: '/abc/.test()' },
-            { unchanged: '/abc/i.test()' },
-            { input: "{/abc/i.test()}", output: "{\n    /abc/i.test()\n}" },
-            { input: 'var x=(a)/a;', output: 'var x = (a) / a;' },
-
-            { unchanged: 'x != -1' },
-
-            { input: 'for (; s-->0;)t', output: 'for (; s-- > 0;) t' },
-            { input: 'for (; s++>0;)u', output: 'for (; s++ > 0;) u' },
-            { input: 'a = s++>s--;', output: 'a = s++ > s--;' },
-            { input: 'a = s++>--s;', output: 'a = s++ > --s;' },
-
-            { input: '{x=#1=[]}', output: '{\n    x = #1=[]\n}' },
-            { input: '{a:#1={}}', output: '{\n    a: #1={}\n}' },
-            { input: '{a:#1#}', output: '{\n    a: #1#\n}' },
-
-            { fragment: true, unchanged: '"incomplete-string' },
-            { fragment: true, unchanged: "\\'incomplete-string" },
-            { fragment: true, unchanged: '/incomplete-regex' },
-            { fragment: true, unchanged: '`incomplete-template-string' },
-
-            { fragment: true, input: '{a:1},{a:2}', output: '{\n    a: 1\n}, {\n    a: 2\n}' },
-            { fragment: true, input: 'var ary=[{a:1}, {a:2}];', output: 'var ary = [{\n    a: 1\n}, {\n    a: 2\n}];' },
-
-            { comment: 'incomplete', fragment: true, input: '{a:#1', output: '{\n    a: #1' },
-            { comment: 'incomplete', fragment: true, input: '{a:#', output: '{\n    a: #' },
-
-            { comment: 'incomplete', fragment: true, input: '}}}', output: '}\n}\n}' },
-
-            { fragment: true, unchanged: '<!--\nvoid();\n// -->' },
-
-            { comment: 'incomplete regexp', fragment: true, input: 'a=/regexp', output: 'a = /regexp' },
-
-            { input: '{a:#1=[],b:#1#,c:#999999#}', output: '{\n    a: #1=[],\n    b: #1#,\n    c: #999999#\n}' },
-
-            { input: "do{x()}while(a>1)", output: "do {\n    x()\n} while (a > 1)" },
-
-            { input: "x(); /reg/exp.match(something)", output: "x();\n/reg/exp.match(something)" },
-
-            { fragment: true, input: "something();(", output: "something();\n(" },
-            { fragment: true, input: "#!she/bangs, she bangs\nf=1", output: "#!she/bangs, she bangs\n\nf = 1" },
-            { fragment: true, input: "#!she/bangs, she bangs\n\nf=1", output: "#!she/bangs, she bangs\n\nf = 1" },
-            { fragment: true, unchanged: "#!she/bangs, she bangs\n\n/* comment */" },
-            { fragment: true, unchanged: "#!she/bangs, she bangs\n\n\n/* comment */" },
-            { fragment: true, unchanged: "#" },
-            { fragment: true, unchanged: "#!" },
-
-            { unchanged: "function namespace::something()" },
-
-            { fragment: true, unchanged: "<!--\nsomething();\n-->" },
-            { fragment: true, input: "<!--\nif(i<0){bla();}\n-->", output: "<!--\nif (i < 0) {\n    bla();\n}\n-->" },
-
-            { input: '{foo();--bar;}', output: '{\n    foo();\n    --bar;\n}' },
-            { input: '{foo();++bar;}', output: '{\n    foo();\n    ++bar;\n}' },
-            { input: '{--bar;}', output: '{\n    --bar;\n}' },
-            { input: '{++bar;}', output: '{\n    ++bar;\n}' },
-            { input: 'if(true)++a;', output: 'if (true) ++a;' },
-            { input: 'if(true)\n++a;', output: 'if (true)\n    ++a;' },
-            { input: 'if(true)--a;', output: 'if (true) --a;' },
-            { input: 'if(true)\n--a;', output: 'if (true)\n    --a;' },
-            { unchanged: 'elem[array]++;' },
-            { unchanged: 'elem++ * elem[array]++;' },
-            { unchanged: 'elem-- * -elem[array]++;' },
-            { unchanged: 'elem-- + elem[array]++;' },
-            { unchanged: 'elem-- - elem[array]++;' },
-            { unchanged: 'elem-- - -elem[array]++;' },
-            { unchanged: 'elem-- - +elem[array]++;' },
-
-
-            {
-                comment: 'Handling of newlines around unary ++ and -- operators',
-                input: '{foo\n++bar;}',
-                output: '{\n    foo\n    ++bar;\n}'
-            },
-            { input: '{foo++\nbar;}', output: '{\n    foo++\n    bar;\n}' },
-
-            {
-                comment: 'This is invalid, but harder to guard against. Issue #203.',
-                input: '{foo\n++\nbar;}',
-                output: '{\n    foo\n    ++\n    bar;\n}'
-            },
-
-            {
-                comment: 'regexps',
-                input: 'a(/abc\\\\/\\\\/def/);b()',
-                output: "a(/abc\\\\/\\\\/def/);\nb()"
-            },
-            { input: 'a(/a[b\\\\[\\\\]c]d/);b()', output: "a(/a[b\\\\[\\\\]c]d/);\nb()" },
-            { comment: 'incomplete char class', fragment: true, unchanged: 'a(/a[b\\\\[' },
-
-            {
-                comment: 'allow unescaped / in char classes',
-                input: 'a(/[a/b]/);b()',
-                output: "a(/[a/b]/);\nb()"
-            },
-            { unchanged: 'typeof /foo\\\\//;' },
-            { unchanged: 'throw /foo\\\\//;' },
-            { unchanged: 'do /foo\\\\//;' },
-            { unchanged: 'return /foo\\\\//;' },
-            { unchanged: 'switch (a) {\n    case /foo\\\\//:\n        b\n}' },
-            { unchanged: 'if (a) /foo\\\\//\nelse /foo\\\\//;' },
-
-            { unchanged: 'if (foo) /regex/.test();' },
-            { unchanged: "for (index in [1, 2, 3]) /^test$/i.test(s)" },
-
-            { unchanged: 'function foo() {\n    return [\n        "one",\n        "two"\n    ];\n}' },
-            { input: 'a=[[1,2],[4,5],[7,8]]', output: "a = [\n    [1, 2],\n    [4, 5],\n    [7, 8]\n]" },
-            {
-                input: 'a=[[1,2],[4,5],function(){},[7,8]]',
-                output: "a = [\n    [1, 2],\n    [4, 5],\n    function() {},\n    [7, 8]\n]"
-            },
-            {
-                input: 'a=[[1,2],[4,5],function(){},function(){},[7,8]]',
-                output: "a = [\n    [1, 2],\n    [4, 5],\n    function() {},\n    function() {},\n    [7, 8]\n]"
-            },
-            {
-                input: 'a=[[1,2],[4,5],function(){},[7,8]]',
-                output: "a = [\n    [1, 2],\n    [4, 5],\n    function() {},\n    [7, 8]\n]"
-            },
-            {
-                input: 'a=[b,c,function(){},function(){},d]',
-                output: "a = [b, c, function() {}, function() {}, d]"
-            },
-            {
-                input: 'a=[b,c,\nfunction(){},function(){},d]',
-                output: "a = [b, c,\n    function() {},\n    function() {},\n    d\n]"
-            },
-            { input: 'a=[a[1],b[4],c[d[7]]]', output: "a = [a[1], b[4], c[d[7]]]" },
-            { input: '[1,2,[3,4,[5,6],7],8]', output: "[1, 2, [3, 4, [5, 6], 7], 8]" },
-
-            {
-                input: '[[["1","2"],["3","4"]],[["5","6","7"],["8","9","0"]],[["1","2","3"],["4","5","6","7"],["8","9","0"]]]',
-                output: '[\n    [\n        ["1", "2"],\n        ["3", "4"]\n    ],\n    [\n        ["5", "6", "7"],\n        ["8", "9", "0"]\n    ],\n    [\n        ["1", "2", "3"],\n        ["4", "5", "6", "7"],\n        ["8", "9", "0"]\n    ]\n]'
-            },
-
-            { input: '{[x()[0]];indent;}', output: '{\n    [x()[0]];\n    indent;\n}' },
-            { unchanged: '/*\n foo trailing space    \n * bar trailing space   \n**/' },
-            { unchanged: '{\n    /*\n    foo    \n    * bar    \n    */\n}' },
-
-            { unchanged: 'return ++i' },
-            { unchanged: 'return !!x' },
-            { unchanged: 'return !x' },
-            { input: 'return [1,2]', output: 'return [1, 2]' },
-            { unchanged: 'return;' },
-            { unchanged: 'return\nfunc' },
-            { input: 'catch(e)', output: 'catch (e)' },
-
-            {
-                input: 'var a=1,b={foo:2,bar:3},{baz:4,wham:5},c=4;',
-                output: 'var a = 1,\n    b = {\n        foo: 2,\n        bar: 3\n    },\n    {\n        baz: 4,\n        wham: 5\n    }, c = 4;'
-            },
-            {
-                input: 'var a=1,b={foo:2,bar:3},{baz:4,wham:5},\nc=4;',
-                output: 'var a = 1,\n    b = {\n        foo: 2,\n        bar: 3\n    },\n    {\n        baz: 4,\n        wham: 5\n    },\n    c = 4;'
-            },
-
-            {
-                comment: 'inline comment',
-                input_: 'function x(/*int*/ start, /*string*/ foo)',
-                output: 'function x( /*int*/ start, /*string*/ foo)'
-            },
-
-            {
-                comment: 'javadoc comment',
-                input: '/**\n* foo\n*/',
-                output: '/**\n * foo\n */'
-            },
-            { input: '{\n/**\n* foo\n*/\n}', output: '{\n    /**\n     * foo\n     */\n}' },
-
-            {
-                comment: 'starless block comment',
-                unchanged: '/**\nfoo\n*/'
-            },
-            { unchanged: '/**\nfoo\n**/' },
-            { unchanged: '/**\nfoo\nbar\n**/' },
-            { unchanged: '/**\nfoo\n\nbar\n**/' },
-            { unchanged: '/**\nfoo\n    bar\n**/' },
-            { input: '{\n/**\nfoo\n*/\n}', output: '{\n    /**\n    foo\n    */\n}' },
-            { input: '{\n/**\nfoo\n**/\n}', output: '{\n    /**\n    foo\n    **/\n}' },
-            { input: '{\n/**\nfoo\nbar\n**/\n}', output: '{\n    /**\n    foo\n    bar\n    **/\n}' },
-            { input: '{\n/**\nfoo\n\nbar\n**/\n}', output: '{\n    /**\n    foo\n\n    bar\n    **/\n}' },
-            { input: '{\n/**\nfoo\n    bar\n**/\n}', output: '{\n    /**\n    foo\n        bar\n    **/\n}' },
-            { unchanged: '{\n    /**\n    foo\nbar\n    **/\n}' },
-
-            { input: 'var a,b,c=1,d,e,f=2;', output: 'var a, b, c = 1,\n    d, e, f = 2;' },
-            { input: 'var a,b,c=[],d,e,f=2;', output: 'var a, b, c = [],\n    d, e, f = 2;' },
-            { unchanged: 'function() {\n    var a, b, c, d, e = [],\n        f;\n}' },
-
-            { input: 'do/regexp/;\nwhile(1);', output: 'do /regexp/;\nwhile (1);' },
-            { input: 'var a = a,\na;\nb = {\nb\n}', output: 'var a = a,\n    a;\nb = {\n    b\n}' },
-
-            { unchanged: 'var a = a,\n    /* c */\n    b;' },
-            { unchanged: 'var a = a,\n    // c\n    b;' },
-
-            {
-                comment: 'weird element referencing',
-                unchanged: 'foo.("bar");'
-            },
-
-
-            { unchanged: 'if (a) a()\nelse b()\nnewline()' },
-            { unchanged: 'if (a) a()\nnewline()' },
-            { input: 'a=typeof(x)', output: 'a = typeof(x)' },
-
-            { unchanged: 'var a = function() {\n        return null;\n    },\n    b = false;' },
-
-            { unchanged: 'var a = function() {\n    func1()\n}' },
-            { unchanged: 'var a = function() {\n    func1()\n}\nvar b = function() {\n    func2()\n}' },
-
-            {
-                comment: 'code with and without semicolons',
-                input_: 'var whatever = require("whatever");\nfunction() {\n    a = 6;\n}',
-                output: 'var whatever = require("whatever");\n\nfunction() {\n    a = 6;\n}'
-            },
-            {
-                input: 'var whatever = require("whatever")\nfunction() {\n    a = 6\n}',
-                output: 'var whatever = require("whatever")\n\nfunction() {\n    a = 6\n}'
-            },
-
-            { input: '{"x":[{"a":1,"b":3},\n7,8,8,8,8,{"b":99},{"a":11}]}', output: '{\n    "x": [{\n            "a": 1,\n            "b": 3\n        },\n        7, 8, 8, 8, 8, {\n            "b": 99\n        }, {\n            "a": 11\n        }\n    ]\n}' },
-            { input: '{"x":[{"a":1,"b":3},7,8,8,8,8,{"b":99},{"a":11}]}', output: '{\n    "x": [{\n        "a": 1,\n        "b": 3\n    }, 7, 8, 8, 8, 8, {\n        "b": 99\n    }, {\n        "a": 11\n    }]\n}' },
-
-            { input: '{"1":{"1a":"1b"},"2"}', output: '{\n    "1": {\n        "1a": "1b"\n    },\n    "2"\n}' },
-            { input: '{a:{a:b},c}', output: '{\n    a: {\n        a: b\n    },\n    c\n}' },
-
-            { input: '{[y[a]];keep_indent;}', output: '{\n    [y[a]];\n    keep_indent;\n}' },
-
-            { input: 'if (x) {y} else { if (x) {y}}', output: 'if (x) {\n    y\n} else {\n    if (x) {\n        y\n    }\n}' },
-
-            { unchanged: 'if (foo) one()\ntwo()\nthree()' },
-            { unchanged: 'if (1 + foo() && bar(baz()) / 2) one()\ntwo()\nthree()' },
-            { unchanged: 'if (1 + foo() && bar(baz()) / 2) one();\ntwo();\nthree();' },
-
-            { input: 'var a=1,b={bang:2},c=3;', output: 'var a = 1,\n    b = {\n        bang: 2\n    },\n    c = 3;' },
-            { input: 'var a={bing:1},b=2,c=3;', output: 'var a = {\n        bing: 1\n    },\n    b = 2,\n    c = 3;' },
-
-        ],
-    }],
-    examples: [{
-        // Example
-        group_name: "one",
-        description: "",
-        options: [],
-        values: [{
-            source: "", //string or array of lines
-            output: "" //string or array of lines
-        }]
-    }]
-};