@bufbuild/protobuf 0.0.6 → 0.0.9

package/dist/esm/legacy-type-registry.js

@@ -0,0 +1,100 @@
+// Copyright 2021-2022 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.
+/**
+ * @deprecated use createRegistry() instead
+ *
+ * TypeRegistry is a simple registry for all message, enum, or service types.
+ */
+export class TypeRegistry {
+    constructor() {
+        this.messages = {};
+        this.enums = {};
+        this.services = {};
+    }
+    /**
+     * Find a message type by its protobuf type name.
+     */
+    findMessage(typeName) {
+        return this.messages[typeName];
+    }
+    /**
+     * Find an enum type by its protobuf type name.
+     */
+    findEnum(typeName) {
+        return this.enums[typeName];
+    }
+    /**
+     * Find a service type by its protobuf type name.
+     */
+    findService(typeName) {
+        return this.services[typeName];
+    }
+    /**
+     * Create a new TypeRegistry from the given types.
+     */
+    static from(...types) {
+        const registry = new TypeRegistry();
+        for (const type of types) {
+            registry.add(type);
+        }
+        return registry;
+    }
+    /**
+     * @deprecated use TypeRegistry.from()
+     */
+    static fromIterable(types) {
+        return TypeRegistry.from(...types);
+    }
+    /**
+     * @deprecated use TypeRegistry.from()
+     */
+    static fromTypes(...types) {
+        return TypeRegistry.from(...types);
+    }
+    /**
+     * Add a type to the registry. For messages, the types used in message
+     * fields are added recursively. For services, the message types used
+     * for requests and responses are added recursively.
+     */
+    add(type) {
+        if ("fields" in type) {
+            if (!this.findMessage(type.typeName)) {
+                this.messages[type.typeName] = type;
+                for (const field of type.fields.list()) {
+                    if (field.kind == "message") {
+                        this.add(field.T);
+                    }
+                    else if (field.kind == "map" && field.V.kind == "message") {
+                        this.add(field.V.T);
+                    }
+                    else if (field.kind == "enum") {
+                        this.add(field.T);
+                    }
+                }
+            }
+        }
+        else if ("methods" in type) {
+            if (!this.findService(type.typeName)) {
+                this.services[type.typeName] = type;
+                for (const method of Object.values(type.methods)) {
+                    this.add(method.I);
+                    this.add(method.O);
+                }
+            }
+        }
+        else {
+            this.enums[type.typeName] = type;
+        }
+    }
+}

package/dist/esm/message.js

@@ -81,8 +81,9 @@ export class Message {
      * Serialize the message to a JSON string.
      */
     toJsonString(options) {
+        var _a;
         const value = this.toJson(options);
-        return JSON.stringify(value, null, options?.prettySpaces ?? 0);
+        return JSON.stringify(value, null, (_a = options === null || options === void 0 ? void 0 : options.prettySpaces) !== null && _a !== void 0 ? _a : 0);
     }
     /**
      * Retrieve the MessageType of this message - a singleton that represents

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

@@ -29,17 +29,18 @@ const writeDefaults = {
     writerFactory: () => new BinaryWriter(),
 };
 function makeReadOptions(options) {
-    return options ? { ...readDefaults, ...options } : readDefaults;
+    return options ? Object.assign(Object.assign({}, readDefaults), options) : readDefaults;
 }
 function makeWriteOptions(options) {
-    return options ? { ...writeDefaults, ...options } : writeDefaults;
+    return options ? Object.assign(Object.assign({}, writeDefaults), options) : writeDefaults;
 }
 export function makeBinaryFormatCommon() {
     return {
         makeReadOptions,
         makeWriteOptions,
         listUnknownFields(message) {
-            return message[unknownFieldsSymbol] ?? [];
+            var _a;
+            return (_a = message[unknownFieldsSymbol]) !== null && _a !== void 0 ? _a : [];
         },
         discardUnknownFields(message) {
             delete message[unknownFieldsSymbol];

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

@@ -15,9 +15,7 @@ import { ScalarType } from "../field.js";
 import { makeBinaryFormatCommon, writeMapEntry, writeMessageField, writePacked, writeScalar, } from "./binary-format-common.js";
 /* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unnecessary-condition, @typescript-eslint/strict-boolean-expressions, no-case-declarations, prefer-const */
 export function makeBinaryFormatProto2() {
-    return {
-        ...makeBinaryFormatCommon(),
-        writeMessage(message, writer, options) {
+    return Object.assign(Object.assign({}, makeBinaryFormatCommon()), { writeMessage(message, writer, options) {
             const type = message.getType();
             let field;
             try {
@@ -81,7 +79,7 @@ export function makeBinaryFormatProto2() {
             }
             catch (e) {
                 let m = field
-                    ? `cannot encode field ${type.typeName}.${field?.name} to binary`
+                    ? `cannot encode field ${type.typeName}.${field === null || field === void 0 ? void 0 : field.name} to binary`
                     : `cannot encode message ${type.typeName} to binary`;
                 let r = e instanceof Error ? e.message : String(e);
                 throw new Error(m + (r.length > 0 ? `: ${r}` : ""));
@@ -90,6 +88,5 @@ export function makeBinaryFormatProto2() {
                 this.writeUnknownFields(message, writer);
             }
             return writer;
-        },
-    };
+        } });
 }

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

@@ -15,9 +15,7 @@ import { ScalarType } from "../field.js";
 import { makeBinaryFormatCommon, writeMapEntry, writeMessageField, writePacked, writeScalar, } from "./binary-format-common.js";
 /* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unnecessary-condition, @typescript-eslint/strict-boolean-expressions, prefer-const, no-case-declarations */
 export function makeBinaryFormatProto3() {
-    return {
-        ...makeBinaryFormatCommon(),
-        writeMessage(message, writer, options) {
+    return Object.assign(Object.assign({}, makeBinaryFormatCommon()), { writeMessage(message, writer, options) {
             const type = message.getType();
             for (const field of type.fields.byNumber()) {
                 let value, // this will be our field value, whether it is member of a oneof or regular field
@@ -73,6 +71,5 @@ export function makeBinaryFormatProto3() {
                 this.writeUnknownFields(message, writer);
             }
             return writer;
-        },
-    };
+        } });
 }

package/dist/esm/private/enum.js

@@ -27,35 +27,30 @@ export function getEnumType(enumObject) {
 /**
  * Sets reflection information on a generated enum.
  */
-export function setEnumType(enumObject, typeName, values
-// We do not surface options at this time
-// opt?: {
-// options?: { readonly [extensionName: string]: JsonValue };
-// },
-) {
+export function setEnumType(enumObject, typeName, values, opt) {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-    enumObject[enumTypeSymbol] = makeEnumType(typeName, values);
+    enumObject[enumTypeSymbol] = makeEnumType(typeName, values.map((v) => ({
+        no: v.no,
+        name: v.name,
+        localName: enumObject[v.no],
+    })), opt);
 }
-// We do not surface options at this time
-// export type PartialEnumValue = Omit<EnumValueInfo, 'options'> & Partial<Pick<EnumValueInfo, "options">>;
 /**
  * Create a new EnumType with the given values.
  */
-export function makeEnumType(typeName, values
-// We do not surface options at this time
-// opt?: {
-// options?: { readonly [extensionName: string]: JsonValue };
-// },
-) {
+export function makeEnumType(typeName, values, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_opt) {
     const names = Object.create(null);
     const numbers = Object.create(null);
     const normalValues = [];
     for (const value of values) {
         // We do not surface options at this time
         // const value: EnumValueInfo = {...v, options: v.options ?? emptyReadonlyObject};
-        normalValues.push(value);
-        names[value.name] = value;
-        numbers[value.no] = value;
+        const n = normalizeEnumValue(value);
+        normalValues.push(n);
+        names[value.name] = n;
+        numbers[value.no] = n;
     }
     return {
         typeName,
@@ -72,25 +67,21 @@ export function makeEnumType(typeName, values
 }
 /**
  * Create a new enum object with the given values.
+ * Sets reflection information.
  */
 export function makeEnum(typeName, values, opt) {
     const enumObject = {};
     for (const value of values) {
-        const name = makeEnumValueName(value, opt?.sharedPrefix);
-        enumObject[name] = value.no;
-        enumObject[value.no] = name;
+        const n = normalizeEnumValue(value);
+        enumObject[n.localName] = n.no;
+        enumObject[n.no] = n.localName;
     }
-    setEnumType(enumObject, typeName, values);
+    setEnumType(enumObject, typeName, values, opt);
     return enumObject;
 }
-// Construct a local name for an enum value.
-// This logic matches the Go function with the same name in private/protoplugin/names.go
-function makeEnumValueName(value, sharedPrefix) {
-    if (sharedPrefix === undefined) {
-        return value.name;
+function normalizeEnumValue(value) {
+    if ("localName" in value) {
+        return value;
     }
-    if (!value.name.startsWith(sharedPrefix)) {
-        return value.name;
-    }
-    return value.name.substring(sharedPrefix.length);
+    return Object.assign(Object.assign({}, value), { localName: value.name });
 }

package/dist/esm/private/field-wrapper.js

@@ -11,6 +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 { ScalarType } from "../field.js";
 /**
  * Wrap field values whose message type has a wrapper.
  */
@@ -29,3 +30,30 @@ export function wrapField(type, value) {
 export function unwrapField(type, value) {
     return type.fieldWrapper ? type.fieldWrapper.unwrapField(value) : value;
 }
+/**
+ * If the given field uses one of the well-known wrapper types, return
+ * the base type it wraps.
+ */
+export function getUnwrappedFieldType(field) {
+    if (field.kind !== "message_field") {
+        return undefined;
+    }
+    if (field.repeated) {
+        return undefined;
+    }
+    if (field.oneof != undefined) {
+        return undefined;
+    }
+    return wktWrapperToScalarType[field.message.typeName];
+}
+const wktWrapperToScalarType = {
+    "google.protobuf.DoubleValue": ScalarType.DOUBLE,
+    "google.protobuf.FloatValue": ScalarType.FLOAT,
+    "google.protobuf.Int64Value": ScalarType.INT64,
+    "google.protobuf.UInt64Value": ScalarType.UINT64,
+    "google.protobuf.Int32Value": ScalarType.INT32,
+    "google.protobuf.UInt32Value": ScalarType.UINT32,
+    "google.protobuf.BoolValue": ScalarType.BOOL,
+    "google.protobuf.StringValue": ScalarType.STRING,
+    "google.protobuf.BytesValue": ScalarType.BYTES,
+};

package/dist/esm/private/field.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 { makeOneofName } from "./names.js";
+import { localOneofName } from "./names.js";
 import { assert } from "./assert.js";
 export class InternalOneofInfo {
     constructor(name) {
@@ -22,7 +22,7 @@ export class InternalOneofInfo {
         this.default = undefined;
         this.fields = [];
         this.name = name;
-        this.localName = makeOneofName(name);
+        this.localName = localOneofName(name);
     }
     addField(field) {
         assert(field.oneof === this, `field ${field.name} not one of ${this.name}`);

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

@@ -29,10 +29,10 @@ const jsonWriteDefaults = {
     prettySpaces: 0,
 };
 function makeReadOptions(options) {
-    return options ? { ...jsonReadDefaults, ...options } : jsonReadDefaults;
+    return options ? Object.assign(Object.assign({}, jsonReadDefaults), options) : jsonReadDefaults;
 }
 function makeWriteOptions(options) {
-    return options ? { ...jsonWriteDefaults, ...options } : jsonWriteDefaults;
+    return options ? Object.assign(Object.assign({}, jsonWriteDefaults), options) : jsonWriteDefaults;
 }
 export function makeJsonFormatCommon(makeWriteField) {
     const writeField = makeWriteField(writeEnum, writeScalar);
@@ -43,7 +43,7 @@ export function makeJsonFormatCommon(makeWriteField) {
             if (json == null || Array.isArray(json) || typeof json != "object") {
                 throw new Error(`cannot decode message ${type.typeName} from JSON: ${this.debug(json)}`);
             }
-            message = message ?? new type();
+            message = message !== null && message !== void 0 ? message : new type();
             const oneofSeen = {};
             for (const [jsonKey, jsonValue] of Object.entries(json)) {
                 const field = type.fields.findJsonName(jsonKey);
@@ -382,13 +382,14 @@ function readEnum(type, json, ignoreUnknownFields) {
         case "string":
             const value = type.findName(json);
             if (value || ignoreUnknownFields) {
-                return value?.no;
+                return value === null || value === void 0 ? void 0 : value.no;
             }
             break;
     }
     throw new Error(`cannot decode enum ${type.typeName} from JSON: ${debugJsonValue(json)}`);
 }
 function writeEnum(type, value, emitIntrinsicDefault, enumAsInteger) {
+    var _a;
     if (value === undefined) {
         return value;
     }
@@ -403,7 +404,7 @@ function writeEnum(type, value, emitIntrinsicDefault, enumAsInteger) {
         return null;
     }
     const val = type.findNumber(value);
-    return val?.name ?? value; // if we don't know the enum value, just return the number
+    return (_a = val === null || val === void 0 ? void 0 : val.name) !== null && _a !== void 0 ? _a : value; // if we don't know the enum value, just return the number
 }
 function writeScalar(type, value, emitIntrinsicDefault) {
     if (value === undefined) {

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

@@ -16,7 +16,8 @@ import { Message, } from "../message.js";
  * Create a new message type using the given runtime.
  */
 export function makeMessageType(runtime, typeName, fields, opt) {
-    const localName = opt?.localName ?? typeName.substring(typeName.lastIndexOf(".") + 1);
+    var _a;
+    const localName = (_a = opt === null || opt === void 0 ? void 0 : opt.localName) !== null && _a !== void 0 ? _a : typeName.substring(typeName.lastIndexOf(".") + 1);
     const type = {
         [localName]: function (data) {
             runtime.util.initFields(this);

package/dist/esm/private/names.js

@@ -12,38 +12,113 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 /**
- * Returns the JSON name for a protobuf field, exactly like protoc does.
+ * Returns the name of a protobuf element in generated code.
+ *
+ * Field names - including oneofs - are converted to lowerCamelCase. For
+ * messages, enumerations and services, the package name is stripped from
+ * the type name. For nested messages and enumerations, the names are joined
+ * with an underscore. For methods, the first character is made lowercase.
  */
-export function makeJsonName(protoName) {
-    return protoCamelCase(protoName);
+export function localName(desc) {
+    switch (desc.kind) {
+        case "enum_field":
+        case "message_field":
+        case "map_field":
+        case "scalar_field":
+            return localFieldName(desc.name, desc.oneof !== undefined);
+        case "oneof":
+            return localOneofName(desc.name);
+        case "enum":
+        case "message":
+        case "service": {
+            const pkg = desc.file.proto.package;
+            const offset = pkg === undefined ? 0 : pkg.length + 1;
+            const name = desc.typeName.substring(offset).replace(/\./g, "_");
+            if (reservedIdent[name]) {
+                return name + "$";
+            }
+            return name;
+        }
+        case "enum_value": {
+            const sharedPrefix = desc.parent.sharedPrefix;
+            if (sharedPrefix === undefined) {
+                return desc.name;
+            }
+            const name = desc.name.substring(sharedPrefix.length);
+            if (reservedObjectProperties[name]) {
+                return name + "$";
+            }
+            return name;
+        }
+        case "rpc": {
+            let name = desc.name;
+            if (name.length == 0) {
+                return name;
+            }
+            name = name[0].toLowerCase() + name.substring(1);
+            if (reservedObjectProperties[name]) {
+                return name + "$";
+            }
+            return name;
+        }
+    }
 }
 /**
- * Returns the local name of a field, exactly like protoc-gen-es does.
+ * Returns the name of a field in generated code.
  */
-export function makeFieldName(protoName, inOneof) {
-    const n = protoCamelCase(protoName);
+export function localFieldName(protoName, inOneof) {
+    let name = protoCamelCase(protoName);
     if (inOneof) {
-        return n;
+        // oneof member names are not properties, but values of the `case` property.
+        return name;
     }
-    return rProp[n] ? n + escapeChar : n;
+    if (reservedObjectProperties[name] || reservedMessageProperties[name]) {
+        name = name + "$";
+    }
+    return name;
 }
 /**
- * Returns the local name of a oneof group, exactly like protoc-gen-es does.
+ * Returns the name of a oneof group in generated code.
  */
-export function makeOneofName(protoName) {
-    return makeFieldName(protoName, false);
+export function localOneofName(protoName) {
+    return localFieldName(protoName, false);
 }
 /**
- * Returns the local name of a rpc, exactly like protoc-gen-es does.
+ * Returns the JSON name for a protobuf field, exactly like protoc does.
  */
-export function makeMethodName(protoName) {
-    if (protoName.length == 0) {
-        return protoName;
+export const fieldJsonName = protoCamelCase;
+/**
+ * Finds a prefix shared by enum values, for example `MY_ENUM_` for
+ * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`.
+ */
+export function findEnumSharedPrefix(enumName, valueNames) {
+    const prefix = camelToSnakeCase(enumName) + "_";
+    for (const name of valueNames) {
+        if (!name.toLowerCase().startsWith(prefix)) {
+            return undefined;
+        }
+        const shortName = name.substring(prefix.length);
+        if (shortName.length == 0) {
+            return undefined;
+        }
+        if (/^\d/.test(shortName)) {
+            // identifiers must not start with numbers
+            return undefined;
+        }
     }
-    return protoName[0].toLowerCase() + protoName.substring(1);
+    return prefix;
+}
+/**
+ * Converts lowerCamelCase or UpperCamelCase into lower_snake_case.
+ * This is used to find shared prefixes in an enum.
+ */
+function camelToSnakeCase(camel) {
+    return (camel.substring(0, 1) + camel.substring(1).replace(/[A-Z]/g, (c) => "_" + c)).toLowerCase();
 }
-// Converts snake_case to protoCamelCase according to the convention
-// used by protoc to convert a field name to a JSON name.
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ */
 function protoCamelCase(snakeCase) {
     let capNext = false;
     const b = [];
@@ -77,17 +152,81 @@ function protoCamelCase(snakeCase) {
     }
     return b.join("");
 }
-// escapeChar must be appended to a reserved name.
-// We choose '$' because it is invalid in proto identifiers.
-const escapeChar = "$";
-// Names that cannot be used for object properties.
-// See buf_es/protoc-gen-es/internal/protoplugin/names.go
-const rProp = {
+// Names that cannot be used for identifiers, such as class names,
+// but _can_ be used for object properties.
+const reservedIdent = {
+    // ECMAScript 2015 keywords
+    break: true,
+    case: true,
+    catch: true,
+    class: true,
+    const: true,
+    continue: true,
+    debugger: true,
+    default: true,
+    delete: true,
+    do: true,
+    else: true,
+    export: true,
+    extends: true,
+    false: true,
+    finally: true,
+    for: true,
+    function: true,
+    if: true,
+    import: true,
+    in: true,
+    instanceof: true,
+    new: true,
+    null: true,
+    return: true,
+    super: true,
+    switch: true,
+    this: true,
+    throw: true,
+    true: true,
+    try: true,
+    typeof: true,
+    var: true,
+    void: true,
+    while: true,
+    with: true,
+    yield: true,
+    // ECMAScript 2015 future reserved keywords
+    enum: true,
+    implements: true,
+    interface: true,
+    let: true,
+    package: true,
+    private: true,
+    protected: true,
+    public: true,
+    static: true,
+    // Class name cannot be 'Object' when targeting ES5 with module CommonJS
+    Object: true,
+    // TypeScript keywords that cannot be used for types (as opposed to variables)
+    bigint: true,
+    number: true,
+    boolean: true,
+    string: true,
+    object: true,
+    // Identifiers reserved for the runtime, so we can generate legible code
+    globalThis: true,
+    Uint8Array: true,
+    Partial: true,
+};
+// Names that cannot be used for object properties because they are reserved
+// by built-in JavaScript properties.
+const reservedObjectProperties = {
     // names reserved by JavaScript
     constructor: true,
     toString: true,
     toJSON: true,
     valueOf: true,
+};
+// Names that cannot be used for object properties because they are reserved
+// by the runtime.
+const reservedMessageProperties = {
     // names reserved by the runtime
     getType: true,
     clone: true,

package/dist/esm/proto-int64.js

@@ -15,7 +15,7 @@ import { int64fromString, int64toString } from "./google/varint.js";
 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 && // eslint-disable-line @typescript-eslint/no-unnecessary-condition -- conditional for BigInt is very much necessary
+    const ok = globalThis.BigInt !== undefined &&
         typeof dv.getBigInt64 === "function" &&
         typeof dv.getBigUint64 === "function" &&
         typeof dv.setBigInt64 === "function" &&

package/dist/esm/proto2.js

@@ -16,14 +16,12 @@ import { makeBinaryFormatProto2 } from "./private/binary-format-proto2.js";
 import { makeUtilCommon } from "./private/util-common.js";
 import { InternalFieldList } from "./private/field-list.js";
 import { InternalOneofInfo } from "./private/field.js";
-import { makeFieldName, makeJsonName } from "./private/names.js";
+import { localFieldName, fieldJsonName } from "./private/names.js";
 import { makeJsonFormatProto2 } from "./private/json-format-proto2.js";
 /**
  * Provides functionality for messages defined with the proto2 syntax.
  */
-export const proto2 = makeProtoRuntime("proto2", makeJsonFormatProto2(), makeBinaryFormatProto2(), {
-    ...makeUtilCommon(),
-    newFieldList(fields) {
+export const proto2 = makeProtoRuntime("proto2", makeJsonFormatProto2(), makeBinaryFormatProto2(), Object.assign(Object.assign({}, makeUtilCommon()), { newFieldList(fields) {
         return new InternalFieldList(fields, normalizeFieldInfosProto2);
     },
     initFields(target) {
@@ -52,21 +50,21 @@ export const proto2 = makeProtoRuntime("proto2", makeJsonFormatProto2(), makeBin
                     break;
             }
         }
-    },
-});
+    } }));
 /* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
 function normalizeFieldInfosProto2(fieldInfos) {
+    var _a, _b, _c;
     const r = [];
     let o;
     for (const field of typeof fieldInfos == "function"
         ? fieldInfos()
         : fieldInfos) {
         const f = field;
-        f.localName = makeFieldName(field.name, field.oneof !== undefined);
-        f.jsonName = field.jsonName ?? makeJsonName(field.name);
-        f.repeated = field.repeated ?? false;
+        f.localName = localFieldName(field.name, field.oneof !== undefined);
+        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : fieldJsonName(field.name);
+        f.repeated = (_b = field.repeated) !== null && _b !== void 0 ? _b : false;
         // In contrast to proto3, repeated fields are unpacked except when explicitly specified.
-        f.packed = field.packed ?? false;
+        f.packed = (_c = field.packed) !== null && _c !== void 0 ? _c : false;
         // We do not surface options at this time
         // f.options = field.options ?? emptyReadonlyObject;
         if (field.oneof !== undefined) {