protobufjs 8.6.1 → 8.6.3

package/README.md

@@ -76,7 +76,7 @@ const decoded = AwesomeMessage.decode(encoded);
 
 Plain objects can be encoded directly when they already use protobuf.js runtime types: numbers for 32-bit numeric fields, booleans for `bool`, strings for `string`, `Uint8Array` or `Buffer` for `bytes`, arrays for repeated fields, and plain objects for maps. Map keys are the string representation of the respective value or an 8-character hash string for 64-bit keys.
 
-Unknown fields present on the wire are preserved by default in `message.$unknowns` and forwarded when the message is re-encoded. Unknown field data can be dropped from a decoded message with `delete message.$unknowns`, discarded during decode with `reader.discardUnknown = true` per reader, or disabled by default for subsequently created readers with `Reader.discardUnknown = true`.
+Unknown fields present on the wire are discarded by default. To preserve and forward unknown fields, set `reader.discardUnknown = false` before decoding with that reader, or make this the default for subsequently created readers with `Reader.discardUnknown = false`. Preserved unknown field data can be dropped from a decoded message with `delete message.$unknowns`.
 
 ### Convert plain objects
 
@@ -292,7 +292,7 @@ const decoded = AwesomeMessage.decode(bytes);
 decoded.customInstanceMethod(); // string
 ```
 
-protobuf.js will populate the constructor with the usual static runtime methods and use it for decoded messages. In TypeScript, custom members are visible when using the custom class type in consuming code.
+protobuf.js will populate the constructor with the usual static runtime methods and use it for decoded messages. When assigning constructors manually, add the type to its parent namespace/root first if fields reference other reflected types. In TypeScript, custom members are visible when using the custom class type in consuming code.
 
 ### Services
 

package/dist/light/protobuf.js

@@ -1,6 +1,6 @@
 /*!
- * protobuf.js v8.6.1 (c) 2016, daniel wirtz
- * compiled sun, 07 jun 2026 00:06:12 utc
+ * protobuf.js v8.6.3 (c) 2016, daniel wirtz
+ * compiled thu, 11 jun 2026 00:02:30 utc
  * licensed under the bsd-3-clause license
  * see: https://github.com/dcodeio/protobuf.js for details
  */
@@ -397,6 +397,10 @@ function missing(field) {
     return "missing required '" + field.name + "'";
 }
 
+function stringMethod(field) {
+    return field._features.utf8_validation === "VERIFY" ? "stringVerify" : "string";
+}
+
 /**
  * Generates a decoder specific to the specified message type.
  * @param {Type} mtype Message type
@@ -466,7 +470,7 @@ function decoder(mtype) {
                         ("case 1:")
                             ("if(u!==%i)", types.mapKey[field.keyType])
                                 ("break")
-                            ("k=r.%s()", field.keyType)
+                            ("k=r.%s()", field.keyType === "string" ? stringMethod(field) : field.keyType)
                             ("continue")
                         ("case 2:")
                             ("if(u!==%i)", types.basic[type] === undefined ? 2 : types.basic[type])
@@ -475,7 +479,7 @@ function decoder(mtype) {
             if (types.basic[type] === undefined) gen
                             ("v=types[%i].decode(r,r.uint32(),undefined,q+1)", i); // can't be groups
             else gen
-                            ("v=r.%s()", type);
+                            ("v=r.%s()", type === "string" ? stringMethod(field) : type);
 
             gen
                             ("continue")
@@ -522,7 +526,7 @@ function decoder(mtype) {
                 else gen
                     ("%s.push(types[%i].decode(r,r.uint32(),undefined,q+1))", ref, i);
             } else gen
-                    ("%s.push(r.%s())", ref, type);
+                    ("%s.push(r.%s())", ref, type === "string" ? stringMethod(field) : type);
 
         // Non-repeated
         } else if (types.basic[type] === undefined) {
@@ -540,7 +544,7 @@ function decoder(mtype) {
             ("case %i:{", field.id)
                 ("if(u!==%i)", types.basic[type])
                     ("break")
-                ("%s=r.%s()", ref, type);
+                ("%s=r.%s()", ref, type === "string" ? stringMethod(field) : type);
         } else {
             gen
             ("case %i:{", field.id)
@@ -550,7 +554,9 @@ function decoder(mtype) {
                 // TODO: Protoc rejects open enums whose first value is not zero.
                 // We should do the same, but for v8 this would be a regression.
                 ("if((v=r.%s())!==%j)", type, field.typeDefault);
-            else if (type === "string" || type === "bytes") gen
+            else if (type === "string") gen
+                ("if((v=r.%s()).length)", stringMethod(field));
+            else if (type === "bytes") gen
                 ("if((v=r.%s()).length)", type);
             else if (types.long[type] !== undefined) gen
                 ("if(typeof(v=r.%s())===\"object\"?v.low||v.high:v!==0)", type);
@@ -1442,9 +1448,9 @@ Field._configure = function configure(Type_) {
 
 },{"13":13,"23":23,"24":24,"5":5}],7:[function(require,module,exports){
 "use strict";
-var protobuf = module.exports = require(8);
+exports = module.exports = require(8);
 
-protobuf.build = "light";
+exports.build = "light";
 
 /**
  * A node-style callback as used by {@link load} and {@link Root#load}.
@@ -1466,9 +1472,9 @@ protobuf.build = "light";
 function load(filename, root, callback) {
     if (typeof root === "function") {
         callback = root;
-        root = new protobuf.Root();
+        root = new exports.Root();
     } else if (!root)
-        root = new protobuf.Root();
+        root = new exports.Root();
     return root.load(filename, callback);
 }
 
@@ -1496,7 +1502,7 @@ function load(filename, root, callback) {
  */
 // function load(filename:string, [root:Root]):Promise<Root>
 
-protobuf.load = load;
+exports.load = load;
 
 /**
  * Synchronously loads one or multiple .proto or preprocessed .json files into a common root namespace (node only).
@@ -1508,47 +1514,46 @@ protobuf.load = load;
  */
 function loadSync(filename, root) {
     if (!root)
-        root = new protobuf.Root();
+        root = new exports.Root();
     return root.loadSync(filename);
 }
 
-protobuf.loadSync = loadSync;
+exports.loadSync = loadSync;
 
 // Serialization
-protobuf.encoder          = require(4);
-protobuf.decoder          = require(3);
-protobuf.verifier         = require(38);
-protobuf.converter        = require(2);
+exports.encoder          = require(4);
+exports.decoder          = require(3);
+exports.verifier         = require(38);
+exports.converter        = require(2);
 
 // Reflection
-protobuf.ReflectionObject = require(13);
-protobuf.Namespace        = require(12);
-protobuf.Root             = require(17);
-protobuf.Enum             = require(5);
-protobuf.Type             = require(22);
-protobuf.Field            = require(6);
-protobuf.OneOf            = require(14);
-protobuf.MapField         = require(9);
-protobuf.Service          = require(21);
-protobuf.Method           = require(11);
+exports.ReflectionObject = require(13);
+exports.Namespace        = require(12);
+exports.Root             = require(17);
+exports.Enum             = require(5);
+exports.Type             = require(22);
+exports.Field            = require(6);
+exports.OneOf            = require(14);
+exports.MapField         = require(9);
+exports.Service          = require(21);
+exports.Method           = require(11);
 
 // Runtime
-protobuf.Message          = require(10);
-protobuf.wrappers         = require(39);
+exports.Message          = require(10);
+exports.wrappers         = require(39);
 
 // Utility
-protobuf.types            = require(23);
-protobuf.util             = require(24);
+exports.types            = require(23);
+exports.util             = require(24);
 
 // Set up possibly cyclic reflection dependencies
-protobuf.ReflectionObject._configure(protobuf.Root);
-protobuf.Namespace._configure(protobuf.Type, protobuf.Service, protobuf.Enum);
-protobuf.Root._configure(protobuf.Type, undefined, {});
-protobuf.Field._configure(protobuf.Type);
+exports.ReflectionObject._configure(exports.Root);
+exports.Namespace._configure(exports.Type, exports.Service, exports.Enum);
+exports.Root._configure(exports.Type, undefined, {});
+exports.Field._configure(exports.Type);
 
 },{"10":10,"11":11,"12":12,"13":13,"14":14,"17":17,"2":2,"21":21,"22":22,"23":23,"24":24,"3":3,"38":38,"39":39,"4":4,"5":5,"6":6,"8":8,"9":9}],8:[function(require,module,exports){
 "use strict";
-var protobuf = exports;
 
 /**
  * Build type, one of `"full"`, `"light"` or `"minimal"`.
@@ -1556,19 +1561,19 @@ var protobuf = exports;
  * @type {string}
  * @const
  */
-protobuf.build = "minimal";
+exports.build = "minimal";
 
 // Serialization
-protobuf.Writer       = require(40);
-protobuf.BufferWriter = require(41);
-protobuf.Reader       = require(15);
-protobuf.BufferReader = require(16);
+exports.Writer       = require(40);
+exports.BufferWriter = require(41);
+exports.Reader       = require(15);
+exports.BufferReader = require(16);
 
 // Utility
-protobuf.util         = require(33);
-protobuf.rpc          = require(19);
-protobuf.roots        = require(18);
-protobuf.configure    = configure;
+exports.util         = require(33);
+exports.rpc          = require(19);
+exports.roots        = require(18);
+exports.configure    = configure;
 
 /* istanbul ignore next */
 /**
@@ -1576,9 +1581,9 @@ protobuf.configure    = configure;
  * @returns {undefined}
  */
 function configure() {
-    protobuf.util._configure();
-    protobuf.Writer._configure(protobuf.BufferWriter);
-    protobuf.Reader._configure(protobuf.BufferReader);
+    exports.util._configure();
+    exports.Writer._configure(exports.BufferWriter);
+    exports.Reader._configure(exports.BufferReader);
 }
 
 // Set up buffer utility according to the environment
@@ -1733,7 +1738,7 @@ var util = require(33);
  * @classdesc Abstract runtime message.
  * @constructor
  * @param {Properties<T>} [properties] Properties to set
- * @property {Array.<Uint8Array>} [$unknowns] Unknown fields preserved while decoding
+ * @property {Array.<Uint8Array>} [$unknowns] Unknown fields preserved while decoding when enabled
  * @template T extends object = object
  */
 function Message(properties) {
@@ -2362,7 +2367,8 @@ Namespace.prototype.remove = function remove(object) {
     if (object.parent !== this)
         throw Error(object + " is not a member of " + this);
 
-    delete this.nested[object.name];
+    if (!util.remove(this.nested, object, object.name))
+        throw Error(object + " is not a member of " + this);
     if (!Object.keys(this.nested).length)
         this.nested = undefined;
 
@@ -3443,18 +3449,16 @@ function readLongVarint() {
             return bits;
         i = 0;
     } else {
-        for (; i < 3; ++i) {
+        for (; i < 4; ++i) {
             /* istanbul ignore if */
             if (this.pos >= this.len)
                 throw indexOutOfRange(this);
-            // 1st..3th
+            // 1st..4th
             bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
             if (this.buf[this.pos++] < 128)
                 return bits;
         }
-        // 4th
-        bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
-        return bits;
+        throw indexOutOfRange(this);
     }
     if (this.len - this.pos > 4) { // fast route (hi)
         for (; i < 5; ++i) {
@@ -3648,6 +3652,23 @@ Reader.prototype.string = function read_string() {
     return utf8.read(this.buf, start, end);
 };
 
+/**
+ * Reads a string preceeded by its byte length as a varint, rejecting invalid UTF8.
+ * @returns {string} Value read
+ */
+Reader.prototype.stringVerify = function read_string_verify() {
+    var length = this.uint32(),
+        start  = this.pos,
+        end    = this.pos + length;
+
+    /* istanbul ignore if */
+    if (end > this.len)
+        throw indexOutOfRange(this, length);
+
+    this.pos = end;
+    return utf8.readStrict(this.buf, start, end);
+};
+
 /**
  * Skips the specified number of bytes if specified, otherwise skips a varint.
  * @param {number} [length] Length if known, otherwise a varint is assumed
@@ -3679,7 +3700,7 @@ Reader.recursionLimit = util.recursionLimit;
  * Whether readers discard unknown fields while decoding.
  * @type {boolean}
  */
-Reader.discardUnknown = false;
+Reader.discardUnknown = true;
 
 /**
  * Skips the next element of the specified wire type.
@@ -4819,6 +4840,7 @@ Object.defineProperties(Type.prototype, {
     /**
      * The registered constructor, if any registered, otherwise a generic constructor.
      * Assigning a function replaces the internal constructor. If the function does not extend {@link Message} yet, its prototype will be setup accordingly and static methods will be populated. If it already extends {@link Message}, it will just replace the internal constructor.
+     * When assigning manually, add the type to its parent namespace/root first if fields reference other reflected types, because constructor setup resolves field defaults.
      * @name Type#ctor
      * @type {Constructor<{}>}
      */
@@ -5088,10 +5110,9 @@ Type.prototype.remove = function remove(object) {
         // See Type#add for the reason why extension fields are excluded here.
 
         /* istanbul ignore if */
-        if (!this.fields || this.fields[object.name] !== object)
+        if (!util.remove(this.fields, object, object.name))
             throw Error(object + " is not a member of " + this);
 
-        delete this.fields[object.name];
         object.parent = null;
         object.onRemove(this);
         return clearCache(this);
@@ -5099,10 +5120,9 @@ Type.prototype.remove = function remove(object) {
     if (object instanceof OneOf) {
 
         /* istanbul ignore if */
-        if (!this.oneofs || this.oneofs[object.name] !== object)
+        if (!util.remove(this.oneofs, object, object.name))
             throw Error(object + " is not a member of " + this);
 
-        delete this.oneofs[object.name];
         object.parent = null;
         object.onRemove(this);
         return clearCache(this);
@@ -5577,6 +5597,28 @@ util.toObject = function toObject(array) {
     return object;
 };
 
+/**
+ * Removes the first matching value from an object.
+ * @param {Object.<string,*>|undefined} object Object to remove from
+ * @param {*} value Value to remove
+ * @param {string} [key] Optional key for fast path removal
+ * @returns {boolean} `true` if removed, otherwise `false`
+ */
+util.remove = function remove(object, value, key) {
+    if (!object)
+        return false;
+    if (key !== undefined && Object.prototype.hasOwnProperty.call(object, key) && object[key] === value) {
+        delete object[key];
+        return true;
+    }
+    for (var names = Object.keys(object), i = 0; i < names.length; ++i)
+        if (object[names[i]] === value) {
+            delete object[names[i]];
+            return true;
+        }
+    return false;
+};
+
 /**
  * Tests whether the specified name is a reserved word in JS.
  * @param {string} name Name to test
@@ -7358,6 +7400,28 @@ util._configure = function() {
  */
 var path = exports;
 
+var urlRe = /^[a-zA-Z][a-zA-Z0-9+.-]+:\/\//;
+
+function normalizeUrl(path) {
+    if (typeof URL === "undefined" || !urlRe.test(path))
+        return null;
+    try {
+        return new URL(path).href;
+    } catch (e) {
+        return null;
+    }
+}
+
+function resolveUrl(originPath, includePath) {
+    if (typeof URL === "undefined" || !urlRe.test(originPath) || urlRe.test(includePath))
+        return null;
+    try {
+        return new URL(includePath, originPath).href;
+    } catch (e) {
+        return null;
+    }
+}
+
 var isAbsolute =
 /**
  * Tests if the specified path is absolute.
@@ -7375,6 +7439,9 @@ var normalize =
  * @returns {string} Normalized path
  */
 path.normalize = function normalize(path) {
+    var normalizedUrl = normalizeUrl(path);
+    if (normalizedUrl)
+        return normalizedUrl;
     var firstTwoCharacters = path.substring(0,2);
     var uncPrefix = "";
     if (firstTwoCharacters === "\\\\") {
@@ -7413,8 +7480,11 @@ path.normalize = function normalize(path) {
  * @returns {string} Path to the include file
  */
 path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
+    var resolvedUrl = resolveUrl(originPath, includePath);
+    if (resolvedUrl)
+        return resolvedUrl;
     if (!alreadyNormalized)
-        includePath = normalize(includePath);
+        includePath = normalize(includePath); // path or absolute url
     if (isAbsolute(includePath))
         return includePath;
     if (!alreadyNormalized)
@@ -7490,7 +7560,8 @@ function pool(alloc, slice, size) {
  * @namespace
  */
 var utf8 = exports,
-    replacementChar = "\ufffd";
+    replacementChar = "\ufffd",
+    strictDecoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 
 /**
  * Calculates the UTF8 byte length of a string.
@@ -7579,6 +7650,56 @@ 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
+ * @param {number} start Source start
+ * @param {number} end Source end
+ * @returns {string} String read
+ */
+utf8.readStrict = function utf8_read_strict_ascii(buffer, start, end) {
+    if (end - start < 1)
+        return "";
+
+    var str = "",
+        i = start,
+        c1, c2, c3, c4, c5, c6, c7, c8;
+
+    for (; i + 7 < end; i += 8) {
+        c1 = buffer[i];
+        c2 = buffer[i + 1];
+        c3 = buffer[i + 2];
+        c4 = buffer[i + 3];
+        c5 = buffer[i + 4];
+        c6 = buffer[i + 5];
+        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);
+        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);
+        str += String.fromCharCode(c1);
+    }
+
+    return str;
+};
+
 /**
  * Writes a string as UTF8 bytes.
  * @param {string} string Source string