msgpack-lite 0.1.20 → 0.1.26

package/lib/write-token.js

@@ -1,21 +1,40 @@
 // write-token.js
 
-var BufferLite = require("./buffer-lite");
-var uint8 = require("./write-uint8").uint8;
+var ieee754 = require("ieee754");
+var Int64Buffer = require("int64-buffer");
+var Uint64BE = Int64Buffer.Uint64BE;
+var Int64BE = Int64Buffer.Int64BE;
 
-var IS_BUFFER_SHIM = ("TYPED_ARRAY_SUPPORT" in Buffer);
+var uint8 = require("./write-uint8").uint8;
+var Bufferish = require("./bufferish");
+var Buffer = Bufferish.global;
+var IS_BUFFER_SHIM = Bufferish.hasBuffer && ("TYPED_ARRAY_SUPPORT" in Buffer);
 var NO_TYPED_ARRAY = IS_BUFFER_SHIM && !Buffer.TYPED_ARRAY_SUPPORT;
+var Buffer_prototype = Bufferish.hasBuffer && Buffer.prototype || {};
 
 exports.getWriteToken = getWriteToken;
 
 function getWriteToken(options) {
-  if (NO_TYPED_ARRAY || (options && options.safe)) {
+  if (options && options.uint8array) {
+    return init_uint8array();
+  } else if (NO_TYPED_ARRAY || (Bufferish.hasBuffer && options && options.safe)) {
     return init_safe();
   } else {
     return init_token();
   }
 }
 
+function init_uint8array() {
+  var token = init_token();
+
+  // float 32 -- 0xca
+  // float 64 -- 0xcb
+  token[0xca] = writeN(0xca, 4, writeFloatBE);
+  token[0xcb] = writeN(0xcb, 8, writeDoubleBE);
+
+  return token;
+}
+
 // Node.js and browsers with TypedArray
 
 function init_token() {
@@ -43,8 +62,8 @@ function init_token() {
 
   // float 32 -- 0xca
   // float 64 -- 0xcb
-  token[0xca] = writeN(0xca, 4, Buffer.prototype.writeFloatBE, true);
-  token[0xcb] = writeN(0xcb, 8, Buffer.prototype.writeDoubleBE, true);
+  token[0xca] = writeN(0xca, 4, (Buffer_prototype.writeFloatBE || writeFloatBE), true);
+  token[0xcb] = writeN(0xcb, 8, (Buffer_prototype.writeDoubleBE || writeDoubleBE), true);
 
   // uint 8 -- 0xcc
   // uint 16 -- 0xcd
@@ -53,7 +72,7 @@ function init_token() {
   token[0xcc] = write1(0xcc);
   token[0xcd] = write2(0xcd);
   token[0xce] = write4(0xce);
-  token[0xcf] = writeN(0xcf, 8, BufferLite.writeUint64BE);
+  token[0xcf] = writeN(0xcf, 8, writeUInt64BE);
 
   // int 8 -- 0xd0
   // int 16 -- 0xd1
@@ -62,7 +81,7 @@ function init_token() {
   token[0xd0] = write1(0xd0);
   token[0xd1] = write2(0xd1);
   token[0xd2] = write4(0xd2);
-  token[0xd3] = writeN(0xd3, 8, BufferLite.writeUint64BE);
+  token[0xd3] = writeN(0xd3, 8, writeInt64BE);
 
   // str 8 -- 0xd9
   // str 16 -- 0xda
@@ -121,7 +140,7 @@ function init_safe() {
   token[0xcc] = writeN(0xcc, 1, Buffer.prototype.writeUInt8);
   token[0xcd] = writeN(0xcd, 2, Buffer.prototype.writeUInt16BE);
   token[0xce] = writeN(0xce, 4, Buffer.prototype.writeUInt32BE);
-  token[0xcf] = writeN(0xcf, 8, BufferLite.writeUint64BE);
+  token[0xcf] = writeN(0xcf, 8, writeUInt64BE);
 
   // int 8 -- 0xd0
   // int 16 -- 0xd1
@@ -130,7 +149,7 @@ function init_safe() {
   token[0xd0] = writeN(0xd0, 1, Buffer.prototype.writeInt8);
   token[0xd1] = writeN(0xd1, 2, Buffer.prototype.writeInt16BE);
   token[0xd2] = writeN(0xd2, 4, Buffer.prototype.writeInt32BE);
-  token[0xd3] = writeN(0xd3, 8, BufferLite.writeUint64BE);
+  token[0xd3] = writeN(0xd3, 8, writeInt64BE);
 
   // str 8 -- 0xd9
   // str 16 -- 0xda
@@ -154,46 +173,55 @@ function init_safe() {
 
 function write1(type) {
   return function(encoder, value) {
-    encoder.reserve(2);
+    var offset = encoder.reserve(2);
     var buffer = encoder.buffer;
-    var offset = encoder.offset;
     buffer[offset++] = type;
-    buffer[offset++] = value;
-    encoder.offset = offset;
+    buffer[offset] = value;
   };
 }
 
 function write2(type) {
   return function(encoder, value) {
-    encoder.reserve(3);
+    var offset = encoder.reserve(3);
     var buffer = encoder.buffer;
-    var offset = encoder.offset;
     buffer[offset++] = type;
     buffer[offset++] = value >>> 8;
-    buffer[offset++] = value;
-    encoder.offset = offset;
+    buffer[offset] = value;
   };
 }
 
 function write4(type) {
   return function(encoder, value) {
-    encoder.reserve(5);
+    var offset = encoder.reserve(5);
     var buffer = encoder.buffer;
-    var offset = encoder.offset;
     buffer[offset++] = type;
     buffer[offset++] = value >>> 24;
     buffer[offset++] = value >>> 16;
     buffer[offset++] = value >>> 8;
-    buffer[offset++] = value;
-    encoder.offset = offset;
+    buffer[offset] = value;
   };
 }
 
 function writeN(type, len, method, noAssert) {
   return function(encoder, value) {
-    encoder.reserve(len + 1);
-    encoder.buffer[encoder.offset++] = type;
-    method.call(encoder.buffer, value, encoder.offset, noAssert);
-    encoder.offset += len;
+    var offset = encoder.reserve(len + 1);
+    encoder.buffer[offset++] = type;
+    method.call(encoder.buffer, value, offset, noAssert);
   };
 }
+
+function writeUInt64BE(value, offset) {
+  new Uint64BE(this, offset, value);
+}
+
+function writeInt64BE(value, offset) {
+  new Int64BE(this, offset, value);
+}
+
+function writeFloatBE(value, offset) {
+  ieee754.write(this, value, offset, false, 23, 4);
+}
+
+function writeDoubleBE(value, offset) {
+  ieee754.write(this, value, offset, false, 52, 8);
+}

package/lib/write-type.js

@@ -5,12 +5,14 @@ var Int64Buffer = require("int64-buffer");
 var Uint64BE = Int64Buffer.Uint64BE;
 var Int64BE = Int64Buffer.Int64BE;
 
-var BufferLite = require("./buffer-lite");
+var Bufferish = require("./bufferish");
+var BufferProto = require("./bufferish-proto");
 var WriteToken = require("./write-token");
 var uint8 = require("./write-uint8").uint8;
 var ExtBuffer = require("./ext-buffer").ExtBuffer;
 
-var IS_BUFFER_SHIM = ("TYPED_ARRAY_SUPPORT" in Buffer);
+var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
+var HAS_MAP = ("undefined" !== typeof Map);
 
 var extmap = [];
 extmap[1] = 0xd4;
@@ -23,22 +25,23 @@ exports.getWriteType = getWriteType;
 
 function getWriteType(options) {
   var token = WriteToken.getWriteToken(options);
+  var useraw = options && options.useraw;
+  var binarraybuffer = HAS_UINT8ARRAY && options && options.binarraybuffer;
+  var isBuffer = binarraybuffer ? Bufferish.isArrayBuffer : Bufferish.isBuffer;
+  var bin = binarraybuffer ? bin_arraybuffer : bin_buffer;
+  var usemap = HAS_MAP && options && options.usemap;
+  var map = usemap ? map_to_map : obj_to_map;
 
   var writeType = {
     "boolean": bool,
     "function": nil,
     "number": number,
-    "object": object,
-    "string": string,
+    "object": (useraw ? object_raw : object),
+    "string": _string(useraw ? raw_head_size : str_head_size),
     "symbol": nil,
     "undefined": nil
   };
 
-  if (options && options.useraw) {
-    writeType.object = object_raw;
-    writeType.string = string_raw;
-  }
-
   return writeType;
 
   // false -- 0xc2
@@ -90,33 +93,53 @@ function getWriteType(options) {
   // str 16 -- 0xda
   // str 32 -- 0xdb
   // fixstr -- 0xa0 - 0xbf
-  function string(encoder, value) {
-    // prepare buffer
-    var length = value.length;
-    var maxsize = 5 + length * 3;
-    encoder.reserve(maxsize);
+  function str_head_size(length) {
+    return (length < 32) ? 1 : (length <= 0xFF) ? 2 : (length <= 0xFFFF) ? 3 : 5;
+  }
 
-    // expected header size
-    var expected = (length < 32) ? 1 : (length <= 0xFF) ? 2 : (length <= 0xFFFF) ? 3 : 5;
+  // raw 16 -- 0xda
+  // raw 32 -- 0xdb
+  // fixraw -- 0xa0 - 0xbf
+  function raw_head_size(length) {
+    return (length < 32) ? 1 : (length <= 0xFFFF) ? 3 : 5;
+  }
 
-    // expected start point
-    var start = encoder.offset + expected;
+  function _string(head_size) {
+    return string;
 
-    // write string
-    length = BufferLite.writeString.call(encoder.buffer, value, start);
+    function string(encoder, value) {
+      // prepare buffer
+      var length = value.length;
+      var maxsize = 5 + length * 3;
+      encoder.offset = encoder.reserve(maxsize);
+      var buffer = encoder.buffer;
 
-    // actual header size
-    var actual = (length < 32) ? 1 : (length <= 0xFF) ? 2 : (length <= 0xFFFF) ? 3 : 5;
+      // expected header size
+      var expected = head_size(length);
 
-    // move content when needed
-    if (expected !== actual) move(encoder, start, length, actual - expected);
+      // expected start point
+      var start = encoder.offset + expected;
 
-    // write header
-    var type = (actual === 1) ? (0xa0 + length) : (actual <= 3) ? 0xd7 + actual : 0xdb;
-    token[type](encoder, length);
+      // write string
+      length = BufferProto.write.call(buffer, value, start);
+
+      // actual header size
+      var actual = head_size(length);
+
+      // move content when needed
+      if (expected !== actual) {
+        var targetStart = start + actual - expected;
+        var end = start + length;
+        BufferProto.copy.call(buffer, buffer, targetStart, start, end);
+      }
 
-    // move cursor
-    encoder.offset += length;
+      // write header
+      var type = (actual === 1) ? (0xa0 + length) : (actual <= 3) ? (0xd7 + actual) : 0xdb;
+      token[type](encoder, length);
+
+      // move cursor
+      encoder.offset += length;
+    }
   }
 
   function object(encoder, value) {
@@ -124,7 +147,7 @@ function getWriteType(options) {
     if (value === null) return nil(encoder, value);
 
     // Buffer
-    if (Buffer.isBuffer(value)) return bin(encoder, value);
+    if (isBuffer(value)) return bin(encoder, value);
 
     // Array
     if (IS_ARRAY(value)) return array(encoder, value);
@@ -138,10 +161,18 @@ function getWriteType(options) {
     if (packer) value = packer(value);
     if (value instanceof ExtBuffer) return ext(encoder, value);
 
-    // plain old objects
+    // plain old Objects or Map
     map(encoder, value);
   }
 
+  function object_raw(encoder, value) {
+    // Buffer
+    if (isBuffer(value)) return raw(encoder, value);
+
+    // others
+    object(encoder, value);
+  }
+
   // nil -- 0xc0
   function nil(encoder, value) {
     var type = 0xc0;
@@ -165,13 +196,17 @@ function getWriteType(options) {
   // bin 8 -- 0xc4
   // bin 16 -- 0xc5
   // bin 32 -- 0xc6
-  function bin(encoder, value) {
+  function bin_buffer(encoder, value) {
     var length = value.length;
     var type = (length < 0xFF) ? 0xc4 : (length <= 0xFFFF) ? 0xc5 : 0xc6;
     token[type](encoder, length);
     encoder.send(value);
   }
 
+  function bin_arraybuffer(encoder, value) {
+    bin_buffer(encoder, new Uint8Array(value));
+  }
+
   // fixext 1 -- 0xd4
   // fixext 2 -- 0xd5
   // fixext 4 -- 0xd6
@@ -192,7 +227,7 @@ function getWriteType(options) {
   // fixmap -- 0x80 - 0x8f
   // map 16 -- 0xde
   // map 32 -- 0xdf
-  function map(encoder, value) {
+  function obj_to_map(encoder, value) {
     var keys = Object.keys(value);
     var length = keys.length;
     var type = (length < 16) ? (0x80 + length) : (length <= 0xFFFF) ? 0xde : 0xdf;
@@ -205,57 +240,30 @@ function getWriteType(options) {
     });
   }
 
-  // raw 16 -- 0xda
-  // raw 32 -- 0xdb
-  // fixraw -- 0xa0 - 0xbf
-  function string_raw(encoder, value) {
-    // prepare buffer
-    var length = value.length;
-    var maxsize = 5 + length * 3;
-    encoder.reserve(maxsize);
-
-    // expected header size
-    var expected = (length < 32) ? 1 : (length <= 0xFFFF) ? 3 : 5;
-
-    // expected start point
-    var start = encoder.offset + expected;
-
-    // write string
-    length = BufferLite.writeString.call(encoder.buffer, value, start);
-
-    // actual header size
-    var actual = (length < 32) ? 1 : (length <= 0xFFFF) ? 3 : 5;
-
-    // move content when needed
-    if (expected !== actual) move(encoder, start, length, actual - expected);
+  // fixmap -- 0x80 - 0x8f
+  // map 16 -- 0xde
+  // map 32 -- 0xdf
+  function map_to_map(encoder, value) {
+    if (!(value instanceof Map)) return obj_to_map(encoder, value);
 
-    // write header
-    var type = (length < 32) ? (0xa0 + length) : (length <= 0xFFFF) ? 0xda : 0xdb;
+    var length = value.size;
+    var type = (length < 16) ? (0x80 + length) : (length <= 0xFFFF) ? 0xde : 0xdf;
     token[type](encoder, length);
 
-    // move cursor
-    encoder.offset += length;
+    var encode = encoder.codec.encode;
+    value.forEach(function(val, key, m) {
+      encode(encoder, key);
+      encode(encoder, val);
+    });
   }
 
   // raw 16 -- 0xda
   // raw 32 -- 0xdb
   // fixraw -- 0xa0 - 0xbf
-  function object_raw(encoder, value) {
-    if (!Buffer.isBuffer(value)) return object(encoder, value);
-
+  function raw(encoder, value) {
     var length = value.length;
     var type = (length < 32) ? (0xa0 + length) : (length <= 0xFFFF) ? 0xda : 0xdb;
     token[type](encoder, length);
     encoder.send(value);
   }
 }
-
-function move(encoder, start, length, diff) {
-  var targetStart = start + diff;
-  var end = start + length;
-  if (IS_BUFFER_SHIM) {
-    BufferLite.copy.call(encoder.buffer, encoder.buffer, targetStart, start, end);
-  } else {
-    encoder.buffer.copy(encoder.buffer, targetStart, start, end);
-  }
-}

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.26",
   "author": "@kawanet",
   "bin": {
     "msgpack": "./bin/msgpack"
@@ -11,26 +11,28 @@
     "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 Wise <josh@joshuawise.ninja>",
+    "Maciej Hirsz <maciej.hirsz@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",
+    "zuul": "^3.11.1"
   },
   "homepage": "https://github.com/kawanet/msgpack-lite",
   "jshintConfig": {
@@ -38,6 +40,7 @@
     "globals": {
       "JSON": true,
       "Symbol": true,
+      "Map": true,
       "window": true
     },
     "mocha": true,
@@ -45,6 +48,7 @@
     "undef": true
   },
   "keywords": [
+    "arraybuffer",
     "buffer",
     "fluentd",
     "messagepack",
@@ -52,7 +56,6 @@
     "serialize",
     "stream",
     "typedarray",
-    "arraybuffer",
     "uint8array"
   ],
   "license": "MIT",
@@ -62,6 +65,13 @@
     "url": "https://github.com/kawanet/msgpack-lite.git"
   },
   "scripts": {
-    "test": "make test"
+    "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",
+    "test-browser-local": "make test-browser-local"
   }
 }