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

package/dist/esm/from-json.js

@@ -11,16 +11,16 @@
 // 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.
-import { assertFloat32, assertInt32, assertUInt32 } from "./reflect/assert.js";
+/* eslint-disable no-case-declarations,@typescript-eslint/restrict-template-expressions */
+import { ScalarType, } from "./descriptors.js";
 import { protoInt64 } from "./proto-int64.js";
 import { create } from "./create.js";
 import { reflect } from "./reflect/reflect.js";
+import { FieldError, isFieldError } from "./reflect/error.js";
 import { formatVal } from "./reflect/reflect-check.js";
-import { LongType, ScalarType, scalarZeroValue, } from "./reflect/scalar.js";
+import { scalarZeroValue } from "./reflect/scalar.js";
 import { base64Decode } from "./wire/base64-encoding.js";
-import { getTextEncoding } from "./wire/text-encoding.js";
-import { anyPack, ListValueDesc, NullValue, StructDesc, ValueDesc, } from "./wkt/index.js";
-import { isWrapperDesc } from "./wkt/wrappers.js";
+import { isWrapperDesc, anyPack, ListValueDesc, NullValue, StructDesc, ValueDesc, } from "./wkt/index.js";
 import { createExtensionContainer, setExtension } from "./extensions.js";
 // Default options for parsing JSON.
 const jsonReadDefaults = {
@@ -52,7 +52,18 @@ export function mergeFromJsonString(messageDesc, target, json, options) {
  */
 export function fromJson(messageDesc, json, options) {
     const msg = reflect(messageDesc);
-    readMessage(msg, json, makeReadOptions(options));
+    try {
+        readMessage(msg, json, makeReadOptions(options));
+    }
+    catch (e) {
+        if (isFieldError(e)) {
+            // @ts-expect-error we use the ES2022 error CTOR option "cause" for better stack traces
+            throw new Error(`cannot decode ${e.field()} from JSON: ${e.message}`, {
+                cause: e,
+            });
+        }
+        throw e;
+    }
     return msg.message;
 }
 /**
@@ -65,7 +76,18 @@ export function fromJson(messageDesc, json, options) {
  * new data.
  */
 export function mergeFromJson(messageDesc, target, json, options) {
-    readMessage(reflect(messageDesc, target), json, makeReadOptions(options));
+    try {
+        readMessage(reflect(messageDesc, target), json, makeReadOptions(options));
+    }
+    catch (e) {
+        if (isFieldError(e)) {
+            // @ts-expect-error we use the ES2022 error CTOR option "cause" for better stack traces
+            throw new Error(`cannot decode ${e.field()} from JSON: ${e.message}`, {
+                cause: e,
+            });
+        }
+        throw e;
+    }
     return target;
 }
 function readMessage(msg, json, opts) {
@@ -74,7 +96,7 @@ function readMessage(msg, json, opts) {
         return;
     }
     if (json == null || Array.isArray(json) || typeof json != "object") {
-        throw new Error(`cannot decode message ${msg.desc.typeName} from JSON: ${formatVal(json)}`);
+        throw new Error(`cannot decode ${msg.desc} from JSON: ${formatVal(json)}`);
     }
     const oneofSeen = new Map();
     const jsonNames = new Map();
@@ -91,9 +113,9 @@ function readMessage(msg, json, opts) {
                 }
                 const seen = oneofSeen.get(field.oneof);
                 if (seen !== undefined) {
-                    throw new Error(`cannot decode message ${msg.desc.typeName} from JSON: multiple keys for oneof "${field.oneof.name}" present: "${seen}", "${jsonKey}"`);
+                    throw new FieldError(field.oneof, `oneof set multiple times by ${seen.name} and ${field.name}`);
                 }
-                oneofSeen.set(field.oneof, jsonKey);
+                oneofSeen.set(field.oneof, field);
             }
             readField(msg, field, jsonValue, opts);
         }
@@ -108,7 +130,7 @@ function readMessage(msg, json, opts) {
                 setExtension(msg.message, extension, get());
             }
             if (!extension && !opts.ignoreUnknownFields) {
-                throw new Error(`cannot decode message ${msg.desc.typeName} from JSON: key "${jsonKey}" is unknown`);
+                throw new Error(`cannot decode ${msg.desc} from JSON: key "${jsonKey}" is unknown`);
             }
         }
     }
@@ -125,95 +147,79 @@ function readField(msg, field, json, opts) {
             readMessageField(msg, field, json, opts);
             break;
         case "list":
-            readListField(msg, field, json, opts);
+            readListField(msg.get(field), json, opts);
             break;
         case "map":
-            readMapField(msg, field, json, opts);
+            readMapField(msg.get(field), json, opts);
             break;
     }
 }
-function readMapField(msg, field, json, opts) {
+function readMapField(map, json, opts) {
     if (json === null) {
         return;
     }
+    const field = map.field();
     if (typeof json != "object" || Array.isArray(json)) {
-        throw new Error(`cannot decode field ${msg.desc.typeName}.${field.name} from JSON: ${formatVal(json)}`);
+        throw new FieldError(field, "expected object, got " + formatVal(json));
     }
     for (const [jsonMapKey, jsonMapValue] of Object.entries(json)) {
         if (jsonMapValue === null) {
-            throw new Error(`cannot decode field ${msg.desc.typeName}.${field.name} from JSON: map value null`);
-        }
-        let key;
-        try {
-            key = readMapKey(field.mapKey, jsonMapKey);
-        }
-        catch (e) {
-            let m = `cannot decode map key for field ${msg.desc.typeName}.${field.name} from JSON: ${formatVal(jsonMapKey)}`;
-            if (e instanceof Error && e.message.length > 0) {
-                m += `: ${e.message}`;
-            }
-            throw new Error(m);
+            throw new FieldError(field, "map value must not be null");
         }
+        let value;
         switch (field.mapKind) {
             case "message":
                 const msgValue = reflect(field.message);
                 readMessage(msgValue, jsonMapValue, opts);
-                msg.setMapEntry(field, key, msgValue);
+                value = msgValue;
                 break;
             case "enum":
-                const enumValue = readEnum(field.enum, jsonMapValue, opts.ignoreUnknownFields, true);
-                if (enumValue !== tokenIgnoredUnknownEnum) {
-                    msg.setMapEntry(field, key, enumValue);
+                value = readEnum(field.enum, jsonMapValue, opts.ignoreUnknownFields, true);
+                if (value === tokenIgnoredUnknownEnum) {
+                    return;
                 }
                 break;
             case "scalar":
-                try {
-                    msg.setMapEntry(field, key, readScalar(field.scalar, jsonMapValue, true));
-                }
-                catch (e) {
-                    let m = `cannot decode map value for field ${msg.desc.typeName}.${field.name} from JSON: ${formatVal(jsonMapValue)}`;
-                    if (e instanceof Error && e.message.length > 0) {
-                        m += `: ${e.message}`;
-                    }
-                    throw new Error(m);
-                }
+                value = scalarFromJson(field, jsonMapValue, true);
                 break;
         }
+        const key = mapKeyFromJson(field.mapKey, jsonMapKey);
+        // TODO fix types
+        // @ts-expect-error TODO
+        const err = map.set(key, value);
+        if (err) {
+            throw err;
+        }
     }
 }
-function readListField(msg, field, json, opts) {
+function readListField(list, json, opts) {
     if (json === null) {
         return;
     }
+    const field = list.field();
     if (!Array.isArray(json)) {
-        throw new Error(`cannot decode field ${msg.desc.typeName}.${field.name} from JSON: ${formatVal(json)}`);
+        throw new FieldError(field, "expected Array, got " + formatVal(json));
     }
     for (const jsonItem of json) {
         if (jsonItem === null) {
-            throw new Error(`cannot decode field ${msg.desc.typeName}.${field.name} from JSON: ${formatVal(jsonItem)}`);
+            throw new FieldError(field, "list item must not be null");
         }
         switch (field.listKind) {
             case "message":
                 const msgValue = reflect(field.message);
                 readMessage(msgValue, jsonItem, opts);
-                msg.addListItem(field, msgValue);
+                list.add(msgValue);
                 break;
             case "enum":
                 const enumValue = readEnum(field.enum, jsonItem, opts.ignoreUnknownFields, true);
                 if (enumValue !== tokenIgnoredUnknownEnum) {
-                    msg.addListItem(field, enumValue);
+                    list.add(enumValue);
                 }
                 break;
             case "scalar":
-                try {
-                    msg.addListItem(field, readScalar(field.scalar, jsonItem, true));
-                }
-                catch (e) {
-                    let m = `cannot decode field ${msg.desc.typeName}.${field.name} from JSON: ${formatVal(jsonItem)}`;
-                    if (e instanceof Error && e.message.length > 0) {
-                        m += `: ${e.message}`;
-                    }
-                    throw new Error(m);
+                const err = list.add(scalarFromJson(field, jsonItem, true));
+                if (err) {
+                    throw err;
                 }
                 break;
         }
@@ -238,36 +244,18 @@ function readEnumField(msg, field, json, opts) {
     }
 }
 function readScalarField(msg, field, json) {
-    try {
-        const scalarValue = readScalar(field.scalar, json, false);
-        if (scalarValue === tokenNull) {
-            msg.clear(field);
-        }
-        else {
-            msg.set(field, scalarValue);
-        }
-    }
-    catch (e) {
-        let m = `cannot decode field ${msg.desc.typeName}.${field.name} from JSON: ${formatVal(json)}`;
-        if (e instanceof Error && e.message.length > 0) {
-            m += `: ${e.message}`;
-        }
-        throw new Error(m);
+    const scalarValue = scalarFromJson(field, json, false);
+    if (scalarValue === tokenNull) {
+        msg.clear(field);
     }
-}
-function readMapKey(type, json) {
-    if (type === ScalarType.BOOL) {
-        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-        switch (json) {
-            case "true":
-                json = true;
-                break;
-            case "false":
-                json = false;
-                break;
+    else {
+        // TODO fix type error
+        // @ts-expect-error TODO
+        const err = msg.set(field, scalarValue);
+        if (err) {
+            throw err;
         }
     }
-    return readScalar(type, json, true);
 }
 const tokenIgnoredUnknownEnum = Symbol();
 function readEnum(desc, json, ignoreUnknownFields, nullAsZeroValue) {
@@ -294,116 +282,143 @@ function readEnum(desc, json, ignoreUnknownFields, nullAsZeroValue) {
             }
             break;
     }
-    throw new Error(`cannot decode enum ${desc.typeName} from JSON: ${formatVal(json)}`);
+    throw new Error(`cannot decode ${desc} from JSON: ${formatVal(json)}`);
 }
 const tokenNull = Symbol();
-function readScalar(type, json, nullAsZeroValue) {
+function scalarFromJson(field, json, nullAsZeroValue) {
     if (json === null) {
         if (nullAsZeroValue) {
-            return scalarZeroValue(type, LongType.BIGINT);
+            return scalarZeroValue(field.scalar, false);
         }
         return tokenNull;
     }
-    // every valid case in the switch below returns, and every fall
-    // through is regarded as a failure.
-    switch (type) {
+    // int64, sfixed64, sint64, fixed64, uint64: Reflect supports string and number.
+    // string, bool: Supported by reflect.
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (field.scalar) {
         // 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:
             if (json === "NaN")
-                return Number.NaN;
+                return NaN;
             if (json === "Infinity")
                 return Number.POSITIVE_INFINITY;
             if (json === "-Infinity")
                 return Number.NEGATIVE_INFINITY;
-            if (json === "") {
-                // empty string is not a number
-                break;
-            }
-            if (typeof json == "string" && json.trim().length !== json.length) {
-                // extra whitespace
-                break;
-            }
-            if (typeof json != "string" && typeof json != "number") {
-                break;
-            }
-            const float = Number(json);
-            if (Number.isNaN(float)) {
-                // not a number
+            if (typeof json == "number") {
+                if (isNaN(json)) {
+                    // NaN must be encoded with string constants
+                    throw new FieldError(field, "unexpected NaN number");
+                }
+                if (!isFinite(json)) {
+                    // Infinity must be encoded with string constants
+                    throw new FieldError(field, "unexpected infinite number");
+                }
                 break;
             }
-            if (!Number.isFinite(float)) {
-                // infinity and -infinity are handled by string representation above, so this is an error
-                break;
+            if (typeof json == "string") {
+                if (json === "") {
+                    // empty string is not a number
+                    break;
+                }
+                if (json.trim().length !== json.length) {
+                    // extra whitespace
+                    break;
+                }
+                const float = Number(json);
+                if (!isFinite(float)) {
+                    // Infinity and NaN must be encoded with string constants
+                    break;
+                }
+                return float;
             }
-            if (type == ScalarType.FLOAT)
-                assertFloat32(float);
-            return float;
+            break;
         // 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:
-            let int32;
-            if (typeof json == "number")
-                int32 = json;
-            else if (typeof json == "string" && json.length > 0) {
-                if (json.trim().length === json.length)
-                    int32 = Number(json);
+            return int32FromJson(json);
+        // 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 ScalarType.BYTES:
+            if (typeof json == "string") {
+                if (json === "") {
+                    return new Uint8Array(0);
+                }
+                try {
+                    return base64Decode(json);
+                }
+                catch (e) {
+                    const message = e instanceof Error ? e.message : String(e);
+                    throw new FieldError(field, message);
+                }
             }
-            if (int32 === undefined)
-                break;
-            if (type == ScalarType.UINT32 || type == ScalarType.FIXED32)
-                assertUInt32(int32);
-            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:
-            if (typeof json != "number" && typeof json != "string")
-                break;
-            return protoInt64.parse(json);
-        case ScalarType.FIXED64:
-        case ScalarType.UINT64:
-            if (typeof json != "number" && typeof json != "string")
-                break;
-            return protoInt64.uParse(json);
-        // bool:
+            break;
+    }
+    return json;
+}
+/**
+ * Try to parse a JSON value to a map key for the reflect API.
+ *
+ * Returns the input if the JSON value cannot be converted.
+ */
+function mapKeyFromJson(type, json) {
+    switch (type) {
         case ScalarType.BOOL:
-            if (typeof json !== "boolean")
-                break;
-            return json;
-        // string:
-        case ScalarType.STRING:
-            if (typeof json !== "string") {
-                break;
-            }
-            // A string must always contain UTF-8 encoded or 7-bit ASCII.
-            if (!getTextEncoding().checkUtf8(json)) {
-                throw new Error("invalid UTF8");
+            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+            switch (json) {
+                case "true":
+                    return true;
+                case "false":
+                    return false;
             }
             return json;
-        // 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 ScalarType.BYTES:
-            if (json === "")
-                return new Uint8Array(0);
-            if (typeof json !== "string")
-                break;
-            return base64Decode(json);
+        case ScalarType.INT32:
+        case ScalarType.FIXED32:
+        case ScalarType.UINT32:
+        case ScalarType.SFIXED32:
+        case ScalarType.SINT32:
+            return int32FromJson(json);
+        default:
+            return json;
     }
-    throw new Error();
+}
+/**
+ * Try to parse a JSON value to a 32-bit integer for the reflect API.
+ *
+ * Returns the input if the JSON value cannot be converted.
+ */
+function int32FromJson(json) {
+    if (typeof json == "string") {
+        if (json === "") {
+            // empty string is not a number
+            return json;
+        }
+        if (json.trim().length !== json.length) {
+            // extra whitespace
+            return json;
+        }
+        const num = Number(json);
+        if (Number.isNaN(num)) {
+            // not a number
+            return json;
+        }
+        return num;
+    }
+    return json;
 }
 function parseJsonString(jsonString, typeName) {
     try {
         return JSON.parse(jsonString);
     }
     catch (e) {
-        throw new Error(`cannot decode ${typeName} from JSON: ${e instanceof Error ? e.message : String(e)}`);
+        const message = e instanceof Error ? e.message : String(e);
+        throw new Error(`cannot decode message ${typeName} from JSON: ${message}`, 
+        // @ts-expect-error we use the ES2022 error CTOR option "cause" for better stack traces
+        { cause: e });
     }
 }
 function tryWktFromJson(msg, jsonValue, opts) {
@@ -439,7 +454,10 @@ function tryWktFromJson(msg, jsonValue, opts) {
                     msg.clear(valueField);
                 }
                 else {
-                    msg.set(valueField, readScalar(valueField.scalar, jsonValue, true));
+                    const err = msg.set(valueField, scalarFromJson(valueField, jsonValue, true));
+                    if (err) {
+                        throw err;
+                    }
                 }
                 return true;
             }
@@ -449,7 +467,7 @@ function tryWktFromJson(msg, jsonValue, opts) {
 function anyFromJson(any, json, opts) {
     var _a;
     if (json === null || Array.isArray(json) || typeof json != "object") {
-        throw new Error(`cannot decode message ${any.$typeName} from JSON: expected object but got ${json === null ? "null" : Array.isArray(json) ? "array" : typeof json}`);
+        throw new Error(`cannot decode message ${any.$typeName} from JSON: expected object but got ${formatVal(json)}`);
     }
     if (Object.keys(json).length == 0) {
         return;
@@ -458,7 +476,13 @@ function anyFromJson(any, json, opts) {
     if (typeof typeUrl != "string" || typeUrl == "") {
         throw new Error(`cannot decode message ${any.$typeName} from JSON: "@type" is empty`);
     }
-    const typeName = typeUrlToName(typeUrl), desc = (_a = opts.registry) === null || _a === void 0 ? void 0 : _a.getMessage(typeName);
+    const typeName = typeUrl.includes("/")
+        ? typeUrl.substring(typeUrl.lastIndexOf("/") + 1)
+        : typeUrl;
+    if (!typeName.length) {
+        throw new Error(`cannot decode message ${any.$typeName} from JSON: "@type" is invalid`);
+    }
+    const desc = (_a = opts.registry) === null || _a === void 0 ? void 0 : _a.getMessage(typeName);
     if (!desc) {
         throw new Error(`cannot decode message ${any.$typeName} from JSON: ${typeUrl} is not in the type registry`);
     }
@@ -477,17 +501,17 @@ function anyFromJson(any, json, opts) {
 }
 function timestampFromJson(timestamp, json) {
     if (typeof json !== "string") {
-        throw new Error(`cannot decode ${timestamp.$typeName} from JSON: ${formatVal(json)}`);
+        throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: ${formatVal(json)}`);
     }
     const matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
     if (!matches) {
-        throw new Error(`cannot decode ${timestamp.$typeName} from JSON: invalid RFC 3339 string`);
+        throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: invalid RFC 3339 string`);
     }
     const ms = Date.parse(
     //prettier-ignore
     matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z"));
     if (Number.isNaN(ms)) {
-        throw new Error(`cannot decode ${timestamp.$typeName} from JSON: invalid RFC 3339 string`);
+        throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: invalid RFC 3339 string`);
     }
     if (ms < Date.parse("0001-01-01T00:00:00Z") ||
         ms > Date.parse("9999-12-31T23:59:59Z")) {
@@ -503,15 +527,15 @@ function timestampFromJson(timestamp, json) {
 }
 function durationFromJson(duration, json) {
     if (typeof json !== "string") {
-        throw new Error(`cannot decode ${duration.$typeName} from JSON: ${formatVal(json)}`);
+        throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${formatVal(json)}`);
     }
     const match = json.match(/^(-?[0-9]+)(?:\.([0-9]+))?s/);
     if (match === null) {
-        throw new Error(`cannot decode ${duration.$typeName} from JSON: ${formatVal(json)}`);
+        throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${formatVal(json)}`);
     }
     const longSeconds = Number(match[1]);
     if (longSeconds > 315576000000 || longSeconds < -315576000000) {
-        throw new Error(`cannot decode ${duration.$typeName} from JSON: ${formatVal(json)}`);
+        throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${formatVal(json)}`);
     }
     duration.seconds = protoInt64.parse(longSeconds);
     if (typeof match[2] !== "string") {
@@ -525,14 +549,14 @@ function durationFromJson(duration, json) {
 }
 function fieldMaskFromJson(fieldMask, json) {
     if (typeof json !== "string") {
-        throw new Error(`cannot decode ${fieldMask.$typeName} from JSON: ${formatVal(json)}`);
+        throw new Error(`cannot decode message ${fieldMask.$typeName} from JSON: ${formatVal(json)}`);
     }
     if (json === "") {
         return;
     }
     function camelToSnake(str) {
         if (str.includes("_")) {
-            throw new Error(`cannot decode ${fieldMask.$typeName} from JSON: path names must be lowerCamelCase`);
+            throw new Error(`cannot decode message ${fieldMask.$typeName} from JSON: path names must be lowerCamelCase`);
         }
         const sc = str.replace(/[A-Z]/g, (letter) => "_" + letter.toLowerCase());
         return sc[0] === "_" ? sc.substring(1) : sc;
@@ -541,7 +565,7 @@ function fieldMaskFromJson(fieldMask, json) {
 }
 function structFromJson(struct, json) {
     if (typeof json != "object" || json == null || Array.isArray(json)) {
-        throw new Error(`cannot decode ${struct.$typeName} from JSON ${formatVal(json)}`);
+        throw new Error(`cannot decode message ${struct.$typeName} from JSON ${formatVal(json)}`);
     }
     for (const [k, v] of Object.entries(json)) {
         const parsedV = create(ValueDesc);
@@ -576,13 +600,13 @@ function valueFromJson(value, json) {
             }
             break;
         default:
-            throw new Error(`cannot decode ${value.$typeName} from JSON ${formatVal(json)}`);
+            throw new Error(`cannot decode message ${value.$typeName} from JSON ${formatVal(json)}`);
     }
     return value;
 }
 function listValueFromJson(listValue, json) {
     if (!Array.isArray(json)) {
-        throw new Error(`cannot decode ${listValue.$typeName} from JSON ${formatVal(json)}`);
+        throw new Error(`cannot decode message ${listValue.$typeName} from JSON ${formatVal(json)}`);
     }
     for (const e of json) {
         const value = create(ValueDesc);
@@ -590,14 +614,3 @@ function listValueFromJson(listValue, json) {
         listValue.values.push(value);
     }
 }
-function typeUrlToName(url) {
-    if (!url.length) {
-        throw new Error(`invalid type url: ${url}`);
-    }
-    const slash = url.lastIndexOf("/");
-    const name = slash >= 0 ? url.substring(slash + 1) : url;
-    if (!name.length) {
-        throw new Error(`invalid type url: ${url}`);
-    }
-    return name;
-}

package/dist/esm/index.d.ts

@@ -2,9 +2,10 @@ export * from "./types.js";
 export * from "./is-message.js";
 export * from "./create.js";
 export * from "./clone.js";
-export * from "./desc-types.js";
+export * from "./descriptors.js";
 export * from "./equals.js";
 export * from "./fields.js";
+export * from "./registry.js";
 export type { JsonValue, JsonObject } from "./json-value.js";
 export { toBinary } from "./to-binary.js";
 export type { BinaryWriteOptions } from "./to-binary.js";

package/dist/esm/index.js

@@ -15,9 +15,10 @@ export * from "./types.js";
 export * from "./is-message.js";
 export * from "./create.js";
 export * from "./clone.js";
-export * from "./desc-types.js";
+export * from "./descriptors.js";
 export * from "./equals.js";
 export * from "./fields.js";
+export * from "./registry.js";
 export { toBinary } from "./to-binary.js";
 export { fromBinary, mergeFromBinary } from "./from-binary.js";
 export * from "./to-json.js";

package/dist/esm/is-message.d.ts

@@ -1,5 +1,5 @@
 import type { MessageShape } from "./types.js";
-import type { DescMessage } from "./desc-types.js";
+import type { DescMessage } from "./descriptors.js";
 /**
  * Determine whether the given `arg` is a message.
  * If `desc` is set, determine whether `arg` is this specific message.

package/dist/esm/proto-int64.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Int64Support for the current environment.
+ */
+export declare const protoInt64: Int64Support;
 /**
  * We use the `bigint` primitive to represent 64-bit integral types. If bigint
  * is unavailable, we fall back to a string representation, which means that
@@ -91,5 +95,4 @@ interface Int64Support {
      */
     uDec(lo: number, hi: number): bigint;
 }
-export declare const protoInt64: Int64Support;
 export {};