protobufjs 8.6.6 → 8.7.1

package/src/parse.js

@@ -220,6 +220,9 @@ function parse(source, root, options) {
     }
 
     function parseId(token, acceptNegative, max) {
+        if (token === null) {
+            throw illegal(token, "end of input");
+        }
         switch (token) {
             case "max": case "MAX": case "Max":
                 return max || maxFieldId;
@@ -252,7 +255,7 @@ function parse(source, root, options) {
         pkg = next();
 
         /* istanbul ignore if */
-        if (!typeRefRe.test(pkg))
+        if (pkg === null || !typeRefRe.test(pkg))
             throw illegal(pkg, "name");
 
         ptr = ptr.define(pkg);
@@ -389,7 +392,7 @@ function parse(source, root, options) {
             throw Error("max depth exceeded");
 
         /* istanbul ignore if */
-        if (!nameRe.test(token = next()))
+        if ((token = next()) === null || !nameRe.test(token))
             throw illegal(token, "type name");
 
         var type = new Type(token);
@@ -456,6 +459,9 @@ function parse(source, root, options) {
 
     function parseField(parent, rule, extend, depth) {
         var type = next();
+        if (type === null) {
+            throw illegal(type, "end of input");
+        }
         if (type === "group") {
             parseGroup(parent, rule, extend, depth);
             return;
@@ -467,8 +473,12 @@ function parse(source, root, options) {
         //    package  .subpackage field       tokens: "package" ".subpackage" [TYPE NAME ENDS HERE] "field"
         // Keep reading tokens until we get a type name with no period at the end,
         // and the next token does not start with a period.
-        while (type.endsWith(".") || peek().startsWith(".")) {
-            type += next();
+        while (type.endsWith(".") || (peek() || "").startsWith(".")) {
+            var part = next();
+            if (part === null) {
+                throw illegal(part, "end of input");
+            }
+            type += part;
         }
 
         /* istanbul ignore if */
@@ -476,6 +486,9 @@ function parse(source, root, options) {
             throw illegal(type, "type");
 
         var name = next();
+        if (name === null) {
+            throw illegal(name, "end of input");
+        }
 
         /* istanbul ignore if */
 
@@ -528,7 +541,7 @@ function parse(source, root, options) {
         var name = next();
 
         /* istanbul ignore if */
-        if (!nameRe.test(name))
+        if (name === null || !nameRe.test(name))
             throw illegal(name, "name");
 
         var fieldName = util.lcFirst(name);
@@ -546,6 +559,10 @@ function parse(source, root, options) {
                 case ";":
                     break;
 
+                case "map":
+                    parseMapField(type);
+                    break;
+
                 case "option":
                     parseOption(type, token);
                     skip(";");
@@ -626,7 +643,7 @@ function parse(source, root, options) {
         var name = next();
 
         /* istanbul ignore if */
-        if (!nameRe.test(name))
+        if (name === null || !nameRe.test(name))
             throw illegal(name, "name");
 
         skip("=");
@@ -653,7 +670,7 @@ function parse(source, root, options) {
     function parseOneOf(parent, token, depth) {
 
         /* istanbul ignore if */
-        if (!nameRe.test(token = next()))
+        if ((token = next()) === null || !nameRe.test(token))
             throw illegal(token, "name");
 
         var oneof = new OneOf(applyCase(token));
@@ -672,10 +689,11 @@ function parse(source, root, options) {
     function parseEnum(parent, token) {
 
         /* istanbul ignore if */
-        if (!nameRe.test(token = next()))
+        if ((token = next()) === null || !nameRe.test(token))
             throw illegal(token, "name");
 
-        var enm = new Enum(token);
+        var enm = new Enum(token),
+            values = [];
         ifBlock(enm, function parseEnum_block(token) {
           switch(token) {
             case ";":
@@ -692,16 +710,18 @@ function parse(source, root, options) {
               break;
 
             default:
-              parseEnumValue(enm, token);
+              values.push(parseEnumValue(token));
           }
         });
+        for (var i = 0; i < values.length; ++i)
+            enm.add(values[i].name, values[i].id, values[i].comment, values[i].options);
         parent.add(enm);
         if (parent === ptr) {
             topLevelObjects.push(enm);
         }
     }
 
-    function parseEnumValue(parent, token) {
+    function parseEnumValue(token) {
 
         /* istanbul ignore if */
         if (!nameRe.test(token))
@@ -733,7 +753,12 @@ function parse(source, root, options) {
         }, function parseEnumValue_line() {
             parseInlineOptions(dummy); // skip
         });
-        parent.add(token, value, dummy.comment, dummy.parsedOptions || dummy.options);
+        return {
+            name: token,
+            id: value,
+            comment: dummy.comment,
+            options: dummy.parsedOptions || dummy.options
+        };
     }
 
     function parseOption(parent, token) {
@@ -784,16 +809,27 @@ function parse(source, root, options) {
             var objectResult = {};
 
             while (!skip("}", true)) {
-                /* istanbul ignore if */
-                if (!nameRe.test(token = next())) {
-                    throw illegal(token, "name");
-                }
-                if (token === null) {
-                  throw illegal(token, "end of input");
+                token = next();
+                var propName;
+                if (token === null)
+                    throw illegal(token, "end of input");
+                if (token === "[") {
+                    token = next();
+                    // Extension name or, for Any, a type URL: "<prefix>/<fully.qualified.Type>".
+                    var slash = token === null ? -1 : token.lastIndexOf("/");
+                    if (token === null || !typeRefRe.test(slash < 0 ? token : token.slice(slash + 1)))
+                        throw illegal(token, "name");
+                    propName = "[" + token + "]";
+                    skip("]");
+                } else {
+                    /* istanbul ignore if */
+                    if (!nameRe.test(token)) {
+                        throw illegal(token, "name");
+                    }
+                    propName = token;
                 }
 
                 var value;
-                var propName = token;
 
                 skip(":", true);
 
@@ -801,25 +837,30 @@ function parse(source, root, options) {
                     // option (my_option) = {
                     //     repeated_value: [ "foo", "bar" ]
                     // };
-                    value = parseOptionValue(parent, name + "." + token, depth + 1);
+                    value = parseOptionValue(parent, name + "." + propName, depth + 1);
                 } else if (peek() === "[") {
                     value = [];
-                    var lastValue;
+                    var lastValue,
+                        lastValueIsAggregate;
                     if (skip("[", true)) {
                         if (!skip("]", true)) {
                             do {
-                                lastValue = readValue(true);
+                                lastValueIsAggregate = peek() === "{";
+                                lastValue = lastValueIsAggregate
+                                    ? parseOptionValue(parent, name + "." + propName, depth + 1)
+                                    : readValue(true);
                                 value.push(lastValue);
                             } while (skip(",", true));
                             skip("]");
                             if (typeof lastValue !== "undefined") {
-                                setOption(parent, name + "." + token, lastValue);
+                                if (!lastValueIsAggregate)
+                                    setOption(parent, name + "." + propName, lastValue);
                             }
                         }
                     }
                 } else {
                     value = readValue(true);
-                    setOption(parent, name + "." + token, value);
+                    setOption(parent, name + "." + propName, value);
                 }
 
                 var prevValue = Object.prototype.hasOwnProperty.call(objectResult, propName)
@@ -854,15 +895,12 @@ function parse(source, root, options) {
         // lift json_name onto Field
         if (name === "json_name" && parent instanceof Field) {
             parent.jsonName = value;
-            return;
         }
         if (parent.setOption)
             parent.setOption(name, value);
     }
 
     function setParsedOption(parent, name, value, propName) {
-        if (name === "json_name" && parent instanceof Field)
-            return; // lifted onto Field#jsonName above
         if (parent.setParsedOption)
             parent.setParsedOption(name, value, propName);
     }
@@ -884,7 +922,7 @@ function parse(source, root, options) {
             throw Error("max depth exceeded");
 
         /* istanbul ignore if */
-        if (!nameRe.test(token = next()))
+        if ((token = next()) === null || !nameRe.test(token))
             throw illegal(token, "service name");
 
         var service = new Service(token);
@@ -962,7 +1000,7 @@ function parse(source, root, options) {
     function parseExtension(parent, token, depth) {
 
         /* istanbul ignore if */
-        if (!typeRefRe.test(token = next()))
+        if ((token = next()) === null || !typeRefRe.test(token))
             throw illegal(token, "reference");
 
         var reference = token;

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/longbits.js

@@ -1,7 +1,7 @@
 "use strict";
 module.exports = LongBits;
 
-var util = require("../util/minimal");
+var Long;
 
 /**
  * Constructs new long bits.
@@ -80,10 +80,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));
     }
@@ -112,8 +112,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) };
 };
@@ -198,3 +198,7 @@ LongBits.prototype.length = function length() {
              : part1 < 2097152 ? 7 : 8
          : part2 < 128 ? 9 : 10;
 };
+
+LongBits._configure = function(Long_) {
+    Long = Long_;
+};