msgpack-lite 0.1.20 → 0.1.27

package/lib/buffer-lite.js

@@ -1,79 +1,115 @@
-// util.js
-
-var Int64Buffer = require("int64-buffer");
-var Uint64BE = Int64Buffer.Uint64BE;
-var Int64BE = Int64Buffer.Int64BE;
+// buffer-lite.js
 
 var MAXBUFLEN = 8192;
 
-exports.writeString = writeString;
-exports.readString = readString;
-exports.byteLength = byteLength;
 exports.copy = copy;
-exports.writeUint64BE = writeUint64BE;
-exports.writeInt64BE = writeInt64BE;
+exports.toString = toString;
+exports.write = write;
 
-// new Buffer(string, "utf-8") is SLOWER then below
+/**
+ * Buffer.prototype.write()
+ *
+ * @param string {String}
+ * @param [offset] {Number}
+ * @returns {Number}
+ */
 
-function writeString(string, start) {
+function write(string, offset) {
   var buffer = this;
-  var index = start || 0;
+  var index = offset || (offset |= 0);
   var length = string.length;
-  // JavaScript's string uses UTF-16 surrogate pairs for characters other than BMP.
-  // This encodes string as CESU-8 which never reaches 4 octets per character.
-  for (var i = 0; i < length; i++) {
-    var chr = string.charCodeAt(i);
-    if (chr < 0x80) {
+  var chr = 0;
+  var i = 0;
+  while (i < length) {
+    chr = string.charCodeAt(i++);
+
+    if (chr < 128) {
       buffer[index++] = chr;
     } else if (chr < 0x800) {
-      buffer[index++] = 0xC0 | (chr >> 6);
+      // 2 bytes
+      buffer[index++] = 0xC0 | (chr >>> 6);
       buffer[index++] = 0x80 | (chr & 0x3F);
+    } else if (chr < 0xD800 || chr > 0xDFFF) {
+      // 3 bytes
+      buffer[index++] = 0xE0 | (chr  >>> 12);
+      buffer[index++] = 0x80 | ((chr >>> 6)  & 0x3F);
+      buffer[index++] = 0x80 | (chr          & 0x3F);
     } else {
-      buffer[index++] = 0xE0 | (chr >> 12);
-      buffer[index++] = 0x80 | ((chr >> 6) & 0x3F);
-      buffer[index++] = 0x80 | (chr & 0x3F);
+      // 4 bytes - surrogate pair
+      chr = (((chr - 0xD800) << 10) | (string.charCodeAt(i++) - 0xDC00)) + 0x10000;
+      buffer[index++] = 0xF0 | (chr >>> 18);
+      buffer[index++] = 0x80 | ((chr >>> 12) & 0x3F);
+      buffer[index++] = 0x80 | ((chr >>> 6)  & 0x3F);
+      buffer[index++] = 0x80 | (chr          & 0x3F);
     }
   }
-  return index - start;
+  return index - offset;
 }
 
-// Buffer.ptototype.toString is 2x FASTER then below
-// https://github.com/feross/buffer may throw "Maximum call stack size exceeded." at String.fromCharCode.apply.
+/**
+ * Buffer.prototype.toString()
+ *
+ * @param [encoding] {String} ignored
+ * @param [start] {Number}
+ * @param [end] {Number}
+ * @returns {String}
+ */
 
-function readString(start, end) {
+function toString(encoding, start, end) {
   var buffer = this;
-  var index = start - 0 || 0;
+  var index = start|0;
   if (!end) end = buffer.length;
-  var size = end - start;
-  if (size > MAXBUFLEN) size = MAXBUFLEN;
-  var out = [];
-  for (; index < end;) {
-    var array = new Array(size);
-    for (var pos = 0; pos < size && index < end;) {
-      var chr = buffer[index++];
-      chr = (chr < 0x80) ? chr :
-        (chr < 0xE0) ? (((chr & 0x3F) << 6) | (buffer[index++] & 0x3F)) :
-          (((chr & 0x3F) << 12) | ((buffer[index++] & 0x3F) << 6) | ((buffer[index++] & 0x3F)));
-      array[pos++] = chr;
+  var string = '';
+  var chr = 0;
+
+  while (index < end) {
+    chr = buffer[index++];
+    if (chr < 128) {
+      string += String.fromCharCode(chr);
+      continue;
     }
-    if (pos < size) array = array.slice(0, pos);
-    out.push(String.fromCharCode.apply("", array));
-  }
-  return (out.length > 1) ? out.join("") : out.length ? out.shift() : "";
-}
 
-// Buffer.byteLength is FASTER than below
+    if ((chr & 0xE0) === 0xC0) {
+      // 2 bytes
+      chr = (chr & 0x1F) << 6 |
+            (buffer[index++] & 0x3F);
+
+    } else if ((chr & 0xF0) === 0xE0) {
+      // 3 bytes
+      chr = (chr & 0x0F)             << 12 |
+            (buffer[index++] & 0x3F) << 6  |
+            (buffer[index++] & 0x3F);
+
+    } else if ((chr & 0xF8) === 0xF0) {
+      // 4 bytes
+      chr = (chr & 0x07)             << 18 |
+            (buffer[index++] & 0x3F) << 12 |
+            (buffer[index++] & 0x3F) << 6  |
+            (buffer[index++] & 0x3F);
+    }
+
+    if (chr >= 0x010000) {
+      // A surrogate pair
+      chr -= 0x010000;
+
+      string += String.fromCharCode((chr >>> 10) + 0xD800, (chr & 0x3FF) + 0xDC00);
+    } else {
+      string += String.fromCharCode(chr);
+    }
+  }
 
-function byteLength(string) {
-  var length = 0 | 0;
-  Array.prototype.forEach.call(string, function(chr) {
-    var code = chr.charCodeAt(0);
-    length += (code < 0x80) ? 1 : (code < 0x800) ? 2 : 3;
-  });
-  return length;
+  return string;
 }
 
-// https://github.com/feross/buffer lacks descending copying feature
+/**
+ * Buffer.prototype.copy()
+ *
+ * @param target {Buffer}
+ * @param [targetStart] {Number}
+ * @param [start] {Number}
+ * @param [end] {Number}
+ * @returns {number}
+ */
 
 function copy(target, targetStart, start, end) {
   var i;
@@ -96,11 +132,3 @@ function copy(target, targetStart, start, end) {
 
   return len;
 }
-
-function writeUint64BE(value, offset) {
-  new Uint64BE(this, offset, value);
-}
-
-function writeInt64BE(value, offset) {
-  new Int64BE(this, offset, value);
-}

package/lib/bufferish-array.js

@@ -0,0 +1,41 @@
+// bufferish-array.js
+
+var Bufferish = require("./bufferish");
+
+var exports = module.exports = alloc(0);
+
+exports.alloc = alloc;
+exports.concat = Bufferish.concat;
+exports.from = from;
+
+/**
+ * @param size {Number}
+ * @returns {Buffer|Uint8Array|Array}
+ */
+
+function alloc(size) {
+  return new Array(size);
+}
+
+/**
+ * @param value {Array|ArrayBuffer|Buffer|String}
+ * @returns {Array}
+ */
+
+function from(value) {
+  if (!Bufferish.isBuffer(value) && Bufferish.isView(value)) {
+    // TypedArray to Uint8Array
+    value = Bufferish.Uint8Array.from(value);
+  } else if (Bufferish.isArrayBuffer(value)) {
+    // ArrayBuffer to Uint8Array
+    value = new Uint8Array(value);
+  } else if (typeof value === "string") {
+    // String to Array
+    return Bufferish.from.call(exports, value);
+  } else if (typeof value === "number") {
+    throw new TypeError('"value" argument must not be a number');
+  }
+
+  // Array-like to Array
+  return Array.prototype.slice.call(value);
+}

package/lib/bufferish-buffer.js

@@ -0,0 +1,46 @@
+// bufferish-buffer.js
+
+var Bufferish = require("./bufferish");
+var Buffer = Bufferish.global;
+
+var exports = module.exports = Bufferish.hasBuffer ? (Buffer.alloc ? Buffer.alloc(0) : alloc(0)) : [];
+
+exports.alloc = Bufferish.hasBuffer && Buffer.alloc || alloc;
+exports.concat = Bufferish.concat;
+exports.from = from;
+
+/**
+ * @param size {Number}
+ * @returns {Buffer|Uint8Array|Array}
+ */
+
+function alloc(size) {
+  return new Buffer(size);
+}
+
+/**
+ * @param value {Array|ArrayBuffer|Buffer|String}
+ * @returns {Buffer}
+ */
+
+function from(value) {
+  if (!Bufferish.isBuffer(value) && Bufferish.isView(value)) {
+    // TypedArray to Uint8Array
+    value = Bufferish.Uint8Array.from(value);
+  } else if (Bufferish.isArrayBuffer(value)) {
+    // ArrayBuffer to Uint8Array
+    value = new Uint8Array(value);
+  } else if (typeof value === "string") {
+    // String to Buffer
+    return Bufferish.from.call(exports, value);
+  } else if (typeof value === "number") {
+    throw new TypeError('"value" argument must not be a number');
+  }
+
+  // Array-like to Buffer
+  if (Buffer.from && Buffer.from.length !== 1) {
+    return Buffer.from(value); // node v6+
+  } else {
+    return new Buffer(value); // node v4
+  }
+}

package/lib/bufferish-proto.js

@@ -0,0 +1,86 @@
+// bufferish-proto.js
+
+/* jshint eqnull:true */
+
+var BufferLite = require("./buffer-lite");
+
+exports.copy = copy;
+exports.slice = slice;
+exports.toString = toString;
+exports.write = gen("write");
+
+var Bufferish = require("./bufferish");
+var Buffer = Bufferish.global;
+
+var isBufferShim = Bufferish.hasBuffer && ("TYPED_ARRAY_SUPPORT" in Buffer);
+var brokenTypedArray = isBufferShim && !Buffer.TYPED_ARRAY_SUPPORT;
+
+/**
+ * @param target {Buffer|Uint8Array|Array}
+ * @param [targetStart] {Number}
+ * @param [start] {Number}
+ * @param [end] {Number}
+ * @returns {Buffer|Uint8Array|Array}
+ */
+
+function copy(target, targetStart, start, end) {
+  var thisIsBuffer = Bufferish.isBuffer(this);
+  var targetIsBuffer = Bufferish.isBuffer(target);
+  if (thisIsBuffer && targetIsBuffer) {
+    // Buffer to Buffer
+    return this.copy(target, targetStart, start, end);
+  } else if (!brokenTypedArray && !thisIsBuffer && !targetIsBuffer &&
+    Bufferish.isView(this) && Bufferish.isView(target)) {
+    // Uint8Array to Uint8Array (except for minor some browsers)
+    var buffer = (start || end != null) ? slice.call(this, start, end) : this;
+    target.set(buffer, targetStart);
+    return buffer.length;
+  } else {
+    // other cases
+    return BufferLite.copy.call(this, target, targetStart, start, end);
+  }
+}
+
+/**
+ * @param [start] {Number}
+ * @param [end] {Number}
+ * @returns {Buffer|Uint8Array|Array}
+ */
+
+function slice(start, end) {
+  // for Buffer, Uint8Array (except for minor some browsers) and Array
+  var f = this.slice || (!brokenTypedArray && this.subarray);
+  if (f) return f.call(this, start, end);
+
+  // Uint8Array (for minor some browsers)
+  var target = Bufferish.alloc.call(this, end - start);
+  copy.call(this, target, 0, start, end);
+  return target;
+}
+
+/**
+ * Buffer.prototype.toString()
+ *
+ * @param [encoding] {String} ignored
+ * @param [start] {Number}
+ * @param [end] {Number}
+ * @returns {String}
+ */
+
+function toString(encoding, start, end) {
+  var f = (!isBufferShim && Bufferish.isBuffer(this)) ? this.toString : BufferLite.toString;
+  return f.apply(this, arguments);
+}
+
+/**
+ * @private
+ */
+
+function gen(method) {
+  return wrap;
+
+  function wrap() {
+    var f = this[method] || BufferLite[method];
+    return f.apply(this, arguments);
+  }
+}

package/lib/bufferish-uint8array.js

@@ -0,0 +1,51 @@
+// bufferish-uint8array.js
+
+var Bufferish = require("./bufferish");
+
+var exports = module.exports = Bufferish.hasArrayBuffer ? alloc(0) : [];
+
+exports.alloc = alloc;
+exports.concat = Bufferish.concat;
+exports.from = from;
+
+/**
+ * @param size {Number}
+ * @returns {Buffer|Uint8Array|Array}
+ */
+
+function alloc(size) {
+  return new Uint8Array(size);
+}
+
+/**
+ * @param value {Array|ArrayBuffer|Buffer|String}
+ * @returns {Uint8Array}
+ */
+
+function from(value) {
+  if (Bufferish.isView(value)) {
+    // TypedArray to ArrayBuffer
+    var byteOffset = value.byteOffset;
+    var byteLength = value.byteLength;
+    value = value.buffer;
+    if (value.byteLength !== byteLength) {
+      if (value.slice) {
+        value = value.slice(byteOffset, byteOffset + byteLength);
+      } else {
+        // Android 4.1 does not have ArrayBuffer.prototype.slice
+        value = new Uint8Array(value);
+        if (value.byteLength !== byteLength) {
+          // TypedArray to ArrayBuffer to Uint8Array to Array
+          value = Array.prototype.slice.call(value, byteOffset, byteOffset + byteLength);
+        }
+      }
+    }
+  } else if (typeof value === "string") {
+    // String to Uint8Array
+    return Bufferish.from.call(exports, value);
+  } else if (typeof value === "number") {
+    throw new TypeError('"value" argument must not be a number');
+  }
+
+  return new Uint8Array(value);
+}

package/lib/bufferish.js

@@ -0,0 +1,108 @@
+// bufferish.js
+
+var Buffer = exports.global = require("./buffer-global");
+var hasBuffer = exports.hasBuffer = Buffer && !!Buffer.isBuffer;
+var hasArrayBuffer = exports.hasArrayBuffer = ("undefined" !== typeof ArrayBuffer);
+
+var isArray = exports.isArray = require("isarray");
+exports.isArrayBuffer = hasArrayBuffer ? isArrayBuffer : _false;
+var isBuffer = exports.isBuffer = hasBuffer ? Buffer.isBuffer : _false;
+var isView = exports.isView = hasArrayBuffer ? (ArrayBuffer.isView || _is("ArrayBuffer", "buffer")) : _false;
+
+exports.alloc = alloc;
+exports.concat = concat;
+exports.from = from;
+
+var BufferArray = exports.Array = require("./bufferish-array");
+var BufferBuffer = exports.Buffer = require("./bufferish-buffer");
+var BufferUint8Array = exports.Uint8Array = require("./bufferish-uint8array");
+var BufferProto = exports.prototype = require("./bufferish-proto");
+
+/**
+ * @param value {Array|ArrayBuffer|Buffer|String}
+ * @returns {Buffer|Uint8Array|Array}
+ */
+
+function from(value) {
+  if (typeof value === "string") {
+    return fromString.call(this, value);
+  } else {
+    return auto(this).from(value);
+  }
+}
+
+/**
+ * @param size {Number}
+ * @returns {Buffer|Uint8Array|Array}
+ */
+
+function alloc(size) {
+  return auto(this).alloc(size);
+}
+
+/**
+ * @param list {Array} array of (Buffer|Uint8Array|Array)s
+ * @param [length]
+ * @returns {Buffer|Uint8Array|Array}
+ */
+
+function concat(list, length) {
+  if (!length) {
+    length = 0;
+    Array.prototype.forEach.call(list, dryrun);
+  }
+  var ref = (this !== exports) && this || list[0];
+  var result = alloc.call(ref, length);
+  var offset = 0;
+  Array.prototype.forEach.call(list, append);
+  return result;
+
+  function dryrun(buffer) {
+    length += buffer.length;
+  }
+
+  function append(buffer) {
+    offset += BufferProto.copy.call(buffer, result, offset);
+  }
+}
+
+var _isArrayBuffer = _is("ArrayBuffer");
+
+function isArrayBuffer(value) {
+  return (value instanceof ArrayBuffer) || _isArrayBuffer(value);
+}
+
+/**
+ * @private
+ */
+
+function fromString(value) {
+  var expected = value.length * 3;
+  var that = alloc.call(this, expected);
+  var actual = BufferProto.write.call(that, value);
+  if (expected !== actual) {
+    that = BufferProto.slice.call(that, 0, actual);
+  }
+  return that;
+}
+
+function auto(that) {
+  return isBuffer(that) ? BufferBuffer
+    : isView(that) ? BufferUint8Array
+    : isArray(that) ? BufferArray
+    : hasBuffer ? BufferBuffer
+    : hasArrayBuffer ? BufferUint8Array
+    : BufferArray;
+}
+
+function _false() {
+  return false;
+}
+
+function _is(name, key) {
+  /* jshint eqnull:true */
+  name = "[object " + name + "]";
+  return function(value) {
+    return (value != null) && {}.toString.call(key ? value[key] : value) === name;
+  };
+}

package/lib/codec-base.js

@@ -0,0 +1,67 @@
+// codec-base.js
+
+var IS_ARRAY = require("isarray");
+
+exports.createCodec = createCodec;
+exports.install = install;
+exports.filter = filter;
+
+var Bufferish = require("./bufferish");
+
+function Codec(options) {
+  if (!(this instanceof Codec)) return new Codec(options);
+  this.options = options;
+  this.init();
+}
+
+Codec.prototype.init = function() {
+  var options = this.options;
+
+  if (options && options.uint8array) {
+    this.bufferish = Bufferish.Uint8Array;
+  }
+
+  return this;
+};
+
+function install(props) {
+  for (var key in props) {
+    Codec.prototype[key] = add(Codec.prototype[key], props[key]);
+  }
+}
+
+function add(a, b) {
+  return (a && b) ? ab : (a || b);
+
+  function ab() {
+    a.apply(this, arguments);
+    return b.apply(this, arguments);
+  }
+}
+
+function join(filters) {
+  filters = filters.slice();
+
+  return function(value) {
+    return filters.reduce(iterator, value);
+  };
+
+  function iterator(value, filter) {
+    return filter(value);
+  }
+}
+
+function filter(filter) {
+  return IS_ARRAY(filter) ? join(filter) : filter;
+}
+
+// @public
+// msgpack.createCodec()
+
+function createCodec(options) {
+  return new Codec(options);
+}
+
+// default shared codec
+
+exports.preset = createCodec({preset: true});

package/lib/codec.js

@@ -1,5 +1,12 @@
 // codec.js
 
+// load both interfaces
+require("./read-core");
+require("./write-core");
+
+// @public
+// msgpack.codec.preset
+
 exports.codec = {
-  preset: require("./ext").createCodec({preset: true})
+  preset: require("./codec-base").preset
 };

package/lib/decode-buffer.js

@@ -2,9 +2,11 @@
 
 exports.DecodeBuffer = DecodeBuffer;
 
-var preset = require("./codec").codec.preset;
+var preset = require("./read-core").preset;
 
-var BufferShortageError = require("./buffer-shortage").BufferShortageError;
+var FlexDecoder = require("./flex-buffer").FlexDecoder;
+
+FlexDecoder.mixin(DecodeBuffer.prototype);
 
 function DecodeBuffer(options) {
   if (!(this instanceof DecodeBuffer)) return new DecodeBuffer(options);
@@ -12,60 +14,14 @@ function DecodeBuffer(options) {
   if (options) {
     this.options = options;
     if (options.codec) {
-      this.codec = options.codec;
+      var codec = this.codec = options.codec;
+      if (codec.bufferish) this.bufferish = codec.bufferish;
     }
   }
 }
 
-DecodeBuffer.prototype.offset = 0;
-
-DecodeBuffer.prototype.push = function(chunk) {
-  var buffers = this.buffers || (this.buffers = []);
-  buffers.push(chunk);
-};
-
 DecodeBuffer.prototype.codec = preset;
 
-DecodeBuffer.prototype.write = function(chunk) {
-  var prev = this.offset ? this.buffer.slice(this.offset) : this.buffer;
-  this.buffer = prev ? (chunk ? Buffer.concat([prev, chunk]) : prev) : chunk;
-  this.offset = 0;
-};
-
-DecodeBuffer.prototype.read = function() {
-  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();
-};
-
-DecodeBuffer.prototype.pull = function() {
-  var buffers = this.buffers || (this.buffers = []);
-  return buffers.shift();
-};
-
 DecodeBuffer.prototype.fetch = function() {
   return this.codec.decode(this);
 };
-
-DecodeBuffer.prototype.flush = function() {
-  while (this.offset < this.buffer.length) {
-    var start = this.offset;
-    var value;
-    try {
-      value = this.fetch();
-    } catch (e) {
-      if (!(e instanceof BufferShortageError)) throw e;
-      // rollback
-      this.offset = start;
-      break;
-    }
-    this.push(value);
-  }
-};

package/lib/decode-stream.js

@@ -26,7 +26,11 @@ function DecodeStream(options) {
 }
 
 DecodeStream.prototype._transform = function(chunk, encoding, callback) {
-  this.decoder.write(chunk);
-  this.decoder.flush();
-  if (callback) callback();
+  try {
+    this.decoder.write(chunk);
+    this.decoder.flush();
+  } catch(e) {
+    return callback(e);
+  }
+  callback();
 };