protobufjs 8.6.5 → 8.7.0

package/src/writer.js

@@ -9,118 +9,52 @@ var LongBits  = util.LongBits,
     base64    = util.base64,
     utf8      = util.utf8;
 
-/**
- * Constructs a new writer operation instance.
- * @classdesc Scheduled writer operation.
- * @constructor
- * @param {function(*, Uint8Array, number)} fn Function to call
- * @param {number} len Value byte length
- * @param {*} val Value to write
- * @ignore
- */
-function Op(fn, len, val) {
-
-    /**
-     * Function to call.
-     * @type {function(Uint8Array, number, *)}
-     */
-    this.fn = fn;
-
-    /**
-     * Value byte length.
-     * @type {number}
-     */
-    this.len = len;
-
-    /**
-     * Next operation.
-     * @type {Writer.Op|undefined}
-     */
-    this.next = undefined;
-
-    /**
-     * Value to write.
-     * @type {*}
-     */
-    this.val = val; // type varies
-}
-
-/* istanbul ignore next */
-function noop() {} // eslint-disable-line no-empty-function
-
-/**
- * Constructs a new writer state instance.
- * @classdesc Copied writer state.
- * @memberof Writer
- * @constructor
- * @param {Writer} writer Writer to copy state from
- * @ignore
- */
-function State(writer) {
-
-    /**
-     * Current head.
-     * @type {Writer.Op}
-     */
-    this.head = writer.head;
-
-    /**
-     * Current tail.
-     * @type {Writer.Op}
-     */
-    this.tail = writer.tail;
-
-    /**
-     * Current buffer length.
-     * @type {number}
-     */
-    this.len = writer.len;
-
-    /**
-     * Next state.
-     * @type {State|null}
-     */
-    this.next = writer.states;
-}
-
 /**
  * Constructs a new writer instance.
- * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.
+ * @classdesc Wire format writer using `Uint8Array`.
  * @constructor
  */
 function Writer() {
 
     /**
-     * Current length.
+     * Write cursor into {@link Writer#buf}.
      * @type {number}
      */
-    this.len = 0;
+    this.pos = 0;
 
     /**
-     * Operations head.
-     * @type {Object}
+     * Backing buffer.
+     * @type {Uint8Array}
      */
-    this.head = new Op(noop, 0, 0);
+    this.buf = this.constructor.alloc(64);
 
     /**
-     * Operations tail
-     * @type {Object}
+     * Cached DataView over {@link Writer#buf}.
+     * @type {DataView|null}
      */
-    this.tail = this.head;
+    this.view = null;
 
     /**
-     * Linked forked states.
-     * @type {Object|null}
+     * Stack of forked length-prefix positions.
+     * @type {Array<number>|null}
      */
     this.states = null;
-
-    // When a value is written, the writer calculates its byte length and puts it into a linked
-    // list of operations to perform when finish() is called. This both allows us to allocate
-    // buffers of the exact required size and reduces the amount of work we have to do compared
-    // to first calculating over objects and then encoding over objects. In our case, the encoding
-    // part is just a linked list walk calling operations with already prepared values.
 }
 
+/**
+ * Current write position.
+ * @name Writer#len
+ * @type {number}
+ * @deprecated Use {@link Writer#pos} instead.
+ */
+Object.defineProperty(Writer.prototype, "len", {
+    configurable: true,
+    enumerable: true,
+    get: function get_len() {
+        return this.pos;
+    }
+});
+
 var create = function create() {
     return util.Buffer
         ? function create_buffer_setup() {
@@ -147,32 +81,45 @@ Writer.create = create();
  * @returns {Uint8Array} Buffer
  */
 Writer.alloc = function alloc(size) {
-    return new util.Array(size);
+    return new Uint8Array(size);
 };
 
 // Use Uint8Array buffer pool in the browser, just like node does with buffers
-/* istanbul ignore else */
-if (util.Array !== Array)
-    Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);
+Writer.alloc = util.pool(Writer.alloc, Uint8Array.prototype.subarray);
 
 /**
- * Pushes a new operation to the queue.
- * @param {function(Uint8Array, number, *)} fn Function to call
- * @param {number} len Value byte length
- * @param {number} val Value to write
- * @returns {Writer} `this`
+ * Calculates the number of bytes a value occupies as a varint.
+ * @param {number} value Value to size (unsigned)
+ * @returns {number} Byte length (1..5)
+ * @ignore
+ */
+function sizeVarint32(value) {
+    return value         < 128       ? 1
+         : value         < 16384     ? 2
+         : value         < 2097152   ? 3
+         : value         < 268435456 ? 4
+         :                             5;
+}
+
+/**
+ * Ensures that at least `n` more bytes fit into the backing buffer, doubling it if not.
+ * @param {number} n Number of additional bytes required
+ * @returns {undefined}
  * @private
  */
-Writer.prototype._push = function push(fn, len, val) {
-    this.tail = this.tail.next = new Op(fn, len, val);
-    this.len += len;
-    return this;
+Writer.prototype._reserve = function _reserve(n) {
+    var need = this.pos + n;
+    if (need > this.buf.length) {
+        var size = this.buf.length << 1;
+        if (size < need)
+            size = need;
+        var buf = this.constructor.alloc(size);
+        buf.set(this.buf.subarray(0, this.pos), 0);
+        this.buf = buf;
+        this.view = null; // invalidate
+    }
 };
 
-function writeByte(val, buf, pos) {
-    buf[pos] = val & 255;
-}
-
 function writeStringAscii(val, buf, pos) {
     for (var i = 0; i < val.length;)
         buf[pos++] = val.charCodeAt(i++);
@@ -184,42 +131,19 @@ function writeVarint32(val, buf, pos) {
         val >>>= 7;
     }
     buf[pos] = val;
+    return pos + 1;
 }
 
-/**
- * Constructs a new varint writer operation instance.
- * @classdesc Scheduled varint writer operation.
- * @extends Op
- * @constructor
- * @param {number} len Value byte length
- * @param {number} val Value to write
- * @ignore
- */
-function VarintOp(len, val) {
-    this.len = len;
-    this.next = undefined;
-    this.val = val;
-}
-
-VarintOp.prototype = Object.create(Op.prototype);
-VarintOp.prototype.fn = writeVarint32;
-
 /**
  * Writes an unsigned 32 bit value as a varint.
  * @param {number} value Value to write
  * @returns {Writer} `this`
  */
 Writer.prototype.uint32 = function write_uint32(value) {
-    // here, the call to this.push has been inlined and a varint specific Op subclass is used.
-    // uint32 is by far the most frequently used operation and benefits significantly from this.
-    this.len += (this.tail = this.tail.next = new VarintOp(
-        (value = value >>> 0)
-                < 128       ? 1
-        : value < 16384     ? 2
-        : value < 2097152   ? 3
-        : value < 268435456 ? 4
-        :                     5,
-    value)).len;
+    value = value >>> 0;
+    this._reserve(5);
+    var pos = this.pos;
+    this.pos = writeVarint32(value, this.buf, pos);
     return this;
 };
 
@@ -230,9 +154,13 @@ Writer.prototype.uint32 = function write_uint32(value) {
  * @returns {Writer} `this`
  */
 Writer.prototype.int32 = function write_int32(value) {
-    return (value |= 0) < 0
-        ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec
-        : this.uint32(value);
+    if ((value |= 0) < 0) { // 10 bytes per spec
+        this._reserve(10);
+        writeVarint64(LongBits.fromNumber(value), this.buf, this.pos);
+        this.pos += 10;
+        return this;
+    }
+    return this.uint32(value);
 };
 
 /**
@@ -256,7 +184,8 @@ function writeVarint64(val, buf, pos) {
         buf[pos++] = lo & 127 | 128;
         lo = lo >>> 7;
     }
-    buf[pos++] = lo;
+    buf[pos] = lo;
+    return pos + 1;
 }
 
 /**
@@ -267,7 +196,10 @@ function writeVarint64(val, buf, pos) {
  */
 Writer.prototype.uint64 = function write_uint64(value) {
     var bits = LongBits.from(value);
-    return this._push(writeVarint64, bits.length(), bits);
+    this._reserve(10);
+    var pos = this.pos;
+    this.pos = writeVarint64(bits, this.buf, pos);
+    return this;
 };
 
 /**
@@ -287,7 +219,10 @@ Writer.prototype.int64 = Writer.prototype.uint64;
  */
 Writer.prototype.sint64 = function write_sint64(value) {
     var bits = LongBits.from(value).zzEncode();
-    return this._push(writeVarint64, bits.length(), bits);
+    this._reserve(10);
+    var pos = this.pos;
+    this.pos = writeVarint64(bits, this.buf, pos);
+    return this;
 };
 
 /**
@@ -296,7 +231,9 @@ Writer.prototype.sint64 = function write_sint64(value) {
  * @returns {Writer} `this`
  */
 Writer.prototype.bool = function write_bool(value) {
-    return this._push(writeByte, 1, value ? 1 : 0);
+    this._reserve(1);
+    this.buf[this.pos++] = value ? 1 : 0;
+    return this;
 };
 
 function writeFixed32(val, buf, pos) {
@@ -312,7 +249,10 @@ function writeFixed32(val, buf, pos) {
  * @returns {Writer} `this`
  */
 Writer.prototype.fixed32 = function write_fixed32(value) {
-    return this._push(writeFixed32, 4, value >>> 0);
+    this._reserve(4);
+    writeFixed32(value >>> 0, this.buf, this.pos);
+    this.pos += 4;
+    return this;
 };
 
 /**
@@ -331,7 +271,11 @@ Writer.prototype.sfixed32 = Writer.prototype.fixed32;
  */
 Writer.prototype.fixed64 = function write_fixed64(value) {
     var bits = LongBits.from(value);
-    return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+    this._reserve(8);
+    writeFixed32(bits.lo, this.buf, this.pos);
+    writeFixed32(bits.hi, this.buf, this.pos + 4);
+    this.pos += 8;
+    return this;
 };
 
 /**
@@ -350,7 +294,10 @@ Writer.prototype.sfixed64 = Writer.prototype.fixed64;
  * @returns {Writer} `this`
  */
 Writer.prototype.float = function write_float(value) {
-    return this._push(util.float.writeFloatLE, 4, value);
+    this._reserve(4);
+    util.float.writeFloatLE(value, this.buf, this.pos);
+    this.pos += 4;
+    return this;
 };
 
 /**
@@ -360,19 +307,12 @@ Writer.prototype.float = function write_float(value) {
  * @returns {Writer} `this`
  */
 Writer.prototype.double = function write_double(value) {
-    return this._push(util.float.writeDoubleLE, 8, value);
+    this._reserve(8);
+    util.float.writeDoubleLE(value, this.buf, this.pos);
+    this.pos += 8;
+    return this;
 };
 
-var writeBytes = util.Array.prototype.set
-    ? function writeBytes_set(val, buf, pos) {
-        buf.set(val, pos); // also works for plain array values
-    }
-    /* istanbul ignore next */
-    : function writeBytes_for(val, buf, pos) {
-        for (var i = 0; i < val.length; ++i)
-            buf[pos + i] = val[i];
-    };
-
 /**
  * Writes a sequence of bytes.
  * @param {Uint8Array|string} value Buffer or base64 encoded string to write
@@ -380,14 +320,21 @@ var writeBytes = util.Array.prototype.set
  */
 Writer.prototype.bytes = function write_bytes(value) {
     var len = value.length >>> 0;
-    if (!len)
-        return this._push(writeByte, 1, 0);
+    if (!len) {
+        this._reserve(1);
+        this.buf[this.pos++] = 0;
+        return this;
+    }
     if (util.isString(value)) {
         var buf = Writer.alloc(len = base64.length(value));
         base64.decode(value, buf, 0);
         value = buf;
     }
-    return this.uint32(len)._push(writeBytes, len, value);
+    this.uint32(len);
+    this._reserve(len);
+    this.buf.set(value, this.pos);
+    this.pos += len;
+    return this;
 };
 
 /**
@@ -397,7 +344,28 @@ Writer.prototype.bytes = function write_bytes(value) {
  */
 Writer.prototype.raw = function write_raw(value) {
     var len = value.length >>> 0;
-    return len ? this._push(writeBytes, len, value) : this;
+    if (!len)
+        return this;
+    this._reserve(len);
+    this.buf.set(value, this.pos);
+    this.pos += len;
+    return this;
+};
+
+/**
+ * Backfills the length varint.
+ * @param {number} pos Position of reserved length byte
+ * @param {number} len Length of content after length varint
+ * @returns {Writer} `this`
+ * @private
+ */
+Writer.prototype._delim = function _delim(pos, len) {
+    var n = sizeVarint32(len);
+    if (n > 1)
+        this.buf.copyWithin(pos + n, pos + 1, pos + 1 + len);
+    writeVarint32(len, this.buf, pos);
+    this.pos = pos + n + len;
+    return this;
 };
 
 /**
@@ -406,21 +374,245 @@ Writer.prototype.raw = function write_raw(value) {
  * @returns {Writer} `this`
  */
 Writer.prototype.string = function write_string(value) {
+    var n = value.length;
+    if (!n) {
+        this._reserve(1);
+        this.buf[this.pos++] = 0;
+        return this;
+    }
+    if (n < 0x80) {
+        this._reserve(n * 3 + 5); // worst case
+        var lenPos = this.pos;
+        return this._delim(lenPos, utf8.write(value, this.buf, lenPos + 1));
+    }
     var len = utf8.length(value);
-    return len
-        ? this.uint32(len)._push(len === value.length ? writeStringAscii : utf8.write, len, value)
-        : this._push(writeByte, 1, 0);
+    this.uint32(len);
+    this._reserve(len);
+    if (len === value.length)
+        writeStringAscii(value, this.buf, this.pos);
+    else
+        utf8.write(value, this.buf, this.pos);
+    this.pos += len;
+    return this;
+};
+
+/**
+ * Writes an array of unsigned 32 bit values as a packed repeated field.
+ * @param {number[]} value Values to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.uint32s = function write_uint32s(value) {
+    var n = value.length;
+    this._reserve(n * 5 + 5); // worst case: 5 bytes per value + length varint
+    var buf = this.buf, lenPos = this.pos, p = lenPos + 1;
+    for (var i = 0; i < n; ++i)
+        p = writeVarint32(value[i] >>> 0, buf, p);
+    return this._delim(lenPos, p - lenPos - 1);
+};
+
+/**
+ * Writes an array of signed 32 bit values as a packed repeated field.
+ * @param {number[]} value Values to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.int32s = function write_int32s(value) {
+    var n = value.length;
+    this._reserve(n * 10 + 5); // worst case: 10 bytes per negative value + length varint
+    var buf = this.buf, lenPos = this.pos, pos = lenPos + 1, val;
+    for (var i = 0; i < n; ++i) {
+        if ((val = value[i] | 0) < 0) { // negatives are 10 bytes per spec
+            pos = writeVarint64(LongBits.fromNumber(val), buf, pos);
+        } else {
+            pos = writeVarint32(val, buf, pos);
+        }
+    }
+    return this._delim(lenPos, pos - lenPos - 1);
+};
+
+/**
+ * Writes an array of 32 bit values as packed, zig-zag encoded varints.
+ * @param {number[]} value Values to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.sint32s = function write_sint32s(value) {
+    var n = value.length;
+    this._reserve(n * 5 + 5);
+    var buf = this.buf, lenPos = this.pos, pos = lenPos + 1;
+    for (var i = 0; i < n; ++i)
+        pos = writeVarint32((value[i] << 1 ^ value[i] >> 31) >>> 0, buf, pos);
+    return this._delim(lenPos, pos - lenPos - 1);
+};
+
+/**
+ * Writes an array of unsigned 64 bit values as a packed repeated field.
+ * @param {Array.<Long|number|string>} value Values to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.uint64s = function write_uint64s(value) {
+    var n = value.length;
+    this._reserve(n * 10 + 5);
+    var buf = this.buf, lenPos = this.pos, pos = lenPos + 1;
+    for (var i = 0; i < n; ++i) {
+        pos = writeVarint64(LongBits.from(value[i]), buf, pos);
+    }
+    return this._delim(lenPos, pos - lenPos - 1);
+};
+
+/**
+ * Writes an array of signed 64 bit values as a packed repeated field.
+ * @function
+ * @param {Array.<Long|number|string>} value Values to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.int64s = Writer.prototype.uint64s;
+
+/**
+ * Writes an array of 64 bit values as packed, zig-zag encoded varints.
+ * @param {Array.<Long|number|string>} value Values to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.sint64s = function write_sint64s(value) {
+    var n = value.length;
+    this._reserve(n * 10 + 5);
+    var buf = this.buf, lenPos = this.pos, pos = lenPos + 1;
+    for (var i = 0; i < n; ++i) {
+        pos = writeVarint64(LongBits.from(value[i]).zzEncode(), buf, pos);
+    }
+    return this._delim(lenPos, pos - lenPos - 1);
+};
+
+/**
+ * Writes an array of boolish values as a packed repeated field.
+ * @param {boolean[]} value Values to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.bools = function write_bools(value) {
+    var n = value.length;
+    this.uint32(n); // one byte per value
+    this._reserve(n);
+    var buf = this.buf, p = this.pos;
+    for (var i = 0; i < n; ++i)
+        buf[p++] = value[i] ? 1 : 0;
+    this.pos += n;
+    return this;
+};
+
+// The view allocation only pays off when amortized over enough writes
+var VIEW_THRESHOLD_FLOAT = 16,
+    VIEW_THRESHOLD_INT   = 128;
+
+function getLazyView(writer, count, threshold) {
+    var view = writer.view;
+    if (view || count < threshold)
+        return view;
+    var buf = writer.buf;
+    return writer.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+
+/**
+ * Writes an array of unsigned 32 bit values as packed, fixed 32 bits.
+ * @param {number[]} value Values to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.fixed32s = function write_fixed32s(value) {
+    var n = value.length, bytes = n * 4;
+    this.uint32(bytes); // length is known exactly
+    this._reserve(bytes);
+    var p = this.pos, i, dv = getLazyView(this, n, VIEW_THRESHOLD_INT);
+    if (dv)
+        for (i = 0; i < n; ++i) { dv.setUint32(p, value[i] >>> 0, true); p += 4; }
+    else {
+        var buf = this.buf;
+        for (i = 0; i < n; ++i) { writeFixed32(value[i] >>> 0, buf, p); p += 4; }
+    }
+    this.pos += bytes;
+    return this;
+};
+
+/**
+ * Writes an array of signed 32 bit values as packed, fixed 32 bits.
+ * @function
+ * @param {number[]} value Values to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.sfixed32s = Writer.prototype.fixed32s;
+
+/**
+ * Writes an array of unsigned 64 bit values as packed, fixed 64 bits.
+ * @param {Array.<Long|number|string>} value Values to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.fixed64s = function write_fixed64s(value) {
+    var n = value.length, bytes = n * 8;
+    this.uint32(bytes);
+    this._reserve(bytes);
+    var p = this.pos, i, bits, dv = getLazyView(this, n, VIEW_THRESHOLD_INT);
+    if (dv)
+        for (i = 0; i < n; ++i) { bits = LongBits.from(value[i]); dv.setUint32(p, bits.lo, true); dv.setUint32(p + 4, bits.hi, true); p += 8; }
+    else {
+        var buf = this.buf;
+        for (i = 0; i < n; ++i) { bits = LongBits.from(value[i]); writeFixed32(bits.lo, buf, p); writeFixed32(bits.hi, buf, p + 4); p += 8; }
+    }
+    this.pos += bytes;
+    return this;
+};
+
+/**
+ * Writes an array of signed 64 bit values as packed, fixed 64 bits.
+ * @function
+ * @param {Array.<Long|number|string>} value Values to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.sfixed64s = Writer.prototype.fixed64s;
+
+/**
+ * Writes an array of floats (32 bit) as a packed repeated field.
+ * @param {number[]} value Values to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.floats = function write_floats(value) {
+    var n = value.length, bytes = n * 4;
+    this.uint32(bytes);
+    this._reserve(bytes);
+    var p = this.pos, i, dv = getLazyView(this, n, VIEW_THRESHOLD_FLOAT);
+    if (dv)
+        for (i = 0; i < n; ++i) { dv.setFloat32(p, value[i], true); p += 4; }
+    else {
+        var buf = this.buf;
+        for (i = 0; i < n; ++i) { util.float.writeFloatLE(value[i], buf, p); p += 4; }
+    }
+    this.pos += bytes;
+    return this;
+};
+
+/**
+ * Writes an array of doubles (64 bit float) as a packed repeated field.
+ * @param {number[]} value Values to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.doubles = function write_doubles(value) {
+    var n = value.length, bytes = n * 8;
+    this.uint32(bytes);
+    this._reserve(bytes);
+    var p = this.pos, i, dv = getLazyView(this, n, VIEW_THRESHOLD_FLOAT);
+    if (dv)
+        for (i = 0; i < n; ++i) { dv.setFloat64(p, value[i], true); p += 8; }
+    else {
+        var buf = this.buf;
+        for (i = 0; i < n; ++i) { util.float.writeDoubleLE(value[i], buf, p); p += 8; }
+    }
+    this.pos += bytes;
+    return this;
 };
 
 /**
  * Forks this writer's state by pushing it to a stack.
- * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
  * @returns {Writer} `this`
  */
 Writer.prototype.fork = function fork() {
-    this.states = new State(this);
-    this.head = this.tail = new Op(noop, 0, 0);
-    this.len = 0;
+    this._reserve(1);
+    (this.states || (this.states = [])).push(this.pos);
+    this.pos += 1;
     return this;
 };
 
@@ -429,47 +621,66 @@ Writer.prototype.fork = function fork() {
  * @returns {Writer} `this`
  */
 Writer.prototype.reset = function reset() {
-    if (this.states) {
-        this.head   = this.states.head;
-        this.tail   = this.states.tail;
-        this.len    = this.states.len;
-        this.states = this.states.next;
+    var states = this.states;
+    if (states && states.length) {
+        this.pos = states.pop();
     } else {
-        this.head = this.tail = new Op(noop, 0, 0);
-        this.len  = 0;
+        this.pos = 0;
     }
     return this;
 };
 
 /**
- * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
+ * Resets to the last state and prepends the fork state's current write length as a varint.
  * @returns {Writer} `this`
  */
 Writer.prototype.ldelim = function ldelim() {
-    var head = this.head,
-        tail = this.tail,
-        len  = this.len;
-    this.reset().uint32(len);
-    if (len) {
-        this.tail.next = head.next; // skip noop
-        this.tail = tail;
-        this.len += len;
+    var states = this.states,
+        len,
+        vlen;
+    if (states && states.length) {
+        var lenPos = states.pop();
+        len = this.pos - lenPos - 1;
+        vlen = sizeVarint32(len);
+        if (vlen > 1) { // grow the reserved single byte and shift content forward
+            this._reserve(vlen - 1);
+            this.buf.copyWithin(lenPos + vlen, lenPos + 1, lenPos + 1 + len);
+            this.pos += vlen - 1;
+            writeVarint32(len, this.buf, lenPos);
+        } else {
+            this.buf[lenPos] = len;
+        }
+    } else { // not forked: prefix the entire buffer with its length
+        // TODO: Compatibility with older generated code.
+        // Remove this branch in the next major release.
+        len = this.pos;
+        vlen = sizeVarint32(len);
+        this._reserve(vlen);
+        this.buf.copyWithin(vlen, 0, len);
+        writeVarint32(len, this.buf, 0);
+        this.pos += vlen;
     }
     return this;
 };
 
 /**
  * Finishes the write operation.
+ * Returns a buffer sized to the written data by default.
+ * @param {boolean} [shared=false] Whether to return a shared view instead of a unique copy
  * @returns {Uint8Array} Finished buffer
  */
-Writer.prototype.finish = function finish() {
-    return this.finishInto(this.constructor.alloc(this.len), 0);
+Writer.prototype.finish = function finish(shared) {
+    if (shared)
+        return this.buf.subarray(0, this.pos);
+    var buf = this.constructor.alloc(this.pos);
+    buf.set(this.buf.subarray(0, this.pos), 0);
+    return buf;
 };
 
 /**
  * Finishes the write operation, writing into the provided buffer.
  * The caller must ensure that `buf` has enough space starting at `offset`
- * to hold {@link Writer#len} bytes.
+ * to hold {@link Writer#pos} bytes.
  * @param {T} buf Target buffer
  * @param {number} [offset=0] Offset to start writing at
  * @returns {T} The provided buffer
@@ -478,13 +689,7 @@ Writer.prototype.finish = function finish() {
 Writer.prototype.finishInto = function finishInto(buf, offset) {
     if (offset === undefined)
         offset = 0;
-    var head = this.head.next,
-        pos  = offset;
-    while (head) {
-        head.fn(head.val, buf, pos);
-        pos += head.len;
-        head = head.next;
-    }
+    buf.set(this.buf.subarray(0, this.pos), offset);
     return buf;
 };