msgpack-lite 0.1.20 → 0.1.26

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 ? 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/encode-buffer.js

@@ -2,10 +2,11 @@
 
 exports.EncodeBuffer = EncodeBuffer;
 
-var preset = require("./codec").codec.preset;
+var preset = require("./write-core").preset;
 
-var MIN_BUFFER_SIZE = 2048;
-var MAX_BUFFER_SIZE = 65536;
+var FlexEncoder = require("./flex-buffer").FlexEncoder;
+
+FlexEncoder.mixin(EncodeBuffer.prototype);
 
 function EncodeBuffer(options) {
   if (!(this instanceof EncodeBuffer)) return new EncodeBuffer(options);
@@ -13,88 +14,14 @@ function EncodeBuffer(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;
     }
   }
 }
 
-EncodeBuffer.prototype.offset = 0;
-EncodeBuffer.prototype.start = 0;
-
-EncodeBuffer.prototype.push = function(chunk) {
-  var buffers = this.buffers || (this.buffers = []);
-  buffers.push(chunk);
-};
-
 EncodeBuffer.prototype.codec = preset;
 
 EncodeBuffer.prototype.write = function(input) {
   this.codec.encode(this, input);
 };
-
-EncodeBuffer.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();
-};
-
-EncodeBuffer.prototype.pull = function() {
-  var buffers = this.buffers || (this.buffers = []);
-  var chunk = buffers.length > 1 ? Buffer.concat(buffers) : buffers[0];
-  buffers.length = 0; // buffer exhausted
-  return chunk;
-};
-
-EncodeBuffer.prototype.fetch = function() {
-  var start = this.start;
-  if (start < this.offset) {
-    this.start = this.offset;
-    return this.buffer.slice(start, this.offset);
-  }
-};
-
-EncodeBuffer.prototype.flush = function() {
-  var buffer = this.fetch();
-  if (buffer) this.push(buffer);
-};
-
-EncodeBuffer.prototype.reserve = function(length) {
-  if (this.buffer) {
-    var size = this.buffer.length;
-
-    // is it long enough?
-    if (this.offset + length < size) return;
-
-    // flush current buffer
-    this.flush();
-
-    // resize it to 2x current length
-    length = Math.max(length, Math.min(size * 2, MAX_BUFFER_SIZE));
-  }
-
-  // minimum buffer size
-  length = length > MIN_BUFFER_SIZE ? length : MIN_BUFFER_SIZE;
-
-  // allocate new buffer
-  this.buffer = new Buffer(length);
-  this.start = 0;
-  this.offset = 0;
-};
-
-EncodeBuffer.prototype.send = function(buffer) {
-  var end = this.offset + buffer.length;
-  if (this.buffer && end < this.buffer.length) {
-    buffer.copy(this.buffer, this.offset);
-    this.offset = end;
-  } else {
-    this.flush();
-    this.push(buffer);
-  }
-};

package/lib/ext-buffer.js

@@ -2,8 +2,10 @@
 
 exports.ExtBuffer = ExtBuffer;
 
+var Bufferish = require("./bufferish");
+
 function ExtBuffer(buffer, type) {
   if (!(this instanceof ExtBuffer)) return new ExtBuffer(buffer, type);
-  this.buffer = buffer;
+  this.buffer = Bufferish.from(buffer);
   this.type = type;
 }

package/lib/ext-packer.js

@@ -0,0 +1,78 @@
+// ext-packer.js
+
+exports.setExtPackers = setExtPackers;
+
+var Bufferish = require("./bufferish");
+var Buffer = Bufferish.global;
+var packTypedArray = Bufferish.Uint8Array.from;
+var _encode;
+
+var ERROR_COLUMNS = {name: 1, message: 1, stack: 1, columnNumber: 1, fileName: 1, lineNumber: 1};
+
+function setExtPackers(codec) {
+  codec.addExtPacker(0x0E, Error, [packError, encode]);
+  codec.addExtPacker(0x01, EvalError, [packError, encode]);
+  codec.addExtPacker(0x02, RangeError, [packError, encode]);
+  codec.addExtPacker(0x03, ReferenceError, [packError, encode]);
+  codec.addExtPacker(0x04, SyntaxError, [packError, encode]);
+  codec.addExtPacker(0x05, TypeError, [packError, encode]);
+  codec.addExtPacker(0x06, URIError, [packError, encode]);
+
+  codec.addExtPacker(0x0A, RegExp, [packRegExp, encode]);
+  codec.addExtPacker(0x0B, Boolean, [packValueOf, encode]);
+  codec.addExtPacker(0x0C, String, [packValueOf, encode]);
+  codec.addExtPacker(0x0D, Date, [Number, encode]);
+  codec.addExtPacker(0x0F, Number, [packValueOf, encode]);
+
+  if ("undefined" !== typeof Uint8Array) {
+    codec.addExtPacker(0x11, Int8Array, packTypedArray);
+    codec.addExtPacker(0x12, Uint8Array, packTypedArray);
+    codec.addExtPacker(0x13, Int16Array, packTypedArray);
+    codec.addExtPacker(0x14, Uint16Array, packTypedArray);
+    codec.addExtPacker(0x15, Int32Array, packTypedArray);
+    codec.addExtPacker(0x16, Uint32Array, packTypedArray);
+    codec.addExtPacker(0x17, Float32Array, packTypedArray);
+
+    // PhantomJS/1.9.7 doesn't have Float64Array
+    if ("undefined" !== typeof Float64Array) {
+      codec.addExtPacker(0x18, Float64Array, packTypedArray);
+    }
+
+    // IE10 doesn't have Uint8ClampedArray
+    if ("undefined" !== typeof Uint8ClampedArray) {
+      codec.addExtPacker(0x19, Uint8ClampedArray, packTypedArray);
+    }
+
+    codec.addExtPacker(0x1A, ArrayBuffer, packTypedArray);
+    codec.addExtPacker(0x1D, DataView, packTypedArray);
+  }
+
+  if (Bufferish.hasBuffer) {
+    codec.addExtPacker(0x1B, Buffer, Bufferish.from);
+  }
+}
+
+function encode(input) {
+  if (!_encode) _encode = require("./encode").encode; // lazy load
+  return _encode(input);
+}
+
+function packValueOf(value) {
+  return (value).valueOf();
+}
+
+function packRegExp(value) {
+  value = RegExp.prototype.toString.call(value).split("/");
+  value.shift();
+  var out = [value.pop()];
+  out.unshift(value.join("/"));
+  return out;
+}
+
+function packError(value) {
+  var out = {};
+  for (var key in ERROR_COLUMNS) {
+    out[key] = value[key];
+  }
+  return out;
+}