@aptre/protobuf-es-lite 0.4.2 → 0.4.4

package/dist/binary.js

@@ -22,9 +22,10 @@ function makeWriteOptions(options) {
 }
 function readField(target, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
 reader, field, wireType, options) {
-    let { repeated, localName } = field;
+    const { repeated } = field;
+    let { localName } = field;
     if (field.oneof) {
-        var oneofMsg = target[field.oneof.localName];
+        let oneofMsg = target[field.oneof.localName];
         if (!oneofMsg) {
             oneofMsg = target[field.oneof.localName] = Object.create(null);
         }
@@ -37,7 +38,7 @@ reader, field, wireType, options) {
     }
     switch (field.kind) {
         case "scalar":
-        case "enum":
+        case "enum": {
             const scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
             let read = readScalar;
             // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- acceptable since it's covered by tests
@@ -45,7 +46,7 @@ reader, field, wireType, options) {
                 read = readScalarLTString;
             }
             if (repeated) {
-                var tgtArr = target[localName];
+                let tgtArr = target[localName];
                 if (!Array.isArray(tgtArr)) {
                     tgtArr = target[localName] = [];
                 }
@@ -53,7 +54,7 @@ reader, field, wireType, options) {
                     scalarType != ScalarType.STRING &&
                     scalarType != ScalarType.BYTES;
                 if (isPacked) {
-                    let e = reader.uint32() + reader.pos;
+                    const e = reader.uint32() + reader.pos;
                     while (reader.pos < e) {
                         tgtArr.push(read(reader, scalarType));
                     }
@@ -66,11 +67,12 @@ reader, field, wireType, options) {
                 target[localName] = read(reader, scalarType);
             }
             break;
-        case "message":
+        }
+        case "message": {
             const fieldT = field.T;
             const messageType = fieldT instanceof Function ? fieldT() : fieldT;
             if (repeated) {
-                var tgtArr = target[localName];
+                let tgtArr = target[localName];
                 if (!Array.isArray(tgtArr)) {
                     tgtArr = target[localName] = [];
                 }
@@ -80,14 +82,16 @@ reader, field, wireType, options) {
                 target[localName] = unwrapField(messageType.fieldWrapper, readMessageField(reader, Object.create(null), messageType.fields, options, field));
             }
             break;
-        case "map":
-            let [mapKey, mapVal] = readMapEntry(field, reader, options);
+        }
+        case "map": {
+            const [mapKey, mapVal] = readMapEntry(field, reader, options);
             if (typeof target[localName] !== "object") {
                 target[localName] = Object.create(null);
             }
             // safe to assume presence of map object, oneof cannot contain repeated values
             target[localName][mapKey] = mapVal;
             break;
+        }
     }
 }
 // Read a map field, expecting key field = 1, value field = 2
@@ -108,10 +112,10 @@ function readMapEntry(field, reader, options) {
                     case "enum":
                         val = reader.int32();
                         break;
-                    case "message":
-                        const messageType = resolveMessageType(field.V.T);
-                        val = readMessageField(reader, Object.create(null), messageType.fields, options, undefined);
+                    case "message": {
+                        val = readMessageField(reader, Object.create(null), resolveMessageType(field.V.T).fields, options, undefined);
                         break;
+                    }
                 }
                 break;
         }
@@ -119,8 +123,8 @@ function readMapEntry(field, reader, options) {
     if (key === undefined) {
         key = scalarZeroValue(field.K, LongType.BIGINT);
     }
-    if (typeof key != "string" && typeof key != "number") {
-        key = key.toString();
+    if (typeof key !== "string" && typeof key !== "number") {
+        key = key?.toString() ?? "";
     }
     if (val === undefined) {
         const fieldKind = field.V.kind;
@@ -170,6 +174,10 @@ function readScalar(reader, type) {
             return reader.uint32();
         case ScalarType.SINT32:
             return reader.sint32();
+        case ScalarType.DATE:
+            throw new Error("cannot read a date with readScalar");
+        default:
+            throw new Error("unknown scalar type");
     }
 }
 // Read a scalar value, but return 64 bit integral types (int64, uint64,
@@ -234,8 +242,8 @@ function writeField(field, value, writer, options) {
     const repeated = field.repeated;
     switch (field.kind) {
         case "scalar":
-        case "enum":
-            let scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
+        case "enum": {
+            const scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
             if (repeated) {
                 assert(Array.isArray(value));
                 if (field.packed) {
@@ -251,6 +259,7 @@ function writeField(field, value, writer, options) {
                 writeScalar(writer, scalarType, field.no, value);
             }
             break;
+        }
         case "message":
             if (repeated) {
                 assert(Array.isArray(value));
@@ -296,7 +305,7 @@ function writeMessageField(writer, options, field, value) {
 }
 function writeScalar(writer, type, fieldNo, value) {
     assert(value !== undefined);
-    let [wireType, method] = scalarTypeInfo(type);
+    const [wireType, method] = scalarTypeInfo(type);
     writer.tag(fieldNo, wireType)[method](value);
 }
 function writePacked(writer, type, fieldNo, value) {
@@ -304,7 +313,7 @@ function writePacked(writer, type, fieldNo, value) {
         return;
     }
     writer.tag(fieldNo, WireType.LengthDelimited).fork();
-    let [, method] = scalarTypeInfo(type);
+    const [, method] = scalarTypeInfo(type);
     for (let i = 0; i < value.length; i++) {
         writer[method](value[i]);
     }
@@ -373,13 +382,14 @@ function writeMapEntry(writer, options, field, key, value) {
         case "enum":
             writeScalar(writer, ScalarType.INT32, 2, value);
             break;
-        case "message":
+        case "message": {
             assert(value !== undefined);
             const messageType = resolveMessageType(field.V.T);
             writer
                 .tag(2, WireType.LengthDelimited)
                 .bytes(messageType.toBinary(value, options));
             break;
+        }
     }
     writer.join();
 }

package/dist/codegen-info.d.ts

@@ -1,5 +1,5 @@
 import { localName } from "./names.js";
-import { getUnwrappedFieldType } from "./field-wrapper.js";
+import { getUnwrappedFieldType, getUnwrappedMessageType } from "./field-wrapper.js";
 import { scalarZeroValue } from "./scalar.js";
 type RuntimeSymbolInfo = {
     typeOnly: boolean;
@@ -11,6 +11,7 @@ export declare const codegenInfo: {
     readonly packageName: "@aptre/protobuf-es-lite";
     readonly localName: typeof localName;
     readonly getUnwrappedFieldType: typeof getUnwrappedFieldType;
+    readonly getUnwrappedMessageType: typeof getUnwrappedMessageType;
     readonly scalarZeroValue: typeof scalarZeroValue;
     readonly safeIdentifier: (name: string) => string;
     readonly safeObjectProperty: (name: string) => string;

package/dist/codegen-info.js

@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { localName, safeIdentifier, safeObjectProperty } from "./names.js";
-import { getUnwrappedFieldType } from "./field-wrapper.js";
+import { getUnwrappedFieldType, getUnwrappedMessageType, } from "./field-wrapper.js";
 import { scalarZeroValue } from "./scalar.js";
 export const packageName = "@aptre/protobuf-es-lite";
 const symbolInfo = (typeOnly, privateImportPath) => ({
@@ -55,6 +55,7 @@ export const codegenInfo = {
     packageName,
     localName,
     getUnwrappedFieldType,
+    getUnwrappedMessageType,
     scalarZeroValue,
     safeIdentifier,
     safeObjectProperty,

package/dist/field-wrapper.d.ts

@@ -1,4 +1,4 @@
-import { DescExtension, DescField } from "./descriptor-set.js";
+import { DescExtension, DescField, DescMessage } from "./descriptor-set.js";
 import { ScalarType } from "./scalar.js";
 /**
  * A field wrapper unwraps a message to a primitive value that is more
@@ -31,3 +31,8 @@ export declare function unwrapField<T, U = T>(fieldWrapper: FieldWrapper<T> | un
  * the primitive type it wraps.
  */
 export declare function getUnwrappedFieldType(field: DescField | DescExtension): ScalarType | undefined;
+/**
+ * If the given field uses one of the well-known wrapper types, return
+ * the primitive type it wraps.
+ */
+export declare function getUnwrappedMessageType(msg: DescMessage): ScalarType | undefined;

package/dist/field-wrapper.js

@@ -14,7 +14,7 @@ export function wrapField(fieldWrapper, value) {
  * message. This function is idempotent.
  */
 export function unwrapField(fieldWrapper, value) {
-    return !!fieldWrapper ? fieldWrapper.unwrapField(value) : value;
+    return fieldWrapper ? fieldWrapper.unwrapField(value) : value;
 }
 /**
  * If the given field uses one of the well-known wrapper types, return
@@ -24,15 +24,25 @@ export function getUnwrappedFieldType(field) {
     if (field.fieldKind !== "message") {
         return undefined;
     }
-    if (field.repeated) {
-        return undefined;
+    if (field.message.typeName !== "google.protobuf.Timestamp") {
+        if (field.repeated || field.oneof != null) {
+            return undefined;
+        }
     }
-    if (field.oneof != undefined) {
+    return getUnwrappedMessageType(field.message);
+}
+/**
+ * If the given field uses one of the well-known wrapper types, return
+ * the primitive type it wraps.
+ */
+export function getUnwrappedMessageType(msg) {
+    if (msg.kind !== "message") {
         return undefined;
     }
-    return wktWrapperToScalarType[field.message.typeName];
+    return wktWrapperToScalarType[msg.typeName];
 }
 const wktWrapperToScalarType = {
+    "google.protobuf.Timestamp": ScalarType.DATE,
     "google.protobuf.DoubleValue": ScalarType.DOUBLE,
     "google.protobuf.FloatValue": ScalarType.FLOAT,
     "google.protobuf.Int64Value": ScalarType.INT64,

package/dist/google/protobuf/timestamp.pb.d.ts

@@ -120,6 +120,7 @@ declare const Timestamp_Wkt: {
     toJson(msg: Timestamp): JsonValue;
     toDate(msg: Timestamp | null | undefined): Date | null;
     fromDate(value: Date | null | undefined): Timestamp;
+    equals(a: Timestamp | Date | undefined | null, b: Timestamp | Date | undefined | null): boolean;
 };
 export declare const Timestamp: MessageType<Timestamp> & typeof Timestamp_Wkt;
 export {};

package/dist/google/protobuf/timestamp.pb.js

@@ -103,6 +103,17 @@ const Timestamp_Wkt = {
         const nanos = (ms % 1000) * 1000000;
         return { seconds: protoInt64.parse(seconds), nanos: nanos };
     },
+    equals(a, b) {
+        const aDate = a instanceof Date ? a : Timestamp_Wkt.toDate(a);
+        const bDate = b instanceof Date ? b : Timestamp_Wkt.toDate(b);
+        if (aDate === bDate) {
+            return true;
+        }
+        if (aDate == null || bDate == null) {
+            return aDate === bDate;
+        }
+        return +aDate === +bDate;
+    },
 };
 // Timestamp contains the message type declaration for Timestamp.
 export const Timestamp = createMessageType({
@@ -112,4 +123,15 @@ export const Timestamp = createMessageType({
         { no: 2, name: "nanos", kind: "scalar", T: ScalarType.INT32 },
     ],
     packedByDefault: true,
+    fieldWrapper: {
+        wrapField(value) {
+            if (value == null || value instanceof Date) {
+                return Timestamp_Wkt.fromDate(value);
+            }
+            return Timestamp.createComplete(value);
+        },
+        unwrapField(msg) {
+            return Timestamp_Wkt.toDate(msg);
+        },
+    },
 }, Timestamp_Wkt);

package/dist/is-message.js

@@ -41,9 +41,10 @@ export function isField(value, field) {
     switch (fieldKind) {
         case "scalar":
             return true;
-        case "message":
+        case "message": {
             const messageType = resolveMessageType(field.T);
             return isMessage(value, messageType.fields.list());
+        }
         case "enum":
             return typeof value === "number";
         case "map":
@@ -54,9 +55,10 @@ export function isField(value, field) {
                         return true;
                     case "enum":
                         return typeof val === "number";
-                    case "message":
+                    case "message": {
                         const messageType = resolveMessageType(field.V.T);
                         return isMessage(val, messageType.fields.list());
+                    }
                     default:
                         return valueKind;
                 }
@@ -102,9 +104,10 @@ export function isCompleteField(value, field) {
     switch (fieldKind) {
         case "scalar":
             return true;
-        case "message":
+        case "message": {
             const messageType = resolveMessageType(field.T);
             return isCompleteMessage(value, messageType.fields.list());
+        }
         case "enum":
             return typeof value === "number";
         case "map":
@@ -115,9 +118,10 @@ export function isCompleteField(value, field) {
                         return true;
                     case "enum":
                         return typeof val === "number";
-                    case "message":
+                    case "message": {
                         const messageType = resolveMessageType(field.V.T);
                         return isCompleteMessage(val, messageType.fields.list());
+                    }
                     default:
                         return valueKind;
                 }

package/dist/json.js

@@ -58,7 +58,7 @@ function readMessage(fields, typeName, json, options, message) {
             readField(message, jsonValue, field, options);
         }
         else {
-            let found = false;
+            const found = false;
             if (!found && !options.ignoreUnknownFields) {
                 throw new Error(`cannot decode message ${typeName} from JSON: key "${jsonKey}" is unknown`);
             }
@@ -114,7 +114,7 @@ function readField(target, jsonValue, field, options) {
         if (!Array.isArray(jsonValue)) {
             throw new Error(`cannot decode field ${field.name} from JSON: ${jsonDebugValue(jsonValue)}`);
         }
-        var targetArray = target[localName];
+        let targetArray = target[localName];
         if (!Array.isArray(targetArray)) {
             targetArray = target[localName] = [];
         }
@@ -123,16 +123,18 @@ function readField(target, jsonValue, field, options) {
                 throw new Error(`cannot decode field ${field.name} from JSON: ${jsonDebugValue(jsonItem)}`);
             }
             switch (field.kind) {
-                case "message":
+                case "message": {
                     const messageType = resolveMessageType(field.T);
                     targetArray.push(unwrapField(messageType.fieldWrapper, messageType.fromJson(jsonItem, options)));
                     break;
-                case "enum":
+                }
+                case "enum": {
                     const enumValue = readEnum(field.T, jsonItem, options.ignoreUnknownFields, true);
                     if (enumValue !== tokenIgnoredUnknownEnum) {
                         targetArray.push(enumValue);
                     }
                     break;
+                }
                 case "scalar":
                     try {
                         targetArray.push(readScalar(field.T, jsonItem, field.L, true));
@@ -155,7 +157,7 @@ function readField(target, jsonValue, field, options) {
         if (typeof jsonValue != "object" || Array.isArray(jsonValue)) {
             throw new Error(`cannot decode field ${field.name} from JSON: ${jsonDebugValue(jsonValue)}`);
         }
-        var targetMap = target[localName];
+        let targetMap = target[localName];
         if (typeof targetMap !== "object") {
             targetMap = target[localName] = Object.create(null);
         }
@@ -176,16 +178,18 @@ function readField(target, jsonValue, field, options) {
             }
             throwSanitizeKey(key);
             switch (field.V.kind) {
-                case "message":
+                case "message": {
                     const messageType = resolveMessageType(field.V.T);
                     targetMap[key] = messageType.fromJson(jsonMapValue, options);
                     break;
-                case "enum":
+                }
+                case "enum": {
                     const enumValue = readEnum(field.V.T, jsonMapValue, options.ignoreUnknownFields, true);
                     if (enumValue !== tokenIgnoredUnknownEnum) {
                         targetMap[key] = enumValue;
                     }
                     break;
+                }
                 case "scalar":
                     try {
                         targetMap[key] = readScalar(field.V.T, jsonMapValue, LongType.BIGINT, true);
@@ -207,7 +211,7 @@ function readField(target, jsonValue, field, options) {
             localName = "value";
         }
         switch (field.kind) {
-            case "message":
+            case "message": {
                 const messageType = resolveMessageType(field.T);
                 if (jsonValue === null &&
                     messageType.typeName != "google.protobuf.Value") {
@@ -215,7 +219,8 @@ function readField(target, jsonValue, field, options) {
                 }
                 target[localName] = unwrapField(messageType.fieldWrapper, messageType.fromJson(jsonValue, options));
                 break;
-            case "enum":
+            }
+            case "enum": {
                 const enumValue = readEnum(field.T, jsonValue, options.ignoreUnknownFields, false);
                 switch (enumValue) {
                     case tokenNull:
@@ -228,6 +233,7 @@ function readField(target, jsonValue, field, options) {
                         break;
                 }
                 break;
+            }
             case "scalar":
                 try {
                     const scalarValue = readScalar(field.T, jsonValue, field.L, false);
@@ -267,7 +273,7 @@ function readEnum(type, json, ignoreUnknownFields, nullAsZeroValue) {
                 return json;
             }
             break;
-        case "string":
+        case "string": {
             const value = type.findName(json);
             if (value !== undefined) {
                 return value.no;
@@ -276,6 +282,7 @@ function readEnum(type, json, ignoreUnknownFields, nullAsZeroValue) {
                 return tokenIgnoredUnknownEnum;
             }
             break;
+        }
     }
     throw new Error(`cannot decode enum ${type.typeName} from JSON: ${jsonDebugValue(json)}`);
 }
@@ -292,7 +299,7 @@ function readScalar(type, json, longType = LongType.BIGINT, nullAsZeroValue = tr
         // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
         // Either numbers or strings are accepted. Exponent notation is also accepted.
         case ScalarType.DOUBLE:
-        case ScalarType.FLOAT:
+        case ScalarType.FLOAT: {
             if (json === "NaN")
                 return Number.NaN;
             if (json === "Infinity")
@@ -322,12 +329,13 @@ function readScalar(type, json, longType = LongType.BIGINT, nullAsZeroValue = tr
             if (type == ScalarType.FLOAT)
                 assertFloat32(float);
             return float;
+        }
         // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
         case ScalarType.INT32:
         case ScalarType.FIXED32:
         case ScalarType.SFIXED32:
         case ScalarType.SINT32:
-        case ScalarType.UINT32:
+        case ScalarType.UINT32: {
             let int32;
             if (typeof json == "number")
                 int32 = json;
@@ -342,22 +350,25 @@ function readScalar(type, json, longType = LongType.BIGINT, nullAsZeroValue = tr
             else
                 assertInt32(int32);
             return int32;
+        }
         // int64, fixed64, uint64: JSON value will be a decimal string. Either numbers or strings are accepted.
         case ScalarType.INT64:
         case ScalarType.SFIXED64:
-        case ScalarType.SINT64:
+        case ScalarType.SINT64: {
             if (typeof json != "number" && typeof json != "string")
                 break;
             const long = protoInt64.parse(json);
             // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
             return longType ? long.toString() : long;
+        }
         case ScalarType.FIXED64:
-        case ScalarType.UINT64:
+        case ScalarType.UINT64: {
             if (typeof json != "number" && typeof json != "string")
                 break;
             const uLong = protoInt64.uParse(json);
             // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
             return longType ? uLong.toString() : uLong;
+        }
         // bool:
         case ScalarType.BOOL:
             if (typeof json !== "boolean")
@@ -400,7 +411,7 @@ function readMapKey(type, json) {
                 break;
         }
     }
-    return readScalar(type, json, LongType.BIGINT, true).toString();
+    return readScalar(type, json, LongType.BIGINT, true)?.toString() ?? "";
 }
 /**
  * Resets the field, so that isFieldSet() will return false.
@@ -470,13 +481,14 @@ function writeField(field, value, options) {
                     jsonObj[entryKey.toString()] = messageType.toJson(entryValue, options);
                 }
                 break;
-            case "enum":
+            case "enum": {
                 const enumType = field.V.T;
                 for (const [entryKey, entryValue] of entries) {
                     // JSON standard allows only (double quoted) string as property key
                     jsonObj[entryKey.toString()] = writeEnum(enumType, entryValue, options.enumAsInteger);
                 }
                 break;
+            }
         }
         return options.emitDefaultValues || entries.length > 0 ?
             jsonObj
@@ -498,12 +510,13 @@ function writeField(field, value, options) {
                         jsonArr.push(writeEnum(field.T, valueArr[i], options.enumAsInteger));
                     }
                     break;
-                case "message":
+                case "message": {
                     const messageType = resolveMessageType(field.T);
                     for (let i = 0; i < valueArr.length; i++) {
                         jsonArr.push(messageType.toJson(wrapField(messageType.fieldWrapper, valueArr[i])));
                     }
                     break;
+                }
             }
         }
         return options.emitDefaultValues || jsonArr.length > 0 ?
@@ -511,25 +524,28 @@ function writeField(field, value, options) {
             : undefined;
     }
     switch (field.kind) {
-        case "scalar":
+        case "scalar": {
             const scalarValue = normalizeScalarValue(field.T, value, false);
-            if (!options.emitDefaultValues
-                && isScalarZeroValue(field.T, scalarValue)) {
+            if (!options.emitDefaultValues &&
+                isScalarZeroValue(field.T, scalarValue)) {
                 return undefined;
             }
             return writeScalar(field.T, value);
-        case "enum":
+        }
+        case "enum": {
             const enumValue = normalizeEnumValue(field.T, value);
             if (!options.emitDefaultValues && enumZeroValue(field.T) === enumValue) {
                 return undefined;
             }
             return writeEnum(field.T, value, options.enumAsInteger);
-        case "message":
+        }
+        case "message": {
             if (!options.emitDefaultValues && value == null) {
                 return undefined;
             }
             const messageType = resolveMessageType(field.T);
             return messageType.toJson(wrapField(messageType.fieldWrapper, value));
+        }
     }
 }
 function writeScalar(type, value) {
@@ -578,6 +594,10 @@ function writeScalar(type, value) {
         case ScalarType.BYTES:
             assert(value instanceof Uint8Array);
             return protoBase64.enc(value);
+        case ScalarType.DATE:
+            throw new Error("cannot write date with writeScalar");
+        default:
+            throw new Error("unknown scalar type");
     }
 }
 function writeEnum(type, value, enumAsInteger) {

package/dist/message.d.ts

@@ -109,7 +109,7 @@ export type MessageTypeParams<T extends Message<T>> = Pick<MessageType<T>, "fiel
  * The argument `packedByDefault` specifies whether fields that do not specify
  * `packed` should be packed (proto3) or unpacked (proto2).
  */
-export declare function createMessageType<T extends Message<T>, E extends Record<string, Function> = {}>(params: MessageTypeParams<T>, exts?: E): MessageType<T> & E;
+export declare function createMessageType<T extends Message<T>, E extends Partial<MessageType<T>> = Partial<MessageType<T>>>(params: MessageTypeParams<T>, exts?: E): MessageType<T> & E;
 export declare function compareMessages<T extends Message<T>>(fields: FieldList, a: T | undefined | null, b: T | undefined | null): boolean;
 export declare function cloneMessage<T extends Message<T>>(message: T | null | undefined, fields: FieldList): T | null;
 /**

package/dist/message.js

@@ -119,9 +119,10 @@ export function compareMessages(fields, a, b) {
             }
             // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- repeated fields are never "map"
             switch (m.kind) {
-                case "message":
+                case "message": {
                     const messageType = resolveMessageType(m.T);
                     return va.every((a, i) => messageType.equals(a, vb[i]));
+                }
                 case "scalar":
                     return va.every((a, i) => scalarEquals(m.T, a, vb[i]));
                 case "enum":
@@ -136,7 +137,7 @@ export function compareMessages(fields, a, b) {
                 return scalarEquals(ScalarType.INT32, va, vb);
             case "scalar":
                 return scalarEquals(m.T, va, vb);
-            case "oneof":
+            case "oneof": {
                 if (va?.case !== vb?.case) {
                     return false;
                 }
@@ -149,27 +150,32 @@ export function compareMessages(fields, a, b) {
                 }
                 // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- oneof fields are never "map"
                 switch (s.kind) {
-                    case "message":
+                    case "message": {
                         const messageType = resolveMessageType(s.T);
                         return messageType.equals(va.value, vb.value);
+                    }
                     case "enum":
                         return scalarEquals(ScalarType.INT32, va.value, vb.value);
                     case "scalar":
                         return scalarEquals(s.T, va.value, vb.value);
                 }
                 throw new Error(`oneof cannot contain ${s.kind}`);
-            case "map":
+            }
+            case "map": {
                 const keys = Object.keys(va).concat(Object.keys(vb));
                 switch (m.V.kind) {
-                    case "message":
+                    case "message": {
                         const messageType = resolveMessageType(m.V.T);
                         return keys.every((k) => messageType.equals(va[k], vb[k]));
+                    }
                     case "enum":
                         return keys.every((k) => scalarEquals(ScalarType.INT32, va[k], vb[k]));
-                    case "scalar":
+                    case "scalar": {
                         const scalarType = m.V.T;
                         return keys.every((k) => scalarEquals(scalarType, va[k], vb[k]));
+                    }
                 }
+            }
         }
     });
 }
@@ -205,7 +211,7 @@ export function createCompleteMessage(fields) {
             case "enum":
                 message[localName] = field.repeated ? [] : enumZeroValue(field.T);
                 break;
-            case "message":
+            case "message": {
                 // oneofs are handled above
                 if (field.oneof) {
                     break;
@@ -216,10 +222,11 @@ export function createCompleteMessage(fields) {
                 }
                 const messageType = resolveMessageType(field.T);
                 message[localName] =
-                    !!messageType.fieldWrapper ?
+                    messageType.fieldWrapper ?
                         messageType.fieldWrapper.unwrapField(null)
                         : createCompleteMessage(messageType.fields);
                 break;
+            }
             case "map":
                 message[localName] = Object.create(null);
                 break;

package/dist/names.js

@@ -248,7 +248,9 @@ export const safeIdentifier = (name) => {
     return name;
 };
 export function checkSanitizeKey(key) {
-    return typeof key === "string" && !!key.length && !reservedObjectProperties.has(key);
+    return (typeof key === "string" &&
+        !!key.length &&
+        !reservedObjectProperties.has(key));
 }
 export function throwSanitizeKey(key) {
     if (typeof key !== "string") {

package/dist/partial.js

@@ -23,7 +23,7 @@ export function applyPartialMessage(source, target, fields, clone = false) {
             continue;
         }
         switch (member.kind) {
-            case "oneof":
+            case "oneof": {
                 if (typeof sourceValue !== "object") {
                     throw new Error(`field ${localName}: invalid oneof: must be an object with case and value`);
                 }
@@ -70,7 +70,8 @@ export function applyPartialMessage(source, target, fields, clone = false) {
                     dv.value = sv;
                 }
                 break;
-            case "scalar":
+            }
+            case "scalar": {
                 if (member.repeated) {
                     if (!Array.isArray(sourceValue)) {
                         throw new Error(`field ${localName}: invalid value: must be array`);
@@ -84,10 +85,12 @@ export function applyPartialMessage(source, target, fields, clone = false) {
                 }
                 t[localName] = normalizeScalarValue(member.T, sourceValue, clone);
                 break;
-            case "enum":
+            }
+            case "enum": {
                 t[localName] = normalizeEnumValue(member.T, sourceValue);
                 break;
-            case "map":
+            }
+            case "map": {
                 if (typeof sourceValue !== "object") {
                     throw new Error(`field ${member.localName}: invalid value: must be object`);
                 }
@@ -97,7 +100,8 @@ export function applyPartialMessage(source, target, fields, clone = false) {
                 }
                 applyPartialMap(sourceValue, tMap, member.V, clone);
                 break;
-            case "message":
+            }
+            case "message": {
                 const mt = resolveMessageType(member.T);
                 if (member.repeated) {
                     // skip null or undefined values
@@ -135,6 +139,7 @@ export function applyPartialMessage(source, target, fields, clone = false) {
                     applyPartialMessage(sourceValue, destMsg, mt.fields);
                 }
                 break;
+            }
         }
     }
 }
@@ -169,7 +174,7 @@ export function applyPartialMap(sourceMap, targetMap, value, clone) {
                 }
             }
             break;
-        case "message":
+        case "message": {
             const messageType = resolveMessageType(value.T);
             for (const [k, v] of Object.entries(sourceMap)) {
                 throwSanitizeKey(k);
@@ -181,7 +186,7 @@ export function applyPartialMap(sourceMap, targetMap, value, clone) {
                     throw new Error(`invalid value: must be object`);
                 }
                 let val = targetMap[k];
-                if (!!messageType.fieldWrapper) {
+                if (messageType.fieldWrapper) {
                     // For wrapper type messages, call createCompleteMessage.
                     val = targetMap[k] = createCompleteMessage(messageType.fields);
                 }
@@ -192,5 +197,6 @@ export function applyPartialMap(sourceMap, targetMap, value, clone) {
                 applyPartialMessage(v, val, messageType.fields);
             }
             break;
+        }
     }
 }

package/dist/protoc-gen-es-lite/typescript.js

@@ -28,32 +28,8 @@ export function generateTs(schema) {
         }
         const messageTypes = [];
         const dependencies = new Map();
-        function collectMessages(message) {
-            if (message.file !== file) {
-                return;
-            }
-            for (const nestedEnum of message.nestedEnums) {
-                generateEnum(schema, f, nestedEnum);
-            }
-            messageTypes.push(message);
-            const deps = new Set();
-            for (const field of message.fields) {
-                if (field.fieldKind === "message" && field.message.file === file) {
-                    deps.add(field.message);
-                }
-                else if (field.fieldKind === "map" &&
-                    field.mapValue.kind === "message" &&
-                    field.mapValue.message.file === file) {
-                    deps.add(field.mapValue.message);
-                }
-            }
-            dependencies.set(message, deps);
-            for (const nestedMessage of message.nestedMessages) {
-                collectMessages(nestedMessage);
-            }
-        }
         for (const message of file.messages) {
-            collectMessages(message);
+            collectMessages(schema, file, message, messageTypes, dependencies, f);
         }
         // Topological sort to ensure consts are declared in the right order.
         const sortedMessageTypes = topologicalSort(messageTypes, dependencies);
@@ -63,6 +39,31 @@ export function generateTs(schema) {
         // We do not generate anything for services or extensions
     }
 }
+// collectMessages collects a list of all message types and their dependencies.
+function collectMessages(schema, file, message, messageTypes, dependencies, f) {
+    if (message.file !== file) {
+        return;
+    }
+    for (const nestedEnum of message.nestedEnums) {
+        generateEnum(schema, f, nestedEnum);
+    }
+    messageTypes.push(message);
+    const deps = new Set();
+    for (const field of message.fields) {
+        if (field.fieldKind === "message" && field.message.file === file) {
+            deps.add(field.message);
+        }
+        else if (field.fieldKind === "map" &&
+            field.mapValue.kind === "message" &&
+            field.mapValue.message.file === file) {
+            deps.add(field.mapValue.message);
+        }
+    }
+    dependencies.set(message, deps);
+    for (const nestedMessage of message.nestedMessages) {
+        collectMessages(schema, file, nestedMessage, messageTypes, dependencies, f);
+    }
+}
 // topologicalSort sorts the list of messages by dependency order.
 function topologicalSort(messages, dependencies) {
     const result = [];
@@ -162,7 +163,7 @@ function generateField(f, field) {
 function generateOneof(f, oneof) {
     f.print();
     f.print(f.jsDoc(oneof, "  "));
-    var oneOfCases = oneof.fields
+    const oneOfCases = oneof.fields
         .map((field) => {
         const { typing } = getFieldTypeInfo(field);
         const doc = f.jsDoc(field, "    ");
@@ -186,7 +187,7 @@ export function generateFieldInfo(f, schema, field) {
     f.print("        ", getFieldInfoLiteral(schema, field), ",");
 }
 export const createTypeImport = (desc) => {
-    var name = localName(desc);
+    let name = localName(desc);
     if (desc.kind === "enum") {
         name += "_Enum";
     }
@@ -395,6 +396,17 @@ function generateWktMethods(schema, f, message, ref) {
             f.print("    const nanos = (ms % 1000) * 1000000;");
             f.print("    return { ", localName(ref.seconds), ": ", protoInt64, ".parse(seconds), ", localName(ref.nanos), ": nanos };");
             f.print("  },");
+            f.print("  equals(a: ", message, " | Date | undefined | null, b: ", message, " | Date | undefined | null): boolean {");
+            f.print("    const aDate = a instanceof Date ? a : ", message, "_Wkt.toDate(a);");
+            f.print("    const bDate = b instanceof Date ? b : ", message, "_Wkt.toDate(b);");
+            f.print("    if (aDate === bDate) {");
+            f.print("      return true;");
+            f.print("    }");
+            f.print("    if (aDate == null || bDate == null) {");
+            f.print("      return aDate === bDate;");
+            f.print("    }");
+            f.print("    return +aDate === +bDate;");
+            f.print("  },");
             break;
         case "google.protobuf.Duration":
             f.print("  fromJson(json: ", JsonValue, " | null | undefined, _options?: Partial<", JsonReadOptions, ">): ", message, " {");
@@ -560,30 +572,18 @@ function generateWktMethods(schema, f, message, ref) {
 }
 function generateWktFieldWrapper(f, message, ref) {
     switch (ref?.typeName) {
-        /* TODO Wrap Timestamp => Date
         case "google.protobuf.Timestamp": {
-          f.print("  fieldWrapper: {");
-          f.print(
-            "    wrapField(value: ",
-            message,
-            " | Date | null | undefined): ",
-            message,
-            " {",
-          );
-          f.print(
-            "      if (value == null || value instanceof Date) { return ",
-            message,
-            "_Wkt.fromDate(value); }",
-          );
-          f.print("      return ", message, ".createComplete(value);");
-          f.print("    },");
-          f.print("    unwrapField(msg: ", message, "): Date | null {");
-          f.print("      return ", message, "_Wkt.toDate(msg);");
-          f.print("    }");
-          f.print("  } as const,");
-          break;
+            f.print("  fieldWrapper: {");
+            f.print("    wrapField(value: ", message, " | Date | null | undefined): ", message, " {");
+            f.print("      if (value == null || value instanceof Date) { return ", message, "_Wkt.fromDate(value); }");
+            f.print("      return ", message, ".createComplete(value);");
+            f.print("    },");
+            f.print("    unwrapField(msg: ", message, "): Date | null {");
+            f.print("      return ", message, "_Wkt.toDate(msg);");
+            f.print("    }");
+            f.print("  } as const,");
+            break;
         }
-        */
         case "google.protobuf.DoubleValue":
         case "google.protobuf.FloatValue":
         case "google.protobuf.Int64Value":

package/dist/protoplugin/ecmascript/transpile.js

@@ -13,7 +13,6 @@
 // limitations under the License.
 import ts from "typescript";
 import { createDefaultMapFromNodeModules, createSystem, createVirtualCompilerHost, } from "@typescript/vfs";
-/* eslint-disable import/no-named-as-default-member */
 // The default options used to auto-transpile if needed.
 const defaultOptions = {
     // Type checking

package/dist/scalar.d.ts

@@ -18,7 +18,8 @@ export declare enum ScalarType {
     SFIXED32 = 15,
     SFIXED64 = 16,
     SINT32 = 17,// Uses ZigZag encoding.
-    SINT64 = 18
+    SINT64 = 18,// Uses ZigZag encoding.
+    DATE = 100
 }
 /**
  * JavaScript representation of fields with 64 bit integral types (int64, uint64,
@@ -50,11 +51,11 @@ export declare enum LongType {
 /**
  * ScalarValue maps from a scalar field type to a TypeScript value type.
  */
-export type ScalarValue<T = ScalarType, L extends LongType = LongType.STRING | LongType.BIGINT> = T extends ScalarType.STRING ? string : T extends ScalarType.INT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.SINT32 ? number : T extends ScalarType.FIXED32 ? number : T extends ScalarType.SFIXED32 ? number : T extends ScalarType.FLOAT ? number : T extends ScalarType.DOUBLE ? number : T extends ScalarType.INT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.SINT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.SFIXED64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.UINT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.FIXED64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.BOOL ? boolean : T extends ScalarType.BYTES ? Uint8Array : never;
+export type ScalarValue<T = ScalarType, L extends LongType = LongType.STRING | LongType.BIGINT> = T extends ScalarType.STRING ? string : T extends ScalarType.INT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.SINT32 ? number : T extends ScalarType.FIXED32 ? number : T extends ScalarType.SFIXED32 ? number : T extends ScalarType.FLOAT ? number : T extends ScalarType.DOUBLE ? number : T extends ScalarType.INT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.SINT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.SFIXED64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.UINT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.FIXED64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.BOOL ? boolean : T extends ScalarType.BYTES ? Uint8Array : T extends ScalarType.DATE ? null : never;
 /**
  * Returns true if both scalar values are equal.
  */
-export declare function scalarEquals(type: ScalarType, a: string | boolean | number | bigint | Uint8Array | undefined, b: string | boolean | number | bigint | Uint8Array | undefined): boolean;
+export declare function scalarEquals(type: ScalarType, a: string | boolean | number | bigint | Uint8Array | Date | null | undefined, b: string | boolean | number | bigint | Uint8Array | Date | null | undefined): boolean;
 /**
  * Returns the zero value for the given scalar type.
  */

package/dist/scalar.js

@@ -48,6 +48,8 @@ export var ScalarType;
     ScalarType[ScalarType["SFIXED64"] = 16] = "SFIXED64";
     ScalarType[ScalarType["SINT32"] = 17] = "SINT32";
     ScalarType[ScalarType["SINT64"] = 18] = "SINT64";
+    // DATE is not a Protobuf scalar type but used internally for the Timestamp wkt.
+    ScalarType[ScalarType["DATE"] = 100] = "DATE";
 })(ScalarType || (ScalarType = {}));
 /**
  * JavaScript representation of fields with 64 bit integral types (int64, uint64,
@@ -85,6 +87,10 @@ export function scalarEquals(type, a, b) {
         // This correctly matches equal values except BYTES and (possibly) 64-bit integers.
         return true;
     }
+    // Special case null/undefined - only equal if both are null/undefined
+    if (a == null || b == null) {
+        return a === b;
+    }
     // Special case BYTES - we need to compare each byte individually
     if (type == ScalarType.BYTES) {
         if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) {
@@ -100,6 +106,15 @@ export function scalarEquals(type, a, b) {
         }
         return true;
     }
+    // Special case DATE - we need to compare the numeric value
+    if (type == ScalarType.DATE) {
+        const dateA = toDate(a, false);
+        const dateB = toDate(b, false);
+        if (dateA == null || dateB == null) {
+            return dateA === dateB;
+        }
+        return dateA != null && dateB != null && +dateA === +dateB;
+    }
     // Special case 64-bit integers - we support number, string and bigint representation.
     // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
     switch (type) {
@@ -136,12 +151,15 @@ export function scalarZeroValue(type, longType) {
             return new Uint8Array(0);
         case ScalarType.STRING:
             return "";
+        case ScalarType.DATE:
+            return null;
         default:
             // Handles INT32, UINT32, SINT32, FIXED32, SFIXED32.
             // We do not use individual cases to save a few bytes code size.
             return 0;
     }
 }
+const dateZeroValue = +new Date(0);
 /**
  * Returns true for a zero-value. For example, an integer has the zero-value `0`,
  * a boolean is `false`, a string is `""`, and bytes is an empty Uint8Array.
@@ -151,6 +169,8 @@ export function scalarZeroValue(type, longType) {
  */
 export function isScalarZeroValue(type, value) {
     switch (type) {
+        case ScalarType.DATE:
+            return value == null || +value === dateZeroValue;
         case ScalarType.BOOL:
             return value === false;
         case ScalarType.STRING:
@@ -178,6 +198,9 @@ export function normalizeScalarValue(type, value, clone, longType = LongType.BIG
     if (isScalarZeroValue(type, value)) {
         return scalarZeroValue(type, longType);
     }
+    if (type === ScalarType.DATE) {
+        return toDate(value, clone);
+    }
     return value;
 }
 // converts any ArrayLike<number> to Uint8Array if necessary.
@@ -185,3 +208,13 @@ export function normalizeScalarValue(type, value, clone, longType = LongType.BIG
 export function toU8Arr(input, clone) {
     return !clone && input instanceof Uint8Array ? input : new Uint8Array(input);
 }
+function toDate(input, clone) {
+    if (input instanceof Date) {
+        return clone ? new Date(input.getTime()) : input;
+    }
+    if (typeof input === "string" || typeof input === "number") {
+        const date = new Date(input);
+        return isNaN(date.getTime()) ? null : date;
+    }
+    return null;
+}

package/dist/text-format.js

@@ -57,6 +57,11 @@ export function parseTextFormatScalarValue(type, value) {
         case ScalarType.FIXED32:
         case ScalarType.SFIXED32:
             return parseInt(value, 10);
+        case ScalarType.DATE:
+            // TODO
+            throw new Error("unimplemented: parse Date from text format");
+        default:
+            throw new Error(`cannot parse ${ScalarType[type]}`);
     }
 }
 /**

package/dist/util.js

@@ -29,17 +29,7 @@ export function getFieldTypeInfo(field) {
             typingInferrableFromZeroValue = true;
             break;
         case "message": {
-            const baseType = codegenInfo.getUnwrappedFieldType(field);
-            if (baseType !== undefined) {
-                typing.push(scalarTypeScriptType(baseType, LongType.BIGINT));
-            }
-            else {
-                typing.push({
-                    kind: "es_ref_message",
-                    type: field.message,
-                    typeOnly: true,
-                });
-            }
+            typing.push(getUnwrappedFieldScriptType(field));
             optional = true;
             typingInferrableFromZeroValue = true;
             break;
@@ -75,11 +65,7 @@ export function getFieldTypeInfo(field) {
                     valueType = scalarTypeScriptType(field.mapValue.scalar, LongType.BIGINT);
                     break;
                 case "message":
-                    valueType = {
-                        kind: "es_ref_message",
-                        type: field.mapValue.message,
-                        typeOnly: true,
-                    };
+                    valueType = getUnwrappedMessageScriptType(field.mapValue.message);
                     break;
                 case "enum":
                     valueType = {
@@ -127,6 +113,8 @@ export function getFieldDefaultValueExpression(field, enumAs = "enum_value_as_is
         }
         case "scalar":
             return literalScalarValue(defaultValue, field);
+        default:
+            return undefined;
     }
 }
 /**
@@ -205,6 +193,13 @@ function literalScalarValue(value, field) {
                 longType: field.longType,
                 value,
             };
+        case ScalarType.DATE:
+            if (value == null) {
+                return `null`;
+            }
+            return `new Date(${(value instanceof Date ? +value : value).toString()})`;
+        default:
+            throw new Error("unsupported scalar type for literalScalarValue");
     }
 }
 function literalEnumValue(value, enumAs) {
@@ -251,7 +246,29 @@ function scalarTypeScriptType(type, longType) {
             return "bigint";
         case ScalarType.BYTES:
             return "Uint8Array";
+        case ScalarType.DATE:
+            return "Date";
         default:
             return "number";
     }
 }
+function getUnwrappedFieldScriptType(field, longType) {
+    const baseType = codegenInfo.getUnwrappedFieldType(field);
+    return baseType ?
+        scalarTypeScriptType(baseType, longType ?? field.longType ?? LongType.BIGINT)
+        : {
+            kind: "es_ref_message",
+            type: field.message,
+            typeOnly: true,
+        };
+}
+function getUnwrappedMessageScriptType(msg, longType = LongType.BIGINT) {
+    const baseType = codegenInfo.getUnwrappedMessageType(msg);
+    return baseType !== undefined ?
+        scalarTypeScriptType(baseType, longType)
+        : {
+            kind: "es_ref_message",
+            type: msg,
+            typeOnly: true,
+        };
+}

package/example/example.pb.ts

@@ -2,14 +2,14 @@
 // @generated from file example/example.proto (package example, syntax proto3)
 /* eslint-disable */
 
-import type { MessageType, PartialFieldInfo } from "@aptre/protobuf-es-lite";
+import type { MessageType, PartialFieldInfo } from "../src/index.js";
 import {
   createEnumType,
   createMessageType,
   Message,
   ScalarType,
   Timestamp,
-} from "@aptre/protobuf-es-lite";
+} from "../src/index.js";
 
 export const protobufPackage = "example";
 
@@ -55,11 +55,11 @@ export type EchoMsg = Message<{
   /**
    * @generated from field: google.protobuf.Timestamp ts = 2;
    */
-  ts?: Timestamp;
+  ts?: Date;
   /**
    * @generated from field: repeated google.protobuf.Timestamp timestamps = 5;
    */
-  timestamps?: Timestamp[];
+  timestamps?: Date[];
 
   /**
    * @generated from oneof example.EchoMsg.demo

package/example/example.proto

@@ -2,6 +2,7 @@ syntax = "proto3";
 package example;
 
 import "google/protobuf/timestamp.proto";
+import "google/protobuf/empty.proto";
 
 // Echoer service returns the given message.
 service Echoer {
@@ -13,6 +14,8 @@ service Echoer {
   rpc EchoClientStream(stream EchoMsg) returns (EchoMsg);
   // EchoBidiStream is an example of a two-way stream.
   rpc EchoBidiStream(stream EchoMsg) returns (stream EchoMsg);
+  // DoNothing does nothing.
+  rpc DoNothing(.google.protobuf.Empty) returns (.google.protobuf.Empty);
 }
 
 // ExampleEnum is an example enumeration.

package/example/tsconfig.json

@@ -2,6 +2,7 @@
   "extends": "../tsconfig.json",
   "files": ["example.pb.ts"],
   "compilerOptions": {
+    "rootDir": "../",
     "paths": {
       "@aptre/protobuf-es-lite": [
         "../src",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aptre/protobuf-es-lite",
   "description": "Lightweight Protobuf codegen for TypeScript and JavaScript.",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "license": "Apache-2.0",
   "repository": {
     "url": "git+ssh://git@github.com/aperturerobotics/protobuf-es-lite.git"
@@ -56,6 +56,7 @@
     "format": "prettier --write './src/**/(*.ts|*.tsx|*.html|*.css|*.scss)'",
     "precommit": "lint-staged",
     "test": "vitest run",
+    "lint": "ESLINT_USE_FLAT_CONFIG=false eslint -c .eslintrc.cjs ./",
     "release:version": "npm version patch -m \"release: v%s\" --no-git-tag-version",
     "release:version:minor": "npm version minor -m \"release: v%s\" --no-git-tag-version",
     "release:commit": "git reset && git add package.json && git commit -s -m \"release: v$npm_package_version\" && git tag v$npm_package_version",
@@ -72,13 +73,18 @@
     "lz-string": "^1.5.0"
   },
   "devDependencies": {
-    "@types/node": "^20.12.7",
+    "@types/node": "^20.12.12",
+    "@typescript-eslint/eslint-plugin": "^7.9.0",
+    "@typescript-eslint/parser": "^7.9.0",
+    "eslint": "^9.2.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-unused-imports": "^3.2.0",
     "lint-staged": ">=10",
     "pre-commit": "^1.2.2",
     "prettier": "^3.2.5",
-    "rimraf": "^5.0.5",
+    "rimraf": "^5.0.7",
     "typescript": "^5.4.5",
-    "vitest": "^1.5.3"
+    "vitest": "^1.6.0"
   },
   "lint-staged": {
     "package.json": "prettier --write",

package/tsconfig.base.json

@@ -3,7 +3,6 @@
     "target": "es2022",
     "module": "Node16",
     "moduleResolution": "Node16",
-    "esModuleInterop": false,
     "forceConsistentCasingInFileNames": true,
     "strict": true,
     "noImplicitAny": true,
@@ -17,8 +16,9 @@
     "noImplicitReturns": true,
     "noFallthroughCasesInSwitch": true,
     "noImplicitOverride": true,
-    "verbatimModuleSyntax": true,
-    "skipLibCheck": false,
-    "declaration": true
+    "declaration": true,
+    "verbatimModuleSyntax": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
   }
 }

package/tsconfig.json

@@ -2,9 +2,6 @@
   "files": ["src/protoc-gen-es-lite/protoc-gen-es-lite-plugin.ts", "src/index.ts", "src/protoplugin/index.ts", "src/protoplugin/ecmascript/index.ts"],
   "extends": "./tsconfig.base.json",
   "compilerOptions": {
-    "verbatimModuleSyntax": false,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
     "rootDir": "./src"
   }
 }