@bufbuild/protobuf 1.4.2 → 1.5.1

package/dist/cjs/binary-encoding.d.ts

@@ -25,13 +25,12 @@ export declare enum WireType {
      */
     LengthDelimited = 2,
     /**
-     * Used for groups
-     * @deprecated
+     * Start of a tag-delimited aggregate, such as a proto2 group, or a message
+     * in editions with message_encoding = DELIMITED.
      */
     StartGroup = 3,
     /**
-     * Used for groups
-     * @deprecated
+     * End of a tag-delimited aggregate.
      */
     EndGroup = 4,
     /**

package/dist/cjs/binary-encoding.js

@@ -46,13 +46,12 @@ var WireType;
      */
     WireType[WireType["LengthDelimited"] = 2] = "LengthDelimited";
     /**
-     * Used for groups
-     * @deprecated
+     * Start of a tag-delimited aggregate, such as a proto2 group, or a message
+     * in editions with message_encoding = DELIMITED.
      */
     WireType[WireType["StartGroup"] = 3] = "StartGroup";
     /**
-     * Used for groups
-     * @deprecated
+     * End of a tag-delimited aggregate.
      */
     WireType[WireType["EndGroup"] = 4] = "EndGroup";
     /**

package/dist/cjs/binary-format.d.ts

@@ -16,8 +16,17 @@ export interface BinaryFormat {
     makeWriteOptions(options?: Partial<BinaryWriteOptions>): Readonly<BinaryWriteOptions>;
     /**
      * Parse a message from binary data, merging fields.
+     *
+     * Supports two message encodings:
+     * - length-prefixed: delimitedMessageEncoding is false or omitted, and
+     *   lengthOrEndTagFieldNo is the expected length of the message in the reader.
+     * - delimited: delimitedMessageEncoding is true, and lengthOrEndTagFieldNo is
+     *   the field number in a tag with wire type end-group signalling the end of
+     *   the message in the reader.
+     *
+     * delimitedMessageEncoding is optional for backwards compatibility.
      */
-    readMessage(message: Message, reader: IBinaryReader, length: number, options: BinaryReadOptions): void;
+    readMessage(message: Message, reader: IBinaryReader, lengthOrEndTagFieldNo: number, options: BinaryReadOptions, delimitedMessageEncoding?: boolean): void;
     /**
      * Serialize a message to binary data.
      */

package/dist/cjs/create-descriptor-set.d.ts

@@ -1,5 +1,4 @@
-import type { FieldDescriptorProto } from "./google/protobuf/descriptor_pb.js";
-import { FileDescriptorProto, FileDescriptorSet } from "./google/protobuf/descriptor_pb.js";
+import { FeatureSetDefaults, FileDescriptorProto, FileDescriptorSet } from "./google/protobuf/descriptor_pb.js";
 import type { DescriptorSet } from "./descriptor-set.js";
 /**
  * Create a DescriptorSet, a convenient interface for working with a set of
@@ -9,8 +8,23 @@ import type { DescriptorSet } from "./descriptor-set.js";
  * before any file that imports it. Protocol buffer compilers always produce
  * files in topological order.
  */
-export declare function createDescriptorSet(input: FileDescriptorProto[] | FileDescriptorSet | Uint8Array): DescriptorSet;
+export declare function createDescriptorSet(input: FileDescriptorProto[] | FileDescriptorSet | Uint8Array, options?: CreateDescriptorSetOptions): DescriptorSet;
 /**
- * Get the default `packed` state of a repeated field.
+ * Options to createDescriptorSet()
  */
-export declare function isPackedFieldByDefault(proto: FieldDescriptorProto, syntax: "proto2" | "proto3"): boolean;
+interface CreateDescriptorSetOptions {
+    /**
+     * Editions support language-specific features with extensions to
+     * google.protobuf.FeatureSet. They can define defaults, and specify on
+     * which targets the features can be set.
+     *
+     * To create a DescriptorSet that provides your language-specific features,
+     * you have to provide a google.protobuf.FeatureSetDefaults message in this
+     * option.
+     *
+     * The defaults can be generated with `protoc` - see the flag
+     * `--experimental_edition_defaults_out`.
+     */
+    featureSetDefaults?: FeatureSetDefaults;
+}
+export {};

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

@@ -13,13 +13,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPackedFieldByDefault = exports.createDescriptorSet = void 0;
+exports.createDescriptorSet = void 0;
 const descriptor_pb_js_1 = require("./google/protobuf/descriptor_pb.js");
 const assert_js_1 = require("./private/assert.js");
 const field_js_1 = require("./field.js");
 const service_type_js_1 = require("./service-type.js");
 const names_js_1 = require("./private/names.js");
-const proto_int64_js_1 = require("./proto-int64.js");
+const text_format_js_1 = require("./private/text-format.js");
+const feature_set_js_1 = require("./private/feature-set.js");
 /**
  * Create a DescriptorSet, a convenient interface for working with a set of
  * google.protobuf.FileDescriptorProto.
@@ -28,13 +29,15 @@ const proto_int64_js_1 = require("./proto-int64.js");
  * before any file that imports it. Protocol buffer compilers always produce
  * files in topological order.
  */
-function createDescriptorSet(input) {
+function createDescriptorSet(input, options) {
+    var _a;
     const cart = {
         enums: new Map(),
         messages: new Map(),
         services: new Map(),
         extensions: new Map(),
         mapEntries: new Map(),
+        resolveFeatures: (0, feature_set_js_1.createFeatureResolver)((_a = options === null || options === void 0 ? void 0 : options.featureSetDefaults) !== null && _a !== void 0 ? _a : feature_set_js_1.featureSetDefaults),
     };
     const fileDescriptors = input instanceof descriptor_pb_js_1.FileDescriptorSet
         ? input.file
@@ -49,20 +52,9 @@ exports.createDescriptorSet = createDescriptorSet;
  * Create a descriptor for a file.
  */
 function newFile(proto, cart) {
-    var _a, _b, _c;
+    var _a, _b;
     (0, assert_js_1.assert)(proto.name, `invalid FileDescriptorProto: missing name`);
-    (0, assert_js_1.assert)(proto.syntax === undefined || proto.syntax === "proto3", `invalid FileDescriptorProto: unsupported syntax: ${(_a = proto.syntax) !== null && _a !== void 0 ? _a : "undefined"}`);
-    const file = {
-        kind: "file",
-        proto,
-        deprecated: (_c = (_b = proto.options) === null || _b === void 0 ? void 0 : _b.deprecated) !== null && _c !== void 0 ? _c : false,
-        syntax: proto.syntax === "proto3" ? "proto3" : "proto2",
-        name: proto.name.replace(/\.proto/, ""),
-        enums: [],
-        messages: [],
-        extensions: [],
-        services: [],
-        toString() {
+    const file = Object.assign(Object.assign({ kind: "file", proto, deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false }, parseFileSyntax(proto.syntax, proto.edition)), { name: proto.name.replace(/\.proto/, ""), enums: [], messages: [], extensions: [], services: [], toString() {
             // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
             return `file ${this.proto.name}`;
         },
@@ -76,7 +68,10 @@ function newFile(proto, cart) {
                 FieldNumber.FileDescriptorProto_Package,
             ]);
         },
-    };
+        getFeatures() {
+            var _a;
+            return cart.resolveFeatures(this.edition, (_a = this.proto.options) === null || _a === void 0 ? void 0 : _a.features);
+        } });
     cart.mapEntries.clear(); // map entries are local to the file, we can safely discard
     for (const enumProto of proto.enumType) {
         addEnum(enumProto, file, undefined, cart);
@@ -129,7 +124,7 @@ function addExtensions(desc, cart) {
  * Recurses into nested types.
  */
 function addFields(message, cart) {
-    const allOneofs = message.proto.oneofDecl.map((proto) => newOneof(proto, message));
+    const allOneofs = message.proto.oneofDecl.map((proto) => newOneof(proto, message, cart));
     const oneofsSeen = new Set();
     for (const proto of message.proto.field) {
         const oneof = findOneof(proto, allOneofs);
@@ -186,6 +181,11 @@ function addEnum(proto, file, parent, cart) {
                 ];
             return findComments(file.proto.sourceCodeInfo, path);
         },
+        getFeatures() {
+            var _a, _b, _c;
+            const parentFeatures = (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getFeatures()) !== null && _b !== void 0 ? _b : this.file.getFeatures();
+            return cart.resolveFeatures(this.file.edition, parentFeatures, (_c = this.proto.options) === null || _c === void 0 ? void 0 : _c.features);
+        },
     };
     cart.enums.set(desc.typeName, desc);
     proto.value.forEach((proto) => {
@@ -218,6 +218,10 @@ function addEnum(proto, file, parent, cart) {
                 ];
                 return findComments(file.proto.sourceCodeInfo, path);
             },
+            getFeatures() {
+                var _a;
+                return cart.resolveFeatures(this.parent.file.edition, this.parent.getFeatures(), (_a = this.proto.options) === null || _a === void 0 ? void 0 : _a.features);
+            },
         });
     });
     ((_c = parent === null || parent === void 0 ? void 0 : parent.nestedEnums) !== null && _c !== void 0 ? _c : file.enums).push(desc);
@@ -259,6 +263,11 @@ function addMessage(proto, file, parent, cart) {
                 ];
             return findComments(file.proto.sourceCodeInfo, path);
         },
+        getFeatures() {
+            var _a, _b, _c;
+            const parentFeatures = (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getFeatures()) !== null && _b !== void 0 ? _b : this.file.getFeatures();
+            return cart.resolveFeatures(this.file.edition, parentFeatures, (_c = this.proto.options) === null || _c === void 0 ? void 0 : _c.features);
+        },
     };
     if (((_c = proto.options) === null || _c === void 0 ? void 0 : _c.mapEntry) === true) {
         cart.mapEntries.set(desc.typeName, desc);
@@ -299,6 +308,10 @@ function addService(proto, file, cart) {
             ];
             return findComments(file.proto.sourceCodeInfo, path);
         },
+        getFeatures() {
+            var _a;
+            return cart.resolveFeatures(this.file.edition, this.file.getFeatures(), (_a = this.proto.options) === null || _a === void 0 ? void 0 : _a.features);
+        },
     };
     file.services.push(desc);
     cart.services.set(desc.typeName, desc);
@@ -366,12 +379,16 @@ function newMethod(proto, parent, cart) {
             ];
             return findComments(parent.file.proto.sourceCodeInfo, path);
         },
+        getFeatures() {
+            var _a;
+            return cart.resolveFeatures(this.parent.file.edition, this.parent.getFeatures(), (_a = this.proto.options) === null || _a === void 0 ? void 0 : _a.features);
+        },
     };
 }
 /**
  * Create a descriptor for a oneof group.
  */
-function newOneof(proto, parent) {
+function newOneof(proto, parent, cart) {
     (0, assert_js_1.assert)(proto.name, `invalid OneofDescriptorProto: missing name`);
     return {
         kind: "oneof",
@@ -391,17 +408,20 @@ function newOneof(proto, parent) {
             ];
             return findComments(parent.file.proto.sourceCodeInfo, path);
         },
+        getFeatures() {
+            var _a;
+            return cart.resolveFeatures(this.parent.file.edition, this.parent.getFeatures(), (_a = this.proto.options) === null || _a === void 0 ? void 0 : _a.features);
+        },
     };
 }
 /**
  * Create a descriptor for a field.
  */
 function newField(proto, file, parent, oneof, cart) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c;
     (0, assert_js_1.assert)(proto.name, `invalid FieldDescriptorProto: missing name`);
     (0, assert_js_1.assert)(proto.number, `invalid FieldDescriptorProto: missing number`);
     (0, assert_js_1.assert)(proto.type, `invalid FieldDescriptorProto: missing type`);
-    const packedByDefault = isPackedFieldByDefault(proto, file.syntax);
     const common = {
         proto,
         deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
@@ -410,8 +430,8 @@ function newField(proto, file, parent, oneof, cart) {
         parent,
         oneof,
         optional: isOptionalField(proto, file.syntax),
-        packed: (_d = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.packed) !== null && _d !== void 0 ? _d : packedByDefault,
-        packedByDefault,
+        packedByDefault: isPackedFieldByDefault(file, proto, cart.resolveFeatures),
+        packed: isPackedField(file, parent, proto, cart.resolveFeatures),
         jsonName: proto.jsonName === (0, names_js_1.fieldJsonName)(proto.name) ? undefined : proto.jsonName,
         scalar: undefined,
         longType: undefined,
@@ -419,11 +439,11 @@ function newField(proto, file, parent, oneof, cart) {
         enum: undefined,
         mapKey: undefined,
         mapValue: undefined,
+        declarationString,
+        // toString, getComments, getFeatures are overridden in newExtension
         toString() {
-            // note that newExtension() calls us with parent = null
             return `field ${this.parent.typeName}.${this.name}`;
         },
-        declarationString,
         getComments() {
             const path = [
                 ...this.parent.getComments().sourcePath,
@@ -432,6 +452,10 @@ function newField(proto, file, parent, oneof, cart) {
             ];
             return findComments(file.proto.sourceCodeInfo, path);
         },
+        getFeatures() {
+            var _a;
+            return cart.resolveFeatures(file.edition, this.parent.getFeatures(), (_a = this.proto.options) === null || _a === void 0 ? void 0 : _a.features);
+        },
     };
     const repeated = proto.label === descriptor_pb_js_1.FieldDescriptorProto_Label.REPEATED;
     switch (proto.type) {
@@ -460,7 +484,7 @@ function newField(proto, file, parent, oneof, cart) {
             (0, assert_js_1.assert)(scalar, `invalid FieldDescriptorProto: unknown type ${proto.type}`);
             return Object.assign(Object.assign({}, common), { kind: "field", fieldKind: "scalar", getDefaultValue,
                 repeated,
-                scalar, longType: ((_e = proto.options) === null || _e === void 0 ? void 0 : _e.jstype) == descriptor_pb_js_1.FieldOptions_JSType.JS_STRING
+                scalar, longType: ((_c = proto.options) === null || _c === void 0 ? void 0 : _c.jstype) == descriptor_pb_js_1.FieldOptions_JSType.JS_STRING
                     ? field_js_1.LongType.STRING
                     : field_js_1.LongType.BIGINT });
         }
@@ -478,6 +502,8 @@ function newExtension(proto, file, parent, cart) {
     return Object.assign(Object.assign({}, field), { kind: "extension", typeName: makeTypeName(proto, parent, file), parent,
         file,
         extendee,
+        // Must override toString, getComments, getFeatures from newField, because we
+        // call newField with parent undefined.
         toString() {
             return `extension ${this.typeName}`;
         },
@@ -493,8 +519,56 @@ function newExtension(proto, file, parent, cart) {
                     this.file.proto.extension.indexOf(proto),
                 ];
             return findComments(file.proto.sourceCodeInfo, path);
+        },
+        getFeatures() {
+            var _a, _b;
+            return cart.resolveFeatures(this.file.edition, ((_a = this.parent) !== null && _a !== void 0 ? _a : this.file).getFeatures(), (_b = this.proto.options) === null || _b === void 0 ? void 0 : _b.features);
         } });
 }
+/**
+ * Parse the "syntax" and "edition" fields, stripping test editions.
+ */
+function parseFileSyntax(syntax, edition) {
+    let e;
+    let s;
+    switch (syntax) {
+        case undefined:
+        case "proto2":
+            s = "proto2";
+            e = descriptor_pb_js_1.Edition.EDITION_PROTO2;
+            break;
+        case "proto3":
+            s = "proto3";
+            e = descriptor_pb_js_1.Edition.EDITION_PROTO3;
+            break;
+        case "editions":
+            s = "editions";
+            switch (edition) {
+                case undefined:
+                case descriptor_pb_js_1.Edition.EDITION_1_TEST_ONLY:
+                case descriptor_pb_js_1.Edition.EDITION_2_TEST_ONLY:
+                case descriptor_pb_js_1.Edition.EDITION_99997_TEST_ONLY:
+                case descriptor_pb_js_1.Edition.EDITION_99998_TEST_ONLY:
+                case descriptor_pb_js_1.Edition.EDITION_99999_TEST_ONLY:
+                case descriptor_pb_js_1.Edition.EDITION_UNKNOWN:
+                    e = descriptor_pb_js_1.Edition.EDITION_UNKNOWN;
+                    break;
+                default:
+                    e = edition;
+                    break;
+            }
+            break;
+        default:
+            throw new Error(`invalid FileDescriptorProto: unsupported syntax: ${syntax}`);
+    }
+    if (syntax === "editions" && edition === descriptor_pb_js_1.Edition.EDITION_UNKNOWN) {
+        throw new Error(`invalid FileDescriptorProto: syntax ${syntax} cannot have edition ${String(edition)}`);
+    }
+    return {
+        syntax: s,
+        edition: e,
+    };
+}
 /**
  * Create a fully qualified name for a protobuf type or extension field.
  *
@@ -592,42 +666,66 @@ function isOptionalField(proto, syntax) {
                 proto.label === descriptor_pb_js_1.FieldDescriptorProto_Label.OPTIONAL);
         case "proto3":
             return proto.proto3Optional === true;
+        case "editions":
+            return false;
     }
 }
 /**
- * Get the default `packed` state of a repeated field.
+ * Is this field packed by default? Only valid for repeated enum fields, and
+ * for repeated scalar fields except BYTES and STRING.
+ *
+ * In proto3 syntax, fields are packed by default. In proto2 syntax, fields
+ * are unpacked by default. With editions, the default is whatever the edition
+ * specifies as a default. In edition 2023, fields are packed by default.
  */
-function isPackedFieldByDefault(proto, syntax) {
-    (0, assert_js_1.assert)(proto.type, `invalid FieldDescriptorProto: missing type`);
-    if (syntax === "proto3") {
-        switch (proto.type) {
-            case descriptor_pb_js_1.FieldDescriptorProto_Type.DOUBLE:
-            case descriptor_pb_js_1.FieldDescriptorProto_Type.FLOAT:
-            case descriptor_pb_js_1.FieldDescriptorProto_Type.INT64:
-            case descriptor_pb_js_1.FieldDescriptorProto_Type.UINT64:
-            case descriptor_pb_js_1.FieldDescriptorProto_Type.INT32:
-            case descriptor_pb_js_1.FieldDescriptorProto_Type.FIXED64:
-            case descriptor_pb_js_1.FieldDescriptorProto_Type.FIXED32:
-            case descriptor_pb_js_1.FieldDescriptorProto_Type.UINT32:
-            case descriptor_pb_js_1.FieldDescriptorProto_Type.SFIXED32:
-            case descriptor_pb_js_1.FieldDescriptorProto_Type.SFIXED64:
-            case descriptor_pb_js_1.FieldDescriptorProto_Type.SINT32:
-            case descriptor_pb_js_1.FieldDescriptorProto_Type.SINT64:
-            case descriptor_pb_js_1.FieldDescriptorProto_Type.BOOL:
-            case descriptor_pb_js_1.FieldDescriptorProto_Type.ENUM:
-                // From the proto3 language guide:
-                // > In proto3, repeated fields of scalar numeric types are packed by default.
-                // This information is incomplete - according to the conformance tests, BOOL
-                // and ENUM are packed by default as well. This means only STRING and BYTES
-                // are not packed by default, which makes sense because they are length-delimited.
-                return true;
-            default:
-                return false;
-        }
+function isPackedFieldByDefault(file, proto, resolveFeatures) {
+    const { repeatedFieldEncoding } = resolveFeatures(file.edition);
+    if (repeatedFieldEncoding != descriptor_pb_js_1.FeatureSet_RepeatedFieldEncoding.PACKED) {
+        return false;
+    }
+    // From the proto3 language guide:
+    // > In proto3, repeated fields of scalar numeric types are packed by default.
+    // This information is incomplete - according to the conformance tests, BOOL
+    // and ENUM are packed by default as well. This means only STRING and BYTES
+    // are not packed by default, which makes sense because they are length-delimited.
+    switch (proto.type) {
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.STRING:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.BYTES:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.GROUP:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.MESSAGE:
+            return false;
+        default:
+            return true;
+    }
+}
+/**
+ * Pack this repeated field?
+ *
+ * Respects field type, proto2/proto3 defaults and the `packed` option, or
+ * edition defaults and the edition features.repeated_field_encoding options.
+ */
+function isPackedField(file, parent, proto, resolveFeatures) {
+    var _a, _b, _c, _d, _e, _f;
+    switch (proto.type) {
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.STRING:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.BYTES:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.GROUP:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.MESSAGE:
+            // length-delimited types cannot be packed
+            return false;
+        default:
+            switch (file.edition) {
+                case descriptor_pb_js_1.Edition.EDITION_PROTO2:
+                    return (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.packed) !== null && _b !== void 0 ? _b : false;
+                case descriptor_pb_js_1.Edition.EDITION_PROTO3:
+                    return (_d = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.packed) !== null && _d !== void 0 ? _d : true;
+                default: {
+                    const { repeatedFieldEncoding } = resolveFeatures(file.edition, (_e = parent === null || parent === void 0 ? void 0 : parent.getFeatures()) !== null && _e !== void 0 ? _e : file.getFeatures(), (_f = proto.options) === null || _f === void 0 ? void 0 : _f.features);
+                    return (repeatedFieldEncoding == descriptor_pb_js_1.FeatureSet_RepeatedFieldEncoding.PACKED);
+                }
+            }
     }
-    return false;
 }
-exports.isPackedFieldByDefault = isPackedFieldByDefault;
 /**
  * Map from a compiler-generated field type to our ScalarType, which is a
  * subset of field types declared by protobuf enum google.protobuf.FieldDescriptorProto.
@@ -784,175 +882,11 @@ function getDefaultValue() {
         return undefined;
     }
     switch (this.fieldKind) {
-        case "enum": {
-            const enumValue = this.enum.values.find((v) => v.name === d);
-            (0, assert_js_1.assert)(enumValue, `cannot parse ${this.toString()} default value: ${d}`);
-            return enumValue.number;
-        }
+        case "enum":
+            return (0, text_format_js_1.parseTextFormatEnumValue)(this.enum, d);
         case "scalar":
-            switch (this.scalar) {
-                case field_js_1.ScalarType.STRING:
-                    return d;
-                case field_js_1.ScalarType.BYTES: {
-                    const u = unescapeBytesDefaultValue(d);
-                    if (u === false) {
-                        throw new Error(`cannot parse ${this.toString()} default value: ${d}`);
-                    }
-                    return u;
-                }
-                case field_js_1.ScalarType.INT64:
-                case field_js_1.ScalarType.SFIXED64:
-                case field_js_1.ScalarType.SINT64:
-                    return proto_int64_js_1.protoInt64.parse(d);
-                case field_js_1.ScalarType.UINT64:
-                case field_js_1.ScalarType.FIXED64:
-                    return proto_int64_js_1.protoInt64.uParse(d);
-                case field_js_1.ScalarType.DOUBLE:
-                case field_js_1.ScalarType.FLOAT:
-                    switch (d) {
-                        case "inf":
-                            return Number.POSITIVE_INFINITY;
-                        case "-inf":
-                            return Number.NEGATIVE_INFINITY;
-                        case "nan":
-                            return Number.NaN;
-                        default:
-                            return parseFloat(d);
-                    }
-                case field_js_1.ScalarType.BOOL:
-                    return d === "true";
-                case field_js_1.ScalarType.INT32:
-                case field_js_1.ScalarType.UINT32:
-                case field_js_1.ScalarType.SINT32:
-                case field_js_1.ScalarType.FIXED32:
-                case field_js_1.ScalarType.SFIXED32:
-                    return parseInt(d, 10);
-            }
-            break;
+            return (0, text_format_js_1.parseTextFormatScalarValue)(this.scalar, d);
         default:
             return undefined;
     }
 }
-/**
- * Parses a text-encoded default value (proto2) of a BYTES field.
- */
-function unescapeBytesDefaultValue(str) {
-    const b = [];
-    const input = {
-        tail: str,
-        c: "",
-        next() {
-            if (this.tail.length == 0) {
-                return false;
-            }
-            this.c = this.tail[0];
-            this.tail = this.tail.substring(1);
-            return true;
-        },
-        take(n) {
-            if (this.tail.length >= n) {
-                const r = this.tail.substring(0, n);
-                this.tail = this.tail.substring(n);
-                return r;
-            }
-            return false;
-        },
-    };
-    while (input.next()) {
-        switch (input.c) {
-            case "\\":
-                if (input.next()) {
-                    switch (input.c) {
-                        case "\\":
-                            b.push(input.c.charCodeAt(0));
-                            break;
-                        case "b":
-                            b.push(0x08);
-                            break;
-                        case "f":
-                            b.push(0x0c);
-                            break;
-                        case "n":
-                            b.push(0x0a);
-                            break;
-                        case "r":
-                            b.push(0x0d);
-                            break;
-                        case "t":
-                            b.push(0x09);
-                            break;
-                        case "v":
-                            b.push(0x0b);
-                            break;
-                        case "0":
-                        case "1":
-                        case "2":
-                        case "3":
-                        case "4":
-                        case "5":
-                        case "6":
-                        case "7": {
-                            const s = input.c;
-                            const t = input.take(2);
-                            if (t === false) {
-                                return false;
-                            }
-                            const n = parseInt(s + t, 8);
-                            if (isNaN(n)) {
-                                return false;
-                            }
-                            b.push(n);
-                            break;
-                        }
-                        case "x": {
-                            const s = input.c;
-                            const t = input.take(2);
-                            if (t === false) {
-                                return false;
-                            }
-                            const n = parseInt(s + t, 16);
-                            if (isNaN(n)) {
-                                return false;
-                            }
-                            b.push(n);
-                            break;
-                        }
-                        case "u": {
-                            const s = input.c;
-                            const t = input.take(4);
-                            if (t === false) {
-                                return false;
-                            }
-                            const n = parseInt(s + t, 16);
-                            if (isNaN(n)) {
-                                return false;
-                            }
-                            const chunk = new Uint8Array(4);
-                            const view = new DataView(chunk.buffer);
-                            view.setInt32(0, n, true);
-                            b.push(chunk[0], chunk[1], chunk[2], chunk[3]);
-                            break;
-                        }
-                        case "U": {
-                            const s = input.c;
-                            const t = input.take(8);
-                            if (t === false) {
-                                return false;
-                            }
-                            const tc = proto_int64_js_1.protoInt64.uEnc(s + t);
-                            const chunk = new Uint8Array(8);
-                            const view = new DataView(chunk.buffer);
-                            view.setInt32(0, tc.lo, true);
-                            view.setInt32(4, tc.hi, true);
-                            b.push(chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6], chunk[7]);
-                            break;
-                        }
-                    }
-                }
-                break;
-            default:
-                b.push(input.c.charCodeAt(0));
-        }
-    }
-    return new Uint8Array(b);
-}

package/dist/cjs/create-registry-from-desc.js

@@ -234,6 +234,7 @@ function makeMessageFieldInfo(field, resolver) {
         name: field.name,
         jsonName: field.jsonName,
         T: messageType,
+        delimited: field.proto.type == descriptor_pb_js_1.FieldDescriptorProto_Type.GROUP,
     };
     if (field.repeated) {
         return Object.assign(Object.assign({}, base), { repeated: true, packed: field.packed, oneof: undefined });