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

package/dist/cjs/from-json.js

@@ -14,16 +14,16 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeFromJson = exports.fromJson = exports.mergeFromJsonString = exports.fromJsonString = void 0;
-const assert_js_1 = require("./reflect/assert.js");
+/* eslint-disable no-case-declarations,@typescript-eslint/restrict-template-expressions */
+const descriptors_js_1 = require("./descriptors.js");
 const proto_int64_js_1 = require("./proto-int64.js");
 const create_js_1 = require("./create.js");
 const reflect_js_1 = require("./reflect/reflect.js");
+const error_js_1 = require("./reflect/error.js");
 const reflect_check_js_1 = require("./reflect/reflect-check.js");
 const scalar_js_1 = require("./reflect/scalar.js");
 const base64_encoding_js_1 = require("./wire/base64-encoding.js");
-const text_encoding_js_1 = require("./wire/text-encoding.js");
 const index_js_1 = require("./wkt/index.js");
-const wrappers_js_1 = require("./wkt/wrappers.js");
 const extensions_js_1 = require("./extensions.js");
 // Default options for parsing JSON.
 const jsonReadDefaults = {
@@ -57,7 +57,18 @@ exports.mergeFromJsonString = mergeFromJsonString;
  */
 function fromJson(messageDesc, json, options) {
     const msg = (0, reflect_js_1.reflect)(messageDesc);
-    readMessage(msg, json, makeReadOptions(options));
+    try {
+        readMessage(msg, json, makeReadOptions(options));
+    }
+    catch (e) {
+        if ((0, error_js_1.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;
 }
 exports.fromJson = fromJson;
@@ -71,7 +82,18 @@ exports.fromJson = fromJson;
  * new data.
  */
 function mergeFromJson(messageDesc, target, json, options) {
-    readMessage((0, reflect_js_1.reflect)(messageDesc, target), json, makeReadOptions(options));
+    try {
+        readMessage((0, reflect_js_1.reflect)(messageDesc, target), json, makeReadOptions(options));
+    }
+    catch (e) {
+        if ((0, error_js_1.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;
 }
 exports.mergeFromJson = mergeFromJson;
@@ -81,7 +103,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: ${(0, reflect_check_js_1.formatVal)(json)}`);
+        throw new Error(`cannot decode ${msg.desc} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
     }
     const oneofSeen = new Map();
     const jsonNames = new Map();
@@ -98,9 +120,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 error_js_1.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);
         }
@@ -115,7 +137,7 @@ function readMessage(msg, json, opts) {
                 (0, extensions_js_1.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`);
             }
         }
     }
@@ -132,95 +154,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: ${(0, reflect_check_js_1.formatVal)(json)}`);
+        throw new error_js_1.FieldError(field, "expected object, got " + (0, reflect_check_js_1.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: ${(0, reflect_check_js_1.formatVal)(jsonMapKey)}`;
-            if (e instanceof Error && e.message.length > 0) {
-                m += `: ${e.message}`;
-            }
-            throw new Error(m);
+            throw new error_js_1.FieldError(field, "map value must not be null");
         }
+        let value;
         switch (field.mapKind) {
             case "message":
                 const msgValue = (0, reflect_js_1.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: ${(0, reflect_check_js_1.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: ${(0, reflect_check_js_1.formatVal)(json)}`);
+        throw new error_js_1.FieldError(field, "expected Array, got " + (0, reflect_check_js_1.formatVal)(json));
     }
     for (const jsonItem of json) {
         if (jsonItem === null) {
-            throw new Error(`cannot decode field ${msg.desc.typeName}.${field.name} from JSON: ${(0, reflect_check_js_1.formatVal)(jsonItem)}`);
+            throw new error_js_1.FieldError(field, "list item must not be null");
         }
         switch (field.listKind) {
             case "message":
                 const msgValue = (0, reflect_js_1.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: ${(0, reflect_check_js_1.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;
         }
@@ -245,36 +251,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: ${(0, reflect_check_js_1.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 === scalar_js_1.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) {
@@ -301,116 +289,143 @@ function readEnum(desc, json, ignoreUnknownFields, nullAsZeroValue) {
             }
             break;
     }
-    throw new Error(`cannot decode enum ${desc.typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
+    throw new Error(`cannot decode ${desc} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
 }
 const tokenNull = Symbol();
-function readScalar(type, json, nullAsZeroValue) {
+function scalarFromJson(field, json, nullAsZeroValue) {
     if (json === null) {
         if (nullAsZeroValue) {
-            return (0, scalar_js_1.scalarZeroValue)(type, scalar_js_1.LongType.BIGINT);
+            return (0, scalar_js_1.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 scalar_js_1.ScalarType.DOUBLE:
-        case scalar_js_1.ScalarType.FLOAT:
+        case descriptors_js_1.ScalarType.DOUBLE:
+        case descriptors_js_1.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 error_js_1.FieldError(field, "unexpected NaN number");
+                }
+                if (!isFinite(json)) {
+                    // Infinity must be encoded with string constants
+                    throw new error_js_1.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 == scalar_js_1.ScalarType.FLOAT)
-                (0, assert_js_1.assertFloat32)(float);
-            return float;
+            break;
         // 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.FIXED32:
-        case scalar_js_1.ScalarType.SFIXED32:
-        case scalar_js_1.ScalarType.SINT32:
-        case scalar_js_1.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);
-            }
-            if (int32 === undefined)
-                break;
-            if (type == scalar_js_1.ScalarType.UINT32 || type == scalar_js_1.ScalarType.FIXED32)
-                (0, assert_js_1.assertUInt32)(int32);
-            else
-                (0, assert_js_1.assertInt32)(int32);
-            return int32;
-        // int64, fixed64, uint64: JSON value will be a decimal string. Either numbers or strings are accepted.
-        case scalar_js_1.ScalarType.INT64:
-        case scalar_js_1.ScalarType.SFIXED64:
-        case scalar_js_1.ScalarType.SINT64:
-            if (typeof json != "number" && typeof json != "string")
-                break;
-            return proto_int64_js_1.protoInt64.parse(json);
-        case scalar_js_1.ScalarType.FIXED64:
-        case scalar_js_1.ScalarType.UINT64:
-            if (typeof json != "number" && typeof json != "string")
-                break;
-            return proto_int64_js_1.protoInt64.uParse(json);
-        // bool:
-        case scalar_js_1.ScalarType.BOOL:
-            if (typeof json !== "boolean")
-                break;
-            return json;
-        // string:
-        case scalar_js_1.ScalarType.STRING:
-            if (typeof json !== "string") {
-                break;
+        case descriptors_js_1.ScalarType.INT32:
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.ScalarType.SINT32:
+        case descriptors_js_1.ScalarType.UINT32:
+            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 descriptors_js_1.ScalarType.BYTES:
+            if (typeof json == "string") {
+                if (json === "") {
+                    return new Uint8Array(0);
+                }
+                try {
+                    return (0, base64_encoding_js_1.base64Decode)(json);
+                }
+                catch (e) {
+                    const message = e instanceof Error ? e.message : String(e);
+                    throw new error_js_1.FieldError(field, message);
+                }
             }
-            // A string must always contain UTF-8 encoded or 7-bit ASCII.
-            if (!(0, text_encoding_js_1.getTextEncoding)().checkUtf8(json)) {
-                throw new Error("invalid UTF8");
+            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 descriptors_js_1.ScalarType.BOOL:
+            // 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 scalar_js_1.ScalarType.BYTES:
-            if (json === "")
-                return new Uint8Array(0);
-            if (typeof json !== "string")
-                break;
-            return (0, base64_encoding_js_1.base64Decode)(json);
+        case descriptors_js_1.ScalarType.INT32:
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.UINT32:
+        case descriptors_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.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) {
@@ -440,13 +455,16 @@ function tryWktFromJson(msg, jsonValue, opts) {
             listValueFromJson(msg.message, jsonValue);
             return true;
         default:
-            if ((0, wrappers_js_1.isWrapperDesc)(msg.desc)) {
+            if ((0, index_js_1.isWrapperDesc)(msg.desc)) {
                 const valueField = msg.desc.fields[0];
                 if (jsonValue === null) {
                     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;
             }
@@ -456,7 +474,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 ${(0, reflect_check_js_1.formatVal)(json)}`);
     }
     if (Object.keys(json).length == 0) {
         return;
@@ -465,7 +483,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`);
     }
@@ -484,17 +508,17 @@ function anyFromJson(any, json, opts) {
 }
 function timestampFromJson(timestamp, json) {
     if (typeof json !== "string") {
-        throw new Error(`cannot decode ${timestamp.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
+        throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: ${(0, reflect_check_js_1.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")) {
@@ -510,15 +534,15 @@ function timestampFromJson(timestamp, json) {
 }
 function durationFromJson(duration, json) {
     if (typeof json !== "string") {
-        throw new Error(`cannot decode ${duration.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
+        throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
     }
     const match = json.match(/^(-?[0-9]+)(?:\.([0-9]+))?s/);
     if (match === null) {
-        throw new Error(`cannot decode ${duration.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
+        throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
     }
     const longSeconds = Number(match[1]);
     if (longSeconds > 315576000000 || longSeconds < -315576000000) {
-        throw new Error(`cannot decode ${duration.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
+        throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
     }
     duration.seconds = proto_int64_js_1.protoInt64.parse(longSeconds);
     if (typeof match[2] !== "string") {
@@ -532,14 +556,14 @@ function durationFromJson(duration, json) {
 }
 function fieldMaskFromJson(fieldMask, json) {
     if (typeof json !== "string") {
-        throw new Error(`cannot decode ${fieldMask.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
+        throw new Error(`cannot decode message ${fieldMask.$typeName} from JSON: ${(0, reflect_check_js_1.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;
@@ -548,7 +572,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 ${(0, reflect_check_js_1.formatVal)(json)}`);
+        throw new Error(`cannot decode message ${struct.$typeName} from JSON ${(0, reflect_check_js_1.formatVal)(json)}`);
     }
     for (const [k, v] of Object.entries(json)) {
         const parsedV = (0, create_js_1.create)(index_js_1.ValueDesc);
@@ -583,13 +607,13 @@ function valueFromJson(value, json) {
             }
             break;
         default:
-            throw new Error(`cannot decode ${value.$typeName} from JSON ${(0, reflect_check_js_1.formatVal)(json)}`);
+            throw new Error(`cannot decode message ${value.$typeName} from JSON ${(0, reflect_check_js_1.formatVal)(json)}`);
     }
     return value;
 }
 function listValueFromJson(listValue, json) {
     if (!Array.isArray(json)) {
-        throw new Error(`cannot decode ${listValue.$typeName} from JSON ${(0, reflect_check_js_1.formatVal)(json)}`);
+        throw new Error(`cannot decode message ${listValue.$typeName} from JSON ${(0, reflect_check_js_1.formatVal)(json)}`);
     }
     for (const e of json) {
         const value = (0, create_js_1.create)(index_js_1.ValueDesc);
@@ -597,14 +621,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/cjs/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/cjs/index.js

@@ -32,9 +32,10 @@ __exportStar(require("./types.js"), exports);
 __exportStar(require("./is-message.js"), exports);
 __exportStar(require("./create.js"), exports);
 __exportStar(require("./clone.js"), exports);
-__exportStar(require("./desc-types.js"), exports);
+__exportStar(require("./descriptors.js"), exports);
 __exportStar(require("./equals.js"), exports);
 __exportStar(require("./fields.js"), exports);
+__exportStar(require("./registry.js"), exports);
 var to_binary_js_1 = require("./to-binary.js");
 Object.defineProperty(exports, "toBinary", { enumerable: true, get: function () { return to_binary_js_1.toBinary; } });
 var from_binary_js_1 = require("./from-binary.js");

package/dist/cjs/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.