@aptre/protobuf-es-lite 0.3.1 → 0.4.1

package/dist/binary.d.ts

@@ -50,7 +50,7 @@ declare function readMapEntry(field: FieldInfo & {
 }, reader: IBinaryReader, options: BinaryReadOptions): [string | number, ScalarValue | AnyMessage | undefined];
 declare function readScalar(reader: IBinaryReader, type: ScalarType): ScalarValue;
 declare function readScalarLTString(reader: IBinaryReader, type: ScalarType): Exclude<ScalarValue, bigint>;
-declare function readMessage<T>(message: T, fields: FieldList, reader: IBinaryReader, lengthOrEndTagFieldNo: number, options: BinaryReadOptions, delimitedMessageEncoding?: boolean): void;
+declare function readMessage<T>(message: T, fields: FieldList, reader: IBinaryReader, lengthOrEndTagFieldNo: number, options: BinaryReadOptions, delimitedMessageEncoding: boolean): void;
 /**
  * Serialize a message to binary data.
  */

package/dist/binary.js

@@ -1,6 +1,6 @@
 import { isFieldSet, resolveMessageType, } from "./field.js";
 import { handleUnknownField, unknownFieldsSymbol } from "./unknown.js";
-import { wrapField } from "./field-wrapper.js";
+import { unwrapField, wrapField } from "./field-wrapper.js";
 import { LongType, ScalarType, scalarZeroValue, } from "./scalar.js";
 import { assert } from "./assert.js";
 import { BinaryReader, BinaryWriter, WireType, } from "./binary-encoding.js";
@@ -26,7 +26,7 @@ reader, field, wireType, options) {
     if (field.oneof) {
         var oneofMsg = target[field.oneof.localName];
         if (!oneofMsg) {
-            oneofMsg = target[field.oneof.localName] = {};
+            oneofMsg = target[field.oneof.localName] = Object.create(null);
         }
         target = oneofMsg;
         if (target.case != localName) {
@@ -74,19 +74,16 @@ reader, field, wireType, options) {
                 if (!Array.isArray(tgtArr)) {
                     tgtArr = target[localName] = [];
                 }
-                tgtArr.push(readMessageField(reader, {}, messageType.fields, options, field));
+                tgtArr.push(unwrapField(messageType.fieldWrapper, readMessageField(reader, Object.create(null), messageType.fields, options, field)));
             }
             else {
-                target[localName] = readMessageField(reader, {}, messageType.fields, options, field);
-                if (messageType.fieldWrapper && !field.oneof && !field.repeated) {
-                    target[localName] = messageType.fieldWrapper.unwrapField(target[localName]);
-                }
+                target[localName] = unwrapField(messageType.fieldWrapper, readMessageField(reader, Object.create(null), messageType.fields, options, field));
             }
             break;
         case "map":
             let [mapKey, mapVal] = readMapEntry(field, reader, options);
             if (typeof target[localName] !== "object") {
-                target[localName] = {};
+                target[localName] = Object.create(null);
             }
             // safe to assume presence of map object, oneof cannot contain repeated values
             target[localName][mapKey] = mapVal;
@@ -113,7 +110,7 @@ function readMapEntry(field, reader, options) {
                         break;
                     case "message":
                         const messageType = resolveMessageType(field.V.T);
-                        val = readMessageField(reader, {}, messageType.fields, options, undefined);
+                        val = readMessageField(reader, Object.create(null), messageType.fields, options, undefined);
                         break;
                 }
                 break;
@@ -135,7 +132,7 @@ function readMapEntry(field, reader, options) {
                 val = field.V.T.values[0].no;
                 break;
             case "message":
-                val = {};
+                val = Object.create(null);
                 break;
         }
     }
@@ -184,13 +181,10 @@ function readScalarLTString(reader, type) {
 // Read a message, avoiding MessageType.fromBinary() to re-use the
 // BinaryReadOptions and the IBinaryReader.
 function readMessageField(reader, message, fields, options, field) {
-    const delimited = field?.delimited;
-    readMessage(message, fields, reader, delimited ? field.no : reader.uint32(), // eslint-disable-line @typescript-eslint/strict-boolean-expressions
-    options, delimited);
+    readMessage(message, fields, reader, field?.delimited ? field.no : reader.uint32(), options, field?.delimited ?? false);
     return message;
 }
 function readMessage(message, fields, reader, lengthOrEndTagFieldNo, options, delimitedMessageEncoding) {
-    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     const end = delimitedMessageEncoding ? reader.len : reader.pos + lengthOrEndTagFieldNo;
     let fieldNo, wireType;
     while (reader.pos < end) {
@@ -227,7 +221,9 @@ function writeMessage(message, fields, writer, options) {
         const value = field.oneof ?
             message[field.oneof.localName].value
             : message[field.localName];
-        writeField(field, value, writer, options);
+        if (value !== undefined) {
+            writeField(field, value, writer, options);
+        }
     }
     if (options.writeUnknownFields) {
         writeUnknownFields(message, writer);

package/dist/enum.d.ts

@@ -1,3 +1,4 @@
+import { DescEnum } from "./index.js";
 /**
  * Reflection information for a protobuf enumeration.
  */
@@ -33,8 +34,17 @@ export interface EnumValueInfo {
      */
     readonly localName: string;
 }
-export declare function normalizeEnumValue(value: EnumValueInfo | Omit<EnumValueInfo, "localName">): EnumValueInfo;
 /**
  * Create a new EnumType with the given values.
  */
 export declare function createEnumType(typeName: string, values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[], _opt?: {}): EnumType;
+export declare function enumInfoZeroValue(values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[]): number;
+export declare function enumDescZeroValue(info: DescEnum): number;
+export declare function enumZeroValue<T extends EnumType>(info: T): number;
+/**
+ * Returns the normalized version of the enum value.
+ * Null is cast to the default value.
+ * String names are cast to the number enum.
+ * If string and the value is unknown, throws an error.
+ */
+export declare function normalizeEnumValue(info: EnumType, value: string | number | null | undefined): number;

package/dist/enum.js

@@ -1,9 +1,3 @@
-export function normalizeEnumValue(value) {
-    if ("localName" in value) {
-        return value;
-    }
-    return { ...value, localName: value.name };
-}
 /**
  * Create a new EnumType with the given values.
  */
@@ -16,7 +10,7 @@ _opt) {
     for (const value of values) {
         // We do not surface options at this time
         // const value: EnumValueInfo = {...v, options: v.options ?? emptyReadonlyObject};
-        const n = normalizeEnumValue(value);
+        const n = "localName" in value ? value : { ...value, localName: value.name };
         normalValues.push(n);
         names[value.name] = n;
         numbers[value.no] = n;
@@ -34,3 +28,58 @@ _opt) {
         },
     };
 }
+// enumInfoZeroValue returns the zero value for an enum info.
+export function enumInfoZeroValue(values) {
+    if (!values?.length) {
+        return 0;
+    }
+    // In proto3, the first enum value must be zero.
+    // In proto2, protobuf-go returns the first value as the default.
+    const zeroValue = values[0];
+    return zeroValue.no;
+}
+// enumDescZeroValue returns the zero value for an enum description.
+export function enumDescZeroValue(info) {
+    // In proto3, the first enum value must be zero.
+    // In proto2, protobuf-go returns the first value as the default.
+    if (info.values.length < 1) {
+        throw new Error("invalid enum: missing at least one value");
+    }
+    const zeroValue = info.values[0];
+    return zeroValue.number;
+}
+// enumZeroValue returns the zero value for an enum type.
+export function enumZeroValue(info) {
+    // In proto3, the first enum value must be zero.
+    // In proto2, protobuf-go returns the first value as the default.
+    if (info.values.length < 1) {
+        throw new Error("invalid enum: missing at least one value");
+    }
+    const zeroValue = info.values[0];
+    return zeroValue.no;
+}
+/**
+ * Returns the normalized version of the enum value.
+ * Null is cast to the default value.
+ * String names are cast to the number enum.
+ * If string and the value is unknown, throws an error.
+ */
+export function normalizeEnumValue(info, value) {
+    const zeroValue = enumZeroValue(info);
+    if (value == null) {
+        return zeroValue;
+    }
+    if (value === "" || value === zeroValue) {
+        return zeroValue;
+    }
+    if (typeof value === "string") {
+        // TODO: strip the type name prefix as well? MyEnum_VALUE
+        const val = info.findName(value);
+        if (!val) {
+            throw new Error(`enum ${info.typeName}: invalid value: "${value}"`);
+        }
+        return val.no;
+    }
+    // return the number value
+    return value;
+}

package/dist/field-wrapper.d.ts

@@ -5,7 +5,15 @@ import { ScalarType } from "./scalar.js";
  * ergonomic for use as a message field.
  */
 export interface FieldWrapper<T = any, U = any> {
+    /**
+     * Wrap a primitive message field value in its corresponding wrapper
+     * message. This function is idempotent.
+     */
     wrapField(value: U | null | undefined): T;
+    /**
+     * If the given field uses one of the well-known wrapper types, return
+     * the primitive type it wraps.
+     */
     unwrapField(value: T): U | null | undefined;
 }
 /**
@@ -13,6 +21,11 @@ export interface FieldWrapper<T = any, U = any> {
  * message. This function is idempotent.
  */
 export declare function wrapField<T>(fieldWrapper: FieldWrapper<T> | undefined, value: any): T;
+/**
+ * Wrap a primitive message field value in its corresponding wrapper
+ * message. This function is idempotent.
+ */
+export declare function unwrapField<T, U = T>(fieldWrapper: FieldWrapper<T> | undefined, value: any): U;
 /**
  * If the given field uses one of the well-known wrapper types, return
  * the primitive type it wraps.

package/dist/field-wrapper.js

@@ -9,6 +9,13 @@ export function wrapField(fieldWrapper, value) {
     }
     return fieldWrapper.wrapField(value);
 }
+/**
+ * Wrap a primitive message field value in its corresponding wrapper
+ * message. This function is idempotent.
+ */
+export function unwrapField(fieldWrapper, value) {
+    return !!fieldWrapper ? fieldWrapper.unwrapField(value) : value;
+}
 /**
  * If the given field uses one of the well-known wrapper types, return
  * the primitive type it wraps.

package/dist/field.d.ts

@@ -28,7 +28,42 @@ import { protoCamelCase } from "./names.js";
  * - "default": Only proto2: An explicit default value.
  * - "delimited": Only proto2: Use the tag-delimited group encoding.
  */
-export type FieldInfo = fiRules<fiScalar> | fiRules<fiEnum> | fiRules<fiMessage> | fiRules<fiMap>;
+export type FieldInfo = ScalarFieldInfo | EnumFieldInfo | MessageFieldInfo | MapFieldInfo;
+/**
+ * ScalarFieldInfo represents a scalar field.
+ * It includes rules for field presence, repetition, and packing.
+ */
+export type ScalarFieldInfo = fiRules<fiScalar>;
+/**
+ * EnumFieldInfo represents an enum field.
+ * It includes rules for field presence, repetition, and packing.
+ */
+export type EnumFieldInfo = fiRules<fiEnum>;
+/**
+ * MessageFieldInfo represents a message field.
+ * It includes rules for field presence, repetition, and packing.
+ */
+export type MessageFieldInfo = fiRules<fiMessage>;
+/**
+ * MapFieldInfo represents a map field with a scalar key type and
+ * a scalar, enum, or message value type.
+ * It includes rules for field presence, repetition, and packing.
+ */
+export type MapFieldInfo = fiRules<fiMap>;
+/**
+ * MapValueInfo represents the value type of a map field.
+ * The value can be a scalar, enum, or message type.
+ */
+export type MapValueInfo = {
+    readonly kind: "scalar";
+    readonly T: ScalarType;
+} | {
+    readonly kind: "enum";
+    readonly T: EnumType;
+} | {
+    readonly kind: "message";
+    readonly T: MessageType<any> | (() => MessageType<any>);
+};
 /**
  * Provides convenient access to field information of a message type.
  */
@@ -78,7 +113,7 @@ export declare function newFieldList(fields: FieldListSource, packedByDefault: b
 /**
  * Returns true if the field is set.
  */
-export declare function isFieldSet(field: FieldInfo, target: Record<string, any>): boolean;
+export declare function isFieldSet(field: FieldInfo, target: Record<string, any> | null | undefined): boolean;
 /**
  * Returns the JSON name for a protobuf field, exactly like protoc does.
  */
@@ -283,16 +318,7 @@ interface fiMap extends fiShared {
     /**
      * Map value type. Can be scalar, enum, or message.
      */
-    readonly V: {
-        readonly kind: "scalar";
-        readonly T: ScalarType;
-    } | {
-        readonly kind: "enum";
-        readonly T: EnumType;
-    } | {
-        readonly kind: "message";
-        readonly T: MessageType<any> | (() => MessageType<any>);
-    };
+    readonly V: MapValueInfo;
     /**
      * Is the field repeated? Never true for maps.
      */

package/dist/field.js

@@ -95,28 +95,32 @@ export function newFieldList(fields, packedByDefault) {
  */
 export function isFieldSet(field, target) {
     const localName = field.localName;
+    if (!target) {
+        return false;
+    }
     if (field.repeated) {
-        return target[localName].length > 0;
+        return !!target[localName]?.length;
     }
     if (field.oneof) {
-        return target[field.oneof.localName].case === localName; // eslint-disable-line @typescript-eslint/no-unsafe-member-access
+        return target[field.oneof.localName]?.case === localName; // eslint-disable-line @typescript-eslint/no-unsafe-member-access
     }
     switch (field.kind) {
         case "enum":
         case "scalar":
             if (field.opt || field.req) {
                 // explicit presence
-                return target[localName] !== undefined;
+                return target[localName] != null;
             }
             // implicit presence
             if (field.kind == "enum") {
                 return target[localName] !== field.T.values[0].no;
             }
+            // not zero value
             return !isScalarZeroValue(field.T, target[localName]);
         case "message":
-            return target[localName] !== undefined;
+            return target[localName] != null;
         case "map":
-            return Object.keys(target[localName]).length > 0; // eslint-disable-line @typescript-eslint/no-unsafe-argument
+            return (target[localName] != null && !!Object.keys(target[localName]).length); // eslint-disable-line @typescript-eslint/no-unsafe-argument
     }
 }
 /**

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

@@ -118,7 +118,8 @@ export type Timestamp = Message<{
 declare const Timestamp_Wkt: {
     fromJson(json: JsonValue): Timestamp;
     toJson(msg: Timestamp): JsonValue;
-    toDate(msg: Timestamp): Date;
+    toDate(msg: Timestamp | null | undefined): Date | null;
+    fromDate(value: Date | null | undefined): Timestamp;
 };
 export declare const Timestamp: MessageType<Timestamp> & typeof Timestamp_Wkt;
 export {};

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

@@ -89,8 +89,20 @@ const Timestamp_Wkt = {
         return new Date(ms).toISOString().replace(".000Z", z);
     },
     toDate(msg) {
+        if (!msg?.seconds && !msg?.nanos) {
+            return null;
+        }
         return new Date(Number(msg.seconds ?? 0) * 1000 + Math.ceil((msg.nanos ?? 0) / 1000000));
     },
+    fromDate(value) {
+        if (value == null) {
+            return {};
+        }
+        const ms = value.getTime();
+        const seconds = Math.floor(ms / 1000);
+        const nanos = (ms % 1000) * 1000000;
+        return { seconds: protoInt64.parse(seconds), nanos: nanos };
+    },
 };
 // Timestamp contains the message type declaration for Timestamp.
 export const Timestamp = createMessageType({

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

@@ -68,7 +68,7 @@ export const DoubleValue = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return DoubleValue.create({ value: value ?? undefined });
+            return DoubleValue.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -104,7 +104,7 @@ export const FloatValue = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return FloatValue.create({ value: value ?? undefined });
+            return FloatValue.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -140,7 +140,7 @@ export const Int64Value = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return Int64Value.create({ value: value ?? undefined });
+            return Int64Value.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -176,7 +176,7 @@ export const UInt64Value = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return UInt64Value.create({ value: value ?? undefined });
+            return UInt64Value.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -212,7 +212,7 @@ export const Int32Value = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return Int32Value.create({ value: value ?? undefined });
+            return Int32Value.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -248,7 +248,7 @@ export const UInt32Value = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return UInt32Value.create({ value: value ?? undefined });
+            return UInt32Value.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -284,7 +284,7 @@ export const BoolValue = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return BoolValue.create({ value: value ?? undefined });
+            return BoolValue.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -320,7 +320,7 @@ export const StringValue = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return StringValue.create({ value: value ?? undefined });
+            return StringValue.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -356,7 +356,7 @@ export const BytesValue = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return BytesValue.create({ value: value ?? undefined });
+            return BytesValue.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 export { Message, CompleteMessage, AnyMessage, MessageType, Field, compareMessages, createMessageType, } from "./message.js";
 export { ServiceType, MethodInfo, MethodInfoUnary, MethodInfoServerStreaming, MethodInfoClientStreaming, MethodInfoBiDiStreaming, MethodKind, MethodIdempotency, } from "./service-type.js";
 export { isCompleteMessage, isCompleteField } from "./is-message.js";
-export { newFieldList, FieldList, PartialFieldInfo, FieldInfo, OneofInfo, fieldJsonName, } from "./field.js";
+export { FieldList, PartialFieldInfo, FieldInfo, ScalarFieldInfo, EnumFieldInfo, MessageFieldInfo, MapFieldInfo, OneofInfo, newFieldList, fieldJsonName, } from "./field.js";
 export { applyPartialMessage } from "./partial.js";
 export { scalarEquals, scalarZeroValue, isScalarZeroValue, ScalarType, ScalarValue, LongType, } from "./scalar.js";
-export { createEnumType, normalizeEnumValue } from "./enum.js";
+export { EnumType, EnumValueInfo, createEnumType, enumInfoZeroValue, enumZeroValue, enumDescZeroValue, normalizeEnumValue, } from "./enum.js";
 export { localName, localFieldName, localOneofName, findEnumSharedPrefix, camelToSnakeCase, protoCamelCase, safeObjectProperty, safeIdentifier, } from "./names.js";
 export { int64FromString, int64ToString, uInt64ToString } from "./varint.js";
 export { protoInt64 } from "./proto-int64.js";
@@ -15,3 +15,4 @@ export { DescComments, AnyDesc, DescEnum, DescEnumValue, DescExtension, DescFiel
 export { jsonReadEnum, jsonReadField, jsonReadMapKey, jsonReadScalar, jsonReadMessage, jsonWriteEnum, jsonWriteField, jsonWriteScalar, jsonWriteMessage, jsonDebugValue, JsonValue, JsonObject, JsonReadOptions, jsonMakeReadOptions, JsonWriteOptions, JsonWriteStringOptions, jsonMakeWriteOptions, } from "./json.js";
 export { binaryReadField, binaryReadMapEntry, binaryReadScalar, binaryReadScalarLTString, binaryReadMessage, binaryWriteField, binaryWriteScalar, binaryWritePacked, binaryWriteMapEntry, binaryWriteMessage, binaryMakeReadOptions, binaryMakeWriteOptions, BinaryReadOptions, BinaryWriteOptions, } from "./binary.js";
 export type { IMessageTypeRegistry, IServiceTypeRegistry, IEnumTypeRegistry, } from "./type-registry.js";
+export { compareFieldZeroValue, isMessageZeroValue, getFieldZeroValue, } from "./zero-value.js";

package/dist/index.js

@@ -1,10 +1,10 @@
 export { compareMessages, createMessageType, } from "./message.js";
 export { MethodKind, MethodIdempotency, } from "./service-type.js";
 export { isCompleteMessage, isCompleteField } from "./is-message.js";
-export { newFieldList, FieldList, fieldJsonName, } from "./field.js";
+export { FieldList, newFieldList, fieldJsonName, } from "./field.js";
 export { applyPartialMessage } from "./partial.js";
 export { scalarEquals, scalarZeroValue, isScalarZeroValue, ScalarType, LongType, } from "./scalar.js";
-export { createEnumType, normalizeEnumValue } from "./enum.js";
+export { createEnumType, enumInfoZeroValue, enumZeroValue, enumDescZeroValue, normalizeEnumValue, } from "./enum.js";
 export { localName, localFieldName, localOneofName, findEnumSharedPrefix, camelToSnakeCase, protoCamelCase, safeObjectProperty, safeIdentifier, } from "./names.js";
 export { int64FromString, int64ToString, uInt64ToString } from "./varint.js";
 export { protoInt64 } from "./proto-int64.js";
@@ -13,3 +13,4 @@ export { protoDouble } from "./proto-double.js";
 export { Timestamp, Duration, Any, Empty, DoubleValue, FloatValue, Int64Value, UInt64Value, Int32Value, UInt32Value, BoolValue, StringValue, BytesValue, Value, NullValue, ListValue, Struct, } from "./google/index.js";
 export { jsonReadEnum, jsonReadField, jsonReadMapKey, jsonReadScalar, jsonReadMessage, jsonWriteEnum, jsonWriteField, jsonWriteScalar, jsonWriteMessage, jsonDebugValue, jsonMakeReadOptions, jsonMakeWriteOptions, } from "./json.js";
 export { binaryReadField, binaryReadMapEntry, binaryReadScalar, binaryReadScalarLTString, binaryReadMessage, binaryWriteField, binaryWriteScalar, binaryWritePacked, binaryWriteMapEntry, binaryWriteMessage, binaryMakeReadOptions, binaryMakeWriteOptions, } from "./binary.js";
+export { compareFieldZeroValue, isMessageZeroValue, getFieldZeroValue, } from "./zero-value.js";

package/dist/json.js

@@ -1,7 +1,8 @@
 import { isFieldSet, resolveMessageType, } from "./field.js";
 import { assert, assertFloat32, assertInt32, assertUInt32 } from "./assert.js";
-import { LongType, ScalarType, scalarZeroValue, } from "./scalar.js";
-import { wrapField } from "./field-wrapper.js";
+import { LongType, ScalarType, isScalarZeroValue, normalizeScalarValue, scalarZeroValue, } from "./scalar.js";
+import { unwrapField, wrapField } from "./field-wrapper.js";
+import { enumZeroValue, normalizeEnumValue } from "./enum.js";
 import { protoInt64 } from "./proto-int64.js";
 import { protoBase64 } from "./proto-base64.js";
 // Default options for parsing JSON.
@@ -65,7 +66,7 @@ function readMessage(fields, typeName, json, options, message) {
     return message;
 }
 function writeMessage(message, fields, options) {
-    const json = {};
+    const json = Object.create(null);
     let field;
     try {
         for (field of fields.byNumber()) {
@@ -123,7 +124,7 @@ function readField(target, jsonValue, field, options) {
             switch (field.kind) {
                 case "message":
                     const messageType = resolveMessageType(field.T);
-                    targetArray.push(messageType.fromJson(jsonItem, options));
+                    targetArray.push(unwrapField(messageType.fieldWrapper, messageType.fromJson(jsonItem, options)));
                     break;
                 case "enum":
                     const enumValue = readEnum(field.T, jsonItem, options.ignoreUnknownFields, true);
@@ -155,7 +156,7 @@ function readField(target, jsonValue, field, options) {
         }
         var targetMap = target[localName];
         if (typeof targetMap !== "object") {
-            targetMap = target[localName] = {};
+            targetMap = target[localName] = Object.create(null);
         }
         for (const [jsonMapKey, jsonMapValue] of Object.entries(jsonValue)) {
             if (jsonMapValue === null) {
@@ -210,11 +211,7 @@ function readField(target, jsonValue, field, options) {
                     messageType.typeName != "google.protobuf.Value") {
                     return;
                 }
-                let currentValue = target[localName];
-                target[localName] = currentValue = messageType.fromJson(jsonValue, options);
-                if (messageType.fieldWrapper && !field.oneof) {
-                    target[localName] = messageType.fieldWrapper.unwrapField(currentValue);
-                }
+                target[localName] = unwrapField(messageType.fieldWrapper, messageType.fromJson(jsonValue, options));
                 break;
             case "enum":
                 const enumValue = readEnum(field.T, jsonValue, options.ignoreUnknownFields, false);
@@ -418,7 +415,7 @@ export function clearField(field, target) {
     else {
         switch (field.kind) {
             case "map":
-                target[localName] = {};
+                target[localName] = Object.create(null);
                 break;
             case "enum":
                 target[localName] = implicitPresence ? field.T.values[0].no : undefined;
@@ -436,7 +433,6 @@ export function clearField(field, target) {
 // Decide whether an unset field should be emitted with JSON write option `emitDefaultValues`
 function canEmitFieldDefaultValue(field) {
     if (field.repeated || field.kind == "map") {
-        // maps are {}, repeated fields are []
         return true;
     }
     if (field.oneof) {
@@ -456,9 +452,9 @@ function canEmitFieldDefaultValue(field) {
 }
 function writeField(field, value, options) {
     if (field.kind == "map") {
-        assert(typeof value == "object" && value != null);
-        const jsonObj = {};
-        const entries = Object.entries(value);
+        const jsonObj = Object.create(null);
+        assert(!value || typeof value === "object");
+        const entries = value ? Object.entries(value) : [];
         switch (field.V.kind) {
             case "scalar":
                 for (const [entryKey, entryValue] of entries) {
@@ -485,24 +481,28 @@ function writeField(field, value, options) {
             : undefined;
     }
     if (field.repeated) {
-        assert(Array.isArray(value));
+        assert(!value || Array.isArray(value));
         const jsonArr = [];
-        switch (field.kind) {
-            case "scalar":
-                for (let i = 0; i < value.length; i++) {
-                    jsonArr.push(writeScalar(field.T, value[i]));
-                }
-                break;
-            case "enum":
-                for (let i = 0; i < value.length; i++) {
-                    jsonArr.push(writeEnum(field.T, value[i], options.enumAsInteger));
-                }
-                break;
-            case "message":
-                for (let i = 0; i < value.length; i++) {
-                    jsonArr.push(value[i].toJson(options));
-                }
-                break;
+        const valueArr = value;
+        if (valueArr && valueArr.length) {
+            switch (field.kind) {
+                case "scalar":
+                    for (let i = 0; i < valueArr.length; i++) {
+                        jsonArr.push(writeScalar(field.T, valueArr[i]));
+                    }
+                    break;
+                case "enum":
+                    for (let i = 0; i < valueArr.length; i++) {
+                        jsonArr.push(writeEnum(field.T, valueArr[i], options.enumAsInteger));
+                    }
+                    break;
+                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 ?
             jsonArr
@@ -510,10 +510,22 @@ function writeField(field, value, options) {
     }
     switch (field.kind) {
         case "scalar":
+            const scalarValue = normalizeScalarValue(field.T, value, false);
+            if (!options.emitDefaultValues
+                && isScalarZeroValue(field.T, scalarValue)) {
+                return undefined;
+            }
             return writeScalar(field.T, value);
         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":
+            if (!options.emitDefaultValues && value == null) {
+                return undefined;
+            }
             const messageType = resolveMessageType(field.T);
             return messageType.toJson(wrapField(messageType.fieldWrapper, value));
     }