js-beautify 0.1.7

data/js-beautify-copy/tests/run-tests

@@ -0,0 +1,17 @@
+#!/usr/bin/js
+
+// a little helper for testing from command line
+// just run it, it will output the test results
+
+try {
+    load('beautify.js');
+    load('tests/sanitytest.js')
+    load('tests/beautify-tests.js')
+} catch (yada) {
+    load('../beautify.js');
+    //load('sanitytest.js')
+    load('beautify-tests.js')
+}
+
+print(run_beautifier_tests().results_raw())
+

data/js-beautify-copy/tests/sanitytest.js

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

data/js-beautify-copy/unpackers/javascriptobfuscator_unpacker.js

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

data/js-beautify-copy/unpackers/myobfuscate_unpacker.js

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

data/js-beautify-copy/unpackers/p_a_c_k_e_r_unpacker.js

@@ -0,0 +1,61 @@
+//
+// Unpacker for Dean Edward's p.a.c.k.e.r, a part of javascript beautifier
+// written by Einar Lielmanis <einar@jsbeautifier.org>
+//
+// Coincidentally, it can defeat a couple of other eval-based compressors.
+//
+// usage:
+//
+// if (P_A_C_K_E_R.detect(some_string)) {
+//     var unpacked = P_A_C_K_E_R.unpack(some_string);
+// }
+// 
+//
+
+var P_A_C_K_E_R = {
+    detect: function (str) {
+        return P_A_C_K_E_R._starts_with(str.toLowerCase().replace(/ +/g, ''), 'eval(function(') ||
+               P_A_C_K_E_R._starts_with(str.toLowerCase().replace(/ +/g, ''), 'eval((function(') ;
+    },
+
+    unpack: function (str) {
+        var unpacked_source = '';
+        if (P_A_C_K_E_R.detect(str)) {
+            try {
+                eval('unpacked_source = ' + str.substring(4) + ';')
+                if (typeof unpacked_source == 'string' && unpacked_source) {
+                    str = unpacked_source;
+                }
+            } catch (error) {
+                // well, it failed. we'll just return the original, instead of crashing on user.
+            }
+        }
+        return str;
+    },
+
+    _starts_with: function (str, what) {
+        return str.substr(0, what.length) === what;
+    },
+
+    run_tests: function (sanity_test) {
+        var t = sanity_test || new SanityTest();
+        t.test_function(P_A_C_K_E_R.detect, "P_A_C_K_E_R.detect");
+        t.expect('', false);
+        t.expect('var a = b', false);
+        t.expect('eval(function(p,a,c,k,e,r', true);
+        t.expect('eval ( function(p, a, c, k, e, r', true);
+        t.test_function(P_A_C_K_E_R.unpack, 'P_A_C_K_E_R.unpack');
+        t.expect("eval(function(p,a,c,k,e,r){e=String;if(!''.replace(/^/,String)){while(c--)r[c]=k[c]||c;k=[function(e){return r[e]}];e=function(){return'\\\\w+'};c=1};while(c--)if(k[c])p=p.replace(new RegExp('\\\\b'+e(c)+'\\\\b','g'),k[c]);return p}('0 2=1',3,3,'var||a'.split('|'),0,{}))",
+            'var a=1');
+
+        var starts_with_a = function(what) { return P_A_C_K_E_R._starts_with(what, 'a'); }
+        t.test_function(starts_with_a, "P_A_C_K_E_R._starts_with(?, a)");
+        t.expect('abc', true);
+        t.expect('bcd', false);
+        t.expect('a', true);
+        t.expect('', false);
+        return t;
+    }
+
+
+}

data/js-beautify-copy/unpackers/urlencode_unpacker.js

@@ -0,0 +1,51 @@
+//
+// trivial bookmarklet/escaped script detector for the javascript beautifier
+// written by Einar Lielmanis <einar@jsbeautifier.org>
+//
+// usage:
+//
+// if (Urlencoded.detect(some_string)) {
+//     var unpacked = Urlencoded.unpack(some_string);
+// }
+// 
+//
+
+var Urlencoded = {
+    detect: function (str) {
+        // the fact that script doesn't contain any space, but has %20 instead
+        // should be sufficient check for now.
+        if (str.indexOf(' ') == -1) {
+            if (str.indexOf('%20') != -1) return true;
+            if (str.replace(/[^%]+/g, '').length > 3) return true;
+        }
+        return false;
+    },
+
+    unpack: function (str) {
+        if (Urlencoded.detect(str)) {
+            return unescape(str.replace(/\+/g, '%20'));
+        }
+        return str;
+    },
+
+
+
+    run_tests: function (sanity_test) {
+        var t = sanity_test || new SanityTest();
+        t.test_function(Urlencoded.detect, "Urlencoded.detect");
+        t.expect('', false);
+        t.expect('var a = b', false);
+        t.expect('var%20a+=+b', true);
+        t.expect('var%20a=b', true);
+        t.expect('var%20%21%22', true);
+        t.test_function(Urlencoded.unpack, 'Urlencoded.unpack');
+        t.expect('', '');
+        t.expect('abcd', 'abcd');
+        t.expect('var a = b', 'var a = b');
+        t.expect('var%20a=b', 'var a=b');
+        t.expect('var%20a+=+b', 'var a = b');
+        return t;
+    }
+
+
+}