protobufjs 8.6.6 → 8.7.1

package/dist/light/protobuf.js

@@ -1,6 +1,6 @@
 /*!
- * protobuf.js v8.6.6 (c) 2016, daniel wirtz
- * compiled sat, 04 jul 2026 01:09:57 utc
+ * protobuf.js v8.7.1 (c) 2016, daniel wirtz
+ * compiled mon, 13 jul 2026 11:04:12 utc
  * licensed under the bsd-3-clause license
  * see: https://github.com/dcodeio/protobuf.js for details
  */
@@ -340,7 +340,7 @@ converter.toObject = function toObject(mtype) {
             else if (field.bytes) {
                 var arrayDefault = Array.prototype.slice.call(field.typeDefault);
                 gen
-        ("if(o.bytes===String)d%s=%j", prop, String.fromCharCode.apply(String, field.typeDefault))
+        ("if(o.bytes===String)d%s=%j", prop, util.base64.encode(field.typeDefault, 0, field.typeDefault.length))
         ("else{")
             ("d%s=%j", prop, arrayDefault)
             ("if(o.bytes!==Array)d%s=util.newBuffer(d%s)", prop, prop)
@@ -498,7 +498,7 @@ function decoder(mtype) {
                                 ("break");
 
             if (types.basic[type] === undefined) gen
-                            ("v=types[%i].decode(r,r.uint32(),undefined,q+1)", i); // can't be groups
+                            ("v=types[%i].decode(r,r.uint32(),undefined,q+1,v)", i); // can't be groups
             else gen
                             ("v=r.%s()", type === "string" ? stringMethod(field) : type);
 
@@ -537,13 +537,9 @@ function decoder(mtype) {
             if (types.packed[type] !== undefined) {
                 gen
                 ("if(u===2){");
-                if (!closed) gen
-                    ("if(!(%s&&%s.length))", ref, ref)
-                        ("%s=[]", ref);
-                gen
-                    ("var c2=r.uint32()+r.pos");
                 if (closed) {
                     gen
+                    ("var c2=r.uint32()+r.pos")
                     ("while(r.pos<c2){")
                         ("s=r.pos")
                         ("v=r.%s()", type)
@@ -555,8 +551,9 @@ function decoder(mtype) {
                             genPreserveUnknown(gen, "util.rawField(" + field.id + ",0,r.raw(s,r.pos))")
                     ("}");
                 } else gen
-                    ("while(r.pos<c2)")
-                        ("%s.push(r.%s())", ref, type);
+                    ("if(!(%s&&%s.length))", ref, ref)
+                        ("%s=[]", ref)
+                    ("r.%ss(%s)", type, ref);
                 gen
                     ("continue")
                 ("}");
@@ -752,10 +749,7 @@ function encoder(mtype) {
             // Packed repeated
             if (field.packed && types.packed[type] !== undefined) { gen
 
-        ("w.uint32(%i).fork()", (field.id << 3 | 2) >>> 0)
-        ("for(var i=0;i<%s.length;++i)", ref)
-            ("w.%s(%s[i])", type, ref)
-        ("w.ldelim()");
+        ("w.uint32(%i).%ss(%s)", (field.id << 3 | 2) >>> 0, type, ref);
 
             // Non-packed
             } else { gen
@@ -1688,7 +1682,7 @@ exports.configure    = configure;
  * @returns {undefined}
  */
 function configure() {
-    exports.util._configure();
+    exports.util.LongBits._configure(exports.util.Long);
     exports.Writer._configure(exports.BufferWriter);
     exports.Reader._configure(exports.BufferReader);
 }
@@ -3389,7 +3383,7 @@ function indexOutOfRange(reader, writeLength) {
 
 /**
  * Constructs a new reader instance using the specified buffer.
- * @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.
+ * @classdesc Wire format reader using `Uint8Array`.
  * @constructor
  * @param {Uint8Array} buffer Buffer to read from
  */
@@ -3413,6 +3407,12 @@ function Reader(buffer) {
      */
     this.len = buffer.length;
 
+    /**
+     * Cached DataView for packed reads.
+     * @type {DataView|null}
+     */
+    this.view = null;
+
     /**
      * Whether to discard unknown fields while decoding.
      * @type {boolean}
@@ -3420,18 +3420,14 @@ function Reader(buffer) {
     this.discardUnknown = Reader.discardUnknown;
 }
 
-var create_array = typeof Uint8Array !== "undefined"
-    ? function create_typed_array(buffer) {
-        if (buffer instanceof Uint8Array || Array.isArray(buffer))
-            return new Reader(buffer);
-        throw Error("illegal buffer");
-    }
-    /* istanbul ignore next */
-    : function create_array(buffer) {
-        if (Array.isArray(buffer))
-            return new Reader(buffer);
-        throw Error("illegal buffer");
-    };
+function create_array(buffer) {
+    // TODO: Remove plain array reader support in the next major release.
+    if (Array.isArray(buffer))
+        buffer = new Uint8Array(buffer);
+    if (buffer instanceof Uint8Array)
+        return new Reader(buffer);
+    throw Error("illegal buffer");
+}
 
 var create = function create() {
     return util.Buffer
@@ -3456,8 +3452,6 @@ var create = function create() {
  */
 Reader.create = create();
 
-Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */ util.Array.prototype.slice;
-
 /**
  * Returns raw bytes from the backing buffer without advancing the reader.
  * @param {number} start Start offset
@@ -3465,12 +3459,7 @@ Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore ne
  * @returns {Uint8Array} Raw bytes
  */
 Reader.prototype.raw = function read_raw(start, end) {
-    if (Array.isArray(this.buf)) // plain array
-        return this.buf.slice(start, end);
-
-    if (start === end) // fix for IE 10/Win8 and others' subarray returning array of size 1
-        return new this.buf.constructor(0);
-    return this._slice.call(this.buf, start, end);
+    return this.buf.subarray(start, end);
 };
 
 /**
@@ -3767,6 +3756,241 @@ Reader.prototype.double = function read_double() {
     return value;
 };
 
+/**
+ * Reads a packed repeated field of unsigned 32 bit varints.
+ * @param {number[]} [array] Array to read into; a new one is created if omitted
+ * @returns {number[]} Array read into
+ */
+Reader.prototype.uint32s = function read_uint32s(array) {
+    if (array === undefined) array = [];
+    var end = this.uint32() + this.pos;
+    while (this.pos < end)
+        array.push(this.uint32());
+    return array;
+};
+
+/**
+ * Reads a packed repeated field of signed 32 bit varints.
+ * @param {number[]} [array] Array to read into; a new one is created if omitted
+ * @returns {number[]} Array read into
+ */
+Reader.prototype.int32s = function read_int32s(array) {
+    if (array === undefined) array = [];
+    var end = this.uint32() + this.pos;
+    while (this.pos < end)
+        array.push(this.int32());
+    return array;
+};
+
+/**
+ * Reads a packed repeated field of zig-zag encoded signed 32 bit varints.
+ * @param {number[]} [array] Array to read into; a new one is created if omitted
+ * @returns {number[]} Array read into
+ */
+Reader.prototype.sint32s = function read_sint32s(array) {
+    if (array === undefined) array = [];
+    var end = this.uint32() + this.pos;
+    while (this.pos < end)
+        array.push(this.sint32());
+    return array;
+};
+
+/**
+ * Reads a packed repeated field of booleans.
+ * @param {boolean[]} [array] Array to read into; a new one is created if omitted
+ * @returns {boolean[]} Array read into
+ */
+Reader.prototype.bools = function read_bools(array) {
+    if (array === undefined) array = [];
+    var end = this.uint32() + this.pos;
+    while (this.pos < end)
+        array.push(this.bool());
+    return array;
+};
+
+// The view allocation only pays off when amortized over enough reads
+var VIEW_THRESHOLD_FLOAT = 8,
+    VIEW_THRESHOLD_INT   = 128;
+
+function getLazyView(reader, count, threshold) {
+    var view = reader.view;
+    if (view || count < threshold)
+        return view;
+    var buf = reader.buf;
+    return reader.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+
+/**
+ * Reads a packed repeated field of unsigned 32 bit fixed values.
+ * @param {number[]} [array] Array to read into; a new one is created if omitted
+ * @returns {number[]} Array read into
+ */
+Reader.prototype.fixed32s = function read_fixed32s(array) {
+    if (array === undefined) array = [];
+    var len = this.uint32(), end = this.pos + len;
+    /* istanbul ignore if */
+    if (end > this.len) throw indexOutOfRange(this, len);
+    var count = len >>> 2, i = array.length, pos = this.pos;
+    array.length = i + count;
+    var dv = getLazyView(this, count, VIEW_THRESHOLD_INT);
+    if (dv)
+        for (var k = 0; k < count; ++k, pos += 4) array[i++] = dv.getUint32(pos, true);
+    else {
+        var buf = this.buf;
+        for (var j = 0; j < count; ++j, pos += 4) array[i++] = readFixed32_end(buf, pos + 4);
+    }
+    this.pos = pos;
+    if (pos !== end) throw indexOutOfRange(this, 4);
+    return array;
+};
+
+/**
+ * Reads a packed repeated field of signed 32 bit fixed values.
+ * @param {number[]} [array] Array to read into; a new one is created if omitted
+ * @returns {number[]} Array read into
+ */
+Reader.prototype.sfixed32s = function read_sfixed32s(array) {
+    if (array === undefined) array = [];
+    var len = this.uint32(), end = this.pos + len;
+    /* istanbul ignore if */
+    if (end > this.len) throw indexOutOfRange(this, len);
+    var count = len >>> 2, i = array.length, pos = this.pos;
+    array.length = i + count;
+    var dv = getLazyView(this, count, VIEW_THRESHOLD_INT);
+    if (dv)
+        for (var k = 0; k < count; ++k, pos += 4) array[i++] = dv.getInt32(pos, true);
+    else {
+        var buf = this.buf;
+        for (var j = 0; j < count; ++j, pos += 4) array[i++] = readFixed32_end(buf, pos + 4) | 0;
+    }
+    this.pos = pos;
+    if (pos !== end) throw indexOutOfRange(this, 4);
+    return array;
+};
+
+/**
+ * Reads a packed repeated field of floats (32 bit).
+ * @param {number[]} [array] Array to read into; a new one is created if omitted
+ * @returns {number[]} Array read into
+ */
+Reader.prototype.floats = function read_floats(array) {
+    if (array === undefined) array = [];
+    var len = this.uint32(), end = this.pos + len;
+    /* istanbul ignore if */
+    if (end > this.len) throw indexOutOfRange(this, len);
+    var count = len >>> 2, i = array.length, pos = this.pos;
+    array.length = i + count;
+    var dv = getLazyView(this, count, VIEW_THRESHOLD_FLOAT);
+    if (dv)
+        for (var k = 0; k < count; ++k, pos += 4) array[i++] = dv.getFloat32(pos, true);
+    else {
+        var buf = this.buf;
+        for (var j = 0; j < count; ++j, pos += 4) array[i++] = util.float.readFloatLE(buf, pos);
+    }
+    this.pos = pos;
+    if (pos !== end) throw indexOutOfRange(this, 4);
+    return array;
+};
+
+/**
+ * Reads a packed repeated field of doubles (64 bit float).
+ * @param {number[]} [array] Array to read into; a new one is created if omitted
+ * @returns {number[]} Array read into
+ */
+Reader.prototype.doubles = function read_doubles(array) {
+    if (array === undefined) array = [];
+    var len = this.uint32(), end = this.pos + len;
+    /* istanbul ignore if */
+    if (end > this.len) throw indexOutOfRange(this, len);
+    var count = len >>> 3, i = array.length, pos = this.pos;
+    array.length = i + count;
+    var dv = getLazyView(this, count, VIEW_THRESHOLD_FLOAT);
+    if (dv)
+        for (var k = 0; k < count; ++k, pos += 8) array[i++] = dv.getFloat64(pos, true);
+    else {
+        var buf = this.buf;
+        for (var j = 0; j < count; ++j, pos += 8) array[i++] = util.float.readDoubleLE(buf, pos);
+    }
+    this.pos = pos;
+    if (pos !== end) throw indexOutOfRange(this, 8);
+    return array;
+};
+
+/**
+ * Reads a packed repeated field of unsigned 64 bit varints.
+ * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted
+ * @returns {Array.<Long|number>} Array read into
+ */
+Reader.prototype.uint64s = function read_uint64s(array) {
+    if (array === undefined) array = [];
+    var end = this.uint32() + this.pos;
+    while (this.pos < end)
+        array.push(this.uint64());
+    return array;
+};
+
+/**
+ * Reads a packed repeated field of signed 64 bit varints.
+ * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted
+ * @returns {Array.<Long|number>} Array read into
+ */
+Reader.prototype.int64s = function read_int64s(array) {
+    if (array === undefined) array = [];
+    var end = this.uint32() + this.pos;
+    while (this.pos < end)
+        array.push(this.int64());
+    return array;
+};
+
+/**
+ * Reads a packed repeated field of zig-zag encoded signed 64 bit varints.
+ * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted
+ * @returns {Array.<Long|number>} Array read into
+ */
+Reader.prototype.sint64s = function read_sint64s(array) {
+    if (array === undefined) array = [];
+    var end = this.uint32() + this.pos;
+    while (this.pos < end)
+        array.push(this.sint64());
+    return array;
+};
+
+/**
+ * Reads a packed repeated field of unsigned 64 bit fixed values.
+ * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted
+ * @returns {Array.<Long|number>} Array read into
+ */
+Reader.prototype.fixed64s = function read_fixed64s(array) {
+    if (array === undefined) array = [];
+    var len = this.uint32(), end = this.pos + len, i = array.length;
+    /* istanbul ignore if */
+    if (end > this.len) throw indexOutOfRange(this, len);
+    var count = len >>> 3;
+    array.length = i + count; // 8 bytes per value, count is known
+    for (var j = 0; j < count; ++j)
+        array[i++] = this.fixed64();
+    if (this.pos !== end) throw indexOutOfRange(this, 8);
+    return array;
+};
+
+/**
+ * Reads a packed repeated field of signed 64 bit fixed values.
+ * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted
+ * @returns {Array.<Long|number>} Array read into
+ */
+Reader.prototype.sfixed64s = function read_sfixed64s(array) {
+    if (array === undefined) array = [];
+    var len = this.uint32(), end = this.pos + len, i = array.length;
+    /* istanbul ignore if */
+    if (end > this.len) throw indexOutOfRange(this, len);
+    var count = len >>> 3;
+    array.length = i + count; // 8 bytes per value, count is known
+    for (var j = 0; j < count; ++j)
+        array[i++] = this.sfixed64();
+    if (this.pos !== end) throw indexOutOfRange(this, 8);
+    return array;
+};
+
 /**
  * Reads a sequence of bytes preceeded by its length as a varint.
  * @returns {Uint8Array} Value read
@@ -3962,7 +4186,7 @@ function BufferReader(buffer) {
      * Read buffer.
      * @name BufferReader#buf
      * @type {Buffer}
-     */
+    */
 }
 
 BufferReader._configure = function () {
@@ -3980,8 +4204,6 @@ BufferReader._configure = function () {
  * @returns {Buffer} Raw bytes
  */
 BufferReader.prototype.raw = function read_raw_buffer(start, end) {
-    if (start === end)
-        return util.Buffer.alloc(0);
     return this._slice.call(this.buf, start, end);
 };
 
@@ -5358,6 +5580,14 @@ Type.prototype.setup = function setup() {
     // Sets up everything at once so that the prototype chain does not have to be re-evaluated
     // multiple times (V8, soft-deopt prototype-check).
 
+    // Resolve feature defaults incl. field presence before generating codecs
+    var root = this.root;
+    if (root && root._needsRecursiveFeatureResolution) {
+        var edition = root._edition || this._edition;
+        if (edition)
+            root._resolveFeaturesRecursive(edition);
+    }
+
     var fullName = this.fullName,
         types    = [];
     for (var i = 0; i < /* initializes */ this.fieldsArray.length; ++i)
@@ -5421,7 +5651,7 @@ Type.prototype.encode = function encode_setup(message, writer) { // eslint-disab
  * @returns {Writer} writer
  */
 Type.prototype.encodeDelimited = function encodeDelimited(message, writer) {
-    return this.encode(message, writer && writer.len ? writer.fork() : writer).ldelim();
+    return this.encode(message, (writer || Writer.create()).fork()).ldelim();
 };
 
 /**
@@ -6873,7 +7103,7 @@ module.exports = fs;
 "use strict";
 module.exports = LongBits;
 
-var util = require(33);
+var Long;
 
 /**
  * Constructs new long bits.
@@ -6952,10 +7182,10 @@ LongBits.fromNumber = function fromNumber(value) {
 LongBits.from = function from(value) {
     if (typeof value === "number")
         return LongBits.fromNumber(value);
-    if (util.isString(value)) {
+    if (typeof value === "string" || value instanceof String) {
         /* istanbul ignore else */
-        if (util.Long)
-            value = util.Long.fromString(value);
+        if (Long)
+            value = Long.fromString(value);
         else
             return LongBits.fromNumber(parseInt(value, 10));
     }
@@ -6984,8 +7214,8 @@ LongBits.prototype.toNumber = function toNumber(unsigned) {
  * @returns {Long} Long
  */
 LongBits.prototype.toLong = function toLong(unsigned) {
-    return util.Long
-        ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned))
+    return Long
+        ? new Long(this.lo | 0, this.hi | 0, Boolean(unsigned))
         /* istanbul ignore next */
         : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
 };
@@ -7071,7 +7301,11 @@ LongBits.prototype.length = function length() {
          : part2 < 128 ? 9 : 10;
 };
 
-},{"33":33}],33:[function(require,module,exports){
+LongBits._configure = function(Long_) {
+    Long = Long_;
+};
+
+},{}],33:[function(require,module,exports){
 "use strict";
 /* global globalThis */
 var util = exports;
@@ -7211,36 +7445,29 @@ util.isSet = function isSet(obj, prop) {
 util.Buffer = (function() {
     try {
         var Buffer = util.global.Buffer;
-        // refuse to use non-node buffers if not explicitly assigned (perf reasons):
-        return Buffer.prototype.utf8Write ? Buffer : /* istanbul ignore next */ null;
+        // refuse to use non-node buffers if not explicitly assigned (perf reasons)
+        return Buffer.prototype.utf8Write || util.isNode ? Buffer : /* istanbul ignore next */ null;
     } catch (e) {
         /* istanbul ignore next */
         return null;
     }
 })();
 
-// Internal alias of or polyfull for Buffer.from.
-util._Buffer_from = null;
-
-// Internal alias of or polyfill for Buffer.allocUnsafe.
-util._Buffer_allocUnsafe = null;
-
 /**
  * Creates a new buffer of whatever type supported by the environment.
  * @param {number|number[]} [sizeOrArray=0] Buffer size or number array
  * @returns {Uint8Array|Buffer} Buffer
  */
 util.newBuffer = function newBuffer(sizeOrArray) {
+    var Buffer = util.Buffer;
     /* istanbul ignore next */
     return typeof sizeOrArray === "number"
-        ? util.Buffer
-            ? util._Buffer_allocUnsafe(sizeOrArray)
-            : new util.Array(sizeOrArray)
-        : util.Buffer
-            ? util._Buffer_from(sizeOrArray)
-            : typeof Uint8Array === "undefined"
-                ? sizeOrArray
-                : new Uint8Array(sizeOrArray);
+        ? Buffer
+            ? Buffer.allocUnsafe(sizeOrArray)
+            : new Uint8Array(sizeOrArray)
+        : Buffer
+            ? Buffer.from(sizeOrArray)
+            : new Uint8Array(sizeOrArray);
 };
 
 /**
@@ -7266,10 +7493,11 @@ util.rawField = function rawField(id, wireType, data) {
 };
 
 /**
- * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.
+ * Array implementation used in the browser.
  * @type {Constructor<Uint8Array>}
+ * @deprecated Use `Uint8Array` instead.
  */
-util.Array = typeof Uint8Array !== "undefined" ? Uint8Array /* istanbul ignore next */ : Array;
+util.Array = Uint8Array;
 
 /**
  * Any compatible Long instance.
@@ -7590,28 +7818,6 @@ util.toJSONOptions = {
     json: true
 };
 
-// Sets up buffer utility according to the environment (called in index-minimal)
-util._configure = function() {
-    var Buffer = util.Buffer;
-    /* istanbul ignore if */
-    if (!Buffer) {
-        util._Buffer_from = util._Buffer_allocUnsafe = null;
-        return;
-    }
-    // because node 4.x buffers are incompatible & immutable
-    // see: https://github.com/dcodeIO/protobuf.js/pull/665
-    util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||
-        /* istanbul ignore next */
-        function Buffer_from(value, encoding) {
-            return new Buffer(value, encoding);
-        };
-    util._Buffer_allocUnsafe = Buffer.allocUnsafe ||
-        /* istanbul ignore next */
-        function Buffer_allocUnsafe(size) {
-            return new Buffer(size);
-        };
-};
-
 },{"25":25,"26":26,"28":28,"30":30,"32":32,"36":36,"37":37,"long":"long"}],34:[function(require,module,exports){
 "use strict";
 
@@ -7777,19 +7983,21 @@ function pool(alloc, slice, size) {
 "use strict";
 
 /**
- * A minimal UTF8 implementation for number arrays.
+ * A minimal UTF8 implementation.
  * @memberof util
  * @namespace
  */
 var utf8 = exports,
     replacementChar = "\ufffd",
+    looseDecoder = new TextDecoder("utf-8", { ignoreBOM: true }),
     strictDecoder;
+var TEXT_DECODER_MIN_LENGTH = 64;
 
 try {
     strictDecoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 } catch (err) {
     // "fatal" option is not supported on Node.js compiled without ICU
-    strictDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
+    strictDecoder = looseDecoder;
 }
 
 /**
@@ -7840,6 +8048,13 @@ function utf8_read_js(buffer, start, end, str) {
     return str;
 }
 
+function utf8_read_decoder(decoder, buffer, start, end) {
+    var source = start === 0 && end === buffer.length
+        ? buffer
+        : buffer.subarray(start, end);
+    return decoder.decode(source);
+}
+
 /**
  * Reads UTF8 bytes as a string.
  * @param {Uint8Array} buffer Source buffer
@@ -7847,9 +8062,11 @@ function utf8_read_js(buffer, start, end, str) {
  * @param {number} end Source end
  * @returns {string} String read
  */
-utf8.read = function utf8_read_ascii(buffer, start, end) {
+utf8.read = function utf8_read_loose(buffer, start, end) {
     if (end - start < 1)
         return "";
+    if (end - start >= TEXT_DECODER_MIN_LENGTH)
+        return utf8_read_decoder(looseDecoder, buffer, start, end);
 
     var str = "",
         i = start,
@@ -7879,17 +8096,6 @@ utf8.read = function utf8_read_ascii(buffer, start, end) {
     return str;
 };
 
-function utf8_read_strict(buffer, start, end) {
-    var source = start === 0 && end === buffer.length
-        ? buffer
-        : buffer.subarray
-            ? buffer.subarray(start, end)
-            : buffer.slice(start, end);
-    if (Array.isArray(source))
-        source = Uint8Array.from(source);
-    return strictDecoder.decode(source);
-}
-
 /**
  * Reads UTF8 bytes as a string, rejecting invalid UTF8.
  * @param {Uint8Array} buffer Source buffer
@@ -7897,9 +8103,11 @@ function utf8_read_strict(buffer, start, end) {
  * @param {number} end Source end
  * @returns {string} String read
  */
-utf8.readStrict = function utf8_read_strict_ascii(buffer, start, end) {
+utf8.readStrict = function utf8_read_strict(buffer, start, end) {
     if (end - start < 1)
         return "";
+    if (end - start >= TEXT_DECODER_MIN_LENGTH)
+        return utf8_read_decoder(strictDecoder, buffer, start, end);
 
     var str = "",
         i = start,
@@ -7915,14 +8123,14 @@ utf8.readStrict = function utf8_read_strict_ascii(buffer, start, end) {
         c7 = buffer[i + 6];
         c8 = buffer[i + 7];
         if ((c1 | c2 | c3 | c4 | c5 | c6 | c7 | c8) & 0x80)
-            return str + utf8_read_strict(buffer, i, end);
+            return str + utf8_read_decoder(strictDecoder, buffer, i, end);
         str += String.fromCharCode(c1, c2, c3, c4, c5, c6, c7, c8);
     }
 
     for (; i < end; ++i) {
         c1 = buffer[i];
         if (c1 & 0x80)
-            return str + utf8_read_strict(buffer, i, end);
+            return str + utf8_read_decoder(strictDecoder, buffer, i, end);
         str += String.fromCharCode(c1);
     }
 
@@ -8270,118 +8478,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() {
@@ -8408,32 +8550,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++);
@@ -8445,42 +8600,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;
 };
 
@@ -8491,9 +8623,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);
 };
 
 /**
@@ -8517,7 +8653,8 @@ function writeVarint64(val, buf, pos) {
         buf[pos++] = lo & 127 | 128;
         lo = lo >>> 7;
     }
-    buf[pos++] = lo;
+    buf[pos] = lo;
+    return pos + 1;
 }
 
 /**
@@ -8528,7 +8665,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;
 };
 
 /**
@@ -8548,7 +8688,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;
 };
 
 /**
@@ -8557,7 +8700,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) {
@@ -8573,7 +8718,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;
 };
 
 /**
@@ -8592,7 +8740,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;
 };
 
 /**
@@ -8611,7 +8763,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;
 };
 
 /**
@@ -8621,19 +8776,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
@@ -8641,14 +8789,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;
 };
 
 /**
@@ -8658,7 +8813,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;
 };
 
 /**
@@ -8667,21 +8843,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;
 };
 
@@ -8690,47 +9090,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
@@ -8739,13 +9158,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;
 };
 
@@ -8782,6 +9195,8 @@ function BufferWriter() {
     Writer.call(this);
 }
 
+var writeStringBuffer;
+
 BufferWriter._configure = function () {
     /**
      * Allocates a buffer of the specified size.
@@ -8789,19 +9204,14 @@ BufferWriter._configure = function () {
      * @param {number} size Buffer size
      * @returns {Buffer} Buffer
      */
-    BufferWriter.alloc = util._Buffer_allocUnsafe;
+    BufferWriter.alloc = util.Buffer && util.Buffer.allocUnsafe;
 
-    BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === "set"
-        ? function writeBytesBuffer_set(val, buf, pos) {
-          buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)
-          // also works for plain array values
+    writeStringBuffer = util.Buffer && util.Buffer.prototype.utf8Write
+        ? function writeStringBuffer_utf8Write(val, buf, pos) {
+            return buf.utf8Write(val, pos);
         }
-        /* istanbul ignore next */
-        : function writeBytesBuffer_copy(val, buf, pos) {
-          if (val.copy) // Buffer values
-            val.copy(buf, pos, 0, val.length);
-          else for (var i = 0; i < val.length;) // plain array values
-            buf[pos++] = val[i++];
+        : function writeStringBuffer_write(val, buf, pos) {
+            return buf.write(val, pos);
         };
 };
 
@@ -8811,48 +9221,42 @@ BufferWriter._configure = function () {
  */
 BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
     if (util.isString(value))
-        value = util._Buffer_from(value, "base64");
+        value = util.Buffer.from(value, "base64");
     var len = value.length >>> 0;
     this.uint32(len);
-    if (len)
-        this._push(BufferWriter.writeBytesBuffer, len, value);
+    if (len) {
+        this._reserve(len);
+        this.buf.set(value, this.pos);
+        this.pos += len;
+    }
     return this;
 };
 
-/**
- * Writes raw bytes without a tag or length prefix.
- * @name BufferWriter#raw
- * @function
- * @param {Uint8Array} value Raw bytes
- * @returns {BufferWriter} `this`
- */
-BufferWriter.prototype.raw = function write_raw_buffer(value) {
-    var len = value.length >>> 0;
-    return len ? this._push(BufferWriter.writeBytesBuffer, len, value) : this;
-};
-
-function writeStringBufferAscii(val, buf, pos) {
-    for (var i = 0; i < val.length;)
-        buf[pos++] = val.charCodeAt(i++);
-}
-
-function writeStringBuffer(val, buf, pos) {
-    if (val.length < 40) // plain js is faster for short strings (probably due to redundant assertions)
-        util.utf8.write(val, buf, pos);
-    else if (buf.utf8Write)
-        buf.utf8Write(val, pos);
-    else
-        buf.write(val, pos);
-}
-
 /**
  * @override
  */
 BufferWriter.prototype.string = function write_string_buffer(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 pos = this.pos,
+            buf = this.buf;
+        return this._delim(pos,
+            n < 40
+                ? util.utf8.write(value, buf, pos + 1)
+                : writeStringBuffer(value, buf, pos + 1)
+        );
+    }
     var len = util.Buffer.byteLength(value);
     this.uint32(len);
-    if (len)
-        this._push(len === value.length && len < 40 ? writeStringBufferAscii : writeStringBuffer, len, value);
+    this._reserve(len);
+    writeStringBuffer(value, this.buf, this.pos);
+    this.pos += len;
     return this;
 };