@bufbuild/protobuf 1.9.0 → 2.0.0-alpha.1

package/dist/cjs/reflect/registry.js

@@ -0,0 +1,870 @@
+"use strict";
+// Copyright 2021-2024 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.maximumEdition = exports.minimumEdition = exports.createFileRegistry = exports.createRegistry = void 0;
+const assert_js_1 = require("./assert.js");
+const text_format_js_1 = require("../wire/text-format.js");
+const scalar_js_1 = require("./scalar.js");
+const nested_types_js_1 = require("./nested-types.js");
+const unsafe_js_1 = require("./unsafe.js");
+/**
+ * Create a registry from the given inputs.
+ *
+ * An input can be:
+ * - Any message, enum, service, or extension descriptor, which adds just the
+ *   descriptor for this type.
+ * - A file descriptor, which adds all typed defined in this file.
+ * - A registry, which adds all types from the registry.
+ *
+ * For duplicate descriptors (same type name), the one given last wins.
+ */
+function createRegistry(...input) {
+    const reg = createMutableRegistry();
+    for (const i of input) {
+        switch (i.kind) {
+            case "registry":
+                for (const n of i) {
+                    reg.add(n);
+                }
+                break;
+            case "file":
+                for (const n of (0, nested_types_js_1.nestedTypes)(i)) {
+                    reg.add(n);
+                }
+                break;
+            default:
+                reg.add(i);
+                break;
+        }
+    }
+    return reg;
+}
+exports.createRegistry = createRegistry;
+function createFileRegistry(...args) {
+    const registry = createMutableRegistry();
+    if ("$typeName" in args[0] &&
+        args[0].$typeName == "google.protobuf.FileDescriptorSet") {
+        for (const file of args[0].file) {
+            addFile(file, registry);
+        }
+        return registry;
+    }
+    if ("$typeName" in args[0]) {
+        const input = args[0];
+        const resolve = args[1];
+        const seen = new Set();
+        // eslint-disable-next-line no-inner-declarations
+        function recurseDeps(file) {
+            const deps = [];
+            for (const protoFileName of file.dependency) {
+                if (registry.getFile(protoFileName) != undefined) {
+                    continue;
+                }
+                if (seen.has(protoFileName)) {
+                    continue;
+                }
+                const dep = resolve(protoFileName);
+                if (!dep) {
+                    throw new Error(`Unable to resolve ${protoFileName}, imported by ${file.name}`);
+                }
+                if ("kind" in dep) {
+                    addDescFile(dep, registry);
+                }
+                else {
+                    seen.add(dep.name);
+                    deps.push(dep);
+                }
+            }
+            return [...deps, ...deps.flatMap((dep) => recurseDeps(dep))];
+        }
+        for (const file of [input, ...recurseDeps(input)].reverse()) {
+            addFile(file, registry);
+        }
+    }
+    else {
+        for (const fileReg of args) {
+            for (const file of fileReg.files) {
+                registry.add(file);
+                for (const type of (0, nested_types_js_1.nestedTypes)(file)) {
+                    registry.add(type);
+                }
+            }
+        }
+    }
+    return registry;
+}
+exports.createFileRegistry = createFileRegistry;
+/**
+ * Create a mutable file registry.
+ * @private
+ */
+function createMutableRegistry() {
+    const types = new Map();
+    const extendees = new Map();
+    const files = new Map();
+    return {
+        kind: "registry",
+        [Symbol.iterator]() {
+            return types.values();
+        },
+        get files() {
+            return files.values();
+        },
+        add(desc) {
+            switch (desc.kind) {
+                case "file":
+                    files.set(desc.proto.name, desc);
+                    break;
+                // @ts-expect-error TS7029
+                case "extension":
+                    // eslint-disable-next-line no-case-declarations
+                    let numberToExt = extendees.get(desc.extendee.typeName);
+                    if (!numberToExt) {
+                        extendees.set(desc.extendee.typeName, (numberToExt = new Map()));
+                    }
+                    numberToExt.set(desc.number, desc);
+                // eslint-disable-next-line no-fallthrough
+                default:
+                    types.set(desc.typeName, desc);
+            }
+        },
+        remove(desc) {
+            switch (desc.kind) {
+                case "file":
+                    files.delete(desc.proto.name);
+                    break;
+                default:
+                    types.delete(desc.typeName);
+            }
+        },
+        get(typeName) {
+            return types.get(typeName);
+        },
+        getFile(fileName) {
+            return files.get(fileName);
+        },
+        getMessage(typeName) {
+            const t = types.get(typeName);
+            return (t === null || t === void 0 ? void 0 : t.kind) == "message" ? t : undefined;
+        },
+        getEnum(typeName) {
+            const t = types.get(typeName);
+            return (t === null || t === void 0 ? void 0 : t.kind) == "enum" ? t : undefined;
+        },
+        getExtension(typeName) {
+            const t = types.get(typeName);
+            return (t === null || t === void 0 ? void 0 : t.kind) == "extension" ? t : undefined;
+        },
+        getExtensionFor(extendee, no) {
+            var _a;
+            return (_a = extendees.get(extendee.typeName)) === null || _a === void 0 ? void 0 : _a.get(no);
+        },
+        getService(typeName) {
+            const t = types.get(typeName);
+            return (t === null || t === void 0 ? void 0 : t.kind) == "service" ? t : undefined;
+        },
+    };
+}
+/**
+ * Add the file descriptor and the types it contains to the registry.
+ */
+function addDescFile(file, reg) {
+    reg.add(file);
+    for (const type of (0, nested_types_js_1.nestedTypes)(file)) {
+        reg.add(type);
+    }
+    for (const dep of file.dependencies) {
+        addDescFile(dep, reg);
+    }
+}
+// bootstrap-inject google.protobuf.Edition.EDITION_PROTO2: const $name: Edition.$localName = $number;
+const EDITION_PROTO2 = 998;
+// bootstrap-inject google.protobuf.Edition.EDITION_PROTO3: const $name: Edition.$localName = $number;
+const EDITION_PROTO3 = 999;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_STRING: const $name: FieldDescriptorProto_Type.$localName = $number;
+const TYPE_STRING = 9;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_GROUP: const $name: FieldDescriptorProto_Type.$localName = $number;
+const TYPE_GROUP = 10;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_MESSAGE: const $name: FieldDescriptorProto_Type.$localName = $number;
+const TYPE_MESSAGE = 11;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_BYTES: const $name: FieldDescriptorProto_Type.$localName = $number;
+const TYPE_BYTES = 12;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_ENUM: const $name: FieldDescriptorProto_Type.$localName = $number;
+const TYPE_ENUM = 14;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Label.LABEL_REPEATED: const $name: FieldDescriptorProto_Label.$localName = $number;
+const LABEL_REPEATED = 3;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Label.LABEL_OPTIONAL: const $name: FieldDescriptorProto_Label.$localName = $number;
+const LABEL_OPTIONAL = 1;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Label.LABEL_REQUIRED: const $name: FieldDescriptorProto_Label.$localName = $number;
+const LABEL_REQUIRED = 2;
+// bootstrap-inject google.protobuf.FieldOptions.JSType.JS_STRING: const $name: FieldOptions_JSType.$localName = $number;
+const JS_STRING = 1;
+// bootstrap-inject google.protobuf.MethodOptions.IdempotencyLevel.IDEMPOTENCY_UNKNOWN: const $name: MethodOptions_IdempotencyLevel.$localName = $number;
+const IDEMPOTENCY_UNKNOWN = 0;
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.EXPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number;
+const EXPLICIT = 1;
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number;
+const LEGACY_REQUIRED = 3;
+// bootstrap-inject google.protobuf.FeatureSet.RepeatedFieldEncoding.PACKED: const $name: FeatureSet_RepeatedFieldEncoding.$localName = $number;
+const PACKED = 1;
+// bootstrap-inject google.protobuf.FeatureSet.MessageEncoding.DELIMITED: const $name: FeatureSet_MessageEncoding.$localName = $number;
+const DELIMITED = 2;
+// bootstrap-inject google.protobuf.FeatureSet.EnumType.OPEN: const $name: FeatureSet_EnumType.$localName = $number;
+const OPEN = 1;
+// prettier-ignore
+// bootstrap-inject defaults: EDITION_PROTO2 to EDITION_2023: export const minimumEdition: SupportedEdition = $minimumEdition, maximumEdition: SupportedEdition = $maximumEdition;
+// generated from protoc v27.0-rc1
+exports.minimumEdition = 998, exports.maximumEdition = 1000;
+const featureDefaults = {
+    // EDITION_PROTO2
+    998: {
+        fieldPresence: 1, // EXPLICIT,
+        enumType: 2, // CLOSED,
+        repeatedFieldEncoding: 2, // EXPANDED,
+        utf8Validation: 3, // NONE,
+        messageEncoding: 1, // LENGTH_PREFIXED,
+        jsonFormat: 2, // LEGACY_BEST_EFFORT,
+    },
+    // EDITION_PROTO3
+    999: {
+        fieldPresence: 2, // IMPLICIT,
+        enumType: 1, // OPEN,
+        repeatedFieldEncoding: 1, // PACKED,
+        utf8Validation: 2, // VERIFY,
+        messageEncoding: 1, // LENGTH_PREFIXED,
+        jsonFormat: 1, // ALLOW,
+    },
+    // EDITION_2023
+    1000: {
+        fieldPresence: 1, // EXPLICIT,
+        enumType: 1, // OPEN,
+        repeatedFieldEncoding: 1, // PACKED,
+        utf8Validation: 2, // VERIFY,
+        messageEncoding: 1, // LENGTH_PREFIXED,
+        jsonFormat: 1, // ALLOW,
+    },
+};
+/**
+ * Create a descriptor for a file, add it to the registry.
+ */
+function addFile(proto, reg) {
+    var _a, _b;
+    const file = {
+        kind: "file",
+        proto,
+        deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+        edition: getFileEdition(proto),
+        name: proto.name.replace(/\.proto/, ""),
+        dependencies: findFileDependencies(proto, reg),
+        enums: [],
+        messages: [],
+        extensions: [],
+        services: [],
+        toString() {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+            return `file ${this.proto.name}`;
+        },
+    };
+    const mapEntriesStore = new Map();
+    const mapEntries = {
+        get(typeName) {
+            return mapEntriesStore.get(typeName);
+        },
+        add(desc) {
+            var _a;
+            (0, assert_js_1.assert)(((_a = desc.proto.options) === null || _a === void 0 ? void 0 : _a.mapEntry) === true);
+            mapEntriesStore.set(desc.typeName, desc);
+        },
+    };
+    for (const enumProto of proto.enumType) {
+        addEnum(enumProto, file, undefined, reg);
+    }
+    for (const messageProto of proto.messageType) {
+        addMessage(messageProto, file, undefined, reg, mapEntries);
+    }
+    for (const serviceProto of proto.service) {
+        addService(serviceProto, file, reg);
+    }
+    addExtensions(file, reg);
+    for (const mapEntry of mapEntriesStore.values()) {
+        // to create a map field, we need access to the map entry's fields
+        addFields(mapEntry, reg, mapEntries);
+    }
+    for (const message of file.messages) {
+        addFields(message, reg, mapEntries);
+        addExtensions(message, reg);
+    }
+    reg.add(file);
+}
+/**
+ * Create descriptors for extensions, and add them to the message / file,
+ * and to our cart.
+ * Recurses into nested types.
+ */
+function addExtensions(desc, reg) {
+    switch (desc.kind) {
+        case "file":
+            for (const proto of desc.proto.extension) {
+                const ext = newField(proto, desc, reg);
+                desc.extensions.push(ext);
+                reg.add(ext);
+            }
+            break;
+        case "message":
+            for (const proto of desc.proto.extension) {
+                const ext = newField(proto, desc, reg);
+                desc.nestedExtensions.push(ext);
+                reg.add(ext);
+            }
+            for (const message of desc.nestedMessages) {
+                addExtensions(message, reg);
+            }
+            break;
+    }
+}
+/**
+ * Create descriptors for fields and oneof groups, and add them to the message.
+ * Recurses into nested types.
+ */
+function addFields(message, reg, mapEntries) {
+    const allOneofs = message.proto.oneofDecl.map((proto) => newOneof(proto, message));
+    const oneofsSeen = new Set();
+    for (const proto of message.proto.field) {
+        const oneof = findOneof(proto, allOneofs);
+        const field = newField(proto, message, reg, oneof, mapEntries);
+        message.fields.push(field);
+        if (oneof === undefined) {
+            message.members.push(field);
+        }
+        else {
+            oneof.fields.push(field);
+            if (!oneofsSeen.has(oneof)) {
+                oneofsSeen.add(oneof);
+                message.members.push(oneof);
+            }
+        }
+    }
+    for (const oneof of allOneofs.filter((o) => oneofsSeen.has(o))) {
+        message.oneofs.push(oneof);
+    }
+    for (const child of message.nestedMessages) {
+        addFields(child, reg, mapEntries);
+    }
+}
+/**
+ * Create a descriptor for an enumeration, and add it our cart and to the
+ * parent type, if any.
+ */
+function addEnum(proto, file, parent, reg) {
+    var _a, _b, _c;
+    const desc = {
+        kind: "enum",
+        proto,
+        deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+        file,
+        parent,
+        open: true,
+        name: proto.name,
+        typeName: makeTypeName(proto, parent, file),
+        values: [],
+        sharedPrefix: findEnumSharedPrefix(proto.name, proto.value.map((v) => v.name)),
+        toString() {
+            return `enum ${this.typeName}`;
+        },
+    };
+    desc.open = isEnumOpen(desc);
+    reg.add(desc);
+    proto.value.forEach((proto) => {
+        var _a, _b;
+        desc.values.push({
+            kind: "enum_value",
+            proto,
+            deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+            parent: desc,
+            name: proto.name,
+            number: proto.number,
+            toString() {
+                return `enum value ${desc.typeName}.${this.name}`;
+            },
+        });
+    });
+    ((_c = parent === null || parent === void 0 ? void 0 : parent.nestedEnums) !== null && _c !== void 0 ? _c : file.enums).push(desc);
+}
+/**
+ * Create a descriptor for a message, including nested types, and add it to our
+ * cart. Note that this does not create descriptors fields.
+ */
+function addMessage(proto, file, parent, reg, mapEntries) {
+    var _a, _b, _c, _d;
+    const desc = {
+        kind: "message",
+        proto,
+        deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+        file,
+        parent,
+        name: proto.name,
+        typeName: makeTypeName(proto, parent, file),
+        fields: [],
+        oneofs: [],
+        members: [],
+        nestedEnums: [],
+        nestedMessages: [],
+        nestedExtensions: [],
+        toString() {
+            return `message ${this.typeName}`;
+        },
+    };
+    if (((_c = proto.options) === null || _c === void 0 ? void 0 : _c.mapEntry) === true) {
+        mapEntries.add(desc);
+    }
+    else {
+        ((_d = parent === null || parent === void 0 ? void 0 : parent.nestedMessages) !== null && _d !== void 0 ? _d : file.messages).push(desc);
+        reg.add(desc);
+    }
+    for (const enumProto of proto.enumType) {
+        addEnum(enumProto, file, desc, reg);
+    }
+    for (const messageProto of proto.nestedType) {
+        addMessage(messageProto, file, desc, reg, mapEntries);
+    }
+}
+/**
+ * Create a descriptor for a service, including methods, and add it to our
+ * cart.
+ */
+function addService(proto, file, reg) {
+    var _a, _b;
+    const desc = {
+        kind: "service",
+        proto,
+        deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+        file,
+        name: proto.name,
+        typeName: makeTypeName(proto, undefined, file),
+        methods: [],
+        toString() {
+            return `service ${this.typeName}`;
+        },
+    };
+    file.services.push(desc);
+    reg.add(desc);
+    for (const methodProto of proto.method) {
+        desc.methods.push(newMethod(methodProto, desc, reg));
+    }
+}
+/**
+ * Create a descriptor for a method.
+ */
+function newMethod(proto, parent, reg) {
+    var _a, _b, _c, _d;
+    let methodKind;
+    if (proto.clientStreaming && proto.serverStreaming) {
+        methodKind = "bidi_streaming";
+    }
+    else if (proto.clientStreaming) {
+        methodKind = "client_streaming";
+    }
+    else if (proto.serverStreaming) {
+        methodKind = "server_streaming";
+    }
+    else {
+        methodKind = "unary";
+    }
+    const input = reg.getMessage(trimLeadingDot(proto.inputType));
+    const output = reg.getMessage(trimLeadingDot(proto.outputType));
+    (0, assert_js_1.assert)(input, `invalid MethodDescriptorProto: input_type ${proto.inputType} not found`);
+    (0, assert_js_1.assert)(output, `invalid MethodDescriptorProto: output_type ${proto.inputType} not found`);
+    const name = proto.name;
+    return {
+        kind: "rpc",
+        proto,
+        deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+        parent,
+        name,
+        methodKind,
+        input,
+        output,
+        idempotency: (_d = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.idempotencyLevel) !== null && _d !== void 0 ? _d : IDEMPOTENCY_UNKNOWN,
+        toString() {
+            return `rpc ${parent.typeName}.${name}`;
+        },
+    };
+}
+/**
+ * Create a descriptor for a oneof group.
+ */
+function newOneof(proto, parent) {
+    return {
+        kind: "oneof",
+        proto,
+        deprecated: false,
+        parent,
+        fields: [],
+        name: proto.name,
+        toString() {
+            return `oneof ${parent.typeName}.${this.name}`;
+        },
+    };
+}
+function newField(proto, parentOrFile, reg, oneof, mapEntries) {
+    var _a, _b, _c;
+    const field = {
+        proto,
+        deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+        name: proto.name,
+        number: proto.number,
+        scalar: undefined,
+        message: undefined,
+        enum: undefined,
+    };
+    if (mapEntries === undefined) {
+        // extension field
+        const file = parentOrFile.kind == "file" ? parentOrFile : parentOrFile.file;
+        const parent = parentOrFile.kind == "file" ? undefined : parentOrFile;
+        const typeName = makeTypeName(proto, parent, file);
+        field.kind = "extension";
+        field.file = file;
+        field.parent = parent;
+        field.oneof = undefined;
+        field.typeName = typeName;
+        field.jsonName = `[${typeName}]`; // option json_name is not allowed on extension fields
+        field.toString = () => `extension ${typeName}`;
+        const extendee = reg.getMessage(trimLeadingDot(proto.extendee));
+        (0, assert_js_1.assert)(extendee, `invalid FieldDescriptorProto: extendee ${proto.extendee} not found`);
+        field.extendee = extendee;
+    }
+    else {
+        // regular field
+        const parent = parentOrFile;
+        (0, assert_js_1.assert)(parent.kind == "message");
+        field.kind = "field";
+        field.parent = parent;
+        field.oneof = oneof;
+        field.jsonName = proto.jsonName;
+        field.toString = () => `field ${parent.typeName}.${proto.name}`;
+    }
+    const label = proto.label;
+    const type = proto.type;
+    const jstype = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.jstype;
+    if (label === LABEL_REPEATED) {
+        // list or map field
+        const mapEntry = type == TYPE_MESSAGE
+            ? mapEntries === null || mapEntries === void 0 ? void 0 : mapEntries.get(trimLeadingDot(proto.typeName))
+            : undefined;
+        if (mapEntry) {
+            // map field
+            field.fieldKind = "map";
+            const keyField = mapEntry.fields.find((f) => f.number === 1);
+            (0, assert_js_1.assert)(keyField);
+            (0, assert_js_1.assert)(keyField.fieldKind == "scalar");
+            (0, assert_js_1.assert)(keyField.scalar != scalar_js_1.ScalarType.BYTES &&
+                keyField.scalar != scalar_js_1.ScalarType.FLOAT &&
+                keyField.scalar != scalar_js_1.ScalarType.DOUBLE);
+            const valueField = mapEntry.fields.find((f) => f.proto.number === 2);
+            (0, assert_js_1.assert)(valueField);
+            (0, assert_js_1.assert)(valueField.fieldKind != "list" && valueField.fieldKind != "map");
+            field.mapKey = keyField.scalar;
+            field.mapKind = valueField.fieldKind;
+            field.message = valueField.message;
+            field.delimitedEncoding = false; // map fields are always LENGTH_PREFIXED
+            field.enum = valueField.enum;
+            field.scalar = valueField.scalar;
+            return field;
+        }
+        // list field
+        field.fieldKind = "list";
+        switch (type) {
+            case TYPE_MESSAGE:
+            case TYPE_GROUP:
+                field.listKind = "message";
+                field.message = reg.getMessage(trimLeadingDot(proto.typeName));
+                (0, assert_js_1.assert)(field.message);
+                field.delimitedEncoding = isDelimitedEncoding(proto, parentOrFile);
+                break;
+            case TYPE_ENUM:
+                field.listKind = "enum";
+                field.enum = reg.getEnum(trimLeadingDot(proto.typeName));
+                (0, assert_js_1.assert)(field.enum);
+                break;
+            default:
+                field.listKind = "scalar";
+                field.scalar = type;
+                field.longType =
+                    jstype == JS_STRING ? scalar_js_1.LongType.STRING : scalar_js_1.LongType.BIGINT;
+                break;
+        }
+        field.packed = isPackedField(proto, parentOrFile);
+        return field;
+    }
+    // singular
+    switch (type) {
+        case TYPE_MESSAGE:
+        case TYPE_GROUP:
+            field.fieldKind = "message";
+            field.message = reg.getMessage(trimLeadingDot(proto.typeName));
+            (0, assert_js_1.assert)(field.message, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`);
+            field.delimitedEncoding = isDelimitedEncoding(proto, parentOrFile);
+            field.getDefaultValue = () => undefined;
+            break;
+        case TYPE_ENUM: {
+            const enumeration = reg.getEnum(trimLeadingDot(proto.typeName));
+            (0, assert_js_1.assert)(enumeration !== undefined, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`);
+            field.fieldKind = "enum";
+            field.enum = reg.getEnum(trimLeadingDot(proto.typeName));
+            field.getDefaultValue = () => {
+                return (0, unsafe_js_1.unsafeIsSetExplicit)(proto, "defaultValue")
+                    ? (0, text_format_js_1.parseTextFormatEnumValue)(enumeration, proto.defaultValue)
+                    : undefined;
+            };
+            break;
+        }
+        default: {
+            field.fieldKind = "scalar";
+            field.scalar = type;
+            field.longType = jstype == JS_STRING ? scalar_js_1.LongType.STRING : scalar_js_1.LongType.BIGINT;
+            field.getDefaultValue = () => {
+                return (0, unsafe_js_1.unsafeIsSetExplicit)(proto, "defaultValue")
+                    ? (0, text_format_js_1.parseTextFormatScalarValue)(type, proto.defaultValue)
+                    : undefined;
+            };
+            break;
+        }
+    }
+    field.presence = getFieldPresence(proto, oneof, parentOrFile);
+    field.optional = isOptionalField(field);
+    return field;
+}
+/**
+ * Parse the "syntax" and "edition" fields, returning one of the supported
+ * editions.
+ */
+function getFileEdition(proto) {
+    switch (proto.syntax) {
+        case "":
+        case "proto2":
+            return EDITION_PROTO2;
+        case "proto3":
+            return EDITION_PROTO3;
+        case "editions":
+            if (proto.edition in featureDefaults) {
+                return proto.edition;
+            }
+            throw new Error(`${proto.name}: unsupported edition`);
+        default:
+            throw new Error(`${proto.name}: unsupported syntax "${proto.syntax}"`);
+    }
+}
+/**
+ * Resolve dependencies of FileDescriptorProto to DescFile.
+ */
+function findFileDependencies(proto, reg) {
+    return proto.dependency.map((wantName) => {
+        const dep = reg.getFile(wantName);
+        if (!dep) {
+            throw new Error(`Cannot find ${wantName}, imported by ${proto.name}`);
+        }
+        return dep;
+    });
+}
+/**
+ * Finds a prefix shared by enum values, for example `my_enum_` for
+ * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`.
+ */
+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 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();
+}
+/**
+ * Create a fully qualified name for a protobuf type or extension field.
+ *
+ * The fully qualified name for messages, enumerations, and services is
+ * constructed by concatenating the package name (if present), parent
+ * message names (for nested types), and the type name. We omit the leading
+ * dot added by protobuf compilers. Examples:
+ * - mypackage.MyMessage
+ * - mypackage.MyMessage.NestedMessage
+ *
+ * The fully qualified name for extension fields is constructed by
+ * concatenating the package name (if present), parent message names (for
+ * extensions declared within a message), and the field name. Examples:
+ * - mypackage.extfield
+ * - mypackage.MyMessage.extfield
+ */
+function makeTypeName(proto, parent, file) {
+    let typeName;
+    if (parent) {
+        typeName = `${parent.typeName}.${proto.name}`;
+    }
+    else if (file.proto.package.length > 0) {
+        typeName = `${file.proto.package}.${proto.name}`;
+    }
+    else {
+        typeName = `${proto.name}`;
+    }
+    return typeName;
+}
+/**
+ * Remove the leading dot from a fully qualified type name.
+ */
+function trimLeadingDot(typeName) {
+    return typeName.startsWith(".") ? typeName.substring(1) : typeName;
+}
+/**
+ * Did the user put the field in a oneof group?
+ * Synthetic oneofs for proto3 optionals are ignored.
+ */
+function findOneof(proto, allOneofs) {
+    if (!(0, unsafe_js_1.unsafeIsSetExplicit)(proto, "oneofIndex")) {
+        return undefined;
+    }
+    if (proto.proto3Optional) {
+        return undefined;
+    }
+    const oneof = allOneofs[proto.oneofIndex];
+    (0, assert_js_1.assert)(oneof, `invalid FieldDescriptorProto: oneof #${proto.oneofIndex} for field #${proto.number} not found`);
+    return oneof;
+}
+/**
+ * Presence of the field.
+ * See https://protobuf.dev/programming-guides/field_presence/
+ */
+function getFieldPresence(proto, oneof, parent) {
+    if (proto.label == LABEL_REQUIRED) {
+        // proto2 required is LEGACY_REQUIRED
+        return LEGACY_REQUIRED;
+    }
+    const { edition } = parent.kind == "message" ? parent.file : parent;
+    if (edition == EDITION_PROTO3) {
+        // proto3 oneof and optional are explicit
+        if (oneof != undefined || proto.proto3Optional) {
+            return EXPLICIT;
+        }
+        // proto3 singular message is explicit
+        const singularMessage = proto.label != LABEL_REPEATED && proto.type == TYPE_MESSAGE;
+        if (singularMessage) {
+            return EXPLICIT;
+        }
+    }
+    // also resolves proto2/proto3 defaults
+    return resolveFeature("fieldPresence", { proto, parent });
+}
+/**
+ * Did the user use the `optional` keyword?
+ */
+function isOptionalField(field) {
+    const edition = (field.kind == "extension" ? field.file : field.parent.file)
+        .edition;
+    if (edition == EDITION_PROTO2) {
+        return !field.oneof && field.proto.label == LABEL_OPTIONAL;
+    }
+    if (edition == EDITION_PROTO3) {
+        return field.proto.proto3Optional;
+    }
+    return false;
+}
+/**
+ * Pack this repeated field?
+ */
+function isPackedField(proto, parent) {
+    if (proto.label != LABEL_REPEATED) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (proto.type) {
+        case TYPE_STRING:
+        case TYPE_BYTES:
+        case TYPE_GROUP:
+        case TYPE_MESSAGE:
+            // length-delimited types cannot be packed
+            return false;
+    }
+    const o = proto.options;
+    if (o && (0, unsafe_js_1.unsafeIsSetExplicit)(o, "packed")) {
+        // prefer the field option over edition features
+        return o.packed;
+    }
+    return (PACKED ==
+        resolveFeature("repeatedFieldEncoding", {
+            proto,
+            parent,
+        }));
+}
+/**
+ * Enumerations can be open or closed.
+ * See https://protobuf.dev/programming-guides/enum/
+ */
+function isEnumOpen(desc) {
+    var _a;
+    return (OPEN ==
+        resolveFeature("enumType", {
+            proto: desc.proto,
+            parent: (_a = desc.parent) !== null && _a !== void 0 ? _a : desc.file,
+        }));
+}
+/**
+ * Encode the message delimited (a.k.a. proto2 group encoding), or
+ * length-prefixed?
+ */
+function isDelimitedEncoding(proto, parent) {
+    if (proto.type == TYPE_GROUP) {
+        return true;
+    }
+    return (DELIMITED ==
+        resolveFeature("messageEncoding", {
+            proto,
+            parent,
+        }));
+}
+function resolveFeature(name, ref) {
+    var _a, _b;
+    const featureSet = (_a = ref.proto.options) === null || _a === void 0 ? void 0 : _a.features;
+    if (featureSet) {
+        const val = featureSet[name];
+        if (val != 0) {
+            return val;
+        }
+    }
+    if ("kind" in ref) {
+        if (ref.kind == "message") {
+            return resolveFeature(name, (_b = ref.parent) !== null && _b !== void 0 ? _b : ref.file);
+        }
+        const editionDefaults = featureDefaults[ref.edition];
+        if (!editionDefaults) {
+            throw new Error(`feature default for edition ${ref.edition} not found`);
+        }
+        return editionDefaults[name];
+    }
+    return resolveFeature(name, ref.parent);
+}