protobufjs 8.6.1 → 8.6.3

package/dist/minimal/protobuf.js

@@ -1,6 +1,6 @@
 /*!
- * protobuf.js v8.6.1 (c) 2016, daniel wirtz
- * compiled sun, 07 jun 2026 00:06:13 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
  */
@@ -39,7 +39,6 @@
 
 })/* end of prelude */({1:[function(require,module,exports){
 "use strict";
-var protobuf = exports;
 
 /**
  * Build type, one of `"full"`, `"light"` or `"minimal"`.
@@ -47,19 +46,19 @@ var protobuf = exports;
  * @type {string}
  * @const
  */
-protobuf.build = "minimal";
+exports.build = "minimal";
 
 // Serialization
-protobuf.Writer       = require(15);
-protobuf.BufferWriter = require(16);
-protobuf.Reader       = require(2);
-protobuf.BufferReader = require(3);
+exports.Writer       = require(15);
+exports.BufferWriter = require(16);
+exports.Reader       = require(2);
+exports.BufferReader = require(3);
 
 // Utility
-protobuf.util         = require(12);
-protobuf.rpc          = require(5);
-protobuf.roots        = require(4);
-protobuf.configure    = configure;
+exports.util         = require(12);
+exports.rpc          = require(5);
+exports.roots        = require(4);
+exports.configure    = configure;
 
 /* istanbul ignore next */
 /**
@@ -67,9 +66,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
@@ -302,18 +301,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) {
@@ -507,6 +504,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
@@ -538,7 +552,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.
@@ -2307,7 +2321,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.
@@ -2396,6 +2411,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