@aptre/protobuf-es-lite 0.2.9 → 0.2.11

package/bin/protoc-gen-es-lite

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-const {runNodeJs} = require("../dist/protoplugin");
-const {protocGenEsLite} = require("../dist/protoc-gen-es-lite/protoc-gen-es-lite-plugin.js");
+import {runNodeJs} from "../dist/protoplugin/index.js";
+import {protocGenEsLite} from "../dist/protoc-gen-es-lite/protoc-gen-es-lite-plugin.js";
 
 runNodeJs(protocGenEsLite);

package/dist/assert.js

@@ -1,4 +1,3 @@
-"use strict";
 // Copyright 2021-2024 Buf Technologies, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,43 +11,38 @@
 // 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.assertFloat32 = exports.assertUInt32 = exports.assertInt32 = exports.assert = void 0;
 /**
  * Assert that condition is truthy or throw error (with message)
  */
-function assert(condition, msg) {
+export function assert(condition, msg) {
     // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- we want the implicit conversion to boolean
     if (!condition) {
         throw new Error(msg);
     }
 }
-exports.assert = assert;
 const FLOAT32_MAX = 3.4028234663852886e38, FLOAT32_MIN = -3.4028234663852886e38, UINT32_MAX = 0xffffffff, INT32_MAX = 0x7fffffff, INT32_MIN = -0x80000000;
 /**
  * Assert a valid signed protobuf 32-bit integer.
  */
-function assertInt32(arg) {
+export function assertInt32(arg) {
     if (typeof arg !== "number")
         throw new Error("invalid int 32: " + typeof arg);
     if (!Number.isInteger(arg) || arg > INT32_MAX || arg < INT32_MIN)
         throw new Error("invalid int 32: " + arg); // eslint-disable-line @typescript-eslint/restrict-plus-operands -- we want the implicit conversion to string
 }
-exports.assertInt32 = assertInt32;
 /**
  * Assert a valid unsigned protobuf 32-bit integer.
  */
-function assertUInt32(arg) {
+export function assertUInt32(arg) {
     if (typeof arg !== "number")
         throw new Error("invalid uint 32: " + typeof arg);
     if (!Number.isInteger(arg) || arg > UINT32_MAX || arg < 0)
         throw new Error("invalid uint 32: " + arg); // eslint-disable-line @typescript-eslint/restrict-plus-operands -- we want the implicit conversion to string
 }
-exports.assertUInt32 = assertUInt32;
 /**
  * Assert a valid protobuf float value.
  */
-function assertFloat32(arg) {
+export function assertFloat32(arg) {
     if (typeof arg !== "number")
         throw new Error("invalid float 32: " + typeof arg);
     if (!Number.isFinite(arg))
@@ -56,4 +50,3 @@ function assertFloat32(arg) {
     if (arg > FLOAT32_MAX || arg < FLOAT32_MIN)
         throw new Error("invalid float 32: " + arg); // eslint-disable-line @typescript-eslint/restrict-plus-operands -- we want the implicit conversion to string
 }
-exports.assertFloat32 = assertFloat32;

package/dist/binary-encoding.js

@@ -1,4 +1,3 @@
-"use strict";
 // Copyright 2021-2024 Buf Technologies, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,11 +11,9 @@
 // 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.BinaryReader = exports.BinaryWriter = exports.WireType = void 0;
-const varint_js_1 = require("./varint.js");
-const assert_js_1 = require("./assert.js");
-const proto_int64_js_1 = require("./proto-int64.js");
+import { varint32read, varint32write, varint64read, varint64write, } from "./varint.js";
+import { assertFloat32, assertInt32, assertUInt32 } from "./assert.js";
+import { protoInt64 } from "./proto-int64.js";
 /* eslint-disable prefer-const,no-case-declarations,@typescript-eslint/restrict-plus-operands */
 /**
  * Protobuf binary format wire types.
@@ -26,7 +23,7 @@ const proto_int64_js_1 = require("./proto-int64.js");
  *
  * See https://developers.google.com/protocol-buffers/docs/encoding#structure
  */
-var WireType;
+export var WireType;
 (function (WireType) {
     /**
      * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum
@@ -59,8 +56,8 @@ var WireType;
      * Always 4 bytes with little-endian byte order.
      */
     WireType[WireType["Bit32"] = 5] = "Bit32";
-})(WireType || (exports.WireType = WireType = {}));
-class BinaryWriter {
+})(WireType || (WireType = {}));
+export class BinaryWriter {
     constructor(textEncoder) {
         /**
          * Previous fork states.
@@ -141,7 +138,7 @@ class BinaryWriter {
      * Write a `uint32` value, an unsigned 32 bit varint.
      */
     uint32(value) {
-        (0, assert_js_1.assertUInt32)(value);
+        assertUInt32(value);
         // write value as varint 32, inlined for speed
         while (value > 0x7f) {
             this.buf.push((value & 0x7f) | 0x80);
@@ -154,8 +151,8 @@ class BinaryWriter {
      * Write a `int32` value, a signed 32 bit varint.
      */
     int32(value) {
-        (0, assert_js_1.assertInt32)(value);
-        (0, varint_js_1.varint32write)(value, this.buf);
+        assertInt32(value);
+        varint32write(value, this.buf);
         return this;
     }
     /**
@@ -184,7 +181,7 @@ class BinaryWriter {
      * Write a `float` value, 32-bit floating point number.
      */
     float(value) {
-        (0, assert_js_1.assertFloat32)(value);
+        assertFloat32(value);
         let chunk = new Uint8Array(4);
         new DataView(chunk.buffer).setFloat32(0, value, true);
         return this.raw(chunk);
@@ -201,7 +198,7 @@ class BinaryWriter {
      * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
      */
     fixed32(value) {
-        (0, assert_js_1.assertUInt32)(value);
+        assertUInt32(value);
         let chunk = new Uint8Array(4);
         new DataView(chunk.buffer).setUint32(0, value, true);
         return this.raw(chunk);
@@ -210,7 +207,7 @@ class BinaryWriter {
      * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
      */
     sfixed32(value) {
-        (0, assert_js_1.assertInt32)(value);
+        assertInt32(value);
         let chunk = new Uint8Array(4);
         new DataView(chunk.buffer).setInt32(0, value, true);
         return this.raw(chunk);
@@ -219,17 +216,17 @@ class BinaryWriter {
      * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
      */
     sint32(value) {
-        (0, assert_js_1.assertInt32)(value);
+        assertInt32(value);
         // zigzag encode
         value = ((value << 1) ^ (value >> 31)) >>> 0;
-        (0, varint_js_1.varint32write)(value, this.buf);
+        varint32write(value, this.buf);
         return this;
     }
     /**
      * Write a `fixed64` value, a signed, fixed-length 64-bit integer.
      */
     sfixed64(value) {
-        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = proto_int64_js_1.protoInt64.enc(value);
+        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.enc(value);
         view.setInt32(0, tc.lo, true);
         view.setInt32(4, tc.hi, true);
         return this.raw(chunk);
@@ -238,7 +235,7 @@ class BinaryWriter {
      * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
      */
     fixed64(value) {
-        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = proto_int64_js_1.protoInt64.uEnc(value);
+        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.uEnc(value);
         view.setInt32(0, tc.lo, true);
         view.setInt32(4, tc.hi, true);
         return this.raw(chunk);
@@ -247,37 +244,36 @@ class BinaryWriter {
      * Write a `int64` value, a signed 64-bit varint.
      */
     int64(value) {
-        let tc = proto_int64_js_1.protoInt64.enc(value);
-        (0, varint_js_1.varint64write)(tc.lo, tc.hi, this.buf);
+        let tc = protoInt64.enc(value);
+        varint64write(tc.lo, tc.hi, this.buf);
         return this;
     }
     /**
      * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
      */
     sint64(value) {
-        let tc = proto_int64_js_1.protoInt64.enc(value), 
+        let tc = protoInt64.enc(value), 
         // zigzag encode
         sign = tc.hi >> 31, lo = (tc.lo << 1) ^ sign, hi = ((tc.hi << 1) | (tc.lo >>> 31)) ^ sign;
-        (0, varint_js_1.varint64write)(lo, hi, this.buf);
+        varint64write(lo, hi, this.buf);
         return this;
     }
     /**
      * Write a `uint64` value, an unsigned 64-bit varint.
      */
     uint64(value) {
-        let tc = proto_int64_js_1.protoInt64.uEnc(value);
-        (0, varint_js_1.varint64write)(tc.lo, tc.hi, this.buf);
+        let tc = protoInt64.uEnc(value);
+        varint64write(tc.lo, tc.hi, this.buf);
         return this;
     }
 }
-exports.BinaryWriter = BinaryWriter;
-class BinaryReader {
+export class BinaryReader {
     constructor(buf, textDecoder) {
-        this.varint64 = varint_js_1.varint64read; // dirty cast for `this`
+        this.varint64 = varint64read; // dirty cast for `this`
         /**
          * Read a `uint32` field, an unsigned 32 bit varint.
          */
-        this.uint32 = varint_js_1.varint32read; // dirty cast for `this` and access to protected `buf`
+        this.uint32 = varint32read; // dirty cast for `this` and access to protected `buf`
         this.buf = buf;
         this.len = buf.length;
         this.pos = 0;
@@ -356,13 +352,13 @@ class BinaryReader {
      * Read a `int64` field, a signed 64-bit varint.
      */
     int64() {
-        return proto_int64_js_1.protoInt64.dec(...this.varint64());
+        return protoInt64.dec(...this.varint64());
     }
     /**
      * Read a `uint64` field, an unsigned 64-bit varint.
      */
     uint64() {
-        return proto_int64_js_1.protoInt64.uDec(...this.varint64());
+        return protoInt64.uDec(...this.varint64());
     }
     /**
      * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
@@ -373,7 +369,7 @@ class BinaryReader {
         let s = -(lo & 1);
         lo = ((lo >>> 1) | ((hi & 1) << 31)) ^ s;
         hi = (hi >>> 1) ^ s;
-        return proto_int64_js_1.protoInt64.dec(lo, hi);
+        return protoInt64.dec(lo, hi);
     }
     /**
      * Read a `bool` field, a variant.
@@ -398,13 +394,13 @@ class BinaryReader {
      * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
      */
     fixed64() {
-        return proto_int64_js_1.protoInt64.uDec(this.sfixed32(), this.sfixed32());
+        return protoInt64.uDec(this.sfixed32(), this.sfixed32());
     }
     /**
      * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
      */
     sfixed64() {
-        return proto_int64_js_1.protoInt64.dec(this.sfixed32(), this.sfixed32());
+        return protoInt64.dec(this.sfixed32(), this.sfixed32());
     }
     /**
      * Read a `float` field, 32-bit floating point number.
@@ -434,4 +430,3 @@ class BinaryReader {
         return this.textDecoder.decode(this.bytes());
     }
 }
-exports.BinaryReader = BinaryReader;

package/dist/binary.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeMapEntry = exports.writeMessage = exports.readMessage = exports.makeWriteOptions = exports.makeReadOptions = exports.readScalarLTString = exports.readScalar = exports.readMapEntry = exports.readField = void 0;
-const field_js_1 = require("./field.js");
-const is_message_js_1 = require("./is-message.js");
-const unknown_js_1 = require("./unknown.js");
-const field_wrapper_js_1 = require("./field-wrapper.js");
-const scalar_js_1 = require("./scalar.js");
-const assert_js_1 = require("./assert.js");
-const binary_encoding_js_1 = require("./binary-encoding.js");
-function readField(target, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+import { isFieldSet, resolveMessageType, } from "./field.js";
+import { isCompleteMessage } from "./is-message.js";
+import { handleUnknownField, unknownFieldsSymbol } from "./unknown.js";
+import { 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";
+export 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;
     if (field.oneof) {
@@ -26,7 +23,7 @@ reader, field, wireType, options) {
     switch (field.kind) {
         case "scalar":
         case "enum":
-            const scalarType = field.kind == "enum" ? scalar_js_1.ScalarType.INT32 : field.T;
+            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
             if (field.kind == "scalar" && field.L > 0) {
@@ -37,9 +34,9 @@ reader, field, wireType, options) {
                 if (!Array.isArray(tgtArr)) {
                     tgtArr = target[localName] = [];
                 }
-                const isPacked = wireType == binary_encoding_js_1.WireType.LengthDelimited &&
-                    scalarType != scalar_js_1.ScalarType.STRING &&
-                    scalarType != scalar_js_1.ScalarType.BYTES;
+                const isPacked = wireType == WireType.LengthDelimited &&
+                    scalarType != ScalarType.STRING &&
+                    scalarType != ScalarType.BYTES;
                 if (isPacked) {
                     let e = reader.uint32() + reader.pos;
                     while (reader.pos < e) {
@@ -65,7 +62,7 @@ reader, field, wireType, options) {
                 tgtArr.push(readMessageField(reader, messageType.create(), messageType.fields, options, field));
             }
             else {
-                if ((0, is_message_js_1.isCompleteMessage)(target[localName], messageType.fields.list())) {
+                if (isCompleteMessage(target[localName], messageType.fields.list())) {
                     readMessageField(reader, target[localName], messageType.fields, options, field);
                 }
                 else {
@@ -86,9 +83,8 @@ reader, field, wireType, options) {
             break;
     }
 }
-exports.readField = readField;
 // Read a map field, expecting key field = 1, value field = 2
-function readMapEntry(field, reader, options) {
+export function readMapEntry(field, reader, options) {
     const length = reader.uint32(), end = reader.pos + length;
     let key, val;
     while (reader.pos < end) {
@@ -106,7 +102,7 @@ function readMapEntry(field, reader, options) {
                         val = reader.int32();
                         break;
                     case "message":
-                        const messageType = (0, field_js_1.resolveMessageType)(field.V.T);
+                        const messageType = resolveMessageType(field.V.T);
                         val = readMessageField(reader, messageType.create(), messageType.fields, options, undefined);
                         break;
                 }
@@ -114,7 +110,7 @@ function readMapEntry(field, reader, options) {
         }
     }
     if (key === undefined) {
-        key = (0, scalar_js_1.scalarZeroValue)(field.K, scalar_js_1.LongType.BIGINT);
+        key = scalarZeroValue(field.K, LongType.BIGINT);
     }
     if (typeof key != "string" && typeof key != "number") {
         key = key.toString();
@@ -123,61 +119,58 @@ function readMapEntry(field, reader, options) {
         const fieldKind = field.V.kind;
         switch (fieldKind) {
             case "scalar":
-                val = (0, scalar_js_1.scalarZeroValue)(field.V.T, scalar_js_1.LongType.BIGINT);
+                val = scalarZeroValue(field.V.T, LongType.BIGINT);
                 break;
             case "enum":
                 val = field.V.T.values[0].no;
                 break;
             case "message":
-                val = (0, field_js_1.resolveMessageType)(field.V.T).create();
+                val = resolveMessageType(field.V.T).create();
                 break;
         }
     }
     return [key, val];
 }
-exports.readMapEntry = readMapEntry;
-function readScalar(reader, type) {
+export function readScalar(reader, type) {
     switch (type) {
-        case scalar_js_1.ScalarType.STRING:
+        case ScalarType.STRING:
             return reader.string();
-        case scalar_js_1.ScalarType.BOOL:
+        case ScalarType.BOOL:
             return reader.bool();
-        case scalar_js_1.ScalarType.DOUBLE:
+        case ScalarType.DOUBLE:
             return reader.double();
-        case scalar_js_1.ScalarType.FLOAT:
+        case ScalarType.FLOAT:
             return reader.float();
-        case scalar_js_1.ScalarType.INT32:
+        case ScalarType.INT32:
             return reader.int32();
-        case scalar_js_1.ScalarType.INT64:
+        case ScalarType.INT64:
             return reader.int64();
-        case scalar_js_1.ScalarType.UINT64:
+        case ScalarType.UINT64:
             return reader.uint64();
-        case scalar_js_1.ScalarType.FIXED64:
+        case ScalarType.FIXED64:
             return reader.fixed64();
-        case scalar_js_1.ScalarType.BYTES:
+        case ScalarType.BYTES:
             return reader.bytes();
-        case scalar_js_1.ScalarType.FIXED32:
+        case ScalarType.FIXED32:
             return reader.fixed32();
-        case scalar_js_1.ScalarType.SFIXED32:
+        case ScalarType.SFIXED32:
             return reader.sfixed32();
-        case scalar_js_1.ScalarType.SFIXED64:
+        case ScalarType.SFIXED64:
             return reader.sfixed64();
-        case scalar_js_1.ScalarType.SINT64:
+        case ScalarType.SINT64:
             return reader.sint64();
-        case scalar_js_1.ScalarType.UINT32:
+        case ScalarType.UINT32:
             return reader.uint32();
-        case scalar_js_1.ScalarType.SINT32:
+        case ScalarType.SINT32:
             return reader.sint32();
     }
 }
-exports.readScalar = readScalar;
 // Read a scalar value, but return 64 bit integral types (int64, uint64,
 // sint64, fixed64, sfixed64) as string instead of bigint.
-function readScalarLTString(reader, type) {
+export function readScalarLTString(reader, type) {
     const v = readScalar(reader, type);
     return typeof v == "bigint" ? v.toString() : v;
 }
-exports.readScalarLTString = readScalarLTString;
 // Read a message, avoiding MessageType.fromBinary() to re-use the
 // BinaryReadOptions and the IBinaryReader.
 function readMessageField(reader, message, fields, options, field) {
@@ -189,52 +182,49 @@ function readMessageField(reader, message, fields, options, field) {
 // Default options for parsing binary data.
 const readDefaults = {
     readUnknownFields: true,
-    readerFactory: (bytes) => new binary_encoding_js_1.BinaryReader(bytes),
+    readerFactory: (bytes) => new BinaryReader(bytes),
 };
 // Default options for serializing binary data.
 const writeDefaults = {
     writeUnknownFields: true,
-    writerFactory: () => new binary_encoding_js_1.BinaryWriter(),
+    writerFactory: () => new BinaryWriter(),
 };
-function makeReadOptions(options) {
+export function makeReadOptions(options) {
     return options ? { ...readDefaults, ...options } : readDefaults;
 }
-exports.makeReadOptions = makeReadOptions;
-function makeWriteOptions(options) {
+export function makeWriteOptions(options) {
     return options ? { ...writeDefaults, ...options } : writeDefaults;
 }
-exports.makeWriteOptions = makeWriteOptions;
-function readMessage(message, fields, reader, lengthOrEndTagFieldNo, options, delimitedMessageEncoding) {
+export 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) {
         [fieldNo, wireType] = reader.tag();
-        if (wireType == binary_encoding_js_1.WireType.EndGroup) {
+        if (wireType == WireType.EndGroup) {
             break;
         }
         const field = fields.find(fieldNo);
         if (!field) {
             const data = reader.skip(wireType);
             if (options.readUnknownFields) {
-                (0, unknown_js_1.handleUnknownField)(message, fieldNo, wireType, data);
+                handleUnknownField(message, fieldNo, wireType, data);
             }
             continue;
         }
         readField(message, reader, field, wireType, options);
     }
     if (delimitedMessageEncoding && // eslint-disable-line @typescript-eslint/strict-boolean-expressions
-        (wireType != binary_encoding_js_1.WireType.EndGroup || fieldNo !== lengthOrEndTagFieldNo)) {
+        (wireType != WireType.EndGroup || fieldNo !== lengthOrEndTagFieldNo)) {
         throw new Error(`invalid end group tag`);
     }
 }
-exports.readMessage = readMessage;
 /**
  * Serialize a message to binary data.
  */
-function writeMessage(message, fields, writer, options) {
+export function writeMessage(message, fields, writer, options) {
     for (const field of fields.byNumber()) {
-        if (!(0, field_js_1.isFieldSet)(field, message)) {
+        if (!isFieldSet(field, message)) {
             if (field.req) {
                 throw new Error(`cannot encode field ${field.name} to binary: required field not set`);
             }
@@ -249,16 +239,15 @@ function writeMessage(message, fields, writer, options) {
         writeUnknownFields(message, writer);
     }
 }
-exports.writeMessage = writeMessage;
 function writeField(field, value, writer, options) {
-    (0, assert_js_1.assert)(value !== undefined);
+    assert(value !== undefined);
     const repeated = field.repeated;
     switch (field.kind) {
         case "scalar":
         case "enum":
-            let scalarType = field.kind == "enum" ? scalar_js_1.ScalarType.INT32 : field.T;
+            let scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
             if (repeated) {
-                (0, assert_js_1.assert)(Array.isArray(value));
+                assert(Array.isArray(value));
                 if (field.packed) {
                     writePacked(writer, scalarType, field.no, value);
                 }
@@ -274,7 +263,7 @@ function writeField(field, value, writer, options) {
             break;
         case "message":
             if (repeated) {
-                (0, assert_js_1.assert)(Array.isArray(value));
+                assert(Array.isArray(value));
                 for (const item of value) {
                     writeMessageField(writer, options, field, item);
                 }
@@ -284,7 +273,7 @@ function writeField(field, value, writer, options) {
             }
             break;
         case "map":
-            (0, assert_js_1.assert)(typeof value == "object" && value != null);
+            assert(typeof value == "object" && value != null);
             for (const [key, val] of Object.entries(value)) {
                 writeMapEntry(writer, options, field, key, val);
             }
@@ -293,7 +282,7 @@ function writeField(field, value, writer, options) {
 }
 function writeUnknownFields(message, writer) {
     const m = message;
-    const c = m[unknown_js_1.unknownFieldsSymbol];
+    const c = m[unknownFieldsSymbol];
     if (c) {
         for (const f of c) {
             writer.tag(f.no, f.wireType).raw(f.data);
@@ -302,21 +291,21 @@ function writeUnknownFields(message, writer) {
 }
 // Value must not be undefined
 function writeMessageField(writer, options, field, value) {
-    const messageType = (0, field_js_1.resolveMessageType)(field.T);
-    const message = (0, field_wrapper_js_1.wrapField)(messageType.fieldWrapper, value);
+    const messageType = resolveMessageType(field.T);
+    const message = wrapField(messageType.fieldWrapper, value);
     // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (field.delimited)
         writer
-            .tag(field.no, binary_encoding_js_1.WireType.StartGroup)
+            .tag(field.no, WireType.StartGroup)
             .raw(messageType.toBinary(message, options))
-            .tag(field.no, binary_encoding_js_1.WireType.EndGroup);
+            .tag(field.no, WireType.EndGroup);
     else
         writer
-            .tag(field.no, binary_encoding_js_1.WireType.LengthDelimited)
+            .tag(field.no, WireType.LengthDelimited)
             .bytes(messageType.toBinary(message, options));
 }
 function writeScalar(writer, type, fieldNo, value) {
-    (0, assert_js_1.assert)(value !== undefined);
+    assert(value !== undefined);
     let [wireType, method] = scalarTypeInfo(type);
     writer.tag(fieldNo, wireType)[method](value);
 }
@@ -324,7 +313,7 @@ function writePacked(writer, type, fieldNo, value) {
     if (!value.length) {
         return;
     }
-    writer.tag(fieldNo, binary_encoding_js_1.WireType.LengthDelimited).fork();
+    writer.tag(fieldNo, WireType.LengthDelimited).fork();
     let [, method] = scalarTypeInfo(type);
     for (let i = 0; i < value.length; i++) {
         writer[method](value[i]);
@@ -343,44 +332,44 @@ function writePacked(writer, type, fieldNo, value) {
  */
 // TODO replace call-sites writeScalar() and writePacked(), then remove
 function scalarTypeInfo(type) {
-    let wireType = binary_encoding_js_1.WireType.Varint;
+    let wireType = WireType.Varint;
     // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- INT32, UINT32, SINT32 are covered by the defaults
     switch (type) {
-        case scalar_js_1.ScalarType.BYTES:
-        case scalar_js_1.ScalarType.STRING:
-            wireType = binary_encoding_js_1.WireType.LengthDelimited;
+        case ScalarType.BYTES:
+        case ScalarType.STRING:
+            wireType = WireType.LengthDelimited;
             break;
-        case scalar_js_1.ScalarType.DOUBLE:
-        case scalar_js_1.ScalarType.FIXED64:
-        case scalar_js_1.ScalarType.SFIXED64:
-            wireType = binary_encoding_js_1.WireType.Bit64;
+        case ScalarType.DOUBLE:
+        case ScalarType.FIXED64:
+        case ScalarType.SFIXED64:
+            wireType = WireType.Bit64;
             break;
-        case scalar_js_1.ScalarType.FIXED32:
-        case scalar_js_1.ScalarType.SFIXED32:
-        case scalar_js_1.ScalarType.FLOAT:
-            wireType = binary_encoding_js_1.WireType.Bit32;
+        case ScalarType.FIXED32:
+        case ScalarType.SFIXED32:
+        case ScalarType.FLOAT:
+            wireType = WireType.Bit32;
             break;
     }
-    const method = scalar_js_1.ScalarType[type].toLowerCase();
+    const method = ScalarType[type].toLowerCase();
     return [wireType, method];
 }
-function writeMapEntry(writer, options, field, key, value) {
-    writer.tag(field.no, binary_encoding_js_1.WireType.LengthDelimited);
+export function writeMapEntry(writer, options, field, key, value) {
+    writer.tag(field.no, WireType.LengthDelimited);
     writer.fork();
     // javascript only allows number or string for object properties
     // we convert from our representation to the protobuf type
     let keyValue = key;
     // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- we deliberately handle just the special cases for map keys
     switch (field.K) {
-        case scalar_js_1.ScalarType.INT32:
-        case scalar_js_1.ScalarType.FIXED32:
-        case scalar_js_1.ScalarType.UINT32:
-        case scalar_js_1.ScalarType.SFIXED32:
-        case scalar_js_1.ScalarType.SINT32:
+        case ScalarType.INT32:
+        case ScalarType.FIXED32:
+        case ScalarType.UINT32:
+        case ScalarType.SFIXED32:
+        case ScalarType.SINT32:
             keyValue = Number.parseInt(key);
             break;
-        case scalar_js_1.ScalarType.BOOL:
-            (0, assert_js_1.assert)(key == "true" || key == "false");
+        case ScalarType.BOOL:
+            assert(key == "true" || key == "false");
             keyValue = key == "true";
             break;
     }
@@ -392,16 +381,15 @@ function writeMapEntry(writer, options, field, key, value) {
             writeScalar(writer, field.V.T, 2, value);
             break;
         case "enum":
-            writeScalar(writer, scalar_js_1.ScalarType.INT32, 2, value);
+            writeScalar(writer, ScalarType.INT32, 2, value);
             break;
         case "message":
-            (0, assert_js_1.assert)(value !== undefined);
-            const messageType = (0, field_js_1.resolveMessageType)(field.V.T);
+            assert(value !== undefined);
+            const messageType = resolveMessageType(field.V.T);
             writer
-                .tag(2, binary_encoding_js_1.WireType.LengthDelimited)
+                .tag(2, WireType.LengthDelimited)
                 .bytes(messageType.toBinary(value, options));
             break;
     }
     writer.join();
 }
-exports.writeMapEntry = writeMapEntry;