msgpack-lite 0.1.20 → 0.1.27

package/lib/write-uint8.js

@@ -8,7 +8,7 @@ for (var i = 0x00; i <= 0xFF; i++) {
 
 function write0(type) {
   return function(encoder) {
-    encoder.reserve(1);
-    encoder.buffer[encoder.offset++] = type;
+    var offset = encoder.reserve(1);
+    encoder.buffer[offset] = type;
   };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "msgpack-lite",
   "description": "Fast Pure JavaScript MessagePack Encoder and Decoder",
-  "version": "0.1.20",
+  "version": "0.1.27",
   "author": "@kawanet",
   "bin": {
     "msgpack": "./bin/msgpack"
@@ -11,26 +11,29 @@
     "url": "https://github.com/kawanet/msgpack-lite/issues"
   },
   "contributors": [
+    "Christopher Vermilion <chris@figlyinc.com>",
     "Frederik Dudzik <4004blog@gmail.com>",
     "Garrett Serack <gserack@gmail.com>",
     "Jesse Armand <jesse@jessearmand.com>",
-    "Joshua Wise <josh@joshuawise.ninja>"
+    "Joshua Mouch <josh@mouch.name>",
+    "Joshua Wise <josh@joshuawise.ninja>",
+    "Maciej Hirsz <maciej.hirsz@gmail.com>",
+    "Rafał Michalski <royaltm75@gmail.com>"
   ],
   "dependencies": {
     "event-lite": "^0.1.1",
-    "ieee754": "^1.1.6",
-    "int64-buffer": "^0.1.6",
+    "ieee754": "^1.1.8",
+    "int64-buffer": "^0.1.9",
     "isarray": "^1.0.0"
   },
   "devDependencies": {
-    "async": "^1.5.2",
-    "browserify": "^13.0.0",
-    "concat-stream": "^1.5.1",
-    "jshint": "^2.9.2",
-    "mocha": "^2.4.5",
+    "async": "^2.1.1",
+    "browserify": "^13.1.0",
+    "concat-stream": "^1.5.2",
+    "jshint": "^2.9.3",
+    "mocha": "^3.1.2",
     "msgpack.codec": "git+https://github.com/kawanet/msgpack-javascript.git#msgpack.codec",
-    "uglify-js": "^2.6.2",
-    "zuul": "^3.10.1"
+    "uglify-js": "^2.7.3"
   },
   "homepage": "https://github.com/kawanet/msgpack-lite",
   "jshintConfig": {
@@ -38,6 +41,7 @@
     "globals": {
       "JSON": true,
       "Symbol": true,
+      "Map": true,
       "window": true
     },
     "mocha": true,
@@ -45,6 +49,7 @@
     "undef": true
   },
   "keywords": [
+    "arraybuffer",
     "buffer",
     "fluentd",
     "messagepack",
@@ -52,7 +57,6 @@
     "serialize",
     "stream",
     "typedarray",
-    "arraybuffer",
     "uint8array"
   ],
   "license": "MIT",
@@ -62,6 +66,12 @@
     "url": "https://github.com/kawanet/msgpack-lite.git"
   },
   "scripts": {
+    "benchmark": "./lib/benchmark.js",
+    "benchmark-lite": "./lib/benchmark.js msgpack-lite",
+    "benchmark-stream": "./lib/benchmark-stream.js",
+    "fixpack": "fixpack",
+    "make": "make",
+    "size": "make clean dist/msgpack.min.js && gzip -9fkv dist/msgpack.min.js && ls -l dist",
     "test": "make test"
   }
 }

package/test/10.encode.js

@@ -6,12 +6,32 @@ 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)), [i]);
+      assert.deepEqual(toArray(msgpack.encode(i, options)), [i]);
     }
   });
 
@@ -21,7 +41,7 @@ describe(TITLE, function() {
     var src = {};
     var exp = [0x80];
     Object.keys(map).forEach(function(key) {
-      assert.deepEqual(toArray(msgpack.encode(src)), exp);
+      assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
       src[key] = map[key];
       exp[0]++;
       exp.push(0xa1);
@@ -36,7 +56,7 @@ describe(TITLE, function() {
     var src = [];
     var exp = [0x90];
     for (var i = 0; i < 16; i++) {
-      assert.deepEqual(toArray(msgpack.encode(src)), exp);
+      assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
       src.push(array[i]);
       exp[0]++;
       exp.push(array[i]);
@@ -45,13 +65,13 @@ describe(TITLE, function() {
 
   // fixstr -- 0xa0 - 0xbf
   it("a0-bf: fixstr", function() {
-    assert.deepEqual(toArray(msgpack.encode("")), [0xa0]);
+    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)), exp);
+      assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
       exp[0]++;
       exp.push(str.charCodeAt(i));
     }
@@ -59,20 +79,20 @@ describe(TITLE, function() {
 
   // nil -- 0xc0
   it("c0: nil (null)", function() {
-    assert.deepEqual(toArray(msgpack.encode(null)), [0xc0]);
+    assert.deepEqual(toArray(msgpack.encode(null, options)), [0xc0]);
   });
   it("c0: nil (undefined)", function() {
-    assert.deepEqual(toArray(msgpack.encode(undefined)), [0xc0]);
+    assert.deepEqual(toArray(msgpack.encode(undefined, options)), [0xc0]);
   });
   it("c0: nil (Function)", function() {
-    assert.deepEqual(toArray(msgpack.encode(NOP)), [0xc0]);
+    assert.deepEqual(toArray(msgpack.encode(NOP, options)), [0xc0]);
   });
 
   // false -- 0xc2
   // true -- 0xc3
   it("c2-c3: boolean", function() {
-    assert.deepEqual(toArray(msgpack.encode(false)), [0xc2]);
-    assert.deepEqual(toArray(msgpack.encode(true)), [0xc3]);
+    assert.deepEqual(toArray(msgpack.encode(false, options)), [0xc2]);
+    assert.deepEqual(toArray(msgpack.encode(true, options)), [0xc3]);
   });
 
   // bin 8 -- 0xc4
@@ -81,23 +101,23 @@ describe(TITLE, function() {
   it("c4-c6: bin 8/16/32", function() {
     this.timeout(30000);
     var bin;
-    bin = Buffer(1);
+    bin = Buffer.alloc(1);
     bin.fill(0);
-    assert.deepEqual(toArray(msgpack.encode(bin)), concat([0xc4, 1], bin));
+    assert.deepEqual(toArray(msgpack.encode(bin, options)), concat([0xc4, 1], bin));
 
-    bin = Buffer(256);
+    bin = Buffer.alloc(256);
     bin.fill(0);
-    assert.deepEqual(toArray(msgpack.encode(bin)), concat([0xc5, 1, 0], bin));
+    assert.deepEqual(toArray(msgpack.encode(bin, options)), concat([0xc5, 1, 0], bin));
 
-    bin = Buffer(65536);
+    bin = Buffer.alloc(65536);
     bin.fill(0);
-    assert.deepEqual(toArray(msgpack.encode(bin)), concat([0xc6, 0, 1, 0, 0], bin));
+    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)), [0xcb, 63, 224, 0, 0, 0, 0, 0, 0]);
+    assert.deepEqual(toArray(msgpack.encode(0.5, options)), [0xcb, 63, 224, 0, 0, 0, 0, 0, 0]);
   });
 
   // uint 8 -- 0xcc
@@ -105,9 +125,9 @@ describe(TITLE, function() {
   // uint 32 -- 0xce
   // uint 64 -- 0xcf -- NOT SUPPORTED
   it("cc-cf: uint 8/16/32/64", function() {
-    assert.deepEqual(toArray(msgpack.encode(0xFF)), [0xcc, 0xFF]);
-    assert.deepEqual(toArray(msgpack.encode(0xFFFF)), [0xcd, 0xFF, 0xFF]);
-    assert.deepEqual(toArray(msgpack.encode(0x7FFFFFFF)), [0xce, 0x7F, 0xFF, 0xFF, 0xFF]);
+    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
@@ -115,9 +135,9 @@ describe(TITLE, function() {
   // int 32 -- 0xd2
   // int 64 -- 0xd3 -- NOT SUPPORTED
   it("d0-d3: int 8/16/32/64", function() {
-    assert.deepEqual(toArray(msgpack.encode(-0x80)), [0xd0, 0x80]);
-    assert.deepEqual(toArray(msgpack.encode(-0x8000)), [0xd1, 0x80, 0x00]);
-    assert.deepEqual(toArray(msgpack.encode(-0x80000000)), [0xd2, 0x80, 0x00, 0x00, 0x00]);
+    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
@@ -129,16 +149,16 @@ describe(TITLE, function() {
     for (var i = 0; i < 17; i++) src += src;
 
     str = src.substr(0, 0xFF);
-    assert.deepEqual(toArray(msgpack.encode(str)), concat([0xd9, 0xFF], Buffer(str)));
+    assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xd9, 0xFF], Buffer.from(str)));
 
     str = src.substr(0, 0x0100);
-    assert.deepEqual(toArray(msgpack.encode(str)), concat([0xda, 0x01, 0x00], Buffer(str)));
+    assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xda, 0x01, 0x00], Buffer.from(str)));
 
     str = src.substr(0, 0xFFFF);
-    assert.deepEqual(toArray(msgpack.encode(str)), concat([0xda, 0xFF, 0xFF], Buffer(str)));
+    assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xda, 0xFF, 0xFF], Buffer.from(str)));
 
     str = src.substr(0, 0x010000);
-    assert.deepEqual(toArray(msgpack.encode(str)), concat([0xdb, 0x00, 0x01, 0x00, 0x00], Buffer(str)));
+    assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xdb, 0x00, 0x01, 0x00, 0x00], Buffer.from(str)));
   });
 
   // array 16 -- 0xdc
@@ -149,11 +169,11 @@ describe(TITLE, function() {
     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)), exp);
+    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)), exp);
+    assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
   });
 
   // map 16 -- 0xde
@@ -163,14 +183,14 @@ describe(TITLE, function() {
     var i, actual;
     var map = {};
     for (i = 0; i < 256; i++) map[i] = i;
-    actual = msgpack.encode(map);
+    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);
+    actual = msgpack.encode(map, options);
     assert.equal(actual[0], 0xdf);
     assert.equal(actual[1], 0);
     assert.equal(actual[2], 1);
@@ -181,10 +201,10 @@ describe(TITLE, function() {
   // negative fixint -- 0xe0 - 0xff
   it("e0-ff: negative fixint", function() {
     for (var i = -32; i <= -1; i++) {
-      assert.deepEqual(toArray(msgpack.encode(i)), [i & 0xFF]);
+      assert.deepEqual(toArray(msgpack.encode(i, options)), [i & 0xFF]);
     }
   });
-});
+}
 
 function toArray(buffer) {
   return Array.prototype.slice.call(buffer);

package/test/11.decode.js

@@ -8,12 +8,13 @@ var TITLE = __filename.replace(/^.*\//, "");
 
 var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
 
+BufferBridge.concat = Buffer.concat;
 ArrayBridge.concat = ArrayBridge_concat;
 Uint8ArrayBridge.concat = Uint8ArrayBridge_concat;
 
 describe(TITLE, function() {
   describe("Buffer", function() {
-    run_tests(Buffer);
+    run_tests(BufferBridge);
   });
 
   describe("Array", function() {
@@ -153,12 +154,12 @@ function run_tests(BUFFER) {
   it("ca-cb: float 32/64", function() {
     var buf;
 
-    buf = Buffer(5);
+    buf = Buffer.alloc(5);
     buf.writeUInt8(0xCA, 0);
     buf.writeFloatBE(0.5, 1);
     assert.deepEqual(msgpack.decode(BUFFER(buf)), 0.5);
 
-    buf = Buffer(9);
+    buf = Buffer.alloc(9);
     buf.writeUInt8(0xCB, 0);
     buf.writeDoubleBE(0.5, 1);
     assert.deepEqual(msgpack.decode(BUFFER(buf)), 0.5);
@@ -176,6 +177,7 @@ function run_tests(BUFFER) {
     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);
@@ -195,6 +197,7 @@ function run_tests(BUFFER) {
     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);
@@ -313,6 +316,16 @@ function run_tests(BUFFER) {
   });
 }
 
+function BufferBridge(array) {
+  if ("number" === typeof array) {
+    array = init_seq(Buffer.alloc(array), array);
+  } else {
+    array = Buffer.from(array);
+  }
+
+  return array;
+}
+
 function ArrayBridge(array) {
   if ("number" === typeof array) {
     array = init_seq([], array);

package/test/14.codec.js

@@ -6,6 +6,8 @@ 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();
@@ -19,12 +21,12 @@ describe(TITLE, function() {
 
     function test(type) {
       // fixext 1 -- 0xd4
-      var source = new Buffer([0xd4, type, type]);
+      var source = Buffer.from([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(encoded, source);
+      assert.deepEqual(toArray(encoded), toArray(source));
     }
   });
 
@@ -80,9 +82,14 @@ function MyClass(value) {
 }
 
 function myClassPacker(obj) {
-  return new Buffer([obj.value]);
+  return Buffer.from([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);
+}

package/test/15.useraw.js

@@ -19,10 +19,10 @@ describe(TITLE, function() {
     options = {codec: msgpack.createCodec({useraw: true})};
 
     // raw
-    assert.deepEqual(toArray(msgpack.decode(new Buffer([0xa1, 65]), options)), [65]);
+    assert.deepEqual(toArray(msgpack.decode(Buffer.from([0xa1, 65]), options)), [65]);
 
     // str
-    assert.equal(msgpack.decode(new Buffer([0xa1, 65])), "A");
+    assert.equal(msgpack.decode(Buffer.from([0xa1, 65])), "A");
   });
 
   it("useraw (encode)", function() {
@@ -30,7 +30,7 @@ describe(TITLE, function() {
     assert.deepEqual(toArray(msgpack.encode("A", options)), [0xa1, 65]);
 
     // raw (Buffer)
-    assert.deepEqual(toArray(msgpack.encode(new Buffer([65]), options)), [0xa1, 65]);
+    assert.deepEqual(toArray(msgpack.encode(Buffer.from([65]), options)), [0xa1, 65]);
 
     // str
     assert.deepEqual(toArray(msgpack.encode("A")), [0xa1, 65]);
@@ -67,7 +67,7 @@ describe(TITLE, function() {
     TESTS.forEach(test);
 
     function test(length) {
-      var source = new Buffer(length);
+      var source = Buffer.alloc(length);
       for (var i = 0; i < length; i++) {
         source[i] = 65; // "A"
       }

package/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(Buffer.from([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 = Buffer.alloc(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(Buffer.from([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]);
+  });
+});

package/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 = Buffer.alloc(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
+  });
+});

package/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);
+}