@bufbuild/protobuf 1.2.0 → 1.3.0

package/dist/cjs/service-type.js

@@ -29,7 +29,7 @@ var MethodKind;
     MethodKind[MethodKind["ServerStreaming"] = 1] = "ServerStreaming";
     MethodKind[MethodKind["ClientStreaming"] = 2] = "ClientStreaming";
     MethodKind[MethodKind["BiDiStreaming"] = 3] = "BiDiStreaming";
-})(MethodKind = exports.MethodKind || (exports.MethodKind = {}));
+})(MethodKind || (exports.MethodKind = MethodKind = {}));
 /**
  * Is this method side-effect-free (or safe in HTTP parlance), or just
  * idempotent, or neither? HTTP based RPC implementation may choose GET verb
@@ -50,4 +50,4 @@ var MethodIdempotency;
      * Idempotent, but may have side effects.
      */
     MethodIdempotency[MethodIdempotency["Idempotent"] = 2] = "Idempotent";
-})(MethodIdempotency = exports.MethodIdempotency || (exports.MethodIdempotency = {}));
+})(MethodIdempotency || (exports.MethodIdempotency = MethodIdempotency = {}));

package/dist/cjs/to-plain-message.js

@@ -0,0 +1,67 @@
+"use strict";
+// Copyright 2021-2023 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPlainMessage = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-argument,no-case-declarations */
+const message_js_1 = require("./message.js");
+/**
+ * toPlainMessage returns a new object by striping
+ * all methods from a message, leaving only fields and
+ * oneof groups. It is recursive, meaning it applies this
+ * same logic to all nested message fields as well.
+ */
+function toPlainMessage(message) {
+    const type = message.getType();
+    const target = {};
+    for (const member of type.fields.byMember()) {
+        const source = message[member.localName];
+        let copy;
+        if (member.repeated) {
+            copy = source.map((e) => toPlainValue(e));
+        }
+        else if (member.kind == "map") {
+            copy = {};
+            for (const [key, v] of Object.entries(source)) {
+                copy[key] = toPlainValue(v);
+            }
+        }
+        else if (member.kind == "oneof") {
+            const f = member.findField(source.case);
+            copy = f
+                ? { case: source.case, value: toPlainValue(source.value) }
+                : { case: undefined };
+        }
+        else {
+            copy = toPlainValue(source);
+        }
+        target[member.localName] = copy;
+    }
+    return target;
+}
+exports.toPlainMessage = toPlainMessage;
+function toPlainValue(value) {
+    if (value === undefined) {
+        return value;
+    }
+    if (value instanceof message_js_1.Message) {
+        return toPlainMessage(value);
+    }
+    if (value instanceof Uint8Array) {
+        const c = new Uint8Array(value.byteLength);
+        c.set(value);
+        return c;
+    }
+    return value;
+}

package/dist/esm/codegen-info.js

@@ -39,6 +39,7 @@ export const codegenInfo = {
         JsonWriteOptions: { typeOnly: true, privateImportPath: "./json-format.js", publicImportPath: packageName },
         JsonValue: { typeOnly: true, privateImportPath: "./json-format.js", publicImportPath: packageName },
         JsonObject: { typeOnly: true, privateImportPath: "./json-format.js", publicImportPath: packageName },
+        protoDouble: { typeOnly: false, privateImportPath: "./proto-double.js", publicImportPath: packageName },
         protoInt64: { typeOnly: false, privateImportPath: "./proto-int64.js", publicImportPath: packageName },
         ScalarType: { typeOnly: false, privateImportPath: "./field.js", publicImportPath: packageName },
         MethodKind: { typeOnly: false, privateImportPath: "./service-type.js", publicImportPath: packageName },

package/dist/esm/create-descriptor-set.js

@@ -11,7 +11,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-import { FieldDescriptorProto_Label, FieldDescriptorProto_Type, FileDescriptorSet, MethodOptions_IdempotencyLevel, } from "./google/protobuf/descriptor_pb.js";
+import { FieldDescriptorProto_Label, FieldDescriptorProto_Type, FileDescriptorProto, FileDescriptorSet, MethodDescriptorProto, MethodOptions_IdempotencyLevel, ServiceDescriptorProto, SourceCodeInfo, } from "./google/protobuf/descriptor_pb.js";
 import { assert } from "./private/assert.js";
 import { ScalarType } from "./field.js";
 import { MethodIdempotency, MethodKind } from "./service-type.js";

package/dist/esm/google/protobuf/any_pb.js

@@ -43,7 +43,7 @@ import { proto3 } from "../../proto3.js";
  *       foo = any.unpack(Foo.getDefaultInstance());
  *     }
  *
- * Example 3: Pack and unpack a message in Python.
+ *  Example 3: Pack and unpack a message in Python.
  *
  *     foo = Foo(...)
  *     any = Any()
@@ -53,7 +53,7 @@ import { proto3 } from "../../proto3.js";
  *       any.Unpack(foo)
  *       ...
  *
- * Example 4: Pack and unpack a message in Go
+ *  Example 4: Pack and unpack a message in Go
  *
  *      foo := &pb.Foo{...}
  *      any, err := anypb.New(foo)
@@ -73,7 +73,7 @@ import { proto3 } from "../../proto3.js";
  * name "y.z".
  *
  * JSON
- *
+ * ====
  * The JSON representation of an `Any` value uses the regular
  * representation of the deserialized, embedded message, with an
  * additional field `@type` which contains the type URL. Example:

package/dist/esm/google/protobuf/api_pb.js

@@ -237,7 +237,7 @@ Method.fields = proto3.util.newFieldList(() => [
  * The mixin construct implies that all methods in `AccessControl` are
  * also declared with same name and request/response types in
  * `Storage`. A documentation generator or annotation processor will
- * see the effective `Storage.GetAcl` method after inheriting
+ * see the effective `Storage.GetAcl` method after inherting
  * documentation and annotations as follows:
  *
  *     service Storage {

package/dist/esm/google/protobuf/descriptor_pb.js

@@ -266,6 +266,15 @@ export class ExtensionRangeOptions extends Message {
          * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999;
          */
         this.uninterpretedOption = [];
+        /**
+         * go/protobuf-stripping-extension-declarations
+         * Like Metadata, but we use a repeated field to hold all extension
+         * declarations. This should avoid the size increases of transforming a large
+         * extension range into small ranges in generated binaries.
+         *
+         * @generated from field: repeated google.protobuf.ExtensionRangeOptions.Declaration declaration = 2;
+         */
+        this.declaration = [];
         proto2.util.initPartial(data, this);
     }
     static fromBinary(bytes, options) {
@@ -285,6 +294,62 @@ ExtensionRangeOptions.runtime = proto2;
 ExtensionRangeOptions.typeName = "google.protobuf.ExtensionRangeOptions";
 ExtensionRangeOptions.fields = proto2.util.newFieldList(() => [
     { no: 999, name: "uninterpreted_option", kind: "message", T: UninterpretedOption, repeated: true },
+    { no: 2, name: "declaration", kind: "message", T: ExtensionRangeOptions_Declaration, repeated: true },
+    { no: 3, name: "verification", kind: "enum", T: proto2.getEnumType(ExtensionRangeOptions_VerificationState), opt: true, default: ExtensionRangeOptions_VerificationState.UNVERIFIED },
+]);
+/**
+ * The verification state of the extension range.
+ *
+ * @generated from enum google.protobuf.ExtensionRangeOptions.VerificationState
+ */
+export var ExtensionRangeOptions_VerificationState;
+(function (ExtensionRangeOptions_VerificationState) {
+    /**
+     * All the extensions of the range must be declared.
+     *
+     * @generated from enum value: DECLARATION = 0;
+     */
+    ExtensionRangeOptions_VerificationState[ExtensionRangeOptions_VerificationState["DECLARATION"] = 0] = "DECLARATION";
+    /**
+     * @generated from enum value: UNVERIFIED = 1;
+     */
+    ExtensionRangeOptions_VerificationState[ExtensionRangeOptions_VerificationState["UNVERIFIED"] = 1] = "UNVERIFIED";
+})(ExtensionRangeOptions_VerificationState || (ExtensionRangeOptions_VerificationState = {}));
+// Retrieve enum metadata with: proto2.getEnumType(ExtensionRangeOptions_VerificationState)
+proto2.util.setEnumType(ExtensionRangeOptions_VerificationState, "google.protobuf.ExtensionRangeOptions.VerificationState", [
+    { no: 0, name: "DECLARATION" },
+    { no: 1, name: "UNVERIFIED" },
+]);
+/**
+ * @generated from message google.protobuf.ExtensionRangeOptions.Declaration
+ */
+export class ExtensionRangeOptions_Declaration extends Message {
+    constructor(data) {
+        super();
+        proto2.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new ExtensionRangeOptions_Declaration().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ExtensionRangeOptions_Declaration().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ExtensionRangeOptions_Declaration().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto2.util.equals(ExtensionRangeOptions_Declaration, a, b);
+    }
+}
+ExtensionRangeOptions_Declaration.runtime = proto2;
+ExtensionRangeOptions_Declaration.typeName = "google.protobuf.ExtensionRangeOptions.Declaration";
+ExtensionRangeOptions_Declaration.fields = proto2.util.newFieldList(() => [
+    { no: 1, name: "number", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true },
+    { no: 2, name: "full_name", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 3, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 4, name: "is_repeated", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
+    { no: 5, name: "reserved", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
+    { no: 6, name: "repeated", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
 ]);
 /**
  * Describes a field within a message.
@@ -812,6 +877,10 @@ MessageOptions.fields = proto2.util.newFieldList(() => [
 export class FieldOptions extends Message {
     constructor(data) {
         super();
+        /**
+         * @generated from field: repeated google.protobuf.FieldOptions.OptionTargetType targets = 19;
+         */
+        this.targets = [];
         /**
          * The parser stores options it doesn't recognize here. See above.
          *
@@ -846,6 +915,7 @@ FieldOptions.fields = proto2.util.newFieldList(() => [
     { no: 16, name: "debug_redact", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: false },
     { no: 17, name: "retention", kind: "enum", T: proto2.getEnumType(FieldOptions_OptionRetention), opt: true },
     { no: 18, name: "target", kind: "enum", T: proto2.getEnumType(FieldOptions_OptionTargetType), opt: true },
+    { no: 19, name: "targets", kind: "enum", T: proto2.getEnumType(FieldOptions_OptionTargetType), repeated: true },
     { no: 999, name: "uninterpreted_option", kind: "message", T: UninterpretedOption, repeated: true },
 ]);
 /**
@@ -860,6 +930,13 @@ export var FieldOptions_CType;
      */
     FieldOptions_CType[FieldOptions_CType["STRING"] = 0] = "STRING";
     /**
+     * The option [ctype=CORD] may be applied to a non-repeated field of type
+     * "bytes". It indicates that in C++, the data should be stored in a Cord
+     * instead of a string.  For very large strings, this may reduce memory
+     * fragmentation. It may also allow better performance when parsing from a
+     * Cord, or when parsing with aliasing enabled, as the parsed Cord may then
+     * alias the original buffer.
+     *
      * @generated from enum value: CORD = 1;
      */
     FieldOptions_CType[FieldOptions_CType["CORD"] = 1] = "CORD";

package/dist/esm/google/protobuf/field_mask_pb.js

@@ -265,7 +265,7 @@ export class FieldMask extends Message {
         }
         return this.paths.map(p => {
             if (p.match(/_[0-9]?_/g) || p.match(/[A-Z]/g)) {
-                throw new Error("cannot decode google.protobuf.FieldMask from JSON: lowerCamelCase of path name \"" + p + "\" is irreversible");
+                throw new Error("cannot encode google.protobuf.FieldMask to JSON: lowerCamelCase of path name \"" + p + "\" is irreversible");
             }
             return protoCamelCase(p);
         }).join(",");

package/dist/esm/google/protobuf/struct_pb.js

@@ -11,7 +11,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-// @generated by protoc-gen-es v1.2.0 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
+// @generated by protoc-gen-es v1.3.0 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
 // @generated from file google/protobuf/struct.proto (package google.protobuf, syntax proto3)
 /* eslint-disable */
 import { proto3 } from "../../proto3.js";
@@ -20,7 +20,7 @@ import { Message } from "../../message.js";
  * `NullValue` is a singleton enumeration to represent the null value for the
  * `Value` type union.
  *
- *  The JSON representation for `NullValue` is JSON `null`.
+ * The JSON representation for `NullValue` is JSON `null`.
  *
  * @generated from enum google.protobuf.NullValue
  */

package/dist/esm/google/protobuf/timestamp_pb.js

@@ -102,7 +102,7 @@ import { proto3 } from "../../proto3.js";
  * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
  * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
  * the Joda Time's [`ISODateTimeFormat.dateTime()`](
- * http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
+ * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
  * ) to obtain a formatter capable of generating timestamps in this format.
  *
  *

package/dist/esm/google/protobuf/type_pb.js

@@ -11,7 +11,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-// @generated by protoc-gen-es v1.2.0 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
+// @generated by protoc-gen-es v1.3.0 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
 // @generated from file google/protobuf/type.proto (package google.protobuf, syntax proto3)
 /* eslint-disable */
 import { proto3 } from "../../proto3.js";
@@ -37,11 +37,18 @@ export var Syntax;
      * @generated from enum value: SYNTAX_PROTO3 = 1;
      */
     Syntax[Syntax["PROTO3"] = 1] = "PROTO3";
+    /**
+     * Syntax `editions`.
+     *
+     * @generated from enum value: SYNTAX_EDITIONS = 2;
+     */
+    Syntax[Syntax["EDITIONS"] = 2] = "EDITIONS";
 })(Syntax || (Syntax = {}));
 // Retrieve enum metadata with: proto3.getEnumType(Syntax)
 proto3.util.setEnumType(Syntax, "google.protobuf.Syntax", [
     { no: 0, name: "SYNTAX_PROTO2" },
     { no: 1, name: "SYNTAX_PROTO3" },
+    { no: 2, name: "SYNTAX_EDITIONS" },
 ]);
 /**
  * A protocol buffer message type.
@@ -81,6 +88,12 @@ export class Type extends Message {
          * @generated from field: google.protobuf.Syntax syntax = 6;
          */
         this.syntax = Syntax.PROTO2;
+        /**
+         * The source edition string, only valid when syntax is SYNTAX_EDITIONS.
+         *
+         * @generated from field: string edition = 7;
+         */
+        this.edition = "";
         proto3.util.initPartial(data, this);
     }
     static fromBinary(bytes, options) {
@@ -105,6 +118,7 @@ Type.fields = proto3.util.newFieldList(() => [
     { no: 4, name: "options", kind: "message", T: Option, repeated: true },
     { no: 5, name: "source_context", kind: "message", T: SourceContext },
     { no: 6, name: "syntax", kind: "enum", T: proto3.getEnumType(Syntax) },
+    { no: 7, name: "edition", kind: "scalar", T: 9 /* ScalarType.STRING */ },
 ]);
 /**
  * A single field of a message type.
@@ -420,6 +434,12 @@ export class Enum extends Message {
          * @generated from field: google.protobuf.Syntax syntax = 5;
          */
         this.syntax = Syntax.PROTO2;
+        /**
+         * The source edition string, only valid when syntax is SYNTAX_EDITIONS.
+         *
+         * @generated from field: string edition = 6;
+         */
+        this.edition = "";
         proto3.util.initPartial(data, this);
     }
     static fromBinary(bytes, options) {
@@ -443,6 +463,7 @@ Enum.fields = proto3.util.newFieldList(() => [
     { no: 3, name: "options", kind: "message", T: Option, repeated: true },
     { no: 4, name: "source_context", kind: "message", T: SourceContext },
     { no: 5, name: "syntax", kind: "enum", T: proto3.getEnumType(Syntax) },
+    { no: 6, name: "edition", kind: "scalar", T: 9 /* ScalarType.STRING */ },
 ]);
 /**
  * Enum value definition.

package/dist/esm/index.js

@@ -13,20 +13,19 @@
 // limitations under the License.
 export { proto3 } from "./proto3.js";
 export { proto2 } from "./proto2.js";
+export { protoDouble } from "./proto-double.js";
 export { protoInt64 } from "./proto-int64.js";
 export { protoBase64 } from "./proto-base64.js";
 export { protoDelimited } from "./proto-delimited.js";
 export { codegenInfo } from "./codegen-info.js";
-export { Message, } from "./message.js";
+export { Message } from "./message.js";
 export { ScalarType } from "./field.js";
 export { MethodKind, MethodIdempotency } from "./service-type.js";
 export { WireType, BinaryWriter, BinaryReader } from "./binary-encoding.js";
-export {} from "./json-format.js";
-export {} from "./descriptor-set.js";
 export { createDescriptorSet } from "./create-descriptor-set.js";
-export {} from "./type-registry.js";
 export { createRegistry } from "./create-registry.js";
 export { createRegistryFromDescriptors } from "./create-registry-from-desc.js";
+export { toPlainMessage } from "./to-plain-message.js";
 // ideally, we would export these types with sub-path exports:
 export * from "./google/protobuf/compiler/plugin_pb.js";
 export * from "./google/protobuf/api_pb.js";

package/dist/esm/private/binary-format-common.js

@@ -11,7 +11,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-import { BinaryReader, BinaryWriter, WireType, } from "../binary-encoding.js";
+import { BinaryReader, BinaryWriter, WireType } from "../binary-encoding.js";
 import { Message } from "../message.js";
 import { ScalarType } from "../field.js";
 import { wrapField } from "./field-wrapper.js";
@@ -109,14 +109,14 @@ export function makeBinaryFormatCommon() {
                         const messageType = field.T;
                         if (repeated) {
                             // safe to assume presence of array, oneof cannot contain repeated values
-                            target[localName].push(messageType.fromBinary(reader.bytes(), options));
+                            target[localName].push(readMessageField(reader, new messageType(), options));
                         }
                         else {
                             if (target[localName] instanceof Message) {
-                                target[localName].fromBinary(reader.bytes(), options);
+                                readMessageField(reader, target[localName], options);
                             }
                             else {
-                                target[localName] = messageType.fromBinary(reader.bytes(), options);
+                                target[localName] = readMessageField(reader, new messageType(), options);
                                 if (messageType.fieldWrapper &&
                                     !field.oneof &&
                                     !field.repeated) {
@@ -135,6 +135,13 @@ export function makeBinaryFormatCommon() {
         },
     };
 }
+// Read a message, avoiding MessageType.fromBinary() to re-use the
+// BinaryReadOptions and the IBinaryReader.
+function readMessageField(reader, message, options) {
+    const format = message.getType().runtime.bin;
+    format.readMessage(message, reader, reader.uint32(), options);
+    return message;
+}
 // Read a map field, expecting key field = 1, value field = 2
 function readMapEntry(field, reader, options) {
     const length = reader.uint32(), end = reader.pos + length;
@@ -154,7 +161,7 @@ function readMapEntry(field, reader, options) {
                         val = reader.int32();
                         break;
                     case "message":
-                        val = field.V.T.fromBinary(reader.bytes(), options);
+                        val = readMessageField(reader, new field.V.T(), options);
                         break;
                 }
                 break;
@@ -185,9 +192,40 @@ function readMapEntry(field, reader, options) {
     }
     return [key, val];
 }
+// Does not use scalarTypeInfo() for better performance.
 function readScalar(reader, type) {
-    let [, method] = scalarTypeInfo(type);
-    return reader[method]();
+    switch (type) {
+        case ScalarType.STRING:
+            return reader.string();
+        case ScalarType.BOOL:
+            return reader.bool();
+        case ScalarType.DOUBLE:
+            return reader.double();
+        case ScalarType.FLOAT:
+            return reader.float();
+        case ScalarType.INT32:
+            return reader.int32();
+        case ScalarType.INT64:
+            return reader.int64();
+        case ScalarType.UINT64:
+            return reader.uint64();
+        case ScalarType.FIXED64:
+            return reader.fixed64();
+        case ScalarType.BYTES:
+            return reader.bytes();
+        case ScalarType.FIXED32:
+            return reader.fixed32();
+        case ScalarType.SFIXED32:
+            return reader.sfixed32();
+        case ScalarType.SFIXED64:
+            return reader.sfixed64();
+        case ScalarType.SINT64:
+            return reader.sint64();
+        case ScalarType.UINT32:
+            return reader.uint32();
+        case ScalarType.SINT32:
+            return reader.sint32();
+    }
 }
 export function writeMapEntry(writer, options, field, key, value) {
     writer.tag(field.no, WireType.LengthDelimited);

package/dist/esm/private/message-type.js

@@ -11,7 +11,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-import { Message, } from "../message.js";
+import { Message } from "../message.js";
 /**
  * Create a new message type using the given runtime.
  */

package/dist/esm/private/util-common.js

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { setEnumType } from "./enum.js";
-import { Message, } from "../message.js";
+import { Message } from "../message.js";
 import { ScalarType } from "../field.js";
 import { scalarEquals } from "./scalars.js";
 /* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-argument,no-case-declarations */

package/dist/esm/proto-base64.js

@@ -87,15 +87,7 @@ export const protoBase64 = {
         return bytes.subarray(0, bytePos);
     },
     /**
-     * Decodes a base64 string to a byte array.
-     *
-     * - ignores white-space, including line breaks and tabs
-     * - allows inner padding (can decode concatenated base64 strings)
-     * - does not require padding
-     * - understands base64url encoding:
-     *   "-" instead of "+",
-     *   "_" instead of "/",
-     *   no padding
+     * Encode a byte array to a base64 string.
      */
     enc(bytes) {
         let base64 = "", groupPos = 0, // position in base64 group
@@ -121,7 +113,7 @@ export const protoBase64 = {
                     break;
             }
         }
-        // padding required?
+        // add output padding
         if (groupPos) {
             base64 += encTable[p];
             base64 += "=";

package/dist/esm/proto-delimited.js

@@ -72,28 +72,23 @@ export const protoDelimited = {
             }
             let buffer = new Uint8Array(0);
             try {
-                for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = yield __await(iterable_1.next()), _a = iterable_1_1.done, !_a;) {
+                for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = yield __await(iterable_1.next()), _a = iterable_1_1.done, !_a; _d = true) {
                     _c = iterable_1_1.value;
                     _d = false;
-                    try {
-                        const chunk = _c;
-                        buffer = append(buffer, chunk);
-                        for (;;) {
-                            const size = protoDelimited.peekSize(buffer);
-                            if (size.eof) {
-                                // size is incomplete, buffer more data
-                                break;
-                            }
-                            if (size.offset + size.size > buffer.byteLength) {
-                                // message is incomplete, buffer more data
-                                break;
-                            }
-                            yield yield __await(protoDelimited.dec(type, buffer));
-                            buffer = buffer.subarray(size.offset + size.size);
+                    const chunk = _c;
+                    buffer = append(buffer, chunk);
+                    for (;;) {
+                        const size = protoDelimited.peekSize(buffer);
+                        if (size.eof) {
+                            // size is incomplete, buffer more data
+                            break;
                         }
-                    }
-                    finally {
-                        _d = true;
+                        if (size.offset + size.size > buffer.byteLength) {
+                            // message is incomplete, buffer more data
+                            break;
+                        }
+                        yield yield __await(protoDelimited.dec(type, buffer));
+                        buffer = buffer.subarray(size.offset + size.size);
                     }
                 }
             }

package/dist/esm/proto-double.js

@@ -0,0 +1,26 @@
+// Copyright 2021-2023 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// Export global Number constants. This is done so that we can safely use
+// these global constants when generating code and be assured we're using
+// the correct values. We cannot rely on globalThis since we support ES2017
+// and globalThis was introduced in ES2020. We also don't want to explicitly
+// generate code using, for example, Number.NaN, since this could clash with
+// a message name of Number. Instead we can export them here since this will
+// be in a different scope as the generated code and we are guaranteed to use
+// the intended global values.
+export const protoDouble = {
+    NaN: Number.NaN,
+    POSITIVE_INFINITY: Number.POSITIVE_INFINITY,
+    NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
+};

package/dist/esm/proto-int64.js

@@ -16,7 +16,7 @@ import { int64FromString, int64ToString, uInt64ToString, } from "./google/varint
 function makeInt64Support() {
     const dv = new DataView(new ArrayBuffer(8));
     // note that Safari 14 implements BigInt, but not the DataView methods
-    const ok = globalThis.BigInt !== undefined &&
+    const ok = typeof BigInt === "function" &&
         typeof dv.getBigInt64 === "function" &&
         typeof dv.getBigUint64 === "function" &&
         typeof dv.setBigInt64 === "function" &&