dexbot 1.4.11 → 1.4.13

package/claw/node_modules/long/tests/suite.js

@@ -0,0 +1,195 @@
+/*
+ Copyright 2013 Daniel Wirtz <dcode@dcode.io>
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS-IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+var Long = require(__dirname+"/../index.js"),
+    gmLong = require("./goog.math.long.js");
+
+var suite = {
+    
+    "basic": function(test) {
+        var longVal = new Long(0xFFFFFFFF, 0x7FFFFFFF);
+        test.equal(longVal.toNumber(), 9223372036854775807);
+        test.equal(longVal.toString(), "9223372036854775807");
+        var longVal2 = Long.fromValue(longVal);
+        test.equal(longVal2.toNumber(), 9223372036854775807);
+        test.equal(longVal2.toString(), "9223372036854775807");
+        test.equal(longVal2.unsigned, longVal.unsigned);
+        test.done();
+    },
+
+    "isLong": function(test) {
+        var longVal = new Long(0xFFFFFFFF, 0x7FFFFFFF);
+        test.strictEqual(Long.isLong(longVal), true);
+        longVal = {"__isLong__": true};
+        test.strictEqual(Long.isLong(longVal), true);
+        test.done();
+    },
+    
+    // Let's assume goog.math.Long has been tested properly and focus on our extensions:
+    
+    "toString": function(test) {
+        var longVal = Long.fromBits(0xFFFFFFFF, 0xFFFFFFFF, true);
+        // #10
+        test.equal(longVal.toString(16), "ffffffffffffffff");
+        test.equal(longVal.toString(10), "18446744073709551615");
+        test.equal(longVal.toString(8), "1777777777777777777777");
+        // #7, obviously wrong in goog.math.Long
+        test.equal(Long.fromString("zzzzzz", 36).toString(36), "zzzzzz");
+        test.equal(Long.fromString("-zzzzzz", 36).toString(36), "-zzzzzz");
+        test.done();
+    },
+
+    "toBytes": function(test) {
+        var longVal = Long.fromBits(0x01234567, 0x12345678);
+        test.deepEqual(longVal.toBytesBE(), [
+            0x12, 0x34, 0x56, 0x78,
+            0x01, 0x23, 0x45, 0x67
+        ]);
+        test.deepEqual(longVal.toBytesLE(), [
+            0x67, 0x45, 0x23, 0x01,
+            0x78, 0x56, 0x34, 0x12
+        ]);
+        test.done();
+    },
+    
+    "unsigned": {
+        
+        "min/max": function(test) {
+            test.equal(Long.MIN_VALUE.toString(), "-9223372036854775808");
+            test.equal(Long.MAX_VALUE.toString(), "9223372036854775807");
+            test.equal(Long.MAX_UNSIGNED_VALUE.toString(), "18446744073709551615");
+            test.done();
+        },
+        
+        "construct_negint": function(test) {
+            var longVal = Long.fromInt(-1, true);
+            test.equal(longVal.low, -1);
+            test.equal(longVal.high, -1);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 18446744073709551615);
+            test.equal(longVal.toString(), "18446744073709551615");
+            test.done();
+        },
+        
+        "construct_highlow": function(test) {
+            var longVal = new Long(0xFFFFFFFF, 0xFFFFFFFF, true);
+            test.equal(longVal.low, -1);
+            test.equal(longVal.high, -1);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 18446744073709551615);
+            test.equal(longVal.toString(), "18446744073709551615");
+            test.done();
+        },
+        
+        "construct_number": function(test) {
+            var longVal = Long.fromNumber(0xFFFFFFFFFFFFFFFF, true);
+            test.equal(longVal.low, -1);
+            test.equal(longVal.high, -1);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 18446744073709551615);
+            test.equal(longVal.toString(), "18446744073709551615");
+            test.done();
+        },
+
+        "toSigned/Unsigned": function(test) {
+            var longVal = Long.fromNumber(-1, false);
+            test.equal(longVal.toNumber(), -1);
+            longVal = longVal.toUnsigned();
+            test.equal(longVal.toNumber(), 0xFFFFFFFFFFFFFFFF);
+            test.equal(longVal.toString(16), 'ffffffffffffffff');
+            longVal = longVal.toSigned();
+            test.equal(longVal.toNumber(), -1);
+            test.done();
+        },
+        
+        "max_unsigned_sub_max_signed": function(test) {
+            var longVal = Long.MAX_UNSIGNED_VALUE.subtract(Long.MAX_VALUE).subtract(Long.ONE);
+            test.equal(longVal.toNumber(), Long.MAX_VALUE.toNumber());
+            test.equal(longVal.toString(), Long.MAX_VALUE.toString());
+            test.done();
+        },
+        
+        "max_sub_max": function(test) {
+            var longVal = Long.MAX_UNSIGNED_VALUE.subtract(Long.MAX_UNSIGNED_VALUE);
+            test.equal(longVal, 0);
+            test.equal(longVal.low, 0);
+            test.equal(longVal.high, 0);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 0);
+            test.equal(longVal.toString(), "0");
+            test.done();
+        },
+        
+        "zero_sub_signed": function(test) {
+            var longVal = Long.fromInt(0, true).add(Long.fromInt(-1, false));
+            test.equal(longVal.low, -1);
+            test.equal(longVal.high, -1);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 18446744073709551615);
+            test.equal(longVal.toString(), "18446744073709551615");
+            test.done();
+        },
+        
+        "max_unsigned_div_max_signed": function(test) {
+            var longVal = Long.MAX_UNSIGNED_VALUE.div(Long.MAX_VALUE);
+            test.equal(longVal.toNumber(), 2);
+            test.equal(longVal.toString(), "2");
+            test.done();
+        },
+        
+        "max_unsigned_div_max_unsigned": function(test) {
+            var longVal = Long.MAX_UNSIGNED_VALUE;
+            test.strictEqual(longVal.div(longVal).toString(), '1');
+            test.done();
+        },
+        
+        "max_unsigned_div_neg_signed": function(test) {
+            var a = Long.MAX_UNSIGNED_VALUE;
+            var b = Long.fromInt(-2);
+            test.strictEqual(b.toUnsigned().toString(), Long.MAX_UNSIGNED_VALUE.sub(1).toString());
+            var longVal = a.div(b);
+            test.strictEqual(longVal.toString(), '1');
+            test.done();
+        },
+
+        "min_signed_div_one": function(test) {
+            var longVal = Long.MIN_VALUE.div(Long.ONE);
+            test.strictEqual(longVal.toString(), Long.MIN_VALUE.toString());
+            test.done();
+        },
+
+        "msb_unsigned": function(test) {
+            var longVal = Long.UONE.shiftLeft(63);
+            test.ok(longVal.notEquals(Long.MIN_VALUE));
+            test.equal(longVal.toString(), "9223372036854775808");
+            test.equal(Long.fromString("9223372036854775808", true).toString(), "9223372036854775808");
+            test.done();
+        },
+        
+        "issue31": function(test) {
+            var a = new Long(0, 8, true);
+            var b = Long.fromNumber(2656901066, true);
+            test.strictEqual(a.unsigned, true);
+            test.strictEqual(b.unsigned, true);
+            var x = a.div(b);
+            test.strictEqual(x.toString(), '12');
+            test.strictEqual(x.unsigned, true);
+            test.done();
+        }
+    }
+};
+
+module.exports = suite;

package/claw/node_modules/lzma/.travis.yml

@@ -0,0 +1,9 @@
+language: node_js
+node_js:
+  - "5"
+  - "4"
+  - "0.12"
+  - "0.11"
+  - "0.10"
+  - "0.8"
+sudo: false

package/claw/node_modules/lzma/LICENSE

@@ -0,0 +1,20 @@
+© 2016 Nathan Rugg <nmrugg@gmail.com>
+
+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.

package/claw/node_modules/lzma/THANKS

@@ -0,0 +1,7 @@
+Developement for LZMA-JS has been financially supported by these fine individuals (in alphabetical order):
+
+benrugg
+Carnegiea
+rjhunter
+
+Thanks guys!

package/claw/node_modules/lzma/bin/lzma.js

@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+
+var lzma,
+    fs,
+    p,
+    params,
+    mode,
+    suffix;
+
+function get_version()
+{
+    return require(p.join("..", "package.json")).version;
+}
+
+function load_req()
+{
+    p = require("path");
+    fs = require("fs");
+    lzma = require(p.join("..", "index.js"));
+}
+
+function progress(percent)
+{
+    if (process.stdout.isTTY) {
+        process.stdout.clearLine();
+        process.stdout.cursorTo(0);
+        if (percent > 0 && percent < 1) {
+            process.stdout.write((percent * 100).toFixed(2) + "%");
+        }
+    }
+}
+
+
+function get_mode()
+{
+    var i;
+    
+    if (params.fast) {
+        return 1;
+    }
+    if (params.slow) {
+        return 9;
+    }
+    
+    for (i = 1; i < 10; i += 1) {
+        if (params[i]) {
+            return i;
+        }
+    }
+    
+    /// Default to 7.
+    return 7;
+}
+
+function parse_parameters(options)
+{
+    var args = {_: []},
+        i,
+        len = process.argv.length,
+        arg;
+    
+    function get_val(prop)
+    {
+        if (options.nonboolean.indexOf(prop) > -1) {
+            i += 1;
+            return process.argv[i];
+        }
+        
+        return true;
+    }
+    
+    function get_letters(letter)
+    {
+        args[letter] = get_val(letter);
+    }
+    
+    options = options || {};
+    
+    if (!Array.isArray(options.nonboolean)) {
+        options.nonboolean = [];
+    }
+    
+    for (i = 2; i < len; i += 1) {
+        arg = process.argv[i];
+        if (arg[0] === "-") {
+            if (arg[1] === "-") {
+                /// Double
+                args[arg.substr(2)] = get_val(arg.substr(2));
+            } else {
+                /// Single
+                arg.substr(1).split("").forEach(get_letters);
+            }
+        } else {
+            args._.push(arg);
+        }
+    }
+    
+    return args;
+}
+
+function stdout_is_ok()
+{
+    return params.f || params.force || !process.stdout.isTTY;
+}
+
+function array2buffer(data)
+{
+    var buf = new Buffer(data.length),
+        j,
+        len = data.length;
+    
+    for (j = 0; j < len; j += 1) {
+        buf[j] = (data[j] < 0 ? data[j] + 256 : data[j]);
+    }
+    
+    return buf;
+}
+
+function write_file(path, mixed, orig)
+{
+    fs.writeFileSync(path, mixed);
+    
+    if (orig && !params.k && !params.keep) {
+        try {
+            fs.unlink(orig);
+        } catch (e) {
+            console.error(e);
+        }
+    }
+}
+
+function compress_files(files)
+{
+    (function loop(i)
+    {
+        var is_file;
+        
+        if (i >= files.length) {
+            return;
+        }
+        
+        is_file = typeof files[i] === "string";
+        
+        if (!params.c && !params.stdout && !params.f && !params.force && !(params.r || params.testComp) && fs.existsSync(files[i] + suffix)) {
+            if (!params.q && !params.quiet) {
+                console.error("File already exists. Use -f to force overwrite.");
+            }
+            return loop(i + 1);
+        }
+        
+        if ((params.c || params.stdout) && !(params.r || params.testComp)) {
+            if (!stdout_is_ok()) {
+                if (!params.q && !params.quiet) {
+                    console.error("Compressed data not written to a terminal. Use -f to force compression.");
+                    console.error("For help, type: lzma.js -h");
+                }
+                return loop(i + 1);
+            }
+        } else {
+            if (p.extname(files[i]) === suffix) {
+                if (!params.q && !params.quiet) {
+                    console.error(p.basename(files[i]) + " already has " + suffix + " suffix -- unchanged. Use -S to change suffix.");
+                }
+                return loop(i + 1);
+            }
+        }
+        
+        lzma.compress(is_file ? fs.readFileSync(files[i]) : files[i].toString(), mode, function ondone(data)
+        {
+            var j,
+                len,
+                buf;
+            
+            if (params.r || params.testComp) {
+                if (data) {
+                    if (params.v || params.verbose) {
+                        console.error((is_file ? files[i] : "STDIN") + " -- compressed succesfully");
+                    }
+                } else {
+                    console.error("Compression error");
+                }
+                return loop(i + 1);
+            }
+            
+            if (params.c || params.stdout) {
+                len = data.length;
+                buf = new Buffer(1);
+                for (j = 0; j < len; j += 1) {
+                    buf[0] = data[j] < 0 ? data[j] + 256 : data[j];
+                    process.stdout.write(buf);
+                }
+            } else {
+                write_file(files[i] + suffix, array2buffer(data), files[i]);
+                if (params.v || params.verbose) {
+                    console.error(files[i] + " -- encoded succesfully");
+                }
+            }
+            loop(i + 1);
+        }, params.q || params.quiet ? null : progress);
+    }(0));
+}
+
+function decompress_files(files)
+{
+    (function loop(i)
+    {
+        var ext,
+            is_file;
+        
+        if (i >= files.length) {
+            return;
+        }
+        
+        is_file = typeof files[i] === "string";
+        
+        if (is_file) {
+            ext = p.extname(files[i]);
+            
+            if (ext !== suffix) {
+                if (!params.q && !params.quiet) {
+                    console.error(p.basename(files[i]) + " unknown suffix -- unchanged. Use -S to change suffix.");
+                }
+                return loop(i + 1);
+            }
+        }
+        
+        if (!params.c && !params.stdout && !params.f && !params.force && !params.t && fs.existsSync(p.basename(files[i], ext))) {
+            if (!params.q && !params.quiet) {
+                console.error("File already exists. Use -f to force overwrite.");
+            }
+            return loop(i + 1);
+        }
+        
+        lzma.decompress(typeof files[i] === "string" ? fs.readFileSync(files[i]) : files[i], function ondone(data)
+        {
+            var j,
+                len,
+                buf;
+            
+            if (params.t || params.test) {
+                if (data) {
+                    if (params.v || params.verbose) {
+                        console.error((is_file ? files[i] : "STDIN") + " -- decoded succesfully");
+                    }
+                } else {
+                    console.error("Decoder error");
+                }
+                return loop(i + 1);
+            }
+            
+            if (params.c || params.stdout) {
+                if (typeof data === "string") {
+                    process.stdout.write(data);
+                } else {
+                    len = data.length;
+                    buf = new Buffer(1);
+                    for (j = 0; j < len; j += 1) {
+                        buf[0] = data[j] < 0 ? data[j] + 256 : data[j];
+                        process.stdout.write(buf);
+                    }
+                }
+            } else {
+                write_file(p.basename(files[i], ext), typeof data === "string" ? data : array2buffer(data), files[i]);
+                if (params.v || params.verbose) {
+                    console.error(files[i] + " -- decoded succesfully");
+                }
+            }
+            loop(i + 1);
+        }, params.q || params.quiet ? null : progress);
+    }(0));
+}
+
+function get_stdin(cb)
+{
+    var buf = new Buffer(0);
+    
+    process.stdin.on("readable", function()
+    {
+        var chunk = process.stdin.read();
+        if (chunk) {
+            buf = Buffer.concat([buf, chunk]);
+        }
+    });
+    
+    process.stdin.on("end", function()
+    {
+        cb(buf);
+    });
+}
+
+function is_compress()
+{
+    return params.z || params.compress || params.r || params.testComp || !(params.d || params.decompress || params.t || params.test);
+}
+
+params = parse_parameters({nonboolean: ["S", "suffix"]});
+
+load_req();
+
+if (params.h || params.help) {
+    console.log("LZMA-JS " + get_version() + " © 2015 Nathan Rugg | MIT");
+    console.log("Based on LZMA SDK");
+    console.log("");
+    console.log("Usage: lzma.js [flags and input files in any order]");
+    console.log("  -c --stdout       output to standard output");
+    console.log("  -d --decompress   force decompression");
+    console.log("  -z --compress     force compression");
+    console.log("  -k --keep         keep (don't delete) input files");
+    console.log("  -f --force        force overwrite of output file and compress links");
+    console.log("  -t --test         test compressed file integrity");
+    console.log("  -r --testComp     test compressing (don't save anything)");
+    console.log("  -S .suf  --suffix .suf   use suffix .suf on compressed files");
+    console.log("  -q --quiet        suppress error messages");
+    console.log("  -v --verbose      be verbose");
+    console.log("  -h --help         print this message");
+    console.log("  -L --license      display the license information");
+    console.log("  -V --version      display version numbers of LZMA SDK and lzma");
+    console.log("  -1 .. -2          fast compression");
+    console.log("  -3 .. -9          good to excellent compression. -7 is the default.");
+    console.log("     --fast         alias for -1");
+    console.log("     --best         alias for -9 (usually *not* what you want)");
+    console.log("");
+    console.log("  Memory usage depends a lot on the chosen compression mode -1 .. -9.");
+    console.log("  NOTE: Mode 9 does not always produce the smallest file.");
+    console.log("");
+    process.exit();
+}
+
+if (params.L || params.license) {
+    console.log("");
+    console.log(fs.readFileSync(p.join(__dirname, "..", "LICENSE"), "utf8"));
+    process.exit();
+}
+
+if (params.V || params.version) {
+    console.log(get_version());
+    process.exit();
+}
+
+suffix = params.S || params.suffix || ".lzma";
+
+if (params._.length) {
+    ///NOTE: -t and --test must be decompress.
+    if (is_compress()) {
+        mode = get_mode();
+        compress_files(params._);
+    } else {
+        decompress_files(params._);
+    }
+} else {
+    /// STDIN needs STDOUT.
+    params.c = true;
+    
+    get_stdin(function onget(data)
+    {
+        if (is_compress()) {
+            compress_files([data]);
+        } else {
+            decompress_files([data]);
+        }
+    });
+}

package/claw/node_modules/lzma/index.js

@@ -0,0 +1,19 @@
+//! © 2015 Nathan Rugg <nmrugg@gmail.com> | MIT
+
+var lzma;
+
+function load_lzma()
+{
+    return require(require("path").join(__dirname, "src" ,"lzma_worker.js")).LZMA_WORKER;
+}
+
+lzma = load_lzma();
+
+///NOTE: This function is for backwards compatibility's sake.
+module.exports.LZMA = function LZMA()
+{
+    return lzma;
+}
+
+module.exports.compress   = lzma.compress;
+module.exports.decompress = lzma.decompress;

package/claw/node_modules/lzma/package.json

@@ -0,0 +1,30 @@
+{
+  "author": "Nathan Rugg <nmrugg@gmail.com>",
+  "name": "lzma",
+  "description": "A JavaScript implementation of the Lempel-Ziv-Markov (LZMA) chain compression algorithm",
+  "version": "2.3.2",
+  "homepage": "http://nmrugg.github.com/LZMA-JS/",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/nmrugg/LZMA-JS.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nmrugg/LZMA-JS/issues"
+  },
+  "bin": {
+    "lzma.js": "bin/lzma.js"
+  },
+  "devDependencies": {
+    "uglify-js": "=2.4.16"
+  },
+  "scripts": {
+    "test": "node test/test-node.js && node test/test-node.js --sync"
+  },
+  "license": "MIT",
+  "tonicExampleFilename": "demos/tonic_example.js",
+  "keywords": [
+    "lzma",
+    "compression",
+    "decompression"
+  ]
+}