msgpack-lite 0.1.20 → 0.1.27

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];
+  }
+}

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);
-  }
-}