@bufbuild/protobuf 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/cjs/to-binary.js

@@ -16,7 +16,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeField = exports.toBinary = void 0;
 const reflect_js_1 = require("./reflect/reflect.js");
 const binary_encoding_js_1 = require("./wire/binary-encoding.js");
-const scalar_js_1 = require("./reflect/scalar.js");
+const descriptors_js_1 = require("./descriptors.js");
 // bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number;
 const LEGACY_REQUIRED = 3;
 // Default options for serializing binary data.
@@ -56,7 +56,7 @@ function writeField(writer, opts, msg, field) {
     switch (field.fieldKind) {
         case "scalar":
         case "enum":
-            writeScalar(writer, (_a = field.scalar) !== null && _a !== void 0 ? _a : scalar_js_1.ScalarType.INT32, field.number, msg.get(field));
+            writeScalar(writer, (_a = field.scalar) !== null && _a !== void 0 ? _a : descriptors_js_1.ScalarType.INT32, field.number, msg.get(field));
             break;
         case "list":
             writeListField(writer, opts, field, msg.get(field));
@@ -91,7 +91,7 @@ function writeListField(writer, opts, field, list) {
         }
         return;
     }
-    const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : scalar_js_1.ScalarType.INT32;
+    const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : descriptors_js_1.ScalarType.INT32;
     if (field.packed) {
         if (!list.size) {
             return;
@@ -116,7 +116,7 @@ function writeMapEntry(writer, opts, field, key, value) {
     switch (field.mapKind) {
         case "scalar":
         case "enum":
-            writeScalar(writer, (_a = field.scalar) !== null && _a !== void 0 ? _a : scalar_js_1.ScalarType.INT32, 2, value);
+            writeScalar(writer, (_a = field.scalar) !== null && _a !== void 0 ? _a : descriptors_js_1.ScalarType.INT32, 2, value);
             break;
         case "message":
             writeFields(writer.tag(2, binary_encoding_js_1.WireType.LengthDelimited).fork(), opts, value).join();
@@ -126,65 +126,65 @@ function writeMapEntry(writer, opts, field, key, value) {
 }
 function writeScalarValue(writer, type, value) {
     switch (type) {
-        case scalar_js_1.ScalarType.STRING:
+        case descriptors_js_1.ScalarType.STRING:
             writer.string(value);
             break;
-        case scalar_js_1.ScalarType.BOOL:
+        case descriptors_js_1.ScalarType.BOOL:
             writer.bool(value);
             break;
-        case scalar_js_1.ScalarType.DOUBLE:
+        case descriptors_js_1.ScalarType.DOUBLE:
             writer.double(value);
             break;
-        case scalar_js_1.ScalarType.FLOAT:
+        case descriptors_js_1.ScalarType.FLOAT:
             writer.float(value);
             break;
-        case scalar_js_1.ScalarType.INT32:
+        case descriptors_js_1.ScalarType.INT32:
             writer.int32(value);
             break;
-        case scalar_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.INT64:
             writer.int64(value);
             break;
-        case scalar_js_1.ScalarType.UINT64:
+        case descriptors_js_1.ScalarType.UINT64:
             writer.uint64(value);
             break;
-        case scalar_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.FIXED64:
             writer.fixed64(value);
             break;
-        case scalar_js_1.ScalarType.BYTES:
+        case descriptors_js_1.ScalarType.BYTES:
             writer.bytes(value);
             break;
-        case scalar_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.FIXED32:
             writer.fixed32(value);
             break;
-        case scalar_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.ScalarType.SFIXED32:
             writer.sfixed32(value);
             break;
-        case scalar_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.SFIXED64:
             writer.sfixed64(value);
             break;
-        case scalar_js_1.ScalarType.SINT64:
+        case descriptors_js_1.ScalarType.SINT64:
             writer.sint64(value);
             break;
-        case scalar_js_1.ScalarType.UINT32:
+        case descriptors_js_1.ScalarType.UINT32:
             writer.uint32(value);
             break;
-        case scalar_js_1.ScalarType.SINT32:
+        case descriptors_js_1.ScalarType.SINT32:
             writer.sint32(value);
             break;
     }
 }
 function writeTypeOfScalar(type) {
     switch (type) {
-        case scalar_js_1.ScalarType.BYTES:
-        case scalar_js_1.ScalarType.STRING:
+        case descriptors_js_1.ScalarType.BYTES:
+        case descriptors_js_1.ScalarType.STRING:
             return binary_encoding_js_1.WireType.LengthDelimited;
-        case scalar_js_1.ScalarType.DOUBLE:
-        case scalar_js_1.ScalarType.FIXED64:
-        case scalar_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.DOUBLE:
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.SFIXED64:
             return binary_encoding_js_1.WireType.Bit64;
-        case scalar_js_1.ScalarType.FIXED32:
-        case scalar_js_1.ScalarType.SFIXED32:
-        case scalar_js_1.ScalarType.FLOAT:
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.ScalarType.FLOAT:
             return binary_encoding_js_1.WireType.Bit32;
         default:
             return binary_encoding_js_1.WireType.Varint;

package/dist/cjs/to-json.d.ts

@@ -1,17 +1,18 @@
-import type { DescMessage } from "./desc-types.js";
+import { type DescMessage } from "./descriptors.js";
 import type { JsonValue } from "./json-value.js";
-import type { Registry } from "./reflect/registry.js";
+import type { Registry } from "./registry.js";
 import type { MessageShape } from "./types.js";
 /**
  * Options for serializing to JSON.
  */
 export interface JsonWriteOptions {
     /**
-     * Emit fields with default values: Fields with default values are omitted
-     * by default in proto3 JSON output. This option overrides this behavior
-     * and outputs fields with their default values.
+     * By default, fields with implicit presence are not serialized if they are
+     * unset. For example, an empty list field or a proto3 int32 field with 0 is
+     * not serialized. With this option enabled, such fields are included in the
+     * output.
      */
-    emitDefaultValues: boolean;
+    alwaysEmitImplicit: boolean;
     /**
      * Emit enum values as integers instead of strings: The name of an enum
      * value is used by default in JSON output. An option may be provided to

package/dist/cjs/to-json.js

@@ -14,21 +14,22 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toJsonString = exports.toJson = void 0;
-const assert_js_1 = require("./reflect/assert.js");
+const descriptors_js_1 = require("./descriptors.js");
 const names_js_1 = require("./reflect/names.js");
 const reflect_js_1 = require("./reflect/reflect.js");
-const scalar_js_1 = require("./reflect/scalar.js");
 const index_js_1 = require("./wkt/index.js");
 const wrappers_js_1 = require("./wkt/wrappers.js");
 const index_js_2 = require("./wire/index.js");
 const extensions_js_1 = require("./extensions.js");
+const reflect_check_js_1 = require("./reflect/reflect-check.js");
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
 // bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number;
 const LEGACY_REQUIRED = 3;
 // bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number;
 const IMPLICIT = 2;
 // Default options for serializing to JSON.
 const jsonWriteDefaults = {
-    emitDefaultValues: false,
+    alwaysEmitImplicit: false,
     enumAsInteger: false,
     useProtoFieldName: false,
 };
@@ -61,9 +62,9 @@ function reflectToJson(msg, opts) {
     for (const f of msg.sortedFields) {
         if (!msg.isSet(f)) {
             if (f.presence == LEGACY_REQUIRED) {
-                throw new Error(`cannot encode field ${msg.desc.typeName}.${f.name} to binary: required field not set`);
+                throw new Error(`cannot encode field ${msg.desc.typeName}.${f.name} to JSON: required field not set`);
             }
-            if (!opts.emitDefaultValues || f.presence !== IMPLICIT) {
+            if (!opts.alwaysEmitImplicit || f.presence !== IMPLICIT) {
                 // Fields with implicit presence omit zero values (e.g. empty string) by default
                 continue;
             }
@@ -98,7 +99,7 @@ function reflectToJson(msg, opts) {
 function fieldToJson(f, val, opts) {
     switch (f.fieldKind) {
         case "scalar":
-            return scalarToJson(f.scalar, val);
+            return scalarToJson(f, val);
         case "message":
             return reflectToJson(val, opts);
         case "enum":
@@ -115,7 +116,7 @@ function mapToJson(map, opts) {
     switch (f.mapKind) {
         case "scalar":
             for (const [entryKey, entryValue] of map) {
-                jsonObj[entryKey.toString()] = scalarToJson(f.scalar, entryValue); // JSON standard allows only (double quoted) string as property key
+                jsonObj[entryKey.toString()] = scalarToJson(f, entryValue); // JSON standard allows only (double quoted) string as property key
             }
             break;
         case "message":
@@ -131,7 +132,7 @@ function mapToJson(map, opts) {
             }
             break;
     }
-    return opts.emitDefaultValues || map.size > 0 ? jsonObj : undefined;
+    return opts.alwaysEmitImplicit || map.size > 0 ? jsonObj : undefined;
 }
 function listToJson(list, opts) {
     const f = list.field();
@@ -139,7 +140,7 @@ function listToJson(list, opts) {
     switch (f.listKind) {
         case "scalar":
             for (const item of list) {
-                jsonArr.push(scalarToJson(f.scalar, item));
+                jsonArr.push(scalarToJson(f, item));
             }
             break;
         case "enum":
@@ -153,11 +154,13 @@ function listToJson(list, opts) {
             }
             break;
     }
-    return opts.emitDefaultValues || jsonArr.length > 0 ? jsonArr : undefined;
+    return opts.alwaysEmitImplicit || jsonArr.length > 0 ? jsonArr : undefined;
 }
 function enumToJson(desc, value, enumAsInteger) {
     var _a;
-    (0, assert_js_1.assert)(typeof value == "number");
+    if (typeof value != "number") {
+        throw new Error(`cannot encode ${desc} to JSON: expected number, got ${(0, reflect_check_js_1.formatVal)(value)}`);
+    }
     if (desc.typeName == "google.protobuf.NullValue") {
         return null;
     }
@@ -167,23 +170,27 @@ function enumToJson(desc, value, enumAsInteger) {
     const val = desc.values.find((v) => v.number == value);
     return (_a = val === null || val === void 0 ? void 0 : val.name) !== null && _a !== void 0 ? _a : value; // if we don't know the enum value, just return the number
 }
-function scalarToJson(type, value) {
-    switch (type) {
+function scalarToJson(field, value) {
+    var _a, _b, _c, _d, _e, _f;
+    switch (field.scalar) {
         // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
-        case scalar_js_1.ScalarType.INT32:
-        case scalar_js_1.ScalarType.SFIXED32:
-        case scalar_js_1.ScalarType.SINT32:
-        case scalar_js_1.ScalarType.FIXED32:
-        case scalar_js_1.ScalarType.UINT32:
-            (0, assert_js_1.assert)(typeof value == "number");
+        case descriptors_js_1.ScalarType.INT32:
+        case descriptors_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.ScalarType.SINT32:
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.UINT32:
+            if (typeof value != "number") {
+                throw new Error(`cannot encode ${field} to JSON: ${(_a = (0, reflect_check_js_1.checkField)(field, value)) === null || _a === void 0 ? void 0 : _a.message}`);
+            }
             return value;
         // 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 scalar_js_1.ScalarType.FLOAT:
-        // assertFloat32(value);
-        case scalar_js_1.ScalarType.DOUBLE: // eslint-disable-line no-fallthrough
-            (0, assert_js_1.assert)(typeof value == "number");
-            if (Number.isNaN(value))
+        case descriptors_js_1.ScalarType.FLOAT:
+        case descriptors_js_1.ScalarType.DOUBLE: // eslint-disable-line no-fallthrough
+            if (typeof value != "number") {
+                throw new Error(`cannot encode ${field} to JSON: ${(_b = (0, reflect_check_js_1.checkField)(field, value)) === null || _b === void 0 ? void 0 : _b.message}`);
+            }
+            if (isNaN(value))
                 return "NaN";
             if (value === Number.POSITIVE_INFINITY)
                 return "Infinity";
@@ -191,28 +198,34 @@ function scalarToJson(type, value) {
                 return "-Infinity";
             return value;
         // string:
-        case scalar_js_1.ScalarType.STRING:
-            (0, assert_js_1.assert)(typeof value == "string");
+        case descriptors_js_1.ScalarType.STRING:
+            if (typeof value != "string") {
+                throw new Error(`cannot encode ${field} to JSON: ${(_c = (0, reflect_check_js_1.checkField)(field, value)) === null || _c === void 0 ? void 0 : _c.message}`);
+            }
             return value;
         // bool:
-        case scalar_js_1.ScalarType.BOOL:
-            (0, assert_js_1.assert)(typeof value == "boolean");
+        case descriptors_js_1.ScalarType.BOOL:
+            if (typeof value != "boolean") {
+                throw new Error(`cannot encode ${field} to JSON: ${(_d = (0, reflect_check_js_1.checkField)(field, value)) === null || _d === void 0 ? void 0 : _d.message}`);
+            }
             return value;
         // JSON value will be a decimal string. Either numbers or strings are accepted.
-        case scalar_js_1.ScalarType.UINT64:
-        case scalar_js_1.ScalarType.FIXED64:
-        case scalar_js_1.ScalarType.INT64:
-        case scalar_js_1.ScalarType.SFIXED64:
-        case scalar_js_1.ScalarType.SINT64:
-            (0, assert_js_1.assert)(typeof value == "bigint" ||
-                typeof value == "string" ||
-                typeof value == "number");
+        case descriptors_js_1.ScalarType.UINT64:
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
+            if (typeof value != "bigint" && typeof value != "string") {
+                throw new Error(`cannot encode ${field} to JSON: ${(_e = (0, reflect_check_js_1.checkField)(field, value)) === null || _e === void 0 ? void 0 : _e.message}`);
+            }
             return value.toString();
         // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
         // Either standard or URL-safe base64 encoding with/without paddings are accepted.
-        case scalar_js_1.ScalarType.BYTES:
-            (0, assert_js_1.assert)(value instanceof Uint8Array);
-            return (0, index_js_2.base64Encode)(value);
+        case descriptors_js_1.ScalarType.BYTES:
+            if (value instanceof Uint8Array) {
+                return (0, index_js_2.base64Encode)(value);
+            }
+            throw new Error(`cannot encode ${field} to JSON: ${(_f = (0, reflect_check_js_1.checkField)(field, value)) === null || _f === void 0 ? void 0 : _f.message}`);
     }
 }
 function jsonName(f, opts) {
@@ -241,7 +254,7 @@ function tryWktToJson(msg, opts) {
         default:
             if ((0, wrappers_js_1.isWrapperDesc)(msg.desc)) {
                 const valueField = msg.desc.fields[0];
-                return scalarToJson(valueField.scalar, msg.get(valueField));
+                return scalarToJson(valueField, msg.get(valueField));
             }
             return undefined;
     }
@@ -275,7 +288,7 @@ function anyToJson(val, opts) {
 function durationToJson(val) {
     if (Number(val.seconds) > 315576000000 ||
         Number(val.seconds) < -315576000000) {
-        throw new Error(`cannot encode ${val.$typeName} to JSON: value out of range`);
+        throw new Error(`cannot encode message ${val.$typeName} to JSON: value out of range`);
     }
     let text = val.seconds.toString();
     if (val.nanos !== 0) {
@@ -299,7 +312,7 @@ function fieldMaskToJson(val) {
         .map((p) => {
         // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
         if (p.match(/_[0-9]?_/g) || p.match(/[A-Z]/g)) {
-            throw new Error(`cannot encode ${val.$typeName} to JSON: lowerCamelCase of path name "` +
+            throw new Error(`cannot encode message ${val.$typeName} to JSON: lowerCamelCase of path name "` +
                 p +
                 '" is irreversible');
         }
@@ -342,10 +355,10 @@ function timestampToJson(val) {
     const ms = Number(val.seconds) * 1000;
     if (ms < Date.parse("0001-01-01T00:00:00Z") ||
         ms > Date.parse("9999-12-31T23:59:59Z")) {
-        throw new Error(`cannot encode ${val.$typeName} to JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`);
+        throw new Error(`cannot encode message ${val.$typeName} to JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`);
     }
     if (val.nanos < 0) {
-        throw new Error(`cannot encode ${val.$typeName} to JSON: nanos must not be negative`);
+        throw new Error(`cannot encode message ${val.$typeName} to JSON: nanos must not be negative`);
     }
     let z = "Z";
     if (val.nanos > 0) {

package/dist/cjs/types.d.ts

@@ -1,5 +1,5 @@
 import type { GenDescEnum, GenDescExtension, GenDescMessage } from "./codegenv1/types.js";
-import type { DescEnum, DescExtension, DescMessage } from "./desc-types.js";
+import type { DescEnum, DescExtension, DescMessage } from "./descriptors.js";
 import type { OneofADT } from "./reflect/guard.js";
 import type { WireType } from "./wire/index.js";
 /**

package/dist/cjs/wire/base64-encoding.js

@@ -52,7 +52,7 @@ function base64Decode(base64Str) {
                 case " ":
                     continue; // skip white-space, and padding
                 default:
-                    throw Error("invalid base64 string.");
+                    throw Error("invalid base64 string");
             }
         }
         switch (groupPos) {
@@ -77,7 +77,7 @@ function base64Decode(base64Str) {
         }
     }
     if (groupPos == 1)
-        throw Error("invalid base64 string.");
+        throw Error("invalid base64 string");
     return bytes.subarray(0, bytePos);
 }
 exports.base64Decode = base64Decode;

package/dist/cjs/wire/binary-encoding.d.ts

@@ -39,6 +39,26 @@ export declare enum WireType {
      */
     Bit32 = 5
 }
+/**
+ * Maximum value for a 32-bit floating point value (Protobuf FLOAT).
+ */
+export declare const FLOAT32_MAX = 3.4028234663852886e+38;
+/**
+ * Minimum value for a 32-bit floating point value (Protobuf FLOAT).
+ */
+export declare const FLOAT32_MIN = -3.4028234663852886e+38;
+/**
+ * Maximum value for an unsigned 32-bit integer (Protobuf UINT32, FIXED32).
+ */
+export declare const UINT32_MAX = 4294967295;
+/**
+ * Maximum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32).
+ */
+export declare const INT32_MAX = 2147483647;
+/**
+ * Minimum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32).
+ */
+export declare const INT32_MIN = -2147483648;
 export declare class BinaryWriter {
     private readonly encodeUtf8;
     /**

package/dist/cjs/wire/binary-encoding.js

@@ -13,9 +13,8 @@
 // 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;
+exports.BinaryReader = exports.BinaryWriter = exports.INT32_MIN = exports.INT32_MAX = exports.UINT32_MAX = exports.FLOAT32_MIN = exports.FLOAT32_MAX = exports.WireType = void 0;
 const varint_js_1 = require("./varint.js");
-const assert_js_1 = require("../reflect/assert.js");
 const proto_int64_js_1 = require("../proto-int64.js");
 const text_encoding_js_1 = require("./text-encoding.js");
 /* eslint-disable prefer-const,no-case-declarations,@typescript-eslint/restrict-plus-operands */
@@ -61,6 +60,26 @@ var WireType;
      */
     WireType[WireType["Bit32"] = 5] = "Bit32";
 })(WireType || (exports.WireType = WireType = {}));
+/**
+ * Maximum value for a 32-bit floating point value (Protobuf FLOAT).
+ */
+exports.FLOAT32_MAX = 3.4028234663852886e38;
+/**
+ * Minimum value for a 32-bit floating point value (Protobuf FLOAT).
+ */
+exports.FLOAT32_MIN = -3.4028234663852886e38;
+/**
+ * Maximum value for an unsigned 32-bit integer (Protobuf UINT32, FIXED32).
+ */
+exports.UINT32_MAX = 0xffffffff;
+/**
+ * Maximum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32).
+ */
+exports.INT32_MAX = 0x7fffffff;
+/**
+ * Minimum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32).
+ */
+exports.INT32_MIN = -0x80000000;
 class BinaryWriter {
     constructor(encodeUtf8 = (0, text_encoding_js_1.getTextEncoding)().encodeUtf8) {
         this.encodeUtf8 = encodeUtf8;
@@ -142,7 +161,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);
@@ -155,7 +174,7 @@ class BinaryWriter {
      * Write a `int32` value, a signed 32 bit varint.
      */
     int32(value) {
-        (0, assert_js_1.assertInt32)(value);
+        assertInt32(value);
         (0, varint_js_1.varint32write)(value, this.buf);
         return this;
     }
@@ -185,7 +204,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);
@@ -202,7 +221,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);
@@ -211,7 +230,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);
@@ -220,7 +239,7 @@ 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);
@@ -442,3 +461,51 @@ class BinaryReader {
     }
 }
 exports.BinaryReader = BinaryReader;
+/**
+ * Assert a valid signed protobuf 32-bit integer as a number or string.
+ */
+function assertInt32(arg) {
+    if (typeof arg == "string") {
+        arg = Number(arg);
+    }
+    else if (typeof arg != "number") {
+        throw new Error("invalid int32: " + typeof arg);
+    }
+    if (!Number.isInteger(arg) ||
+        arg > exports.INT32_MAX ||
+        arg < exports.INT32_MIN)
+        throw new Error("invalid int32: " + arg);
+}
+/**
+ * Assert a valid unsigned protobuf 32-bit integer as a number or string.
+ */
+function assertUInt32(arg) {
+    if (typeof arg == "string") {
+        arg = Number(arg);
+    }
+    else if (typeof arg != "number") {
+        throw new Error("invalid uint32: " + typeof arg);
+    }
+    if (!Number.isInteger(arg) ||
+        arg > exports.UINT32_MAX ||
+        arg < 0)
+        throw new Error("invalid uint32: " + arg);
+}
+/**
+ * Assert a valid protobuf float value as a number or string.
+ */
+function assertFloat32(arg) {
+    if (typeof arg == "string") {
+        const o = arg;
+        arg = Number(arg);
+        if (isNaN(arg) && o !== "NaN") {
+            throw new Error("invalid float32: " + o);
+        }
+    }
+    else if (typeof arg != "number") {
+        throw new Error("invalid float32: " + typeof arg);
+    }
+    if (Number.isFinite(arg) &&
+        (arg > exports.FLOAT32_MAX || arg < exports.FLOAT32_MIN))
+        throw new Error("invalid float32: " + arg);
+}

package/dist/cjs/wire/size-delimited.d.ts

@@ -1,4 +1,4 @@
-import type { DescMessage } from "../desc-types.js";
+import type { DescMessage } from "../descriptors.js";
 import type { BinaryWriteOptions } from "../to-binary.js";
 import type { MessageShape } from "../types.js";
 import type { BinaryReadOptions } from "../from-binary.js";

package/dist/cjs/wire/text-format.d.ts

@@ -1,5 +1,4 @@
-import type { DescEnum } from "../desc-types.js";
-import { ScalarType } from "../reflect/scalar.js";
+import { type DescEnum, ScalarType } from "../descriptors.js";
 /**
  * Parse an enum value from the Protobuf text format.
  *

package/dist/cjs/wire/text-format.js

@@ -14,9 +14,9 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTextFormatScalarValue = exports.parseTextFormatEnumValue = void 0;
-const assert_js_1 = require("../reflect/assert.js");
+const descriptors_js_1 = require("../descriptors.js");
 const proto_int64_js_1 = require("../proto-int64.js");
-const scalar_js_1 = require("../reflect/scalar.js");
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
 /**
  * Parse an enum value from the Protobuf text format.
  *
@@ -24,7 +24,9 @@ const scalar_js_1 = require("../reflect/scalar.js");
  */
 function parseTextFormatEnumValue(descEnum, value) {
     const enumValue = descEnum.values.find((v) => v.name === value);
-    (0, assert_js_1.assert)(enumValue, `cannot parse ${descEnum.name} default value: ${value}`);
+    if (!enumValue) {
+        throw new Error(`cannot parse ${descEnum} default value: ${value}`);
+    }
     return enumValue.number;
 }
 exports.parseTextFormatEnumValue = parseTextFormatEnumValue;
@@ -35,24 +37,24 @@ exports.parseTextFormatEnumValue = parseTextFormatEnumValue;
  */
 function parseTextFormatScalarValue(type, value) {
     switch (type) {
-        case scalar_js_1.ScalarType.STRING:
+        case descriptors_js_1.ScalarType.STRING:
             return value;
-        case scalar_js_1.ScalarType.BYTES: {
+        case descriptors_js_1.ScalarType.BYTES: {
             const u = unescapeBytesDefaultValue(value);
             if (u === false) {
-                throw new Error(`cannot parse ${scalar_js_1.ScalarType[type]} default value: ${value}`);
+                throw new Error(`cannot parse ${descriptors_js_1.ScalarType[type]} default value: ${value}`);
             }
             return u;
         }
-        case scalar_js_1.ScalarType.INT64:
-        case scalar_js_1.ScalarType.SFIXED64:
-        case scalar_js_1.ScalarType.SINT64:
+        case descriptors_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
             return proto_int64_js_1.protoInt64.parse(value);
-        case scalar_js_1.ScalarType.UINT64:
-        case scalar_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.UINT64:
+        case descriptors_js_1.ScalarType.FIXED64:
             return proto_int64_js_1.protoInt64.uParse(value);
-        case scalar_js_1.ScalarType.DOUBLE:
-        case scalar_js_1.ScalarType.FLOAT:
+        case descriptors_js_1.ScalarType.DOUBLE:
+        case descriptors_js_1.ScalarType.FLOAT:
             switch (value) {
                 case "inf":
                     return Number.POSITIVE_INFINITY;
@@ -63,13 +65,13 @@ function parseTextFormatScalarValue(type, value) {
                 default:
                     return parseFloat(value);
             }
-        case scalar_js_1.ScalarType.BOOL:
+        case descriptors_js_1.ScalarType.BOOL:
             return value === "true";
-        case scalar_js_1.ScalarType.INT32:
-        case scalar_js_1.ScalarType.UINT32:
-        case scalar_js_1.ScalarType.SINT32:
-        case scalar_js_1.ScalarType.FIXED32:
-        case scalar_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.ScalarType.INT32:
+        case descriptors_js_1.ScalarType.UINT32:
+        case descriptors_js_1.ScalarType.SINT32:
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.SFIXED32:
             return parseInt(value, 10);
     }
 }