@code-yeongyu/senpi 2026.8.19 → 2026.8.20-2

package/node_modules/@bufbuild/protobuf/dist/esm/from-json.js

@@ -14,13 +14,18 @@
 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 { formatVal, reasonSingular, checkScalarValue, } from "./reflect/reflect-check.js";
 import { protoSnakeCase } from "./reflect/names.js";
+import { scalarZeroValue } from "./reflect/scalar.js";
+import { unsafeLocal } from "./reflect/unsafe.js";
+import { localMessageMapper } from "./reflect/message.js";
 import { base64Decode } from "./wire/base64-encoding.js";
 import { hasCustomJsonRepresentation, isWrapperDesc, anyPack, ListValueSchema, NullValue, StructSchema, ValueSchema, } from "./wkt/index.js";
 import { createExtensionContainer, setExtension } from "./extensions.js";
+import { durationSecondsMax, durationSecondsMin, timestampMsMax, timestampMsMin, } from "./wkt/json.js";
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name = $number;
+const IMPLICIT = 2;
 function makeReadContext(options) {
     return Object.assign(Object.assign({ ignoreUnknownFields: false, recursionLimit: 100 }, options), { depth: 0 });
 }
@@ -54,20 +59,9 @@ export function mergeFromJsonString(schema, target, json, options) {
  * duplicate-key checking.
  */
 export function fromJson(schema, json, options) {
-    const msg = reflect(schema);
-    try {
-        readMessage(msg, json, makeReadContext(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;
+    const message = create(schema);
+    readMessage(schema, message, json, options);
+    return message;
 }
 /**
  * Parse a message from a JSON value, merging fields into the target.
@@ -82,8 +76,20 @@ export function fromJson(schema, json, options) {
  * for strict checking.
  */
 export function mergeFromJson(schema, target, json, options) {
+    if (target.$typeName !== schema.typeName &&
+        schema.fields.length > 0) {
+        throw new FieldError(schema.fields[0], `cannot use ${schema.fields[0]} with message ${target.$typeName}`, "ForeignFieldError");
+    }
+    readMessage(schema, target, json, options);
+    return target;
+}
+/**
+ * Run the compiled decoder for the message, wrapping FieldErrors with the
+ * standard error message.
+ */
+function readMessage(schema, message, json, options) {
     try {
-        readMessage(reflect(schema, target), json, makeReadContext(options));
+        compiledReader(schema)(message, json, makeReadContext(options));
     }
     catch (e) {
         if (isFieldError(e)) {
@@ -94,13 +100,14 @@ export function mergeFromJson(schema, target, json, options) {
         }
         throw e;
     }
-    return target;
 }
 /**
  * Parses an enum value from JSON.
  */
 export function enumFromJson(descEnum, json) {
-    return readEnum(descEnum, json, false);
+    // With ignoreUnknownFields false, the converter never returns the token
+    // for ignored unknown enum values.
+    return compileEnumConverter(descEnum)(json, false);
 }
 /**
  * Is the given value a JSON enum value?
@@ -108,315 +115,646 @@ export function enumFromJson(descEnum, json) {
 export function isEnumJson(descEnum, value) {
     return undefined !== descEnum.values.find((v) => v.name === value);
 }
-const messageJsonFields = new WeakMap();
-function getJsonField(desc, jsonKey) {
-    var _a;
-    if (!messageJsonFields.has(desc)) {
-        const jsonNames = new Map();
-        for (const field of desc.fields) {
-            jsonNames.set(field.name, field).set(field.jsonName, field);
-        }
-        messageJsonFields.set(desc, jsonNames);
+const compiledReaders = new WeakMap();
+/**
+ * Return the compiled decoder for a message, compiling it on first use.
+ */
+function compiledReader(desc) {
+    let compiled = compiledReaders.get(desc);
+    if (compiled === undefined) {
+        compiled = compileMessage(desc);
     }
-    return (_a = messageJsonFields.get(desc)) === null || _a === void 0 ? void 0 : _a.get(jsonKey);
+    return compiled;
 }
-function readMessage(msg, json, ctx) {
-    var _a;
-    if (++ctx.depth > ctx.recursionLimit) {
-        throw new Error(`cannot decode ${msg.desc} from JSON: maximum recursion depth of ${ctx.recursionLimit} reached`);
-    }
-    if (tryWktFromJson(msg, json, ctx)) {
-        ctx.depth--;
-        return;
-    }
-    if (json == null || Array.isArray(json) || typeof json != "object") {
-        throw new Error(`cannot decode ${msg.desc} from JSON: ${formatVal(json)}`);
-    }
-    const oneofSeen = new Map();
-    const fieldSeen = new Set();
-    for (const [jsonKey, jsonValue] of Object.entries(json)) {
-        const field = getJsonField(msg.desc, jsonKey);
-        if (field) {
-            if (fieldSeen.has(field)) {
-                // The same field may be set by its proto name and its JSON name, or by
-                // a duplicate or unicode-escaped key that JSON.parse already collapsed.
-                // Checked before the null-skip below so that a null entry still counts.
-                throw new FieldError(field, "set multiple times");
+function compileMessage(desc) {
+    const descString = String(desc);
+    const readWkt = compileWkt(desc);
+    if (readWkt !== undefined) {
+        // All message decoders count against the recursion limit, including
+        // well-known types with a custom JSON representation.
+        const compiled = (message, json, ctx) => {
+            if (++ctx.depth > ctx.recursionLimit) {
+                throw new Error(`cannot decode ${descString} from JSON: maximum recursion depth of ${ctx.recursionLimit} reached`);
             }
-            fieldSeen.add(field);
-            if (field.oneof && jsonValue === null && field.fieldKind == "scalar") {
-                // see conformance test Required.Proto3.JsonInput.OneofFieldNull{First,Second}
-                continue;
+            readWkt(message, json, ctx);
+            ctx.depth--;
+        };
+        compiledReaders.set(desc, compiled);
+        return compiled;
+    }
+    const typeName = desc.typeName;
+    // Fields are looked up by their proto name and their JSON name.
+    const fieldsByJsonKey = new Map();
+    const compiled = (message, json, ctx) => {
+        var _a;
+        if (++ctx.depth > ctx.recursionLimit) {
+            throw new Error(`cannot decode ${descString} from JSON: maximum recursion depth of ${ctx.recursionLimit} reached`);
+        }
+        if (json == null || Array.isArray(json) || typeof json != "object") {
+            throw new Error(`cannot decode ${descString} from JSON: ${formatVal(json)}`);
+        }
+        const oneofSeen = new Map();
+        const fieldSeen = new Set();
+        const jsonKeys = Object.keys(json);
+        for (let i = 0; i < jsonKeys.length; i++) {
+            const jsonKey = jsonKeys[i];
+            const jsonValue = json[jsonKey];
+            const entry = fieldsByJsonKey.get(jsonKey);
+            if (entry !== undefined) {
+                const field = entry.field;
+                if (fieldSeen.has(field)) {
+                    // The same field may be set by its proto name and its JSON name, or by
+                    // a duplicate or unicode-escaped key that JSON.parse already collapsed.
+                    // Checked before the null-skip below so that a null entry still counts.
+                    throw new FieldError(field, "set multiple times");
+                }
+                fieldSeen.add(field);
+                if (entry.oneofScalarNullSkip && jsonValue === null) {
+                    continue;
+                }
+                if (entry.oneof) {
+                    const seen = oneofSeen.get(entry.oneof);
+                    if (seen !== undefined) {
+                        throw new FieldError(entry.oneof, `oneof set multiple times by ${seen.name} and ${field.name}`);
+                    }
+                    oneofSeen.set(entry.oneof, field);
+                }
+                entry.read(message, jsonValue, ctx);
             }
-            if (field.oneof) {
-                const seen = oneofSeen.get(field.oneof);
-                if (seen !== undefined) {
-                    throw new FieldError(field.oneof, `oneof set multiple times by ${seen.name} and ${field.name}`);
+            else {
+                const extension = jsonKey.startsWith("[") && jsonKey.endsWith("]")
+                    ? (_a = ctx.registry) === null || _a === void 0 ? void 0 : _a.getExtension(jsonKey.substring(1, jsonKey.length - 1))
+                    : undefined;
+                if ((extension === null || extension === void 0 ? void 0 : extension.extendee.typeName) == typeName) {
+                    const [container, field, get] = createExtensionContainer(extension);
+                    compileFieldReader(field)(container[unsafeLocal], jsonValue, ctx);
+                    setExtension(message, extension, get());
+                }
+                if (extension === undefined && !ctx.ignoreUnknownFields) {
+                    throw new Error(`cannot decode ${descString} from JSON: key "${jsonKey}" is unknown`);
                 }
-                oneofSeen.set(field.oneof, field);
             }
-            readField(msg, field, jsonValue, ctx);
         }
-        else {
-            let extension = undefined;
-            if (jsonKey.startsWith("[") &&
-                jsonKey.endsWith("]") &&
-                // biome-ignore lint/suspicious/noAssignInExpressions: no
-                (extension = (_a = ctx.registry) === null || _a === void 0 ? void 0 : _a.getExtension(jsonKey.substring(1, jsonKey.length - 1))) &&
-                extension.extendee.typeName === msg.desc.typeName) {
-                const [container, field, get] = createExtensionContainer(extension);
-                readField(container, field, jsonValue, ctx);
-                setExtension(msg.message, extension, get());
-            }
-            if (!extension && !ctx.ignoreUnknownFields) {
-                throw new Error(`cannot decode ${msg.desc} from JSON: key "${jsonKey}" is unknown`);
+        ctx.depth--;
+    };
+    // Register before compiling fields, so that recursive message types
+    // resolve to this instance instead of compiling endlessly.
+    compiledReaders.set(desc, compiled);
+    for (const field of desc.fields) {
+        const entry = {
+            read: compileFieldReader(field),
+            field,
+            oneof: field.oneof,
+            oneofScalarNullSkip: field.oneof !== undefined && field.fieldKind == "scalar",
+        };
+        fieldsByJsonKey.set(field.name, entry).set(field.jsonName, entry);
+    }
+    return compiled;
+}
+/**
+ * Compile a decoder for a well-known type with a custom JSON representation,
+ * or return undefined for other messages. The recursion limit is enforced by
+ * the caller.
+ */
+function compileWkt(desc) {
+    if (!desc.typeName.startsWith("google.protobuf.")) {
+        return undefined;
+    }
+    switch (desc.typeName) {
+        case "google.protobuf.Any":
+            return (message, json, ctx) => anyFromJson(message, json, ctx);
+        case "google.protobuf.Timestamp":
+            return (message, json) => timestampFromJson(message, json);
+        case "google.protobuf.Duration":
+            return (message, json) => durationFromJson(message, json);
+        case "google.protobuf.FieldMask":
+            return (message, json) => fieldMaskFromJson(message, json);
+        case "google.protobuf.Struct":
+            return (message, json, ctx) => structFromJson(message, json, ctx);
+        case "google.protobuf.Value":
+            return (message, json, ctx) => valueFromJson(message, json, ctx);
+        case "google.protobuf.ListValue":
+            return (message, json, ctx) => listValueFromJson(message, json, ctx);
+        default:
+            if (isWrapperDesc(desc)) {
+                const valueField = desc.fields[0];
+                const localName = valueField.localName;
+                const scalar = valueField.scalar;
+                const longAsString = valueField.longAsString;
+                const readScalar = compileScalarConverter(valueField);
+                return (message, json) => {
+                    if (json === null) {
+                        message[localName] = scalarZeroValue(scalar, longAsString);
+                    }
+                    else {
+                        message[localName] = readScalar(json);
+                    }
+                };
             }
-        }
+            return undefined;
     }
-    ctx.depth--;
 }
-function readField(msg, field, json, ctx) {
+function compileFieldReader(field) {
     switch (field.fieldKind) {
         case "scalar":
-            readScalarField(msg, field, json);
-            break;
+            return compileScalarFieldReader(field);
         case "enum":
-            readEnumField(msg, field, json, ctx);
-            break;
+            return compileEnumFieldReader(field);
         case "message":
-            readMessageField(msg, field, json, ctx);
-            break;
+            return compileMessageFieldReader(field);
         case "list":
-            readListField(msg.get(field), json, ctx);
-            break;
+            return compileListFieldReader(field);
         case "map":
-            readMapField(msg.get(field), json, ctx);
-            break;
+            return compileMapFieldReader(field);
     }
 }
-function readListOrMapItem(field, json, ctx) {
-    if (field.scalar && json !== null) {
-        return scalarFromJson(field, json);
-    }
-    if (field.message && !isResetSentinelNullValue(field, json)) {
-        const msgValue = reflect(field.message);
-        readMessage(msgValue, json, ctx);
-        return msgValue;
+function compileScalarFieldReader(field) {
+    const readScalar = compileScalarConverter(field);
+    const localName = field.localName;
+    if (field.oneof) {
+        // JSON null for a oneof scalar member is skipped by the message decoder.
+        const oneofLocalName = field.oneof.localName;
+        return (message, json) => {
+            message[oneofLocalName] = {
+                case: localName,
+                value: readScalar(json),
+            };
+        };
     }
-    if (field.enum && !isResetSentinelNullValue(field, json)) {
-        return readEnum(field.enum, json, ctx.ignoreUnknownFields);
-    }
-    throw new FieldError(field, `${field.fieldKind === "list" ? "list item" : "map value"} must not be null`);
-}
-function readMapField(map, json, ctx) {
-    if (json === null) {
-        return;
-    }
-    const field = map.field();
-    if (typeof json != "object" || Array.isArray(json)) {
-        throw new FieldError(field, "expected object, got " + formatVal(json));
-    }
-    const seen = new Set();
-    for (const [jsonMapKey, jsonMapValue] of Object.entries(json)) {
-        const key = mapKeyFromJson(field.mapKey, jsonMapKey);
-        if (seen.has(key)) {
-            throw new FieldError(field, `duplicate map key "${jsonMapKey}"`);
+    const clear = compileClear(field);
+    return (message, json) => {
+        if (json === null) {
+            clear(message);
         }
-        seen.add(key);
-        const value = readListOrMapItem(field, jsonMapValue, ctx);
-        if (value !== tokenIgnoredUnknownEnum) {
-            map.set(key, value);
+        else {
+            message[localName] = readScalar(json);
         }
-    }
+    };
 }
-function readListField(list, json, ctx) {
-    if (json === null) {
-        return;
-    }
-    const field = list.field();
-    if (!Array.isArray(json)) {
-        throw new FieldError(field, "expected Array, got " + formatVal(json));
+/**
+ * Compile a function that resets the field to unset, mirroring the clear
+ * operation of the reflect API for fields that are not part of a oneof.
+ */
+function compileClear(field) {
+    const localName = field.localName;
+    if (field.presence != IMPLICIT) {
+        // Fields with explicit presence have properties on the prototype chain
+        // for default / zero values (except for proto3). By deleting their own
+        // property, the field is reset.
+        return (message) => {
+            delete message[localName];
+        };
     }
-    for (const jsonItem of json) {
-        const value = readListOrMapItem(field, jsonItem, ctx);
-        if (value !== tokenIgnoredUnknownEnum) {
-            list.add(value);
-        }
+    if (field.fieldKind == "enum") {
+        const zero = field.enum.values[0].number;
+        return (message) => {
+            message[localName] = zero;
+        };
     }
+    const scalar = field.scalar;
+    const longAsString = field.longAsString;
+    return (message) => {
+        message[localName] = scalarZeroValue(scalar, longAsString);
+    };
 }
-function readMessageField(msg, field, json, ctx) {
-    if (isResetSentinelNullValue(field, json)) {
-        msg.clear(field);
-        return;
+function compileEnumFieldReader(field) {
+    const readEnumValue = compileEnumConverter(field.enum);
+    const checkEnum = compileEnumCheck(field.enum);
+    const localName = field.localName;
+    // Fields with enum google.protobuf.NullValue permit a Protobuf-serializable
+    // null; for all other enums, JSON null resets the field.
+    const nullResets = field.enum.typeName != "google.protobuf.NullValue";
+    if (field.oneof) {
+        const oneofLocalName = field.oneof.localName;
+        return (message, json, ctx) => {
+            if (json === null && nullResets) {
+                const oneof = message[oneofLocalName];
+                if (oneof.case === localName) {
+                    message[oneofLocalName] = { case: undefined };
+                }
+                return;
+            }
+            const value = readEnumValue(json, ctx.ignoreUnknownFields);
+            if (value === tokenIgnoredUnknownEnum) {
+                return;
+            }
+            const check = checkEnum(value);
+            if (check !== true) {
+                throw new FieldError(field, reasonSingular(field, value, check));
+            }
+            message[oneofLocalName] = { case: localName, value };
+        };
     }
-    const msgValue = msg.isSet(field) ? msg.get(field) : reflect(field.message);
-    readMessage(msgValue, json, ctx);
-    msg.set(field, msgValue);
+    const clear = compileClear(field);
+    return (message, json, ctx) => {
+        if (json === null && nullResets) {
+            clear(message);
+            return;
+        }
+        const value = readEnumValue(json, ctx.ignoreUnknownFields);
+        if (value === tokenIgnoredUnknownEnum) {
+            return;
+        }
+        const check = checkEnum(value);
+        if (check !== true) {
+            throw new FieldError(field, reasonSingular(field, value, check));
+        }
+        message[localName] = value;
+    };
 }
-function readEnumField(msg, field, json, ctx) {
-    if (isResetSentinelNullValue(field, json)) {
-        msg.clear(field);
-        return;
-    }
-    const enumValue = readEnum(field.enum, json, ctx.ignoreUnknownFields);
-    if (enumValue !== tokenIgnoredUnknownEnum) {
-        msg.set(field, enumValue);
+function compileMessageFieldReader(field) {
+    const localName = field.localName;
+    const { toMessage, toLocal } = localMessageMapper(field);
+    const readChild = compiledReader(field.message);
+    // Fields with message google.protobuf.Value permit a Protobuf-serializable
+    // null; for all other messages, JSON null resets the field.
+    const nullResets = field.message.typeName != "google.protobuf.Value";
+    if (field.oneof) {
+        const oneofLocalName = field.oneof.localName;
+        return (message, json, ctx) => {
+            const oneof = message[oneofLocalName];
+            if (json === null && nullResets) {
+                if (oneof.case === localName) {
+                    message[oneofLocalName] = { case: undefined };
+                }
+                return;
+            }
+            const child = toMessage(oneof.case === localName ? oneof.value : undefined);
+            readChild(child, json, ctx);
+            message[oneofLocalName] = { case: localName, value: toLocal(child) };
+        };
     }
+    return (message, json, ctx) => {
+        if (json === null && nullResets) {
+            delete message[localName];
+            return;
+        }
+        const child = toMessage(message[localName]);
+        readChild(child, json, ctx);
+        message[localName] = toLocal(child);
+    };
 }
-function readScalarField(msg, field, json) {
-    if (json === null) {
-        msg.clear(field);
-    }
-    else {
-        msg.set(field, scalarFromJson(field, json));
-    }
+function compileListFieldReader(field) {
+    const localName = field.localName;
+    const readItem = compileListItemReader(field);
+    return (message, json, ctx) => {
+        if (json === null) {
+            return;
+        }
+        if (!Array.isArray(json)) {
+            throw new FieldError(field, "expected Array, got " + formatVal(json));
+        }
+        const items = message[localName];
+        for (let i = 0; i < json.length; i++) {
+            const value = readItem(json[i], ctx, items.length);
+            if (value !== tokenIgnoredUnknownEnum) {
+                items.push(value);
+            }
+        }
+    };
 }
 /**
- * Indicates whether a value is a sentinel for reseting a field.
- *
- * For this to be true, the value must be a JSON null and the field must not
- * permit a present, Protobuf-serializable null.
- *
- * Only message google.protobuf.Value and enum google.protobuf.NullValue fields
- * permit Protobuf-serializable nulls.
- *
- * Note that field-resetting sentinel nulls are not permitted in lists and maps.
+ * Compile a decoder for a list item. The index is only used in errors, and
+ * accounts for previously merged items.
  */
-function isResetSentinelNullValue(field, json) {
-    var _a, _b;
-    return (json === null &&
-        ((_a = field.message) === null || _a === void 0 ? void 0 : _a.typeName) != "google.protobuf.Value" &&
-        ((_b = field.enum) === null || _b === void 0 ? void 0 : _b.typeName) != "google.protobuf.NullValue");
+function compileListItemReader(field) {
+    switch (field.listKind) {
+        case "scalar": {
+            const parseScalar = compileScalarParse(field);
+            const checkValue = checkScalarValue(field.scalar);
+            const toLocal = compileScalarToLocal(field);
+            return (json, ctx, index) => {
+                if (json === null) {
+                    throw new FieldError(field, "list item must not be null");
+                }
+                const value = parseScalar(json);
+                const check = checkValue(value);
+                if (check !== true) {
+                    throw new FieldError(field, `list item #${index + 1}: ${reasonSingular(field, value, check)}`);
+                }
+                return toLocal(value);
+            };
+        }
+        case "enum": {
+            const readEnumValue = compileEnumConverter(field.enum);
+            const checkEnum = compileEnumCheck(field.enum);
+            const nullResets = field.enum.typeName != "google.protobuf.NullValue";
+            return (json, ctx, index) => {
+                if (json === null && nullResets) {
+                    throw new FieldError(field, "list item must not be null");
+                }
+                const value = readEnumValue(json, ctx.ignoreUnknownFields);
+                if (value === tokenIgnoredUnknownEnum) {
+                    return value;
+                }
+                const check = checkEnum(value);
+                if (check !== true) {
+                    throw new FieldError(field, `list item #${index + 1}: ${reasonSingular(field, value, check)}`);
+                }
+                return value;
+            };
+        }
+        case "message": {
+            const { toMessage, toLocal } = localMessageMapper(field);
+            const readChild = compiledReader(field.message);
+            const nullResets = field.message.typeName != "google.protobuf.Value";
+            return (json, ctx) => {
+                if (json === null && nullResets) {
+                    throw new FieldError(field, "list item must not be null");
+                }
+                const child = toMessage(undefined);
+                readChild(child, json, ctx);
+                return toLocal(child);
+            };
+        }
+    }
 }
-const tokenIgnoredUnknownEnum = Symbol();
-function readEnum(desc, json, ignoreUnknownFields) {
-    if (json === null) {
-        return desc.values[0].number;
+function compileMapFieldReader(field) {
+    const localName = field.localName;
+    const mapKey = field.mapKey;
+    const parseMapKey = compileMapKeyParse(mapKey);
+    const checkMapKey = checkScalarValue(mapKey);
+    let parseValue;
+    // Additional validation for scalar and enum values, matching the checks
+    // of the reflect API. Message values need no validation.
+    let checkValue;
+    let toLocalValue = (value) => value;
+    // Fields with google.protobuf.Value or google.protobuf.NullValue values
+    // permit a Protobuf-serializable null.
+    let nullResets = true;
+    switch (field.mapKind) {
+        case "scalar": {
+            parseValue = compileScalarParse(field);
+            checkValue = checkScalarValue(field.scalar);
+            toLocalValue = compileScalarToLocal(field);
+            break;
+        }
+        case "enum": {
+            const readEnumValue = compileEnumConverter(field.enum);
+            parseValue = (json, ctx) => readEnumValue(json, ctx.ignoreUnknownFields);
+            checkValue = compileEnumCheck(field.enum);
+            nullResets = field.enum.typeName != "google.protobuf.NullValue";
+            break;
+        }
+        case "message": {
+            const { toMessage, toLocal } = localMessageMapper(field);
+            const readChild = compiledReader(field.message);
+            nullResets = field.message.typeName != "google.protobuf.Value";
+            parseValue = (json, ctx) => {
+                const child = toMessage(undefined);
+                readChild(child, json, ctx);
+                return toLocal(child);
+            };
+            break;
+        }
     }
-    switch (typeof json) {
-        case "number":
-            if (Number.isInteger(json)) {
-                return json;
+    return (message, json, ctx) => {
+        if (json === null) {
+            return;
+        }
+        if (typeof json != "object" || Array.isArray(json)) {
+            throw new FieldError(field, "expected object, got " + formatVal(json));
+        }
+        const record = message[localName];
+        const seen = new Set();
+        const jsonMapKeys = Object.keys(json);
+        for (let i = 0; i < jsonMapKeys.length; i++) {
+            const jsonMapKey = jsonMapKeys[i];
+            const jsonMapValue = json[jsonMapKey];
+            const key = parseMapKey(jsonMapKey);
+            if (seen.has(key)) {
+                throw new FieldError(field, `duplicate map key "${jsonMapKey}"`);
             }
-            break;
-        case "string":
-            const value = desc.values.find((ev) => ev.name === json);
-            if (value !== undefined) {
-                return value.number;
+            seen.add(key);
+            if (jsonMapValue === null && nullResets) {
+                throw new FieldError(field, "map value must not be null");
             }
-            if (ignoreUnknownFields) {
-                return tokenIgnoredUnknownEnum;
+            const value = parseValue(jsonMapValue, ctx);
+            if (value === tokenIgnoredUnknownEnum) {
+                continue;
             }
-            break;
+            const checkKey = checkMapKey(key);
+            if (checkKey !== true) {
+                throw new FieldError(field, `invalid map key: ${reasonSingular({ scalar: mapKey }, key, checkKey)}`);
+            }
+            if (checkValue !== undefined) {
+                const check = checkValue(value);
+                if (check !== true) {
+                    throw new FieldError(field, `map entry ${formatVal(key)}: ${reasonSingular(field, value, check)}`);
+                }
+            }
+            // Object property keys are always strings or symbols. Assigning with a
+            // boolean, number, or bigint key implicitly converts it to a string.
+            record[key] = toLocalValue(value);
+        }
+    };
+}
+const tokenIgnoredUnknownEnum = Symbol();
+/**
+ * Compile a converter from a JSON value to an enum value. JSON null returns
+ * the enum's first value. With ignoreUnknownFields false, unknown string
+ * values raise an error; with true, they return tokenIgnoredUnknownEnum.
+ * The value is not checked against the enum's values, see compileEnumCheck.
+ */
+function compileEnumConverter(desc) {
+    const zero = desc.values[0].number;
+    const values = desc.values;
+    return (json, ignoreUnknownFields) => {
+        if (json === null) {
+            return zero;
+        }
+        switch (typeof json) {
+            case "number":
+                if (Number.isInteger(json)) {
+                    return json;
+                }
+                break;
+            case "string": {
+                const value = values.find((ev) => ev.name === json);
+                if (value !== undefined) {
+                    return value.number;
+                }
+                if (ignoreUnknownFields) {
+                    return tokenIgnoredUnknownEnum;
+                }
+                break;
+            }
+        }
+        throw new Error(`cannot decode ${desc} from JSON: ${formatVal(json)}`);
+    };
+}
+/**
+ * Compile the check that the reflect API performs for enum values: open
+ * enums accept any int32 value, closed enums accept only declared values.
+ */
+function compileEnumCheck(desc) {
+    if (desc.open) {
+        return checkScalarValue(ScalarType.INT32);
     }
-    throw new Error(`cannot decode ${desc} from JSON: ${formatVal(json)}`);
+    const values = desc.values;
+    return (value) => values.some((v) => v.number === value);
 }
 /**
- * Try to parse a JSON value to a scalar value for the reflect API.
- *
- * Returns the input if the JSON value cannot be converted. Raises a FieldError
- * if conversion would be ambiguous.
+ * Compile a converter from a JSON value to the local representation of a
+ * scalar, fusing JSON parsing, the validation of the reflect API, and the
+ * conversion to the local 64-bit integer representation.
+ */
+function compileScalarConverter(field) {
+    const parseScalar = compileScalarParse(field);
+    const checkValue = checkScalarValue(field.scalar);
+    const toLocal = compileScalarToLocal(field);
+    return (json) => {
+        const value = parseScalar(json);
+        const check = checkValue(value);
+        if (check !== true) {
+            throw new FieldError(field, reasonSingular(field, value, check));
+        }
+        return toLocal(value);
+    };
+}
+/**
+ * Compile the JSON-specific parsing step for a scalar value: the special
+ * string values of float and double, string-encoded numbers, and base64
+ * bytes. Returns the input unchanged if the JSON value cannot be converted;
+ * the validation step raises an error for it.
  */
-function scalarFromJson(field, json) {
-    // int64, sfixed64, sint64, fixed64, uint64: Reflect supports string and number.
-    // string, bool: Supported by reflect.
+function compileScalarParse(field) {
     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 NaN;
-            if (json === "Infinity")
-                return Number.POSITIVE_INFINITY;
-            if (json === "-Infinity")
-                return Number.NEGATIVE_INFINITY;
-            if (typeof json == "number") {
-                if (Number.isNaN(json)) {
-                    // NaN must be encoded with string constants
-                    throw new FieldError(field, "unexpected NaN number");
-                }
-                if (!Number.isFinite(json)) {
-                    // Infinity must be encoded with string constants
-                    throw new FieldError(field, "unexpected infinite number");
-                }
-                break;
-            }
-            if (typeof json == "string") {
-                if (json === "") {
-                    // empty string is not a number
-                    break;
-                }
-                if (json.trim().length !== json.length) {
-                    // extra whitespace
-                    break;
+            return (json) => {
+                if (json === "NaN")
+                    return NaN;
+                if (json === "Infinity")
+                    return Number.POSITIVE_INFINITY;
+                if (json === "-Infinity")
+                    return Number.NEGATIVE_INFINITY;
+                if (typeof json == "number") {
+                    if (Number.isNaN(json)) {
+                        // NaN must be encoded with string constants
+                        throw new FieldError(field, "unexpected NaN number");
+                    }
+                    if (!Number.isFinite(json)) {
+                        // Infinity must be encoded with string constants
+                        throw new FieldError(field, "unexpected infinite number");
+                    }
+                    return json;
                 }
-                const float = Number(json);
-                if (!Number.isFinite(float)) {
-                    // Infinity and NaN must be encoded with string constants
-                    break;
+                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 float = Number(json);
+                    if (!Number.isFinite(float)) {
+                        // Infinity and NaN must be encoded with string constants
+                        return json;
+                    }
+                    return float;
                 }
-                return float;
-            }
-            break;
+                return json;
+            };
         // 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:
-            return int32FromJson(json);
+            return int32FromJson;
         // 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);
+            return (json) => {
+                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);
+                    }
                 }
+                return json;
+            };
+        // int64, sfixed64, sint64, fixed64, uint64: The validation step accepts
+        // string and number. string, bool: no conversion.
+        default:
+            return (json) => json;
+    }
+}
+/**
+ * Compile the conversion of a validated scalar value to its local
+ * representation: 64-bit integers become bigint, or string with the
+ * longAsString option.
+ */
+function compileScalarToLocal(field) {
+    const longAsString = field.fieldKind !== "map" && field.longAsString;
+    switch (field.scalar) {
+        case ScalarType.INT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.SINT64:
+            if (longAsString) {
+                return (value) => String(value);
             }
-            break;
+            return (value) => typeof value == "string" || typeof value == "number"
+                ? protoInt64.parse(value)
+                : value;
+        case ScalarType.FIXED64:
+        case ScalarType.UINT64:
+            if (longAsString) {
+                return (value) => String(value);
+            }
+            return (value) => typeof value == "string" || typeof value == "number"
+                ? protoInt64.uParse(value)
+                : value;
+        default:
+            return (value) => value;
     }
-    return json;
 }
 /**
- * Try to parse a JSON value to a map key for the reflect API.
- * Canonicalizes 64-bit integers given as string, so that "01 and "1" are one
- * key, and duplicates can raise an error.
- * Returns the input if the JSON value cannot be converted.
+ * Return a parser from a JSON value to a map key for the given key type.
+ * Canonicalizes 64-bit integers given as string, so that "01" and "1" are
+ * one key, and duplicates can raise an error.
+ * The parser returns the input if the JSON value cannot be converted.
  */
-function mapKeyFromJson(type, jsonString) {
+function compileMapKeyParse(type) {
     switch (type) {
         case ScalarType.BOOL:
-            switch (jsonString) {
-                case "true":
-                    return true;
-                case "false":
-                    return false;
-            }
-            return jsonString;
+            return (jsonString) => {
+                switch (jsonString) {
+                    case "true":
+                        return true;
+                    case "false":
+                        return false;
+                }
+                return jsonString;
+            };
         case ScalarType.INT32:
         case ScalarType.FIXED32:
         case ScalarType.UINT32:
         case ScalarType.SFIXED32:
         case ScalarType.SINT32:
-            return int32FromJson(jsonString);
+            return int32FromJson;
         case ScalarType.INT64:
         case ScalarType.SINT64:
         case ScalarType.SFIXED64:
         case ScalarType.UINT64:
         case ScalarType.FIXED64:
-            return /^-?0+$/.test(jsonString)
+            return (jsonString) => /^-?0+$/.test(jsonString)
                 ? "0"
                 : jsonString.replace(/^(-?)0+(?=\d)/, "$1");
         default:
-            return jsonString;
+            // ScalarType.STRING
+            return (jsonString) => jsonString;
     }
 }
 /**
@@ -536,46 +874,6 @@ function checkDuplicateKeys(jsonString, typeName) {
         }
     }
 }
-function tryWktFromJson(msg, jsonValue, ctx) {
-    if (!msg.desc.typeName.startsWith("google.protobuf.")) {
-        return false;
-    }
-    switch (msg.desc.typeName) {
-        case "google.protobuf.Any":
-            anyFromJson(msg.message, jsonValue, ctx);
-            return true;
-        case "google.protobuf.Timestamp":
-            timestampFromJson(msg.message, jsonValue);
-            return true;
-        case "google.protobuf.Duration":
-            durationFromJson(msg.message, jsonValue);
-            return true;
-        case "google.protobuf.FieldMask":
-            fieldMaskFromJson(msg.message, jsonValue);
-            return true;
-        case "google.protobuf.Struct":
-            structFromJson(msg.message, jsonValue, ctx);
-            return true;
-        case "google.protobuf.Value":
-            valueFromJson(msg.message, jsonValue, ctx);
-            return true;
-        case "google.protobuf.ListValue":
-            listValueFromJson(msg.message, jsonValue, ctx);
-            return true;
-        default:
-            if (isWrapperDesc(msg.desc)) {
-                const valueField = msg.desc.fields[0];
-                if (jsonValue === null) {
-                    msg.clear(valueField);
-                }
-                else {
-                    msg.set(valueField, scalarFromJson(valueField, jsonValue));
-                }
-                return true;
-            }
-            return false;
-    }
-}
 function anyFromJson(any, json, ctx) {
     var _a;
     if (json === null || Array.isArray(json) || typeof json != "object") {
@@ -598,19 +896,18 @@ function anyFromJson(any, json, ctx) {
     if (!desc) {
         throw new Error(`cannot decode message ${any.$typeName} from JSON: ${typeUrl} is not in the type registry`);
     }
-    const msg = reflect(desc);
+    const message = create(desc);
     if (hasCustomJsonRepresentation(desc) &&
         Object.prototype.hasOwnProperty.call(json, "value")) {
-        const value = json.value;
-        readMessage(msg, value, ctx);
+        compiledReader(desc)(message, json.value, ctx);
     }
     else {
         const copy = Object.assign({}, json);
         // biome-ignore lint/performance/noDelete: <explanation>
         delete copy["@type"];
-        readMessage(msg, copy, ctx);
+        compiledReader(desc)(message, copy, ctx);
     }
-    anyPack(msg.desc, msg.message, any);
+    anyPack(desc, message, any);
 }
 function timestampFromJson(timestamp, json) {
     if (typeof json !== "string") {
@@ -626,8 +923,7 @@ function timestampFromJson(timestamp, json) {
     if (Number.isNaN(ms)) {
         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")) {
+    if (ms < timestampMsMin || ms > timestampMsMax) {
         throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`);
     }
     timestamp.seconds = protoInt64.parse(ms / 1000);
@@ -647,7 +943,7 @@ function durationFromJson(duration, json) {
         throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${formatVal(json)}`);
     }
     const longSeconds = Number(match[1]);
-    if (longSeconds > 315576000000 || longSeconds < -315576000000) {
+    if (longSeconds > durationSecondsMax || longSeconds < durationSecondsMin) {
         throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${formatVal(json)}`);
     }
     duration.seconds = protoInt64.parse(longSeconds);
@@ -678,10 +974,12 @@ function structFromJson(struct, json, ctx) {
     if (typeof json != "object" || json == null || Array.isArray(json)) {
         throw new Error(`cannot decode message ${struct.$typeName} from JSON ${formatVal(json)}`);
     }
-    for (const [k, v] of Object.entries(json)) {
-        const parsedV = create(ValueSchema);
-        valueFromJson(parsedV, v, ctx);
-        struct.fields[k] = parsedV;
+    const keys = Object.keys(json);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const parsedValue = create(ValueSchema);
+        valueFromJson(parsedValue, json[key], ctx);
+        struct.fields[key] = parsedValue;
     }
 }
 function valueFromJson(value, json, ctx) {
@@ -723,9 +1021,9 @@ function listValueFromJson(listValue, json, ctx) {
     if (!Array.isArray(json)) {
         throw new Error(`cannot decode message ${listValue.$typeName} from JSON ${formatVal(json)}`);
     }
-    for (const e of json) {
+    for (let i = 0; i < json.length; i++) {
         const value = create(ValueSchema);
-        valueFromJson(value, e, ctx);
+        valueFromJson(value, json[i], ctx);
         listValue.values.push(value);
     }
 }