@aptre/protobuf-es-lite 0.2.10 → 0.2.12

package/dist/create-descriptor-set.js

@@ -1,4 +1,3 @@
-"use strict";
 // Copyright 2021-2024 Buf Technologies, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,16 +11,14 @@
 // 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.createDescriptorSet = void 0;
-const assert_js_1 = require("./assert.js");
-const feature_set_js_1 = require("./feature-set.js");
-const field_js_1 = require("./field.js");
-const descriptor_pb_js_1 = require("./google/protobuf/descriptor.pb.js");
-const names_js_1 = require("./names.js");
-const scalar_js_1 = require("./scalar.js");
-const service_type_js_1 = require("./service-type.js");
-const text_format_js_1 = require("./text-format.js");
+import { assert } from "./assert.js";
+import { createFeatureResolver } from "./feature-set.js";
+import { fieldJsonName } from "./field.js";
+import { Edition, FeatureSet_RepeatedFieldEncoding, FieldDescriptorProto_Label, FieldDescriptorProto_Type, FieldOptions_JSType, FileDescriptorSet, MethodOptions_IdempotencyLevel, } from "./google/protobuf/descriptor.pb.js";
+import { findEnumSharedPrefix } from "./names.js";
+import { LongType, ScalarType } from "./scalar.js";
+import { MethodIdempotency, MethodKind } from "./service-type.js";
+import { parseTextFormatEnumValue, parseTextFormatScalarValue, } from "./text-format.js";
 /**
  * Create a DescriptorSet, a convenient interface for working with a set of
  * google.protobuf.FileDescriptorProto.
@@ -30,7 +27,7 @@ const text_format_js_1 = require("./text-format.js");
  * before any file that imports it. Protocol buffer compilers always produce
  * files in topological order.
  */
-function createDescriptorSet(input, options) {
+export function createDescriptorSet(input, options) {
     const cart = {
         files: [],
         enums: new Map(),
@@ -39,7 +36,7 @@ function createDescriptorSet(input, options) {
         extensions: new Map(),
         mapEntries: new Map(),
     };
-    const fileDescriptors = input instanceof Uint8Array ? descriptor_pb_js_1.FileDescriptorSet.fromBinary(input).file ?? []
+    const fileDescriptors = input instanceof Uint8Array ? FileDescriptorSet.fromBinary(input).file ?? []
         : Array.isArray(input) ? input
             : input.file ?? [];
     const resolverByEdition = new Map();
@@ -47,19 +44,18 @@ function createDescriptorSet(input, options) {
         const edition = proto.edition || parseFileSyntax(proto.syntax, proto.edition).edition;
         let resolveFeatures = resolverByEdition.get(edition);
         if (resolveFeatures === undefined) {
-            resolveFeatures = (0, feature_set_js_1.createFeatureResolver)(edition, options?.featureSetDefaults, options?.serializationOptions);
+            resolveFeatures = createFeatureResolver(edition, options?.featureSetDefaults, options?.serializationOptions);
             resolverByEdition.set(edition, resolveFeatures);
         }
         addFile(proto, cart, resolveFeatures);
     }
     return cart;
 }
-exports.createDescriptorSet = createDescriptorSet;
 /**
  * Create a descriptor for a file.
  */
 function addFile(proto, cart, resolveFeatures) {
-    (0, assert_js_1.assert)(proto.name, `invalid FileDescriptorProto: missing name`);
+    assert(proto.name, `invalid FileDescriptorProto: missing name`);
     const file = {
         kind: "file",
         proto,
@@ -170,7 +166,7 @@ function addFields(message, cart, resolveFeatures) {
  * parent type, if any.
  */
 function addEnum(proto, file, parent, cart, resolveFeatures) {
-    (0, assert_js_1.assert)(proto.name, `invalid EnumDescriptorProto: missing name`);
+    assert(proto.name, `invalid EnumDescriptorProto: missing name`);
     const desc = {
         kind: "enum",
         proto,
@@ -180,7 +176,7 @@ function addEnum(proto, file, parent, cart, resolveFeatures) {
         name: proto.name,
         typeName: makeTypeName(proto, parent, file),
         values: [],
-        sharedPrefix: (0, names_js_1.findEnumSharedPrefix)(proto.name, proto.value?.map((v) => v.name ?? "") ?? []),
+        sharedPrefix: findEnumSharedPrefix(proto.name, proto.value?.map((v) => v.name ?? "") ?? []),
         toString() {
             return `enum ${this.typeName}`;
         },
@@ -203,8 +199,8 @@ function addEnum(proto, file, parent, cart, resolveFeatures) {
     };
     cart.enums.set(desc.typeName, desc);
     proto.value?.forEach((proto) => {
-        (0, assert_js_1.assert)(proto.name, `invalid EnumValueDescriptorProto: missing name`);
-        (0, assert_js_1.assert)(proto.number !== undefined, `invalid EnumValueDescriptorProto: missing number`);
+        assert(proto.name, `invalid EnumValueDescriptorProto: missing name`);
+        assert(proto.number !== undefined, `invalid EnumValueDescriptorProto: missing number`);
         desc.values.push({
             kind: "enum_value",
             proto,
@@ -242,7 +238,7 @@ function addEnum(proto, file, parent, cart, resolveFeatures) {
  * cart. Note that this does not create descriptors fields.
  */
 function addMessage(proto, file, parent, cart, resolveFeatures) {
-    (0, assert_js_1.assert)(proto.name, `invalid DescriptorProto: missing name`);
+    assert(proto.name, `invalid DescriptorProto: missing name`);
     const desc = {
         kind: "message",
         proto,
@@ -296,7 +292,7 @@ function addMessage(proto, file, parent, cart, resolveFeatures) {
  * cart.
  */
 function addService(proto, file, cart, resolveFeatures) {
-    (0, assert_js_1.assert)(proto.name, `invalid ServiceDescriptorProto: missing name`);
+    assert(proto.name, `invalid ServiceDescriptorProto: missing name`);
     const desc = {
         kind: "service",
         proto,
@@ -329,39 +325,39 @@ function addService(proto, file, cart, resolveFeatures) {
  * Create a descriptor for a method.
  */
 function newMethod(proto, parent, cart, resolveFeatures) {
-    (0, assert_js_1.assert)(proto.name, `invalid MethodDescriptorProto: missing name`);
-    (0, assert_js_1.assert)(proto.inputType, `invalid MethodDescriptorProto: missing input_type`);
-    (0, assert_js_1.assert)(proto.outputType, `invalid MethodDescriptorProto: missing output_type`);
+    assert(proto.name, `invalid MethodDescriptorProto: missing name`);
+    assert(proto.inputType, `invalid MethodDescriptorProto: missing input_type`);
+    assert(proto.outputType, `invalid MethodDescriptorProto: missing output_type`);
     let methodKind;
     if (proto.clientStreaming === true && proto.serverStreaming === true) {
-        methodKind = service_type_js_1.MethodKind.BiDiStreaming;
+        methodKind = MethodKind.BiDiStreaming;
     }
     else if (proto.clientStreaming === true) {
-        methodKind = service_type_js_1.MethodKind.ClientStreaming;
+        methodKind = MethodKind.ClientStreaming;
     }
     else if (proto.serverStreaming === true) {
-        methodKind = service_type_js_1.MethodKind.ServerStreaming;
+        methodKind = MethodKind.ServerStreaming;
     }
     else {
-        methodKind = service_type_js_1.MethodKind.Unary;
+        methodKind = MethodKind.Unary;
     }
     let idempotency;
     switch (proto.options?.idempotencyLevel) {
-        case descriptor_pb_js_1.MethodOptions_IdempotencyLevel.IDEMPOTENT:
-            idempotency = service_type_js_1.MethodIdempotency.Idempotent;
+        case MethodOptions_IdempotencyLevel.IDEMPOTENT:
+            idempotency = MethodIdempotency.Idempotent;
             break;
-        case descriptor_pb_js_1.MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS:
-            idempotency = service_type_js_1.MethodIdempotency.NoSideEffects;
+        case MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS:
+            idempotency = MethodIdempotency.NoSideEffects;
             break;
-        case descriptor_pb_js_1.MethodOptions_IdempotencyLevel.IDEMPOTENCY_UNKNOWN:
+        case MethodOptions_IdempotencyLevel.IDEMPOTENCY_UNKNOWN:
         case undefined:
             idempotency = undefined;
             break;
     }
     const input = cart.messages.get(trimLeadingDot(proto.inputType));
     const output = cart.messages.get(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`);
+    assert(input, `invalid MethodDescriptorProto: input_type ${proto.inputType} not found`);
+    assert(output, `invalid MethodDescriptorProto: output_type ${proto.inputType} not found`);
     const name = proto.name;
     return {
         kind: "rpc",
@@ -393,7 +389,7 @@ function newMethod(proto, parent, cart, resolveFeatures) {
  * Create a descriptor for a oneof group.
  */
 function newOneof(proto, parent, resolveFeatures) {
-    (0, assert_js_1.assert)(proto.name, `invalid OneofDescriptorProto: missing name`);
+    assert(proto.name, `invalid OneofDescriptorProto: missing name`);
     return {
         kind: "oneof",
         proto,
@@ -421,9 +417,9 @@ function newOneof(proto, parent, resolveFeatures) {
  * Create a descriptor for a field.
  */
 function newField(proto, file, parent, oneof, cart, resolveFeatures) {
-    (0, assert_js_1.assert)(proto.name, `invalid FieldDescriptorProto: missing name`);
-    (0, assert_js_1.assert)(proto.number, `invalid FieldDescriptorProto: missing number`);
-    (0, assert_js_1.assert)(proto.type, `invalid FieldDescriptorProto: missing type`);
+    assert(proto.name, `invalid FieldDescriptorProto: missing name`);
+    assert(proto.number, `invalid FieldDescriptorProto: missing number`);
+    assert(proto.type, `invalid FieldDescriptorProto: missing type`);
     const common = {
         proto,
         deprecated: proto.options?.deprecated ?? false,
@@ -434,7 +430,7 @@ function newField(proto, file, parent, oneof, cart, resolveFeatures) {
         optional: isOptionalField(proto, file.syntax),
         packedByDefault: isPackedFieldByDefault(proto, resolveFeatures),
         packed: isPackedField(file, parent, proto, resolveFeatures),
-        jsonName: proto.jsonName === (0, field_js_1.fieldJsonName)(proto.name) ? undefined : proto.jsonName,
+        jsonName: proto.jsonName === fieldJsonName(proto.name) ? undefined : proto.jsonName,
         scalar: undefined,
         longType: undefined,
         message: undefined,
@@ -458,14 +454,14 @@ function newField(proto, file, parent, oneof, cart, resolveFeatures) {
             return resolveFeatures(parent.getFeatures(), proto.options?.features);
         },
     };
-    const repeated = proto.label === descriptor_pb_js_1.FieldDescriptorProto_Label.REPEATED;
+    const repeated = proto.label === FieldDescriptorProto_Label.REPEATED;
     switch (proto.type) {
-        case descriptor_pb_js_1.FieldDescriptorProto_Type.MESSAGE:
-        case descriptor_pb_js_1.FieldDescriptorProto_Type.GROUP: {
-            (0, assert_js_1.assert)(proto.typeName, `invalid FieldDescriptorProto: missing type_name`);
+        case FieldDescriptorProto_Type.MESSAGE:
+        case FieldDescriptorProto_Type.GROUP: {
+            assert(proto.typeName, `invalid FieldDescriptorProto: missing type_name`);
             const mapEntry = cart.mapEntries.get(trimLeadingDot(proto.typeName));
             if (mapEntry !== undefined) {
-                (0, assert_js_1.assert)(repeated, `invalid FieldDescriptorProto: expected map entry to be repeated`);
+                assert(repeated, `invalid FieldDescriptorProto: expected map entry to be repeated`);
                 return {
                     ...common,
                     kind: "field",
@@ -475,7 +471,7 @@ function newField(proto, file, parent, oneof, cart, resolveFeatures) {
                 };
             }
             const message = cart.messages.get(trimLeadingDot(proto.typeName));
-            (0, assert_js_1.assert)(message !== undefined, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`);
+            assert(message !== undefined, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`);
             return {
                 ...common,
                 kind: "field",
@@ -484,10 +480,10 @@ function newField(proto, file, parent, oneof, cart, resolveFeatures) {
                 message,
             };
         }
-        case descriptor_pb_js_1.FieldDescriptorProto_Type.ENUM: {
-            (0, assert_js_1.assert)(proto.typeName, `invalid FieldDescriptorProto: missing type_name`);
+        case FieldDescriptorProto_Type.ENUM: {
+            assert(proto.typeName, `invalid FieldDescriptorProto: missing type_name`);
             const e = cart.enums.get(trimLeadingDot(proto.typeName));
-            (0, assert_js_1.assert)(e !== undefined, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`);
+            assert(e !== undefined, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`);
             return {
                 ...common,
                 kind: "field",
@@ -499,7 +495,7 @@ function newField(proto, file, parent, oneof, cart, resolveFeatures) {
         }
         default: {
             const scalar = fieldTypeToScalarType[proto.type];
-            (0, assert_js_1.assert)(scalar, `invalid FieldDescriptorProto: unknown type ${proto.type}`);
+            assert(scalar, `invalid FieldDescriptorProto: unknown type ${proto.type}`);
             return {
                 ...common,
                 kind: "field",
@@ -507,9 +503,9 @@ function newField(proto, file, parent, oneof, cart, resolveFeatures) {
                 getDefaultValue,
                 repeated,
                 scalar,
-                longType: proto.options?.jstype == descriptor_pb_js_1.FieldOptions_JSType.JS_STRING ?
-                    scalar_js_1.LongType.STRING
-                    : scalar_js_1.LongType.BIGINT,
+                longType: proto.options?.jstype == FieldOptions_JSType.JS_STRING ?
+                    LongType.STRING
+                    : LongType.BIGINT,
             };
         }
     }
@@ -518,11 +514,11 @@ function newField(proto, file, parent, oneof, cart, resolveFeatures) {
  * Create a descriptor for an extension field.
  */
 function newExtension(proto, file, parent, cart, resolveFeatures) {
-    (0, assert_js_1.assert)(proto.extendee, `invalid FieldDescriptorProto: missing extendee`);
+    assert(proto.extendee, `invalid FieldDescriptorProto: missing extendee`);
     const field = newField(proto, file, null, // to safe us many lines of duplicated code, we trick the type system
     undefined, cart, resolveFeatures);
     const extendee = cart.messages.get(trimLeadingDot(proto.extendee));
-    (0, assert_js_1.assert)(extendee, `invalid FieldDescriptorProto: extendee ${proto.extendee} not found`);
+    assert(extendee, `invalid FieldDescriptorProto: extendee ${proto.extendee} not found`);
     return {
         ...field,
         kind: "extension",
@@ -564,23 +560,23 @@ function parseFileSyntax(syntax, edition) {
         case "":
         case "proto2":
             s = "proto2";
-            e = descriptor_pb_js_1.Edition.EDITION_PROTO2;
+            e = Edition.EDITION_PROTO2;
             break;
         case "proto3":
             s = "proto3";
-            e = descriptor_pb_js_1.Edition.EDITION_PROTO3;
+            e = Edition.EDITION_PROTO3;
             break;
         case "editions":
             s = "editions";
             switch (edition) {
                 case undefined:
-                case descriptor_pb_js_1.Edition.EDITION_1_TEST_ONLY:
-                case descriptor_pb_js_1.Edition.EDITION_2_TEST_ONLY:
-                case descriptor_pb_js_1.Edition.EDITION_99997_TEST_ONLY:
-                case descriptor_pb_js_1.Edition.EDITION_99998_TEST_ONLY:
-                case descriptor_pb_js_1.Edition.EDITION_99999_TEST_ONLY:
-                case descriptor_pb_js_1.Edition.EDITION_UNKNOWN:
-                    e = descriptor_pb_js_1.Edition.EDITION_UNKNOWN;
+                case Edition.EDITION_1_TEST_ONLY:
+                case Edition.EDITION_2_TEST_ONLY:
+                case Edition.EDITION_99997_TEST_ONLY:
+                case Edition.EDITION_99998_TEST_ONLY:
+                case Edition.EDITION_99999_TEST_ONLY:
+                case Edition.EDITION_UNKNOWN:
+                    e = Edition.EDITION_UNKNOWN;
                     break;
                 default:
                     e = edition;
@@ -590,7 +586,7 @@ function parseFileSyntax(syntax, edition) {
         default:
             throw new Error(`invalid FileDescriptorProto: unsupported syntax: ${syntax}`);
     }
-    if (syntax === "editions" && edition === descriptor_pb_js_1.Edition.EDITION_UNKNOWN) {
+    if (syntax === "editions" && edition === Edition.EDITION_UNKNOWN) {
         throw new Error(`invalid FileDescriptorProto: syntax ${syntax} cannot have edition ${String(edition)}`);
     }
     return {
@@ -604,7 +600,7 @@ function parseFileSyntax(syntax, edition) {
 function findFileDependencies(proto, cart) {
     return (proto.dependency?.map((wantName) => {
         const dep = cart.files.find((f) => f.proto.name === wantName);
-        (0, assert_js_1.assert)(dep);
+        assert(dep);
         return dep;
     }) ?? []);
 }
@@ -625,7 +621,7 @@ function findFileDependencies(proto, cart) {
  * - mypackage.MyMessage.extfield
  */
 function makeTypeName(proto, parent, file) {
-    (0, assert_js_1.assert)(proto.name, `invalid proto: missing name`);
+    assert(proto.name, `invalid proto: missing name`);
     let typeName;
     if (parent) {
         typeName = `${parent.typeName}.${proto.name}`;
@@ -645,17 +641,17 @@ function trimLeadingDot(typeName) {
     return typeName.startsWith(".") ? typeName.substring(1) : typeName;
 }
 function getMapFieldTypes(mapEntry) {
-    (0, assert_js_1.assert)(mapEntry.proto.options?.mapEntry, `invalid DescriptorProto: expected ${mapEntry.toString()} to be a map entry`);
-    (0, assert_js_1.assert)(mapEntry.fields.length === 2, `invalid DescriptorProto: map entry ${mapEntry.toString()} has ${mapEntry.fields.length} fields`);
+    assert(mapEntry.proto.options?.mapEntry, `invalid DescriptorProto: expected ${mapEntry.toString()} to be a map entry`);
+    assert(mapEntry.fields.length === 2, `invalid DescriptorProto: map entry ${mapEntry.toString()} has ${mapEntry.fields.length} fields`);
     const keyField = mapEntry.fields.find((f) => f.proto.number === 1);
-    (0, assert_js_1.assert)(keyField, `invalid DescriptorProto: map entry ${mapEntry.toString()} is missing key field`);
+    assert(keyField, `invalid DescriptorProto: map entry ${mapEntry.toString()} is missing key field`);
     const mapKey = keyField.scalar;
-    (0, assert_js_1.assert)(mapKey !== undefined &&
-        mapKey !== scalar_js_1.ScalarType.BYTES &&
-        mapKey !== scalar_js_1.ScalarType.FLOAT &&
-        mapKey !== scalar_js_1.ScalarType.DOUBLE, `invalid DescriptorProto: map entry ${mapEntry.toString()} has unexpected key type ${keyField.proto.type ?? -1}`);
+    assert(mapKey !== undefined &&
+        mapKey !== ScalarType.BYTES &&
+        mapKey !== ScalarType.FLOAT &&
+        mapKey !== ScalarType.DOUBLE, `invalid DescriptorProto: map entry ${mapEntry.toString()} has unexpected key type ${keyField.proto.type ?? -1}`);
     const valueField = mapEntry.fields.find((f) => f.proto.number === 2);
-    (0, assert_js_1.assert)(valueField, `invalid DescriptorProto: map entry ${mapEntry.toString()} is missing value field`);
+    assert(valueField, `invalid DescriptorProto: map entry ${mapEntry.toString()} is missing value field`);
     switch (valueField.fieldKind) {
         case "scalar":
             return {
@@ -695,9 +691,9 @@ function findOneof(proto, allOneofs) {
         return undefined;
     }
     let oneof;
-    if (proto.proto3Optional) {
+    if (!proto.proto3Optional) {
         oneof = allOneofs[oneofIndex];
-        (0, assert_js_1.assert)(oneof, `invalid FieldDescriptorProto: oneof #${oneofIndex} for field #${proto.number ?? -1} not found`);
+        assert(oneof, `invalid FieldDescriptorProto: oneof #${oneofIndex} for field #${proto.number ?? -1} not found`);
     }
     return oneof;
 }
@@ -709,7 +705,7 @@ function isOptionalField(proto, syntax) {
     switch (syntax) {
         case "proto2":
             return (proto.oneofIndex === undefined &&
-                proto.label === descriptor_pb_js_1.FieldDescriptorProto_Label.OPTIONAL);
+                proto.label === FieldDescriptorProto_Label.OPTIONAL);
         case "proto3":
             return proto.proto3Optional === true;
         case "editions":
@@ -726,7 +722,7 @@ function isOptionalField(proto, syntax) {
  */
 function isPackedFieldByDefault(proto, resolveFeatures) {
     const { repeatedFieldEncoding } = resolveFeatures();
-    if (repeatedFieldEncoding != descriptor_pb_js_1.FeatureSet_RepeatedFieldEncoding.PACKED) {
+    if (repeatedFieldEncoding != FeatureSet_RepeatedFieldEncoding.PACKED) {
         return false;
     }
     // From the proto3 language guide:
@@ -735,10 +731,10 @@ function isPackedFieldByDefault(proto, resolveFeatures) {
     // and ENUM are packed by default as well. This means only STRING and BYTES
     // are not packed by default, which makes sense because they are length-delimited.
     switch (proto.type) {
-        case descriptor_pb_js_1.FieldDescriptorProto_Type.STRING:
-        case descriptor_pb_js_1.FieldDescriptorProto_Type.BYTES:
-        case descriptor_pb_js_1.FieldDescriptorProto_Type.GROUP:
-        case descriptor_pb_js_1.FieldDescriptorProto_Type.MESSAGE:
+        case FieldDescriptorProto_Type.STRING:
+        case FieldDescriptorProto_Type.BYTES:
+        case FieldDescriptorProto_Type.GROUP:
+        case FieldDescriptorProto_Type.MESSAGE:
             return false;
         default:
             return true;
@@ -752,21 +748,21 @@ function isPackedFieldByDefault(proto, resolveFeatures) {
  */
 function isPackedField(file, parent, proto, resolveFeatures) {
     switch (proto.type) {
-        case descriptor_pb_js_1.FieldDescriptorProto_Type.STRING:
-        case descriptor_pb_js_1.FieldDescriptorProto_Type.BYTES:
-        case descriptor_pb_js_1.FieldDescriptorProto_Type.GROUP:
-        case descriptor_pb_js_1.FieldDescriptorProto_Type.MESSAGE:
+        case FieldDescriptorProto_Type.STRING:
+        case FieldDescriptorProto_Type.BYTES:
+        case FieldDescriptorProto_Type.GROUP:
+        case FieldDescriptorProto_Type.MESSAGE:
             // length-delimited types cannot be packed
             return false;
         default:
             switch (file.edition) {
-                case descriptor_pb_js_1.Edition.EDITION_PROTO2:
+                case Edition.EDITION_PROTO2:
                     return proto.options?.packed ?? false;
-                case descriptor_pb_js_1.Edition.EDITION_PROTO3:
+                case Edition.EDITION_PROTO3:
                     return proto.options?.packed ?? true;
                 default: {
                     const { repeatedFieldEncoding } = resolveFeatures(parent?.getFeatures() ?? file.getFeatures(), proto.options?.features);
-                    return (repeatedFieldEncoding == descriptor_pb_js_1.FeatureSet_RepeatedFieldEncoding.PACKED);
+                    return (repeatedFieldEncoding == FeatureSet_RepeatedFieldEncoding.PACKED);
                 }
             }
     }
@@ -776,24 +772,24 @@ function isPackedField(file, parent, proto, resolveFeatures) {
  * subset of field types declared by protobuf enum google.protobuf.FieldDescriptorProto.
  */
 const fieldTypeToScalarType = {
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.DOUBLE]: scalar_js_1.ScalarType.DOUBLE,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.FLOAT]: scalar_js_1.ScalarType.FLOAT,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.INT64]: scalar_js_1.ScalarType.INT64,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.UINT64]: scalar_js_1.ScalarType.UINT64,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.INT32]: scalar_js_1.ScalarType.INT32,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.FIXED64]: scalar_js_1.ScalarType.FIXED64,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.FIXED32]: scalar_js_1.ScalarType.FIXED32,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.BOOL]: scalar_js_1.ScalarType.BOOL,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.STRING]: scalar_js_1.ScalarType.STRING,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.GROUP]: undefined,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.MESSAGE]: undefined,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.BYTES]: scalar_js_1.ScalarType.BYTES,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.UINT32]: scalar_js_1.ScalarType.UINT32,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.ENUM]: undefined,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.SFIXED32]: scalar_js_1.ScalarType.SFIXED32,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.SFIXED64]: scalar_js_1.ScalarType.SFIXED64,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.SINT32]: scalar_js_1.ScalarType.SINT32,
-    [descriptor_pb_js_1.FieldDescriptorProto_Type.SINT64]: scalar_js_1.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,
 };
 /**
  * Find comments.
@@ -858,13 +854,13 @@ function declarationString() {
     }
     const file = this.kind === "extension" ? this.file : this.parent.file;
     if (file.syntax == "proto2" &&
-        this.proto.label === descriptor_pb_js_1.FieldDescriptorProto_Label.REQUIRED) {
+        this.proto.label === FieldDescriptorProto_Label.REQUIRED) {
         parts.push("required");
     }
     let type;
     switch (this.fieldKind) {
         case "scalar":
-            type = scalar_js_1.ScalarType[this.scalar].toLowerCase();
+            type = ScalarType[this.scalar].toLowerCase();
             break;
         case "enum":
             type = this.enum.typeName;
@@ -873,11 +869,11 @@ function declarationString() {
             type = this.message.typeName;
             break;
         case "map": {
-            const k = scalar_js_1.ScalarType[this.mapKey].toLowerCase();
+            const k = ScalarType[this.mapKey].toLowerCase();
             let v;
             switch (this.mapValue.kind) {
                 case "scalar":
-                    v = scalar_js_1.ScalarType[this.mapValue.scalar].toLowerCase();
+                    v = ScalarType[this.mapValue.scalar].toLowerCase();
                     break;
                 case "enum":
                     v = this.mapValue.enum.typeName;
@@ -897,8 +893,8 @@ function declarationString() {
     }
     let defaultValue = this.proto.defaultValue;
     if (defaultValue !== undefined) {
-        if (this.proto.type == descriptor_pb_js_1.FieldDescriptorProto_Type.BYTES ||
-            this.proto.type == descriptor_pb_js_1.FieldDescriptorProto_Type.STRING) {
+        if (this.proto.type == FieldDescriptorProto_Type.BYTES ||
+            this.proto.type == FieldDescriptorProto_Type.STRING) {
             defaultValue = '"' + defaultValue.replace('"', '\\"') + '"';
         }
         options.push(`default = ${defaultValue}`);
@@ -907,7 +903,7 @@ function declarationString() {
         options.push(`json_name = "${this.jsonName}"`);
     }
     if (this.proto.options?.jstype !== undefined) {
-        options.push(`jstype = ${descriptor_pb_js_1.FieldOptions_JSType[this.proto.options.jstype]}`);
+        options.push(`jstype = ${FieldOptions_JSType[this.proto.options.jstype]}`);
     }
     if (this.proto.options?.deprecated === true) {
         options.push(`deprecated = true`);
@@ -927,9 +923,9 @@ function getDefaultValue() {
     }
     switch (this.fieldKind) {
         case "enum":
-            return (0, text_format_js_1.parseTextFormatEnumValue)(this.enum, d);
+            return parseTextFormatEnumValue(this.enum, d);
         case "scalar":
-            return (0, text_format_js_1.parseTextFormatScalarValue)(this.scalar, d);
+            return parseTextFormatScalarValue(this.scalar, d);
         default:
             return undefined;
     }

package/dist/descriptor-set.js

@@ -1,4 +1,3 @@
-"use strict";
 // Copyright 2021-2024 Buf Technologies, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,4 +11,4 @@
 // 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 });
+export {};

package/dist/enum.js

@@ -1,17 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEnumType = exports.normalizeEnumValue = void 0;
-function normalizeEnumValue(value) {
+export function normalizeEnumValue(value) {
     if ("localName" in value) {
         return value;
     }
     return { ...value, localName: value.name };
 }
-exports.normalizeEnumValue = normalizeEnumValue;
 /**
  * Create a new EnumType with the given values.
  */
-function createEnumType(typeName, values, 
+export function createEnumType(typeName, values, 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 _opt) {
     const names = Object.create(null);
@@ -38,4 +34,3 @@ _opt) {
         },
     };
 }
-exports.createEnumType = createEnumType;

package/dist/feature-set.d.ts

@@ -14,6 +14,6 @@ export type MergedFeatureSet = FeatureSet & Required<FeatureSet>;
 export type FeatureResolverFn = (a?: FeatureSet, b?: FeatureSet) => MergedFeatureSet;
 /**
  * Create an edition feature resolver with the given feature set defaults, or
- * the feature set defaults supported by @bufbuild/protobuf.
+ * the feature set defaults supported by @aptre/protobuf-es-lite.
  */
 export declare function createFeatureResolver(edition: Edition, compiledFeatureSetDefaults?: FeatureSetDefaults, serializationOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>): FeatureResolverFn;