msgpack-lite 0.1.20 → 0.1.26

package/lib/ext-unpacker.js

@@ -0,0 +1,81 @@
+// ext-unpacker.js
+
+exports.setExtUnpackers = setExtUnpackers;
+
+var Bufferish = require("./bufferish");
+var Buffer = Bufferish.global;
+var _decode;
+
+var ERROR_COLUMNS = {name: 1, message: 1, stack: 1, columnNumber: 1, fileName: 1, lineNumber: 1};
+
+function setExtUnpackers(codec) {
+  codec.addExtUnpacker(0x0E, [decode, unpackError(Error)]);
+  codec.addExtUnpacker(0x01, [decode, unpackError(EvalError)]);
+  codec.addExtUnpacker(0x02, [decode, unpackError(RangeError)]);
+  codec.addExtUnpacker(0x03, [decode, unpackError(ReferenceError)]);
+  codec.addExtUnpacker(0x04, [decode, unpackError(SyntaxError)]);
+  codec.addExtUnpacker(0x05, [decode, unpackError(TypeError)]);
+  codec.addExtUnpacker(0x06, [decode, unpackError(URIError)]);
+
+  codec.addExtUnpacker(0x0A, [decode, unpackRegExp]);
+  codec.addExtUnpacker(0x0B, [decode, unpackClass(Boolean)]);
+  codec.addExtUnpacker(0x0C, [decode, unpackClass(String)]);
+  codec.addExtUnpacker(0x0D, [decode, unpackClass(Date)]);
+  codec.addExtUnpacker(0x0F, [decode, unpackClass(Number)]);
+
+  if ("undefined" !== typeof Uint8Array) {
+    codec.addExtUnpacker(0x11, unpackClass(Int8Array));
+    codec.addExtUnpacker(0x12, unpackClass(Uint8Array));
+    codec.addExtUnpacker(0x13, [unpackArrayBuffer, unpackClass(Int16Array)]);
+    codec.addExtUnpacker(0x14, [unpackArrayBuffer, unpackClass(Uint16Array)]);
+    codec.addExtUnpacker(0x15, [unpackArrayBuffer, unpackClass(Int32Array)]);
+    codec.addExtUnpacker(0x16, [unpackArrayBuffer, unpackClass(Uint32Array)]);
+    codec.addExtUnpacker(0x17, [unpackArrayBuffer, unpackClass(Float32Array)]);
+
+    // PhantomJS/1.9.7 doesn't have Float64Array
+    if ("undefined" !== typeof Float64Array) {
+      codec.addExtUnpacker(0x18, [unpackArrayBuffer, unpackClass(Float64Array)]);
+    }
+
+    // IE10 doesn't have Uint8ClampedArray
+    if ("undefined" !== typeof Uint8ClampedArray) {
+      codec.addExtUnpacker(0x19, unpackClass(Uint8ClampedArray));
+    }
+
+    codec.addExtUnpacker(0x1A, unpackArrayBuffer);
+    codec.addExtUnpacker(0x1D, [unpackArrayBuffer, unpackClass(DataView)]);
+  }
+
+  if (Bufferish.hasBuffer) {
+    codec.addExtUnpacker(0x1B, unpackClass(Buffer));
+  }
+}
+
+function decode(input) {
+  if (!_decode) _decode = require("./decode").decode; // lazy load
+  return _decode(input);
+}
+
+function unpackRegExp(value) {
+  return RegExp.apply(null, value);
+}
+
+function unpackError(Class) {
+  return function(value) {
+    var out = new Class();
+    for (var key in ERROR_COLUMNS) {
+      out[key] = value[key];
+    }
+    return out;
+  };
+}
+
+function unpackClass(Class) {
+  return function(value) {
+    return new Class(value);
+  };
+}
+
+function unpackArrayBuffer(value) {
+  return (new Uint8Array(value)).buffer;
+}

package/lib/ext.js

@@ -1,80 +1,7 @@
 // ext.js
 
-var IS_ARRAY = require("isarray");
+// load both interfaces
+require("./read-core");
+require("./write-core");
 
-exports.createCodec = createCodec;
-
-var ExtBuffer = require("./ext-buffer").ExtBuffer;
-var ExtPreset = require("./ext-preset");
-var ReadCore = require("./read-core");
-var WriteCore = require("./write-core");
-
-function Codec(options) {
-  if (!(this instanceof Codec)) return new Codec(options);
-  this.extPackers = {};
-  this.extUnpackers = [];
-  this.encode = WriteCore.getEncoder(options);
-  this.decode = ReadCore.getDecoder(options);
-  if (options && options.preset) {
-    ExtPreset.setExtPreset(this);
-  }
-}
-
-function createCodec(options) {
-  return new Codec(options);
-}
-
-Codec.prototype.addExtPacker = function(etype, Class, packer) {
-  if (IS_ARRAY(packer)) {
-    packer = join(packer);
-  }
-  var name = Class.name;
-  if (name && name !== "Object") {
-    this.extPackers[name] = extPacker;
-  } else {
-    var list = this.extEncoderList || (this.extEncoderList = []);
-    list.unshift([Class, extPacker]);
-  }
-
-  function extPacker(value) {
-    var buffer = packer(value);
-    return new ExtBuffer(buffer, etype);
-  }
-};
-
-Codec.prototype.addExtUnpacker = function(etype, unpacker) {
-  this.extUnpackers[etype] = IS_ARRAY(unpacker) ? join(unpacker) : unpacker;
-};
-
-Codec.prototype.getExtPacker = function(value) {
-  var c = value.constructor;
-  var e = c && c.name && this.extPackers[c.name];
-  if (e) return e;
-  var list = this.extEncoderList;
-  if (!list) return;
-  var len = list.length;
-  for (var i = 0; i < len; i++) {
-    var pair = list[i];
-    if (c === pair[0]) return pair[1];
-  }
-};
-
-Codec.prototype.getExtUnpacker = function(type) {
-  return this.extUnpackers[type] || extUnpacker;
-
-  function extUnpacker(buffer) {
-    return new ExtBuffer(buffer, type);
-  }
-};
-
-function join(filters) {
-  filters = filters.slice();
-
-  return function(value) {
-    return filters.reduce(iterator, value);
-  };
-
-  function iterator(value, filter) {
-    return filter(value);
-  }
-}
+exports.createCodec = require("./codec-base").createCodec;

package/lib/flex-buffer.js

@@ -0,0 +1,194 @@
+// flex-buffer.js
+
+exports.FlexDecoder = FlexDecoder;
+exports.FlexEncoder = FlexEncoder;
+
+var Bufferish = require("./bufferish");
+
+var MIN_BUFFER_SIZE = 2048;
+var MAX_BUFFER_SIZE = 65536;
+var BUFFER_SHORTAGE = "BUFFER_SHORTAGE";
+
+function FlexDecoder() {
+  if (!(this instanceof FlexDecoder)) return new FlexDecoder();
+}
+
+function FlexEncoder() {
+  if (!(this instanceof FlexEncoder)) return new FlexEncoder();
+}
+
+FlexDecoder.mixin = mixinFactory(getDecoderMethods());
+FlexDecoder.mixin(FlexDecoder.prototype);
+
+FlexEncoder.mixin = mixinFactory(getEncoderMethods());
+FlexEncoder.mixin(FlexEncoder.prototype);
+
+function getDecoderMethods() {
+  return {
+    bufferish: Bufferish,
+    write: write,
+    fetch: fetch,
+    flush: flush,
+    push: push,
+    pull: pull,
+    read: read,
+    reserve: reserve,
+    offset: 0
+  };
+
+  function write(chunk) {
+    var prev = this.offset ? Bufferish.prototype.slice.call(this.buffer, this.offset) : this.buffer;
+    this.buffer = prev ? (chunk ? this.bufferish.concat([prev, chunk]) : prev) : chunk;
+    this.offset = 0;
+  }
+
+  function flush() {
+    while (this.offset < this.buffer.length) {
+      var start = this.offset;
+      var value;
+      try {
+        value = this.fetch();
+      } catch (e) {
+        if (e && e.message != BUFFER_SHORTAGE) throw e;
+        // rollback
+        this.offset = start;
+        break;
+      }
+      this.push(value);
+    }
+  }
+
+  function reserve(length) {
+    var start = this.offset;
+    var end = start + length;
+    if (end > this.buffer.length) throw new Error(BUFFER_SHORTAGE);
+    this.offset = end;
+    return start;
+  }
+}
+
+function getEncoderMethods() {
+  return {
+    bufferish: Bufferish,
+    write: write,
+    fetch: fetch,
+    flush: flush,
+    push: push,
+    pull: pull,
+    read: read,
+    reserve: reserve,
+    send: send,
+    maxBufferSize: MAX_BUFFER_SIZE,
+    minBufferSize: MIN_BUFFER_SIZE,
+    offset: 0,
+    start: 0
+  };
+
+  function fetch() {
+    var start = this.start;
+    if (start < this.offset) {
+      var end = this.start = this.offset;
+      return Bufferish.prototype.slice.call(this.buffer, start, end);
+    }
+  }
+
+  function flush() {
+    while (this.start < this.offset) {
+      var value = this.fetch();
+      if (value) this.push(value);
+    }
+  }
+
+  function pull() {
+    var buffers = this.buffers || (this.buffers = []);
+    var chunk = buffers.length > 1 ? this.bufferish.concat(buffers) : buffers[0];
+    buffers.length = 0; // buffer exhausted
+    return chunk;
+  }
+
+  function reserve(length) {
+    var req = length | 0;
+
+    if (this.buffer) {
+      var size = this.buffer.length;
+      var start = this.offset | 0;
+      var end = start + req;
+
+      // is it long enough?
+      if (end < size) {
+        this.offset = end;
+        return start;
+      }
+
+      // flush current buffer
+      this.flush();
+
+      // resize it to 2x current length
+      length = Math.max(length, Math.min(size * 2, this.maxBufferSize));
+    }
+
+    // minimum buffer size
+    length = Math.max(length, this.minBufferSize);
+
+    // allocate new buffer
+    this.buffer = this.bufferish.alloc(length);
+    this.start = 0;
+    this.offset = req;
+    return 0;
+  }
+
+  function send(buffer) {
+    var length = buffer.length;
+    if (length > this.minBufferSize) {
+      this.flush();
+      this.push(buffer);
+    } else {
+      var offset = this.reserve(length);
+      Bufferish.prototype.copy.call(buffer, this.buffer, offset);
+    }
+  }
+}
+
+// common methods
+
+function write() {
+  throw new Error("method not implemented: write()");
+}
+
+function fetch() {
+  throw new Error("method not implemented: fetch()");
+}
+
+function read() {
+  var length = this.buffers && this.buffers.length;
+
+  // fetch the first result
+  if (!length) return this.fetch();
+
+  // flush current buffer
+  this.flush();
+
+  // read from the results
+  return this.pull();
+}
+
+function push(chunk) {
+  var buffers = this.buffers || (this.buffers = []);
+  buffers.push(chunk);
+}
+
+function pull() {
+  var buffers = this.buffers || (this.buffers = []);
+  return buffers.shift();
+}
+
+function mixinFactory(source) {
+  return mixin;
+
+  function mixin(target) {
+    for (var key in source) {
+      target[key] = source[key];
+    }
+    return target;
+  }
+}

package/lib/read-core.js

@@ -1,9 +1,18 @@
 // read-core.js
 
-exports.getDecoder = getDecoder;
-
+var ExtBuffer = require("./ext-buffer").ExtBuffer;
+var ExtUnpacker = require("./ext-unpacker");
 var readUint8 = require("./read-format").readUint8;
 var ReadToken = require("./read-token");
+var CodecBase = require("./codec-base");
+
+CodecBase.install({
+  addExtUnpacker: addExtUnpacker,
+  getExtUnpacker: getExtUnpacker,
+  init: init
+});
+
+exports.preset = init.call(CodecBase.preset);
 
 function getDecoder(options) {
   var readToken = ReadToken.getReadToken(options);
@@ -16,3 +25,28 @@ function getDecoder(options) {
     return func(decoder);
   }
 }
+
+function init() {
+  var options = this.options;
+  this.decode = getDecoder(options);
+
+  if (options && options.preset) {
+    ExtUnpacker.setExtUnpackers(this);
+  }
+
+  return this;
+}
+
+function addExtUnpacker(etype, unpacker) {
+  var unpackers = this.extUnpackers || (this.extUnpackers = []);
+  unpackers[etype] = CodecBase.filter(unpacker);
+}
+
+function getExtUnpacker(type) {
+  var unpackers = this.extUnpackers || (this.extUnpackers = []);
+  return unpackers[type] || extUnpacker;
+
+  function extUnpacker(buffer) {
+    return new ExtBuffer(buffer, type);
+  }
+}

package/lib/read-format.js

@@ -8,40 +8,39 @@ var Int64BE = Int64Buffer.Int64BE;
 exports.getReadFormat = getReadFormat;
 exports.readUint8 = uint8;
 
-var BufferLite = require("./buffer-lite");
-var BufferShortageError = require("./buffer-shortage").BufferShortageError;
+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 getReadFormat(options) {
+  var binarraybuffer = Bufferish.hasArrayBuffer && options && options.binarraybuffer;
+  var int64 = options && options.int64;
+  var usemap = HAS_MAP && options && options.usemap;
+
   var readFormat = {
-    map: map,
+    map: (usemap ? map_to_map : map_to_obj),
     array: array,
     str: str,
-    bin: bin,
+    bin: (binarraybuffer ? bin_arraybuffer : bin_buffer),
     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),
+    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)
   };
 
-  if (options && options.int64) {
-    readFormat.uint64 = read(8, readUInt64BE_int64);
-    readFormat.int64 = read(8, readInt64BE_int64);
-  }
-
   return readFormat;
 }
 
-function map(decoder, len) {
+function map_to_obj(decoder, len) {
   var value = {};
   var i;
   var k = new Array(len);
@@ -58,6 +57,23 @@ 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;
@@ -68,54 +84,74 @@ 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 new BufferShortageError();
-  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_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(decoder, len) {
-  var start = decoder.offset;
-  var end = decoder.offset = start + len;
-  if (end > decoder.buffer.length) throw new BufferShortageError();
-  return slice.call(decoder.buffer, start, end);
+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 new BufferShortageError();
-  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 new BufferShortageError();
-  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;
-  if (decoder.offset + 2 > buffer.length) throw new BufferShortageError();
-  return (buffer[decoder.offset++] << 8) | buffer[decoder.offset++];
+  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;
+  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 new BufferShortageError();
+    var start = decoder.reserve(len);
     return method.call(decoder.buffer, start, NO_ASSERT);
   };
 }
@@ -137,18 +173,9 @@ function readInt64BE_int64(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

@@ -124,7 +124,7 @@ function init_token(format) {
 
 function init_useraw(format) {
   var i;
-  var token = getReadToken(format).slice();
+  var token = init_token(format).slice();
 
   // raw 8 -- 0xd9
   // raw 16 -- 0xda

package/lib/write-core.js

@@ -1,8 +1,17 @@
 // write-core.js
 
-exports.getEncoder = getEncoder;
-
+var ExtBuffer = require("./ext-buffer").ExtBuffer;
+var ExtPacker = require("./ext-packer");
 var WriteType = require("./write-type");
+var CodecBase = require("./codec-base");
+
+CodecBase.install({
+  addExtPacker: addExtPacker,
+  getExtPacker: getExtPacker,
+  init: init
+});
+
+exports.preset = init.call(CodecBase.preset);
 
 function getEncoder(options) {
   var writeType = WriteType.getWriteType(options);
@@ -14,3 +23,47 @@ function getEncoder(options) {
     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];
+  }
+}