msgpack-lite 0.1.17 → 0.1.26

package/lib/read-format.js

@@ -1,39 +1,52 @@
 // read-format.js
 
-exports.format = {
-  map: map,
-  array: array,
-  str: str,
-  bin: bin,
-  ext: ext,
-  uint8: uint8,
-  uint16: uint16,
-  uint32: read(4, Buffer.prototype.readUInt32BE),
-  uint64: read(8, readUInt64BE),
-  int8: read(1, Buffer.prototype.readInt8),
-  int16: read(2, Buffer.prototype.readInt16BE),
-  int32: read(4, Buffer.prototype.readInt32BE),
-  int64: read(8, readInt64BE),
-  float32: read(4, readFloatBE),
-  float64: read(8, readDoubleBE)
-};
-
 var ieee754 = require("ieee754");
+var Int64Buffer = require("int64-buffer");
+var Uint64BE = Int64Buffer.Uint64BE;
+var Int64BE = Int64Buffer.Int64BE;
+
+exports.getReadFormat = getReadFormat;
+exports.readUint8 = uint8;
 
-var BufferLite = require("./buffer-lite");
-var decode = require("./read-core").decode;
-var BUFFER_SHORTAGE = require("./common").BUFFER_SHORTAGE;
-var readInt32BE = Buffer.prototype.readInt32BE;
-var readUInt32BE = Buffer.prototype.readUInt32BE;
+var Bufferish = require("./bufferish");
+var BufferProto = require("./bufferish-proto");
 
-var IS_BUFFER_SHIM = ("TYPED_ARRAY_SUPPORT" in Buffer);
+var HAS_MAP = ("undefined" !== typeof Map);
 var NO_ASSERT = true;
 
-function map(decoder, len) {
+function getReadFormat(options) {
+  var binarraybuffer = Bufferish.hasArrayBuffer && options && options.binarraybuffer;
+  var int64 = options && options.int64;
+  var usemap = HAS_MAP && options && options.usemap;
+
+  var readFormat = {
+    map: (usemap ? map_to_map : map_to_obj),
+    array: array,
+    str: str,
+    bin: (binarraybuffer ? bin_arraybuffer : bin_buffer),
+    ext: ext,
+    uint8: uint8,
+    uint16: uint16,
+    uint32: uint32,
+    uint64: read(8, int64 ? readUInt64BE_int64 : readUInt64BE),
+    int8: int8,
+    int16: int16,
+    int32: int32,
+    int64: read(8, int64 ? readInt64BE_int64 : readInt64BE),
+    float32: read(4, readFloatBE),
+    float64: read(8, readDoubleBE)
+  };
+
+  return readFormat;
+}
+
+function map_to_obj(decoder, len) {
   var value = {};
   var i;
   var k = new Array(len);
   var v = new Array(len);
+
+  var decode = decoder.codec.decode;
   for (i = 0; i < len; i++) {
     k[i] = decode(decoder);
     v[i] = decode(decoder);
@@ -44,8 +57,26 @@ function map(decoder, len) {
   return value;
 }
 
+function map_to_map(decoder, len) {
+  var value = new Map();
+  var i;
+  var k = new Array(len);
+  var v = new Array(len);
+
+  var decode = decoder.codec.decode;
+  for (i = 0; i < len; i++) {
+    k[i] = decode(decoder);
+    v[i] = decode(decoder);
+  }
+  for (i = 0; i < len; i++) {
+    value.set(k[i], v[i]);
+  }
+  return value;
+}
+
 function array(decoder, len) {
   var value = new Array(len);
+  var decode = decoder.codec.decode;
   for (var i = 0; i < len; i++) {
     value[i] = decode(decoder);
   }
@@ -53,83 +84,98 @@ function array(decoder, len) {
 }
 
 function str(decoder, len) {
-  var start = decoder.offset;
-  var end = decoder.offset = start + len;
-  var buffer = decoder.buffer;
-  if (end > buffer.length) throw BUFFER_SHORTAGE;
-  if (IS_BUFFER_SHIM || !Buffer.isBuffer(buffer)) {
-    // slower (compat)
-    return BufferLite.readString.call(buffer, start, end);
-  } else {
-    // 2x faster
-    return buffer.toString("utf-8", start, end);
-  }
+  var start = decoder.reserve(len);
+  var end = start + len;
+  return BufferProto.toString.call(decoder.buffer, "utf-8", start, end);
 }
 
-function bin(decoder, len) {
-  var start = decoder.offset;
-  var end = decoder.offset = start + len;
-  if (end > decoder.buffer.length) throw BUFFER_SHORTAGE;
-  return slice.call(decoder.buffer, start, end);
+function bin_buffer(decoder, len) {
+  var start = decoder.reserve(len);
+  var end = start + len;
+  var buf = BufferProto.slice.call(decoder.buffer, start, end);
+  return Bufferish.from(buf);
+}
+
+function bin_arraybuffer(decoder, len) {
+  var start = decoder.reserve(len);
+  var end = start + len;
+  var buf = BufferProto.slice.call(decoder.buffer, start, end);
+  return Bufferish.Uint8Array.from(buf).buffer;
 }
 
 function ext(decoder, len) {
-  var start = decoder.offset;
-  var end = decoder.offset = start + len + 1;
-  if (end > decoder.buffer.length) throw BUFFER_SHORTAGE;
-  var type = decoder.buffer[start];
+  var start = decoder.reserve(len+1);
+  var type = decoder.buffer[start++];
+  var end = start + len;
   var unpack = decoder.codec.getExtUnpacker(type);
   if (!unpack) throw new Error("Invalid ext type: " + (type ? ("0x" + type.toString(16)) : type));
-  var buf = slice.call(decoder.buffer, start + 1, end);
+  var buf = BufferProto.slice.call(decoder.buffer, start, end);
   return unpack(buf);
 }
 
 function uint8(decoder) {
-  var buffer = decoder.buffer;
-  if (decoder.offset >= buffer.length) throw BUFFER_SHORTAGE;
-  return buffer[decoder.offset++];
+  var start = decoder.reserve(1);
+  return decoder.buffer[start];
+}
+
+function int8(decoder) {
+  var start = decoder.reserve(1);
+  var value = decoder.buffer[start];
+  return (value & 0x80) ? value - 0x100 : value;
 }
 
 function uint16(decoder) {
+  var start = decoder.reserve(2);
+  var buffer = decoder.buffer;
+  return (buffer[start++] << 8) | buffer[start];
+}
+
+function int16(decoder) {
+  var start = decoder.reserve(2);
+  var buffer = decoder.buffer;
+  var value = (buffer[start++] << 8) | buffer[start];
+  return (value & 0x8000) ? value - 0x10000 : value;
+}
+
+function uint32(decoder) {
+  var start = decoder.reserve(4);
   var buffer = decoder.buffer;
-  if (decoder.offset + 2 > buffer.length) throw BUFFER_SHORTAGE;
-  return (buffer[decoder.offset++] << 8) | buffer[decoder.offset++];
+  return (buffer[start++] * 16777216) + (buffer[start++] << 16) + (buffer[start++] << 8) + buffer[start];
+}
+
+function int32(decoder) {
+  var start = decoder.reserve(4);
+  var buffer = decoder.buffer;
+  return (buffer[start++] << 24) | (buffer[start++] << 16) | (buffer[start++] << 8) | buffer[start];
 }
 
 function read(len, method) {
   return function(decoder) {
-    var start = decoder.offset;
-    var end = decoder.offset = start + len;
-    if (end > decoder.buffer.length) throw BUFFER_SHORTAGE;
+    var start = decoder.reserve(len);
     return method.call(decoder.buffer, start, NO_ASSERT);
   };
 }
 
-function readUInt64BE(start, noAssert) {
-  var upper = readUInt32BE.call(this, start, noAssert);
-  var lower = readUInt32BE.call(this, start + 4, noAssert);
-  return upper ? (upper * 4294967296 + lower) : lower;
+function readUInt64BE(start) {
+  return new Uint64BE(this, start).toNumber();
+}
+
+function readInt64BE(start) {
+  return new Int64BE(this, start).toNumber();
 }
 
-function readInt64BE(start, noAssert) {
-  var upper = readInt32BE.call(this, start, noAssert);
-  var lower = readUInt32BE.call(this, start + 4, noAssert);
-  return upper ? (upper * 4294967296 + lower) : lower;
+function readUInt64BE_int64(start) {
+  return new Uint64BE(this, start);
+}
+
+function readInt64BE_int64(start) {
+  return new Int64BE(this, start);
 }
 
 function readFloatBE(start) {
-  if (this.readFloatBE) return this.readFloatBE(start);
   return ieee754.read(this, start, false, 23, 4);
 }
 
 function readDoubleBE(start) {
-  if (this.readDoubleBE) return this.readDoubleBE(start);
   return ieee754.read(this, start, false, 52, 8);
-}
-
-function slice(start, end) {
-  var f = this.slice || Array.prototype.slice;
-  var buf = f.call(this, start, end);
-  if (!Buffer.isBuffer(buf)) buf = Buffer(buf);
-  return buf;
-}
+}

package/lib/read-token.js

@@ -1,13 +1,22 @@
 // read-token.js
 
-var token = exports.token = new Array(256);
+var ReadFormat = require("./read-format");
 
-var format = require("./read-format").format;
+exports.getReadToken = getReadToken;
 
-init();
+function getReadToken(options) {
+  var format = ReadFormat.getReadFormat(options);
 
-function init() {
+  if (options && options.useraw) {
+    return init_useraw(format);
+  } else {
+    return init_token(format);
+  }
+}
+
+function init_token(format) {
   var i;
+  var token = new Array(256);
 
   // positive fixint -- 0x00 - 0x7f
   for (i = 0x00; i <= 0x7f; i++) {
@@ -109,6 +118,27 @@ function init() {
   for (i = 0xe0; i <= 0xff; i++) {
     token[i] = constant(i - 0x100);
   }
+
+  return token;
+}
+
+function init_useraw(format) {
+  var i;
+  var token = init_token(format).slice();
+
+  // raw 8 -- 0xd9
+  // raw 16 -- 0xda
+  // raw 32 -- 0xdb
+  token[0xd9] = token[0xc4];
+  token[0xda] = token[0xc5];
+  token[0xdb] = token[0xc6];
+
+  // fixraw -- 0xa0 - 0xbf
+  for (i = 0xa0; i <= 0xbf; i++) {
+    token[i] = fix(i - 0xa0, format.bin);
+  }
+
+  return token;
 }
 
 function constant(value) {

package/lib/write-core.js

@@ -1,11 +1,69 @@
 // write-core.js
 
-exports.encode = encode;
+var ExtBuffer = require("./ext-buffer").ExtBuffer;
+var ExtPacker = require("./ext-packer");
+var WriteType = require("./write-type");
+var CodecBase = require("./codec-base");
 
-var type = require("./write-type").type;
+CodecBase.install({
+  addExtPacker: addExtPacker,
+  getExtPacker: getExtPacker,
+  init: init
+});
 
-function encode(encoder, value) {
-  var func = type[typeof value];
-  if (!func) throw new Error("Unsupported type \"" + (typeof value) + "\": " + value);
-  func(encoder, value);
+exports.preset = init.call(CodecBase.preset);
+
+function getEncoder(options) {
+  var writeType = WriteType.getWriteType(options);
+  return encode;
+
+  function encode(encoder, value) {
+    var func = writeType[typeof value];
+    if (!func) throw new Error("Unsupported type \"" + (typeof value) + "\": " + value);
+    func(encoder, value);
+  }
+}
+
+function init() {
+  var options = this.options;
+  this.encode = getEncoder(options);
+
+  if (options && options.preset) {
+    ExtPacker.setExtPackers(this);
+  }
+
+  return this;
+}
+
+function addExtPacker(etype, Class, packer) {
+  packer = CodecBase.filter(packer);
+  var name = Class.name;
+  if (name && name !== "Object") {
+    var packers = this.extPackers || (this.extPackers = {});
+    packers[name] = extPacker;
+  } else {
+    // fallback for IE
+    var list = this.extEncoderList || (this.extEncoderList = []);
+    list.unshift([Class, extPacker]);
+  }
+
+  function extPacker(value) {
+    if (packer) value = packer(value);
+    return new ExtBuffer(value, etype);
+  }
+}
+
+function getExtPacker(value) {
+  var packers = this.extPackers || (this.extPackers = {});
+  var c = value.constructor;
+  var e = c && c.name && packers[c.name];
+  if (e) return e;
+
+  // fallback for IE
+  var list = this.extEncoderList || (this.extEncoderList = []);
+  var len = list.length;
+  for (var i = 0; i < len; i++) {
+    var pair = list[i];
+    if (c === pair[0]) return pair[1];
+  }
 }

package/lib/write-token.js

@@ -1,34 +1,51 @@
 // write-token.js
 
-var token = exports.token = new Array(256);
+var ieee754 = require("ieee754");
+var Int64Buffer = require("int64-buffer");
+var Uint64BE = Int64Buffer.Uint64BE;
+var Int64BE = Int64Buffer.Int64BE;
 
-var BufferLite = require("./buffer-lite");
 var uint8 = require("./write-uint8").uint8;
-
-var NO_ASSERT = true;
-var IS_BUFFER_SHIM = ("TYPED_ARRAY_SUPPORT" in Buffer);
+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 (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;
+}
 
-init();
+// Node.js and browsers with TypedArray
 
-function init() {
+function init_token() {
+  // (immediate values)
   // positive fixint -- 0x00 - 0x7f
   // nil -- 0xc0
   // false -- 0xc2
   // true -- 0xc3
   // negative fixint -- 0xe0 - 0xff
-  for (var i = 0x00; i <= 0xFF; i++) {
-    token[i] = uint8[i];
-  }
+  var token = uint8.slice();
 
-  if (NO_TYPED_ARRAY) {
-    init_compatible(); // old browsers
-  } else {
-    init_optimized(); // Node.js and browsers with TypedArray
-  }
-}
-
-function init_optimized() {
   // bin 8 -- 0xc4
   // bin 16 -- 0xc5
   // bin 32 -- 0xc6
@@ -45,8 +62,8 @@ function init_optimized() {
 
   // float 32 -- 0xca
   // float 64 -- 0xcb
-  token[0xca] = writeN(0xca, 4, Buffer.prototype.writeFloatBE);
-  token[0xcb] = writeN(0xcb, 8, Buffer.prototype.writeDoubleBE);
+  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
@@ -55,7 +72,7 @@ function init_optimized() {
   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
@@ -64,7 +81,7 @@ function init_optimized() {
   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
@@ -82,9 +99,21 @@ function init_optimized() {
   // map 32 -- 0xdf
   token[0xde] = write2(0xde);
   token[0xdf] = write4(0xdf);
+
+  return token;
 }
 
-function init_compatible() {
+// safe mode: for old browsers and who needs asserts
+
+function init_safe() {
+  // (immediate values)
+  // positive fixint -- 0x00 - 0x7f
+  // nil -- 0xc0
+  // false -- 0xc2
+  // true -- 0xc3
+  // negative fixint -- 0xe0 - 0xff
+  var token = uint8.slice();
+
   // bin 8 -- 0xc4
   // bin 16 -- 0xc5
   // bin 32 -- 0xc6
@@ -111,7 +140,7 @@ function init_compatible() {
   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
@@ -120,7 +149,7 @@ function init_compatible() {
   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
@@ -138,50 +167,61 @@ function init_compatible() {
   // map 32 -- 0xdf
   token[0xde] = writeN(0xde, 2, Buffer.prototype.writeUInt16BE);
   token[0xdf] = writeN(0xdf, 4, Buffer.prototype.writeUInt32BE);
+
+  return token;
 }
 
 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) {
+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, NO_ASSERT);
-    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);
+}