protobufjs 8.7.0 → 8.7.2

package/README.md

@@ -7,15 +7,13 @@
   <a href="https://www.jsdelivr.com/package/npm/protobufjs"><img src="https://img.shields.io/jsdelivr/npm/hm/protobufjs?label=requests&logo=jsdelivr" alt=""></a>
 </p>
 
-**Protocol Buffers** are a language-neutral, platform-neutral, extensible way of serializing structured data for use in communications protocols, data storage, and more, originally designed at Google ([see](https://protobuf.dev/)).
-
-**protobuf.js** is a very fast, conformant, and unusually versatile JavaScript implementation of Protocol Buffers for Node.js and browsers. It works with `.proto` files out of the box, does not require protoc, and supports runtime reflection as well as specialized code generation with strong TypeScript declarations.
+**protobuf.js** is a very fast, conformant, and unusually versatile JavaScript implementation of [Protocol Buffers](https://protobuf.dev) for Node.js and browsers. It is independently maintained with contributions from the upstream Protocol Buffers project, works with `.proto` schemas without requiring `protoc`, and supports runtime reflection as well as specialized code generation with matching TypeScript declarations.
 
 If protobuf.js is important to your project or organization, or if you depend on it commercially, [consider supporting](https://github.com/sponsors/dcodeIO) its ongoing maintenance. Sponsorship helps make bug fixes, releases, LTS/security handling, and user support more sustainable.
 
 ## Getting started
 
-Getting up and running is simple: Install the package, load a `.proto` file, and you are all set to encode and decode Protobuf messages. From there, protobuf.js grows with your requirements: Add any combination of capabilities, such as [code generation](#code-generation), [TypeScript declarations](#typescript-integration), [transport-agnostic services](#services), [programmatic schemas](#programmatic-schemas), [optional extensions](#extensions), and more as needed. All in one flexible toolkit.
+Getting up and running is simple: Install the package, load a schema, and you are all set to encode and decode Protobuf messages. From there, protobuf.js grows with your requirements: Add code generation with TypeScript declarations, transport-agnostic services, support for text-based formats, and more as needed.
 
 ### Install
 
@@ -33,7 +31,7 @@ The CLI is a JS-native protobuf.js toolchain that does not require setting up `p
 
 #### Browser builds
 
-Canonical browser builds for each runtime variant are [provided via the jsDelivr CDN](https://cdn.jsdelivr.net/npm/protobufjs@8.X.X/dist/), supporting CommonJS, AMD and global `window.protobuf`. Make sure to pin an exact version in production.
+Canonical browser builds are [provided via the jsDelivr CDN](https://cdn.jsdelivr.net/npm/protobufjs@8.X.X/dist/), supporting CommonJS, AMD and global `window.protobuf`. Make sure to pin an exact version in production.
 
 ## Usage
 
@@ -60,7 +58,7 @@ const root = await protobuf.load("awesome.proto");
 const AwesomeMessage = root.lookupType("awesomepackage.AwesomeMessage");
 ```
 
-Optionally use `load()` with a callback, or `loadSync()` for synchronous loading on Node.js.
+Optionally use `load()` with a callback, or `loadSync()` for synchronous loading on Node.js. Imports resolve relative to the importing file by default. To resolve imports against a specific base directory, create a `Root` and override `root.resolvePath` before calling `root.load()`.
 
 ### Encode and decode
 
@@ -78,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 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`.
+Note that, as with any structured binary format, decoded structures incur runtime memory overhead beyond their encoded representation. Applications processing untrusted input should therefore apply appropriate input-size and concurrency limits to bound memory use. For this reason, unknown fields present on the wire are intentionally discarded as the safer default, but can be retained by setting `reader.discardUnknown = false` per reader, or by setting `Reader.discardUnknown = false` to make it the default for subsequently created readers. Preserved unknown field data can also be explicitly dropped with `delete message.$unknowns`.
 
 ### Convert plain objects
 
@@ -138,41 +136,28 @@ Message types expose focused methods for validation, conversion, and binary I/O.
 * **message.toJSON**(): `object`  
   Converts a message instance to JSON-compatible output using default conversion options.
 
-Message instances provide runtime identity, so they can be tested with `instanceof`. Their `toJSON` method integrates them with `JSON.stringify`.
+Message instances provide stable runtime identity for testing with `instanceof`.
 
 Length-delimited methods read and write a varint byte length before the message, which is useful for streams and framed protocols.
 
 If required fields are missing while decoding proto2 data, `decode` throws `protobuf.util.ProtocolError` with the partially decoded message available as `err.instance`.
 
-## Runtimes
-
-protobuf.js provides three runtime entry points, keeping parser and reflection support optional: Runtime `.proto` loading needs the parser, JSON/reflection bundles need reflection support, and generated static modules only need the minimal runtime.
-
-| Import                  | Includes           | Use when
-| ----------------------- | ------------------ | --------
-| `protobufjs`            | Reflection, Parser | You load `.proto` files at runtime
-| `protobufjs/light.js`   | Reflection         | You load JSON bundles or build schemas programmatically
-| `protobufjs/minimal.js` | Static runtime     | You use generated static code
-
-The full build includes the light build, and the light build includes the minimal runtime.
-
 ## Code generation
 
-Use [`protobufjs-cli`](./cli/#readme) to generate reflection bundles, static JavaScript code, and matching TypeScript declarations, either directly with `pbjs` or through the optional `protoc-gen-pbjs` plugin for `protoc`.
+Use [`protobufjs-cli`](./cli/#readme) to generate schema-specific code, either directly with `pbjs` or through the optional `protoc-gen-pbjs` plugin for `protoc`.
 
-Reflection keeps schemas as JSON metadata and generates optimized functions at runtime. Static code emits schema-specific, reflection-free functions ahead of time. The main tradeoffs are how schemas are loaded, how bundle size scales with schema size, and whether reflection metadata should remain available at runtime.
+protobuf.js offers two code-generation modes, both with matching TypeScript declarations: reflection modules generate optimized code at runtime with reflection metadata retained; static modules generate reflection-free code ahead of time. Both use the same runtime package and automatically import only the runtime capabilities they need.
 
-| Target | Output | Minimum Runtime |
-|--------|--------|-----------------|
-| `json` | JSON bundle | `protobufjs/light.js` |
-| `json-module` | JSON bundle module | `protobufjs/light.js` |
-| `static-module` | Static code module | `protobufjs/minimal.js` |
+| Target | Output | Runtime entry |
+|--------|--------|---------------|
+| `json-module` | Reflection module | `protobufjs/light.js` (without parser) |
+| `static-module` | Static code module | `protobufjs/minimal.js` (without reflection) |
 
 Module targets support `--wrap default` for CommonJS and AMD, plus `esm`, `commonjs`, `amd`, and `closure`; `--wrap` can also load a custom wrapper module.
 
 ### Static modules
 
-Static modules emit dedicated JavaScript for your schema, so they only need `protobufjs/minimal.js` at runtime.
+Static modules emit dedicated, reflection-free JavaScript code for your schema.
 
 ```sh
 npx pbjs -t static-module -w esm -o awesome.js --dts awesome.proto
@@ -184,22 +169,11 @@ import { awesomepackage } from "./awesome.js";
 const message = awesomepackage.AwesomeMessage.create({ awesomeField: "hello" });
 ```
 
-While static code is verbose by design, its repeated patterns compress well with Brotli or gzip, and it works in [CSP](https://w3c.github.io/webappsec-csp/)-restricted environments that disallow unsafe-eval without sacrificing performance.
-
-### Reflection bundles
+Static code is repetitive by design, but compresses unusually well with Brotli or gzip and works in [CSP](https://w3c.github.io/webappsec-csp/)-restricted environments.
 
-Reflection bundles store schemas as compact JSON metadata, avoiding `.proto` parsing at runtime and letting browsers load schema metadata in one request. While they require at least `protobufjs/light.js`, large schemas can produce smaller combined bundles than equivalent static modules because common code is shared through reflection.
+### Reflection modules
 
-```sh
-npx pbjs -t json -o awesome.json awesome1.proto awesome2.proto ...
-```
-
-```ts
-const bundle = require("./awesome.json");
-
-const root = protobuf.Root.fromJSON(bundle);
-const AwesomeMessage = root.lookupType("awesomepackage.AwesomeMessage");
-```
+Reflection modules wrap schemas as compact JSON metadata while avoiding `.proto` parsing at runtime.
 
 ```sh
 npx pbjs -t json-module -w esm -o awesome.js --dts awesome.proto
@@ -211,13 +185,11 @@ import { awesomepackage } from "./awesome.js";
 const AwesomeMessage = awesomepackage.AwesomeMessage;
 ```
 
-JSON modules export the reflection root and, with `-w esm`, also provide top-level named exports that align with static modules. Their declarations mirror `static-module` typings, but because JSON modules are backed by reflection objects, message instances should be created with `MyMessage.create(...)` instead of constructors. Code using `create(...)` works with static modules as well.
+Declarations for reflection modules mirror `static-module` typings. Because JSON modules export reflection objects, message instances should be created with `MyMessage.create(...)` rather than constructors. Code using `create(...)` works with static modules as well. Separately, `-t json` can serialize reflection metadata as bare JSON bundles for use with `load()` or `Root.fromJSON()`.
 
 ### TypeScript integration
 
-protobuf.js works with TypeScript out of the box: the runtime API is typed, and generated JavaScript can be paired with strong TypeScript declarations in the same CLI invocation. Generated output is directly usable from JavaScript without a transpile step, and strongly typed in TypeScript projects, with type-checked oneofs and JavaScript-friendly plain-object input.
-
-For example, given the oneof:
+protobuf.js works with TypeScript out of the box: its runtime API is typed, and generated code can be paired with matching TypeScript declarations in a single CLI invocation. Declarations are strongly typed, including discriminated unions for oneofs and scoped types for plain-object usage:
 
 ```proto
 message Profile {
@@ -228,8 +200,6 @@ message Profile {
 }
 ```
 
-Generated declarations narrow both the `contact` oneof and the concrete values:
-
 ```ts
 const profile = Profile.create({
   contact: "email",
@@ -246,7 +216,7 @@ if (decoded.contact === "phone") {
 }
 ```
 
-Plain objects can use the same narrowed shape through a collision-free scoped type:
+The same narrowed shape is available for plain-object inputs:
 
 ```ts
 const object: Profile.$Shape = {
@@ -259,7 +229,7 @@ const object: Profile.$Shape = {
 
 ### Programmatic schemas
 
-The full and light builds can construct schemas directly through reflection:
+Schemas can be constructed directly through reflection:
 
 ```ts
 const AwesomeMessage = new protobuf.Type("AwesomeMessage")
@@ -316,22 +286,7 @@ const myService = MyService.create(myRpcImpl/*, requestDelimited?, responseDelim
 
 See [examples/streaming-rpc.js](./examples/streaming-rpc.js) for a streaming example.
 
-Integration example with [@grpc/grpc-js](https://www.npmjs.com/package/@grpc/grpc-js):
-
-```js
-const grpc = require('@grpc/grpc-js');
-
-const Client = grpc.makeGenericClientConstructor({});
-const client = new Client(serverAddress, grpc.credentials.createInsecure());
-
-const rpcImpl = (method, requestData, callback) =>
-  client.makeUnaryRequest(method.path, (data) => data, (data) => data, requestData, callback);
-
-const greeter = root.lookupService("example.Greeter").create(rpcImpl);
-const reply = await greeter.sayHello({ name: "world" });
-```
-
-See [examples/grpc-service.js](./examples/grpc-service.js) for a complete example.
+See [examples/grpc-service.js](./examples/grpc-service.js) for an integration example with [@grpc/grpc-js](https://www.npmjs.com/package/@grpc/grpc-js).
 
 ### Extensions
 
@@ -339,7 +294,7 @@ The following extensions provide descriptor conversion and text-based protobuf f
 
 #### Descriptors
 
-protobuf.js uses a compact JSON-based reflection representation internally that is easy to embed and fast to parse, so schemas can be loaded directly without first decoding binary descriptor blobs or postprocessing their full JSON representation. See [ext/descriptor](./ext/README.md#descriptor) for use cases that need conversion between reflected roots and `protoc` descriptor messages.
+protobuf.js uses a compact JSON-based reflection representation internally. See [ext/descriptor](./ext/README.md#descriptor) for use cases that need conversion between reflected roots and `protoc` descriptor messages.
 
 #### ProtoJSON
 
@@ -351,7 +306,7 @@ Protocol Buffers [Text Format](https://protobuf.dev/reference/protobuf/textforma
 
 ## Conformance
 
-protobuf.js is validated against the official Protocol Buffers conformance suite, achieving complete binary wire-format conformance for **Proto2**, **Proto3** and **Editions**, plus complete **ProtoJSON** and **Text Format** conformance in its default configuration with reflection metadata present.
+protobuf.js is validated against the official Protocol Buffers conformance suite. It passes all required and recommended tests for the **Proto2**, **Proto3** and **Editions** binary wire formats, with complete **ProtoJSON** and **Text Format** support available as optional extensions when those formats are needed.
 
 <!-- BEGIN CONFORMANCE DATA -->
 
@@ -367,37 +322,59 @@ protobuf.js is validated against the official Protocol Buffers conformance suite
 
 <!-- END CONFORMANCE DATA -->
 
-[Structured results](https://github.com/protobufjs/protobuf.js/actions/workflows/test.yml?query=branch%3Amaster+event%3Apush) are available as CI artifacts. In case of contradicting claims by your favorite LLM, [see](https://dev.to/dcode/when-the-model-is-the-marketing-device-a-protobuf-short-story-2p7p).
+[Structured results](https://github.com/protobufjs/protobuf.js/actions/workflows/test.yml?query=branch%3Amaster+event%3Apush) of the conformance tests are also available as CI artifacts.
 
 ## Performance
 
-In both reflection and reflection-free modes, protobuf.js builds specialized encoders and decoders on top of hand-tuned reader and writer primitives, making it a strong fit from battery-powered devices to high-traffic servers, or generally for projects and their downstream users adopting protobuf as a faster, smaller alternative to JSON.
+Both reflection and static modes use specialized encoders and decoders backed by the same hand-tuned reader and writer primitives.
 
-The repository includes a [small benchmark](./bench) over a common message shape, plus Mapbox's vector tile fixture and Buf's perf payload, both unmodified. For each case, it compares protobuf.js encode and decode throughput against JSON encode/decode, Google's protoc-gen-js, and Buf's protoc-gen-es. Results show that protobuf.js is consistently faster than the other Protobuf implementations, up to an order of magnitude on real-world data, and among the libraries tested, it is the only one that is an upgrade over using JSON.
+The repository includes a [benchmark suite](./bench) you can run yourself. It compares protobuf.js with other general-purpose JavaScript implementations across three substantially different cases: our classic common message shape and two unmodified, structurally distinct fixtures sourced externally. The suite measures each library's recommended serialization and deserialization path using identical schemas and inputs, with JSON included as an additional baseline. Across these cases, protobuf.js is a clear upgrade over using JSON and consistently the fastest Protobuf implementation by a considerable margin.
 
 <!-- BEGIN BENCHMARK DATA -->
 
-![Encode benchmark](./bench/results/encode.svg)
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="./bench/results/encode-dark.svg">
+  <source media="(prefers-color-scheme: light)" srcset="./bench/results/encode-light.svg">
+  <img alt="Encode benchmark" src="./bench/results/encode.svg">
+</picture>
+
+<details>
+<summary>Show table</summary>
+
+| Implementation | Common | Vector tile | Buf perf |
+| --- | ---: | ---: | ---: |
+| protobuf.js static | **5.34M ops/s** &nbsp; <small>1.0x</small> | **3.09K ops/s** &nbsp; <small>1.0x</small> | 43.1K ops/s &nbsp; <small>1.0x</small> |
+| protobuf.js reflect | 4.89M ops/s &nbsp; <small>1.1x</small> | 3.03K ops/s &nbsp; <small>1.0x</small> | **43.3K ops/s** &nbsp; <small>1.0x</small> |
+| JSON | 2.09M ops/s &nbsp; <small>2.6x</small> | 897 ops/s &nbsp; <small>3.4x</small> | 6.70K ops/s &nbsp; <small>6.5x</small> |
+| protoc-gen-js | 1.03M ops/s &nbsp; <small>5.2x</small> | 700 ops/s &nbsp; <small>4.4x</small> | 13.9K ops/s &nbsp; <small>3.1x</small> |
+| protoc-gen-es | 402K ops/s &nbsp; <small>13.3x</small> | 235 ops/s &nbsp; <small>13.2x</small> | 8.22K ops/s &nbsp; <small>5.3x</small> |
+
+</details>
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="./bench/results/decode-dark.svg">
+  <source media="(prefers-color-scheme: light)" srcset="./bench/results/decode-light.svg">
+  <img alt="Decode benchmark" src="./bench/results/decode.svg">
+</picture>
 
-| Case | protobuf.js static | protobuf.js reflect | JSON | protoc-gen-js | protoc-gen-es |
-| --- | ---: | ---: | ---: | ---: | ---: |
-| Common | 3.18M ops/s | 3.25M ops/s | 2.07M ops/s | 1.01M ops/s | 395K ops/s |
-| Vector tile | 2.82K ops/s | 2.76K ops/s | 859 ops/s | 680 ops/s | 231 ops/s |
-| Buf perf | 41.4K ops/s | 39.9K ops/s | 6.59K ops/s | 13.5K ops/s | 8.00K ops/s |
+<details>
+<summary>Show table</summary>
 
-![Decode benchmark](./bench/results/decode.svg)
+| Implementation | Common | Vector tile | Buf perf |
+| --- | ---: | ---: | ---: |
+| protobuf.js static | 6.45M ops/s &nbsp; <small>1.1x</small> | 2.70K ops/s &nbsp; <small>1.1x</small> | **81.7K ops/s** &nbsp; <small>1.0x</small> |
+| protobuf.js reflect | **6.93M ops/s** &nbsp; <small>1.0x</small> | **2.99K ops/s** &nbsp; <small>1.0x</small> | 80.3K ops/s &nbsp; <small>1.0x</small> |
+| JSON | 1.37M ops/s &nbsp; <small>5.0x</small> | 1.06K ops/s &nbsp; <small>2.8x</small> | 19.5K ops/s &nbsp; <small>4.2x</small> |
+| protoc-gen-js | 811K ops/s &nbsp; <small>8.5x</small> | 851 ops/s &nbsp; <small>3.5x</small> | 21.7K ops/s &nbsp; <small>3.8x</small> |
+| protoc-gen-es | 691K ops/s &nbsp; <small>10.0x</small> | 376 ops/s &nbsp; <small>8.0x</small> | 14.3K ops/s &nbsp; <small>5.7x</small> |
 
-| Case | protobuf.js static | protobuf.js reflect | JSON | protoc-gen-js | protoc-gen-es |
-| --- | ---: | ---: | ---: | ---: | ---: |
-| Common | 6.11M ops/s | 6.09M ops/s | 1.31M ops/s | 790K ops/s | 710K ops/s |
-| Vector tile | 2.45K ops/s | 2.78K ops/s | 1.04K ops/s | 858 ops/s | 392 ops/s |
-| Buf perf | 72.5K ops/s | 66.4K ops/s | 19.0K ops/s | 21.1K ops/s | 14.2K ops/s |
+</details>
 
 <!-- END BENCHMARK DATA -->
 
-[Structured results](./bench/results/latest.json) of this run are available as committed artifacts.
+[Structured results](./bench/results/latest.json) and environment details for this run are also available as committed artifacts.
 
-To run the benchmark yourself on your own hardware:
+To run the benchmark on your own hardware:
 
 ```sh
 npm --prefix bench install

package/dist/light/protobuf.js

@@ -1,6 +1,6 @@
 /*!
- * protobuf.js v8.7.0 (c) 2016, daniel wirtz
- * compiled mon, 06 jul 2026 13:50:00 utc
+ * protobuf.js v8.7.2 (c) 2016, daniel wirtz
+ * compiled sat, 08 aug 2026 13:15:56 utc
  * licensed under the bsd-3-clause license
  * see: https://github.com/dcodeio/protobuf.js for details
  */
@@ -340,12 +340,16 @@ 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)
         ("}");
-            } else gen
+            } else if ((field.type === "double" || field.type === "float") && typeof field.typeDefault === "number"
+                    && (!isFinite(field.typeDefault) || Object.is(field.typeDefault, -0))) gen
+        ("d%s=%f", prop, field.typeDefault)
+        ("if(o.json&&!isFinite(d%s))d%s=String(d%s)", prop, prop, prop);
+            else gen
         ("d%s=%j", prop, field.typeDefault); // also messages (=null)
         } gen
     ("}");
@@ -498,7 +502,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);
 
@@ -884,8 +888,11 @@ function Enum(name, values, options, comment, comments, valuesOptions) {
 
     if (values)
         for (var keys = Object.keys(values), i = 0; i < keys.length; ++i)
-            if (keys[i] !== "__proto__" && typeof values[keys[i]] === "number") // use forward entries only
-                this.valuesById[ this.values[keys[i]] = values[keys[i]] ] = keys[i];
+            if (keys[i] !== "__proto__" && typeof values[keys[i]] === "number") { // use forward entries only
+                this.values[keys[i]] = values[keys[i]];
+                if (this.valuesById[values[keys[i]]] === undefined)
+                    this.valuesById[values[keys[i]]] = keys[i];
+            }
 }
 
 /**
@@ -1414,12 +1421,17 @@ Field.prototype.resolve = function resolve() {
 
     // convert to internal data type if necesssary
     if (this.long) {
-        this.typeDefault = util.Long.fromNumber(this.typeDefault, this.type === "uint64" || this.type === "fixed64");
+        var unsigned = this.type === "uint64" || this.type === "fixed64";
+        this.typeDefault = typeof this.typeDefault === "string"
+            ? util.Long.fromString(this.typeDefault, unsigned)
+            : util.Long.fromNumber(this.typeDefault, unsigned);
 
         /* istanbul ignore else */
         if (Object.freeze)
             Object.freeze(this.typeDefault); // long instances are meant to be immutable anyway (i.e. use small int cache that even requires it)
 
+    } else if (types.long[this.type] !== undefined && typeof this.typeDefault === "string") {
+        this.typeDefault = parseInt(this.typeDefault, 10);
     } else if (this.bytes && typeof this.typeDefault === "string") {
         var buf;
         if (util.base64.test(this.typeDefault))
@@ -1682,6 +1694,7 @@ exports.configure    = configure;
  * @returns {undefined}
  */
 function configure() {
+    exports.util.LongBits._configure(exports.util.Long);
     exports.Writer._configure(exports.BufferWriter);
     exports.Reader._configure(exports.BufferReader);
 }
@@ -3762,9 +3775,18 @@ Reader.prototype.double = function read_double() {
  */
 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());
+    var end = this.uint32() + this.pos, buf = this.buf, pos = this.pos, value;
+    while (pos < end) {
+        value = buf[pos++];
+        if (value < 128)
+            array.push(value);
+        else {
+            this.pos = pos - 1;
+            array.push(this.uint32());
+            pos = this.pos;
+        }
+    }
+    this.pos = pos;
     return array;
 };
 
@@ -3775,9 +3797,18 @@ Reader.prototype.uint32s = function read_uint32s(array) {
  */
 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());
+    var end = this.uint32() + this.pos, buf = this.buf, pos = this.pos, value;
+    while (pos < end) {
+        value = buf[pos++];
+        if (value < 128)
+            array.push(value);
+        else {
+            this.pos = pos - 1;
+            array.push(this.int32());
+            pos = this.pos;
+        }
+    }
+    this.pos = pos;
     return array;
 };
 
@@ -3801,9 +3832,18 @@ Reader.prototype.sint32s = function read_sint32s(array) {
  */
 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());
+    var end = this.uint32() + this.pos, buf = this.buf, pos = this.pos, value;
+    while (pos < end) {
+        value = buf[pos++];
+        if (value < 128)
+            array.push(value !== 0);
+        else {
+            this.pos = pos - 1;
+            array.push(this.bool());
+            pos = this.pos;
+        }
+    }
+    this.pos = pos;
     return array;
 };
 
@@ -6493,7 +6533,9 @@ function codegen(functionParams, functionName) {
         formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {
             var value = formatParams[formatOffset++];
             switch ($1) {
-                case "d": case "f": return String(Number(value));
+                case "d": case "f":
+                    value = Number(value);
+                    return Object.is(value, -0) ? "-0" : String(value);
                 case "i": return String(Math.floor(value));
                 case "j": return JSON.stringify(value);
                 case "s": return String(value);
@@ -7102,7 +7144,7 @@ module.exports = fs;
 "use strict";
 module.exports = LongBits;
 
-var util = require(33);
+var Long;
 
 /**
  * Constructs new long bits.
@@ -7181,10 +7223,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));
     }
@@ -7213,8 +7255,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) };
 };
@@ -7300,7 +7342,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;
@@ -7983,7 +8029,6 @@ function pool(alloc, slice, size) {
  * @namespace
  */
 var utf8 = exports,
-    replacementChar = "\ufffd",
     looseDecoder = new TextDecoder("utf-8", { ignoreBOM: true }),
     strictDecoder;
 var TEXT_DECODER_MIN_LENGTH = 64;
@@ -8018,31 +8063,6 @@ utf8.length = function utf8_length(string) {
     return len;
 };
 
-function utf8_read_js(buffer, start, end, str) {
-    for (var i = start; i < end;) {
-        var t = buffer[i++];
-        if (t <= 0x7F) {
-            str += String.fromCharCode(t);
-        } else if (t >= 0xC0 && t < 0xE0) {
-            var c2 = (t & 0x1F) << 6 | buffer[i++] & 0x3F;
-            str += c2 >= 0x80 ? String.fromCharCode(c2) : replacementChar;
-        } else if (t >= 0xE0 && t < 0xF0) {
-            var c3 = (t & 0xF) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;
-            str += c3 >= 0x800 ? String.fromCharCode(c3) : replacementChar;
-        } else if (t >= 0xF0) {
-            var t2 = (t & 7) << 18 | (buffer[i++] & 0x3F) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;
-            if (t2 < 0x10000 || t2 > 0x10FFFF)
-                str += replacementChar;
-            else {
-                t2 -= 0x10000;
-                str += String.fromCharCode(0xD800 + (t2 >> 10));
-                str += String.fromCharCode(0xDC00 + (t2 & 0x3FF));
-            }
-        }
-    }
-    return str;
-}
-
 function utf8_read_decoder(decoder, buffer, start, end) {
     var source = start === 0 && end === buffer.length
         ? buffer
@@ -8077,14 +8097,14 @@ utf8.read = function utf8_read_loose(buffer, start, end) {
         c7 = buffer[i + 6];
         c8 = buffer[i + 7];
         if ((c1 | c2 | c3 | c4 | c5 | c6 | c7 | c8) & 0x80)
-            return utf8_read_js(buffer, i, end, str);
+            return str + utf8_read_decoder(looseDecoder, 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 utf8_read_js(buffer, i, end, str);
+            return str + utf8_read_decoder(looseDecoder, buffer, i, end);
         str += String.fromCharCode(c1);
     }
 
@@ -8490,7 +8510,7 @@ function Writer() {
      * Backing buffer.
      * @type {Uint8Array}
      */
-    this.buf = this.constructor.alloc(64);
+    this.buf = this.constructor.alloc(Writer.initialBufferSize);
 
     /**
      * Cached DataView over {@link Writer#buf}.
@@ -8505,6 +8525,12 @@ function Writer() {
     this.states = null;
 }
 
+/**
+ * Initial backing buffer size in bytes. Defaults to 128.
+ * @type {number}
+ */
+Writer.initialBufferSize = 128;
+
 /**
  * Current write position.
  * @name Writer#len