415gotit

node_modules/msgpack-lite/test/10.encode.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
+
+describe(TITLE, function() {
+  describe("Buffer", function() {
+    run_tests();
+  });
+
+  var describe_Uint8Array = HAS_UINT8ARRAY ? describe : describe.skip;
+  describe_Uint8Array("Uint8Array", function() {
+    run_tests({uint8array: true});
+  });
+});
+
+function run_tests(codecopt) {
+  var options;
+
+  if (codecopt) it(JSON.stringify(codecopt), function() {
+    var codec = msgpack.createCodec(codecopt);
+    assert.ok(codec);
+    options = {codec: codec};
+  });
+
+  // positive fixint -- 0x00 - 0x7f
+  it("00-7f: positive fixint", function() {
+    for (var i = 0; i <= 0x7F; i++) {
+      assert.deepEqual(toArray(msgpack.encode(i, options)), [i]);
+    }
+  });
+
+  // fixmap -- 0x80 - 0x8f
+  it("80-8f: fixmap", function() {
+    var map = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10, k: 11, l: 12, m: 13, n: 14, o: 15, p: 16};
+    var src = {};
+    var exp = [0x80];
+    Object.keys(map).forEach(function(key) {
+      assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
+      src[key] = map[key];
+      exp[0]++;
+      exp.push(0xa1);
+      exp.push(key.charCodeAt(0));
+      exp.push(map[key]);
+    });
+  });
+
+  // fixarray -- 0x90 - 0x9f
+  it("90-9f: fixarray", function() {
+    var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+    var src = [];
+    var exp = [0x90];
+    for (var i = 0; i < 16; i++) {
+      assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
+      src.push(array[i]);
+      exp[0]++;
+      exp.push(array[i]);
+    }
+  });
+
+  // fixstr -- 0xa0 - 0xbf
+  it("a0-bf: fixstr", function() {
+    assert.deepEqual(toArray(msgpack.encode("", options)), [0xa0]);
+
+    var str = "0123456789abcdefghijklmnopqrstu";
+    var exp = [0xa0];
+    for (var i = 0; i < 32; i++) {
+      var src = str.substr(0, i);
+      assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
+      exp[0]++;
+      exp.push(str.charCodeAt(i));
+    }
+  });
+
+  // nil -- 0xc0
+  it("c0: nil (null)", function() {
+    assert.deepEqual(toArray(msgpack.encode(null, options)), [0xc0]);
+  });
+  it("c0: nil (undefined)", function() {
+    assert.deepEqual(toArray(msgpack.encode(undefined, options)), [0xc0]);
+  });
+  it("c0: nil (Function)", function() {
+    assert.deepEqual(toArray(msgpack.encode(NOP, options)), [0xc0]);
+  });
+
+  // false -- 0xc2
+  // true -- 0xc3
+  it("c2-c3: boolean", function() {
+    assert.deepEqual(toArray(msgpack.encode(false, options)), [0xc2]);
+    assert.deepEqual(toArray(msgpack.encode(true, options)), [0xc3]);
+  });
+
+  // bin 8 -- 0xc4
+  // bin 16 -- 0xc5
+  // bin 32 -- 0xc6
+  it("c4-c6: bin 8/16/32", function() {
+    this.timeout(30000);
+    var bin;
+    bin = Buffer(1);
+    bin.fill(0);
+    assert.deepEqual(toArray(msgpack.encode(bin, options)), concat([0xc4, 1], bin));
+
+    bin = Buffer(256);
+    bin.fill(0);
+    assert.deepEqual(toArray(msgpack.encode(bin, options)), concat([0xc5, 1, 0], bin));
+
+    bin = Buffer(65536);
+    bin.fill(0);
+    assert.deepEqual(toArray(msgpack.encode(bin, options)), concat([0xc6, 0, 1, 0, 0], bin));
+  });
+
+  // float 32 -- 0xca -- NOT SUPPORTED
+  // float 64 -- 0xcb
+  it("ca-cb: float 32/64", function() {
+    assert.deepEqual(toArray(msgpack.encode(0.5, options)), [0xcb, 63, 224, 0, 0, 0, 0, 0, 0]);
+  });
+
+  // uint 8 -- 0xcc
+  // uint 16 -- 0xcd
+  // uint 32 -- 0xce
+  // uint 64 -- 0xcf -- NOT SUPPORTED
+  it("cc-cf: uint 8/16/32/64", function() {
+    assert.deepEqual(toArray(msgpack.encode(0xFF, options)), [0xcc, 0xFF]);
+    assert.deepEqual(toArray(msgpack.encode(0xFFFF, options)), [0xcd, 0xFF, 0xFF]);
+    assert.deepEqual(toArray(msgpack.encode(0x7FFFFFFF, options)), [0xce, 0x7F, 0xFF, 0xFF, 0xFF]);
+  });
+
+  // int 8 -- 0xd0
+  // int 16 -- 0xd1
+  // int 32 -- 0xd2
+  // int 64 -- 0xd3 -- NOT SUPPORTED
+  it("d0-d3: int 8/16/32/64", function() {
+    assert.deepEqual(toArray(msgpack.encode(-0x80, options)), [0xd0, 0x80]);
+    assert.deepEqual(toArray(msgpack.encode(-0x8000, options)), [0xd1, 0x80, 0x00]);
+    assert.deepEqual(toArray(msgpack.encode(-0x80000000, options)), [0xd2, 0x80, 0x00, 0x00, 0x00]);
+  });
+
+  // str 8 -- 0xd9
+  // str 16 -- 0xda
+  // str 32 -- 0xdb
+  it("d9-db: str 8/16/32", function() {
+    this.timeout(30000);
+    var str, src = "a";
+    for (var i = 0; i < 17; i++) src += src;
+
+    str = src.substr(0, 0xFF);
+    assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xd9, 0xFF], Buffer(str)));
+
+    str = src.substr(0, 0x0100);
+    assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xda, 0x01, 0x00], Buffer(str)));
+
+    str = src.substr(0, 0xFFFF);
+    assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xda, 0xFF, 0xFF], Buffer(str)));
+
+    str = src.substr(0, 0x010000);
+    assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xdb, 0x00, 0x01, 0x00, 0x00], Buffer(str)));
+  });
+
+  // array 16 -- 0xdc
+  // array 32 -- 0xdd
+  it("dc-dd: array 16/32", function() {
+    this.timeout(30000);
+    var i, exp;
+    var src = new Array(256);
+    for (i = 0; i < 256; i++) src[i] = i & 0x7F;
+    exp = [0xdc, 0x01, 0x00].concat(src);
+    assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
+
+    for (i = 0; i < 8; i++) src = src.concat(src);
+    exp = [0xdd, 0x00, 0x01, 0x00, 0x00].concat(src);
+    assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
+  });
+
+  // map 16 -- 0xde
+  // map 32 -- 0xdf
+  it("de-df: map 16/32", function() {
+    this.timeout(30000);
+    var i, actual;
+    var map = {};
+    for (i = 0; i < 256; i++) map[i] = i;
+    actual = msgpack.encode(map, options);
+    // check only headers because order may vary
+    assert.equal(actual[0], 0xde);
+    assert.equal(actual[1], 1);
+    assert.equal(actual[2], 0);
+
+    for (i = 256; i < 65536; i++) map[i] = i;
+    actual = msgpack.encode(map, options);
+    assert.equal(actual[0], 0xdf);
+    assert.equal(actual[1], 0);
+    assert.equal(actual[2], 1);
+    assert.equal(actual[3], 0);
+    assert.equal(actual[4], 0);
+  });
+
+  // negative fixint -- 0xe0 - 0xff
+  it("e0-ff: negative fixint", function() {
+    for (var i = -32; i <= -1; i++) {
+      assert.deepEqual(toArray(msgpack.encode(i, options)), [i & 0xFF]);
+    }
+  });
+}
+
+function toArray(buffer) {
+  return Array.prototype.slice.call(buffer);
+}
+
+function concat(buf) {
+  return Array.prototype.concat.apply([], Array.prototype.map.call(arguments, toArray));
+}
+
+function NOP() {
+}

node_modules/msgpack-lite/test/11.decode.js

@@ -0,0 +1,371 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
+
+ArrayBridge.concat = ArrayBridge_concat;
+Uint8ArrayBridge.concat = Uint8ArrayBridge_concat;
+
+describe(TITLE, function() {
+  describe("Buffer", function() {
+    run_tests(Buffer);
+  });
+
+  describe("Array", function() {
+    run_tests(ArrayBridge);
+  });
+
+  var describe_Uint8Array = HAS_UINT8ARRAY ? describe : describe.skip;
+  describe_Uint8Array("Uint8Array", function() {
+    run_tests(Uint8ArrayBridge);
+  });
+});
+
+function run_tests(BUFFER) {
+  // positive fixint -- 0x00 - 0x7f
+  it("00-7f: positive fixint", function() {
+    for (var i = 0; i <= 0x7F; i++) {
+      assert.deepEqual(msgpack.decode(BUFFER([i])), i);
+    }
+  });
+
+  // fixmap -- 0x80 - 0x8f
+  it("80-8f: fixmap", function() {
+    var map = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10, k: 11, l: 12, m: 13, n: 14, o: 15, p: 16};
+    var src = [0x80];
+    var exp = {};
+    Object.keys(map).forEach(function(key) {
+      assert.deepEqual(msgpack.decode(BUFFER(src)), exp);
+      src[0]++;
+      src.push(0xa1);
+      src.push(key.charCodeAt(0));
+      src.push(map[key]);
+      exp[key] = map[key];
+    });
+  });
+
+  // fixarray -- 0x90 - 0x9f
+  it("90-9f: fixarray", function() {
+    var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+    var src = [0x90];
+    var exp = [];
+    for (var i = 0; i < 16; i++) {
+      assert.deepEqual(msgpack.decode(BUFFER(src)), exp);
+      src[0]++;
+      src.push(array[i]);
+      exp.push(array[i]);
+    }
+  });
+
+  // fixstr -- 0xa0 - 0xbf
+  it("a0-bf: fixstr", function() {
+    var str = "0123456789abcdefghijklmnopqrstu";
+    var src = [0xa0];
+    for (var i = 0; i < 32; i++) {
+      var exp = str.substr(0, i);
+      assert.deepEqual(msgpack.decode(BUFFER(src)), exp);
+      src[0]++;
+      src.push(str.charCodeAt(i));
+    }
+  });
+
+  // nil -- 0xc0
+  it("c0: nil", function() {
+    assert.deepEqual(msgpack.decode(BUFFER([0xc0])), null);
+  });
+
+  // (never used) -- 0xc1
+  it("c1: (never used)", function(done) {
+    try {
+      msgpack.decode(BUFFER([0xc1]));
+      done("should throw");
+    } catch (e) {
+      done();
+    }
+  });
+
+  // false -- 0xc2
+  // true -- 0xc3
+  it("c2-c3: boolean", function() {
+    assert.equal(msgpack.decode(BUFFER([0xc2])), false);
+    assert.equal(msgpack.decode(BUFFER([0xc3])), true);
+  });
+
+  // bin 8 -- 0xc4
+  // bin 16 -- 0xc5
+  // bin 32 -- 0xc6
+  it("c4-c6: bin 8/16/32", function() {
+    this.timeout(30000);
+    var bin, buf, act;
+
+    bin = BUFFER(1);
+    buf = BUFFER.concat([BUFFER([0xc4, 1]), bin]);
+    act = msgpack.decode(buf);
+    assert.ok(Buffer.isBuffer(act));
+    assert.deepEqual(ArrayBridge(act), ArrayBridge(bin));
+
+    bin = BUFFER(256);
+    buf = BUFFER.concat([BUFFER([0xc5, 1, 0]), bin]);
+    act = msgpack.decode(buf);
+    assert.ok(Buffer.isBuffer(act));
+    assert.deepEqual(ArrayBridge(act), ArrayBridge(bin));
+
+    bin = BUFFER(65536);
+    buf = BUFFER.concat([BUFFER([0xc6, 0, 1, 0, 0]), bin]);
+    act = msgpack.decode(buf);
+    assert.ok(Buffer.isBuffer(act));
+    assert.deepEqual(ArrayBridge(act), ArrayBridge(bin));
+  });
+
+  // ext 8 -- 0xc7
+  // ext 16 -- 0xc8
+  // ext 32 -- 0xc9
+  it("c7-c9: ext 8/16/32", function() {
+    this.timeout(30000);
+    var ext, buf, act;
+
+    ext = BUFFER(1);
+    buf = BUFFER.concat([BUFFER([0xc7, 1, 0]), ext]);
+    act = msgpack.decode(buf);
+    assert.ok(Buffer.isBuffer(act.buffer));
+    assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
+
+    ext = BUFFER(256);
+    buf = BUFFER.concat([BUFFER([0xc8, 1, 0, 0]), ext]);
+    act = msgpack.decode(buf);
+    assert.ok(Buffer.isBuffer(act.buffer));
+    assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
+
+    ext = BUFFER(65536);
+    buf = BUFFER.concat([BUFFER([0xc9, 0, 1, 0, 0, 0]), ext]);
+    act = msgpack.decode(buf);
+    assert.ok(Buffer.isBuffer(act.buffer));
+    assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
+  });
+
+  // float 32 -- 0xca
+  // float 64 -- 0xcb
+  it("ca-cb: float 32/64", function() {
+    var buf;
+
+    buf = Buffer(5);
+    buf.writeUInt8(0xCA, 0);
+    buf.writeFloatBE(0.5, 1);
+    assert.deepEqual(msgpack.decode(BUFFER(buf)), 0.5);
+
+    buf = Buffer(9);
+    buf.writeUInt8(0xCB, 0);
+    buf.writeDoubleBE(0.5, 1);
+    assert.deepEqual(msgpack.decode(BUFFER(buf)), 0.5);
+  });
+
+  // uint 8 -- 0xcc
+  // uint 16 -- 0xcd
+  // uint 32 -- 0xce
+  // uint 64 -- 0xcf
+  it("cc-cf: uint 8/16/32/64", function() {
+    assert.deepEqual(msgpack.decode(BUFFER([0xcc, 0x01])), 0x01);
+    assert.deepEqual(msgpack.decode(BUFFER([0xcc, 0xFF])), 0xFF);
+    assert.deepEqual(msgpack.decode(BUFFER([0xcd, 0x00, 0x01])), 0x0001);
+    assert.deepEqual(msgpack.decode(BUFFER([0xcd, 0xFF, 0xFF])), 0xFFFF);
+    assert.deepEqual(msgpack.decode(BUFFER([0xce, 0x00, 0x00, 0x00, 0x01])), 0x00000001);
+    assert.deepEqual(msgpack.decode(BUFFER([0xce, 0x7F, 0xFF, 0xFF, 0xFF])), 0x7FFFFFFF);
+    assert.deepEqual(msgpack.decode(BUFFER([0xce, 0xFF, 0xFF, 0xFF, 0xFF])), 0xFFFFFFFF);
+    assert.deepEqual(msgpack.decode(BUFFER([0xce, 0x12, 0x34, 0x56, 0x78])), 0x12345678);
+    assert.deepEqual(msgpack.decode(BUFFER([0xcf, 0, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF])), 0x00000000FFFFFFFF);
+    assert.deepEqual(msgpack.decode(BUFFER([0xcf, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0, 0])), 0x0000FFFFFFFF0000);
+    assert.deepEqual(msgpack.decode(BUFFER([0xcf, 0xFF, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0])), 0xFFFFFFFF00000000);
+  });
+
+  // int 8 -- 0xd0
+  // int 16 -- 0xd1
+  // int 32 -- 0xd2
+  // int 64 -- 0xd3
+  it("d0-d3: int 8/16/32/64", function() {
+    assert.deepEqual(msgpack.decode(BUFFER([0xd0, 0x7F])), 0x7F);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd0, 0x80])), -0x80);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd0, 0xFF])), -1);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd1, 0x7F, 0xFF])), 0x7FFF);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd1, 0x80, 0x00])), -0x8000);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd1, 0xFF, 0xFF])), -1);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd2, 0x7F, 0xFF, 0xFF, 0xFF])), 0x7FFFFFFF);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd2, 0x80, 0x00, 0x00, 0x00])), -0x80000000);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd2, 0xFF, 0xFF, 0xFF, 0xFF])), -1);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd2, 0x12, 0x34, 0x56, 0x78])), 0x12345678);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd3, 0, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF])), 0x00000000FFFFFFFF);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd3, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0, 0])), 0x0000FFFFFFFF0000);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd3, 0x7F, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0])), 0x7FFFFFFF00000000);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd3, 0x80, 0, 0, 0, 0, 0, 0, 0])), -0x8000000000000000);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF])), -1);
+  });
+
+  // fixext 1 -- 0xd4
+  // fixext 2 -- 0xd5
+  // fixext 4 -- 0xd6
+  // fixext 8 -- 0xd7
+  // fixext 16 -- 0xd8
+  it("d4-d8: fixext 1/2/4/8/16", function() {
+    var ext, buf, act;
+
+    ext = BUFFER(1);
+    buf = BUFFER.concat([BUFFER([0xd4, 0]), ext]);
+    act = msgpack.decode(buf);
+    assert.ok(Buffer.isBuffer(act.buffer));
+    assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
+
+    ext = BUFFER(2);
+    buf = BUFFER.concat([BUFFER([0xd5, 0]), ext]);
+    act = msgpack.decode(buf);
+    assert.ok(Buffer.isBuffer(act.buffer));
+    assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
+
+    ext = BUFFER(4);
+    buf = BUFFER.concat([BUFFER([0xd6, 0]), ext]);
+    act = msgpack.decode(buf);
+    assert.ok(Buffer.isBuffer(act.buffer));
+    assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
+
+    ext = BUFFER(8);
+    buf = BUFFER.concat([BUFFER([0xd7, 0]), ext]);
+    act = msgpack.decode(buf);
+    assert.ok(Buffer.isBuffer(act.buffer));
+    assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
+
+    ext = BUFFER(16);
+    buf = BUFFER.concat([BUFFER([0xd8, 0]), ext]);
+    act = msgpack.decode(buf);
+    assert.ok(Buffer.isBuffer(act.buffer));
+    assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
+  });
+
+  // str 8 -- 0xd9
+  // str 16 -- 0xda
+  // str 32 -- 0xdb
+  it("d9-db: str 8/16/32", function() {
+    this.timeout(30000);
+    var str, buf, src = "a";
+    for (var i = 0; i < 17; i++) src += src;
+
+    str = src.substr(0, 0xFF);
+    buf = BUFFER.concat([BUFFER([0xd9, 0xFF]), BUFFER(str)]);
+    assert.deepEqual(msgpack.decode(buf), str);
+
+    str = src.substr(0, 0x0100);
+    buf = BUFFER.concat([BUFFER([0xda, 0x01, 0x00]), BUFFER(str)]);
+    assert.deepEqual(msgpack.decode(buf), str);
+
+    str = src.substr(0, 0xFFFF);
+    buf = BUFFER.concat([BUFFER([0xda, 0xFF, 0xFF]), BUFFER(str)]);
+    assert.deepEqual(msgpack.decode(buf), str);
+
+    str = src.substr(0, 0x010000);
+    buf = BUFFER.concat([BUFFER([0xdb, 0x00, 0x01, 0x00, 0x00]), BUFFER(str)]);
+    assert.deepEqual(msgpack.decode(buf), str);
+  });
+
+  // array 16 -- 0xdc
+  // array 32 -- 0xdd
+  it("dc-dd: array 16/32", function() {
+    this.timeout(30000);
+    var i, src;
+    var array = new Array(256);
+    for (i = 0; i < 256; i++) array[i] = i & 0x7F;
+    src = [0xdc, 0x01, 0x00].concat(array);
+    assert.deepEqual(msgpack.decode(BUFFER(src)), array);
+
+    for (i = 0; i < 8; i++) array = array.concat(array);
+    src = [0xdd, 0x00, 0x01, 0x00, 0x00].concat(array);
+    assert.deepEqual(msgpack.decode(BUFFER(src)), array);
+  });
+
+  // map 16 -- 0xde
+  // map 32 -- 0xdf
+  it("de-df: map 16/32", function() {
+    this.timeout(30000);
+    var i, src, key;
+    var map = {};
+    var array = [];
+    for (i = 0; i < 256; i++) {
+      key = i.toString(16);
+      if (i < 16) key = "0" + key;
+      map[key] = i & 0x7F;
+      array.push(0xa2);
+      array.push(key.charCodeAt(0));
+      array.push(key.charCodeAt(1));
+      array.push(i & 0x7F);
+    }
+    src = [0xde, 0x01, 0x00].concat(array);
+    assert.deepEqual(msgpack.decode(BUFFER(src)), map);
+
+    for (i = 0; i < 8; i++) array = array.concat(array);
+    src = [0xdf, 0x00, 0x01, 0x00, 0x00].concat(array);
+    assert.deepEqual(msgpack.decode(BUFFER(src)), map);
+  });
+
+  // negative fixint -- 0xe0 - 0xff
+  it("e0-ff: negative fixint", function() {
+    for (var i = -32; i <= -1; i++) {
+      assert.deepEqual(msgpack.decode(BUFFER([i & 0xFF])), i);
+    }
+  });
+}
+
+function ArrayBridge(array) {
+  if ("number" === typeof array) {
+    array = init_seq([], array);
+  } else if ("string" === typeof array) {
+    array = copy_string([], array);
+  } else if (Buffer.isBuffer(array) || (HAS_UINT8ARRAY && (array instanceof Uint8Array))) {
+    array = copy_array([], array);
+  }
+
+  return array;
+}
+
+function init_seq(array, length) {
+  for (var i = 0; i < length; i++) {
+    array[i] = i & 255;
+  }
+  return array;
+}
+
+function copy_string(array, src) {
+  for (var i = 0; i < src.length; i++) {
+    array[i] = src.charCodeAt(i);
+  }
+  return array;
+}
+
+function copy_array(array, src) {
+  for (var i = 0; i < src.length; i++) {
+    array[i] = src[i];
+  }
+  return array;
+}
+
+function ArrayBridge_concat(pair) {
+  return Array.prototype.concat.apply([], pair);
+}
+
+function Uint8ArrayBridge(array) {
+  if ("number" === typeof array) {
+    array = init_seq(new Uint8Array(array), array);
+  } else if ("string" === typeof array) {
+    array = copy_string(new Uint8Array(array.length), array);
+  } else if (Buffer.isBuffer(array)) {
+    array = copy_array(new Uint8Array(array.length), array);
+  } else {
+    array = new Uint8Array(array);
+  }
+
+  return array;
+}
+
+function Uint8ArrayBridge_concat(pair) {
+  return Uint8ArrayBridge(ArrayBridge_concat(pair.map(ArrayBridge)));
+}

node_modules/msgpack-lite/test/12.encoder.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var source = {"foo": "bar"};
+var packed = toArray(msgpack.encode(source));
+
+describe(TITLE, function() {
+
+  it("Encoder().encode(obj)", function(done) {
+    var encoder = new msgpack.Encoder();
+    encoder.on("data", function(data) {
+      assert.deepEqual(toArray(data), packed);
+    });
+    encoder.on("end", done);
+    encoder.encode(source);
+    encoder.end();
+  });
+
+  it("Encoder().end(obj)", function(done) {
+    var encoder = new msgpack.Encoder();
+    encoder.on("data", function(data) {
+      assert.deepEqual(toArray(data), packed);
+    });
+    encoder.on("end", done);
+    encoder.end(source);
+  });
+});
+
+function toArray(buffer) {
+  return Array.prototype.slice.call(buffer);
+}

node_modules/msgpack-lite/test/13.decoder.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var source = {"foo": "bar"};
+var packed = msgpack.encode(source);
+
+describe(TITLE, function() {
+
+  it("Decoder().decode(obj)", function(done) {
+    var decoder = new msgpack.Decoder();
+    decoder.on("data", function(data) {
+      assert.deepEqual(data, source);
+    });
+    decoder.on("end", done);
+    decoder.decode(packed);
+    decoder.end();
+  });
+
+  it("Decoder().end(obj)", function(done) {
+    var decoder = new msgpack.Decoder();
+    decoder.on("data", function(data) {
+      assert.deepEqual(data, source);
+    });
+    decoder.on("end", done);
+    decoder.end(packed);
+  });
+});

node_modules/msgpack-lite/test/14.codec.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
+
+describe(TITLE, function() {
+  it("createCodec()", function() {
+    var codec = msgpack.createCodec();
+    var options = {codec: codec};
+    assert.ok(codec);
+
+    // this codec does not have preset codec
+    for (var i = 0; i < 256; i++) {
+      test(i);
+    }
+
+    function test(type) {
+      // fixext 1 -- 0xd4
+      var source = new Buffer([0xd4, type, type]);
+      var decoded = msgpack.decode(source, options);
+      assert.equal(decoded.type, type);
+      assert.equal(decoded.buffer.length, 1);
+      var encoded = msgpack.encode(decoded, options);
+      assert.deepEqual(toArray(encoded), toArray(source));
+    }
+  });
+
+  it("addExtPacker()", function() {
+    var codec = msgpack.createCodec();
+    codec.addExtPacker(0, MyClass, myClassPacker);
+    codec.addExtUnpacker(0, myClassUnpacker);
+    var options = {codec: codec};
+    [0, 1, 127, 255].forEach(test);
+
+    function test(type) {
+      var source = new MyClass(type);
+      var encoded = msgpack.encode(source, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.ok(decoded instanceof MyClass);
+      assert.equal(decoded.value, type);
+    }
+  });
+
+  // The safe mode works as same as the default mode. It'd be hard for test it.
+  it("createCodec({safe: true})", function() {
+    var options = {codec: msgpack.createCodec({safe: true})};
+    var source = 1;
+    var encoded = msgpack.encode(source, options);
+    var decoded = msgpack.decode(encoded, options);
+    assert.equal(decoded, source);
+  });
+
+  it("createCodec({preset: true})", function() {
+    var options1 = {codec: msgpack.createCodec({preset: true})};
+    var options2 = {codec: msgpack.createCodec({preset: false})};
+
+    var source = new Date();
+    var encoded = msgpack.encode(source, options1);
+    assert.equal(encoded[0], 0xC7, "preset ext format failure. (128 means map format)"); // ext 8
+    assert.equal(encoded[1], 0x09); // 1+8
+    assert.equal(encoded[2], 0x0D); // Date
+
+    // decode as Boolean instance
+    var decoded = msgpack.decode(encoded, options1);
+    assert.equal(decoded - 0, source - 0);
+    assert.ok(decoded instanceof Date);
+
+    // decode as ExtBuffer
+    decoded = msgpack.decode(encoded, options2);
+    assert.ok(!(decoded instanceof Date));
+    assert.equal(decoded.type, 0x0D);
+  });
+});
+
+function MyClass(value) {
+  this.value = value & 0xFF;
+}
+
+function myClassPacker(obj) {
+  return new Buffer([obj.value]);
+}
+
+function myClassUnpacker(buffer) {
+  return new MyClass(buffer[0]);
+}
+
+function toArray(array) {
+  if (HAS_UINT8ARRAY && array instanceof ArrayBuffer) array = new Uint8Array(array);
+  return Array.prototype.slice.call(array);
+}

node_modules/msgpack-lite/test/15.useraw.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var TESTS = [0, 1, 31, 32, 255, 256, 65535, 65536];
+
+function toArray(array) {
+  return Array.prototype.slice.call(array);
+}
+
+describe(TITLE, function() {
+  var options;
+
+  it("useraw (decode)", function() {
+    options = {codec: msgpack.createCodec({useraw: true})};
+
+    // raw
+    assert.deepEqual(toArray(msgpack.decode(new Buffer([0xa1, 65]), options)), [65]);
+
+    // str
+    assert.equal(msgpack.decode(new Buffer([0xa1, 65])), "A");
+  });
+
+  it("useraw (encode)", function() {
+    // raw (String)
+    assert.deepEqual(toArray(msgpack.encode("A", options)), [0xa1, 65]);
+
+    // raw (Buffer)
+    assert.deepEqual(toArray(msgpack.encode(new Buffer([65]), options)), [0xa1, 65]);
+
+    // str
+    assert.deepEqual(toArray(msgpack.encode("A")), [0xa1, 65]);
+  });
+
+  it("useraw (String)", function() {
+    TESTS.forEach(test);
+
+    function test(length) {
+      var source = "";
+      for (var i = 0; i < length; i++) {
+        source += "a";
+      }
+
+      // encode as raw
+      var encoded = msgpack.encode(source, options);
+      assert.ok(encoded.length);
+
+      // decode as raw (Buffer)
+      var buffer = msgpack.decode(encoded, options);
+      assert.ok(Buffer.isBuffer(buffer));
+      assert.equal(buffer.length, length);
+      if (length) assert.equal(buffer[0], 97);
+
+      // decode as str (String)
+      var string = msgpack.decode(encoded);
+      assert.equal(typeof string, "string");
+      assert.equal(string.length, length);
+      assert.equal(string, source);
+    }
+  });
+
+  it("useraw (Buffer)", function() {
+    TESTS.forEach(test);
+
+    function test(length) {
+      var source = new Buffer(length);
+      for (var i = 0; i < length; i++) {
+        source[i] = 65; // "A"
+      }
+
+      // encode as raw
+      var encoded = msgpack.encode(source, options);
+      assert.ok(encoded.length);
+
+      // decode as raw (Buffer)
+      var buffer = msgpack.decode(encoded, options);
+      assert.ok(Buffer.isBuffer(buffer));
+      assert.equal(buffer.length, length);
+      if (length) assert.equal(buffer[0], 65);
+
+      // decode as str (String)
+      var string = msgpack.decode(encoded);
+      assert.equal(typeof string, "string");
+      assert.equal(string.length, length);
+      if (length) assert.equal(string[0], "A");
+    }
+  });
+});

node_modules/msgpack-lite/test/16.binarraybuffer.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
+
+var TESTS = [0, 1, 31, 32, 255, 256, 65535, 65536];
+
+function toArray(array) {
+  if (array instanceof ArrayBuffer) array = new Uint8Array(array);
+  return Array.prototype.slice.call(array);
+}
+
+// run this test when Uint8Array is available
+var describeSkip = HAS_UINT8ARRAY ? describe : describe.skip;
+
+describeSkip(TITLE, function() {
+  var options;
+
+  it("binarraybuffer (decode)", function() {
+    var decoded;
+    options = {codec: msgpack.createCodec({binarraybuffer: true, preset: true})};
+
+    // bin (Buffer)
+    decoded = msgpack.decode(new Buffer([0xc4, 2, 65, 66]), options);
+    assert.ok(decoded instanceof ArrayBuffer);
+    assert.ok(!Buffer.isBuffer(decoded));
+    assert.deepEqual(toArray(decoded), [65, 66]);
+
+    // bin (Uint8Array)
+    decoded = msgpack.decode(new Uint8Array([0xc4, 2, 97, 98]), options);
+    assert.ok(decoded instanceof ArrayBuffer);
+    assert.ok(!Buffer.isBuffer(decoded));
+    assert.deepEqual(toArray(decoded), [97, 98]);
+
+    // bin (Array)
+    decoded = msgpack.decode([0xc4, 2, 65, 66], options);
+    assert.ok(decoded instanceof ArrayBuffer);
+    assert.ok(!Buffer.isBuffer(decoded));
+    assert.deepEqual(toArray(decoded), [65, 66]);
+  });
+
+  it("binarraybuffer (encode)", function() {
+    // bin (ArrayBuffer)
+    var encoded = msgpack.encode(new Uint8Array([65, 66]).buffer, options);
+    assert.deepEqual(toArray(encoded), [0xc4, 2, 65, 66]);
+  });
+
+  it("binarraybuffer (large)", function() {
+    TESTS.forEach(test);
+
+    function test(length) {
+      var source = new Uint8Array(length);
+      for (var i = 0; i < length; i++) {
+        source[i] = 65; // "A"
+      }
+
+      var encoded = msgpack.encode(source.buffer, options);
+      assert.ok(encoded.length);
+
+      var decoded = msgpack.decode(encoded, options);
+      assert.ok(decoded instanceof ArrayBuffer);
+      assert.ok(!Buffer.isBuffer(decoded));
+      decoded = new Uint8Array(decoded);
+      assert.equal(decoded.length, length);
+      if (length) assert.equal(decoded[0], 65);
+    }
+  });
+
+  // addExtPacker() and getExtPacker() methods need a valid constructor name.
+  // IE10 and iOS7 Safari may give another constructor name than Buffer.
+  // At those cases, below will be encoded as Uint8Array: [0xd5, 0x12, 97, 98]
+  var b = new Buffer(1);
+  var c = b.constructor;
+  var d = (c && c.name === "Buffer") ? it : it.skip;
+  d("encode Buffer ext format 0x1B", function() {
+    // fixext 2 (Buffer)
+    var encoded = msgpack.encode(new Buffer([97, 98]), options);
+    assert.deepEqual(toArray(encoded), [0xd5, 0x1b, 97, 98]);
+  });
+
+  it("decode Buffer ext format 0x1B", function() {
+    // fixext 2 (Buffer)
+    var decoded = msgpack.decode([0xd5, 0x1b, 65, 66], options);
+    assert.ok(Buffer.isBuffer(decoded));
+    assert.deepEqual(toArray(decoded), [65, 66]);
+  });
+});

node_modules/msgpack-lite/test/17.uint8array.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var Bufferish = require("../lib/bufferish");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
+
+describe(TITLE, function() {
+  it("{}", function() {
+    var encoded = msgpack.encode(1);
+    assert.ok(Buffer.isBuffer(encoded));
+    // assert.ok(!ArrayBuffer.isView(encoded));
+  });
+
+  var it_Uint8Array = HAS_UINT8ARRAY ? it : it.skip;
+  var codecopt = {uint8array: true};
+
+  it_Uint8Array(JSON.stringify(codecopt), function() {
+    var codec = msgpack.createCodec(codecopt);
+    assert.ok(codec);
+    var options = {codec: codec};
+
+    // small data
+    var encoded = msgpack.encode(1, options);
+    if (ArrayBuffer.isView) assert.ok(ArrayBuffer.isView(encoded));
+    assert.ok(Bufferish.isView(encoded));
+    assert.ok(!Buffer.isBuffer(encoded));
+
+    // bigger data
+    var big = new Buffer(8192); // 8KB
+    big[big.length - 1] = 99;
+    var source = [big, big, big, big, big, big, big, big]; // 64KB
+    encoded = msgpack.encode(source, options);
+    if (ArrayBuffer.isView) assert.ok(ArrayBuffer.isView(encoded));
+    assert.ok(Bufferish.isView(encoded));
+    assert.ok(!Buffer.isBuffer(encoded));
+    assert.equal(encoded[encoded.length - 1], 99); // last byte
+  });
+});

node_modules/msgpack-lite/test/18.utf8.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var OPTIONS = [{}, {safe: true}];
+
+describe(TITLE, function() {
+  OPTIONS.forEach(function(options) {
+    var suffix = " " + JSON.stringify(options);
+    it("string (ASCII)" + suffix, function() {
+      var string = "a";
+      var array = [0xa1, 0x61];
+      var encoded = msgpack.encode(string, options);
+      var decoded = msgpack.decode(array, options);
+      assert.deepEqual(toArray(encoded), array);
+      assert.equal(decoded, string);
+    });
+
+    it("string (Greek)" + suffix, function() {
+      var string = "α";
+      var array = [0xa2, 0xce, 0xb1];
+      var encoded = msgpack.encode(string, options);
+      var decoded = msgpack.decode(array, options);
+      assert.deepEqual(toArray(encoded), array);
+      assert.equal(decoded, string);
+    });
+
+    it("string (Asian)" + suffix, function() {
+      var string = "亜";
+      var array = [0xa3, 0xe4, 0xba, 0x9c];
+      var encoded = msgpack.encode(string, options);
+      var decoded = msgpack.decode(array, options);
+      assert.deepEqual(toArray(encoded), array);
+      assert.equal(decoded, string);
+    });
+
+    // U+1F426 "🐦" bird
+    // http://unicode.org/emoji/charts/full-emoji-list.html#1f426
+    it("string (Emoji)" + suffix, function() {
+      var string = "\uD83D\uDC26"; // surrogate pair
+      var array_utf8 = [0xa4, 0xf0, 0x9f, 0x90, 0xa6]; // UTF-8
+      var array_cesu8 = [0xa6, 0xed, 0xa0, 0xbd, 0xed, 0xb0, 0xa6]; // CESU-8
+      var encoded = msgpack.encode(string, options);
+      var decoded_utf8 = msgpack.decode(array_utf8, options);
+      var decoded_cesu8 = msgpack.decode(array_cesu8, options);
+      assert.deepEqual(toArray(encoded), array_utf8);
+      assert.equal(decoded_utf8, string);
+      assert.equal(decoded_cesu8, string);
+    });
+  });
+});
+
+function toArray(buffer) {
+  return Array.prototype.slice.call(buffer);
+}

node_modules/msgpack-lite/test/20.roundtrip.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var STRING_ASCII = "a";
+var STRING_GREEK = "α";
+var STRING_ASIAN = "亜";
+
+// 128K characters
+for (var i = 0; i < 17; i++) {
+  STRING_ASCII = STRING_ASCII + STRING_ASCII;
+  STRING_GREEK = STRING_GREEK + STRING_GREEK;
+  STRING_ASIAN = STRING_ASIAN + STRING_ASIAN;
+}
+
+function pattern(min, max, offset) {
+  var array = [];
+  var check = {};
+  var val = min - 1;
+  while (val <= max) {
+    if (min <= val && !check[val]) array.push(val);
+    check[val++] = 1;
+    if (val <= max && !check[val]) array.push(val);
+    check[val++] = 1;
+    if (val <= max && !check[val]) array.push(val);
+    check[val--] = 1;
+    val = val ? val * 2 - 1 : 1;
+  }
+  return array;
+}
+
+var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
+
+describe(TITLE, function() {
+  describe("Buffer", function() {
+    run_tests();
+  });
+
+  var describe_Uint8Array = HAS_UINT8ARRAY ? describe : describe.skip;
+  describe_Uint8Array("Uint8Array", function() {
+    run_tests({uint8array: true});
+  });
+});
+
+function run_tests(codecopt) {
+  var options;
+
+  if (codecopt) it(JSON.stringify(codecopt), function() {
+    var codec = msgpack.createCodec(codecopt);
+    assert.ok(codec);
+    options = {codec: codec};
+  });
+
+  it("null", function() {
+    [null, undefined].forEach(function(value) {
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded, value);
+    });
+  });
+
+  it("boolean", function() {
+    [true, false].forEach(function(value) {
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded, value);
+    });
+  });
+
+  it("positive int (small)", function() {
+    pattern(0, 0x40000000).forEach(function(value) {
+      value = value | 0; // integer
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded, value);
+    });
+  });
+
+  it("positive int (large)", function() {
+    pattern(0x40000000, 0xFFFFFFFF).forEach(function(value) {
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded, value);
+    });
+  });
+
+  it("negative int (small)", function() {
+    pattern(0, 0x40000000).forEach(function(value) {
+      value = -value | 0; // integer
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded, value);
+    });
+  });
+
+  it("negative int (large)", function() {
+    pattern(0x40000000, 0xFFFFFFFF).forEach(function(value) {
+      value = -value;
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded, value);
+    });
+  });
+
+  it("float", function() {
+    [1.1, 10.01, 100.001, 1000.0001, 10000.00001, 100000.000001, 1000000.0000001].forEach(function(value) {
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded, value);
+    });
+  });
+
+  it("string (ASCII)", function() {
+    this.timeout(30000);
+    pattern(0, 65537).forEach(function(length) {
+      var value = STRING_ASCII.substr(0, length);
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded, value);
+    });
+  });
+
+  it("string (GREEK)", function() {
+    this.timeout(30000);
+    pattern(0, 65537).forEach(function(length) {
+      var value = STRING_GREEK.substr(0, length);
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded, value);
+    });
+  });
+
+  it("string (ASIAN)", function() {
+    this.timeout(30000);
+    pattern(0, 65537).forEach(function(length) {
+      var value = STRING_ASIAN.substr(0, length);
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded, value);
+    });
+  });
+
+  it("array (small)", function() {
+    pattern(0, 257).forEach(function(length, idx) {
+      var value = new Array(length);
+      for (var i = 0; i < length; i++) {
+        value[i] = String.fromCharCode(i);
+      }
+      assert.equal(value.length, length);
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded.length, length);
+      assert.equal(decoded[0], value[0]);
+      assert.equal(decoded[length - 1], value[length - 1]);
+    });
+  });
+
+  it("array (large)", function() {
+    this.timeout(30000);
+    pattern(0, 65537).forEach(function(length) {
+      var value = new Array(length);
+      assert.equal(value.length, length);
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded.length, length);
+      assert.equal(decoded[0], value[0]);
+      assert.equal(decoded[length - 1], value[length - 1]);
+    });
+  });
+
+  it("object map (small)", function() {
+    pattern(0, 257).forEach(function(length) {
+      var value = {};
+      for (var i = 0; i < length; i++) {
+        var key = String.fromCharCode(i);
+        value[key] = length;
+      }
+      assert.equal(Object.keys(value).length, length);
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(Object.keys(decoded).length, length);
+      assert.equal(decoded[0], value[0]);
+      assert.equal(decoded[length - 1], value[length - 1]);
+    });
+  });
+
+  it("object map (large)", function() {
+    this.timeout(30000);
+    pattern(65536, 65537).forEach(function(length) {
+      var value = {};
+      for (var i = 0; i < length; i++) {
+        value[i] = length;
+      }
+      assert.equal(Object.keys(value).length, length);
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(Object.keys(decoded).length, length);
+      assert.equal(decoded[0], value[0]);
+      assert.equal(decoded[length - 1], value[length - 1]);
+    });
+  });
+
+  it("buffer", function() {
+    this.timeout(30000);
+    pattern(2, 65537).forEach(function(length, idx) {
+      var value = new Buffer(length);
+      value.fill(idx);
+      assert.equal(value.length, length);
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded.length, length);
+      assert.equal(decoded[0], value[0]);
+      assert.equal(decoded[length - 1], value[length - 1]);
+    });
+  });
+}

node_modules/msgpack-lite/test/21.ext.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env mocha -R spec
+
+/*jshint -W053 */
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+describe(TITLE, function() {
+  it("Boolean", function() {
+    [true, false].forEach(function(value) {
+      var source = new Boolean(value);
+      assert.equal(source - 0, value - 0);
+      var encoded = msgpack.encode(source);
+      assert.equal(encoded[0], 0xD4, "preset ext format failure. (128 means map format)"); // fixext 1
+      assert.equal(encoded[1], 0x0B); // Boolean
+      var decoded = msgpack.decode(encoded);
+      assert.equal(decoded - 0, source - 0);
+      assert.ok(decoded instanceof Boolean);
+    });
+  });
+
+  it("Date", function() {
+    var source = new Date();
+    var encoded = msgpack.encode(source);
+    assert.equal(encoded[0], 0xC7, "preset ext format failure. (128 means map format)"); // ext 8
+    assert.equal(encoded[1], 0x09); // 1+8
+    assert.equal(encoded[2], 0x0D); // Date
+    var decoded = msgpack.decode(encoded);
+    assert.equal(decoded - 0, source - 0);
+    assert.ok(decoded instanceof Date);
+  });
+
+  var ERROR_TYPES = ["Error", "EvalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError"];
+  ERROR_TYPES.forEach(function(name, idx) {
+    var Class = global[name];
+    it(name, function() {
+      var message = "foo:" + idx;
+      var source = new Class(message);
+      var encoded = msgpack.encode(source);
+      var decoded = msgpack.decode(encoded);
+      assert.equal(decoded + "", source + "");
+      assert.equal(decoded.name, name);
+      assert.equal(decoded.message, message);
+      assert.ok(decoded instanceof Class);
+    });
+  });
+
+  it("RegExp", function() {
+    var source = new RegExp("foo");
+    var encoded = msgpack.encode(source);
+    var decoded = msgpack.decode(encoded);
+    assert.equal(decoded + "", source + "");
+    assert.ok(decoded instanceof RegExp);
+  });
+
+  it("RegExp //g", function() {
+    var source = /foo\/bar/g;
+    var encoded = msgpack.encode(source);
+    var decoded = msgpack.decode(encoded);
+    assert.equal(decoded + "", source + "");
+    assert.ok(decoded instanceof RegExp);
+  });
+
+  it("Number", function() {
+    var source = new Number(123.456);
+    var encoded = msgpack.encode(source);
+    assert.equal(encoded[0], 0xC7); // ext 8
+    assert.equal(encoded[1], 0x09); // 1+8
+    assert.equal(encoded[2], 0x0F); // Number
+    var decoded = msgpack.decode(encoded);
+    assert.equal(decoded - 0, source - 0);
+    assert.ok(decoded instanceof Number);
+  });
+
+  it("String", function() {
+    var source = new String("qux");
+    var encoded = msgpack.encode(source);
+    var decoded = msgpack.decode(encoded);
+    assert.equal(decoded + "", source + "");
+    assert.ok(decoded instanceof String);
+  });
+});

node_modules/msgpack-lite/test/22.typedarray.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env mocha -R spec
+
+/*jshint -W053 */
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var TYPED_ARRAY = {
+  "Int8Array": [0, 1, 2, 126, 127, -128, -127, -2, -1],
+  "Uint8Array": [0, 1, 2, 253, 254, 255],
+  "Uint8ClampedArray": [0, 1, 2, 253, 254, 255],
+  "Int16Array": [0, 1, 2, 32766, 32767, -32768, -32767, -2, -1],
+  "Uint16Array": [0, 1, 2, 65534, 65535],
+  "Int32Array": [0, 1, 2, 2147483646, 2147483647],
+  "Uint32Array": [0, 1, 2, 4294967294, 4294967295],
+  "Float32Array": [0, 1, 0.5, 0.25, -0.25, -0.5, -1],
+  "Float64Array": [0, 1, 0.5, 0.25, -0.25, -0.5, -1]
+};
+
+var ARRAY_BUFFER = {
+  "ArrayBuffer": [0, 1, 2, 253, 254, 255]
+};
+
+var DATA_VIEW = {
+  "DataView": [0, 1, 2, 253, 254, 255]
+};
+
+describe(TITLE, function() {
+  Object.keys(TYPED_ARRAY).forEach(function(name) {
+    var Class = global[name];
+    var skip = Class ? it : it.skip;
+    skip(name, function() {
+      var sample = TYPED_ARRAY[name];
+      var source = new Class(sample);
+      assert.ok(source instanceof Class);
+      assert.equal(source.length, sample.length);
+      var encoded = msgpack.encode(source);
+      var decoded = msgpack.decode(encoded);
+      var actual = Array.prototype.slice.call(decoded);
+      assert.deepEqual(actual, sample);
+      assert.ok(decoded instanceof Class);
+    });
+  });
+
+  Object.keys(ARRAY_BUFFER).forEach(function(name) {
+    var Class = global[name];
+    var skip = Class ? it : it.skip;
+    skip(name, function() {
+      var sample = ARRAY_BUFFER[name];
+      var source = (new Uint8Array(sample)).buffer;
+      assert.ok(source instanceof Class);
+      assert.equal(source.byteLength, sample.length);
+      var encoded = msgpack.encode(source);
+      var decoded = msgpack.decode(encoded);
+      var actual = Array.prototype.slice.call(new Uint8Array(decoded));
+      assert.deepEqual(actual, sample);
+      assert.ok(decoded instanceof Class);
+    });
+  });
+
+  Object.keys(DATA_VIEW).forEach(function(name) {
+    var Class = global[name];
+    var skip = Class ? it : it.skip;
+    skip(name, function() {
+      var sample = DATA_VIEW[name];
+      var source = new DataView((new Uint8Array(sample)).buffer);
+      assert.ok(source instanceof Class);
+      assert.equal(source.byteLength, sample.length);
+      var encoded = msgpack.encode(source);
+      var decoded = msgpack.decode(encoded);
+      var actual = Array.prototype.slice.call(new Uint8Array(decoded.buffer));
+      assert.deepEqual(actual, sample);
+      assert.ok(decoded instanceof Class);
+    });
+  });
+});

node_modules/msgpack-lite/test/23.extbuffer.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env mocha -R spec
+
+/*jshint -W053 */
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
+
+describe(TITLE, function() {
+  it("ExtBuffer (0x00)", function() {
+    testExtBuffer(0);
+  });
+
+  it("ExtBuffer (0x20-0xFF)", function() {
+    for (var i = 32; i < 256; i++) {
+      testExtBuffer(i);
+    }
+  });
+
+  it("ExtBuffer Array (0x20-0xFF)", function() {
+    for (var i = 32; i < 256; i++) {
+      testExtBufferArray(i);
+    }
+  });
+
+  function testExtBuffer(type) {
+    // fixext 8 -- 0xd7
+    var header = new Buffer([0xd7, type]);
+    var content = new Buffer(8);
+    for (var i = 0; i < 8; i++) {
+      content[i] = (type + i) & 0x7F;
+    }
+    var source = Buffer.concat([header, content]);
+    var decoded = msgpack.decode(source);
+    assert.equal(decoded.type, type);
+    assert.equal(decoded.buffer.length, content.length);
+    assert.deepEqual(toArray(decoded.buffer), toArray(content));
+    var encoded = msgpack.encode(decoded);
+    assert.deepEqual(toArray(encoded), toArray(source));
+  }
+
+  // Unpack and re-pack an array of extension types.
+  // Tests, among other things, that the right number of bytes are
+  // consumed with each ext type read.
+  function testExtBufferArray(type) {
+    function content(j) {
+        var x = j * type;
+        return Buffer([x & 0x7F, (x + 1) & 0x7F]);
+    }
+    // fixarray len 10
+    var arrayHeader = new Buffer([0x9a]);
+    var fullBuffer = arrayHeader;
+    for (var j = 0; j < 10; j++) {
+      // fixext 2 -- 0xd5
+      var header = new Buffer([0xd5, type]);
+      fullBuffer = Buffer.concat([fullBuffer, header, content(j)]);
+    }
+    var decoded = msgpack.decode(fullBuffer);
+    assert.equal(true, decoded instanceof Array);
+    assert.equal(decoded.length, 10);
+    for (j = 0; j < 10; j++) {
+      assert.equal(decoded[j].type, type);
+      assert.equal(decoded[j].buffer.length, 2);
+      assert.deepEqual(decoded[j].buffer, content(j));
+    }
+    var encoded = msgpack.encode(decoded);
+    assert.deepEqual(encoded, fullBuffer);
+  }
+
+});
+
+function toArray(array) {
+  if (HAS_UINT8ARRAY && array instanceof ArrayBuffer) array = new Uint8Array(array);
+  return Array.prototype.slice.call(array);
+}

node_modules/msgpack-lite/test/24.int64.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env mocha -R spec
+
+/*jshint -W053 */
+
+var Int64Buffer = require("int64-buffer");
+var Uint64BE = Int64Buffer.Uint64BE;
+var Int64BE = Int64Buffer.Int64BE;
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+describe(TITLE, function() {
+  var options = {};
+
+  it("createCodec({int64: true})", function() {
+    var codec = msgpack.createCodec({int64: true});
+    assert.ok(codec);
+    options.codec = codec;
+  });
+
+  it("Uint64BE", function() {
+    [
+      0, 1, Math.pow(2, 16), Math.pow(2, 32), Math.pow(2, 48)
+    ].forEach(function(value) {
+      var source = Uint64BE(value);
+      assert.equal(+source, value);
+      var encoded = msgpack.encode(source, options);
+      assert.equal(encoded[0], 0xcf);
+      assert.equal(encoded.length, 9);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(+decoded, value);
+    });
+
+    [
+      "0", "1", "123456789abcdef0", "fedcba9876543210"
+    ].forEach(function(value) {
+      var source = Uint64BE(value, 16);
+      assert.equal(source.toString(16), value);
+      var encoded = msgpack.encode(source, options);
+      assert.equal(encoded[0], 0xcf);
+      assert.equal(encoded.length, 9);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded.toString(16), value);
+    });
+  });
+
+  it("Int64BE", function() {
+    [
+      0, 1, Math.pow(2, 16), Math.pow(2, 32), Math.pow(2, 48),
+      -1, -Math.pow(2, 16), -Math.pow(2, 32), -Math.pow(2, 48)
+    ].forEach(function(value) {
+      var source = Int64BE(value);
+      assert.equal(+source, value);
+      var encoded = msgpack.encode(source, options);
+      assert.equal(encoded[0], 0xd3);
+      assert.equal(encoded.length, 9);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(+decoded, value);
+    });
+
+    [
+      "0", "1", "-1", "123456789abcdef0", "-123456789abcdef0"
+    ].forEach(function(value) {
+      var source = Int64BE(value, 16);
+      assert.equal(source.toString(16), value);
+      var encoded = msgpack.encode(source, options);
+      assert.equal(encoded[0], 0xd3);
+      assert.equal(encoded.length, 9);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded.toString(16), value);
+    });
+  });
+});

node_modules/msgpack-lite/test/26.es6.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+describe(TITLE, function() {
+
+  var skip = ("undefined" !== typeof Symbol) ? it : it.skip;
+  skip("Symbol", function() {
+    assert.deepEqual(toArray(msgpack.encode(Symbol("foo"))), [0xc0]);
+  });
+
+});
+
+function toArray(buffer) {
+  return Array.prototype.slice.call(buffer);
+}

node_modules/msgpack-lite/test/27.usemap.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var HAS_MAP = ("undefined" !== typeof Map);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+function pattern(min, max, offset) {
+  var array = [];
+  var check = {};
+  var val = min - 1;
+  while (val <= max) {
+    if (min <= val && !check[val]) array.push(val);
+    check[val++] = 1;
+    if (val <= max && !check[val]) array.push(val);
+    check[val++] = 1;
+    if (val <= max && !check[val]) array.push(val);
+    check[val--] = 1;
+    val = val ? val * 2 - 1 : 1;
+  }
+  return array;
+}
+
+// Run these tests when Map is available
+var describeSkip = HAS_MAP ? describe : describe.skip;
+
+describeSkip(TITLE, function() {
+
+  it("Map (small)", function() {
+    pattern(0, 257).forEach(function(length) {
+      var value = new Map();
+      assert.equal(true, value instanceof Map);
+      for (var i = 0; i < length; i++) {
+        var key = String.fromCharCode(i);
+        value.set(key, length);
+      }
+      assert.equal(value.size, length);
+      var options = {codec: msgpack.createCodec({usemap: true})};
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(true, decoded instanceof Map);
+      assert.equal(decoded.size, length);
+      assert.equal(decoded.get(String.fromCharCode(0)), value.get(String.fromCharCode(0)));
+      assert.equal(decoded.get(String.fromCharCode(length - 1)), value.get(String.fromCharCode(length - 1)));
+    });
+  });
+
+  it("Map (large)", function() {
+    this.timeout(30000);
+    pattern(65536, 65537).forEach(function(length) {
+      var value = new Map();
+      for (var i = 0; i < length; i++) {
+        value.set(i, length);
+      }
+      assert.equal(value.size, length);
+      var options = {codec: msgpack.createCodec({usemap: true})};
+      var encoded = msgpack.encode(value, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.equal(decoded.size, length);
+      assert.equal(decoded.get(0), value.get(0));
+      assert.equal(decoded.get(length - 1), value.get(length - 1));
+    });
+  });
+});

node_modules/msgpack-lite/test/30.stream.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var Stream = require("stream");
+var concat = require("concat-stream");
+
+var msgpack = require("../index");
+var TITLE = __filename.replace(/^.*\//, "");
+var example = require("./example.json");
+
+var src = [
+  ["foo"],
+  ["bar"],
+  ["baz"]
+];
+
+var encoded = [
+  msgpack.encode(src[0]),
+  msgpack.encode(src[1]),
+  msgpack.encode(src[2])
+];
+
+var encodeall = Buffer.concat(encoded);
+
+describe(TITLE, function() {
+
+  it("msgpack.createEncodeStream()", function(done) {
+    var encoder = msgpack.createEncodeStream();
+    encoder.pipe(concat(onEnd));
+    encoder.write(src[0]);
+    encoder.write(src[1]);
+    encoder.write(src[2]);
+    encoder.end();
+
+    function onEnd(data) {
+      assert.deepEqual(data, encodeall);
+      done();
+    }
+  });
+
+  it("msgpack.createDecodeStream()", function(done) {
+    var count = 0;
+    var decoder = msgpack.createDecodeStream();
+
+    decoder.on("data", onData);
+    decoder.write(encoded[0]);
+    decoder.write(encoded[1]);
+    decoder.write(encoded[2]);
+    decoder.end();
+
+    function onData(data) {
+      assert.deepEqual(data, src[count++]);
+      if (count === 3) done();
+    }
+  });
+
+  it("pipe(encoder).pipe(decoder)", function(done) {
+    var count = 0;
+    var inputStream = new Stream.PassThrough({objectMode: true});
+    var encoder = msgpack.createEncodeStream();
+    var passThrough = new Stream.PassThrough();
+    var decoder = msgpack.createDecodeStream();
+    var outputStream = new Stream.PassThrough({objectMode: true});
+
+    inputStream.pipe(encoder).pipe(passThrough).pipe(decoder).pipe(outputStream);
+    outputStream.on("data", onData);
+    inputStream.write(src[0]);
+    inputStream.write(src[1]);
+    inputStream.write(src[2]);
+    inputStream.end();
+
+    function onData(data) {
+      assert.deepEqual(data, src[count++]);
+      if (count === 3) done();
+    }
+  });
+
+  it("pipe(decoder).pipe(encoder)", function(done) {
+    var inputStream = new Stream.PassThrough();
+    var decoder = msgpack.createDecodeStream();
+    var passThrough = new Stream.PassThrough({objectMode: true});
+    var encoder = msgpack.createEncodeStream();
+
+    inputStream.pipe(decoder).pipe(passThrough).pipe(encoder).pipe(concat(onEnd));
+    inputStream.write(encoded[0]);
+    inputStream.write(encoded[1]);
+    inputStream.write(encoded[2]);
+    inputStream.end();
+
+    function onEnd(data) {
+      assert.deepEqual(data, encodeall);
+      done();
+    }
+  });
+
+  it("write()", function(done) {
+    var count = 0;
+    var buf = msgpack.encode(example);
+    var decoder = msgpack.createDecodeStream();
+    decoder.on("data", onData);
+
+    for (var i = 0; i < 3; i++) {
+      Array.prototype.forEach.call(buf, each);
+    }
+
+    // decode stream should be closed
+    decoder.end();
+
+    // write a single byte into the decode stream
+    function each(x) {
+      decoder.write(Buffer([x]));
+    }
+
+    function onData(data) {
+      assert.deepEqual(data, example);
+      if (++count === 3) done();
+    }
+  });
+});

node_modules/msgpack-lite/test/50.compat.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+
+var msgpack = require("../index");
+var TITLE = __filename.replace(/^.*\//, "");
+
+var data = require("./example.json");
+
+describe(TITLE, function() {
+  test("msgpack", function(they) {
+    assert.deepEqual(they.unpack(msgpack.encode(data)), data);
+    assert.deepEqual(msgpack.decode(Buffer(they.pack(data))), data);
+  });
+
+  test("msgpack-js", function(they) {
+    assert.deepEqual(they.decode(msgpack.encode(data)), data);
+    assert.deepEqual(msgpack.decode(Buffer(they.encode(data))), data);
+  });
+
+  test("msgpack-js-v5", function(they) {
+    assert.deepEqual(they.decode(msgpack.encode(data)), data);
+    assert.deepEqual(msgpack.decode(Buffer(they.encode(data))), data);
+  });
+
+  test("msgpack5", function(they) {
+    they = they();
+    assert.deepEqual(they.decode(msgpack.encode(data)), data);
+    assert.deepEqual(msgpack.decode(Buffer(they.encode(data))), data);
+  });
+
+  test("notepack", function(they) {
+    assert.deepEqual(they.decode(msgpack.encode(data)), data);
+    assert.deepEqual(msgpack.decode(Buffer(they.encode(data))), data);
+  });
+
+  test("msgpack-unpack", function(they) {
+    assert.deepEqual(they(msgpack.encode(data)), data);
+  });
+
+  test("msgpack.codec", function(they) {
+    they = they.msgpack;
+    assert.deepEqual(they.unpack(msgpack.encode(data)), data);
+    assert.deepEqual(msgpack.decode(Buffer(they.pack(data))), data);
+  });
+});
+
+function test(name, func) {
+  var they;
+  var method = it;
+  try {
+    they = require(name);
+  } catch (e) {
+    method = it.skip;
+    name += ": " + e;
+  }
+  method(name, func.bind(null, they));
+}

node_modules/msgpack-lite/test/61.encode-only.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+
+var encode = require("../lib/encode").encode;
+var ExtBuffer = require("../lib/ext-buffer").ExtBuffer;
+var TITLE = __filename.replace(/^.*\//, "");
+
+describe(TITLE, function() {
+  it("encode", function() {
+    // int
+    assert.deepEqual(toArray(encode(1)), [1]);
+
+    // str
+    assert.deepEqual(toArray(encode("a")), [161, 97]);
+
+    // ExtBuffer
+    var ext = new ExtBuffer(new Buffer([1]), 127);
+    assert.ok(ext instanceof ExtBuffer);
+    assert.deepEqual(toArray(encode(ext)), [212, 127, 1]);
+  });
+});
+
+function toArray(buffer) {
+  return Array.prototype.slice.call(buffer);
+}

node_modules/msgpack-lite/test/62.decode-only.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+
+var decode = require("../lib/decode").decode;
+var ExtBuffer = require("../lib/ext-buffer").ExtBuffer;
+var TITLE = __filename.replace(/^.*\//, "");
+
+describe(TITLE, function() {
+  it("decode", function() {
+    // int
+    assert.equal(decode([1]), 1);
+
+    // str
+    assert.equal(decode([161, 97]), "a");
+
+    // ExtBuffer
+    var ext = decode(new Buffer([212, 127, 1]));
+    assert.ok(ext instanceof ExtBuffer);
+    assert.equal(ext.buffer[0], 1);
+    assert.equal(ext.type, 127);
+  });
+});

node_modules/msgpack-lite/test/63.module-deps.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env mocha -R spec
+
+var TITLE = __filename.replace(/^.*\//, "");
+
+describe(TITLE, function() {
+  var mdeps;
+  var itSkip = it;
+
+  try {
+    mdeps = require("browserify/node_modules/module-deps");
+  } catch (e) {
+    itSkip = it.skip;
+  }
+
+  // index.js should not require stream modules
+
+  itSkip("index.js dependencies", function(next) {
+    var opt = {file: __dirname + "/../index.js"};
+    var list = [];
+    mdeps().on("data", onData).on("end", onEnd).end(opt);
+
+    function onData(data) {
+      list.push(data.file);
+    }
+
+    function onEnd() {
+      var hit = list.filter(check)[0];
+      next(hit && new Error(hit));
+    }
+
+    function check(value) {
+      return value.match(/stream/) && !value.match(/node_modules/);
+    }
+  });
+
+  // decode.js should not require encode|write modules
+
+  itSkip("decode.js dependencies", function(next) {
+    var opt = {file: __dirname + "/../lib/decode.js"};
+    var list = [];
+    mdeps().on("data", onData).on("end", onEnd).end(opt);
+
+    function onData(data) {
+      list.push(data.file);
+    }
+
+    function onEnd() {
+      var hit = list.filter(check)[0];
+      next(hit && new Error(hit));
+    }
+
+    function check(value) {
+      return value.match(/encode|write/) && !value.match(/node_modules/);
+    }
+  });
+
+  // encode.js should not require decode|read modules
+
+  itSkip("encode.js dependencies", function(next) {
+    var opt = {file: __dirname + "/../lib/encode.js"};
+    var list = [];
+    mdeps().on("data", onData).on("end", onEnd).end(opt);
+
+    function onData(data) {
+      list.push(data.file);
+    }
+
+    function onEnd() {
+      var hit = list.filter(check)[0];
+      next(hit && new Error(hit));
+    }
+
+    function check(value) {
+      return value.match(/decode|read/) && !value.match(/node_modules/);
+    }
+  });
+});

node_modules/msgpack-lite/test/example.json

@@ -0,0 +1,52 @@
+{
+  "int0": 0,
+  "int1": 1,
+  "int1-": -1,
+  "int8": 255,
+  "int8-": -255,
+  "int16": 256,
+  "int16-": -256,
+  "int32": 65536,
+  "int32-": -65536,
+  "nil": null,
+  "true": true,
+  "false": false,
+  "float": 0.5,
+  "float-": -0.5,
+  "string0": "",
+  "string1": "A",
+  "string4": "foobarbaz",
+  "string8": "Omnes viae Romam ducunt.",
+  "string16": "L’homme n’est qu’un roseau, le plus faible de la nature ; mais c’est un roseau pensant. Il ne faut pas que l’univers entier s’arme pour l’écraser : une vapeur, une goutte d’eau, suffit pour le tuer. Mais, quand l’univers l’écraserait, l’homme serait encore plus noble que ce qui le tue, puisqu’il sait qu’il meurt, et l’avantage que l’univers a sur lui, l’univers n’en sait rien. Toute notre dignité consiste donc en la pensée. C’est de là qu’il faut nous relever et non de l’espace et de la durée, que nous ne saurions remplir. Travaillons donc à bien penser : voilà le principe de la morale.",
+  "array0": [],
+  "array1": [
+    "foo"
+  ],
+  "array8": [
+    1,
+    2,
+    4,
+    8,
+    16,
+    32,
+    64,
+    128,
+    256,
+    512,
+    1024,
+    2048,
+    4096,
+    8192,
+    16384,
+    32768,
+    65536,
+    131072,
+    262144,
+    524288,
+    1048576
+  ],
+  "map0": {},
+  "map1": {
+    "foo": "bar"
+  }
+}

node_modules/msgpack-lite/test/zuul/ie.html

@@ -0,0 +1,4 @@
+<!--[if lte IE 9]>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/es5-shim/4.1.10/es5-shim.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/json3/3.3.2/json3.min.js"></script>
+<![endif]-->