protobufjs 8.6.6 → 8.7.0

package/src/reader.js

@@ -15,7 +15,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
  */
@@ -39,6 +39,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}
@@ -46,18 +52,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
@@ -82,8 +84,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
@@ -91,12 +91,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);
 };
 
 /**
@@ -393,6 +388,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

package/src/reader_buffer.js

@@ -28,7 +28,7 @@ function BufferReader(buffer) {
      * Read buffer.
      * @name BufferReader#buf
      * @type {Buffer}
-     */
+    */
 }
 
 BufferReader._configure = function () {
@@ -46,8 +46,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);
 };
 

package/src/type.js

@@ -494,6 +494,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)
@@ -557,7 +565,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();
 };
 
 /**

package/src/util/minimal.js

@@ -137,36 +137,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);
 };
 
 /**
@@ -192,10 +185,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.
@@ -515,25 +509,3 @@ util.toJSONOptions = {
     bytes: String,
     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);
-        };
-};

package/src/util/utf8.js

@@ -1,19 +1,21 @@
 "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;
 }
 
 /**
@@ -64,6 +66,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
@@ -71,9 +80,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,
@@ -103,17 +114,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
@@ -121,9 +121,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,
@@ -139,14 +141,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);
     }