@bufbuild/protobuf 0.0.1-alpha.1 → 0.0.2-alpha.2

package/dist/esm/descriptor-set.js

@@ -1,8 +1,17 @@
-import {
-  FieldDescriptorProto_Label,
-  FieldDescriptorProto_Type,
-  MethodOptions_IdempotencyLevel,
-} from "./google/protobuf/descriptor_pb.js";
+// 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.
+import { FieldDescriptorProto_Label, FieldDescriptorProto_Type, MethodOptions_IdempotencyLevel, } from "./google/protobuf/descriptor_pb.js";
 import { assert } from "./private/assert.js";
 import { ScalarType } from "./field.js";
 import { MethodIdempotency, MethodKind } from "./service-type.js";
@@ -14,504 +23,447 @@ import { MethodIdempotency, MethodKind } from "./service-type.js";
  * with a leading dot.
  */
 export class DescriptorSet {
-  constructor() {
-    this.enums = {};
-    this.messages = {};
-    this.services = {};
-  }
-  /**
-   * May raise an error on invalid descriptors.
-   */
-  add(...files) {
-    for (const file of files) {
-      newFile(file, this);
-    }
-  }
-  listEnums() {
-    return Object.values(this.enums).filter(isDefined);
-  }
-  listMessages() {
-    return Object.values(this.messages).filter(isDefined);
-  }
-  listServices() {
-    return Object.values(this.services).filter(isDefined);
-  }
+    constructor() {
+        this.enums = {};
+        this.messages = {};
+        this.services = {};
+    }
+    /**
+     * May raise an error on invalid descriptors.
+     */
+    add(...files) {
+        for (const file of files) {
+            newFile(file, this);
+        }
+    }
+    listEnums() {
+        return Object.values(this.enums).filter(isDefined);
+    }
+    listMessages() {
+        return Object.values(this.messages).filter(isDefined);
+    }
+    listServices() {
+        return Object.values(this.services).filter(isDefined);
+    }
 }
 function isDefined(v) {
-  return v !== undefined;
+    return v !== undefined;
 }
 const fieldTypeToScalarType = {
-  [FieldDescriptorProto_Type.DOUBLE]: ScalarType.DOUBLE,
-  [FieldDescriptorProto_Type.FLOAT]: ScalarType.FLOAT,
-  [FieldDescriptorProto_Type.INT64]: ScalarType.INT64,
-  [FieldDescriptorProto_Type.UINT64]: ScalarType.UINT64,
-  [FieldDescriptorProto_Type.INT32]: ScalarType.INT32,
-  [FieldDescriptorProto_Type.FIXED64]: ScalarType.FIXED64,
-  [FieldDescriptorProto_Type.FIXED32]: ScalarType.FIXED32,
-  [FieldDescriptorProto_Type.BOOL]: ScalarType.BOOL,
-  [FieldDescriptorProto_Type.STRING]: ScalarType.STRING,
-  [FieldDescriptorProto_Type.GROUP]: undefined,
-  [FieldDescriptorProto_Type.MESSAGE]: undefined,
-  [FieldDescriptorProto_Type.BYTES]: ScalarType.BYTES,
-  [FieldDescriptorProto_Type.UINT32]: ScalarType.UINT32,
-  [FieldDescriptorProto_Type.ENUM]: undefined,
-  [FieldDescriptorProto_Type.SFIXED32]: ScalarType.SFIXED32,
-  [FieldDescriptorProto_Type.SFIXED64]: ScalarType.SFIXED64,
-  [FieldDescriptorProto_Type.SINT32]: ScalarType.SINT32,
-  [FieldDescriptorProto_Type.SINT64]: ScalarType.SINT64,
+    [FieldDescriptorProto_Type.DOUBLE]: ScalarType.DOUBLE,
+    [FieldDescriptorProto_Type.FLOAT]: ScalarType.FLOAT,
+    [FieldDescriptorProto_Type.INT64]: ScalarType.INT64,
+    [FieldDescriptorProto_Type.UINT64]: ScalarType.UINT64,
+    [FieldDescriptorProto_Type.INT32]: ScalarType.INT32,
+    [FieldDescriptorProto_Type.FIXED64]: ScalarType.FIXED64,
+    [FieldDescriptorProto_Type.FIXED32]: ScalarType.FIXED32,
+    [FieldDescriptorProto_Type.BOOL]: ScalarType.BOOL,
+    [FieldDescriptorProto_Type.STRING]: ScalarType.STRING,
+    [FieldDescriptorProto_Type.GROUP]: undefined,
+    [FieldDescriptorProto_Type.MESSAGE]: undefined,
+    [FieldDescriptorProto_Type.BYTES]: ScalarType.BYTES,
+    [FieldDescriptorProto_Type.UINT32]: ScalarType.UINT32,
+    [FieldDescriptorProto_Type.ENUM]: undefined,
+    [FieldDescriptorProto_Type.SFIXED32]: ScalarType.SFIXED32,
+    [FieldDescriptorProto_Type.SFIXED64]: ScalarType.SFIXED64,
+    [FieldDescriptorProto_Type.SINT32]: ScalarType.SINT32,
+    [FieldDescriptorProto_Type.SINT64]: ScalarType.SINT64,
 };
 function newFile(proto, ds) {
-  assert(proto.name, `missing file descriptor name`);
-  if (proto.syntax !== undefined && proto.syntax !== "proto3") {
-    throw new Error(`invalid descriptor: unsupported syntax: ${proto.syntax}`);
-  }
-  const file = {
-    proto,
-    syntax: proto.syntax === "proto3" ? "proto3" : "proto2",
-    name: proto.name.endsWith(".proto")
-      ? proto.name.substring(-".proto".length)
-      : proto.name,
-    toString() {
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
-      return `file ${this.proto.name}`;
-    },
-  };
-  for (const messageType of proto.messageType) {
-    newMessage(messageType, undefined, file, ds);
-  }
-  for (const enumType of proto.enumType) {
-    newEnum(enumType, undefined, file, ds);
-  }
-  for (const extension of proto.extension) {
-    newExtension(extension, undefined, file, ds);
-  }
-  for (const service of proto.service) {
-    newService(service, file, ds);
-  }
-  return file;
+    assert(proto.name, `missing file descriptor name`);
+    if (proto.syntax !== undefined && proto.syntax !== "proto3") {
+        throw new Error(`invalid descriptor: unsupported syntax: ${proto.syntax}`);
+    }
+    const file = {
+        proto,
+        syntax: proto.syntax === "proto3" ? "proto3" : "proto2",
+        name: proto.name.endsWith(".proto")
+            ? proto.name.substring(-".proto".length)
+            : proto.name,
+        toString() {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+            return `file ${this.proto.name}`;
+        },
+    };
+    for (const messageType of proto.messageType) {
+        newMessage(messageType, undefined, file, ds);
+    }
+    for (const enumType of proto.enumType) {
+        newEnum(enumType, undefined, file, ds);
+    }
+    for (const extension of proto.extension) {
+        newExtension(extension, undefined, file, ds);
+    }
+    for (const service of proto.service) {
+        newService(service, file, ds);
+    }
+    return file;
 }
 function newEnum(proto, parent, file, us) {
-  assert(proto.name, `invalid descriptor: missing enum descriptor name`);
-  let protoTypeName;
-  if (parent) {
-    protoTypeName = `${parent.protoTypeName}.${proto.name}`;
-  } else if (file.proto.package !== undefined) {
-    protoTypeName = `.${file.proto.package}.${proto.name}`;
-  } else {
-    protoTypeName = `.${proto.name}`;
-  }
-  const values = [];
-  const enumT = {
-    proto,
-    file,
-    parent,
-    name: proto.name,
-    protoTypeName,
-    typeName: protoTypeName.startsWith(".")
-      ? protoTypeName.substring(1)
-      : protoTypeName,
-    values,
-    toString() {
-      return `enum ${this.typeName}`;
-    },
-  };
-  us.enums[enumT.protoTypeName] = enumT;
-  for (const value of proto.value) {
-    values.push(newEnumValue(value, enumT));
-  }
-  return enumT;
+    assert(proto.name, `invalid descriptor: missing enum descriptor name`);
+    let protoTypeName;
+    if (parent) {
+        protoTypeName = `${parent.protoTypeName}.${proto.name}`;
+    }
+    else if (file.proto.package !== undefined) {
+        protoTypeName = `.${file.proto.package}.${proto.name}`;
+    }
+    else {
+        protoTypeName = `.${proto.name}`;
+    }
+    const values = [];
+    const enumT = {
+        proto,
+        file,
+        parent,
+        name: proto.name,
+        protoTypeName,
+        typeName: protoTypeName.startsWith(".")
+            ? protoTypeName.substring(1)
+            : protoTypeName,
+        values,
+        toString() {
+            return `enum ${this.typeName}`;
+        },
+    };
+    us.enums[enumT.protoTypeName] = enumT;
+    for (const value of proto.value) {
+        values.push(newEnumValue(value, enumT));
+    }
+    return enumT;
 }
 function newEnumValue(proto, parent) {
-  assert(proto.name, `invalid descriptor: missing enum value descriptor name`);
-  assert(
-    proto.number !== undefined,
-    `invalid descriptor: missing enum value descriptor number`
-  );
-  return {
-    proto,
-    name: proto.name,
-    number: proto.number,
-    parent,
-    toString() {
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
-      return `enum value ${this.parent.typeName}.${this.proto.name}`;
-    },
-  };
+    assert(proto.name, `invalid descriptor: missing enum value descriptor name`);
+    assert(proto.number !== undefined, `invalid descriptor: missing enum value descriptor number`);
+    return {
+        proto,
+        name: proto.name,
+        number: proto.number,
+        parent,
+        toString() {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+            return `enum value ${this.parent.typeName}.${this.proto.name}`;
+        },
+    };
 }
 function newMessage(proto, parent, file, us) {
-  assert(proto.name, `invalid descriptor: missing name`);
-  const nestedMessages = [];
-  const fields = [];
-  const oneofs = [];
-  const nestedEnums = [];
-  const nestedExtensions = [];
-  let protoTypeName;
-  if (parent) {
-    protoTypeName = `${parent.protoTypeName}.${proto.name}`;
-  } else if (file.proto.package !== undefined) {
-    protoTypeName = `.${file.proto.package}.${proto.name}`;
-  } else {
-    protoTypeName = `.${proto.name}`;
-  }
-  const message = {
-    proto,
-    file,
-    parent,
-    name: proto.name,
-    typeName: protoTypeName.startsWith(".")
-      ? protoTypeName.substring(1)
-      : protoTypeName,
-    protoTypeName,
-    fields,
-    oneofs,
-    nestedEnums,
-    nestedMessages,
-    nestedExtensions,
-    toString() {
-      return `message ${this.typeName}`;
-    },
-  };
-  us.messages[message.protoTypeName] = message;
-  for (const nestedType of proto.nestedType) {
-    nestedMessages.push(newMessage(nestedType, message, file, us));
-  }
-  for (const oneofDecl of proto.oneofDecl) {
-    oneofs.push(newOneof(oneofDecl, message, file));
-  }
-  for (const field of proto.field) {
-    let oneof = undefined;
-    if (field.oneofIndex !== undefined) {
-      oneof = oneofs[field.oneofIndex];
-      assert(
-        oneof,
-        `invalid descriptor: oneof declaration index ${
-          field.oneofIndex
-        } specified by field #${field.number ?? -1} not found`
-      );
-    }
-    fields.push(newField(field, message, oneof));
-  }
-  for (const enumType of proto.enumType) {
-    nestedEnums.push(newEnum(enumType, message, file, us));
-  }
-  for (const extension of proto.extension) {
-    nestedExtensions.push(newExtension(extension, message, file, us));
-  }
-  return message;
+    assert(proto.name, `invalid descriptor: missing name`);
+    const nestedMessages = [];
+    const fields = [];
+    const oneofs = [];
+    const nestedEnums = [];
+    const nestedExtensions = [];
+    let protoTypeName;
+    if (parent) {
+        protoTypeName = `${parent.protoTypeName}.${proto.name}`;
+    }
+    else if (file.proto.package !== undefined) {
+        protoTypeName = `.${file.proto.package}.${proto.name}`;
+    }
+    else {
+        protoTypeName = `.${proto.name}`;
+    }
+    const message = {
+        proto,
+        file,
+        parent,
+        name: proto.name,
+        typeName: protoTypeName.startsWith(".")
+            ? protoTypeName.substring(1)
+            : protoTypeName,
+        protoTypeName,
+        fields,
+        oneofs,
+        nestedEnums,
+        nestedMessages,
+        nestedExtensions,
+        toString() {
+            return `message ${this.typeName}`;
+        },
+    };
+    us.messages[message.protoTypeName] = message;
+    for (const nestedType of proto.nestedType) {
+        nestedMessages.push(newMessage(nestedType, message, file, us));
+    }
+    for (const oneofDecl of proto.oneofDecl) {
+        oneofs.push(newOneof(oneofDecl, message, file));
+    }
+    for (const field of proto.field) {
+        let oneof = undefined;
+        if (field.oneofIndex !== undefined) {
+            oneof = oneofs[field.oneofIndex];
+            assert(oneof, `invalid descriptor: oneof declaration index ${field.oneofIndex} specified by field #${field.number ?? -1} not found`);
+        }
+        fields.push(newField(field, message, oneof));
+    }
+    for (const enumType of proto.enumType) {
+        nestedEnums.push(newEnum(enumType, message, file, us));
+    }
+    for (const extension of proto.extension) {
+        nestedExtensions.push(newExtension(extension, message, file, us));
+    }
+    return message;
 }
 function newField(proto, parent, oneof) {
-  assert(proto.name, `invalid descriptor: missing name`);
-  assert(proto.number, `invalid descriptor: missing number`);
-  assert(proto.type, `invalid descriptor: missing type`);
-  let optional = false;
-  let packed = proto.options?.packed === true;
-  switch (parent.file.syntax) {
-    case "proto2":
-      optional =
-        oneof === undefined &&
-        proto.label === FieldDescriptorProto_Label.OPTIONAL;
-      break;
-    case "proto3":
-      optional = proto.proto3Optional === true;
-      switch (proto.type) {
-        case FieldDescriptorProto_Type.DOUBLE:
-        case FieldDescriptorProto_Type.FLOAT:
-        case FieldDescriptorProto_Type.INT64:
-        case FieldDescriptorProto_Type.UINT64:
-        case FieldDescriptorProto_Type.INT32:
-        case FieldDescriptorProto_Type.FIXED64:
-        case FieldDescriptorProto_Type.FIXED32:
-        case FieldDescriptorProto_Type.UINT32:
-        case FieldDescriptorProto_Type.SFIXED32:
-        case FieldDescriptorProto_Type.SFIXED64:
-        case FieldDescriptorProto_Type.SINT32:
-        case FieldDescriptorProto_Type.SINT64:
-        case FieldDescriptorProto_Type.BOOL:
-        case 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.
-          packed = true;
-          break;
-        case FieldDescriptorProto_Type.STRING:
-        case FieldDescriptorProto_Type.GROUP:
-        case FieldDescriptorProto_Type.MESSAGE:
-        case FieldDescriptorProto_Type.BYTES:
-          assert(
-            !packed,
-            `invalid descriptor: ${
-              FieldDescriptorProto_Type[proto.type]
-            } cannot be packed`
-          );
-          break;
-      }
-      break;
-  }
-  const field = {
-    proto,
-    name: proto.name,
-    number: proto.number,
-    type: proto.type,
-    parent,
-    oneof: proto.proto3Optional === true ? undefined : oneof,
-    optional,
-    packed,
-    toString() {
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
-      return `field ${parent.typeName}.${proto.name}`;
-    },
-    resolve(us) {
-      return resolveField(this, us);
-    },
-  };
-  if (oneof) {
-    oneof.fields.push(field);
-  }
-  return field;
+    assert(proto.name, `invalid descriptor: missing name`);
+    assert(proto.number, `invalid descriptor: missing number`);
+    assert(proto.type, `invalid descriptor: missing type`);
+    let optional = false;
+    let packed = proto.options?.packed === true;
+    switch (parent.file.syntax) {
+        case "proto2":
+            optional =
+                oneof === undefined &&
+                    proto.label === FieldDescriptorProto_Label.OPTIONAL;
+            break;
+        case "proto3":
+            optional = proto.proto3Optional === true;
+            switch (proto.type) {
+                case FieldDescriptorProto_Type.DOUBLE:
+                case FieldDescriptorProto_Type.FLOAT:
+                case FieldDescriptorProto_Type.INT64:
+                case FieldDescriptorProto_Type.UINT64:
+                case FieldDescriptorProto_Type.INT32:
+                case FieldDescriptorProto_Type.FIXED64:
+                case FieldDescriptorProto_Type.FIXED32:
+                case FieldDescriptorProto_Type.UINT32:
+                case FieldDescriptorProto_Type.SFIXED32:
+                case FieldDescriptorProto_Type.SFIXED64:
+                case FieldDescriptorProto_Type.SINT32:
+                case FieldDescriptorProto_Type.SINT64:
+                case FieldDescriptorProto_Type.BOOL:
+                case 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.
+                    packed = true;
+                    break;
+                case FieldDescriptorProto_Type.STRING:
+                case FieldDescriptorProto_Type.GROUP:
+                case FieldDescriptorProto_Type.MESSAGE:
+                case FieldDescriptorProto_Type.BYTES:
+                    assert(!packed, `invalid descriptor: ${FieldDescriptorProto_Type[proto.type]} cannot be packed`);
+                    break;
+            }
+            break;
+    }
+    const field = {
+        proto,
+        name: proto.name,
+        number: proto.number,
+        type: proto.type,
+        parent,
+        oneof: proto.proto3Optional === true ? undefined : oneof,
+        optional,
+        packed,
+        toString() {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+            return `field ${parent.typeName}.${proto.name}`;
+        },
+        resolve(us) {
+            return resolveField(this, us);
+        },
+    };
+    if (oneof) {
+        oneof.fields.push(field);
+    }
+    return field;
 }
 function resolveField(u, us) {
-  const repeated = u.proto.label === FieldDescriptorProto_Label.REPEATED;
-  switch (u.type) {
-    case FieldDescriptorProto_Type.MESSAGE:
-    case FieldDescriptorProto_Type.GROUP: {
-      assert(
-        u.proto.typeName,
-        `invalid descriptor: ${u.toString()} has type ${
-          FieldDescriptorProto_Type[u.type]
-        }, but type_name is unset`
-      );
-      const refMessage = us.messages[u.proto.typeName];
-      assert(
-        refMessage,
-        `invalid descriptor: cannot find type_name "${
-          u.proto.typeName
-        }" specified by ${u.toString()}`
-      );
-      if (refMessage.proto.options?.mapEntry !== undefined) {
+    const repeated = u.proto.label === FieldDescriptorProto_Label.REPEATED;
+    switch (u.type) {
+        case FieldDescriptorProto_Type.MESSAGE:
+        case FieldDescriptorProto_Type.GROUP: {
+            assert(u.proto.typeName, `invalid descriptor: ${u.toString()} has type ${FieldDescriptorProto_Type[u.type]}, but type_name is unset`);
+            const refMessage = us.messages[u.proto.typeName];
+            assert(refMessage, `invalid descriptor: cannot find type_name "${u.proto.typeName}" specified by ${u.toString()}`);
+            if (refMessage.proto.options?.mapEntry !== undefined) {
+                return {
+                    ...u,
+                    repeated: false,
+                    scalarType: undefined,
+                    message: undefined,
+                    enum: undefined,
+                    map: resolveMap(refMessage, us),
+                };
+            }
+            return {
+                ...u,
+                repeated,
+                scalarType: undefined,
+                message: refMessage,
+                enum: undefined,
+                map: undefined,
+            };
+        }
+        case FieldDescriptorProto_Type.ENUM: {
+            assert(u.proto.typeName, `invalid descriptor: ${u.toString()} has type ${FieldDescriptorProto_Type[u.type]}, but type_name is unset`);
+            const refEnum = us.enums[u.proto.typeName];
+            assert(refEnum, `invalid descriptor: cannot find type_name "${u.proto.typeName}" specified by ${u.toString()}`);
+            return {
+                ...u,
+                repeated,
+                scalarType: undefined,
+                message: undefined,
+                enum: refEnum,
+                map: undefined,
+            };
+        }
+        default: {
+            const scalarType = fieldTypeToScalarType[u.type];
+            assert(scalarType, `invalid descriptor: unable to convert google.protobuf.FieldDescriptorProto.Type ${FieldDescriptorProto_Type[u.type]} to ScalarType`);
+            return {
+                ...u,
+                repeated,
+                scalarType,
+                message: undefined,
+                enum: undefined,
+                map: undefined,
+            };
+        }
+    }
+}
+function resolveMap(mapEntry, us) {
+    assert(mapEntry.proto.options?.mapEntry, `invalid descriptor: expected ${mapEntry.toString()} to be a map entry`);
+    assert(mapEntry.fields.length === 2, `invalid descriptor: map entry ${mapEntry.toString()} has ${mapEntry.fields.length} fields`);
+    const uKeyField = mapEntry.fields.find((f) => f.proto.number === 1);
+    assert(uKeyField, `invalid descriptor: map entry ${mapEntry.toString()} is missing key field`);
+    const keyField = resolveField(uKeyField, us);
+    assert(keyField.scalarType !== undefined &&
+        keyField.scalarType !== ScalarType.BYTES &&
+        keyField.scalarType !== ScalarType.FLOAT &&
+        keyField.scalarType !== ScalarType.DOUBLE, `invalid descriptor: map entry ${mapEntry.toString()} has unexpected key type ${FieldDescriptorProto_Type[keyField.type]}`);
+    const uValueField = mapEntry.fields.find((f) => f.proto.number === 2);
+    assert(uValueField, `invalid descriptor: map entry ${mapEntry.toString()} is missing value field`);
+    const valueField = resolveField(uValueField, us);
+    if (valueField.scalarType !== undefined) {
+        return {
+            key: keyField.scalarType,
+            value: {
+                scalarType: valueField.scalarType,
+                enum: undefined,
+                message: undefined,
+            },
+        };
+    }
+    if (valueField.enum !== undefined) {
+        return {
+            key: keyField.scalarType,
+            value: { scalar: undefined, enum: valueField.enum, message: undefined },
+        };
+    }
+    if (valueField.message !== undefined) {
         return {
-          ...u,
-          repeated: false,
-          scalarType: undefined,
-          message: undefined,
-          enum: undefined,
-          map: resolveMap(refMessage, us),
+            key: keyField.scalarType,
+            value: {
+                scalar: undefined,
+                enum: undefined,
+                message: valueField.message,
+            },
         };
-      }
-      return {
-        ...u,
-        repeated,
-        scalarType: undefined,
-        message: refMessage,
-        enum: undefined,
-        map: undefined,
-      };
-    }
-    case FieldDescriptorProto_Type.ENUM: {
-      assert(
-        u.proto.typeName,
-        `invalid descriptor: ${u.toString()} has type ${
-          FieldDescriptorProto_Type[u.type]
-        }, but type_name is unset`
-      );
-      const refEnum = us.enums[u.proto.typeName];
-      assert(
-        refEnum,
-        `invalid descriptor: cannot find type_name "${
-          u.proto.typeName
-        }" specified by ${u.toString()}`
-      );
-      return {
-        ...u,
-        repeated,
-        scalarType: undefined,
-        message: undefined,
-        enum: refEnum,
-        map: undefined,
-      };
-    }
-    default: {
-      const scalarType = fieldTypeToScalarType[u.type];
-      assert(
-        scalarType,
-        `invalid descriptor: unable to convert google.protobuf.FieldDescriptorProto.Type ${
-          FieldDescriptorProto_Type[u.type]
-        } to ScalarType`
-      );
-      return {
-        ...u,
-        repeated,
-        scalarType,
-        message: undefined,
-        enum: undefined,
-        map: undefined,
-      };
-    }
-  }
+    }
+    throw new Error(`invalid descriptor: map entry ${mapEntry.toString()} has unexpected value type ${FieldDescriptorProto_Type[keyField.type]}`);
 }
-function resolveMap(mapEntry, us) {
-  assert(
-    mapEntry.proto.options?.mapEntry,
-    `invalid descriptor: expected ${mapEntry.toString()} to be a map entry`
-  );
-  assert(
-    mapEntry.fields.length === 2,
-    `invalid descriptor: map entry ${mapEntry.toString()} has ${
-      mapEntry.fields.length
-    } fields`
-  );
-  const uKeyField = mapEntry.fields.find((f) => f.proto.number === 1);
-  assert(
-    uKeyField,
-    `invalid descriptor: map entry ${mapEntry.toString()} is missing key field`
-  );
-  const keyField = resolveField(uKeyField, us);
-  assert(
-    keyField.scalarType !== undefined &&
-      keyField.scalarType !== ScalarType.BYTES &&
-      keyField.scalarType !== ScalarType.FLOAT &&
-      keyField.scalarType !== ScalarType.DOUBLE,
-    `invalid descriptor: map entry ${mapEntry.toString()} has unexpected key type ${
-      FieldDescriptorProto_Type[keyField.type]
-    }`
-  );
-  const uValueField = mapEntry.fields.find((f) => f.proto.number === 2);
-  assert(
-    uValueField,
-    `invalid descriptor: map entry ${mapEntry.toString()} is missing value field`
-  );
-  const valueField = resolveField(uValueField, us);
-  if (valueField.scalarType !== undefined) {
-    return {
-      key: keyField.scalarType,
-      value: {
-        scalarType: valueField.scalarType,
-        enum: undefined,
-        message: undefined,
-      },
-    };
-  }
-  if (valueField.enum !== undefined) {
-    return {
-      key: keyField.scalarType,
-      value: { scalar: undefined, enum: valueField.enum, message: undefined },
-    };
-  }
-  if (valueField.message !== undefined) {
+function newOneof(proto, parent, file) {
+    assert(proto.name, `invalid descriptor: missing oneof descriptor name`);
     return {
-      key: keyField.scalarType,
-      value: {
-        scalar: undefined,
-        enum: undefined,
-        message: valueField.message,
-      },
+        proto,
+        parent,
+        file,
+        fields: [],
+        name: proto.name,
+        toString() {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+            return `oneof ${parent.typeName}.${proto.name}`;
+        },
     };
-  }
-  throw new Error(
-    `invalid descriptor: map entry ${mapEntry.toString()} has unexpected value type ${
-      FieldDescriptorProto_Type[keyField.type]
-    }`
-  );
 }
-function newOneof(proto, parent, file) {
-  assert(proto.name, `invalid descriptor: missing oneof descriptor name`);
-  return {
-    proto,
-    parent,
-    file,
-    fields: [],
-    name: proto.name,
-    toString() {
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
-      return `oneof ${parent.typeName}.${proto.name}`;
-    },
-  };
-}
-function newExtension(
-  proto,
-  parent,
-  file,
-  us // eslint-disable-line @typescript-eslint/no-unused-vars
+function newExtension(proto, parent, file, us // eslint-disable-line @typescript-eslint/no-unused-vars
 ) {
-  assert(proto.name, `invalid descriptor: missing field descriptor name`);
-  return {
-    proto,
-    file,
-    parent,
-  };
+    assert(proto.name, `invalid descriptor: missing field descriptor name`);
+    return {
+        proto,
+        file,
+        parent,
+    };
 }
 function newService(proto, file, us) {
-  assert(proto.name, `invalid descriptor: missing service descriptor name`);
-  let protoTypeName;
-  if (file.proto.package !== undefined) {
-    protoTypeName = `.${file.proto.package}.${proto.name}`;
-  } else {
-    protoTypeName = `.${proto.name}`;
-  }
-  const methods = [];
-  const service = {
-    proto,
-    file,
-    typeName: protoTypeName.startsWith(".")
-      ? protoTypeName.substring(1)
-      : protoTypeName,
-    protoTypeName,
-    methods,
-    toString() {
-      return `service ${this.typeName}`;
-    },
-  };
-  for (const method of proto.method) {
-    methods.push(newMethod(method, service));
-  }
-  us.services[service.protoTypeName] = service;
-  return service;
+    assert(proto.name, `invalid descriptor: missing service descriptor name`);
+    let protoTypeName;
+    if (file.proto.package !== undefined) {
+        protoTypeName = `.${file.proto.package}.${proto.name}`;
+    }
+    else {
+        protoTypeName = `.${proto.name}`;
+    }
+    const methods = [];
+    const service = {
+        proto,
+        file,
+        typeName: protoTypeName.startsWith(".")
+            ? protoTypeName.substring(1)
+            : protoTypeName,
+        protoTypeName,
+        methods,
+        toString() {
+            return `service ${this.typeName}`;
+        },
+    };
+    for (const method of proto.method) {
+        methods.push(newMethod(method, service));
+    }
+    us.services[service.protoTypeName] = service;
+    return service;
 }
 function newMethod(proto, parent) {
-  assert(proto.name, `invalid descriptor: missing method descriptor name`);
-  assert(proto.inputType, `invalid descriptor: missing method input type`);
-  assert(proto.outputType, `invalid descriptor: missing method output type`);
-  let kind;
-  if (proto.clientStreaming === true && proto.serverStreaming === true) {
-    kind = MethodKind.BiDiStreaming;
-  } else if (proto.clientStreaming === true) {
-    kind = MethodKind.ClientStreaming;
-  } else if (proto.serverStreaming === true) {
-    kind = MethodKind.ServerStreaming;
-  } else {
-    kind = MethodKind.Unary;
-  }
-  let idempotency;
-  switch (proto.options?.idempotencyLevel) {
-    case MethodOptions_IdempotencyLevel.IDEMPOTENT:
-      idempotency = MethodIdempotency.Idempotent;
-      break;
-    case MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS:
-      idempotency = MethodIdempotency.NoSideEffects;
-      break;
-    case MethodOptions_IdempotencyLevel.IDEMPOTENCY_UNKNOWN:
-    case undefined:
-      idempotency = undefined;
-      break;
-  }
-  const inputTypeName = proto.inputType.startsWith(".")
-    ? proto.inputType.substring(1)
-    : proto.inputType;
-  const outputTypeName = proto.outputType.startsWith(".")
-    ? proto.outputType.substring(1)
-    : proto.outputType;
-  return {
-    proto,
-    parent,
-    name: proto.name,
-    kind,
-    idempotency,
-    inputTypeName,
-    outputTypeName,
-    toString() {
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
-      return `rpc ${this.parent.typeName}.${proto.name}`;
-    },
-  };
+    assert(proto.name, `invalid descriptor: missing method descriptor name`);
+    assert(proto.inputType, `invalid descriptor: missing method input type`);
+    assert(proto.outputType, `invalid descriptor: missing method output type`);
+    let kind;
+    if (proto.clientStreaming === true && proto.serverStreaming === true) {
+        kind = MethodKind.BiDiStreaming;
+    }
+    else if (proto.clientStreaming === true) {
+        kind = MethodKind.ClientStreaming;
+    }
+    else if (proto.serverStreaming === true) {
+        kind = MethodKind.ServerStreaming;
+    }
+    else {
+        kind = MethodKind.Unary;
+    }
+    let idempotency;
+    switch (proto.options?.idempotencyLevel) {
+        case MethodOptions_IdempotencyLevel.IDEMPOTENT:
+            idempotency = MethodIdempotency.Idempotent;
+            break;
+        case MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS:
+            idempotency = MethodIdempotency.NoSideEffects;
+            break;
+        case MethodOptions_IdempotencyLevel.IDEMPOTENCY_UNKNOWN:
+        case undefined:
+            idempotency = undefined;
+            break;
+    }
+    const inputTypeName = proto.inputType.startsWith(".")
+        ? proto.inputType.substring(1)
+        : proto.inputType;
+    const outputTypeName = proto.outputType.startsWith(".")
+        ? proto.outputType.substring(1)
+        : proto.outputType;
+    return {
+        proto,
+        parent,
+        name: proto.name,
+        kind,
+        idempotency,
+        inputTypeName,
+        outputTypeName,
+        toString() {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+            return `rpc ${this.parent.typeName}.${proto.name}`;
+        },
+    };
 }